import OAI.Analysis.FactorGeneration.HaarPatches

namespace OAI

noncomputable section

namespace Generator.Tracial

/-! Extension of actual partial unitaries and ordered words from pH.
The empty word maps to p, so word transport retains a final p. -/
section
open UltrapowerBridge
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
variable {M : VonNeumannAlgebra H} (p : AlgebraProjection M)

def PartialUnitary.fromRepresentedCorner (v : PartialUnitary (representedCorner p)) :
    PartialUnitary M where
  support := ⟨cornerEmbedding p v.support.val,v.support.property.map (cornerEmbedding p)⟩
  unitary := ⟨cornerEmbedding p v.val, by
    exact (congrArg (fun x => x * cornerEmbedding p v.val)
      (map_star (cornerEmbedding p) v.val).symm).trans
        ((map_mul (cornerEmbedding p) (star v.val) v.val).symm.trans
          (congrArg (cornerEmbedding p) v.unitary.initial)), by
    exact (congrArg (fun x => cornerEmbedding p v.val * x)
      (map_star (cornerEmbedding p) v.val).symm).trans
        ((map_mul (cornerEmbedding p) v.val (star v.val)).symm.trans
          (congrArg (cornerEmbedding p) v.unitary.final))⟩

theorem PartialUnitary.fromRepresentedCorner_support_le
    (v : PartialUnitary (representedCorner p)) : (v.fromRepresentedCorner p).support ≤ p :=
  cornerEmbedding_left p v.support.val

theorem cornerEmbedding_signedLetter (v : (representedCorner p).toStarSubalgebra) (s : Bool) :
    cornerEmbedding p (signedLetter v s)=signedLetter (cornerEmbedding p v) s := by
  cases s with
  | false => rfl
  | true => exact map_star (cornerEmbedding p) v

theorem cornerEmbedding_patchingWord (v : (representedCorner p).toStarSubalgebra)
    (xs : List (Bool × (representedCorner p).toStarSubalgebra)) :
    cornerEmbedding p (patchingWord v xs)=
      patchingWord (cornerEmbedding p v) (xs.map (fun a => (a.1,cornerEmbedding p a.2)))*p.val := by
  induction xs with
  | nil => simp [patchingWord]
  | cons a xs ih =>
    simp only [patchingWord,List.map_cons,map_mul,cornerEmbedding_signedLetter,ih,mul_assoc]

theorem cornerEmbedding_patchingWord_nonempty (v : (representedCorner p).toStarSubalgebra)
    (xs : List (Bool × (representedCorner p).toStarSubalgebra)) (hx : xs ≠ []) :
    cornerEmbedding p (patchingWord v xs)=
      patchingWord (cornerEmbedding p v) (xs.map (fun a => (a.1,cornerEmbedding p a.2))) := by
  induction xs with
  | nil => exact (hx rfl).elim
  | cons a xs ih =>
    cases xs with
    | nil => simp [patchingWord,cornerEmbedding_signedLetter]
    | cons b ys =>
      change cornerEmbedding p (signedLetter v a.1*a.2*patchingWord v (b::ys)) =
        signedLetter (cornerEmbedding p v) a.1*cornerEmbedding p a.2*
          patchingWord (cornerEmbedding p v) ((b::ys).map (fun c => (c.1,cornerEmbedding p c.2)))
      exact (map_mul (cornerEmbedding p) (signedLetter v a.1 * a.2)
        (patchingWord v (b :: ys))).trans
        (congrArg₂ (fun x y : M.toStarSubalgebra => x * y)
          ((map_mul (cornerEmbedding p) (signedLetter v a.1) a.2).trans
            (congrArg (fun x => x * cornerEmbedding p a.2)
              (cornerEmbedding_signedLetter p v a.1)))
          (ih (by simp)))

theorem cornerEmbedding_trace (τ : TracialRepresentation M) (hp : p.val ≠ 0)
    (a : (representedCorner p).toStarSubalgebra) :
    τ.trace (cornerEmbedding p a)=τ.trace p.val*(representedCornerTrace τ p hp).trace a := by
  rw [representedCornerTrace_trace]
  have ht : τ.trace p.val ≠ 0 := by
    intro h
    have := projection_trace_pos τ p.val p.property hp
    simp [h] at this
  exact (mul_div_cancel₀ _ ht).symm

