AFTD Auto-Formalizing Theoretical Domains

amp_damping_shift_trace_preserving_only_if

theoremverifiedformalization

If $e^{tL_c}$ is trace-preserving for some $t > 0$, then $c = 0$.

Statement

theorem amp_damping_shift_trace_preserving_only_if (d : ℕ) (h : 2 ≤ d) (c t : ℝ) (ht : 0 < t)
    (htp : is_trace_preserving_linear_map d (superop_exp d (amp_damping_generator d h + (c : ℂ) • LinearMap.id) t)) : c = 0
Formalizes
arXiv:2610.37187 Proposition 9 (eq. 7.1), trace preservation only for c = 0
Verified
08 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 5
  • 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$),…
  • superop_expFor a $\mathbb{C}$-linear endomorphism $L$ of $M_d(\mathbb{C})$ and $t \in \mathbb{R}$, the linear endomorphism $e^{tL}$: the map whose…
  • is_trace_preserving_linear_mapA linear map Φ on d × d complex matrices is trace-preserving if the trace of Φ(X) equals the trace of X for all d × d complex matrices X.
  • p_amp_dampingThe projection matrix P = |1⟩⟨1| onto the second standard basis state in dimension d ≥ 2.
  • v_amp_dampingThe matrix unit V = |0⟩⟨1| in the standard basis of d × d complex matrices for d ≥ 2.
Used by 1

Read back from the Lean

For any natural number $d \ge 2$ and any real numbers $c$ and $t$ with $t > 0$: if the superoperator $\exp(t(\mathcal{L} + c \cdot \mathrm{id}))$ on $d \times d$ complex matrices (where $\mathcal{L}$ is the amplitude damping Lindblad generator) is trace-preserving (i.e., preserves the matrix trace of every $d \times d$ complex matrix), then $c = 0$.

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

