Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Finite tensor chains of states and channels

Definition
Nonadditivity_TensorPowers

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

holevo-additivity-gap-v100holevo-informationquantum-channelsquantum-information

Finite tensor chains are defined recursively, starting from the one-dimensional empty product. The interface equips their index types with finite decidable structure and supplies the equivalence between a tensor chain of pairs and a pair of tensor chains. Product inputs pass through the corresponding tensor chain of channels componentwise, and the entropy of a tensor chain of states or product outputs is the sum of the component entropies.

Definition code
import Definitions.Def_Nonadditivity_Channels
import Definitions.Def_Nonadditivity_Entropy
import Definitions.Def_Nonadditivity_EntropyProducts
import Definitions.Def_Nonadditivity_PureChannelEntropy
import Mathlib.Analysis.Matrix.Order
import Mathlib.Analysis.Matrix.PosDef
import Mathlib.Analysis.SpecialFunctions.Log.Basic
import Mathlib.Data.Matrix.Basic
import Mathlib.LinearAlgebra.Matrix.Kronecker
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.Ring

/-
Copyright (c) 2026 the Nonadditivity project contributors.
All rights reserved. See COPYRIGHT.md for licensing and attribution.
-/



/-!
# Finite tensor blocks of genuine density matrices and channels

The Hilbert-space indices are nested products. Block states and channels
are defined recursively using their actual Kronecker products, and the
entropy identities are proved by induction from the concrete binary law.
-/

namespace Nonadditivity.Entropy

open scoped BigOperators ComplexOrder ComplexConjugate Kronecker Matrix

noncomputable section

universe u

/-- Index type of a finite block, with the empty block the one-dimensional space. -/
def TensorChainIndex (ι : Type u) : ℕ → Type u
  | 0 => PUnit.{u + 1}
  | n + 1 => TensorChainIndex ι n × ι

instance tensorChainIndexFintype (ι : Type u) [Fintype ι] :
    (n : ℕ) → Fintype (TensorChainIndex ι n)
  | 0 => inferInstanceAs (Fintype PUnit.{u + 1})
  | n + 1 => by
    change Fintype (TensorChainIndex ι n × ι)
    letI := tensorChainIndexFintype ι n
    infer_instance

instance tensorChainIndexDecidableEq (ι : Type u) [DecidableEq ι] :
    (n : ℕ) → DecidableEq (TensorChainIndex ι n)
  | 0 => inferInstanceAs (DecidableEq PUnit.{u + 1})
  | n + 1 => by
    change DecidableEq (TensorChainIndex ι n × ι)
    letI := tensorChainIndexDecidableEq ι n
    infer_instance

universe v

/-- Regroup a finite interleaved tensor index into its two tensor blocks. -/
def pairChainEquiv (ι : Type u) (μ : Type v) :
    (n : ℕ) → TensorChainIndex (ι × μ) n ≃ TensorChainIndex ι n × TensorChainIndex μ n
  | 0 =>
    { toFun := fun _ => (PUnit.unit, PUnit.unit)
      invFun := fun _ => PUnit.unit
      left_inv := fun x => by cases x; rfl
      right_inv := fun x => by rcases x with ⟨a,b⟩; cases a; cases b; rfl }
  | n + 1 =>
    { toFun := fun x =>
        let a := (pairChainEquiv ι μ n) x.1
        ((a.1, x.2.1), (a.2, x.2.2))
      invFun := fun x =>
        ((pairChainEquiv ι μ n).symm (x.1.1, x.2.1), (x.1.2, x.2.2))
      left_inv := fun x => by
        rcases x with ⟨a, ⟨i,j⟩⟩
        simp
      right_inv := fun x => by
        rcases x with ⟨⟨a,i⟩, ⟨b,j⟩⟩
        simp }

@[simp] theorem pairChainEquiv_succ_apply (ι : Type u) (μ : Type v) (n : ℕ)
    (a : TensorChainIndex (ι × μ) n) (i : ι) (j : μ) :
    pairChainEquiv ι μ (n + 1) (a, (i,j)) =
      (((pairChainEquiv ι μ n a).1, i), ((pairChainEquiv ι μ n a).2, j)) := rfl

@[simp] theorem pairChainEquiv_succ_symm_apply (ι : Type u) (μ : Type v) (n : ℕ)
    (a : TensorChainIndex ι n) (b : TensorChainIndex μ n) (i : ι) (j : μ) :
    (pairChainEquiv ι μ (n + 1)).symm ((a,i),(b,j)) =
      ((pairChainEquiv ι μ n).symm (a,b), (i,j)) := rfl

/-- The unique density matrix of the one-dimensional empty tensor block. -/
def emptyTensorState : DensityMatrix PUnit.{u + 1} where
  matrix := 1
  positive := Matrix.PosSemidef.one
  normalized := by simp [Matrix.trace_one]

theorem emptyTensorState_entropy : emptyTensorState.{u}.vonNeumann = 0 := by
  apply le_antisymm
  · simpa using emptyTensorState.{u}.vonNeumann_le_log_dim
  · exact emptyTensorState.{u}.vonNeumann_nonneg

/-- An actual finite tensor block of an arbitrary state family. -/
def DensityMatrix.tensorChain {ι : Type u} [Fintype ι] [DecidableEq ι]
    (ρ : ℕ → DensityMatrix ι) : (n : ℕ) → DensityMatrix (TensorChainIndex ι n)
  | 0 => emptyTensorState
  | n + 1 => (tensorChain ρ n).tensor (ρ n)