theorem cornerEmbedding_trace_re (τ : TracialRepresentation M) (hp : p.val ≠ 0)
    (a : (representedCorner p).toStarSubalgebra) :
    (τ.trace (cornerEmbedding p a)).re=
      (τ.trace p.val).re*((representedCornerTrace τ p hp).trace a).re := by
  rw [cornerEmbedding_trace p τ hp,projection_trace_real τ p,Complex.mul_re]
  simp

end

/-! Finite partial independence in every nonzero represented subcorner,
with actual ambient support, membership and trace estimates. -/
section
open UltrapowerBridge
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (τ : TracialRepresentation M)
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_represented_corner_partial_independence
    (p : AlgebraProjection M) (hpN : p.val.val ∈ N) (hp : p.val ≠ 0)
    (F : Finset (representedCorner p).toStarSubalgebra)
    (hF : ∀ x ∈ F,‖x‖ ≤ 1) (hc : ∀ x ∈ F,τ.trace (cornerEmbedding p x)=0)
    (n : ℕ) (ε : ℝ) (hε : 0 < ε) :
    ∃ v : PartialUnitary M,v.val.val ∈ N ∧ v.support ≤ p ∧
      (τ.trace p.val).re/4 < (τ.trace v.support.val).re ∧
      ∀ x₀ ∈ (F : Set (representedCorner p).toStarSubalgebra) ∪ {1},
      ∀ xs : List (Bool × (representedCorner p).toStarSubalgebra),
        1 ≤ xs.length → xs.length ≤ n →
        patchingCoefficients (F : Set (representedCorner p).toStarSubalgebra) xs →
        ‖τ.trace (cornerEmbedding p x₀ *
          patchingWord v.val (xs.map (fun a => (a.1,cornerEmbedding p a.2))))‖ ≤
          (τ.trace p.val).re*ε := by
  let σ := representedCornerTrace τ p hp
  have hf := representedCorner_factor (restrictedTrace τ hNM)
    (projectionInSubalgebra p hpN) hfactor
  have hd := representedCorner_diffuse (projectionInSubalgebra p hpN) hdiff
  have hi := representedCorner_irreducible τ p hpN hNM hirr
  have hs := representedCorner_separable τ p hp hsep
  have hcenter : ∀ x ∈ F,σ.trace x=0 := by
    intro x hx
    rw [representedCornerTrace_trace,hc x hx,zero_div]
  obtain ⟨u,hu,ht,hw⟩ := exists_finite_partial_independence σ
    (representedSubcorner_le p hpN hNM) hf hd hi hs F hF hcenter n ε hε
  refine ⟨u.fromRepresentedCorner p,hu,u.fromRepresentedCorner_support_le p,?_,?_⟩
  · change (τ.trace p.val).re/4 < (τ.trace (cornerEmbedding p u.support.val)).re
    rw [cornerEmbedding_trace_re p τ hp]
    have hpos := projection_trace_pos τ p.val p.property hp
    have h := mul_lt_mul_of_pos_left ht hpos
    dsimp [σ] at h
    linarith
  · intro x₀ hx₀ xs hlen hn hcoeff
    have hne : xs ≠ [] := by intro h; simp [h] at hlen
    have he : cornerEmbedding p x₀ *
        patchingWord (u.fromRepresentedCorner p).val
          (xs.map (fun a => (a.1,cornerEmbedding p a.2))) =
        cornerEmbedding p (x₀*patchingWord u.val xs) := by
      rw [map_mul,cornerEmbedding_patchingWord_nonempty p _ _ hne]
      rfl
    rw [he,cornerEmbedding_trace p τ hp,norm_mul,projection_trace_real τ p,
      Complex.norm_real,Real.norm_of_nonneg ((projection_trace_pos τ p.val p.property hp).le)]
    exact mul_le_mul_of_nonneg_left (hw x₀ hx₀ xs hlen hn hcoeff)
      ((projection_trace_pos τ p.val p.property hp).le)

