Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Two-fold Hilbert sums and block operators

Definition
CRCD_Quantum_TraceInequality_BlockDiagonal

by JWang226 · Oct 7, 2026 · Mathlib c5ea003 (Lean v4.30.0)

channel-renyi-continuity-jwang226quantum-information

Let HHH be a complex inner-product space and let H⊕2HH\oplus_2HH⊕2​H be its two-fold sum with norm ∥(x,y)∥2=∥x∥2+∥y∥2\|(x,y)\|^2=\|x\|^2+\|y\|^2∥(x,y)∥2=∥x∥2+∥y∥2. Coordinate projections and inclusions are continuous linear maps, with a continuous linear equivalence to the two-coordinate function space. For bounded endomorphisms AijA_{ij}Aij​, define

Block⁡(A00,A01,A10,A11)(x,y)=(A00x+A01y, A10x+A11y),diag⁡(A,B)(x,y)=(Ax,By).\operatorname{Block}(A_{00},A_{01},A_{10},A_{11})(x,y)=(A_{00}x+A_{01}y,\ A_{10}x+A_{11}y),\qquad\operatorname{diag}(A,B)(x,y)=(Ax,By).Block(A00​,A01​,A10​,A11​)(x,y)=(A00​x+A01​y, A10​x+A11​y),diag(A,B)(x,y)=(Ax,By).

For complete nonzero HHH, the diagonal construction is bundled as a real star-algebra homomorphism from the product operator algebra to the algebra on H⊕2HH\oplus_2HH⊕2​H. The elementary coordinate interfaces themselves only require the inner-product-space structure. No finite-dimensional assumption is imposed. These constructions express operator compression and Jensen inequalities as block-matrix statements on a Hilbert space.

Definition code
import Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order
import Mathlib.Analysis.CStarAlgebra.ContinuousLinearMap
import Mathlib.Analysis.Convex.Continuous
import Mathlib.Analysis.InnerProductSpace.Adjoint
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.Analysis.InnerProductSpace.StarOrder
import Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Order
import Mathlib.LinearAlgebra.Matrix.PosDef
import Mathlib.Topology.Algebra.Module.LinearMapPiProd
import Definitions.Def_CRCD_Quantum_TraceInequality_LownerHeinzCore_part_3
import Definitions.Def_CRCD_Quantum_TraceInequality_LownerHeinzTheorem






namespace JensenOperatorInequality

universe u

open LownerHeinzTheorem

variable {ℋ : Type u}
variable [NormedAddCommGroup ℋ] [InnerProductSpace ℂ ℋ] [CompleteSpace ℋ]
variable [Nontrivial ℋ]

/-- A two-fold Hilbert sum used for the block-operator proof of Jensen's inequality. -/
abbrev HSum (ℋ : Type u) [NormedAddCommGroup ℋ] [InnerProductSpace ℂ ℋ] : Type u :=
  PiLp 2 (fun _ : Fin 2 => ℋ)

noncomputable def hsumEquiv (ℋ : Type u) [NormedAddCommGroup ℋ] [InnerProductSpace ℂ ℋ] :
    HSum ℋ ≃L[ℂ] (Fin 2 → ℋ) :=
  PiLp.continuousLinearEquiv (p := (2 : ENNReal)) (𝕜 := ℂ) (β := fun _ : Fin 2 => ℋ)

noncomputable def hsumProj (ℋ : Type u) [NormedAddCommGroup ℋ] [InnerProductSpace ℂ ℋ]
    (i : Fin 2) : HSum ℋ →L[ℂ] ℋ :=
  (ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin 2 => ℋ) i) ∘L
    (hsumEquiv ℋ).toContinuousLinearMap

noncomputable def hsumIncl (ℋ : Type u) [NormedAddCommGroup ℋ] [InnerProductSpace ℂ ℋ]
    (i : Fin 2) : ℋ →L[ℂ] HSum ℋ :=
  (hsumEquiv ℋ).symm.toContinuousLinearMap ∘L
    (ContinuousLinearMap.single ℂ (fun _ : Fin 2 => ℋ) i)

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
@[simp] theorem hsumProj_hsumIncl_apply (i j : Fin 2) (x : ℋ) :
    hsumProj ℋ i (hsumIncl ℋ j x) = if i = j then x else 0 := by
  fin_cases i <;> fin_cases j <;> simp [hsumProj, hsumIncl, hsumEquiv]

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
@[simp] theorem inner_hsumIncl_hsumIncl (i j : Fin 2) (x y : ℋ) :
    inner ℂ (hsumIncl ℋ i x) (hsumIncl ℋ j y) = if i = j then inner ℂ x y else 0 := by
  fin_cases i <;> fin_cases j <;> simp [hsumIncl, hsumEquiv, PiLp.inner_apply]

