| import OAI.Analysis.GroupDeterminants.LogSeries |
|
|
| namespace OAI |
|
|
| universe uA |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace GroupRingDeterminant |
|
|
| open Filter Topology |
|
|
| section TraceCFC |
| variable {A : Type uA} [CStarAlgebra A] [Nontrivial A] |
|
|
| lemma hasDerivAt_trace_log_one_sub (τ : A →L[ℝ] ℂ) |
| (hτ : ∀ a b, τ (a * b) = τ (b * a)) |
| {f f' : ℝ → A} {x : ℝ} (hf : ∀ y, HasDerivAt f (f' y) y) |
| (hc : ContinuousAt f' x) (hn : ‖f x‖ < 1) (hself : ∀ y, IsSelfAdjoint (f y)) : |
| HasDerivAt (fun y => τ (CFC.log (1 - f y))) |
| (-τ (f' x * Ring.inverse (1 - f x))) x := by |
| have hd := (hasDerivAt_trace_logSeries_local τ hτ hf hc hn).neg |
| apply hd.congr_of_eventuallyEq |
| have he : ∀ᶠ y in 𝓝 x, ‖f y‖ < 1 := |
| (hf x).continuousAt.norm.eventually (gt_mem_nhds hn) |
| filter_upwards [he] with y hy |
| have hh := (τ.hasSum (hasSum_pow_div_cfc_log (f y) (hself y) hy)).tsum_eq |
| simpa only [map_neg, neg_neg, Pi.neg_apply] using (congrArg Neg.neg hh).symm |
|
|
| omit [Nontrivial A] in |
| lemma log_smul_of_isUnit (V : A) (hV : IsSelfAdjoint V) (hu : IsUnit V) |
| (c : ℝ) (hc : 0 < c) : |
| CFC.log (c • V) = Real.log c • (1 : A) + CFC.log V := by |
| have hne (x : ℝ) (hx : x ∈ spectrum ℝ V) : x ≠ 0 := by |
| intro he |
| exact (spectrum.zero_notMem_iff ℝ).mpr hu (he ▸ hx) |
| have hl : ContinuousOn Real.log (spectrum ℝ V) := by |
| intro x hx |
| exact (Real.continuousAt_log (hne x hx)).continuousWithinAt |
| have hlc : ContinuousOn Real.log ((fun x : ℝ => c * x) '' spectrum ℝ V) := by |
| rintro y ⟨x, hx, rfl⟩ |
| exact (Real.continuousAt_log (mul_ne_zero hc.ne' (hne x hx))).continuousWithinAt |
| have he : cfc (fun x : ℝ => c * x) V = c • V := cfc_const_mul_id c V hV |
| rw [CFC.log, ← he, ← cfc_comp' Real.log (fun x : ℝ => c * x) V hlc (by fun_prop) hV] |
| calc |
| cfc (fun x : ℝ => Real.log (c * x)) V = |
| cfc (fun x : ℝ => Real.log c + Real.log x) V := by |
| apply cfc_congr |
| intro x hx |
| exact Real.log_mul hc.ne' (hne x hx) |
| _ = Real.log c • (1 : A) + CFC.log V := by |
| rw [cfc_add V (fun _ : ℝ => Real.log c) Real.log (by fun_prop) hl, |
| cfc_const (Real.log c) V hV, Algebra.algebraMap_eq_smul_one] |
| rfl |
| |
| lemma norm_one_sub_rescale_star_mul_self (M : A) (hu : IsUnit M) : |
| ‖1 - (‖star M * M‖ + 1)⁻¹ • (star M * M)‖ < 1 := by |
| let N := star M * M |
| let c := ‖N‖ + 1 |
| have hc : 0 < c := by dsimp [c]; positivity |
| have hN : IsSelfAdjoint N := IsSelfAdjoint.star_mul_self M |
| have huN : IsUnit N := hu.star.mul hu |
| have he : cfc (fun x : ℝ => 1 - c⁻¹ * x) N = 1 - c⁻¹ • N := by |
| rw [cfc_sub (fun _ : ℝ => 1) (fun x => c⁻¹ * x) N (by fun_prop) (by fun_prop), |
| cfc_const_one ℝ N hN, cfc_const_mul_id c⁻¹ N hN] |
| change ‖1 - c⁻¹ • N‖ < 1 |
| rw [← he] |
| apply norm_cfc_lt zero_lt_one |
| intro x hx |
| have hx₀ : 0 < x := by |
| have hn : 0 ≤ x := spectrum_star_mul_self_nonneg x hx |
| have hnz : x ≠ 0 := fun hz => (spectrum.zero_notMem_iff ℝ).mpr huN (hz ▸ hx) |
| exact lt_of_le_of_ne hn (Ne.symm hnz) |
| have hxn : x < c := by |
| have hb := spectrum.norm_le_norm_of_mem hx |
| dsimp [c] |
| rw [Real.norm_of_nonneg hx₀.le] at hb |
| linarith |
| rw [Real.norm_eq_abs, abs_lt] |
| have hxc : 0 < c⁻¹ * x := mul_pos (inv_pos.mpr hc) hx₀ |
| have hxc' : c⁻¹ * x < 1 := by |
| rw [mul_comm, ← div_eq_mul_inv] |
| exact (div_lt_one hc).mpr hxn |
| constructor <;> linarith |
|
|
| omit [Nontrivial A] in |
| lemma ringInverse_smul (N : A) (hu : IsUnit N) (c : ℝ) (hc : c ≠ 0) : |
| Ring.inverse (c • N) = c⁻¹ • Ring.inverse N := by |
| have hu' : IsUnit (c • N) := by |
| rw [Algebra.smul_def] |
| exact ((isUnit_iff_ne_zero.mpr hc).map (algebraMap ℝ A)).mul hu |
| have hm : (c • N) * (c⁻¹ • Ring.inverse N) = 1 := by |
| rw [smul_mul_smul_comm, mul_inv_cancel₀ hc, one_smul, Ring.mul_inverse_cancel N hu] |
| calc |
| Ring.inverse (c • N) = Ring.inverse (c • N) * 1 := (mul_one _).symm |
| _ = Ring.inverse (c • N) * ((c • N) * (c⁻¹ • Ring.inverse N)) := by rw [hm] |
| _ = c⁻¹ • Ring.inverse N := Ring.inverse_mul_cancel_left _ _ hu' |
|
|
| lemma hasDerivAt_trace_log_of_rescale (τ : A →L[ℝ] ℂ) |
| (hτ : ∀ a b, τ (a * b) = τ (b * a)) |
| {N N' : ℝ → A} {x c : ℝ} (hc : 0 < c) |
| (hd : ∀ y, HasDerivAt N (N' y) y) (hdc : ContinuousAt N' x) |
| (hself : ∀ y, IsSelfAdjoint (N y)) (hu : ∀ y, IsUnit (N y)) |
| (hn : ‖1 - c⁻¹ • N x‖ < 1) : |
| HasDerivAt (fun y => τ (CFC.log (N y))) |
| (τ (N' x * Ring.inverse (N x))) x := by |
| let W := fun y => (1 : A) - c⁻¹ • N y |
| let W' := fun y => -(c⁻¹ • N' y) |
| have hW (y : ℝ) : HasDerivAt W (W' y) y := by |
| simpa [W, W'] using (hd y).const_smul c⁻¹ |>.const_sub 1 |
| have hWc : ContinuousAt W' x := (hdc.const_smul c⁻¹).neg |
| have hWs (y : ℝ) : IsSelfAdjoint (W y) := |
| (IsSelfAdjoint.one A).sub ((IsSelfAdjoint.all (c⁻¹)).smul (hself y)) |
| have he (y : ℝ) : 1 - W y = c⁻¹ • N y := by dsimp [W]; abel |
| have hue (y : ℝ) : IsUnit (1 - W y) := by |
| rw [he, Algebra.smul_def] |
| exact ((isUnit_iff_ne_zero.mpr (inv_ne_zero hc.ne')).map (algebraMap ℝ A)).mul (hu y) |
| have hrescale (y : ℝ) : c • (1 - W y) = N y := by |
| rw [he, smul_smul, mul_inv_cancel₀ hc.ne', one_smul] |
| have hlog (y : ℝ) : CFC.log (N y) = Real.log c • (1 : A) + CFC.log (1 - W y) := by |
| rw [← hrescale y] |
| exact log_smul_of_isUnit (1 - W y) ((IsSelfAdjoint.one A).sub (hWs y)) (hue y) c hc |
| have H := (hasDerivAt_trace_log_one_sub τ hτ hW hWc hn hWs).const_add |
| (τ (Real.log c • (1 : A))) |
| have hdval : -τ (W' x * Ring.inverse (1 - W x)) = τ (N' x * Ring.inverse (N x)) := by |
| rw [he, ringInverse_smul (N x) (hu x) _ (inv_ne_zero hc.ne'), inv_inv] |
| dsimp [W'] |
| rw [neg_mul, smul_mul_smul_comm, inv_mul_cancel₀ hc.ne', one_smul, map_neg, neg_neg] |
| rw [hdval] at H |
| convert! H using 1 |
| ext y |
| rw [hlog, map_add] |
|
|
| omit [Nontrivial A] in |
| lemma trace_star_mul_self_log_derivative_value (τ : A →L[ℝ] ℂ) |
| (hτ : ∀ a b, τ (a * b) = τ (b * a)) (hstar : ∀ a, τ (star a) = star (τ a)) |
| (M D : A) (hu : IsUnit M) : |
| τ ((star D * M + star M * D) * Ring.inverse (star M * M)) = |
| (2 * (τ (D * Ring.inverse M)).re : ℝ) := by |
| rw [add_mul, map_add] |
| have hfirst : τ (star D * M * Ring.inverse (star M * M)) = |
| star (τ (D * Ring.inverse M)) := by |
| rw [Ring.inverse_mul (Or.inl hu.star), ← mul_assoc, |
| Ring.mul_inverse_cancel_right M (star D) hu, hτ, Ring.inverse_star, |
| ← star_mul, hstar] |
| have hsecond : τ (star M * D * Ring.inverse (star M * M)) = τ (D * Ring.inverse M) := by |
| rw [mul_assoc, hτ, Ring.inverse_mul (Or.inl hu.star), mul_assoc D, |
| mul_assoc (Ring.inverse M), Ring.inverse_mul_cancel (star M) hu.star, mul_one] |
| rw [hfirst, hsecond, add_comm] |
| exact Complex.add_conj _ |
|
|
| lemma hasDerivAt_trace_log_star_mul_self (τ : A →L[ℝ] ℂ) |
| (hτ : ∀ a b, τ (a * b) = τ (b * a)) (hstar : ∀ a, τ (star a) = star (τ a)) |
| {M M' : ℝ → A} {x : ℝ} (hd : ∀ y, HasDerivAt M (M' y) y) |
| (hdc : ContinuousAt M' x) (hu : ∀ y, IsUnit (M y)) : |
| HasDerivAt (fun y => τ (CFC.log (star (M y) * M y))) |
| (2 * (τ (M' x * Ring.inverse (M x))).re : ℝ) x := by |
| let N := fun y => star (M y) * M y |
| let N' := fun y => star (M' y) * M y + star (M y) * M' y |
| have hN (y : ℝ) : HasDerivAt N (N' y) y := (hd y).star.mul (hd y) |
| have hNc : ContinuousAt N' x := |
| (hdc.star.mul (hd x).continuousAt).add ((hd x).continuousAt.star.mul hdc) |
| have H := hasDerivAt_trace_log_of_rescale τ hτ |
| (show 0 < ‖N x‖ + 1 by positivity) hN hNc |
| (fun y => IsSelfAdjoint.star_mul_self (M y)) (fun y => (hu y).star.mul (hu y)) |
| (norm_one_sub_rescale_star_mul_self (M x) (hu x)) |
| rwa [trace_star_mul_self_log_derivative_value τ hτ hstar (M x) (M' x) (hu x)] at H |
|
|
| omit [Nontrivial A] in |
| lemma trace_derivative_mul_value (τ : A →L[ℝ] ℂ) |
| (hτ : ∀ a b, τ (a * b) = τ (b * a)) (L R D E : A) |
| (hL : IsUnit L) (hR : IsUnit R) : |
| τ ((D * R + L * E) * Ring.inverse (L * R)) = |
| τ (D * Ring.inverse L) + τ (E * Ring.inverse R) := by |
| rw [add_mul, map_add, Ring.inverse_mul (Or.inl hL)] |
| congr 1 |
| · rw [← mul_assoc, Ring.mul_inverse_cancel_right R D hR] |
| · rw [mul_assoc L, hτ L, ← mul_assoc E, mul_assoc (E * Ring.inverse R), |
| Ring.inverse_mul_cancel L hL, mul_one] |
|
|
| omit [Nontrivial A] in |
| def nilpotentShearUnit (S : A) (hS : S * S = 0) (x : ℝ) : Aˣ where |
| val := 1 + x • S |
| inv := 1 - x • S |
| val_inv := by |
| simp only [add_mul, mul_sub, one_mul, mul_one, smul_mul_smul_comm, hS, smul_zero] |
| abel |
| inv_val := by |
| simp only [sub_mul, mul_add, one_mul, mul_one, smul_mul_smul_comm, hS, smul_zero] |
| abel |
|
|
| omit [Nontrivial A] in |
| lemma ringInverse_nilpotentShear (S : A) (hS : S * S = 0) (x : ℝ) : |
| Ring.inverse (1 + x • S) = 1 - x • S := |
| Ring.inverse_unit (nilpotentShearUnit S hS x) |
|
|
| omit [Nontrivial A] in |
| lemma nilpotentShear_trace_derivative (τ : A →L[ℝ] ℂ) (S : A) |
| (hS : S * S = 0) (ht : τ S = 0) (x : ℝ) : |
| τ (S * Ring.inverse (1 + x • S)) = 0 := by |
| rw [ringInverse_nilpotentShear S hS x, mul_sub, mul_one, mul_smul_comm, hS, |
| smul_zero, sub_zero, ht] |
|
|
| lemma trace_log_shear_invariant (τ : A →L[ℝ] ℂ) |
| (hτ : ∀ a b, τ (a * b) = τ (b * a)) (hstar : ∀ a, τ (star a) = star (τ a)) |
| (B S T : A) (hB : IsUnit B) (hS : S * S = 0) (hT : T * T = 0) |
| (htS : τ S = 0) (htT : τ T = 0) (x : ℝ) : |
| τ (CFC.log (star ((1 + x • S) * B * (1 + x • T)) * |
| ((1 + x • S) * B * (1 + x • T)))) = τ (CFC.log (star B * B)) := by |
| let M := fun y : ℝ => (1 + y • S) * B * (1 + y • T) |
| let M' := fun y : ℝ => S * B * (1 + y • T) + (1 + y • S) * B * T |
| have hL (y : ℝ) : HasDerivAt (fun y : ℝ => 1 + y • S) S y := by |
| simpa using ((hasDerivAt_id y).smul_const S).const_add 1 |
| have hR (y : ℝ) : HasDerivAt (fun y : ℝ => 1 + y • T) T y := by |
| simpa using ((hasDerivAt_id y).smul_const T).const_add 1 |
| have hd (y : ℝ) : HasDerivAt M (M' y) y := ((hL y).mul_const B).mul (hR y) |
| have hdc : Continuous M' := by dsimp [M']; fun_prop |
| have huL (y : ℝ) : IsUnit (1 + y • S) := (nilpotentShearUnit S hS y).isUnit |
| have huR (y : ℝ) : IsUnit (1 + y • T) := (nilpotentShearUnit T hT y).isUnit |
| have hu (y : ℝ) : IsUnit (M y) := ((huL y).mul hB).mul (huR y) |
| have hz (y : ℝ) : τ (M' y * Ring.inverse (M y)) = 0 := by |
| dsimp [M, M'] |
| rw [trace_derivative_mul_value τ hτ _ _ _ _ ((huL y).mul hB) (huR y), |
| Ring.inverse_mul (Or.inl (huL y)), ← mul_assoc, |
| Ring.mul_inverse_cancel_right B S hB, |
| nilpotentShear_trace_derivative τ S hS htS, |
| nilpotentShear_trace_derivative τ T hT htT, add_zero] |
| have H (y : ℝ) : HasDerivAt (fun y => τ (CFC.log (star (M y) * M y))) 0 y := by |
| simpa only [hz y, Complex.zero_re, mul_zero, Complex.ofReal_zero] using |
| hasDerivAt_trace_log_star_mul_self τ hτ hstar hd hdc.continuousAt hu (x := y) |
| have he := is_const_of_deriv_eq_zero (fun y => (H y).differentiableAt) |
| (fun y => (H y).deriv) x 0 |
| simpa [M] using he |
|
|
| end TraceCFC |
|
|
| end GroupRingDeterminant |
|
|
| end |
|
|
| end OAI |
|
|
