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