math / data /lean /OAI /Analysis /FactorGeneration /HaarPatches.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
16.8 kB
import OAI.Analysis.FactorGeneration.LocalPatches
namespace OAI
noncomputable section
namespace Generator.Tracial
/-! The same ordered signed words in any star algebra, with exact transport
through bounded sequence evaluation and the actual quotient homomorphism. -/
section
open UltrapowerBridge
def algebraSignedLetter {A : Type*} [Star A] (v : A) (s : Bool) : A :=
if s then star v else v
def algebraPatchingWord {A : Type*} [Monoid A] [Star A] (v : A) :
List (Bool Γ— A) β†’ A
| [] => 1
| (s,x)::xs => algebraSignedLetter v s*x*algebraPatchingWord v xs
def optionalCoefficient {A : Type*} [One A] (x : β„• β†’ A) : Option β„• β†’ A
| none => 1
| some i => x i
theorem map_algebraPatchingWord {A B : Type*} [Ring A] [Ring B]
[StarRing A] [StarRing B] [Algebra β„‚ A] [Algebra β„‚ B]
(f : A →⋆ₐ[β„‚] B) (v : A) (xs : List (Bool Γ— A)) :
f (algebraPatchingWord v xs) =
algebraPatchingWord (f v) (xs.map (fun a => (a.1,f a.2))) := by
induction xs with
| nil => exact f.map_one
| cons a xs ih =>
simp only [algebraPatchingWord,List.map_cons,map_mul,ih]
congr 2
cases a.1
Β· rfl
Β· exact map_star f v
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {M : VonNeumannAlgebra H}
theorem algebraPatchingWord_eq (v : M.toStarSubalgebra)
(xs : List (Bool Γ— M.toStarSubalgebra)) :
algebraPatchingWord v xs = patchingWord v xs := by
induction xs with
| nil => rfl
| cons a xs ih => simp only [algebraPatchingWord,patchingWord,ih,algebraSignedLetter,signedLetter]
def boundedEvaluation (j : β„•) : Bounded M →⋆ₐ[β„‚] M.toStarSubalgebra where
toFun a := a.val j
map_one' := rfl
map_mul' _ _ := rfl
map_zero' := rfl
map_add' _ _ := rfl
commutes' _ := rfl
map_star' _ := rfl
theorem bounded_word_evaluation (v : Bounded M) (xs : List (Bool Γ— Bounded M)) (j : β„•) :
(algebraPatchingWord v xs).val j =
patchingWord (v.val j) (xs.map (fun a => (a.1,a.2.val j))) := by
induction xs with
| nil => rfl
| cons a xs ih =>
change (algebraSignedLetter v a.1).val j * a.2.val j *
(algebraPatchingWord v xs).val j = _
rw [ih]
simp only [List.map_cons,patchingWord]
cases a.1 <;> rfl
end
/-! The finite-error f=1 conclusion of Popa Lemma 3.2, for the irreducible
scalar-commutant inclusion with the explicit represented-factor hypotheses. -/
section
open UltrapowerBridge
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (Ο„ : TracialRepresentation M)
theorem patchingTolerance_scale (Ξ΄ : ℝ) (k : β„•) :
patchingTolerance Ξ΄ k=Ξ΄*patchingTolerance 1 k := by
induction k with
| zero => simp
| succ k ih => rw [patchingTolerance_succ,patchingTolerance_succ,ih]; ring
def diagonalCoefficientFamily (x : β„• β†’ β„• β†’ M.toStarSubalgebra) (j : β„•) : Finset M.toStarSubalgebra := by
classical
exact (Finset.range (j+1)).image (fun i => x i j)
variable (hNM : N ≀ M)
variable (hfactor : βˆ€ c : N.toStarSubalgebra,
(βˆ€ a : N.toStarSubalgebra,a*c=c*a) β†’ βˆƒ z : β„‚,c=z β€’ (1 : N.toStarSubalgebra))
variable (hdiff : βˆ€ p : N.toStarSubalgebra,IsStarProjection p β†’ p β‰  0 β†’
βˆƒ q : N.toStarSubalgebra,IsStarProjection q ∧ q β‰  0 ∧ q β‰  p ∧ p*q=q ∧ q*p=q)
variable (hirr : βˆ€ c : M.toStarSubalgebra,
(βˆ€ a : N.toStarSubalgebra,coordinateInclusion hNM a*c=c*coordinateInclusion hNM a) β†’
βˆƒ z : β„‚,c=z β€’ (1 : M.toStarSubalgebra))
variable (hsep : TopologicalSpace.IsSeparable (Set.range (baseVector Ο„)))
include hfactor hdiff hirr hsep
theorem exists_finite_partial_independence
(F : Finset M.toStarSubalgebra) (hF : βˆ€ x ∈ F,β€–xβ€– ≀ 1)
(hcenter : βˆ€ x ∈ F,Ο„.trace x=0) (n : β„•) (Ξ΅ : ℝ) (hΞ΅ : 0 < Ξ΅) :
βˆƒ v : PartialUnitary M,v.val.val ∈ N ∧ 1/4 < (Ο„.trace v.support.val).re ∧
βˆ€ xβ‚€ ∈ (F : Set M.toStarSubalgebra) βˆͺ {1},βˆ€ xs : List (Bool Γ— M.toStarSubalgebra),
1 ≀ xs.length β†’ xs.length ≀ n β†’ patchingCoefficients (F : Set M.toStarSubalgebra) xs β†’
β€–Ο„.trace (xβ‚€*patchingWord v.val xs)β€– ≀ Ξ΅ := by
let Ξ΄ := Ξ΅/patchingTolerance 1 n
have ht := patchingTolerance_pos 1 (by norm_num) n
have hΞ΄ : 0 < Ξ΄ := div_pos hΞ΅ ht
obtain ⟨v,hv,hs⟩ := exists_large_admissible_partialUnitary Ο„ hNM hfactor hdiff hirr hsep
F hF hcenter n Ξ΄ hΞ΄
have he : patchingTolerance Ξ΄ n=Ξ΅ := by
rw [patchingTolerance_scale]
exact div_mul_cancelβ‚€ Ξ΅ ht.ne'
refine ⟨v,hv.2,hs,?_⟩
intro xβ‚€ hxβ‚€ xs hpos hn hc
have hh := hv.1.2 xβ‚€ hxβ‚€ xs hpos hn hc
have hmono := patchingTolerance_mono Ξ΄ hΞ΄ hn
rw [he] at hmono
exact hh.trans ((mul_le_of_le_one_right (patchingTolerance_pos Ξ΄ hΞ΄ xs.length).le
(PartialUnitary.support_trace_le_one Ο„ v)).trans hmono)
/-- A genuine diagonal sequence for a countable family of varying centered
contractions; the coefficient at stage j may depend on j. This is still a
partial-unitary construction, not a full free Haar unitary. -/
theorem exists_diagonal_partial_independence
(x : β„• β†’ β„• β†’ M.toStarSubalgebra) (hx : βˆ€ i j,β€–x i jβ€– ≀ 1)
(hc : βˆ€ i j,Ο„.trace (x i j)=0) :
βˆƒ v : β„• β†’ PartialUnitary M,βˆ€ j,
(v j).val.val ∈ N ∧ 1/4 < (Ο„.trace (v j).support.val).re ∧
βˆ€ a ∈ (diagonalCoefficientFamily x j : Set M.toStarSubalgebra) βˆͺ {1},
βˆ€ xs : List (Bool Γ— M.toStarSubalgebra),
1 ≀ xs.length β†’ xs.length ≀ j+1 β†’
patchingCoefficients (diagonalCoefficientFamily x j : Set M.toStarSubalgebra) xs β†’
β€–Ο„.trace (a*patchingWord (v j).val xs)β€– ≀ 1/((j : ℝ)+1) := by
classical
have hstage : βˆ€ j,βˆƒ v : PartialUnitary M,v.val.val ∈ N ∧ 1/4 < (Ο„.trace v.support.val).re ∧
βˆ€ a ∈ (diagonalCoefficientFamily x j : Set M.toStarSubalgebra) βˆͺ {1},
βˆ€ xs : List (Bool Γ— M.toStarSubalgebra),
1 ≀ xs.length β†’ xs.length ≀ j+1 β†’
patchingCoefficients (diagonalCoefficientFamily x j : Set M.toStarSubalgebra) xs β†’
β€–Ο„.trace (a*patchingWord v.val xs)β€– ≀ 1/((j : ℝ)+1) := by
intro j
apply exists_finite_partial_independence Ο„ hNM hfactor hdiff hirr hsep
(diagonalCoefficientFamily x j) ?_ ?_ (j+1) _ (by positivity)
Β· intro a ha
obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp ha
exact hx i j
Β· intro a ha
obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp ha
exact hc i j
choose v hv using hstage
exact ⟨v,hv⟩
end
/-! A countable diagonal construction with actual vanishing ordered moments.
The countable coefficients may vary with the sequence coordinate. -/
open Filter
open scoped Topology
section
open UltrapowerBridge
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (Ο„ : TracialRepresentation M)
def indexedCoefficient (x : β„• β†’ β„• β†’ M.toStarSubalgebra) (j : β„•) :
Option β„• β†’ M.toStarSubalgebra
| none => 1
| some i => x i j
theorem eventually_list_indices (is : List β„•) : βˆ€αΆ  j : β„• in atTop,βˆ€ i ∈ is,i ≀ j := by
induction is with
| nil => exact Eventually.of_forall (fun _ => by simp)
| cons i is ih =>
filter_upwards [ih,eventually_ge_atTop i] with j hj hi
intro a ha
rcases List.mem_cons.mp ha with rfl | ha
Β· exact hi
Β· exact hj a ha
theorem eventually_indexedCoefficient (x : β„• β†’ β„• β†’ M.toStarSubalgebra) (i : Option β„•) :
βˆ€αΆ  j : β„• in atTop,indexedCoefficient x j i ∈
(diagonalCoefficientFamily x j : Set M.toStarSubalgebra) βˆͺ {1} := by
classical
cases i with
| none => exact Eventually.of_forall (fun _ => Or.inr rfl)
| some i =>
filter_upwards [eventually_ge_atTop i] with j hj
exact Or.inl (Finset.mem_image.mpr ⟨i,Finset.mem_range.mpr (by omega),rfl⟩)
variable (hNM : N ≀ M)
variable (hfactor : βˆ€ c : N.toStarSubalgebra,
(βˆ€ a : N.toStarSubalgebra,a*c=c*a) β†’ βˆƒ z : β„‚,c=z β€’ (1 : N.toStarSubalgebra))
variable (hdiff : βˆ€ p : N.toStarSubalgebra,IsStarProjection p β†’ p β‰  0 β†’
βˆƒ q : N.toStarSubalgebra,IsStarProjection q ∧ q β‰  0 ∧ q β‰  p ∧ p*q=q ∧ q*p=q)
variable (hirr : βˆ€ c : M.toStarSubalgebra,
(βˆ€ a : N.toStarSubalgebra,coordinateInclusion hNM a*c=c*coordinateInclusion hNM a) β†’
βˆƒ z : β„‚,c=z β€’ (1 : M.toStarSubalgebra))
variable (hsep : TopologicalSpace.IsSeparable (Set.range (baseVector Ο„)))
include hfactor hdiff hirr hsep
/-- Every nonempty source word is encoded by its internal index list, final
sign and two optional endpoint indices. None represents exactly the unit. -/
theorem exists_countable_partial_independence
(x : β„• β†’ β„• β†’ M.toStarSubalgebra) (hx : βˆ€ i j,β€–x i jβ€– ≀ 1)
(hc : βˆ€ i j,Ο„.trace (x i j)=0) :
βˆƒ v : β„• β†’ PartialUnitary M,
(βˆ€ j,(v j).val.val ∈ N) ∧ (βˆ€ j,1/4 < (Ο„.trace (v j).support.val).re) ∧
βˆ€ first last : Option β„•,βˆ€ xs : List (Bool Γ— β„•),βˆ€ s : Bool,
Tendsto (fun j => Ο„.trace (indexedCoefficient x j first * patchingWord (v j).val
(xs.map (fun a => (a.1,x a.2 j)) ++ [(s,indexedCoefficient x j last)]))) atTop (𝓝 0) := by
classical
obtain ⟨v,hv⟩ := exists_diagonal_partial_independence Ο„ hNM hfactor hdiff hirr hsep x hx hc
refine ⟨v,fun j => (hv j).1,fun j => (hv j).2.1,?_⟩
intro first last xs s
apply tendsto_iff_norm_sub_tendsto_zero.mpr
simp only [sub_zero]
apply squeeze_zero' (Eventually.of_forall (fun _ => norm_nonneg _)) ?_
tendsto_one_div_add_atTop_nhds_zero_nat
filter_upwards [eventually_list_indices (xs.map Prod.snd),eventually_ge_atTop xs.length,
eventually_indexedCoefficient x first,eventually_indexedCoefficient x last] with j hj hlen hfirst hlast
apply (hv j).2.2 _ hfirst _ (by simp) (by simpa using Nat.add_le_add_right hlen 1)
apply patchingCoefficients_append_endpoint _ _ ?_ (s,indexedCoefficient x j last) hlast
intro a ha
obtain ⟨b,hb,rfl⟩ := List.mem_map.mp ha
exact Finset.mem_image.mpr ⟨b.2,Finset.mem_range.mpr (by
have hh := hj b.2 (List.mem_map.mpr ⟨b,hb,rfl⟩)
omega),rfl⟩
end
/-! Actual positive-support partial independence in the bounded-sequence
tracial quotient. Freeness is expressed by domination of atTop. -/
open Filter
open scoped Topology
section
open UltrapowerBridge
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (Ο„ : TracialRepresentation M)
def boundedPartialUnitary (v : β„• β†’ PartialUnitary M) : Bounded M :=
⟨fun j => (v j).val,1,zero_le_one,fun j => (v j).unitary.norm_le_one⟩
def boundedPartialSupport (v : β„• β†’ PartialUnitary M) : Bounded M :=
⟨fun j => (v j).support.val,1,zero_le_one,fun j => (v j).support.property.norm_le⟩
theorem boundedPartialSupport_projection (v : β„• β†’ PartialUnitary M) :
IsStarProjection (boundedPartialSupport v) := by
constructor
Β· apply Subtype.ext
funext j
exact (v j).support.property.isIdempotentElem
Β· apply Subtype.ext
funext j
exact (v j).support.property.isSelfAdjoint
theorem boundedPartialUnitary_initial (v : β„• β†’ PartialUnitary M) :
star (boundedPartialUnitary v)*boundedPartialUnitary v = boundedPartialSupport v := by
apply Subtype.ext
funext j
exact (v j).unitary.initial
theorem boundedPartialUnitary_final (v : β„• β†’ PartialUnitary M) :
boundedPartialUnitary v*star (boundedPartialUnitary v) = boundedPartialSupport v := by
apply Subtype.ext
funext j
exact (v j).unitary.final
theorem boundedPartialUnitary_inclusion (hNM : N ≀ M)
(v : β„• β†’ PartialUnitary M) (hv : βˆ€ j,(v j).val.val ∈ N) :
βˆƒ w : Bounded N,boundedInclusion hNM w = boundedPartialUnitary v := by
refine ⟨⟨fun j => ⟨(v j).val.val,hv j⟩,1,zero_le_one,
fun j => (v j).unitary.norm_le_one⟩,?_⟩
rfl
theorem quotient_ordered_moment_zero (Ο‰ : Ultrafilter β„•) (hΟ‰ : (Ο‰ : Filter β„•) ≀ atTop)
(v : β„• β†’ PartialUnitary M) (x : β„• β†’ Bounded M)
(first last : Option β„•) (xs : List (Bool Γ— β„•)) (s : Bool)
(hz : Tendsto (fun j => Ο„.trace (indexedCoefficient (fun i => (x i).val) j first *
patchingWord (v j).val (xs.map (fun a => (a.1,(x a.2).val j)) ++
[(s,indexedCoefficient (fun i => (x i).val) j last)]))) atTop (𝓝 0)) :
quotientTrace Ο„ Ο‰ (optionalCoefficient (fun i => quotientMap Ο„ (Ο‰ : Filter β„•) (x i)) first *
algebraPatchingWord (quotientMap Ο„ (Ο‰ : Filter β„•) (boundedPartialUnitary v))
(xs.map (fun a => (a.1,quotientMap Ο„ (Ο‰ : Filter β„•) (x a.2))) ++
[(s,optionalCoefficient (fun i => quotientMap Ο„ (Ο‰ : Filter β„•) (x i)) last)])) = 0 := by
let f := quotientStarAlgHom Ο„ (Ο‰ : Filter β„•)
let b : Bounded M := optionalCoefficient x first * algebraPatchingWord (boundedPartialUnitary v)
(xs.map (fun a => (a.1,x a.2)) ++ [(s,optionalCoefficient x last)])
have hopt (i : Option β„•) : f (optionalCoefficient x i) =
optionalCoefficient (fun i => f (x i)) i := by cases i <;> simp [optionalCoefficient]
have hb : f b = optionalCoefficient (fun i => f (x i)) first *
algebraPatchingWord (f (boundedPartialUnitary v))
(xs.map (fun a => (a.1,f (x a.2))) ++ [(s,optionalCoefficient (fun i => f (x i)) last)]) := by
simp only [b,map_mul,map_algebraPatchingWord,hopt,List.map_append,List.map_cons,List.map_nil,
List.map_map,Function.comp_def]
change quotientTrace Ο„ Ο‰ (optionalCoefficient (fun i => f (x i)) first *
algebraPatchingWord (f (boundedPartialUnitary v))
(xs.map (fun a => (a.1,f (x a.2))) ++ [(s,optionalCoefficient (fun i => f (x i)) last)])) = 0
rw [← hb]
apply tendsto_nhds_unique (traceRep_tendsto Ο„ Ο‰ b)
have he (j : β„•) : b.val j = indexedCoefficient (fun i => (x i).val) j first *
patchingWord (v j).val (xs.map (fun a => (a.1,(x a.2).val j)) ++
[(s,indexedCoefficient (fun i => (x i).val) j last)]) := by
change (optionalCoefficient x first).val j * _ = _
rw [bounded_word_evaluation]
have ho (i : Option β„•) : (optionalCoefficient x i).val j =
indexedCoefficient (fun i => (x i).val) j i := by cases i <;> rfl
simp only [ho,List.map_append,List.map_cons,List.map_nil,List.map_map,Function.comp_def]
rfl
simpa only [he] using hz.mono_left hω
end
/-! Exact multilinearity factors for ordered words; no factors are inverted
and signs affect only the partial-unitary letters. -/
theorem algebraPatchingWord_scale {A I : Type*} [Ring A] [Star A] [Algebra β„‚ A]
(v : A) (x y : I β†’ A) (c : I β†’ β„‚) (h : βˆ€ i,x i=c i β€’ y i)
(xs : List (Bool Γ— I)) :
algebraPatchingWord v (xs.map (fun a => (a.1,x a.2))) =
(xs.map (fun a => c a.2)).prod β€’
algebraPatchingWord v (xs.map (fun a => (a.1,y a.2))) := by
induction xs with
| nil => simp [algebraPatchingWord]
| cons a xs ih =>
simp only [List.map_cons,algebraPatchingWord,ih,List.prod_cons]
rw [h a.2]
simp only [
mul_smul_comm,smul_mul_assoc,smul_smul,mul_comm (c a.2)]
theorem optionalCoefficient_scale {A : Type*} [Ring A] [Algebra β„‚ A]
(x y : β„• β†’ A) (c : β„• β†’ β„‚) (h : βˆ€ i,x i=c i β€’ y i) (i : Option β„•) :
optionalCoefficient x i=optionalCoefficient c i β€’ optionalCoefficient y i := by
cases i <;> simp [optionalCoefficient,h]
theorem ordered_moment_scale {A : Type*} [Ring A] [Star A] [Algebra β„‚ A]
(v : A) (x y : β„• β†’ A) (c : β„• β†’ β„‚) (h : βˆ€ i,x i=c i β€’ y i)
(first last : Option β„•) (xs : List (Bool Γ— β„•)) (s : Bool) :
optionalCoefficient x first *
algebraPatchingWord v (xs.map (fun a => (a.1,x a.2)) ++ [(s,optionalCoefficient x last)]) =
(optionalCoefficient c first * ((xs.map (fun a => c a.2)).prod * optionalCoefficient c last)) β€’
(optionalCoefficient y first *
algebraPatchingWord v (xs.map (fun a => (a.1,y a.2)) ++ [(s,optionalCoefficient y last)])) := by
have hw := algebraPatchingWord_scale v (optionalCoefficient x) (optionalCoefficient y)
(optionalCoefficient c) (optionalCoefficient_scale x y c h)
(xs.map (fun a => (a.1,some a.2)) ++ [(s,last)])
simp only [List.map_append,List.map_cons,List.map_nil,List.map_map,Function.comp_def,
optionalCoefficient,List.prod_append,List.prod_cons,List.prod_nil,mul_one] at hw
change algebraPatchingWord v (xs.map (fun a => (a.1,x a.2)) ++ [(s,optionalCoefficient x last)]) =
((xs.map (fun a => c a.2)).prod * optionalCoefficient c last) β€’
algebraPatchingWord v (xs.map (fun a => (a.1,y a.2)) ++ [(s,optionalCoefficient y last)]) at hw
rw [hw,optionalCoefficient_scale x y c h first,smul_mul_assoc,mul_smul_comm,smul_smul]
end Generator.Tracial
end
end OAI