To show that the shifted amplitude damping evolution exp(t(L + c • id)) cannot be trace-preserving for t > 0 unless c = 0, the proof determines the trace scaling factor of the evolution. Because the amplitude damping Lindbladian generator L is trace-annihilating (Tr(L(Y)) = 0), the trace row functional is a left eigenvector of the generator matrix with eigenvalue t * c. Exponentiating this relation shows that the trace of any matrix is multiplied by exp(t * c) under the channel. Evaluating on the basis matrix E_{0,0} then forces exp(t * c) = 1, which implies c = 0 since t > 0.

  1. The coordinate of a matrix A in the standard basis at (i, j) is the matrix entry A i j.

    Unfolding the standard basis definition on matrices simplifies the basis representation directly to evaluation at the index pair (i, j).

    lines 1–3

    uses Module.Basis.map_repr

    theorem amp_damping_tp_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 amplitude damping Kraus operator v = |0⟩⟨1| satisfies v* * v = p, where p = |1⟩⟨1| is the projection onto the excited state.

    Evaluating the matrix product (v* * v) i j = ∑_k (v* i k) * (v k j) = ∑_k conj(v k i) * (v k j) by case analysis on the indices: both factors are nonzero if and only if k = 0 and i = j = 1, which yields the projection matrix p.

    lines 5–11

    uses Matrix.mul_apply, Matrix.star_apply, Finset.sum_ite_eq'

    theorem amp_damping_tp_v_star_mul_v (d : ℕ) (h : 2 ≤ d) :
        star (v_amp_damping d h) * v_amp_damping d h = p_amp_damping d h := by
      ext i j
      simp only [v_amp_damping, p_amp_damping, Matrix.mul_apply, Matrix.star_apply]
      simp only [Complex.star_def, map_one, map_zero, apply_ite (starRingEnd ℂ)]
      simp [ite_and, Finset.sum_ite_eq']
      split_ifs <;> rfl
  3. The amplitude damping Lindbladian generator L is trace-annihilating: Tr(L(Y)) = 0 for all matrices Y.

    Expanding the definition L(Y) = v * Y * v* - (1/2)(p * Y + Y * p) and using the linearity and cyclicity of the trace, Tr(v * Y * v*) = Tr(v* * v * Y) = Tr(p * Y) and Tr(Y * p) = Tr(p * Y). The three trace terms cancel algebraically: Tr(p * Y) - (1/2)(Tr(p * Y) + Tr(p * Y)) = 0.

    lines 13–20

    uses Matrix.trace_sub, Matrix.trace_add, Matrix.trace_smul, Matrix.trace_mul_comm, amp_damping_tp_v_star_mul_v

    theorem amp_damping_tp_generator_trace (d : ℕ) (h : 2 ≤ d) (Y : Matrix (Fin d) (Fin d) ℂ) :
        (amp_damping_generator d h Y).trace = 0 := by
      simp only [amp_damping_generator, LinearMap.sub_apply, LinearMap.comp_apply, LinearMap.smul_apply,
        LinearMap.add_apply, LinearMap.mulLeft_apply, LinearMap.mulRight_apply, Matrix.trace_sub,
        Matrix.trace_smul, Matrix.trace_add]
      rw [← Matrix.mul_assoc, Matrix.trace_mul_comm, ← Matrix.mul_assoc, amp_damping_tp_v_star_mul_v,
        Matrix.trace_mul_comm Y]
      simp; ring
  4. The trace of a matrix X equals the sum of its standard basis coordinates on the diagonal index pairs.

    Splitting the sum over the product type Fin d × Fin d into a double sum, only terms with i = j survive, which recovers ∑_i X i i = Tr(X).

    lines 22–26

    uses Fintype.sum_prod_type, amp_damping_tp_std_basis_repr_apply

    theorem amp_damping_tp_trace_eq_sum_repr (d : ℕ) (X : Matrix (Fin d) (Fin d) ℂ) :
        X.trace = ∑ k, (fun k : Fin d × Fin d => if k.1 = k.2 then (1 : ℂ) else 0) k *
          (Matrix.stdBasis ℂ (Fin d) (Fin d)).repr X k := by
      rw [Fintype.sum_prod_type]
      simp [amp_damping_tp_std_basis_repr_apply, Matrix.trace]
  5. The trace of the standard basis matrix E_k is 1 if k is a diagonal pair (k₁ = k₂) and 0 otherwise.

    The standard basis matrix E_{(i,j)} has a single nonzero entry 1 at (i, j), so its trace ∑_l (E_{(i,j)}) l l is 1 when i = j and 0 otherwise.

    lines 28–31

    uses Matrix.stdBasis_eq_single

    theorem amp_damping_tp_trace_std_basis (d : ℕ) (k : Fin d × Fin d) :
        (Matrix.stdBasis ℂ (Fin d) (Fin d) k).trace = if k.1 = k.2 then 1 else 0 := by
      rw [Matrix.stdBasis_eq_single]
      simp [Matrix.trace, Matrix.single, ite_and, eq_comm]
  6. The trace row-vector matrix R semiconjugates the generator matrix M = t • [L + c • id] to (t * c) • R, meaning R * M = (t * c) • R.

    Multiplying R by the k-th column of the generator matrix sums the diagonal coordinates of (t • (L + c • id))(E_k), which equals t • Tr(L(E_k) + c • E_k). Since L is trace-annihilating, this simplifies to t * c * Tr(E_k) = t * c * δ_{k₁, k₂}, which matches the (i, k)-th entry of (t * c) • R.

    lines 33–48

    uses LinearMap.toMatrix_apply, amp_damping_tp_trace_eq_sum_repr, amp_damping_tp_generator_trace, amp_damping_tp_trace_std_basis

    theorem amp_damping_tp_trace_row_semiconj (d : ℕ) (h : 2 ≤ d) (c t : ℝ) :
        SemiconjBy (Matrix.of fun (_ : Fin d × Fin d) (k : Fin d × Fin d) => if k.1 = k.2 then (1 : ℂ) else 0)
          ((t : ℂ) • LinearMap.toMatrix (Matrix.stdBasis ℂ (Fin d) (Fin d)) (Matrix.stdBasis ℂ (Fin d) (Fin d))
            (amp_damping_generator d h + (c : ℂ) • LinearMap.id))
          (algebraMap ℂ (Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ) ((t : ℂ) * c)) := by
      unfold SemiconjBy
      ext i k
      rw [Matrix.mul_smul, Matrix.smul_apply, Matrix.mul_apply, Algebra.algebraMap_eq_smul_one,
        Matrix.smul_mul, Matrix.one_mul, Matrix.smul_apply]
      simp only [LinearMap.toMatrix_apply, Matrix.of_apply]
      have key := amp_damping_tp_trace_eq_sum_repr d (((amp_damping_generator d h + (c : ℂ) • LinearMap.id :
        Module.End ℂ (Matrix (Fin d) (Fin d) ℂ))) (Matrix.stdBasis ℂ (Fin d) (Fin d) k))
      rw [← key]
      simp only [LinearMap.add_apply, LinearMap.smul_apply, LinearMap.id_apply, Matrix.trace_add,
        Matrix.trace_smul, amp_damping_tp_generator_trace, amp_damping_tp_trace_std_basis]
      simp [smul_eq_mul]
  7. The semiconjugation relation exponentiates to the matrix exponential: R * E = exp(t * c) • R, where E = exp(t • [L + c • id]).

    Exponentiating the right factor in the semiconjugation relation R * M = ((t * c) • I) * R gives R * exp(M) = exp((t * c) • I) * R. Since exp((t * c) • I) = exp(t * c) • I, this yields R * E = exp(t * c) • R.

    lines 50–67

    uses amp_damping_tp_trace_row_semiconj, NormedSpace.algebraMap_exp_comm

    theorem amp_damping_tp_trace_superop_exp (d : ℕ) (h : 2 ≤ d) (c t : ℝ) (X : Matrix (Fin d) (Fin d) ℂ) :
        (superop_exp d (amp_damping_generator d h + (c : ℂ) • LinearMap.id) t X).trace =
          NormedSpace.exp ((t : ℂ) * c) * X.trace := by
      set b := Matrix.stdBasis ℂ (Fin d) (Fin d)
      set R : Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ :=
        Matrix.of fun (_ : Fin d × Fin d) (k : Fin d × Fin d) => if k.1 = k.2 then (1 : ℂ) else 0 with hR
      set E := NormedSpace.exp ((t : ℂ) • LinearMap.toMatrix b b
          (amp_damping_generator d h + (c : ℂ) • LinearMap.id)) with hE
      have hsemi : R * E = NormedSpace.exp ((t : ℂ) * c) • R := by
        have h1 := (amp_damping_tp_trace_row_semiconj d h c t)
        have h2 : SemiconjBy R E (NormedSpace.exp (algebraMap ℂ (Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ)
            ((t : ℂ) * c))) := by
          open scoped Matrix.Norms.Operator in exact h1.exp_right
        rw [h2.eq]
        have h3 : NormedSpace.exp (algebraMap ℂ (Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ) ((t : ℂ) * c)) =
            algebraMap ℂ (Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ) (NormedSpace.exp ((t : ℂ) * c)) := by
          open scoped Matrix.Norms.Operator in exact (NormedSpace.algebraMap_exp_comm _).symm
        rw [h3, Algebra.algebraMap_eq_smul_one, Matrix.smul_mul, Matrix.one_mul]
  8. The trace of the evolved matrix under the superoperator exponential satisfies Tr(exp(t(L + c • id))(X)) = exp(t * c) * Tr(X).

    Expressing Tr(exp(t(L + c • id))(X)) in the standard basis as the action of the diagonal indicator row vector on E * [X], we swap the order of summation. The inner column sum of E against the diagonal indicator simplifies via R * E = exp(t * c) • R to exp(t * c) times the diagonal indicator, recovering exp(t * c) * Tr(X).

    lines 68–84

    uses LinearMap.toMatrix_mulVec_repr, LinearMap.toMatrix_toLin, amp_damping_tp_trace_eq_sum_repr, Finset.sum_comm

      have hrep : b.repr (superop_exp d (amp_damping_generator d h + (c : ℂ) • LinearMap.id) t X) =
          Matrix.mulVec E (b.repr X) := by
        rw [← LinearMap.toMatrix_mulVec_repr b b]
        simp [superop_exp, hE, b, LinearMap.toMatrix_toLin]
      rw [amp_damping_tp_trace_eq_sum_repr, amp_damping_tp_trace_eq_sum_repr, hrep]
      have i0 : Fin d × Fin d := (⟨0, by omega⟩, ⟨0, by omega⟩)
      have hrow : ∀ l, ∑ k, (if k.1 = k.2 then (1 : ℂ) else 0) * E k l =
          NormedSpace.exp ((t : ℂ) * c) * (if l.1 = l.2 then (1 : ℂ) else 0) := by
        intro l
        have := congrFun (congrFun hsemi i0) l
        simpa [Matrix.mul_apply, hR] using this
      simp only [Matrix.mulVec, dotProduct, Finset.mul_sum]
      rw [Finset.sum_comm]
      refine Finset.sum_congr rfl fun l _ => ?_
      rw [← mul_assoc, ← hrow l, Finset.sum_mul]
      refine Finset.sum_congr rfl fun k _ => ?_
      ring
  9. If the superoperator exponential is trace-preserving, evaluating on the standard basis matrix E_{0,0} gives exp(t * c) = 1 in ℂ.

    Applying the trace-preserving assumption to E_{0,0} gives Tr(exp(t(L + c • id))(E_{0,0})) = Tr(E_{0,0}). By the trace scaling formula, the left-hand side is exp(t * c) * Tr(E_{0,0}). Since Tr(E_{0,0}) = 1, this simplifies to exp(t * c) = 1.

    lines 86–90

    uses amp_damping_tp_trace_superop_exp, amp_damping_tp_trace_std_basis

    theorem amp_damping_shift_trace_preserving_only_if (d : ℕ) (h : 2 ≤ d) (c t : ℝ) (ht : 0 < t)
        (htp : is_trace_preserving_linear_map d (superop_exp d (amp_damping_generator d h + (c : ℂ) • LinearMap.id) t)) : c = 0 := by
      have h00 := htp (Matrix.stdBasis ℂ (Fin d) (Fin d) (⟨0, by omega⟩, ⟨0, by omega⟩))
      rw [amp_damping_tp_trace_superop_exp, amp_damping_tp_trace_std_basis] at h00
      simp only [if_true, mul_one] at h00
  10. The real exponential satisfies Real.exp(t * c) = 1.

    Writing the complex scalar (t : ℂ) * c as the cast of the real product t * c, the complex exponential equation exp(t * c) = 1 pulls back across the embedding ℝ ↪ ℂ to the real equation Real.exp(t * c) = 1.

    lines 91–94

    uses Complex.exp_eq_exp_ℂ, Complex.ofReal_exp

      have hreal : Real.exp (t * c) = 1 := by
        have : ((t : ℂ) * c) = ((t * c : ℝ) : ℂ) := by push_cast; ring
        rw [this, ← Complex.exp_eq_exp_ℂ, ← Complex.ofReal_exp] at h00
        exact_mod_cast h00
  11. c = 0.

    Since Real.exp(t * c) = 1, the exponent must vanish, so t * c = 0. As t > 0 by hypothesis, linear arithmetic rules out t = 0, leaving c = 0 as the only solution.

    lines 95–98

      have htc : t * c = 0 := by simpa using hreal
      rcases mul_eq_zero.mp htc with h1 | h1
      · linarith
      · exact h1
Module.Basis.map_repr
The coordinate representation of a vector in a basis transported by a linear equivalence is the representation in the original basis precomposed with the inverse map.
Matrix.mul_apply
The (i, k)-th entry of a matrix product M * N is the sum over j of M i j * N j k.
Matrix.star_apply
The (i, j)-th entry of the conjugate transpose of a matrix M is the complex conjugate of M j i.
Finset.sum_ite_eq'
A finite sum of terms with an indicator condition x = a evaluates to the value at a if a belongs to the set, and 0 otherwise.
amp_damping_tp_v_star_mul_v
For the amplitude damping Kraus operator v = |0⟩⟨1|, the product v* * v equals the projector p = |1⟩⟨1|.
Matrix.trace_sub
The trace of a difference of matrices equals the difference of their traces: Tr(A - B) = Tr(A) - Tr(B).
Matrix.trace_add
The trace of a sum of matrices equals the sum of their traces: Tr(A + B) = Tr(A) + Tr(B).
Matrix.trace_smul
The trace of a scalar multiple of a matrix equals the scalar times the trace: Tr(r • A) = r • Tr(A).
Matrix.trace_mul_comm
The trace of a matrix product is cyclic: Tr(A * B) = Tr(B * A).
Fintype.sum_prod_type
A summation over a product type of two finite types can be rewritten as an iterated double sum.
amp_damping_tp_std_basis_repr_apply
The coordinate of a matrix A with respect to the standard basis at pair (i, j) is the entry A i j.
Matrix.stdBasis_eq_single
The standard basis matrix at (i, j) is equal to the single-entry indicator matrix with 1 at (i, j) and 0 elsewhere.
LinearMap.toMatrix_apply
The (i, j)-th entry of the matrix representing a linear map f with respect to bases v₁ and v₂ is the i-th coordinate of f(v₁(j)) in v₂.
amp_damping_tp_generator_trace
The Lindbladian generator of amplitude damping is trace-annihilating: Tr(L(Y)) = 0 for every matrix Y.
amp_damping_tp_trace_std_basis
The trace of the standard basis matrix at index pair k is 1 if k is on the diagonal (k₁ = k₂) and 0 otherwise.
amp_damping_tp_trace_eq_sum_repr
The trace of a matrix X equals the sum over diagonal index pairs k of its standard basis coordinates.
amp_damping_tp_trace_row_semiconj
The trace row-vector matrix R semiconjugates the matrix representing t(L + c id) to (t * c) * R.
NormedSpace.algebraMap_exp_comm
The canonical algebra homomorphism from scalars to a matrix algebra commutes with the exponential map.
LinearMap.toMatrix_mulVec_repr
The matrix representation of a linear map applied to the coordinate vector of x gives the coordinate vector of f(x).
LinearMap.toMatrix_toLin
The matrix representation of a linear map constructed from a matrix via toLin recovers the original matrix.
Finset.sum_comm
Two finite sums over independent index sets can have their order of summation swapped.
amp_damping_tp_trace_superop_exp
The trace of the superoperator exponential exp(t(L + c id))(X) equals exp(t * c) times Tr(X).
Complex.exp_eq_exp_ℂ
The complex exponential function coincides with the normed space exponential on the complex numbers.
Complex.ofReal_exp
The complex exponential of a real scalar cast to ℂ equals the cast of its real exponential.

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_tp_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_tp_v_star_mul_v (d : ℕ) (h : 2 ≤ d) :    star (v_amp_damping d h) * v_amp_damping d h = p_amp_damping d h := by  ext i j  simp only [v_amp_damping, p_amp_damping, Matrix.mul_apply, Matrix.star_apply]  simp only [Complex.star_def, map_one, map_zero, apply_ite (starRingEnd ℂ)]  simp [ite_and, Finset.sum_ite_eq']  split_ifs <;> rfltheorem amp_damping_tp_generator_trace (d : ℕ) (h : 2 ≤ d) (Y : Matrix (Fin d) (Fin d) ℂ) :    (amp_damping_generator d h Y).trace = 0 := by  simp only [amp_damping_generator, LinearMap.sub_apply, LinearMap.comp_apply, LinearMap.smul_apply,    LinearMap.add_apply, LinearMap.mulLeft_apply, LinearMap.mulRight_apply, Matrix.trace_sub,    Matrix.trace_smul, Matrix.trace_add]  rw [← Matrix.mul_assoc, Matrix.trace_mul_comm, ← Matrix.mul_assoc, amp_damping_tp_v_star_mul_v,    Matrix.trace_mul_comm Y]  simp; ringtheorem amp_damping_tp_trace_eq_sum_repr (d : ℕ) (X : Matrix (Fin d) (Fin d) ℂ) :    X.trace = ∑ k, (fun k : Fin d × Fin d => if k.1 = k.2 then (1 : ℂ) else 0) k *      (Matrix.stdBasis ℂ (Fin d) (Fin d)).repr X k := by  rw [Fintype.sum_prod_type]  simp [amp_damping_tp_std_basis_repr_apply, Matrix.trace]theorem amp_damping_tp_trace_std_basis (d : ℕ) (k : Fin d × Fin d) :    (Matrix.stdBasis ℂ (Fin d) (Fin d) k).trace = if k.1 = k.2 then 1 else 0 := by  rw [Matrix.stdBasis_eq_single]  simp [Matrix.trace, Matrix.single, ite_and, eq_comm]theorem amp_damping_tp_trace_row_semiconj (d : ℕ) (h : 2 ≤ d) (c t : ℝ) :    SemiconjBy (Matrix.of fun (_ : Fin d × Fin d) (k : Fin d × Fin d) => if k.1 = k.2 then (1 : ℂ) else 0)      ((t : ℂ) • LinearMap.toMatrix (Matrix.stdBasis ℂ (Fin d) (Fin d)) (Matrix.stdBasis ℂ (Fin d) (Fin d))        (amp_damping_generator d h + (c : ℂ) • LinearMap.id))      (algebraMap ℂ (Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ) ((t : ℂ) * c)) := by  unfold SemiconjBy  ext i k  rw [Matrix.mul_smul, Matrix.smul_apply, Matrix.mul_apply, Algebra.algebraMap_eq_smul_one,    Matrix.smul_mul, Matrix.one_mul, Matrix.smul_apply]  simp only [LinearMap.toMatrix_apply, Matrix.of_apply]  have key := amp_damping_tp_trace_eq_sum_repr d (((amp_damping_generator d h + (c : ℂ) • LinearMap.id :    Module.End ℂ (Matrix (Fin d) (Fin d) ℂ))) (Matrix.stdBasis ℂ (Fin d) (Fin d) k))  rw [← key]  simp only [LinearMap.add_apply, LinearMap.smul_apply, LinearMap.id_apply, Matrix.trace_add,    Matrix.trace_smul, amp_damping_tp_generator_trace, amp_damping_tp_trace_std_basis]  simp [smul_eq_mul]theorem amp_damping_tp_trace_superop_exp (d : ℕ) (h : 2 ≤ d) (c t : ℝ) (X : Matrix (Fin d) (Fin d) ℂ) :    (superop_exp d (amp_damping_generator d h + (c : ℂ) • LinearMap.id) t X).trace =      NormedSpace.exp ((t : ℂ) * c) * X.trace := by  set b := Matrix.stdBasis ℂ (Fin d) (Fin d)  set R : Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ :=    Matrix.of fun (_ : Fin d × Fin d) (k : Fin d × Fin d) => if k.1 = k.2 then (1 : ℂ) else 0 with hR  set E := NormedSpace.exp ((t : ℂ) • LinearMap.toMatrix b b      (amp_damping_generator d h + (c : ℂ) • LinearMap.id)) with hE  have hsemi : R * E = NormedSpace.exp ((t : ℂ) * c) • R := by    have h1 := (amp_damping_tp_trace_row_semiconj d h c t)    have h2 : SemiconjBy R E (NormedSpace.exp (algebraMap ℂ (Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ)        ((t : ℂ) * c))) := by      open scoped Matrix.Norms.Operator in exact h1.exp_right    rw [h2.eq]    have h3 : NormedSpace.exp (algebraMap ℂ (Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ) ((t : ℂ) * c)) =        algebraMap ℂ (Matrix (Fin d × Fin d) (Fin d × Fin d) ℂ) (NormedSpace.exp ((t : ℂ) * c)) := by      open scoped Matrix.Norms.Operator in exact (NormedSpace.algebraMap_exp_comm _).symm    rw [h3, Algebra.algebraMap_eq_smul_one, Matrix.smul_mul, Matrix.one_mul]  have hrep : b.repr (superop_exp d (amp_damping_generator d h + (c : ℂ) • LinearMap.id) t X) =      Matrix.mulVec E (b.repr X) := by    rw [← LinearMap.toMatrix_mulVec_repr b b]    simp [superop_exp, hE, b, LinearMap.toMatrix_toLin]  rw [amp_damping_tp_trace_eq_sum_repr, amp_damping_tp_trace_eq_sum_repr, hrep]  have i0 : Fin d × Fin d := (⟨0, by omega⟩, ⟨0, by omega⟩)  have hrow : ∀ l, ∑ k, (if k.1 = k.2 then (1 : ℂ) else 0) * E k l =      NormedSpace.exp ((t : ℂ) * c) * (if l.1 = l.2 then (1 : ℂ) else 0) := by    intro l    have := congrFun (congrFun hsemi i0) l    simpa [Matrix.mul_apply, hR] using this  simp only [Matrix.mulVec, dotProduct, Finset.mul_sum]  rw [Finset.sum_comm]  refine Finset.sum_congr rfl fun l _ => ?_  rw [← mul_assoc, ← hrow l, Finset.sum_mul]  refine Finset.sum_congr rfl fun k _ => ?_  ringtheorem amp_damping_shift_trace_preserving_only_if (d : ℕ) (h : 2 ≤ d) (c t : ℝ) (ht : 0 < t)    (htp : is_trace_preserving_linear_map d (superop_exp d (amp_damping_generator d h + (c : ℂ) • LinearMap.id) t)) : c = 0 := by  have h00 := htp (Matrix.stdBasis ℂ (Fin d) (Fin d) (⟨0, by omega⟩, ⟨0, by omega⟩))  rw [amp_damping_tp_trace_superop_exp, amp_damping_tp_trace_std_basis] at h00  simp only [if_true, mul_one] at h00  have hreal : Real.exp (t * c) = 1 := by    have : ((t : ℂ) * c) = ((t * c : ℝ) : ℂ) := by push_cast; ring    rw [this, ← Complex.exp_eq_exp_ℂ, ← Complex.ofReal_exp] at h00    exact_mod_cast h00  have htc : t * c = 0 := by simpa using hreal  rcases mul_eq_zero.mp htc with h1 | h1  · linarith  · exact h1
See it in the graphDiscuss this resultChallenge it