import Mathlib.Algebra.Star.Subalgebra
import Mathlib.Algebra.Star.Unitary
import Mathlib.Analysis.Complex.Basic
import Mathlib.Analysis.Normed.Module.Basic
import Mathlib.Analysis.Normed.Operator.Bilinear
import Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap
import Mathlib.Topology.Algebra.StarSubalgebra
import OAI.Analysis.FactorGeneration.Words

namespace OAI

noncomputable section

namespace Generator

/-! The algebraic star algebra generated by one unitary is exactly the linear
span of all its integer powers. No topology on the ambient algebra is needed. -/
section
variable {R A : Type*} [CommRing R] [StarRing R]
  [Ring A] [StarRing A] [Algebra R A] [StarModule R A]

def unitaryPowerMonoid (v : unitary A) : Submonoid A where
  carrier := Set.range (fun n : ℤ => (↑(v^n) : A))
  one_mem' := ⟨0, by simp⟩
  mul_mem' := by
    rintro a b ⟨n,rfl⟩ ⟨m,rfl⟩
    exact ⟨n+m,by simp [zpow_add]⟩

theorem unitary_power_mem_adjoin (v : unitary A) (n : ℤ) :
    (↑(v^n) : A) ∈ StarAlgebra.adjoin R {(v : A)} := by
  have hv := StarAlgebra.self_mem_adjoin_singleton R (v : A)
  cases n with
  | ofNat n => simpa using (StarAlgebra.adjoin R {(v : A)}).pow_mem hv n
  | negSucc n =>
    have hs : star (v : A) ∈ StarAlgebra.adjoin R {(v : A)} := star_mem hv
    have hp := (StarAlgebra.adjoin R {(v : A)}).pow_mem hs (n+1)
    change (↑(v ^ (-(↑n + 1) : ℤ)) : A) ∈ _
    rw [zpow_neg, ← Int.natCast_add_one, zpow_natCast]
    change star ((v : A)^(n+1)) ∈ _
    rw [star_pow]
    exact hp

theorem unitary_adjoin_eq_span (v : unitary A) :
    (StarAlgebra.adjoin R {(v : A)}).toSubalgebra.toSubmodule =
      Submodule.span R (Set.range (fun n : ℤ => (↑(v^n) : A))) := by
  apply le_antisymm
  · rw [StarAlgebra.adjoin_eq_span]
    apply Submodule.span_mono
    change Submonoid.closure _ ≤ unitaryPowerMonoid v
    apply Submonoid.closure_le.mpr
    intro x hx
    rcases hx with hx | hx
    · obtain rfl := Set.mem_singleton_iff.mp hx
      exact ⟨1,by simp⟩
    · have hx' : x = star (v : A) := by
        have he : star x = (v : A) := by simpa using hx
        exact (star_star x).symm.trans (congrArg star he)
      subst x
      exact ⟨-1,by change (↑(v ^ (-1 : ℤ)) : A) = _; rw [zpow_neg_one]; rfl⟩
  · apply Submodule.span_le.mpr
    rintro x ⟨n,rfl⟩
    exact unitary_power_mem_adjoin v n

end

/-! Centered Laurent polynomials and their norm closure. -/
open scoped Topology
section Algebraic
variable {A : Type*} [Ring A] [StarRing A] [Algebra ℂ A] [StarModule ℂ A]

def nonzeroUnitaryPowers (v : unitary A) : Set A :=
  {x | ∃ n : ℤ,n ≠ 0 ∧ x=(↑(v^n) : A)}

def centerLinear (φ : A →ₗ[ℂ] ℂ) : A →ₗ[ℂ] A :=
  LinearMap.id - φ.smulRight (1 : A)

omit [StarRing A] [StarModule ℂ A] in
@[simp] theorem centerLinear_apply (φ : A →ₗ[ℂ] ℂ) (x : A) :
    centerLinear φ x = x-φ x • (1 : A) := rfl

theorem center_adjoin_mem_span (v : unitary A) (φ : A →ₗ[ℂ] ℂ)
    (h1 : φ 1=1) (hhaar : ∀ n : ℤ,n ≠ 0 → φ (↑(v^n) : A)=0)
    (x : A) (hx : x ∈ StarAlgebra.adjoin ℂ {(v : A)}) :
    centerLinear φ x ∈ Submodule.span ℂ (nonzeroUnitaryPowers v) := by
  have hx' : x ∈ Submodule.span ℂ (Set.range (fun n : ℤ => (↑(v^n) : A))) := by
    rw [← unitary_adjoin_eq_span]; exact hx
  clear hx
  induction hx' using Submodule.span_induction with
  | mem x hx =>
    obtain ⟨n,rfl⟩ := hx
    by_cases hn : n=0
    · simp [hn,h1]
    · rw [centerLinear_apply,hhaar n hn,zero_smul,sub_zero]
      exact Submodule.subset_span ⟨n,hn,rfl⟩
  | zero => simpa only [map_zero] using (Submodule.span ℂ (nonzeroUnitaryPowers v)).zero_mem
  | add x y hx hy ihx ihy =>
    rw [map_add]; exact Submodule.add_mem _ ihx ihy
  | smul r x hx ih =>
    rw [map_smul]; exact Submodule.smul_mem _ r ih

