AFTD Auto-Formalizing Theoretical Domains

amp_damping_shift_trace

theoremverifiedformalization

For every integer $d \ge 2$ and every real number $c$, let $G$ be the amplitude-damping generator $G(X) = V X V^\dagger - \tfrac12(PX + XP)$ on $M_d(\mathbb{C})$, with $V = |0\rangle\langle 1|$ and $P = |1\rangle\langle 1|$, and let $L_c = G + c\,\mathrm{id}$ (a $\mathbb{C}$-linear map on $M_d(\mathbb{C})$, with the real $c$ viewed in $\mathbb{C}$). Then the trace of $L_c$ as a linear map on $M_d(\mathbb{C})$ equals $c d^2 - d$ (as a complex number).

Statement

theorem amp_damping_shift_trace (d : ℕ) (h : 2 ≤ d) (c : ℝ) :
    LinearMap.trace ℂ (Matrix (Fin d) (Fin d) ℂ) (amp_damping_generator d h + (c : ℂ) • LinearMap.id) = (c : ℂ) * (d : ℂ) ^ 2 - d
Formalizes
arXiv:2610.37187 Proposition 9 (eq. 7.1), the trace identity
Verified
08 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 3
  • amp_damping_generatorThe $\mathbb{C}$-linear map $G : M_d(\mathbb{C}) \to M_d(\mathbb{C})$ (bundled as a linear endomorphism, for $d \ge 2$),…
  • v_amp_dampingThe matrix unit V = |0⟩⟨1| in the standard basis of d × d complex matrices for d ≥ 2.
  • p_amp_dampingThe projection matrix P = |1⟩⟨1| onto the second standard basis state in dimension d ≥ 2.
Used by 1

Read back from the Lean

For any natural number $d$, any proof $h : 2 \le d$, and any real number $c$, the trace (as a $\mathbb{C}$-linear endomorphism of the space of $d \times d$ complex matrices $\mathrm{Matrix}(\mathrm{Fin}\ d, \mathrm{Fin}\ d, \mathbb{C})$) of the operator $\mathrm{amp\_damping\_generator}(d, h) + c \cdot \mathrm{id}$ is equal to $c \cdot d^2 - d$ (evaluated in $\mathbb{C}$).

Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.

The proof, explained

