math / data /lean /OAI /Analysis /FactorGeneration /HaarSequences.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
25.5 kB
import OAI.Analysis.FactorGeneration.RepresentedFreeness
namespace OAI
noncomputable section
namespace Generator.Tracial
/-! One constructed Haar extension retains endpoint moments, represented
norm-closed freeness, and an actual unitary sequence in the included algebra. -/
section
attribute [local instance] quotientL2AddCommMonoid quotientL2AddCommGroup
quotientOperatorSemiring quotientOperatorNonAssocSemiring quotientOperatorAlgebra
quotientOperatorSemitopology
open UltrapowerBridge Filter
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (Ο„ : TracialRepresentation M) (Ο‰ : Ultrafilter β„•)
/-- Full endpoint formula; the internal factors alone must be centered. -/
def HaarEndpoints (D : Subalgebra β„‚ (Q Ο„ Ο‰)) (t : unitary (Q Ο„ Ο‰)) : Prop :=
βˆ€ c ∈ D,βˆ€ d ∈ D,βˆ€ n : β„€,n β‰  0 β†’ βˆ€ xs : List (Q Ο„ Ο‰ Γ— β„€),
(βˆ€ z ∈ xs,z.1 ∈ D ∧ quotientTrace Ο„ Ο‰ z.1=0 ∧ z.2 β‰  0) β†’
quotientTrace Ο„ Ο‰ (c*integerValueWord Ο„ Ο‰ t n xs d)=0
theorem HaarEndpoints.haar {D : Subalgebra β„‚ (Q Ο„ Ο‰)} {t : unitary (Q Ο„ Ο‰)}
(h : HaarEndpoints Ο„ Ο‰ D t) (n : β„€) (hn : n β‰  0) :
quotientTrace Ο„ Ο‰ (↑(t^n) : Q Ο„ Ο‰)=0 := by
simpa only [integerValueWord,mul_one,one_mul] using
h 1 D.one_mem 1 D.one_mem n hn [] (by simp)
theorem HaarEndpoints.representedFree {D : Subalgebra β„‚ (Q Ο„ Ο‰)}
{t : unitary (Q Ο„ Ο‰)} (h : HaarEndpoints Ο„ Ο‰ D t) :
representedClosedFree Ο„ Ο‰ t D := by
apply represented_haar_free_interface Ο„ Ο‰ t D (h.haar Ο„ Ο‰)
apply endpoint_all_alternating Ο„ Ο‰ _ D
intro c hc d hd q hq xs hxs
apply endpoint_moments_laurent_closure Ο„ Ο‰ D t h c d q hc hd
(Submodule.le_topologicalClosure _ (Submodule.subset_span hq)) xs
intro z hz
exact ⟨(hxs z hz).1,(hxs z hz).2.1,
Submodule.le_topologicalClosure _ (Submodule.subset_span (hxs z hz).2.2)⟩
structure CoordinateHaarData (hNM : N ≀ M) (D : Subalgebra β„‚ (Q Ο„ Ο‰)) where
t : unitary (Q Ο„ Ο‰)
coordinates : Bounded N
unitary_coordinates : βˆ€ j,coordinates.val j ∈ unitary N.toStarSubalgebra
represents : quotientInclusion Ο„ hNM (Ο‰ : Filter β„•)
(quotientMap (restrictedTrace Ο„ hNM) (Ο‰ : Filter β„•) coordinates)=(t : Q Ο„ Ο‰)
endpoints : HaarEndpoints Ο„ Ο‰ D t
variable (hNM : N ≀ M)
variable (hfactor : βˆ€ c : N.toStarSubalgebra,
(βˆ€ a : N.toStarSubalgebra,a*c=c*a) β†’ βˆƒ z : β„‚,c=z β€’ (1 : N.toStarSubalgebra))
variable (hdiff : βˆ€ r : N.toStarSubalgebra,IsStarProjection r β†’ r β‰  0 β†’
βˆƒ q : N.toStarSubalgebra,IsStarProjection q ∧ q β‰  0 ∧ q β‰  r ∧ r*q=q ∧ q*r=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 nonempty_coordinateHaarData (hΟ‰ : (Ο‰ : Filter β„•) ≀ atTop)
(D : Subalgebra β„‚ (Q Ο„ Ο‰)) (hD : TopologicalSpace.IsSeparable (D : Set (Q Ο„ Ο‰))) :
Nonempty (CoordinateHaarData Ο„ Ο‰ hNM D) := by
obtain ⟨t,⟨b,hb,he⟩,_,hep⟩ := exists_coordinate_haar_endpoints
(H := H) (N := N) (M := M) τ ω hNM hfactor hdiff hirr hsep hω D hD
exact ⟨⟨t,b,hb,he,hep⟩⟩
end
/-! Scalar expansion of same-sign gaps. Opposite-sign gaps must be centered,
so deleting a scalar gap can never cancel an entire power. -/
section
open UltrapowerBridge Filter
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {M : VonNeumannAlgebra H} (Ο„ : TracialRepresentation M) (Ο‰ : Ultrafilter β„•)
def SamePowerSign (n m : β„€) : Prop := (0 < n ∧ 0 < m) ∨ (n < 0 ∧ m < 0)
def ReducedIntegerGaps (D : Subalgebra β„‚ (Q Ο„ Ο‰)) : β„€ β†’ List (Q Ο„ Ο‰ Γ— β„€) β†’ Prop
| _,[] => True
| n,(d,m)::xs => d ∈ D ∧ m β‰  0 ∧
(quotientTrace Ο„ Ο‰ d=0 ∨ SamePowerSign n m) ∧ ReducedIntegerGaps D m xs
theorem integerValueWord_mul_power (t : unitary (Q Ο„ Ο‰)) (n m : β„€)
(xs : List (Q Ο„ Ο‰ Γ— β„€)) (b : Q Ο„ Ο‰) :
(↑(t^n) : Q Ο„ Ο‰)*integerValueWord Ο„ Ο‰ t m xs b=
integerValueWord Ο„ Ο‰ t (n+m) xs b := by
cases xs <;> simp [integerValueWord,zpow_add,mul_assoc]
/-- Prefixes are absorbed into an arbitrary linear functional. Its centered
endpoint property is preserved when a centered gap is appended. -/
theorem reduced_integer_gap_functional (D : Subalgebra β„‚ (Q Ο„ Ο‰))
(t : unitary (Q Ο„ Ο‰)) (L : Q Ο„ Ο‰ β†’β‚—[β„‚] β„‚)
(hm : βˆ€ b ∈ D,βˆ€ n : β„€,n β‰  0 β†’ βˆ€ xs : List (Q Ο„ Ο‰ Γ— β„€),
(βˆ€ z ∈ xs,z.1 ∈ D ∧ quotientTrace Ο„ Ο‰ z.1=0 ∧ z.2 β‰  0) β†’
L (integerValueWord Ο„ Ο‰ t n xs b)=0)
(n : β„€) (hn : n β‰  0) (xs : List (Q Ο„ Ο‰ Γ— β„€))
(hx : ReducedIntegerGaps Ο„ Ο‰ D n xs) (b : Q Ο„ Ο‰) (hb : b ∈ D) :
L (integerValueWord Ο„ Ο‰ t n xs b)=0 := by
induction xs generalizing L n with
| nil => exact hm b hb n hn [] (by simp)
| cons z xs ih =>
rcases z with ⟨d,m⟩
rcases hx with ⟨hd,hm0,hgap,hxs⟩
let d0 := d-quotientTrace Ο„ Ο‰ d β€’ (1 : Q Ο„ Ο‰)
have hd0 : d0 ∈ D := D.sub_mem hd (D.smul_mem D.one_mem _)
have ht0 : quotientTrace Ο„ Ο‰ d0=0 := by
change (traceLinear Ο„ Ο‰) (d-quotientTrace Ο„ Ο‰ d β€’ (1 : Q Ο„ Ο‰))=0
rw [map_sub,map_smul]
change quotientTrace Ο„ Ο‰ d-quotientTrace Ο„ Ο‰ d*quotientTrace Ο„ Ο‰ 1=0
rw [quotientTrace_one,mul_one,sub_self]
let L' : Q Ο„ Ο‰ β†’β‚—[β„‚] β„‚ := L.comp (LinearMap.mulLeft β„‚ ((↑(t^n) : Q Ο„ Ο‰)*d0))
have hL' : βˆ€ c ∈ D,βˆ€ k : β„€,k β‰  0 β†’ βˆ€ ys : List (Q Ο„ Ο‰ Γ— β„€),
(βˆ€ z ∈ ys,z.1 ∈ D ∧ quotientTrace Ο„ Ο‰ z.1=0 ∧ z.2 β‰  0) β†’
L' (integerValueWord Ο„ Ο‰ t k ys c)=0 := by
intro c hc k hk ys hys
exact hm c hc n hn ((d0,k)::ys) (by
intro z hz
rcases List.mem_cons.mp hz with rfl | hz
· exact ⟨hd0,ht0,hk⟩
Β· exact hys z hz)
have hc := ih L' hL' m hm0 hxs
have hs : quotientTrace Ο„ Ο‰ d * L (integerValueWord Ο„ Ο‰ t (n+m) xs b)=0 := by
rcases hgap with hzero | hsign
Β· rw [hzero,zero_mul]
Β· have hsum : n+m β‰  0 := by rcases hsign with h | h <;> omega
rw [ih L hm (n+m) hsum ?_]
Β· exact mul_zero _
Β· cases xs with
| nil => trivial
| cons z ys =>
rcases hxs with ⟨hz,hnz,hgz,hys⟩
refine ⟨hz,hnz,?_,hys⟩
rcases hgz with hzero | hsame
Β· exact Or.inl hzero
Β· right
rcases hsign with h | h <;> rcases hsame with h' | h' <;>
simp only [SamePowerSign] at * <;> omega
have he : d=d0+quotientTrace Ο„ Ο‰ d β€’ (1 : Q Ο„ Ο‰) := by
simp only [d0,sub_add_cancel]
change L ((↑(t^n) : Q Ο„ Ο‰)*d*integerValueWord Ο„ Ο‰ t m xs b)=0
rw [he,mul_add,add_mul,map_add]
change L' (integerValueWord Ο„ Ο‰ t m xs b) +
L (((↑(t^n) : Q Ο„ Ο‰)*(quotientTrace Ο„ Ο‰ d β€’ (1 : Q Ο„ Ο‰)))*
integerValueWord Ο„ Ο‰ t m xs b)=0
rw [hc,mul_smul_comm,mul_one,smul_mul_assoc,map_smul,
integerValueWord_mul_power,smul_eq_mul,hs,add_zero]
theorem HaarEndpoints.reduced_gaps {D : Subalgebra β„‚ (Q Ο„ Ο‰)}
{t : unitary (Q Ο„ Ο‰)} (h : HaarEndpoints Ο„ Ο‰ D t)
(a : Q Ο„ Ο‰) (ha : a ∈ D) (b : Q Ο„ Ο‰) (hb : b ∈ D)
(n : β„€) (hn : n β‰  0) (xs : List (Q Ο„ Ο‰ Γ— β„€))
(hx : ReducedIntegerGaps Ο„ Ο‰ D n xs) :
quotientTrace Ο„ Ο‰ (a*integerValueWord Ο„ Ο‰ t n xs b)=0 := by
apply reduced_integer_gap_functional Ο„ Ο‰ D t
((traceLinear Ο„ Ο‰).comp (LinearMap.mulLeft β„‚ a))
(fun b hb n hn xs hxs => h a ha b hb n hn xs hxs) n hn xs hx b hb
/-! Expand nonzero integer powers into signs while retaining the exact rule:
only an equal-sign gap may have a nonzero scalar part. -/
def signExponent (s : Bool) : β„€ := if s then -1 else 1
theorem signedLetter_integer (t : unitary (Q Ο„ Ο‰)) (s : Bool) :
algebraSignedLetter (t : Q Ο„ Ο‰) s=(↑(t^signExponent s) : Q Ο„ Ο‰) := by
cases s
Β· simp [signExponent,algebraSignedLetter]
Β· change star (t : Q Ο„ Ο‰)=(↑(t^(-1 : β„€)) : Q Ο„ Ο‰)
rw [zpow_neg_one]
rfl
def SignedReducedGaps (D : Subalgebra β„‚ (Q Ο„ Ο‰)) : Bool β†’ List (Q Ο„ Ο‰ Γ— Bool) β†’ Prop
| _,[] => True
| s,(d,t)::xs => d ∈ D ∧ (s β‰  t β†’ quotientTrace Ο„ Ο‰ d=0) ∧ SignedReducedGaps D t xs
theorem betweenWord_integerValue (t : unitary (Q Ο„ Ο‰)) (s : Bool)
(xs : List (Q Ο„ Ο‰ Γ— Bool)) (b : Q Ο„ Ο‰) :
betweenWord (t : Q Ο„ Ο‰) s xs b=integerValueWord Ο„ Ο‰ t (signExponent s)
(xs.map (fun z => (z.1,signExponent z.2))) b := by
induction xs generalizing s with
| nil => simp [betweenWord,integerValueWord,signedLetter_integer]
| cons z xs ih => simp [betweenWord,integerValueWord,signedLetter_integer,ih]
theorem signedReducedGaps_integer {D : Subalgebra β„‚ (Q Ο„ Ο‰)}
(s : Bool) (xs : List (Q Ο„ Ο‰ Γ— Bool)) (hx : SignedReducedGaps Ο„ Ο‰ D s xs) :
ReducedIntegerGaps Ο„ Ο‰ D (signExponent s)
(xs.map (fun z => (z.1,signExponent z.2))) := by
induction xs generalizing s with
| nil => trivial
| cons z xs ih =>
refine ⟨hx.1,?_,?_,ih z.2 hx.2.2⟩
Β· cases z.2 <;> simp [signExponent]
Β· by_cases h : s=z.2
Β· right
rw [h]
cases z.2 <;> simp [signExponent,SamePowerSign]
Β· exact Or.inl (hx.2.1 h)
theorem HaarEndpoints.signed_gaps {D : Subalgebra β„‚ (Q Ο„ Ο‰)}
{t : unitary (Q Ο„ Ο‰)} (h : HaarEndpoints Ο„ Ο‰ D t)
(a : Q Ο„ Ο‰) (ha : a ∈ D) (b : Q Ο„ Ο‰) (hb : b ∈ D)
(s : Bool) (xs : List (Q Ο„ Ο‰ Γ— Bool)) (hx : SignedReducedGaps Ο„ Ο‰ D s xs) :
quotientTrace Ο„ Ο‰ (a*betweenWord (t : Q Ο„ Ο‰) s xs b)=0 := by
rw [betweenWord_integerValue]
apply h.reduced_gaps Ο„ Ο‰ a ha b hb _ (by cases s <;> simp [signExponent])
exact signedReducedGaps_integer Ο„ Ο‰ s xs hx
theorem signedReducedGaps_repeat {D : Subalgebra β„‚ (Q Ο„ Ο‰)}
(s : Bool) (n : β„•) (xs : List (Q Ο„ Ο‰ Γ— Bool))
(hx : SignedReducedGaps Ο„ Ο‰ D s xs) :
SignedReducedGaps Ο„ Ο‰ D s (List.replicate n (1,s)++xs) := by
induction n with
| zero => simpa using hx
| succ n ih =>
rw [List.replicate_succ,List.cons_append]
exact ⟨D.one_mem,fun h => (h rfl).elim,ih⟩
theorem signedReducedGaps_blocks {D : Subalgebra β„‚ (Q Ο„ Ο‰)}
(s : Bool) (n : β„•) (xs : List (Q Ο„ Ο‰ Γ— (Bool Γ— β„•)))
(hx : βˆ€ z ∈ xs,z.1 ∈ D ∧ quotientTrace Ο„ Ο‰ z.1=0) :
SignedReducedGaps Ο„ Ο‰ D s (powerBlockGaps s n xs) := by
induction xs generalizing s n with
| nil =>
simpa only [powerBlockGaps,List.append_nil] using
signedReducedGaps_repeat Ο„ Ο‰ (D := D) s n [] trivial
| cons z xs ih =>
apply signedReducedGaps_repeat
exact ⟨(hx z (by simp)).1,fun _ => (hx z (by simp)).2,
ih _ _ (fun w hw => hx w (by simp [hw]))⟩
theorem integerValueWord_blocks (t : unitary (Q Ο„ Ο‰)) (n : β„€) (hn : n β‰  0)
(xs : List (Q Ο„ Ο‰ Γ— β„€)) (hx : βˆ€ z ∈ xs,z.2 β‰  0) (b : Q Ο„ Ο‰) :
integerValueWord Ο„ Ο‰ t n xs b=betweenWord (t : Q Ο„ Ο‰) (integerPowerBlock n).1
(powerBlockGaps (integerPowerBlock n).1 (integerPowerBlock n).2
(xs.map (fun z => (z.1,integerPowerBlock z.2)))) b := by
rw [← powerBlockWord_expand]
induction xs generalizing n with
| nil => simp [integerValueWord,powerBlockWord,integerPowerBlock_eval t n hn]
| cons z xs ih =>
simp only [integerValueWord,List.map_cons,powerBlockWord,integerPowerBlock_eval t n hn]
rw [ih z.2 (hx z (by simp)) (fun w hw => hx w (by simp [hw]))]
end
/-! Absorption of base-algebra unitaries, with signed scalar gap expansions. -/
section Algebra
variable {A : Type*} [Monoid A] [StarMul A]
def absorbedGapList (u : A) (s : Bool) : List (A Γ— Bool) β†’ List (A Γ— Bool)
| [] => []
| (d,t)::xs => (productRight u s*d*productLeft u t,t)::absorbedGapList u t xs
theorem betweenWord_absorb_left (u v : A) (s : Bool) (xs : List (A Γ— Bool)) (b : A) :
betweenWord (u*v) s xs b=productLeft u s*betweenWord v s (absorbedGapList u s xs)
(productRight u (finalWordSign s xs)*b) := by
induction xs generalizing s with
| nil => simp [betweenWord,absorbedGapList,finalWordSign,signed_product_split,mul_assoc]
| cons z xs ih =>
simp only [betweenWord,absorbedGapList,finalWordSign,signed_product_split,ih,mul_assoc]
end Algebra
section
open UltrapowerBridge Filter
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {M : VonNeumannAlgebra H} (Ο„ : TracialRepresentation M) (Ο‰ : Ultrafilter β„•)
theorem absorbedGapList_reduced (D : StarSubalgebra β„‚ (Q Ο„ Ο‰))
(u : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ D)
(s : Bool) (xs : List (Q Ο„ Ο‰ Γ— Bool))
(hx : SignedReducedGaps Ο„ Ο‰ D.toSubalgebra s xs) :
SignedReducedGaps Ο„ Ο‰ D.toSubalgebra s (absorbedGapList (u : Q Ο„ Ο‰) s xs) := by
induction xs generalizing s with
| nil => trivial
| cons z xs ih =>
rcases z with ⟨d,r⟩
refine ⟨?_,?_,ih r hx.2.2⟩
Β· cases s <;> cases r <;> simp only [productRight,productLeft,Bool.false_eq_true,
↓reduceIte,mul_one,one_mul]
Β· exact D.mul_mem hx.1 hu
Β· exact hx.1
Β· exact D.mul_mem (D.mul_mem (D.star_mem' hu) hx.1) hu
Β· exact D.mul_mem (D.star_mem' hu) hx.1
Β· intro hne
cases s <;> cases r
Β· exact (hne rfl).elim
Β· simpa [productRight,productLeft] using hx.2.1 (by decide)
Β· change quotientTrace Ο„ Ο‰ (star (u : Q Ο„ Ο‰)*d*(u : Q Ο„ Ο‰))=0
rw [quotientTrace_mul_comm Ο„ Ο‰ (star (u : Q Ο„ Ο‰)*d),← mul_assoc,
u.property.2,one_mul]
exact hx.2.1 (by decide)
Β· exact (hne rfl).elim
theorem HaarEndpoints.mul_left_signed {D : StarSubalgebra β„‚ (Q Ο„ Ο‰)}
{t : unitary (Q Ο„ Ο‰)} (h : HaarEndpoints Ο„ Ο‰ D.toSubalgebra t)
(u : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ D)
(a : Q Ο„ Ο‰) (ha : a ∈ D) (b : Q Ο„ Ο‰) (hb : b ∈ D)
(s : Bool) (xs : List (Q Ο„ Ο‰ Γ— Bool))
(hx : SignedReducedGaps Ο„ Ο‰ D.toSubalgebra s xs) :
quotientTrace Ο„ Ο‰ (a*betweenWord (↑(u*t) : Q Ο„ Ο‰) s xs b)=0 := by
change quotientTrace Ο„ Ο‰ (a*betweenWord ((u : Q Ο„ Ο‰)*(t : Q Ο„ Ο‰)) s xs b)=0
rw [betweenWord_absorb_left,← mul_assoc]
apply h.signed_gaps Ο„ Ο‰ _ ?_ _ ?_ s _ (absorbedGapList_reduced Ο„ Ο‰ D u hu s xs hx)
Β· cases s <;> simp only [productLeft,Bool.false_eq_true,↓reduceIte,mul_one]
Β· exact D.mul_mem ha hu
Β· exact ha
Β· cases finalWordSign s xs <;> simp only [productRight,Bool.false_eq_true,↓reduceIte,one_mul]
Β· exact hb
Β· exact D.mul_mem (D.star_mem' hu) hb
theorem HaarEndpoints.mul_left {D : StarSubalgebra β„‚ (Q Ο„ Ο‰)}
{t : unitary (Q Ο„ Ο‰)} (h : HaarEndpoints Ο„ Ο‰ D.toSubalgebra t)
(u : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ D) :
HaarEndpoints Ο„ Ο‰ D.toSubalgebra (u*t) := by
intro a ha b hb n hn xs hxs
rw [integerValueWord_blocks Ο„ Ο‰ _ n hn xs (fun z hz => (hxs z hz).2.2)]
apply h.mul_left_signed Ο„ Ο‰ u hu a ha b hb
apply signedReducedGaps_blocks
intro z hz
obtain ⟨w,hw,rfl⟩ := List.mem_map.mp hz
exact ⟨(hxs w hw).1,(hxs w hw).2.1⟩
theorem integerValueWord_inv (t : unitary (Q Ο„ Ο‰)) (n : β„€)
(xs : List (Q Ο„ Ο‰ Γ— β„€)) (b : Q Ο„ Ο‰) :
integerValueWord Ο„ Ο‰ t⁻¹ n xs b=integerValueWord Ο„ Ο‰ t (-n)
(xs.map (fun z => (z.1,-z.2))) b := by
induction xs generalizing n with
| nil => simp [integerValueWord,zpow_neg]
| cons z xs ih => simp [integerValueWord,zpow_neg,ih]
theorem HaarEndpoints.inv {D : Subalgebra β„‚ (Q Ο„ Ο‰)} {t : unitary (Q Ο„ Ο‰)}
(h : HaarEndpoints Ο„ Ο‰ D t) : HaarEndpoints Ο„ Ο‰ D t⁻¹ := by
intro a ha b hb n hn xs hxs
rw [integerValueWord_inv]
apply h a ha b hb (-n) (neg_ne_zero.mpr hn)
intro z hz
obtain ⟨w,hw,rfl⟩ := List.mem_map.mp hz
exact ⟨(hxs w hw).1,(hxs w hw).2.1,neg_ne_zero.mpr (hxs w hw).2.2⟩
theorem HaarEndpoints.mul_right {D : StarSubalgebra β„‚ (Q Ο„ Ο‰)}
{t : unitary (Q Ο„ Ο‰)} (h : HaarEndpoints Ο„ Ο‰ D.toSubalgebra t)
(u : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ D) :
HaarEndpoints Ο„ Ο‰ D.toSubalgebra (t*u) := by
have h' := (h.inv Ο„ Ο‰).mul_left Ο„ Ο‰ u⁻¹ (show (↑u⁻¹ : Q Ο„ Ο‰) ∈ D from D.star_mem' hu)
simpa only [mul_inv_rev,inv_inv] using h'.inv Ο„ Ο‰
theorem HaarEndpoints.absorb {D : StarSubalgebra β„‚ (Q Ο„ Ο‰)}
{t : unitary (Q Ο„ Ο‰)} (h : HaarEndpoints Ο„ Ο‰ D.toSubalgebra t)
(a b : unitary (Q Ο„ Ο‰)) (ha : (a : Q Ο„ Ο‰) ∈ D) (hb : (b : Q Ο„ Ο‰) ∈ D) :
HaarEndpoints Ο„ Ο‰ D.toSubalgebra (a*t*b) :=
(h.mul_left Ο„ Ο‰ a ha).mul_right Ο„ Ο‰ b hb
end
/-! Successive Haar choices in algebraic star subalgebras of the tracial quotient, with freeness retained in their represented operator-norm closures. -/
section
open UltrapowerBridge Filter
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (Ο„ : TracialRepresentation M) (Ο‰ : Ultrafilter β„•)
structure SuccessiveCoordinateHaar (hNM : N ≀ M) (seed : Set (Q Ο„ Ο‰)) where
algebra : β„• β†’ StarSubalgebra β„‚ (Q Ο„ Ο‰)
step : βˆ€ j,CoordinateHaarData Ο„ Ο‰ hNM (algebra j).toSubalgebra
initial : algebra 0=StarAlgebra.adjoin β„‚ seed
successor : βˆ€ j,algebra (j+1)=StarAlgebra.adjoin β„‚
(insert ((step j).t : Q Ο„ Ο‰) (algebra j : Set (Q Ο„ Ο‰)))
separable : βˆ€ j,TopologicalSpace.IsSeparable (algebra j : Set (Q Ο„ Ο‰))
variable (hNM : N ≀ M)
variable (hfactor : βˆ€ c : N.toStarSubalgebra,
(βˆ€ a : N.toStarSubalgebra,a*c=c*a) β†’ βˆƒ z : β„‚,c=z β€’ (1 : N.toStarSubalgebra))
variable (hdiff : βˆ€ r : N.toStarSubalgebra,IsStarProjection r β†’ r β‰  0 β†’
βˆƒ q : N.toStarSubalgebra,IsStarProjection q ∧ q β‰  0 ∧ q β‰  r ∧ r*q=q ∧ q*r=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 nonempty_successiveCoordinateHaar (hΟ‰ : (Ο‰ : Filter β„•) ≀ atTop)
(seed : Set (Q Ο„ Ο‰)) (hseed : seed.Countable) :
Nonempty (SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed) := by
let : NormedSpace β„‚ (Q Ο„ Ο‰) := (quotientInnerProductSpace Ο„ Ο‰).toNormedSpace
have : IsBoundedSMul β„‚ (Q Ο„ Ο‰) :=
IsBoundedSMul.of_norm_smul_le NormedSpace.norm_smul_le
have : ContinuousSMul β„‚ (Q Ο„ Ο‰) := IsBoundedSMul.continuousSMul
let step (s : {s : Set (Q Ο„ Ο‰) // s.Countable}) := Classical.choice
(nonempty_coordinateHaarData τ ω hNM hfactor hdiff hirr hsep hω
(StarAlgebra.adjoin β„‚ s.val).toSubalgebra (separable_countable_star_adjoin s.property))
let S : β„• β†’ {s : Set (Q Ο„ Ο‰) // s.Countable} := Nat.rec ⟨seed,hseed⟩
(fun _ s => ⟨insert ((step s).t : Q Ο„ Ο‰) s.val,s.property.insert _⟩)
refine ⟨⟨fun j => StarAlgebra.adjoin β„‚ (S j).val,fun j => step (S j),rfl,?_,
fun j => separable_countable_star_adjoin (S j).property⟩⟩
intro j
change StarAlgebra.adjoin β„‚ (insert ((step (S j)).t : Q Ο„ Ο‰) (S j).val)=
StarAlgebra.adjoin β„‚ (insert ((step (S j)).t : Q Ο„ Ο‰)
(StarAlgebra.adjoin β„‚ (S j).val : Set (Q Ο„ Ο‰)))
apply le_antisymm
Β· apply StarAlgebra.adjoin_mono
exact Set.insert_subset_insert (StarAlgebra.subset_adjoin β„‚ _)
Β· apply StarAlgebra.adjoin_le
apply Set.insert_subset
Β· exact StarAlgebra.subset_adjoin β„‚ _ (Set.mem_insert _ _)
Β· exact StarAlgebra.adjoin_mono (Set.subset_insert _ _)
omit hfactor hdiff hirr hsep
variable {hNM}
theorem SuccessiveCoordinateHaar.monotone {seed : Set (Q Ο„ Ο‰)}
(F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed) : Monotone F.algebra := by
apply monotone_nat_of_le_succ
intro j x hx
rw [F.successor]
exact StarAlgebra.subset_adjoin β„‚ _ (Set.mem_insert_of_mem _ hx)
theorem SuccessiveCoordinateHaar.seed_mem {seed : Set (Q Ο„ Ο‰)}
(F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed) (j : β„•) : seed βŠ† F.algebra j := by
intro x hx
apply F.monotone Ο„ Ο‰ (Nat.zero_le j)
rw [F.initial]
exact StarAlgebra.subset_adjoin β„‚ seed hx
theorem SuccessiveCoordinateHaar.previous_mem {seed : Set (Q Ο„ Ο‰)}
(F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed) {i j : β„•} (hij : i < j) :
((F.step i).t : Q Ο„ Ο‰) ∈ F.algebra j := by
apply F.monotone Ο„ Ο‰ hij
rw [F.successor]
exact StarAlgebra.subset_adjoin β„‚ _ (Set.mem_insert _ _)
end
/-! Free variables and prefixes with Haar endpoint properties of W and y=zW*. Coordinates are retained in the sequence data. -/
open UltrapowerBridge Filter
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β„‚ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (Ο„ : TracialRepresentation M) (Ο‰ : Ultrafilter β„•)
def prefixVariable (u : unitary (Q Ο„ Ο‰)) (t : β„• β†’ unitary (Q Ο„ Ο‰)) : β„• β†’ unitary (Q Ο„ Ο‰)
| 0 => t 0
| j+1 => u*t (j+1)
def prefixProduct (u : unitary (Q Ο„ Ο‰)) (t : β„• β†’ unitary (Q Ο„ Ο‰)) : β„• β†’ unitary (Q Ο„ Ο‰)
| 0 => 1
| j+1 => prefixProduct u t j*prefixVariable Ο„ Ο‰ u t j
theorem prefixProduct_formula (u : unitary (Q Ο„ Ο‰)) (t : β„• β†’ unitary (Q Ο„ Ο‰)) (ell : β„•) :
prefixProduct Ο„ Ο‰ u t (ell+1)=t 0*((List.range ell).map (fun j => u*t (j+1))).prod := by
induction ell with
| zero => simp [prefixProduct,prefixVariable]
| succ ell ih =>
change prefixProduct Ο„ Ο‰ u t (ell+1)*(u*t (ell+1))=_
rw [ih]
simp only [List.range_succ,List.map_append,List.map_singleton,List.prod_append,
List.prod_singleton,mul_assoc]
variable {hNM : N ≀ M} {seed : Set (Q Ο„ Ο‰)}
theorem SuccessiveCoordinateHaar.variable_mem (F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed)
(u : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ seed) {i j : β„•} (hij : i < j) :
(prefixVariable Ο„ Ο‰ u (fun k => (F.step k).t) i : Q Ο„ Ο‰) ∈ F.algebra j := by
cases i with
| zero => exact F.previous_mem Ο„ Ο‰ hij
| succ i => exact (F.algebra j).mul_mem (F.seed_mem Ο„ Ο‰ j hu) (F.previous_mem Ο„ Ο‰ hij)
theorem SuccessiveCoordinateHaar.prefix_mem (F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed)
(u : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ seed) {k j : β„•} (hkj : k ≀ j) :
(prefixProduct Ο„ Ο‰ u (fun i => (F.step i).t) k : Q Ο„ Ο‰) ∈ F.algebra j := by
induction k with
| zero => exact (F.algebra j).one_mem
| succ k ih =>
exact (F.algebra j).mul_mem (ih (by omega)) (F.variable_mem Ο„ Ο‰ u hu (by omega))
theorem SuccessiveCoordinateHaar.variable_endpoints (F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed)
(u : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ seed) (j : β„•) :
HaarEndpoints Ο„ Ο‰ (F.algebra j).toSubalgebra
(prefixVariable Ο„ Ο‰ u (fun k => (F.step k).t) j) := by
cases j with
| zero => exact (F.step 0).endpoints
| succ j => exact (F.step (j+1)).endpoints.mul_left Ο„ Ο‰ u (F.seed_mem Ο„ Ο‰ _ hu)
theorem SuccessiveCoordinateHaar.prefix_endpoints (F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed)
(u : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ seed) (ell : β„•) :
HaarEndpoints Ο„ Ο‰ (F.algebra ell).toSubalgebra
(prefixProduct Ο„ Ο‰ u (fun k => (F.step k).t) (ell+1)) :=
(F.variable_endpoints Ο„ Ο‰ u hu ell).mul_left Ο„ Ο‰ _ (F.prefix_mem Ο„ Ο‰ u hu le_rfl)
theorem SuccessiveCoordinateHaar.target_endpoints (F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM seed)
(u z : unitary (Q Ο„ Ο‰)) (hu : (u : Q Ο„ Ο‰) ∈ seed) (hz : (z : Q Ο„ Ο‰) ∈ seed) (ell : β„•) :
HaarEndpoints Ο„ Ο‰ (F.algebra ell).toSubalgebra
(z*(prefixProduct Ο„ Ο‰ u (fun k => (F.step k).t) (ell+1))⁻¹) :=
((F.prefix_endpoints Ο„ Ο‰ u hu ell).inv Ο„ Ο‰).mul_left Ο„ Ο‰ z (F.seed_mem Ο„ Ο‰ _ hz)
variable (hNM : N ≀ M)
variable (hfactor : βˆ€ c : N.toStarSubalgebra,
(βˆ€ a : N.toStarSubalgebra,a*c=c*a) β†’ βˆƒ z : β„‚,c=z β€’ (1 : N.toStarSubalgebra))
variable (hdiff : βˆ€ r : N.toStarSubalgebra,IsStarProjection r β†’ r β‰  0 β†’
βˆƒ q : N.toStarSubalgebra,IsStarProjection q ∧ q β‰  0 ∧ q β‰  r ∧ r*q=q ∧ q*r=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_perturbation_haar_system (hΟ‰ : (Ο‰ : Filter β„•) ≀ atTop)
(u z : unitary (Q Ο„ Ο‰)) (xi : Q Ο„ Ο‰) :
βˆƒ F : SuccessiveCoordinateHaar Ο„ Ο‰ hNM {(u : Q Ο„ Ο‰),(z : Q Ο„ Ο‰),xi},
(βˆ€ j,HaarEndpoints Ο„ Ο‰ (F.algebra j).toSubalgebra
(prefixVariable Ο„ Ο‰ u (fun k => (F.step k).t) j)) ∧
βˆ€ ell,HaarEndpoints Ο„ Ο‰ (F.algebra ell).toSubalgebra
(prefixProduct Ο„ Ο‰ u (fun k => (F.step k).t) (ell+1)) ∧
HaarEndpoints Ο„ Ο‰ (F.algebra ell).toSubalgebra
(z*(prefixProduct Ο„ Ο‰ u (fun k => (F.step k).t) (ell+1))⁻¹) := by
let F := Classical.choice (nonempty_successiveCoordinateHaar τ ω hNM hfactor hdiff hirr hsep hω
{(u : Q Ο„ Ο‰),(z : Q Ο„ Ο‰),xi} (((Set.countable_singleton xi).insert (z : Q Ο„ Ο‰)).insert (u : Q Ο„ Ο‰)))
exact ⟨F,F.variable_endpoints Ο„ Ο‰ u (by simp),fun ell =>
⟨F.prefix_endpoints Ο„ Ο‰ u (by simp) ell,F.target_endpoints Ο„ Ο‰ u z (by simp) (by simp) ell⟩⟩
end Generator.Tracial
end
end OAI