| import OAI.Analysis.IrrationalRotation.Operators.Conjugation |
| import OAI.Analysis.IrrationalRotation.Spectral.QuasinilpotentCommuting |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Topology |
| namespace Invariant233 |
| namespace ConjugationSupport |
|
|
| variable {A : Type*} [NormedRing A] [NormedAlgebra ℂ A] |
|
|
| def leftMul (a : A) : A →L[ℂ] A := ContinuousLinearMap.mul ℂ A a |
|
|
| def rightMul (a : A) : A →L[ℂ] A := (ContinuousLinearMap.mul ℂ A).flip a |
|
|
| @[simp] theorem leftMul_apply (a x : A) : leftMul a x = a * x := rfl |
| @[simp] theorem rightMul_apply (a x : A) : rightMul a x = x * a := rfl |
|
|
| @[simp] theorem leftMul_pow (a : A) (n : ℕ) : (leftMul a) ^ n = leftMul (a ^ n) := by |
| induction n with |
| | zero => ext x; simp |
| | succ n ih => ext x; simp [pow_succ, ih, mul_assoc] |
|
|
| @[simp] theorem rightMul_pow (a : A) (n : ℕ) : (rightMul a) ^ n = rightMul (a ^ n) := by |
| induction n with |
| | zero => ext x; simp |
| | succ n ih => |
| ext x |
| simp only [pow_succ, mul_apply_eq_comp, ih, rightMul_apply] |
| rw [mul_assoc, ← pow_succ', pow_succ] |
|
|
| theorem leftMul_commute_rightMul (a b : A) : Commute (leftMul a) (rightMul b) := by |
| apply ContinuousLinearMap.ext |
| intro x |
| simp [mul_assoc] |
|
|
| theorem norm_leftMul_le (a : A) : ‖leftMul a‖ ≤ ‖a‖ := |
| ContinuousLinearMap.opNorm_mul_apply_le ℂ A a |
|
|
| theorem norm_rightMul_le (a : A) : ‖rightMul a‖ ≤ ‖a‖ := by |
| apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _) |
| intro x |
| exact (norm_mul_le x a).trans_eq (mul_comm _ _) |
|
|
| theorem normQuasinilpotent_leftMul {a : A} (ha : NormQuasinilpotent a) : |
| NormQuasinilpotent (leftMul a) := by |
| apply root_tendsto_zero_of_geometric_bounds _ (fun _ => norm_nonneg _) |
| intro r hr |
| obtain ⟨C, hC, hb⟩ := ha.geometric_bound r hr |
| refine ⟨C, hC, fun n => ?_⟩ |
| rw [leftMul_pow] |
| exact (norm_leftMul_le _).trans (hb n) |
|
|
| theorem normQuasinilpotent_rightMul {a : A} (ha : NormQuasinilpotent a) : |
| NormQuasinilpotent (rightMul a) := by |
| apply root_tendsto_zero_of_geometric_bounds _ (fun _ => norm_nonneg _) |
| intro r hr |
| obtain ⟨C, hC, hb⟩ := ha.geometric_bound r hr |
| refine ⟨C, hC, fun n => ?_⟩ |
| rw [rightMul_pow] |
| exact (norm_rightMul_le _).trans (hb n) |
|
|
| theorem mul_left_right_pow_apply (a b x : A) (n : ℕ) : |
| ((leftMul a * rightMul b) ^ n) x = a ^ n * x * b ^ n := by |
| rw [(leftMul_commute_rightMul a b).mul_pow, leftMul_pow, rightMul_pow] |
| simp [mul_assoc] |
|
|
| @[simp] theorem leftMul_one : leftMul (1 : A) = 1 := by ext x; simp |
| @[simp] theorem rightMul_one : rightMul (1 : A) = 1 := by ext x; simp |
| @[simp] theorem leftMul_add (a b : A) : leftMul (a + b) = leftMul a + leftMul b := by |
| ext x |
| simp [add_mul] |
| @[simp] theorem rightMul_add (a b : A) : rightMul (a + b) = rightMul a + rightMul b := by |
| ext x |
| simp [mul_add] |
|
|
| theorem sub_one_pow_apply (B : A →L[ℂ] A) (x : A) (n : ℕ) : |
| ((B - 1) ^ n) x = ∑ j ∈ Finset.range (n + 1), |
| ((-1 : ℂ) ^ j * (n.choose j : ℂ)) • ((B ^ (n - j)) x) := by |
| have hexp : (B - 1) ^ n = ∑ j ∈ Finset.range (n + 1), |
| n.choose j • ((-1 : A →L[ℂ] A) ^ j * B ^ (n - j)) := by |
| rw [show B - 1 = -1 + B by abel] |
| simpa only [Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk] using |
| (Commute.neg_one_left B).add_pow' n |
| rw [hexp] |
| simp only [sum_apply] |
| apply Finset.sum_congr rfl |
| intro j hj |
| have hnegpow : ∀ (k : ℕ) (y : A), ((-1 : A →L[ℂ] A) ^ k) y = (-1 : ℂ) ^ k • y := by |
| intro k |
| induction k with |
| | zero => intro y; simp |
| | succ k ih => intro y; simp [pow_succ', mul_apply_eq_comp, ih] |
| simp only [smul_apply, mul_apply_eq_comp, hnegpow] |
| rw [← Nat.cast_smul_eq_nsmul ℂ, smul_smul] |
| congr 1 |
| ring |
|
|
| end ConjugationSupport |
|
|
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
|
|
| open ConjugationSupport |
|
|
| def conjugationDefectMap (C : HilbertConjugation H) (T : H →L[ℂ] H) : |
| (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H) := |
| leftMul (star T) * rightMul (C.conjugate T) - 1 |
|
|
| theorem conjugationDefectMap_one_add (C : HilbertConjugation H) (Q : H →L[ℂ] H) : |
| conjugationDefectMap C (1 + Q) = |
| leftMul (star Q) + rightMul (C.conjugate Q) + |
| leftMul (star Q) * rightMul (C.conjugate Q) := by |
| simp only [conjugationDefectMap, star_add, star_one, |
| HilbertConjugation.conjugate_add, HilbertConjugation.conjugate_one, |
| leftMul_add, rightMul_add, leftMul_one, rightMul_one] |
| noncomm_ring |
|
|
| theorem normQuasinilpotent_conjugationDefectMap_one_add |
| (C : HilbertConjugation H) {Q : H →L[ℂ] H} (hQ : NormQuasinilpotent Q) : |
| NormQuasinilpotent (conjugationDefectMap C (1 + Q)) := by |
| have hnorm : ∀ n : ℕ, ‖(star Q) ^ n‖ = ‖Q ^ n‖ := by |
| intro n |
| rw [← star_pow] |
| exact ContinuousLinearMap.adjoint.norm_map _ |
| have hstar : NormQuasinilpotent (star Q) := by |
| simpa only [NormQuasinilpotent, hnorm] using hQ |
| have hL := normQuasinilpotent_leftMul hstar |
| have hR := normQuasinilpotent_rightMul (C.normQuasinilpotent_conjugate hQ) |
| have hcomm := leftMul_commute_rightMul (star Q) (C.conjugate Q) |
| rw [conjugationDefectMap_one_add] |
| apply (hL.add_of_commute hR hcomm).add_of_commute (hL.mul_of_commute hR hcomm) |
| exact ((Commute.refl _).mul_right hcomm).add_left |
| (hcomm.symm.mul_right (Commute.refl _)) |
|
|
| theorem conjugationDefect_eq_power_apply (C : HilbertConjugation H) |
| (T : H →L[ℂ] H) (m : ℕ) : |
| conjugationDefect C T m = ((conjugationDefectMap C T) ^ m) 1 := by |
| simp only [conjugationDefectMap, sub_one_pow_apply, conjugationDefect, |
| mul_left_right_pow_apply, mul_one, HilbertConjugation.conjugate_pow] |
|
|
| theorem isInfiniteConjugationIsometry_one_add (C : HilbertConjugation H) |
| {Q : H →L[ℂ] H} (hQ : NormQuasinilpotent Q) : |
| IsInfiniteConjugationIsometry C (1 + Q) := by |
| apply root_tendsto_zero_of_geometric_bounds _ (fun _ => norm_nonneg _) |
| intro r hr |
| obtain ⟨K, hK, hb⟩ := |
| (normQuasinilpotent_conjugationDefectMap_one_add C hQ).geometric_bound r hr |
| refine ⟨K * (‖(1 : H →L[ℂ] H)‖ + 1), by positivity, fun n => ?_⟩ |
| rw [conjugationDefect_eq_power_apply] |
| calc |
| ‖((conjugationDefectMap C (1 + Q)) ^ n) 1‖ |
| ≤ ‖(conjugationDefectMap C (1 + Q)) ^ n‖ * ‖(1 : H →L[ℂ] H)‖ := |
| ContinuousLinearMap.le_opNorm _ _ |
| _ ≤ (K * r ^ n) * (‖(1 : H →L[ℂ] H)‖ + 1) := |
| mul_le_mul (hb n) (by linarith) (norm_nonneg _) (by positivity) |
| _ = K * (‖(1 : H →L[ℂ] H)‖ + 1) * r ^ n := by ring |
|
|
| end Invariant233 |
|
|
| end |
|
|
| end OAI |
|
|
