| import OAI.Analysis.FreeGroupFactor.FreeSum |
|
|
| namespace OAI |
|
|
| namespace FreeGroupFactorMain |
|
|
| noncomputable section |
|
|
| universe uA uB uG uH uι |
|
|
| open Set Metric Filter |
| open scoped NNReal Topology BigOperators ContDiff |
|
|
| abbrev Coeff (G : Type uG) := G →₀ ℝ |
|
|
| def coefficientShift {G : Type uG} [Group G] (g : G) : Coeff G ≃+ Coeff G := |
| Finsupp.domCongr (Equiv.mulLeft g) |
|
|
| @[simp] theorem coefficientShift_apply {G : Type uG} [Group G] (g : G) (h : Coeff G) (b : G) : |
| coefficientShift g h b = h (g⁻¹ * b) := rfl |
|
|
| @[simp] theorem coefficientShift_one {G : Type uG} [Group G] (h : Coeff G) : |
| coefficientShift (1 : G) h = h := by |
| ext b |
| simp |
|
|
| @[simp] theorem coefficientShift_mul {G : Type uG} [Group G] (g b : G) (h : Coeff G) : |
| coefficientShift (g * b) h = coefficientShift g (coefficientShift b h) := by |
| ext c |
| simp [mul_assoc] |
|
|
| def coefficientAction (G : Type uG) [Group G] : G →* MulAut (Multiplicative (Coeff G)) where |
| toFun g := AddEquiv.toMultiplicative (coefficientShift g) |
| map_one' := by |
| apply MulEquiv.ext |
| intro h |
| exact coefficientShift_one h.toAdd |
| map_mul' g b := by |
| apply MulEquiv.ext |
| intro h |
| exact coefficientShift_mul g b h.toAdd |
|
|
| def cocycleGraph {ι : Type uι} (h : ι → Coeff (FreeGroup ι)) : |
| FreeGroup ι →* (Multiplicative (Coeff (FreeGroup ι)) ⋊[coefficientAction (FreeGroup ι)] |
| FreeGroup ι) := |
| FreeGroup.lift (fun i => ⟨Multiplicative.ofAdd (h i), FreeGroup.of i⟩) |
|
|
| @[simp] theorem cocycleGraph_right {ι : Type uι} (h : ι → Coeff (FreeGroup ι)) |
| (g : FreeGroup ι) : (cocycleGraph h g).right = g := by |
| have hr : SemidirectProduct.rightHom.comp (cocycleGraph h) = MonoidHom.id _ := by |
| ext i |
| simp [cocycleGraph] |
| exact DFunLike.congr_fun hr g |
|
|
| def freeCocycle {ι : Type uι} (h : ι → Coeff (FreeGroup ι)) (g : FreeGroup ι) : |
| Coeff (FreeGroup ι) := (cocycleGraph h g).left.toAdd |
|
|
| @[simp] theorem freeCocycle_of {ι : Type uι} (h : ι → Coeff (FreeGroup ι)) (i : ι) : |
| freeCocycle h (FreeGroup.of i) = h i := by |
| simp [freeCocycle, cocycleGraph] |
|
|
| @[simp] theorem freeCocycle_one {ι : Type uι} (h : ι → Coeff (FreeGroup ι)) : |
| freeCocycle h 1 = 0 := by simp [freeCocycle] |
|
|
| theorem freeCocycle_mul {ι : Type uι} (h : ι → Coeff (FreeGroup ι)) (g b : FreeGroup ι) : |
| freeCocycle h (g * b) = freeCocycle h g + coefficientShift g (freeCocycle h b) := by |
| unfold freeCocycle |
| rw [map_mul] |
| rw [SemidirectProduct.mul_left, cocycleGraph_right] |
| rfl |
|
|
| theorem freeCocycle_inv {ι : Type uι} (h : ι → Coeff (FreeGroup ι)) (g : FreeGroup ι) : |
| freeCocycle h g⁻¹ = -coefficientShift g⁻¹ (freeCocycle h g) := by |
| have he := freeCocycle_mul h g⁻¹ g |
| simp only [inv_mul_cancel, freeCocycle_one] at he |
| exact eq_neg_of_add_eq_zero_left he.symm |
|
|
| namespace UnitaryEvaluation |
| variable {A : Type uA} [CStarAlgebra A] {ι : Type uι} |
|
|
| def hamiltonianLinear (S : A) (U : ι → unitary A) : (FreeGroup ι →₀ ℝ) →ₗ[ℝ] A := |
| Finsupp.linearCombination ℝ (fun g => wordHom U g * S * star (wordHom U g)) |
|
|
| theorem hamiltonianLinear_eq [DecidableEq ι] (S : A) (U : ι → unitary A) (k : FreeGroup ι →₀ ℝ) : |
| hamiltonianLinear S U k = PolynomialFlow.hamiltonian S k (fun i => (U i : A)) := by |
| classical |
| simp only [hamiltonianLinear, Finsupp.linearCombination_apply, |
| PolynomialFlow.hamiltonian, Finsupp.sum, wordHom_word] |
| apply Finset.sum_congr rfl |
| intro g _hg |
| exact (Complex.coe_smul (k g) _).symm |
|
|
| theorem hamiltonianLinear_shift (S : A) (U : ι → unitary A) |
| (g : FreeGroup ι) (k : FreeGroup ι →₀ ℝ) : |
| hamiltonianLinear S U (coefficientShift g k) = |
| wordHom U g * hamiltonianLinear S U k * star (wordHom U g) := by |
| induction k using Finsupp.induction_linear with |
| | zero => simp |
| | add p q hp hq => simp only [map_add, hp, hq, mul_add, add_mul] |
| | single b c => |
| have he : coefficientShift g (Finsupp.single b c) = Finsupp.single (g*b) c := by |
| simp only [coefficientShift, Finsupp.domCongr_apply, |
| Finsupp.equivMapDomain_eq_mapDomain, Finsupp.mapDomain_single] |
| rfl |
| rw [he] |
| simp only [hamiltonianLinear, Finsupp.linearCombination_single, map_mul, star_mul, |
| smul_mul_assoc, mul_smul_comm, mul_assoc] |
|
|
| theorem wordHom_mem_unitary (U : ι → unitary A) (g : FreeGroup ι) : |
| wordHom U g ∈ unitary A := (FreeGroup.lift U g).property |
|
|
| theorem hasDerivAt_wordHom_cocycle [Fintype ι] [DecidableEq ι] |
| (S : A) (hS : IsSelfAdjoint S) (h : ι → FreeGroup ι →₀ ℝ) |
| (U : ℝ → ι → unitary A) |
| (hU : ∀ t, HasDerivAt (fun t j => (U t j : A)) |
| (PolynomialFlow.field S h (fun j => (U t j : A))) t) |
| (g : FreeGroup ι) (t : ℝ) : |
| HasDerivAt (fun s => wordHom (U s) g) |
| (Complex.I • (hamiltonianLinear S (U t) (freeCocycle h g) * wordHom (U t) g)) t := by |
| induction g using FreeGroup.induction_on with |
| | one => simpa using hasDerivAt_const t (1:A) |
| | of i => |
| simpa only [freeCocycle_of, wordHom_of, hamiltonianLinear_eq, |
| PolynomialFlow.field, smul_mul_assoc] using |
| (hasDerivAt_pi.mp (hU t) i) |
| | inv_of i ih => |
| let g := FreeGroup.of i |
| change HasDerivAt (fun s => wordHom (U s) g⁻¹) _ t |
| have hs : IsSelfAdjoint (hamiltonianLinear S (U t) (freeCocycle h g)) := by |
| rw [hamiltonianLinear_eq] |
| exact PolynomialFlow.selfAdjoint_hamiltonian S hS _ _ |
| simp only [wordHom_inv] |
| convert ih.star using 1 |
| dsimp [g] at hs |
| simp only [freeCocycle_inv, map_neg, hamiltonianLinear_shift, wordHom_inv, |
| star_smul, Complex.star_def, Complex.conj_I, star_mul, hs.star_eq, star_star, |
| neg_mul, neg_smul, smul_neg] |
| rw [mul_assoc, mul_assoc, (wordHom_mem_unitary (U t) g).2, mul_one] |
| | mul g b hg hb => |
| simp only [map_mul] |
| convert hg.mul hb using 1 |
| simp only [freeCocycle_mul, map_add, hamiltonianLinear_shift, add_mul, |
| smul_add, smul_mul_assoc, mul_smul_comm] |
| simp only [mul_assoc] |
| rw [← mul_assoc (star (wordHom (U t) g)), |
| (wordHom_mem_unitary (U t) g).1, one_mul] |
|
|
| end UnitaryEvaluation |
|
|
| section |
| open UnitaryEvaluation |
|
|
| def groupUnitaryUHom (G : Type uG) [Group G] : G →* unitary (groupVonNeumann G) where |
| toFun g := ⟨groupUnitary g, groupUnitary_mem_unitary g⟩ |
| map_one' := Subtype.ext groupUnitary_one |
| map_mul' g b := Subtype.ext (groupUnitary_mul g b) |
|
|
| theorem laurentValue_group (ι : Type uι) (l : ℤ →₀ ℂ) : |
| laurentValue (generatorUnitary (none : Option ι)) l = |
| groupLaurent (FreeGroup.of (none : Option ι)) l := by |
| classical |
| unfold laurentValue coefficientHom groupLaurent |
| rw [Finsupp.linearCombination_apply] |
| apply Finsupp.sum_congr |
| intro m _hm |
| change l m • (((generatorUnitary (none : Option ι))^m : |
| unitary (groupVonNeumann (FreeGroup (Option ι)))) : groupVonNeumann (FreeGroup (Option ι))) = |
| l m • groupUnitary (FreeGroup.of (none : Option ι) ^ m) |
| congr 1 |
| have hh := (groupUnitaryUHom (FreeGroup (Option ι))).map_zpow |
| (FreeGroup.of none) m |
| exact congrArg Subtype.val hh.symm |
|
|
| theorem wordHom_original {ι : Type uι} (g : FreeGroup ι) : |
| wordHom (fun j => generatorUnitary (some j)) g = groupUnitary (FreeGroup.map Option.some g) := by |
| have he : wordHom (fun j : ι => generatorUnitary (some j)) = |
| (groupUnitaryHom (FreeGroup (Option ι))).comp (FreeGroup.map Option.some) := by |
| apply FreeGroup.ext_hom |
| intro i |
| simp only [MonoidHom.comp_apply, FreeGroup.map.of, wordHom_of] |
| rfl |
| exact DFunLike.congr_fun he g |
|
|
| theorem hamiltonianLinear_original_bound {ι : Type uι} [DecidableEq ι] |
| (l : ℤ →₀ ℂ) (h0 : l 0 = 0) |
| (hS : IsSelfAdjoint (laurentValue (generatorUnitary (none : Option ι)) l)) |
| (K : ℝ) (hK : 0 ≤ K) |
| (hn : ‖laurentValue (generatorUnitary (none : Option ι)) l‖ ≤ K) |
| (k : FreeGroup ι →₀ ℝ) : |
| ‖hamiltonianLinear (laurentValue (generatorUnitary (none : Option ι)) l) |
| (fun j => generatorUnitary (some j)) k‖ ≤ 3*K*Real.sqrt (k.sum (fun _ r => r^2)) := by |
| rw [laurentValue_group] at hS hn ⊢ |
| convert centered_laurent_free_sum l h0 hS K hK hn k using 1 |
| congr 1 |
| unfold hamiltonianLinear |
| rw [Finsupp.linearCombination_apply] |
| apply Finsupp.sum_congr |
| intro g _hg |
| rw [wordHom_original, ← groupLaurent_conjugate] |
| rfl |
|
|
| variable {A : Type uA} {B : Type uB} [CStarAlgebra A] [CStarAlgebra B] |
|
|
| theorem hamiltonianLinear_map {ι : Type uι} |
| (Φ : A ≃⋆ₐ[ℂ] B) (S : A) (U : ι → unitary A) (V : ι → unitary B) |
| (hUV : ∀ g, Φ (wordHom U g) = wordHom V g) (k : FreeGroup ι →₀ ℝ) : |
| Φ (hamiltonianLinear S U k) = hamiltonianLinear (Φ S) V k := by |
| classical |
| simp only [hamiltonianLinear, Finsupp.linearCombination_apply, Finsupp.sum, |
| map_sum, ← Complex.coe_smul, map_smul, map_mul, map_star, hUV] |
|
|
| theorem hamiltonianLinear_single_one {ι : Type uι} (S : A) (U : ι → unitary A) : |
| hamiltonianLinear S U (Finsupp.single 1 1) = S := by |
| simp [hamiltonianLinear] |
|
|
| end |
| section |
|
|
| variable {A : Type uA} [CStarAlgebra A] |
|
|
| theorem unitary_curve_displacement (S : A) (hS : IsSelfAdjoint S) |
| (W : ℝ → unitary A) (H : ℝ → A) |
| (hW : ∀ t, HasDerivAt (fun s => (W s : A)) |
| (Complex.I • (H t * (W t : A))) t) |
| (B : ℝ) (hB : ∀ t ∈ Set.Icc (0:ℝ) 1, ‖H t-S‖ ≤ B) : |
| ‖(W 1 : A) - NormedSpace.exp (Complex.I • S) * (W 0 : A)‖ ≤ B := by |
| let : NormedAlgebra ℚ A := NormedAlgebra.restrictScalars ℚ ℂ A |
| let E (t : ℝ) : A := NormedSpace.exp (t • (-Complex.I • S)) |
| have hEu (t : ℝ) : E t ∈ unitary A := by |
| apply NormedSpace.exp_mem_unitary_of_mem_skewAdjoint |
| change star (t • (-Complex.I • S)) = -(t • (-Complex.I • S)) |
| rw [star_smul, star_smul, star_trivial, star_neg, Complex.star_def, |
| Complex.conj_I, neg_neg, hS.star_eq, neg_smul, smul_neg] |
| rw [neg_neg] |
| let D (t : ℝ) : A := Complex.I • (E t * (H t-S) * (W t : A)) |
| have hd (t : ℝ) : HasDerivAt (fun s => E s * (W s : A)) (D t) t := by |
| have he := hasDerivAt_exp_smul_const (-Complex.I • S) t |
| convert he.mul (hW t) using 1 |
| dsimp [E, D] |
| simp only [mul_sub, sub_mul, smul_sub, mul_smul_comm, smul_mul_assoc, |
| neg_smul, mul_neg, neg_mul, smul_neg, mul_assoc] |
| abel |
| have hb (t : ℝ) (ht : t ∈ Set.Icc (0:ℝ) 1) : ‖D t‖ ≤ B := by |
| dsimp [D] |
| rw [norm_smul, Complex.norm_I, one_mul, |
| CStarRing.norm_mul_mem_unitary _ (W t).property, |
| CStarRing.norm_mem_unitary_mul _ (hEu t)] |
| exact hB t ht |
| have hm := (convex_Icc (0:ℝ) 1).norm_image_sub_le_of_norm_hasDerivWithin_le |
| (fun t _ => (hd t).hasDerivWithinAt) hb (by simp : (0:ℝ) ∈ Set.Icc 0 1) |
| (by simp : (1:ℝ) ∈ Set.Icc 0 1) |
| have hE0 : E 0 = 1 := by simp [E] |
| have hE1 : E 1 * NormedSpace.exp (Complex.I • S) = 1 := by |
| dsimp [E] |
| rw [one_smul, neg_smul, ← NormedSpace.exp_add_of_commute (Commute.refl _).neg_left, |
| neg_add_cancel, NormedSpace.exp_zero] |
| have heq : E 1 * ((W 1 : A) - NormedSpace.exp (Complex.I • S) * (W 0 : A)) = |
| E 1 * (W 1 : A) - E 0 * (W 0 : A) := by |
| rw [mul_sub, ← mul_assoc, hE1, hE0] |
| rw [← heq, CStarRing.norm_mem_unitary_mul _ (hEu 1)] at hm |
| simpa using hm |
|
|
| end |
|
|
| namespace UnitaryEvaluation |
| variable {A : Type uA} [CStarAlgebra A] {ι : Type uι} [Fintype ι] [DecidableEq ι] |
|
|
| omit [Fintype ι] [DecidableEq ι] in |
| theorem hamiltonianLinear_norm_map (Φ : A ≃⋆ₐ[ℂ] A) |
| (S : A) (hS : Φ S = S) (U V : ι → unitary A) |
| (hUV : ∀ g, Φ (wordHom U g) = wordHom V g) (k : FreeGroup ι →₀ ℝ) : |
| ‖hamiltonianLinear S V k‖ = ‖hamiltonianLinear S U k‖ := by |
| have he := FreeGroupFactorMain.hamiltonianLinear_map Φ S U V hUV k |
| rw [hS] at he |
| rw [← he, StarAlgEquiv.norm_map] |
|
|
| omit [Fintype ι] in |
| theorem generator_displacement (S : A) (h : ι → FreeGroup ι →₀ ℝ) |
| (U : ℝ → ι → unitary A) |
| (hU : ∀ t, HasDerivAt (fun t j => (U t j : A)) |
| (PolynomialFlow.field S h (fun j => (U t j : A))) t) |
| (B : ι → ℝ) (hb : ∀ t j, ‖hamiltonianLinear S (U t) (h j)‖ ≤ B j) (j : ι) : |
| ‖(U 1 j : A) - (U 0 j : A)‖ ≤ B j := by |
| have hd := unitary_curve_displacement (0 : A) (by simp) |
| (fun t => U t j) (fun t => hamiltonianLinear S (U t) (h j)) |
| (fun t => by |
| simpa only [hamiltonianLinear_eq, PolynomialFlow.field] using |
| (hasDerivAt_pi.mp (hU t) j)) |
| (B j) (fun t _ => by simpa only [sub_zero] using hb t j) |
| simpa only [smul_zero, NormedSpace.exp_zero, one_mul] using hd |
|
|
| theorem word_displacement (S : A) (hS : IsSelfAdjoint S) |
| (h : ι → FreeGroup ι →₀ ℝ) (U : ℝ → ι → unitary A) |
| (hU : ∀ t, HasDerivAt (fun t j => (U t j : A)) |
| (PolynomialFlow.field S h (fun j => (U t j : A))) t) |
| (w : FreeGroup ι) (B : ℝ) |
| (hb : ∀ t, ‖hamiltonianLinear S (U t) (freeCocycle h w - Finsupp.single 1 1)‖ ≤ B) : |
| ‖wordHom (U 1) w - NormedSpace.exp (Complex.I • S) * wordHom (U 0) w‖ ≤ B := by |
| apply unitary_curve_displacement S hS (fun t => FreeGroup.lift (U t) w) |
| (fun t => hamiltonianLinear S (U t) (freeCocycle h w)) |
| (fun t => hasDerivAt_wordHom_cocycle S hS h U hU w t) |
| intro t _ht |
| simpa only [map_sub, FreeGroupFactorMain.hamiltonianLinear_single_one] using hb t |
|
|
| end UnitaryEvaluation |
|
|
| section |
| open UnitaryEvaluation |
|
|
| variable {ι : Type uι} [Fintype ι] [DecidableEq ι] |
|
|
| omit [Fintype ι] [DecidableEq ι] in |
| theorem wordHom_extend_none_zpow {A : Type uA} [CStarAlgebra A] |
| (U : ι → unitary A) (C : unitary A) (m : ℤ) : |
| wordHom (extendUnitary U C) (FreeGroup.of none ^ m) = ((C^m : unitary A) : A) := by |
| change ((FreeGroup.lift (extendUnitary U C) (FreeGroup.of none ^ m) : unitary A) : A) = _ |
| simp only [map_zpow, FreeGroup.lift_apply_of, extendUnitary, Option.elim_none] |
|
|
| omit [Fintype ι] [DecidableEq ι] in |
| theorem flow_iso_fix_laurent (l : ℤ →₀ ℂ) |
| (U : ι → unitary (groupVonNeumann (FreeGroup (Option ι)))) |
| (Φ : groupVonNeumann (FreeGroup (Option ι)) ≃⋆ₐ[ℂ] groupVonNeumann (FreeGroup (Option ι))) |
| (hΦ : ∀ g, Φ (groupUnitary g) = wordHom (extendUnitary U (generatorUnitary (none : Option ι))) g) : |
| Φ (laurentValue (generatorUnitary (none : Option ι)) l) = |
| laurentValue (generatorUnitary (none : Option ι)) l := by |
| classical |
| conv_lhs => rw [laurentValue_group] |
| simp only [groupLaurent, Finsupp.sum, map_sum, map_smul, hΦ, wordHom_extend_none_zpow] |
| rfl |
|
|
| omit [Fintype ι] in |
| theorem flow_iso_hamiltonian_bound (l : ℤ →₀ ℂ) (h0 : l 0 = 0) |
| (hS : IsSelfAdjoint (laurentValue (generatorUnitary (none : Option ι)) l)) |
| (K : ℝ) (hK : 0 ≤ K) (hn : ‖laurentValue (generatorUnitary (none : Option ι)) l‖ ≤ K) |
| (U : ι → unitary (groupVonNeumann (FreeGroup (Option ι)))) |
| (Φ : groupVonNeumann (FreeGroup (Option ι)) ≃⋆ₐ[ℂ] groupVonNeumann (FreeGroup (Option ι))) |
| (hΦ : ∀ g, Φ (groupUnitary g) = wordHom (extendUnitary U (generatorUnitary (none : Option ι))) g) |
| (k : FreeGroup ι →₀ ℝ) : |
| ‖hamiltonianLinear (laurentValue (generatorUnitary (none : Option ι)) l) U k‖ ≤ |
| 3*K*Real.sqrt (k.sum (fun _ r => r^2)) := by |
| have hword (g : FreeGroup ι) : |
| Φ (wordHom (fun j => generatorUnitary (some j)) g) = wordHom U g := by |
| rw [wordHom_original, hΦ, wordHom_extend] |
| rw [hamiltonianLinear_norm_map Φ |
| (laurentValue (generatorUnitary (none : Option ι)) l) |
| (flow_iso_fix_laurent l U Φ hΦ) (fun j => generatorUnitary (some j)) U hword k] |
| exact hamiltonianLinear_original_bound l h0 hS K hK hn k |
|
|
| theorem laurent_bounded_flow |
| (h : ι → FreeGroup ι →₀ ℝ) (l : ℤ →₀ ℂ) (h0 : l 0 = 0) |
| (hS : IsSelfAdjoint (laurentValue (generatorUnitary (none : Option ι)) l)) |
| (K : ℝ) (hK : 0 ≤ K) (hn : ‖laurentValue (generatorUnitary (none : Option ι)) l‖ ≤ K) : |
| ∃ U : ℝ → ι → unitary (groupVonNeumann (FreeGroup (Option ι))), |
| U 0 = (fun j => generatorUnitary (some j)) ∧ |
| (∀ t, HasDerivAt (fun t j => (U t j : groupVonNeumann (FreeGroup (Option ι)))) |
| (PolynomialFlow.field (laurentValue (generatorUnitary (none : Option ι)) l) h |
| (fun j => (U t j : groupVonNeumann (FreeGroup (Option ι))))) t) ∧ |
| (∀ t k, ‖hamiltonianLinear (laurentValue (generatorUnitary (none : Option ι)) l) (U t) k‖ ≤ |
| 3*K*Real.sqrt (k.sum (fun _ r => r^2))) ∧ |
| ∃ β : groupVonNeumann (FreeGroup (Option ι)) ≃⋆ₐ[ℂ] groupVonNeumann (FreeGroup (Option ι)), |
| (∀ T, canonicalTrace (β T) = canonicalTrace T) ∧ |
| @Continuous _ _ (groupUltraweakTopology (FreeGroup (Option ι))) |
| (groupUltraweakTopology (FreeGroup (Option ι))) β ∧ |
| ∀ g, β (groupUnitary g) = wordHom (extendUnitary (U 1) (generatorUnitary (none : Option ι))) g := by |
| classical |
| obtain ⟨X,hU,hX₀,hX,hiso⟩ := laurent_flow_automorphisms h l hS |
| let U (t : ℝ) : ι → unitary (groupVonNeumann (FreeGroup (Option ι))) := fun j => ⟨X t j, hU t j⟩ |
| refine ⟨U,?_,hX,?_,hiso 1⟩ |
| · funext j |
| exact Subtype.ext (congrFun hX₀ j) |
| · intro t k |
| obtain ⟨Φ,_ht,_hc,hΦ⟩ := hiso t |
| exact flow_iso_hamiltonian_bound l h0 hS K hK hn (U t) Φ hΦ k |
|
|
| theorem flow_displacements_from_bounds |
| (h : ι → FreeGroup ι →₀ ℝ) (l : ℤ →₀ ℂ) |
| (hS : IsSelfAdjoint (laurentValue (generatorUnitary (none : Option ι)) l)) (K : ℝ) |
| (U : ℝ → ι → unitary (groupVonNeumann (FreeGroup (Option ι)))) |
| (hU₀ : U 0 = fun j => generatorUnitary (some j)) |
| (hX : ∀ t, HasDerivAt (fun t j => (U t j : groupVonNeumann (FreeGroup (Option ι)))) |
| (PolynomialFlow.field (laurentValue (generatorUnitary (none : Option ι)) l) h |
| (fun j => (U t j : groupVonNeumann (FreeGroup (Option ι))))) t) |
| (hbound : ∀ t k, ‖hamiltonianLinear (laurentValue (generatorUnitary (none : Option ι)) l) (U t) k‖ ≤ |
| 3*K*Real.sqrt (k.sum (fun _ r => r^2))) : |
| (∀ j, ‖(U 1 j : groupVonNeumann (FreeGroup (Option ι))) - groupUnitary (FreeGroup.of (some j))‖ ≤ |
| 3*K*Real.sqrt ((h j).sum (fun _ r => r^2))) ∧ |
| ∀ w : FreeGroup ι, ‖wordHom (U 1) w - NormedSpace.exp (Complex.I • laurentValue (generatorUnitary (none : Option ι)) l) * |
| groupUnitary (FreeGroup.map Option.some w)‖ ≤ |
| 3*K*Real.sqrt ((freeCocycle h w - Finsupp.single 1 1).sum (fun _ r => r^2)) := by |
| constructor |
| · intro j |
| have hd := generator_displacement (laurentValue (generatorUnitary (none : Option ι)) l) h U hX |
| (fun j => 3*K*Real.sqrt ((h j).sum (fun _ r => r^2))) |
| (fun t j => hbound t (h j)) j |
| rw [hU₀] at hd |
| exact hd |
| · intro w |
| have hd := word_displacement (laurentValue (generatorUnitary (none : Option ι)) l) hS h U hX w |
| (3*K*Real.sqrt ((freeCocycle h w - Finsupp.single 1 1).sum (fun _ r => r^2))) |
| (fun t => hbound t (freeCocycle h w - Finsupp.single 1 1)) |
| rwa [hU₀, wordHom_original] at hd |
|
|
| theorem laurent_flow_displacement |
| (h : ι → FreeGroup ι →₀ ℝ) (l : ℤ →₀ ℂ) (h0 : l 0 = 0) |
| (hS : IsSelfAdjoint (laurentValue (generatorUnitary (none : Option ι)) l)) |
| (K : ℝ) (hK : 0 ≤ K) (hn : ‖laurentValue (generatorUnitary (none : Option ι)) l‖ ≤ K) : |
| ∃ β : groupVonNeumann (FreeGroup (Option ι)) ≃⋆ₐ[ℂ] groupVonNeumann (FreeGroup (Option ι)), |
| (∀ T, canonicalTrace (β T) = canonicalTrace T) ∧ |
| @Continuous _ _ (groupUltraweakTopology (FreeGroup (Option ι))) |
| (groupUltraweakTopology (FreeGroup (Option ι))) β ∧ |
| β (groupUnitary (FreeGroup.of none)) = groupUnitary (FreeGroup.of none) ∧ |
| (∀ j : ι, ‖β (groupUnitary (FreeGroup.of (some j))) - groupUnitary (FreeGroup.of (some j))‖ ≤ |
| 3*K*Real.sqrt ((h j).sum (fun _ r => r^2))) ∧ |
| ∀ w : FreeGroup ι, ‖β (groupUnitary (FreeGroup.map Option.some w)) - |
| NormedSpace.exp (Complex.I • laurentValue (generatorUnitary (none : Option ι)) l) * |
| groupUnitary (FreeGroup.map Option.some w)‖ ≤ |
| 3*K*Real.sqrt ((freeCocycle h w - Finsupp.single 1 1).sum (fun _ r => r^2)) := by |
| classical |
| obtain ⟨U,hU₀,hX,hbound,β,hβt,hβc,hβ⟩ := laurent_bounded_flow (ι := ι) h l h0 hS K hK hn |
| obtain ⟨hgen,hword⟩ := flow_displacements_from_bounds (ι := ι) h l hS K U hU₀ hX hbound |
| refine ⟨β,hβt,hβc,?_,?_,?_⟩ |
| · exact (hβ (FreeGroup.of (none : Option ι))).trans (wordHom_of _ _) |
| · intro j |
| rw [hβ] |
| simpa only [wordHom_of, extendUnitary, Option.elim_some] using hgen j |
| · intro w |
| rw [hβ] |
| simpa only [wordHom_extend] using hword w |
|
|
| end |
|
|
| def groupL2 {G : Type uG} [Group G] : groupVonNeumann G →L[ℂ] GroupHilbert G := |
| ({ toFun := fun T => (T : GroupOperator G) deltaOne |
| map_add' := by intros; rfl |
| map_smul' := by intros; rfl } : groupVonNeumann G →ₗ[ℂ] GroupHilbert G).mkContinuous 1 (by |
| intro T |
| calc |
| ‖(T : GroupOperator G) deltaOne‖ ≤ ‖T‖ * ‖(deltaOne : GroupHilbert G)‖ := |
| ContinuousLinearMap.le_opNorm _ _ |
| _ = 1 * ‖T‖ := by simp [deltaOne, lp.norm_single]) |
|
|
| abbrev twoNorm {G : Type uG} [Group G] (T : groupVonNeumann G) : ℝ := ‖groupL2 T‖ |
|
|
| @[simp] theorem groupL2_apply {G : Type uG} [Group G] (T : groupVonNeumann G) : |
| groupL2 T = (T : GroupOperator G) deltaOne := rfl |
|
|
| theorem twoNorm_le_norm {G : Type uG} [Group G] (T : groupVonNeumann G) : |
| twoNorm T ≤ ‖T‖ := by |
| calc |
| _ ≤ ‖(T : GroupOperator G)‖ * ‖(deltaOne : GroupHilbert G)‖ := |
| ContinuousLinearMap.le_opNorm _ _ |
| _ = _ := by simp [deltaOne, lp.norm_single] |
|
|
| theorem twoNorm_sq {G : Type uG} [Group G] (T : groupVonNeumann G) : |
| (twoNorm T : ℂ)^2 = canonicalTrace (star T*T) := by |
| classical |
| rw [canonicalTrace_star_mul, ← deltaOne_eq] |
| rfl |
|
|
| theorem twoNorm_star {G : Type uG} [Group G] (T : groupVonNeumann G) : |
| twoNorm (star T) = twoNorm T := by |
| classical |
| have hsq : (twoNorm (star T) : ℂ)^2 = (twoNorm T : ℂ)^2 := by |
| rw [twoNorm_sq, twoNorm_sq, star_star] |
| exact canonicalTrace_mul T (star T) |
| have hr := congrArg Complex.re hsq |
| norm_cast at hr |
| nlinarith [norm_nonneg (groupL2 (star T)), norm_nonneg (groupL2 T)] |
|
|
| theorem twoNorm_mul_unitary_left {G : Type uG} [Group G] |
| (U : unitary (groupVonNeumann G)) (T : groupVonNeumann G) : |
| twoNorm ((U : groupVonNeumann G)*T) = twoNorm T := by |
| apply ContinuousLinearMap.norm_map_of_mem_unitary |
| exact ⟨congrArg Subtype.val U.property.1, congrArg Subtype.val U.property.2⟩ |
|
|
| theorem twoNorm_mul_unitary_right {G : Type uG} [Group G] |
| (U : unitary (groupVonNeumann G)) (T : groupVonNeumann G) : |
| twoNorm (T*(U : groupVonNeumann G)) = twoNorm T := by |
| rw [← twoNorm_star, star_mul] |
| change twoNorm (((star U : unitary (groupVonNeumann G)) : groupVonNeumann G) * star T) = _ |
| rw [twoNorm_mul_unitary_left, twoNorm_star] |
|
|
| theorem twoNorm_iso {G : Type uG} {H : Type uH} [Group G] [Group H] |
| (Φ : groupVonNeumann G ≃⋆ₐ[ℂ] groupVonNeumann H) |
| (hΦ : ∀ T, canonicalTrace (Φ T) = canonicalTrace T) (T : groupVonNeumann G) : |
| twoNorm (Φ T) = twoNorm T := by |
| have hs : Φ (star T) = star (Φ T) := Φ.map_star' T |
| have hm : Φ (star T * T) = Φ (star T) * Φ T := Φ.map_mul' (star T) T |
| have hsq : (twoNorm (Φ T) : ℂ)^2 = (twoNorm T : ℂ)^2 := by |
| rw [twoNorm_sq, twoNorm_sq, ← hs, ← hm, hΦ] |
| have hr := congrArg Complex.re hsq |
| norm_cast at hr |
| nlinarith [norm_nonneg (groupL2 (Φ T)), norm_nonneg (groupL2 T)] |
|
|
| theorem canonicalTrace_star {G : Type uG} [Group G] (T : groupVonNeumann G) : |
| canonicalTrace (star T) = star (canonicalTrace T) := by |
| classical |
| have hh := groupVN_star_coefficient T 1 |
| change ((star T : GroupOperator G) (lp.single 2 1 1)) 1 = |
| (starRingEnd ℂ) (((T : GroupOperator G) (lp.single 2 1 1)) 1) |
| simpa only [deltaOne_eq, inv_one] using hh |
|
|
| end |
|
|
| end FreeGroupFactorMain |
|
|
| end OAI |
|
|