theorem DensityMatrix.tensorChain_entropy {ι : Type u} [Fintype ι] [DecidableEq ι]
    (ρ : ℕ → DensityMatrix ι) (n : ℕ) :
    (tensorChain ρ n).vonNeumann = ∑ j ∈ Finset.range n, (ρ j).vonNeumann := by
  induction n with
  | zero =>
    change emptyTensorState.{u}.vonNeumann = 0
    exact emptyTensorState_entropy
  | succ n ih =>
    calc
      (tensorChain ρ (n + 1)).vonNeumann = (tensorChain ρ n).vonNeumann +
          (ρ n).vonNeumann := (tensorChain ρ n).tensor_entropy (ρ n)
      _ = ∑ j ∈ Finset.range (n + 1), (ρ j).vonNeumann := by
        rw [ih, Finset.sum_range_succ]



end

end Nonadditivity.Entropy

namespace Nonadditivity.Channels.KrausChannel

open Nonadditivity.Entropy
open scoped BigOperators ComplexOrder ComplexConjugate Kronecker Matrix

noncomputable section

/-- Concrete tensor channels produce the concrete tensor of their product-input outputs. -/
theorem tensor_output {ι μ ο ν κ η : Type*}
    [Fintype ι] [DecidableEq ι] [Fintype μ] [DecidableEq μ]
    [Fintype ο] [DecidableEq ο] [Fintype ν] [DecidableEq ν]
    [Fintype κ] [Fintype η]
    (T : KrausChannel ι ο κ) (S : KrausChannel μ ν η)
    (ρ : DensityMatrix ι) (σ : DensityMatrix μ) :
    (T.tensor S).output (ρ.tensor σ) = (T.output ρ).tensor (S.output σ) := by
  apply Nonadditivity.Channels.densityMatrix_ext
  exact T.tensor_map S ρ.matrix σ.matrix



universe u v w

/-- The empty channel sends the unique one-dimensional input state to its unique output state. -/
def emptyTensorChannel :
    KrausChannel PUnit.{u + 1} PUnit.{v + 1} PUnit.{w + 1} where
  kraus := fun _ _ _ => 1
  complete := by
    ext i j
    cases i
    cases j
    simp [Matrix.sum_apply, Matrix.mul_apply, Matrix.conjTranspose_apply]

theorem emptyTensorChannel_output :
    emptyTensorChannel.{u,v,w}.output emptyTensorState.{u} = emptyTensorState.{v} := by
  apply Nonadditivity.Channels.densityMatrix_ext
  ext i j
  cases i
  cases j
  simp [output, map, emptyTensorChannel, emptyTensorState, Matrix.mul_apply,
    Matrix.conjTranspose_apply]

/-- The actual tensor block of a local Kraus-channel family. -/
def tensorChain {ι : Type u} {ο : Type v} {κ : Type w}
    [Fintype ι] [DecidableEq ι] [Fintype ο] [DecidableEq ο] [Fintype κ]
    (T : ℕ → KrausChannel ι ο κ) :
    (n : ℕ) → KrausChannel (TensorChainIndex ι n) (TensorChainIndex ο n)
      (TensorChainIndex κ n)
  | 0 => emptyTensorChannel
  | n + 1 => (tensorChain T n).tensor (T n)

/-- Actual tensor blocks map actual product states to actual products of local outputs. -/
theorem tensorChain_output {ι : Type u} {ο : Type v} {κ : Type w}
    [Fintype ι] [DecidableEq ι] [Fintype ο] [DecidableEq ο] [Fintype κ]
    (T : ℕ → KrausChannel ι ο κ) (ρ : ℕ → DensityMatrix ι) (n : ℕ) :
    (tensorChain T n).output (DensityMatrix.tensorChain ρ n) =
      DensityMatrix.tensorChain (fun j => (T j).output (ρ j)) n := by
  induction n with
  | zero => exact emptyTensorChannel_output
  | succ n ih =>
    change ((tensorChain T n).tensor (T n)).output
      ((DensityMatrix.tensorChain ρ n).tensor (ρ n)) =
        (DensityMatrix.tensorChain (fun j => (T j).output (ρ j)) n).tensor
          ((T n).output (ρ n))
    exact (tensor_output (tensorChain T n) (T n) (DensityMatrix.tensorChain ρ n) (ρ n)).trans
      (congrArg (fun q : DensityMatrix (TensorChainIndex ο n) =>
        q.tensor ((T n).output (ρ n))) ih)

/-- Exact entropy sum for the outputs of a genuine finite channel tensor block. -/
theorem tensorChain_output_entropy {ι : Type u} {ο : Type v} {κ : Type w}
    [Fintype ι] [DecidableEq ι] [Fintype ο] [DecidableEq ο] [Fintype κ]
    (T : ℕ → KrausChannel ι ο κ) (ρ : ℕ → DensityMatrix ι) (n : ℕ) :
    ((tensorChain T n).output (DensityMatrix.tensorChain ρ n)).vonNeumann =
      ∑ j ∈ Finset.range n, ((T j).output (ρ j)).vonNeumann := by
  rw [tensorChain_output, DensityMatrix.tensorChain_entropy]



end

end Nonadditivity.Channels.KrausChannel
Source
https://github.com/JWang226/Holevo-Additivity-Gap/blob/635aa93eb3a2310b79fd5371e2ce311914ec5887/Nonadditivity/TensorPowers.lean#L24-L202
Human review
  • Endorsed by Shuze Chen · Oct 9, 2026

    Confirmed by the moderator at approval.

  • Endorsed by JWang226 · Oct 9, 2026

    Confirmed by the mission captain (proposal self-audit).

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