end Algebraic
section
variable {A : Type*} [NormedRing A] [NormedAlgebra ℂ A]
  [StarRing A] [StarModule ℂ A] [ContinuousStar A]

/-- Every centered element of the actual norm-closed generated star algebra
is a norm limit of linear combinations of nonzero powers. -/
theorem centered_elemental_mem_closedSpan (v : unitary A) (φ : A →L[ℂ] ℂ)
    (h1 : φ 1=1) (hhaar : ∀ n : ℤ,n ≠ 0 → φ (↑(v^n) : A)=0)
    (x : A) (hx : x ∈ StarAlgebra.elemental ℂ (v : A)) (hcenter : φ x=0) :
    x ∈ (Submodule.span ℂ (nonzeroUnitaryPowers v)).topologicalClosure := by
  let S := (Submodule.span ℂ (nonzeroUnitaryPowers v)).topologicalClosure
  let f : A →L[ℂ] A := ContinuousLinearMap.id ℂ A - φ.smulRight (1 : A)
  have hc : IsClosed {y : A | f y ∈ S} := (Submodule.span ℂ (nonzeroUnitaryPowers v)).isClosed_topologicalClosure.preimage f.continuous
  have hp : ∀ y ∈ StarAlgebra.adjoin ℂ {(v : A)},f y ∈ S := by
    intro y hy
    exact Submodule.le_topologicalClosure _ (center_adjoin_mem_span v φ.toLinearMap h1 hhaar y hy)
  have hh : f x ∈ S := closure_minimal hp hc hx
  change x-φ x • (1 : A) ∈ S at hh
  simpa only [hcenter,zero_smul,sub_zero] using hh

end

/-! A continuous functional on a normed algebra extends zero product moments
separately to the closed linear span in each slot. -/
open scoped Topology
section
variable {A : Type*} [NormedRing A] [NormedAlgebra ℂ A]

def sandwichFunctional (φ : A →L[ℂ] ℂ) (a b : A) : A →L[ℂ] ℂ where
  toFun x := φ (a*x*b)
  map_add' x y := by simp only [mul_add,add_mul,map_add]
  map_smul' c x := by simp only [mul_smul_comm,smul_mul_assoc,map_smul,RingHom.id_apply]
  cont := by fun_prop

theorem functional_sandwich_closedSpan (φ : A →L[ℂ] ℂ) (S : Set A) (a b x : A)
    (hx : x ∈ (Submodule.span ℂ S).topologicalClosure)
    (hm : ∀ y ∈ S,φ (a*y*b)=0) : φ (a*x*b)=0 := by
  let f := sandwichFunctional φ a b
  have hs : Submodule.span ℂ S ≤ LinearMap.ker f.toLinearMap := by
    apply Submodule.span_le.mpr
    intro y hy
    exact hm y hy
  exact (Submodule.span ℂ S).topologicalClosure_minimal hs f.isClosed_ker hx

theorem functional_product_closedSpan (φ : A →L[ℂ] ℂ)
    (sets : List (Set A)) (xs : List A) (a : A)
    (hxs : List.Forall₂ (fun S x => x ∈ (Submodule.span ℂ S).topologicalClosure) sets xs)
    (hm : ∀ ys,List.Forall₂ (fun S y => y ∈ S) sets ys → φ (a*ys.prod)=0) :
    φ (a*xs.prod)=0 := by
  induction xs generalizing sets a with
  | nil => cases hxs; exact hm [] .nil
  | cons x xs ih =>
    cases hxs with
    | @cons S x sets xs hx hxs =>
      have hh := functional_sandwich_closedSpan φ S a xs.prod x hx (by
        intro y hy
        apply ih sets (a*y) hxs
        intro ys hys
        simpa only [List.prod_cons,mul_assoc] using hm (y::ys) (.cons hy hys))
      simpa only [List.prod_cons,mul_assoc] using hh