The trace of the shifted amplitude-damping generator L_c = G + c • id on M_d(ℂ) is computed by taking its matrix trace in the standard elementary matrix basis {E_{x,y}}. This expresses Tr(L_c) as a double sum of the (x, y)-th entries of L_c(E_{x,y}). Evaluating each term on the basis elements shows that the jump term V X V† has trace 0, the two projector terms -(1/2) P X and -(1/2) X P each contribute -d/2, and the scalar shift c • id contributes c d^2, yielding c d^2 - d after ring simplification.

  1. Evaluating the standard basis coordinate representation of a matrix A at (i, j) yields the matrix entry A i j. automation

    Unfolding Matrix.stdBasis and simplifying with Module.Basis.map_repr reduces the basis coordinate extraction to the direct evaluation of the matrix at indices i and j.

    lines 1–3

    uses Matrix.stdBasis, Module.Basis.map_repr

    theorem amp_damping_std_basis_repr_apply (d : ℕ) (A : Matrix (Fin d) (Fin d) ℂ) (i j : Fin d) :
        (Matrix.stdBasis ℂ (Fin d) (Fin d)).repr A (i, j) = A i j := by
      simp [Matrix.stdBasis, Module.Basis.map_repr]
  2. The trace of L_c equals the double sum over all basis pairs (x, y) of the (x, y)-th coordinate of L_c applied to the standard basis matrix E_{x,y}.

    By LinearMap.trace_eq_matrix_trace, the trace of L_c as an operator equals the matrix trace of its representation in the standard basis. Expanding Matrix.trace, Matrix.diag, and LinearMap.toMatrix_apply expresses this as a sum of diagonal entries, which Fintype.sum_prod_type splits into a double sum over row index x and column index y.

    lines 7–9

    uses LinearMap.trace_eq_matrix_trace, Matrix.trace, Matrix.diag, LinearMap.toMatrix_apply, Fintype.sum_prod_type

      rw [LinearMap.trace_eq_matrix_trace ℂ (Matrix.stdBasis ℂ (Fin d) (Fin d))]
      simp only [Matrix.trace, Matrix.diag, LinearMap.toMatrix_apply]
      rw [Fintype.sum_prod_type]
  3. The double sum evaluates to -(d/2) - (d/2) + c * d^2. automation

    The simplifier unfolds the definition of the amplitude-damping generator, the jump matrix V, and the projector P, expressing basis matrices as elementary single-entry matrices. It evaluates the matrix products and collapses the sums using Kronecker delta simplifications (Finset.sum_ite_eq, Finset.sum_ite_eq', ite_and) and the coordinate lemma amp_damping_std_basis_repr_apply. The jump term V E_{x,y} V† contributes 0, each projector term -(1/2) P E_{x,y} and -(1/2) E_{x,y} P contributes -(d/2), and the identity shift c • id contributes c * d^2.

    lines 10–12

    uses amp_damping_generator, Matrix.stdBasis_eq_single, v_amp_damping, p_amp_damping, Matrix.mul_apply, Matrix.single, Finset.sum_add_distrib, amp_damping_std_basis_repr_apply, Finset.sum_ite_eq, Finset.sum_ite_eq', ite_and

      simp [amp_damping_generator, Matrix.stdBasis_eq_single, v_amp_damping, p_amp_damping,
        Matrix.mul_apply, Matrix.single, Finset.sum_add_distrib, amp_damping_std_basis_repr_apply,
        Finset.sum_ite_eq, Finset.sum_ite_eq', ite_and]
  4. The expression -(d/2) - (d/2) + c * d^2 equals c * d^2 - d. automation

    Elementary ring arithmetic combines the two -(d/2) terms into -d and rearranges the expression into c * d^2 - d.

    line 13

      ring
Matrix.stdBasis
The standard basis of the module of m × n matrices over R, indexed by pairs (i, j).
Module.Basis.map_repr
The coordinate representation of a vector in a basis transported along a linear equivalence is obtained by composing with the inverse equivalence.
LinearMap.trace_eq_matrix_trace
The trace of a linear endomorphism equals the matrix trace of its representation with respect to any basis.
Matrix.trace
The trace of a square matrix is the sum of its diagonal entries.
Matrix.diag
The diagonal of a square matrix maps an index i to the entry A i i.
LinearMap.toMatrix_apply
The (i, j)-th entry of the matrix representing a linear map between two bases is the i-th coordinate of the image of the j-th basis vector.
Fintype.sum_prod_type
A sum over pairs in a Cartesian product of two finite types can be split into an iterated double sum over each component.
amp_damping_generator
The amplitude-damping Lindblad generator G(X) = V X V† - (1/2)(P X + X P).
Matrix.stdBasis_eq_single
The standard basis matrix at (i, j) is the elementary matrix with 1 at (i, j) and 0 elsewhere.
v_amp_damping
The jump matrix V = |0⟩⟨1| = E_{0,1} in dimension d.
p_amp_damping
The projector matrix P = |1⟩⟨1| = E_{1,1} in dimension d.
Matrix.mul_apply
The (i, k)-th entry of a matrix product is given by the row-column inner product.
Matrix.single
The matrix with a specified entry at (i, j) and zeros elsewhere.
Finset.sum_add_distrib
The sum of a sum of functions over a finite set equals the sum of their individual sums.
amp_damping_std_basis_repr_apply
The (i, j)-th coordinate of a matrix in the standard basis is its (i, j)-th entry.
Finset.sum_ite_eq
Summing over a finite set an indicator that fires when the index equals a yields the value at a (or 0 if a is not in the set).
Finset.sum_ite_eq'
Summing over a finite set an indicator that fires when a equals the index yields the value at a (or 0 if a is not in the set).
ite_and
A conditional with a conjunction of conditions is equivalent to nested conditionals.

Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.

Lean source view module on GitHub

theorem amp_damping_std_basis_repr_apply (d : ℕ) (A : Matrix (Fin d) (Fin d) ℂ) (i j : Fin d) :    (Matrix.stdBasis ℂ (Fin d) (Fin d)).repr A (i, j) = A i j := by  simp [Matrix.stdBasis, Module.Basis.map_repr]theorem amp_damping_shift_trace (d : ℕ) (h : 2 ≤ d) (c : ℝ) :    LinearMap.trace ℂ (Matrix (Fin d) (Fin d) ℂ) (amp_damping_generator d h + (c : ℂ) • LinearMap.id) = (c : ℂ) * (d : ℂ) ^ 2 - d := by  rw [LinearMap.trace_eq_matrix_trace ℂ (Matrix.stdBasis ℂ (Fin d) (Fin d))]  simp only [Matrix.trace, Matrix.diag, LinearMap.toMatrix_apply]  rw [Fintype.sum_prod_type]  simp [amp_damping_generator, Matrix.stdBasis_eq_single, v_amp_damping, p_amp_damping,    Matrix.mul_apply, Matrix.single, Finset.sum_add_distrib, amp_damping_std_basis_repr_apply,    Finset.sum_ite_eq, Finset.sum_ite_eq', ite_and]  ring
See it in the graphDiscuss this resultChallenge it