end

/-! Ordered-word transport with ambient unit endpoints, and contractive
compression of supported centered coefficients. -/
section
open UltrapowerBridge
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
variable {M : VonNeumannAlgebra H} (p : AlgebraProjection M)

theorem cornerCompress_norm_le (a : M.toStarSubalgebra) : ‖cornerCompress p a‖ ≤ ‖a‖ := by
  apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _)
  intro y
  change ‖p.val.val (a.val y.val)‖ ≤ ‖a‖*‖y‖
  exact ((p.val.val.le_opNorm _).trans
    (mul_le_of_le_one_left (norm_nonneg _) p.property.norm_le)).trans (a.val.le_opNorm y.val)

theorem cornerCompress_supported (a : M.toStarSubalgebra)
    (hl : p.val*a=a) (hr : a*p.val=a) : cornerEmbedding p (cornerCompress p a)=a := by
  rw [cornerEmbedding_compress,hl,hr]

theorem cornerEmbedding_ordered_tail (v : (representedCorner p).toStarSubalgebra)
    (x : ℕ → (representedCorner p).toStarSubalgebra) (xs : List (Bool × ℕ))
    (s : Bool) (last : Option ℕ) :
    cornerEmbedding p (patchingWord v
      (xs.map (fun a => (a.1,x a.2)) ++ [(s,optionalCoefficient x last)]))=
    patchingWord (cornerEmbedding p v)
      (xs.map (fun a => (a.1,cornerEmbedding p (x a.2))) ++
        [(s,optionalCoefficient (fun i => cornerEmbedding p (x i)) last)]) := by
  induction xs with
  | nil =>
    cases last <;>
      simp only [List.map_nil,List.nil_append,patchingWord,mul_one,optionalCoefficient,
        map_mul,← cornerEmbedding_signedLetter]
  | cons a xs ih =>
    change cornerEmbedding p (signedLetter v a.1*x a.2*patchingWord v
      (xs.map (fun b => (b.1,x b.2)) ++ [(s,optionalCoefficient x last)])) = _
    exact (map_mul (cornerEmbedding p) (signedLetter v a.1 * x a.2) _).trans
      (congrArg₂ (fun y z : M.toStarSubalgebra => y * z)
        ((map_mul (cornerEmbedding p) (signedLetter v a.1) (x a.2)).trans
          (congrArg (fun y => y * cornerEmbedding p (x a.2))
            (cornerEmbedding_signedLetter p v a.1))) ih)

theorem cornerEmbedding_ordered_moment (v : (representedCorner p).toStarSubalgebra)
    (x : ℕ → (representedCorner p).toStarSubalgebra) (first last : Option ℕ)
    (xs : List (Bool × ℕ)) (s : Bool) :
    cornerEmbedding p (optionalCoefficient x first * patchingWord v
      (xs.map (fun a => (a.1,x a.2)) ++ [(s,optionalCoefficient x last)]))=
    optionalCoefficient (fun i => cornerEmbedding p (x i)) first *
      patchingWord (cornerEmbedding p v)
        (xs.map (fun a => (a.1,cornerEmbedding p (x a.2))) ++
          [(s,optionalCoefficient (fun i => cornerEmbedding p (x i)) last)]) := by
  cases first with
  | none => simpa only [optionalCoefficient,one_mul] using
      cornerEmbedding_ordered_tail p v x xs s last
  | some i =>
    rw [map_mul,cornerEmbedding_ordered_tail]
    rfl

end