omit [Nontrivial ℋ] in
@[simp] theorem hsumIncl_adjoint (i : Fin 2) :
    (hsumIncl ℋ i).adjoint = hsumProj ℋ i := by
  fin_cases i
  · ext x
    refine ext_inner_right ℂ fun y => ?_
    rw [ContinuousLinearMap.adjoint_inner_left]
    simp [hsumProj, hsumIncl, hsumEquiv, PiLp.inner_apply]
  · ext x
    refine ext_inner_right ℂ fun y => ?_
    rw [ContinuousLinearMap.adjoint_inner_left]
    simp [hsumProj, hsumIncl, hsumEquiv, PiLp.inner_apply]

omit [Nontrivial ℋ] in
@[simp] theorem hsumProj_adjoint (i : Fin 2) :
    (hsumProj ℋ i).adjoint = hsumIncl ℋ i := by
  calc
    (hsumProj ℋ i).adjoint = ((hsumIncl ℋ i).adjoint).adjoint := by
      rw [hsumIncl_adjoint (ℋ := ℋ) i]
    _ = hsumIncl ℋ i := ContinuousLinearMap.adjoint_adjoint _

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
@[simp] theorem hsumIncl_proj_sum (z : HSum ℋ) :
    hsumIncl ℋ 0 (hsumProj ℋ 0 z) + hsumIncl ℋ 1 (hsumProj ℋ 1 z) = z := by
  ext i
  fin_cases i <;> simp [hsumProj, hsumIncl, hsumEquiv]

/-- The block diagonal operator `diag(A, B)` on the two-fold Hilbert sum. -/
noncomputable def blockDiagonal (A B : L ℋ) : L (HSum ℋ) :=
  hsumIncl ℋ 0 ∘L A ∘L hsumProj ℋ 0 + hsumIncl ℋ 1 ∘L B ∘L hsumProj ℋ 1

/-- A general `2 × 2` block operator on `HSum ℋ`. -/
noncomputable def blockOp (A00 A01 A10 A11 : L ℋ) : L (HSum ℋ) :=
  hsumIncl ℋ 0 ∘L A00 ∘L hsumProj ℋ 0 +
    hsumIncl ℋ 0 ∘L A01 ∘L hsumProj ℋ 1 +
    hsumIncl ℋ 1 ∘L A10 ∘L hsumProj ℋ 0 +
    hsumIncl ℋ 1 ∘L A11 ∘L hsumProj ℋ 1

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
theorem blockOp_ext {T S : L (HSum ℋ)}
    (h0 : ∀ z : HSum ℋ, hsumProj ℋ 0 (T z) = hsumProj ℋ 0 (S z))
    (h1 : ∀ z : HSum ℋ, hsumProj ℋ 1 (T z) = hsumProj ℋ 1 (S z)) :
    T = S := by
  ext z i
  fin_cases i
  · simpa using h0 z
  · simpa using h1 z

omit [Nontrivial ℋ] in
@[simp] theorem blockDiagonal_star (A B : L ℋ) :
    star (blockDiagonal (ℋ := ℋ) A B) = blockDiagonal (ℋ := ℋ) (star A) (star B) := by
  ext z i
  fin_cases i
  · simp [blockDiagonal, ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_comp]
  · simp [blockDiagonal, ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_comp]

noncomputable def blockDiagonalHom : (L ℋ × L ℋ) →⋆ₐ[ℝ] L (HSum ℋ) where
  toFun p := blockDiagonal (ℋ := ℋ) p.1 p.2
  map_one' := by
    ext z
    simp [blockDiagonal]
  map_mul' := by
    intro p q
    ext z i
    fin_cases i <;>
      simp [blockDiagonal, hsumProj, hsumIncl, hsumEquiv, ContinuousLinearMap.mul_def]
  map_zero' := by
    ext z i
    fin_cases i <;> simp [blockDiagonal]
  map_add' := by
    intro p q
    ext z i
    fin_cases i <;>
      simp [blockDiagonal, hsumProj, hsumIncl, hsumEquiv, ContinuousLinearMap.add_apply]
  commutes' := by
    intro r
    ext z i
    fin_cases i <;> {
      simp [blockDiagonal, hsumProj, hsumIncl, hsumEquiv, Algebra.algebraMap_eq_smul_one]
    }
  map_star' := by
    intro p
    simp