theorem alternatingFrom_closedSpan_slots (S T : Set A) (b : Bool) (xs : List A)
    (hx : alternatingFrom ((Submodule.span ℂ S).topologicalClosure : Set A)
      ((Submodule.span ℂ T).topologicalClosure : Set A) b xs) :
    List.Forall₂ (fun s x => x ∈ (Submodule.span ℂ s).topologicalClosure)
      (alternatingSlotSets S T b xs.length) xs := by
  induction xs generalizing b with
  | nil => exact .nil
  | cons x xs ih =>
    cases b <;> exact .cons hx.1 (ih _ hx.2)

theorem alternatingMomentsZero_closedSpan (φ : A →L[ℂ] ℂ) (S T : Set A)
    (hm : alternatingMomentsZero φ S T) :
    alternatingMomentsZero φ ((Submodule.span ℂ S).topologicalClosure : Set A)
      ((Submodule.span ℂ T).topologicalClosure : Set A) := by
  intro b xs hn hx
  have hh := functional_product_closedSpan φ (alternatingSlotSets S T b xs.length) xs 1
    (alternatingFrom_closedSpan_slots S T b xs hx) (by
      intro ys hys
      have hl : ys.length=xs.length := by
        rw [← hys.length_eq,alternatingSlotSets_length]
      have hy : ys ≠ [] := by
        intro he
        have hz : xs.length=0 := by simpa [he] using hl.symm
        exact hn (List.length_eq_zero_iff.mp hz)
      have ha : alternatingFrom S T b ys := by
        apply (alternatingFrom_slots S T b ys).mpr
        simpa only [hl] using hys
      simpa only [one_mul] using hm b ys hy ha)
  simpa only [one_mul] using hh

/-- Standard freeness: every nonempty alternating product of centered elements
vanishes, starting with either algebra and with no restriction on length parity. -/
def freeSets (φ : A → ℂ) (S T : Set A) : Prop :=
  alternatingMomentsZero φ {x | x ∈ S ∧ φ x=0} {x | x ∈ T ∧ φ x=0}

end

/-! Norm completion of algebraic mixed moments gives full freeness of the
actual generated C*-algebra from the closed base algebra. -/
variable {A : Type*} [NormedRing A] [NormedAlgebra ℂ A]

/-- Centering commutes with norm approximation in a unital subalgebra. -/
theorem centered_subalgebra_closure_mem (φ : A →L[ℂ] ℂ) (h1 : φ 1=1)
    (D : Subalgebra ℂ A) (x : A) (hx : x ∈ D.topologicalClosure) (hcenter : φ x=0) :
    x ∈ (Submodule.span ℂ {d | d ∈ D ∧ φ d=0}).topologicalClosure := by
  let S := Submodule.span ℂ {d | d ∈ D ∧ φ d=0}
  let f : A →L[ℂ] A := ContinuousLinearMap.id ℂ A - φ.smulRight (1 : A)
  have hc : IsClosed {y : A | f y ∈ S.topologicalClosure} :=
    S.isClosed_topologicalClosure.preimage f.continuous
  have hp : ∀ y ∈ D,f y ∈ S.topologicalClosure := by
    intro y hy
    apply Submodule.le_topologicalClosure
    apply Submodule.subset_span
    change y-φ y • (1 : A) ∈ D ∧ φ (y-φ y • (1 : A))=0
    refine ⟨D.sub_mem hy (D.smul_mem D.one_mem _),?_⟩
    simp only [map_sub,map_smul,h1,smul_eq_mul,mul_one,sub_self]
  have hh : f x ∈ S.topologicalClosure := closure_minimal hp hc hx
  change x-φ x • (1 : A) ∈ S.topologicalClosure at hh
  simpa only [hcenter,zero_smul,sub_zero] using hh

variable [StarRing A] [StarModule ℂ A] [ContinuousStar A]

theorem unitary_generated_free_of_power_moments (φ : A →L[ℂ] ℂ) (h1 : φ 1=1)
    (v : unitary A) (D : Subalgebra ℂ A)
    (hhaar : ∀ n : ℤ,n ≠ 0 → φ (↑(v^n) : A)=0)
    (hm : alternatingMomentsZero φ (nonzeroUnitaryPowers v) {d | d ∈ D ∧ φ d=0}) :
    freeSets φ (StarAlgebra.elemental ℂ (v : A)) D.topologicalClosure := by
  have hclosed := alternatingMomentsZero_closedSpan φ _ _ hm
  intro b xs hn hx
  apply hclosed b xs hn
  clear hn
  induction xs generalizing b with
  | nil => trivial
  | cons x xs ih =>
    cases b with
    | true =>
      exact ⟨centered_elemental_mem_closedSpan v φ h1 hhaar x hx.1.1 hx.1.2,ih _ hx.2⟩
    | false =>
      exact ⟨centered_subalgebra_closure_mem φ h1 D x hx.1.1 hx.1.2,ih _ hx.2⟩

end Generator

end

end OAI