/-! Diagonal partial independence in genuinely varying Hilbert-space corners.
The result retains an actual ambient partial-unitary sequence. -/
open Filter
open scoped Topology
section
open UltrapowerBridge
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (τ : TracialRepresentation M)

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_varying_corner_partial_independence
    (p : ℕ → AlgebraProjection M) (hpN : ∀ j,(p j).val.val ∈ N)
    (hp : ∀ j,(p j).val ≠ 0)
    (x : (j : ℕ) → ℕ → (representedCorner (p j)).toStarSubalgebra)
    (hx : ∀ j i,‖x j i‖ ≤ 1)
    (hc : ∀ j i,τ.trace (cornerEmbedding (p j) (x j i))=0) :
    ∃ v : ℕ → PartialUnitary M,
      (∀ j,(v j).val.val ∈ N) ∧ (∀ j,(v j).support ≤ p j) ∧
      (∀ j,(τ.trace (p j).val).re/4 < (τ.trace (v j).support.val).re) ∧
      ∀ first last : Option ℕ,∀ xs : List (Bool × ℕ),∀ s : Bool,
        Tendsto (fun j => τ.trace (
          optionalCoefficient (fun i => cornerEmbedding (p j) (x j i)) first *
          patchingWord (v j).val
            (xs.map (fun a => (a.1,cornerEmbedding (p j) (x j a.2))) ++
              [(s,optionalCoefficient (fun i => cornerEmbedding (p j) (x j i)) last)])))
          atTop (𝓝 0) := by
  classical
  let σ := fun j => representedCornerTrace τ (p j) (hp j)
  let F := fun j => (Finset.range (j+1)).image (x j)
  have hstage (j : ℕ) := exists_finite_partial_independence (σ j)
    (representedSubcorner_le (p j) (hpN j) hNM)
    (representedCorner_factor (restrictedTrace τ hNM)
      (projectionInSubalgebra (p j) (hpN j)) hfactor)
    (representedCorner_diffuse (projectionInSubalgebra (p j) (hpN j)) hdiff)
    (representedCorner_irreducible τ (p j) (hpN j) hNM hirr)
    (representedCorner_separable τ (p j) (hp j) hsep)
    (F j) (by
      intro a ha
      obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp ha
      exact hx j i) (by
      intro a ha
      obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp ha
      rw [representedCornerTrace_trace,hc j i,zero_div])
    (j+1) (1/((j : ℝ)+1)) (by positivity)
  choose u hu ht hw using hstage
  let v := fun j => (u j).fromRepresentedCorner (p j)
  refine ⟨v,hu,fun j => (u j).fromRepresentedCorner_support_le (p j),?_,?_⟩
  · intro j
    change (τ.trace (p j).val).re/4 < (τ.trace (cornerEmbedding (p j) (u j).support.val)).re
    rw [cornerEmbedding_trace_re (p j) τ (hp j)]
    have h := mul_lt_mul_of_pos_left (ht j)
      (projection_trace_pos τ (p j).val (p j).property (hp j))
    dsimp [σ] at h
    linarith
  · 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
    have hopt (i : Option ℕ) : ∀ᶠ j : ℕ in atTop,
        optionalCoefficient (x j) i ∈ (F j : Set _) ∪ {1} := by
      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⟩)
    filter_upwards [eventually_list_indices (xs.map Prod.snd),eventually_ge_atTop xs.length,
      hopt first,hopt last] with j hj hlen hfirst hlast
    have he := cornerEmbedding_ordered_moment (p j) (u j).val (x j) first last xs s
    change ‖τ.trace (optionalCoefficient (fun i => cornerEmbedding (p j) (x j i)) first *
      patchingWord (cornerEmbedding (p j) (u j).val) _)‖ ≤ _
    rw [← he,cornerEmbedding_trace (p j) τ (hp j),norm_mul]
    have hb : ‖(σ j).trace (optionalCoefficient (x j) first *
        patchingWord (u j).val (xs.map (fun a => (a.1,x j a.2)) ++
          [(s,optionalCoefficient (x j) last)]))‖ ≤ 1/((j : ℝ)+1) := by
      apply hw j _ hfirst _ (by simp) (by simpa using Nat.add_le_add_right hlen 1)
      apply patchingCoefficients_append_endpoint _ _ ?_ (s,optionalCoefficient (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⟩
    have htrace : ‖τ.trace (p j).val‖ ≤ 1 :=
      ((τ.norm_trace_le_norm₂ _).trans (τ.norm₂_le_norm _)).trans (p j).property.norm_le
    exact (mul_le_of_le_one_left (norm_nonneg _) htrace).trans hb

end

/-! Actual coordinate partial-unitary witnesses in supported corners, followed
by exact quotient moments and the ambient quarter-support bound. -/
open Filter
open scoped Topology
open UltrapowerBridge
variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
variable {N M : VonNeumannAlgebra H} (τ : TracialRepresentation M)

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_supported_corner_partial_sequence
    (p : ℕ → AlgebraProjection M) (hpN : ∀ j,(p j).val.val ∈ N)
    (hp : ∀ j,(p j).val ≠ 0)
    (x : ℕ → ℕ → M.toStarSubalgebra) (hx : ∀ i j,‖x i j‖ ≤ 1)
    (hc : ∀ i j,τ.trace (x i j)=0)
    (hl : ∀ i j,(p j).val*x i j=x i j) (hr : ∀ i j,x i j*(p j).val=x i j) :
    ∃ v : ℕ → PartialUnitary M,
      (∀ j,(v j).val.val ∈ N) ∧ (∀ j,(v j).support ≤ p j) ∧
      (∀ j,(τ.trace (p j).val).re/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
  let y := fun j i => cornerCompress (p j) (x i j)
  have he (j i : ℕ) : cornerEmbedding (p j) (y j i)=x i j :=
    cornerCompress_supported (p j) (x i j) (hl i j) (hr i j)
  obtain ⟨v,hv,hs,ht,hw⟩ := exists_varying_corner_partial_independence τ hNM hfactor hdiff hirr hsep
    p hpN hp y (fun j i => (cornerCompress_norm_le (p j) (x i j)).trans (hx i j))
    (fun j i => by rw [he]; exact hc i j)
  refine ⟨v,hv,hs,ht,?_⟩
  intro first last xs s
  have hh := hw first last xs s
  cases first <;> cases last <;>
    simpa only [he,optionalCoefficient,indexedCoefficient] using hh

theorem exists_quotient_corner_partial_sequence
    (ω : Ultrafilter ℕ) (hω : (ω : Filter ℕ) ≤ atTop)
    (g : Bounded M) (hg : ∀ j,IsStarProjection (g.val j))
    (hgN : ∀ j,(g.val j).val ∈ N) (hg0 : ∀ j,g.val j ≠ 0)
    (x : ℕ → Bounded M) (hx : ∀ i j,‖(x i).val j‖ ≤ 1)
    (hc : ∀ i j,τ.trace ((x i).val j)=0)
    (hl : ∀ i,g*x i=x i) (hr : ∀ i,x i*g=x i) :
    ∃ v : ℕ → PartialUnitary M,
      (∀ j,(v j).val.val ∈ N) ∧ (∀ j,g.val j*(v j).support.val=(v j).support.val) ∧
      (quotientTrace τ ω (quotientMap τ (ω : Filter ℕ) g)).re/4 ≤
        (quotientTrace τ ω (quotientMap τ (ω : Filter ℕ) (boundedPartialSupport v))).re ∧
      ∀ first last : Option ℕ,∀ xs : List (Bool × ℕ),∀ s : Bool,
        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 p := fun j => (⟨g.val j,hg j⟩ : AlgebraProjection M)
  obtain ⟨v,hv,hs,ht,hw⟩ := exists_supported_corner_partial_sequence τ hNM hfactor hdiff hirr hsep
    p hgN hg0 (fun i => (x i).val) hx hc
    (fun i j => congrArg (fun a : Bounded M => a.val j) (hl i))
    (fun i j => congrArg (fun a : Bounded M => a.val j) (hr i))
  refine ⟨v,hv,hs,?_,?_⟩
  · apply le_of_tendsto_of_tendsto
      ((Complex.continuous_re.continuousAt.tendsto.comp (traceRep_tendsto τ ω g)).div_const 4)
      (Complex.continuous_re.continuousAt.tendsto.comp (traceRep_tendsto τ ω (boundedPartialSupport v)))
    exact Eventually.of_forall (fun j => (ht j).le)
  · intro first last xs s
    exact quotient_ordered_moment_zero τ ω hω v x first last xs s (hw first last xs s)

end Generator.Tracial

end

end OAI