| import OAI.Analysis.FreeGroupFactor.SmallCocycle |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| universe uA uG |
|
|
| open Set Metric Filter |
| open scoped NNReal Topology BigOperators ContDiff |
|
|
| namespace FreeGroupFactorMain.MobiusLog |
| variable {A : Type uA} [CommCStarAlgebra A] [Nontrivial A] |
|
|
| theorem norm_neg_smul_star_lt (C : unitary A) {r : ℝ} (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| ‖-r • star (C : A)‖ < 1 := by |
| calc |
| ‖-r • star (C : A)‖ = r * ‖(C : A)‖ := by |
| rw [norm_smul, norm_star, Real.norm_eq_abs, abs_neg, abs_of_nonneg hr0] |
| _ ≤ r * 1 := mul_le_mul_of_nonneg_left (CStarRing.norm_coe_unitary C).le hr0 |
| _ < 1 := by simpa using hr1 |
|
|
| def denominator (C : unitary A) (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : Aˣ := |
| Units.oneSub (-r • star (C : A)) (norm_neg_smul_star_lt C hr0 hr1) |
|
|
| @[simp] theorem denominator_coe (C : unitary A) (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| (denominator C r hr0 hr1 : A) = 1 + r • star (C : A) := by |
| simp [denominator, sub_neg_eq_add] |
|
|
| def mobius (C : unitary A) (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : unitary A := |
| ⟨((star (denominator C r hr0 hr1)) * (denominator C r hr0 hr1)⁻¹ : Aˣ), by |
| apply (Units.mul_inv_mem_unitary _ _).mpr |
| rw [star_star, mul_comm]⟩ |
|
|
| theorem denominator_add_star_isUnit (C : unitary A) (r : ℝ) |
| (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| IsUnit ((denominator C r hr0 hr1 : A) + star (denominator C r hr0 hr1 : A)) := by |
| have hn : ‖-(r/2) • ((C : A) + star (C : A))‖ < 1 := by |
| calc |
| _ = (r/2) * ‖(C : A) + star (C : A)‖ := by |
| rw [norm_smul, Real.norm_eq_abs, abs_neg, abs_of_nonneg (by positivity)] |
| _ ≤ (r/2) * (1+1) := by |
| gcongr |
| exact (norm_add_le _ _).trans (by |
| rw [norm_star] |
| exact add_le_add (CStarRing.norm_coe_unitary C).le (CStarRing.norm_coe_unitary C).le) |
| _ < 1 := by linarith |
| have hu := isUnit_one_sub_of_norm_lt_one hn |
| have he : (denominator C r hr0 hr1 : A) + star (denominator C r hr0 hr1 : A) = |
| (2 : ℝ) • (1 - (-(r/2) • ((C : A) + star (C : A)))) := by |
| simp only [denominator_coe, star_add, star_one, star_smul, star_trivial, star_star] |
| module |
| rw [he] |
| rw [Algebra.smul_def] |
| exact ((isUnit_iff_ne_zero.mpr (by norm_num) : IsUnit (2 : ℝ)).map |
| (algebraMap ℝ A)).mul hu |
|
|
| theorem mobius_add_one_isUnit (C : unitary A) (r : ℝ) |
| (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| IsUnit ((mobius C r hr0 hr1 : A) + 1) := by |
| have hu := denominator_add_star_isUnit C r hr0 hr1 |
| have he : ((mobius C r hr0 hr1 : A) + 1) * (denominator C r hr0 hr1 : A) = |
| (denominator C r hr0 hr1 : A) + star (denominator C r hr0 hr1 : A) := by |
| simp only [mobius, Units.val_mul, Units.coe_star, add_mul, mul_assoc, |
| Units.inv_mul, mul_one, one_mul] |
| exact add_comm _ _ |
| rw [← he] at hu |
| exact (IsUnit.mul_iff.mp hu).1 |
|
|
| theorem mobius_norm_sub_one_lt_two (C : unitary A) (r : ℝ) |
| (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| ‖(mobius C r hr0 hr1 : A) - 1‖ < 2 := by |
| apply (Unitary.norm_sub_one_lt_two_iff (mobius C r hr0 hr1).property).mpr |
| rw [spectrum.notMem_iff] |
| simpa [sub_eq_add_neg, add_comm] using |
| (mobius_add_one_isUnit C r hr0 hr1).neg |
|
|
| theorem mobius_bounded_log (C : unitary A) (r : ℝ) |
| (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| ∃ S : selfAdjoint A, ‖S‖ ≤ Real.pi ∧ selfAdjoint.expUnitary S = mobius C r hr0 hr1 := by |
| exact ⟨Unitary.argSelfAdjoint _, Unitary.norm_argSelfAdjoint_le_pi _, |
| expUnitary_argSelfAdjoint (mobius_norm_sub_one_lt_two C r hr0 hr1)⟩ |
|
|
| theorem mobius_decomp (C : unitary A) (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| (mobius C r hr0 hr1 : A) = r • (C : A) + |
| (1-r^2) • ((denominator C r hr0 hr1)⁻¹ : Aˣ) := by |
| let q := denominator C r hr0 hr1 |
| have he : (r • (C : A) + (1-r^2) • ((q⁻¹ : Aˣ) : A)) * (q : A) = star (q : A) := by |
| rw [add_mul, smul_mul_assoc, smul_mul_assoc, Units.inv_mul, denominator_coe, |
| mul_add, mul_one, mul_smul_comm, C.property.2] |
| simp only [star_add, star_one, star_smul, star_trivial, star_star, smul_add, smul_smul] |
| module |
| have hh := congrArg (fun x : A => x * ((q⁻¹ : Aˣ) : A)) he |
| simpa only [mul_assoc, Units.mul_inv, mul_one, mobius, Units.val_mul, Units.coe_star] |
| using hh.symm |
|
|
| theorem trace_star_mul_denominator_inv (C : unitary A) (τ : A →L[ℂ] ℂ) |
| (hτ : ∀ m : ℤ, τ ((C^m : unitary A) : A) = if m = 0 then 1 else 0) |
| (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| τ (star (C : A) * ((denominator C r hr0 hr1)⁻¹ : Aˣ)) = 0 := by |
| let t : A := -r • star (C : A) |
| have hs := summable_geometric_of_norm_lt_one (norm_neg_smul_star_lt C hr0 hr1) |
| change τ (star (C : A) * ∑' m : ℕ, t^m) = _ |
| rw [← hs.tsum_mul_left, τ.map_tsum (hs.mul_left _)] |
| have hz : ∀ m : ℕ, τ (star (C : A) * t^m) = 0 := by |
| intro m |
| have he : star (C : A) * (star (C : A))^m = ((C^(-(m+1 : ℤ)) : unitary A) : A) := by |
| rw [show (m:ℤ)+1 = ((m+1:ℕ):ℤ) by simp, zpow_neg, zpow_natCast, |
| ← Unitary.star_eq_inv] |
| rw [Unitary.coe_star, SubmonoidClass.coe_pow, star_pow, pow_succ'] |
| dsimp [t] |
| rw [smul_pow, mul_smul_comm, he, τ.map_smul_of_tower] |
| rw [hτ, ite_eq_right (by omega), smul_zero] |
| change (∑' m : ℕ, τ (star (C : A) * t^m)) = 0 |
| simp only [hz, tsum_zero] |
|
|
| theorem trace_star_mul_mobius (C : unitary A) (τ : A →L[ℂ] ℂ) |
| (hτ : ∀ m : ℤ, τ ((C^m : unitary A) : A) = if m = 0 then 1 else 0) |
| (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| τ (star (C : A) * (mobius C r hr0 hr1 : A)) = (r : ℂ) := by |
| rw [mobius_decomp, mul_add, mul_smul_comm, mul_smul_comm, C.property.1, |
| map_add, τ.map_smul_of_tower, τ.map_smul_of_tower, |
| trace_star_mul_denominator_inv C τ hτ r hr0 hr1] |
| have ht : τ 1 = 1 := by simpa using hτ 0 |
| simp [ht] |
|
|
| end FreeGroupFactorMain.MobiusLog |
| namespace FreeGroupFactorMain.ElementalMobius |
| variable {A : Type uA} [CStarAlgebra A] [Nontrivial A] |
|
|
| abbrev unitaryElemental (C : unitary A) : unitary (StarAlgebra.elemental ℂ (C : A)) := |
| ⟨⟨C, StarAlgebra.elemental.self_mem ℂ (C : A)⟩, |
| ⟨Subtype.ext C.property.1, Subtype.ext C.property.2⟩⟩ |
|
|
| def inclusion (C : unitary A) : (StarAlgebra.elemental ℂ (C : A)) →L[ℂ] A := |
| (StarAlgebra.elemental ℂ (C : A)).subtype.toAlgHom.toLinearMap.mkContinuous 1 |
| (fun _ => by simp) |
|
|
| omit [Nontrivial A] in |
| @[simp] theorem inclusion_apply (C : unitary A) (x : StarAlgebra.elemental ℂ (C : A)) : |
| inclusion C x = (x : A) := rfl |
|
|
| omit [Nontrivial A] in |
| theorem unitaryElemental_zpow (C : unitary A) (m : ℤ) : |
| (((unitaryElemental C ^ m : unitary (StarAlgebra.elemental ℂ (C : A))) : |
| StarAlgebra.elemental ℂ (C : A)) : A) = ((C ^ m : unitary A) : A) := by |
| let f : unitary (StarAlgebra.elemental ℂ (C : A)) →* unitary A := |
| Unitary.map (StarMonoidHom.ofClass (StarAlgebra.elemental ℂ (C : A)).subtype) |
| exact congrArg (fun u : unitary A => (u : A)) (f.map_zpow (unitaryElemental C) m) |
|
|
| def value (C : unitary A) (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : unitary A := |
| Unitary.map (StarMonoidHom.ofClass (StarAlgebra.elemental ℂ (C : A)).subtype) |
| (MobiusLog.mobius (unitaryElemental C) r hr0 hr1) |
|
|
| theorem trace (C : unitary A) (τ : A →L[ℂ] ℂ) |
| (hτ : ∀ m : ℤ, τ ((C^m : unitary A) : A) = if m = 0 then 1 else 0) |
| (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| τ (star (C : A) * (value C r hr0 hr1 : A)) = r := by |
| have ht (m : ℤ) : (τ.comp (inclusion C)) ((unitaryElemental C^m : unitary _) : |
| StarAlgebra.elemental ℂ (C : A)) = if m = 0 then 1 else 0 := by |
| simp only [ContinuousLinearMap.comp_apply, inclusion_apply, unitaryElemental_zpow, hτ] |
| exact MobiusLog.trace_star_mul_mobius (unitaryElemental C) (τ.comp (inclusion C)) ht r hr0 hr1 |
|
|
| theorem bounded_log (C : unitary A) (r : ℝ) (hr0 : 0 ≤ r) (hr1 : r < 1) : |
| ∃ S : A, S ∈ StarAlgebra.elemental ℂ (C : A) ∧ IsSelfAdjoint S ∧ ‖S‖ ≤ Real.pi ∧ |
| NormedSpace.exp (Complex.I • S) = (value C r hr0 hr1 : A) := by |
| let B := StarAlgebra.elemental ℂ (C : A) |
| obtain ⟨S,hSn,hSexp⟩ := MobiusLog.mobius_bounded_log (unitaryElemental C) r hr0 hr1 |
| have hTsa : IsSelfAdjoint ((S : B) : A) := congrArg (fun x : B => (x : A)) S.property |
| refine ⟨((S : B) : A), (S : B).property, hTsa, hSn, ?_⟩ |
| have hmap := congrArg (fun x : unitary B => ((x : B) : A)) hSexp |
| change B.subtype (NormedSpace.exp (Complex.I • (S : B))) = _ at hmap |
| let : NormedAlgebra ℚ A := NormedAlgebra.restrictScalars ℚ ℂ A |
| let : NormedAlgebra ℚ B := NormedAlgebra.restrictScalars ℚ ℂ B |
| rw [NormedSpace.map_exp B.subtype continuous_subtype_val] at hmap |
| exact hmap |
|
|
| end FreeGroupFactorMain.ElementalMobius |
| namespace FreeGroupFactorMain |
| variable {G : Type uG} [Group G] |
|
|
| @[simp] theorem twoNorm_one : twoNorm (1 : groupVonNeumann G) = 1 := by |
| simp [twoNorm, groupL2, deltaOne, lp.norm_single] |
|
|
| @[simp] theorem twoNorm_unitary (U : unitary (groupVonNeumann G)) : |
| twoNorm (U : groupVonNeumann G) = 1 := by |
| simpa using twoNorm_mul_unitary_left U 1 |
|
|
| theorem twoNorm_sub_unitary_sq (U V : unitary (groupVonNeumann G)) : |
| twoNorm ((U : groupVonNeumann G) - (V : groupVonNeumann G)) ^ 2 = |
| 2 - 2 * (canonicalTrace (star (U : groupVonNeumann G) * (V : groupVonNeumann G))).re := by |
| classical |
| unfold twoNorm |
| rw [map_sub, norm_sub_sq (𝕜 := ℂ)] |
| change (twoNorm (U : groupVonNeumann G))^2 - |
| 2*(inner ℂ (groupL2 (U : groupVonNeumann G)) (groupL2 (V : groupVonNeumann G))).re + |
| (twoNorm (V : groupVonNeumann G))^2 = _ |
| rw [twoNorm_unitary, twoNorm_unitary, canonicalTrace_star_mul_inner] |
| simp only [groupL2_apply, deltaOne_eq] |
| ring |
|
|
| def canonicalTraceContinuous : groupVonNeumann G →L[ℂ] ℂ := |
| (canonicalTraceLinear (G := G)).mkContinuous 1 (fun T => by |
| change ‖canonicalTrace T‖ ≤ 1 * ‖T‖ |
| simpa only [one_mul] using norm_canonicalTrace_le T) |
|
|
| @[simp] theorem canonicalTraceContinuous_apply (T : groupVonNeumann G) : |
| canonicalTraceContinuous T = canonicalTrace T := rfl |
|
|
| theorem haar_approx_log (C : unitary (groupVonNeumann G)) |
| (hτ : ∀ m : ℤ, canonicalTrace ((C^m : unitary (groupVonNeumann G)) : groupVonNeumann G) = |
| if m = 0 then 1 else 0) |
| {ε : ℝ} (hε : 0 < ε) : |
| ∃ S : groupVonNeumann G, |
| S ∈ StarAlgebra.elemental ℂ (C : groupVonNeumann G) ∧ IsSelfAdjoint S ∧ |
| ‖S‖ ≤ Real.pi ∧ twoNorm (NormedSpace.exp (Complex.I • S) - (C : groupVonNeumann G)) < ε := by |
| classical |
| let r : ℝ := 1 - min (ε^2/4) (1/2) |
| have hpos : 0 < min (ε^2/4) (1/2:ℝ) := lt_min (by positivity) (by norm_num) |
| have hr0 : 0 ≤ r := by dsimp [r]; have := min_le_right (ε^2/4) (1/2:ℝ); linarith |
| have hr1 : r < 1 := by dsimp [r]; linarith |
| obtain ⟨S,hSm,hSsa,hSn,hSexp⟩ := ElementalMobius.bounded_log C r hr0 hr1 |
| refine ⟨S,hSm,hSsa,hSn,?_⟩ |
| rw [hSexp] |
| have he := twoNorm_sub_unitary_sq C (ElementalMobius.value C r hr0 hr1) |
| rw [← canonicalTraceContinuous_apply, ElementalMobius.trace C canonicalTraceContinuous hτ r hr0 hr1, Complex.ofReal_re] at he |
| have hs : twoNorm ((ElementalMobius.value C r hr0 hr1 : groupVonNeumann G)-(C : groupVonNeumann G)) = |
| twoNorm ((C : groupVonNeumann G)-(ElementalMobius.value C r hr0 hr1 : groupVonNeumann G)) := by |
| unfold twoNorm |
| rw [map_sub, map_sub, norm_sub_rev] |
| rw [hs] |
| have hm := min_le_left (ε^2/4) (1/2:ℝ) |
| dsimp [r] at he |
| nlinarith [norm_nonneg (groupL2 ((C : groupVonNeumann G)-(ElementalMobius.value C r hr0 hr1 : groupVonNeumann G)))] |
|
|
| end FreeGroupFactorMain |
|
|
| open scoped BigOperators |
| namespace FreeGroupFactorMain.LaurentApprox |
|
|
| section |
| variable {A : Type uA} [CStarAlgebra A] |
|
|
| def value (C : unitary A) (l : ℤ →₀ ℂ) : A := |
| l.sum (fun m c => c • ((C^m : unitary A) : A)) |
|
|
| def powers (C : unitary A) : Submonoid A where |
| carrier := Set.range (fun m : ℤ => ((C^m : unitary A) : A)) |
| one_mem' := ⟨0, by simp⟩ |
| mul_mem' := by |
| rintro x y ⟨m, rfl⟩ ⟨n, rfl⟩ |
| exact ⟨m+n, by simp [zpow_add]⟩ |
|
|
| theorem adjoin_mem_span (C : unitary A) {x : A} |
| (hx : x ∈ StarAlgebra.adjoin ℂ ({(C : A)} : Set A)) : |
| x ∈ Submodule.span ℂ (Set.range (fun m : ℤ => ((C^m : unitary A) : A))) := by |
| have hs : Submonoid.closure ({(C : A)} ∪ star ({(C : A)} : Set A)) ≤ powers C := by |
| apply Submonoid.closure_le.mpr |
| intro y hy |
| simp only [Set.mem_union, Set.mem_singleton_iff, Set.star_singleton] at hy |
| rcases hy with rfl | rfl |
| · exact ⟨1, by simp⟩ |
| · exact ⟨-1, by change (((C^(-1:ℤ) : unitary A) : A)) = _; simp only [zpow_neg_one]; rfl⟩ |
| exact Submodule.span_mono hs (by |
| rw [← StarAlgebra.adjoin_eq_span] |
| exact hx) |
|
|
| theorem approx (C : unitary A) {x : A} |
| (hx : x ∈ StarAlgebra.elemental ℂ (C : A)) {ε : ℝ} (hε : 0 < ε) : |
| ∃ l : ℤ →₀ ℂ, ‖value C l - x‖ < ε := by |
| change x ∈ closure (StarAlgebra.adjoin ℂ ({(C : A)} : Set A) : Set A) at hx |
| obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.mp hx ε hε |
| obtain ⟨l, hl⟩ := Finsupp.mem_span_range_iff_exists_finsupp.mp (adjoin_mem_span C hy) |
| refine ⟨l, ?_⟩ |
| simpa only [value, hl, dist_eq_norm, norm_sub_rev] using hxy |
|
|
| theorem approx_selfAdjoint (C : unitary A) {x : A} |
| (hx : x ∈ StarAlgebra.elemental ℂ (C : A)) (hsa : IsSelfAdjoint x) |
| {ε : ℝ} (hε : 0 < ε) : |
| ∃ l : ℤ →₀ ℂ, IsSelfAdjoint (value C l) ∧ ‖value C l - x‖ < ε := by |
| change x ∈ closure (StarAlgebra.adjoin ℂ ({(C : A)} : Set A) : Set A) at hx |
| obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.mp hx ε hε |
| let z : A := (1/2 : ℝ) • (y + star y) |
| have hz : z ∈ StarAlgebra.adjoin ℂ ({(C : A)} : Set A) := by |
| exact (StarAlgebra.adjoin ℂ ({(C : A)} : Set A)).smul_mem |
| (by exact add_mem hy (star_mem hy)) (1/2 : ℝ) |
| obtain ⟨l, hl⟩ := Finsupp.mem_span_range_iff_exists_finsupp.mp (adjoin_mem_span C hz) |
| have hl' : value C l = z := hl |
| refine ⟨l, ?_, ?_⟩ |
| · rw [hl'] |
| show star z = z |
| simp [z, add_comm] |
| · rw [hl'] |
| have hz' : z - x = (1/2:ℝ) • ((y-x) + star (y-x)) := by |
| simp only [z, star_sub, hsa.star_eq] |
| module |
| rw [hz', norm_smul, Real.norm_eq_abs, abs_of_pos (by norm_num : (0:ℝ)<1/2)] |
| have hn := norm_add_le (y-x) (star (y-x)) |
| rw [norm_star] at hn |
| have hh : ‖y-x‖ < ε := by simpa only [dist_eq_norm, norm_sub_rev] using hxy |
| nlinarith |
|
|
| @[simp] theorem value_add (C : unitary A) (l k : ℤ →₀ ℂ) : |
| value C (l+k) = value C l + value C k := |
| (Finsupp.linearCombination ℂ (fun m : ℤ => ((C^m : unitary A) : A))).map_add l k |
|
|
| @[simp] theorem value_sub (C : unitary A) (l k : ℤ →₀ ℂ) : |
| value C (l-k) = value C l - value C k := |
| (Finsupp.linearCombination ℂ (fun m : ℤ => ((C^m : unitary A) : A))).map_sub l k |
|
|
| @[simp] theorem value_single (C : unitary A) (m : ℤ) (c : ℂ) : |
| value C (Finsupp.single m c) = c • ((C^m : unitary A) : A) := by |
| simp [value] |
|
|
| theorem trace_value (C : unitary A) (τ : A →L[ℂ] ℂ) |
| (hτ : ∀ m : ℤ, τ ((C^m : unitary A) : A) = if m = 0 then 1 else 0) |
| (l : ℤ →₀ ℂ) : τ (value C l) = l 0 := by |
| classical |
| simp only [value, Finsupp.sum, map_sum, map_smul, hτ] |
| simp [smul_eq_mul, mul_ite, eq_comm] |
|
|
| theorem approx_selfAdjoint_exp (C : unitary A) {x : A} |
| (hx : x ∈ StarAlgebra.elemental ℂ (C : A)) (hsa : IsSelfAdjoint x) |
| {ε : ℝ} (hε : 0 < ε) : |
| ∃ l : ℤ →₀ ℂ, IsSelfAdjoint (value C l) ∧ ‖value C l‖ ≤ ‖x‖+1 ∧ |
| ‖NormedSpace.exp (Complex.I • value C l) - NormedSpace.exp (Complex.I • x)‖ < ε := by |
| have hc : ContinuousAt (fun y : A => NormedSpace.exp (Complex.I • y)) x := by |
| exact (NormedSpace.exp_analytic (𝕂 := ℂ) _).continuousAt.comp |
| (continuous_const_smul _).continuousAt |
| obtain ⟨δ, hδ, hd⟩ := Metric.continuousAt_iff.mp hc ε hε |
| obtain ⟨l, hsa', hl⟩ := approx_selfAdjoint C hx hsa (ε := min δ 1) (lt_min hδ (by norm_num)) |
| refine ⟨l, hsa', ?_, ?_⟩ |
| · have hh := norm_add_le (value C l-x) x |
| rw [sub_add_cancel] at hh |
| have := (lt_min_iff.mp hl).2 |
| linarith |
| · simpa only [dist_eq_norm] using |
| hd (by simpa only [dist_eq_norm] using (lt_min_iff.mp hl).1) |
|
|
| end |
|
|
| variable {A : Type uA} [CStarAlgebra A] [Nontrivial A] |
|
|
| theorem center (C : unitary A) (τ : A →L[ℂ] ℂ) |
| (hτ : ∀ m : ℤ, τ ((C^m : unitary A) : A) = if m = 0 then 1 else 0) |
| (hstar : ∀ x, τ (star x) = star (τ x)) (hb : ∀ x, ‖τ x‖ ≤ ‖x‖) |
| (l : ℤ →₀ ℂ) (hsa : IsSelfAdjoint (value C l)) (K : ℝ) (hn : ‖value C l‖ ≤ K) : |
| ∃ k : ℤ →₀ ℂ, k 0 = 0 ∧ IsSelfAdjoint (value C k) ∧ ‖value C k‖ ≤ 2*K ∧ |
| ∃ z : unitary ℂ, NormedSpace.exp (Complex.I • value C k) = |
| (z : ℂ) • NormedSpace.exp (Complex.I • value C l) := by |
| let : NormedAlgebra ℚ A := NormedAlgebra.restrictScalars ℚ ℂ A |
| have hre : IsSelfAdjoint (l 0) := by |
| change star (l 0) = l 0 |
| rw [← trace_value C τ hτ l, ← hstar, hsa.star_eq] |
| have hbn : ‖l 0‖ ≤ ‖value C l‖ := by rw [← trace_value C τ hτ l]; exact hb _ |
| let k : ℤ →₀ ℂ := l - Finsupp.single 0 (l 0) |
| have hk : value C k = value C l - (l 0) • (1 : A) := by |
| simp only [k,value_sub,value_single,zpow_zero,Submonoid.coe_one] |
| refine ⟨k,by simp [k],?_,?_,?_⟩ |
| · rw [hk] |
| exact hsa.sub (hre.smul (IsSelfAdjoint.one A)) |
| · rw [hk] |
| calc |
| ‖value C l - (l 0) • (1 : A)‖ ≤ ‖value C l‖ + ‖(l 0) • (1 : A)‖ := norm_sub_le _ _ |
| _ ≤ ‖value C l‖ + ‖l 0‖ := by |
| gcongr |
| simp only [norm_smul, norm_one, mul_one, le_refl] |
| _ ≤ 2*K := by linarith |
| · let z : unitary ℂ := selfAdjoint.expUnitary ⟨-(l 0), hre.neg⟩ |
| refine ⟨z,?_⟩ |
| have he : NormedSpace.exp ((Complex.I * (-(l 0))) • (1 : A)) = (z : ℂ) • (1 : A) := by |
| rw [← Algebra.algebraMap_eq_smul_one, ← NormedSpace.algebraMap_exp_comm] |
| exact Algebra.algebraMap_eq_smul_one _ |
| rw [hk] |
| have hs : Complex.I • (value C l - (l 0) • (1 : A)) = |
| (Complex.I * (-(l 0))) • (1 : A) + Complex.I • value C l := by module |
| rw [hs, NormedSpace.exp_add_of_commute, he, smul_mul_assoc, one_mul] |
| exact (Commute.one_left (Complex.I • value C l)).smul_left _ |
|
|
| end FreeGroupFactorMain.LaurentApprox |
|
|
| namespace FreeGroupFactorMain |
| variable {G : Type uG} [Group G] |
|
|
| theorem haar_centered_laurent (C : unitary (groupVonNeumann G)) |
| (hτ : ∀ m : ℤ, canonicalTrace ((C^m : unitary (groupVonNeumann G)) : groupVonNeumann G) = |
| if m = 0 then 1 else 0) {ε : ℝ} (hε : 0 < ε) : |
| ∃ k : ℤ →₀ ℂ, k 0 = 0 ∧ IsSelfAdjoint (LaurentApprox.value C k) ∧ |
| ‖LaurentApprox.value C k‖ ≤ 2*(Real.pi+1) ∧ ∃ z : unitary ℂ, |
| twoNorm (NormedSpace.exp (Complex.I • LaurentApprox.value C k) - (z : ℂ) • (C : groupVonNeumann G)) < ε := by |
| obtain ⟨S,hSm,hSsa,hSn,hSe⟩ := haar_approx_log C hτ (half_pos hε) |
| obtain ⟨l,hlS,hln,hle⟩ := LaurentApprox.approx_selfAdjoint_exp C hSm hSsa (half_pos hε) |
| obtain ⟨k,hk0,hkS,hkn,z,hze⟩ := LaurentApprox.center C canonicalTraceContinuous hτ |
| canonicalTrace_star norm_canonicalTrace_le l hlS (Real.pi+1) (hln.trans (by linarith)) |
| refine ⟨k,hk0,hkS,hkn,z,?_⟩ |
| have hsmul : (z : ℂ) • |
| (NormedSpace.exp (Complex.I • LaurentApprox.value C l) - (C : groupVonNeumann G)) = |
| (z : ℂ) • NormedSpace.exp (Complex.I • LaurentApprox.value C l) - |
| (z : ℂ) • (C : groupVonNeumann G) := |
| smul_sub (z : ℂ) (NormedSpace.exp (Complex.I • LaurentApprox.value C l)) |
| (C : groupVonNeumann G) |
| rw [hze, ← hsmul] |
| change ‖groupL2 ((z : ℂ) • _)‖ < ε |
| rw [map_smul, norm_smul, CStarRing.norm_coe_unitary, one_mul] |
| have he : NormedSpace.exp (Complex.I • LaurentApprox.value C l) - (C : groupVonNeumann G) = |
| (NormedSpace.exp (Complex.I • LaurentApprox.value C l) - NormedSpace.exp (Complex.I • S)) + |
| (NormedSpace.exp (Complex.I • S) - (C : groupVonNeumann G)) := by abel |
| rw [he, map_add] |
| have ht := norm_add_le (groupL2 (NormedSpace.exp (Complex.I • LaurentApprox.value C l) - NormedSpace.exp (Complex.I • S))) |
| (groupL2 (NormedSpace.exp (Complex.I • S) - (C : groupVonNeumann G))) |
| have hb := twoNorm_le_norm (NormedSpace.exp (Complex.I • LaurentApprox.value C l) - NormedSpace.exp (Complex.I • S)) |
| change ‖groupL2 (NormedSpace.exp (Complex.I • S) - (C : groupVonNeumann G))‖ < ε/2 at hSe |
| linarith |
|
|
| end FreeGroupFactorMain |
|
|
| end |
|
|
| end OAI |
|
|