omit [Nontrivial ℋ] in
@[simp] theorem blockDiagonalHom_apply (p : L ℋ × L ℋ) :
    blockDiagonalHom (ℋ := ℋ) p = blockDiagonal (ℋ := ℋ) p.1 p.2 :=
  rfl

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
@[simp] theorem hsumProj_blockDiagonal_zero (A B : L ℋ) (z : HSum ℋ) :
    hsumProj ℋ 0 (blockDiagonal A B z) = A (hsumProj ℋ 0 z) := by
  simp [blockDiagonal]

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
@[simp] theorem hsumProj_blockDiagonal_one (A B : L ℋ) (z : HSum ℋ) :
    hsumProj ℋ 1 (blockDiagonal A B z) = B (hsumProj ℋ 1 z) := by
  simp [blockDiagonal]

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
@[simp] theorem blockDiagonal_one :
    blockDiagonal (ℋ := ℋ) (1 : L ℋ) (1 : L ℋ) = (1 : L (HSum ℋ)) := by
  ext z i
  fin_cases i <;> simp [blockDiagonal]

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
theorem blockDiagonal_nonneg {A B : L ℋ} (hA : 0 ≤ A) (hB : 0 ≤ B) :
    0 ≤ blockDiagonal (ℋ := ℋ) A B := by
  have hApos : A.IsPositive := (ContinuousLinearMap.nonneg_iff_isPositive A).mp hA
  have hBpos : B.IsPositive := (ContinuousLinearMap.nonneg_iff_isPositive B).mp hB
  refine (ContinuousLinearMap.nonneg_iff_isPositive _).mpr ?_
  rw [ContinuousLinearMap.isPositive_iff_complex]
  intro z
  have hAz := (ContinuousLinearMap.isPositive_iff_complex A).mp hApos (hsumProj ℋ 0 z)
  have hBz := (ContinuousLinearMap.isPositive_iff_complex B).mp hBpos (hsumProj ℋ 1 z)
  have hz0 :
      inner ℂ ((hsumIncl ℋ 0) (A (hsumProj ℋ 0 z))) z =
        inner ℂ (A (hsumProj ℋ 0 z)) (hsumProj ℋ 0 z) := by
    simp [hsumProj, hsumIncl, hsumEquiv, PiLp.inner_apply]
  have hz1 :
      inner ℂ ((hsumIncl ℋ 1) (B (hsumProj ℋ 1 z))) z =
        inner ℂ (B (hsumProj ℋ 1 z)) (hsumProj ℋ 1 z) := by
    simp [hsumProj, hsumIncl, hsumEquiv, PiLp.inner_apply]
  constructor
  · dsimp [blockDiagonal]
    rw [inner_add_left, hz0, hz1]
    calc
      ↑(RCLike.re
          (inner ℂ (A (hsumProj ℋ 0 z)) (hsumProj ℋ 0 z) +
            inner ℂ (B (hsumProj ℋ 1 z)) (hsumProj ℋ 1 z))) =
          ↑(RCLike.re (inner ℂ (A (hsumProj ℋ 0 z)) (hsumProj ℋ 0 z)) +
            RCLike.re (inner ℂ (B (hsumProj ℋ 1 z)) (hsumProj ℋ 1 z))) := by
            simp
      _ = inner ℂ (A (hsumProj ℋ 0 z)) (hsumProj ℋ 0 z) +
          inner ℂ (B (hsumProj ℋ 1 z)) (hsumProj ℋ 1 z) := by
            have hsumre :
                (↑(RCLike.re (inner ℂ (A (hsumProj ℋ 0 z)) (hsumProj ℋ 0 z)) +
                    RCLike.re (inner ℂ (B (hsumProj ℋ 1 z)) (hsumProj ℋ 1 z))) : ℂ) =
                  ((RCLike.re (inner ℂ (A (hsumProj ℋ 0 z)) (hsumProj ℋ 0 z)) : ℂ) +
                    (RCLike.re (inner ℂ (B (hsumProj ℋ 1 z)) (hsumProj ℋ 1 z)) : ℂ)) := by
                  simp
            rw [hsumre, hAz.1, hBz.1]
  · dsimp [blockDiagonal]
    rw [inner_add_left, hz0, hz1]
    exact add_nonneg hAz.2 hBz.2

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
@[simp] theorem hsumProj_blockOp_zero (A00 A01 A10 A11 : L ℋ) (z : HSum ℋ) :
    hsumProj ℋ 0 (blockOp (ℋ := ℋ) A00 A01 A10 A11 z) =
      A00 (hsumProj ℋ 0 z) + A01 (hsumProj ℋ 1 z) := by
  simp [blockOp]

omit [CompleteSpace ℋ] [Nontrivial ℋ] in
@[simp] theorem hsumProj_blockOp_one (A00 A01 A10 A11 : L ℋ) (z : HSum ℋ) :
    hsumProj ℋ 1 (blockOp (ℋ := ℋ) A00 A01 A10 A11 z) =
      A10 (hsumProj ℋ 0 z) + A11 (hsumProj ℋ 1 z) := by
  simp [blockOp]

omit [Nontrivial ℋ] in
@[simp] theorem blockOp_star (A00 A01 A10 A11 : L ℋ) :
    star (blockOp (ℋ := ℋ) A00 A01 A10 A11) =
      blockOp (ℋ := ℋ) (star A00) (star A10) (star A01) (star A11) := by
  ext z i
  fin_cases i
  · simp [blockOp, ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_comp]
    abel
  · simp [blockOp, ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_comp]
    abel

end JensenOperatorInequality
Source
https://github.com/Hayata-Yamasaki-Group/lean-quantum/blob/bf1c4f6aaec84948f1a1c76c0728432813404a0f/Quantum/TraceInequality/BlockDiagonal.lean#L16-L212

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me