amp_damping_shift_trace_preserving_only_if
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
- amp_damping_shift_sharp_spectral_boundFix $d \ge 2$, $V = |0\rangle\langle 1|$, $P = |1\rangle\langle 1|$, $G(X) = VXV^\dagger - \tfrac12(PX + XP)$ and…
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.
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).
uses
Module.Basis.map_reprtheorem 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]
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.
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
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.
uses
Matrix.trace_sub,Matrix.trace_add,Matrix.trace_smul,Matrix.trace_mul_comm,amp_damping_tp_v_star_mul_vtheorem 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
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).
uses
Fintype.sum_prod_type,amp_damping_tp_std_basis_repr_applytheorem 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]
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.
uses
Matrix.stdBasis_eq_singletheorem 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]
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.
uses
LinearMap.toMatrix_apply,amp_damping_tp_trace_eq_sum_repr,amp_damping_tp_generator_trace,amp_damping_tp_trace_std_basistheorem 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]
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.
uses
amp_damping_tp_trace_row_semiconj,NormedSpace.algebraMap_exp_commtheorem 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]
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).
uses
LinearMap.toMatrix_mulVec_repr,LinearMap.toMatrix_toLin,amp_damping_tp_trace_eq_sum_repr,Finset.sum_commhave 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
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.
uses
amp_damping_tp_trace_superop_exp,amp_damping_tp_trace_std_basistheorem 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
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.
uses
Complex.exp_eq_exp_ℂ,Complex.ofReal_exphave 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
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.
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.
- The superoperator exponential is computed by converting the linear map on matrices to a d² × d² matrix via the standard basis, taking the normed space matrix exponential, and converting back. Trace preservation is tracked through the left action on the vectorized trace functional.
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
Choose a tactic — a marked line — to see the goals Lean had before and after it, as in Lean’s infoview. Step with ← → or j k.
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