import OAI.Analysis.FreeGroupFactor.Reducing

namespace OAI

namespace FreeGroupFactorMain

noncomputable section

universe uG uH uα uι

open Set Metric Filter
open scoped NNReal Topology BigOperators ContDiff

namespace ConjugateSectors

 def basisAction {ι : Type uι} : FreeGroup ι →* MulAut (FreeGroup (FreeGroup ι)) where
  toFun g := FreeGroup.freeGroupCongr (Equiv.mulLeft g)
  map_one' := by
    apply MulEquiv.toMonoidHom_injective
    apply FreeGroup.ext_hom
    intro j
    simp [FreeGroup.freeGroupCongr_apply]
  map_mul' g h := by
    apply MulEquiv.toMonoidHom_injective
    apply FreeGroup.ext_hom
    intro j
    simp [FreeGroup.freeGroupCongr_apply, mul_assoc]

 abbrev Witness (ι : Type uι) := FreeGroup (FreeGroup ι) ⋊[basisAction] FreeGroup ι

 @[simp] theorem basisAction_of {ι : Type uι} (g j : FreeGroup ι) :
    basisAction g (FreeGroup.of j) = FreeGroup.of (g * j) := by
  simp [basisAction, FreeGroup.freeGroupCongr_apply]

 def witness {ι : Type uι} : FreeGroup (Option ι) →* Witness ι :=
  FreeGroup.lift (fun i => match i with
    | none => SemidirectProduct.inl (FreeGroup.of 1)
    | some j => SemidirectProduct.inr (FreeGroup.of j))

 @[simp] theorem witness_some {ι : Type uι} (g : FreeGroup ι) :
    witness (FreeGroup.map Option.some g) = SemidirectProduct.inr g := by
  have hh : (witness (ι := ι)).comp (FreeGroup.map Option.some) = SemidirectProduct.inr := by
    apply FreeGroup.ext_hom
    intro j
    simp [witness]
  exact DFunLike.congr_fun hh g

 @[simp] theorem witness_none {ι : Type uι} :
    witness (FreeGroup.of (none : Option ι)) = SemidirectProduct.inl (FreeGroup.of 1) := by
  simp [witness]

 def conjugate {ι : Type uι} (g : FreeGroup ι) : FreeGroup (Option ι) :=
  FreeGroup.map Option.some g * FreeGroup.of none * (FreeGroup.map Option.some g)⁻¹

 @[simp] theorem witness_conjugate {ι : Type uι} (g : FreeGroup ι) :
    witness (conjugate g) = SemidirectProduct.inl (FreeGroup.of g) := by
  simp only [conjugate, map_mul, map_inv, witness_some, witness_none]
  rw [← map_inv, ← SemidirectProduct.inl_aut, basisAction_of, mul_one]

 def begins {ι : Type uι} [DecidableEq ι] (i : ι) (g : FreeGroup ι) : Prop :=
  ∃ b w, g.toWord = (i, b) :: w

 theorem begins_unique {ι : Type uι} [DecidableEq ι] {i j : ι} {g : FreeGroup ι}
    (hi : begins i g) (hj : begins j g) : i = j := by
  obtain ⟨b, w, hi⟩ := hi
  obtain ⟨c, v, hj⟩ := hj
  rw [hi] at hj
  exact congrArg Prod.fst (List.cons.inj hj).1

 theorem reduce_prepend {ι : Type uι} [DecidableEq ι] (i : ι) (b : Bool)
    (w : List (ι × Bool)) (hw : FreeGroup.reduce w = w)
    (hhead : ∀ c v, w ≠ (i, c) :: v) (n : ℕ) :
    FreeGroup.reduce (List.replicate n (i, b) ++ w) = List.replicate n (i, b) ++ w := by
  induction n with
  | zero => simpa using hw
  | succ n ih =>
    rw [List.replicate_succ, List.cons_append, FreeGroup.reduce.cons, ih]
    cases n with
    | zero =>
      cases w with
      | nil => rfl
      | cons a v =>
        rcases a with ⟨j, c⟩
        have hij : i ≠ j := by
          intro he
          subst j
          exact hhead c v rfl
        simp [hij]
    | succ n => simp [List.replicate_succ]

 theorem begins_pow_mul {ι : Type uι} [DecidableEq ι] (i : ι) (g : FreeGroup ι)
    (hg : ¬ begins i g) (k : ℤ) (hk : k ≠ 0) : begins i ((FreeGroup.of i) ^ k * g) := by
  have hh : ∀ c v, g.toWord ≠ (i, c) :: v := by
    intro c v eq
    exact hg ⟨c, v, eq⟩
  cases k with
  | ofNat n =>
    cases n with
    | zero => exact (hk rfl).elim
    | succ n =>
      refine ⟨true, List.replicate n (i, true) ++ g.toWord, ?_⟩
      rw [Int.ofNat_eq_natCast, zpow_natCast, FreeGroup.toWord_mul, FreeGroup.toWord_of_pow,
        reduce_prepend i true g.toWord (FreeGroup.reduce_toWord g) hh]
      simp [List.replicate_succ]
  | negSucc n =>
    refine ⟨false, List.replicate n (i, false) ++ g.toWord, ?_⟩
    rw [zpow_negSucc, FreeGroup.toWord_mul, FreeGroup.toWord_inv, FreeGroup.toWord_of_pow]
    simp only [FreeGroup.invRev, List.reverse_replicate, List.map_replicate, Bool.not_true]
    rw [reduce_prepend i false g.toWord (FreeGroup.reduce_toWord g) hh]
    simp [List.replicate_succ]

 def sector {ι : Type uι} [DecidableEq ι] (i : FreeGroup ι) : Set (FreeGroup (Option ι)) :=
  {g | begins i (witness g).left}

 theorem sector_disjoint {ι : Type uι} [DecidableEq ι] {i j : FreeGroup ι} (hij : i ≠ j) :
    Disjoint (sector i) (sector j) := by
  rw [Set.disjoint_left]
  intro g hi hj
  exact hij (begins_unique hi hj)

 theorem sector_prefix {ι : Type uι} [DecidableEq ι] (i : FreeGroup ι)
    (g : FreeGroup (Option ι)) (hg : g ∉ sector i) (k : ℤ) (hk : k ≠ 0) :
    (conjugate i) ^ k * g ∈ sector i := by
  change begins i (witness ((conjugate i) ^ k * g)).left
  rw [map_mul, map_zpow, witness_conjugate, ← map_zpow]
  simp only [SemidirectProduct.mul_left, SemidirectProduct.left_inl,
    SemidirectProduct.right_inl, map_one, MulAut.one_apply]
  exact begins_pow_mul i (witness g).left hg k hk

end ConjugateSectors

namespace CoordinateProjection

abbrev Hilbert (α : Type uα) := lp (fun _ : α => ℂ) 2

def restrict {α : Type uα} (s : Set α) (ξ : Hilbert α) : Hilbert α := by
  classical
  refine ⟨s.indicator ξ, (lp.memℓp ξ).mono' ?_⟩
  intro a
  by_cases ha : a ∈ s <;> simp [Set.indicator, ha]

@[simp] theorem restrict_apply {α : Type uα} (s : Set α) (ξ : Hilbert α) (a : α) :
    restrict s ξ a = s.indicator ξ a := rfl

theorem norm_restrict_le {α : Type uα} (s : Set α) (ξ : Hilbert α) :
    ‖restrict s ξ‖ ≤ ‖ξ‖ := by
  classical
  apply lp.norm_mono (by norm_num)
  intro a
  by_cases ha : a ∈ s <;> simp [Set.indicator, ha]

def linearMap {α : Type uα} (s : Set α) : Hilbert α →ₗ[ℂ] Hilbert α where
  toFun := restrict s
  map_add' ξ η := by
    classical
    ext a
    by_cases ha : a ∈ s <;> simp [Set.indicator, ha]
  map_smul' c ξ := by
    classical
    ext a
    by_cases ha : a ∈ s <;> simp [Set.indicator, ha]

def proj {α : Type uα} (s : Set α) : Hilbert α →L[ℂ] Hilbert α :=
  (linearMap s).mkContinuous 1 (fun ξ => by
    change ‖restrict s ξ‖ ≤ 1 * ‖ξ‖
    simpa only [one_mul] using norm_restrict_le s ξ)

@[simp] theorem proj_apply {α : Type uα} (s : Set α) (ξ : Hilbert α) (a : α) :
    proj s ξ a = s.indicator ξ a := rfl

theorem norm_proj_le {α : Type uα} (s : Set α) : ‖proj s‖ ≤ 1 := by
  apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one
  intro ξ
  change ‖restrict s ξ‖ ≤ 1 * ‖ξ‖
  simpa only [one_mul] using norm_restrict_le s ξ

theorem star_proj {α : Type uα} (s : Set α) : star (proj s) = proj s := by
  classical
  rw [ContinuousLinearMap.star_eq_adjoint, eq_comm, ContinuousLinearMap.eq_adjoint_iff]
  intro ξ η
  simp only [lp.inner_eq_tsum]
  apply tsum_congr
  intro a
  by_cases ha : a ∈ s <;> simp [Set.indicator, ha]

theorem proj_orthogonal {α : Type uα} (s t : Set α) (hst : Disjoint s t)
    (ξ η : Hilbert α) : inner ℂ (proj s ξ) (proj t η) = 0 := by
  classical
  rw [lp.inner_eq_tsum]
  have hz (a : α) : inner ℂ (proj s ξ a) (proj t η a) = 0 := by
    by_cases hs : a ∈ s
    · have ht : a ∉ t := fun ht => Set.disjoint_left.mp hst hs ht
      simp [Set.indicator, ht]
    · simp [Set.indicator, hs]
  simp only [hz, tsum_zero]

@[simp] theorem complement_apply {α : Type uα} (s : Set α) (ξ : Hilbert α) (a : α) :
    ((1 - proj s) ξ) a = sᶜ.indicator ξ a := by
  classical
  by_cases ha : a ∈ s <;> simp [Set.indicator, ha]

end CoordinateProjection

open scoped BigOperators
namespace FreeSum
variable {ι : Type uι} {H : Type uH} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
local notation "Op" => H →L[ℂ] H

omit [CompleteSpace H] in
theorem norm_sum_sq (s : Finset ι) (v : ι → H)
    (hv : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → inner ℂ (v i) (v j) = 0) :
    ‖∑ i ∈ s, v i‖ ^ 2 = ∑ i ∈ s, ‖v i‖ ^ 2 := by
  classical
  have hh : inner ℂ (∑ i ∈ s, v i) (∑ i ∈ s, v i) =
      ∑ i ∈ s, inner ℂ (v i) (v i) := by
    rw [sum_inner]
    apply Finset.sum_congr rfl
    intro i hi
    rw [inner_sum]
    apply Finset.sum_eq_single i
    · intro j hj hji
      exact hv i hi j hj hji.symm
    · simp_all
  simp only [inner_self_eq_norm_sq_to_K] at hh
  exact_mod_cast hh

omit [CompleteSpace H] in

theorem norm_sum_orthogonal (s : Finset ι) (T : ι → Op) (b : ι → ℝ)
    (hT : ∀ i ∈ s, ‖T i‖ ≤ b i)
    (horth : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → ∀ x y,
      inner ℂ (T i x) (T j y) = 0) :
    ‖∑ i ∈ s, T i‖ ≤ Real.sqrt (∑ i ∈ s, b i ^ 2) := by
  classical
  apply ContinuousLinearMap.opNorm_le_bound _ (Real.sqrt_nonneg _)
  intro x
  simp only [sum_apply]
  have hsq := norm_sum_sq s (fun i => T i x) (fun i hi j hj hij => horth i hi j hj hij x x)
  have hle : ∑ i ∈ s, ‖T i x‖ ^ 2 ≤ (∑ i ∈ s, b i ^ 2) * ‖x‖ ^ 2 := by
    rw [Finset.sum_mul]
    apply Finset.sum_le_sum
    intro i hi
    have hnorm : ‖T i x‖ ≤ b i * ‖x‖ :=
      (T i).le_opNorm x |>.trans (mul_le_mul_of_nonneg_right (hT i hi) (norm_nonneg x))
    calc
      ‖T i x‖ ^ 2 ≤ (b i * ‖x‖) ^ 2 := pow_le_pow_left₀ (norm_nonneg _) hnorm _
      _ = b i ^ 2 * ‖x‖ ^ 2 := mul_pow _ _ _
  have hsum : 0 ≤ ∑ i ∈ s, b i ^ 2 := Finset.sum_nonneg fun _ _ => sq_nonneg _
  have hsqrt := Real.sq_sqrt hsum
  have hn := norm_nonneg (∑ i ∈ s, T i x)
  have hr := mul_nonneg (Real.sqrt_nonneg (∑ i ∈ s, b i ^ 2)) (norm_nonneg x)
  nlinarith

omit [CompleteSpace H] in

theorem norm_weighted_sum_orthogonal (s : Finset ι) (T : ι → Op) (k : ι → ℝ)
    (K : ℝ) (hK : 0 ≤ K) (hT : ∀ i ∈ s, ‖T i‖ ≤ K)
    (horth : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → ∀ x y,
      inner ℂ (T i x) (T j y) = 0) :
    ‖∑ i ∈ s, (k i : ℂ) • T i‖ ≤ K * Real.sqrt (∑ i ∈ s, k i ^ 2) := by
  have hh := norm_sum_orthogonal s (fun i => (k i : ℂ) • T i)
    (fun i => |k i| * K) (by
      intro i hi
      rw [norm_smul, Complex.norm_real, Real.norm_eq_abs]
      exact mul_le_mul_of_nonneg_left (hT i hi) (abs_nonneg _)) (by
      intro i hi j hj hij x y
      simp only [smul_apply, inner_smul_left, inner_smul_right,
        horth i hi j hj hij, mul_zero])
  have hs : Real.sqrt (∑ i ∈ s, (|k i| * K) ^ 2) =
      K * Real.sqrt (∑ i ∈ s, k i ^ 2) := by
    simp_rw [mul_pow, sq_abs]
    rw [← Finset.sum_mul, Real.sqrt_mul (Finset.sum_nonneg fun _ _ => sq_nonneg _),
      Real.sqrt_sq hK, mul_comm]
  rwa [hs] at hh

theorem three_block_bound (s : Finset ι) (P S : ι → Op) (k : ι → ℝ)
    (K : ℝ) (hK : 0 ≤ K)
    (hP : ∀ i ∈ s, star (P i) = P i) (hPn : ∀ i ∈ s, ‖P i‖ ≤ 1)
    (hS : ∀ i ∈ s, star (S i) = S i) (hSn : ∀ i ∈ s, ‖S i‖ ≤ K)
    (horth : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → ∀ x y,
      inner ℂ (P i x) (P j y) = 0)
    (hcompression : ∀ i ∈ s, (1 - P i) * S i * (1 - P i) = 0) :
    ‖∑ i ∈ s, (k i : ℂ) • S i‖ ≤ 3 * K * Real.sqrt (∑ i ∈ s, k i ^ 2) := by
  classical
  let A : Op := ∑ i ∈ s, (k i : ℂ) • (P i * S i)
  let D : Op := ∑ i ∈ s, (k i : ℂ) • (P i * S i * P i)
  have hPS (i : ι) (hi : i ∈ s) : ‖P i * S i‖ ≤ K := by
    calc
      ‖P i * S i‖ ≤ ‖P i‖ * ‖S i‖ := norm_mul_le _ _
      _ ≤ 1 * K := mul_le_mul (hPn i hi) (hSn i hi) (norm_nonneg _) (by norm_num)
      _ = K := one_mul _
  have hA : ‖A‖ ≤ K * Real.sqrt (∑ i ∈ s, k i ^ 2) := by
    apply norm_weighted_sum_orthogonal s _ k K hK hPS
    intro i hi j hj hij x y
    exact horth i hi j hj hij (S i x) (S j y)
  have hD : ‖D‖ ≤ K * Real.sqrt (∑ i ∈ s, k i ^ 2) := by
    apply norm_weighted_sum_orthogonal s _ k K hK
    · intro i hi
      calc
        ‖P i * S i * P i‖ ≤ ‖P i * S i‖ * ‖P i‖ := norm_mul_le _ _
        _ ≤ K * 1 := mul_le_mul (hPS i hi) (hPn i hi) (norm_nonneg _) hK
        _ = K := mul_one _
    · intro i hi j hj hij x y
      exact horth i hi j hj hij (S i (P i x)) (S j (P j y))
  have heq : (∑ i ∈ s, (k i : ℂ) • S i) = A + star A - D := by
    dsimp [A, D]
    simp only [star_sum, star_smul, star_trivial,
      star_mul, ← Finset.sum_add_distrib, ← Finset.sum_sub_distrib]
    apply Finset.sum_congr rfl
    intro i hi
    rw [hP i hi, hS i hi, ← smul_add, ← smul_sub]
    congr 1
    apply sub_eq_zero.mp
    calc
      S i - (P i * S i + S i * P i - P i * S i * P i) =
          (1 - P i) * S i * (1 - P i) := by noncomm_ring
      _ = 0 := hcompression i hi
  rw [heq]
  calc
    ‖A + star A - D‖ ≤ ‖A + star A‖ + ‖D‖ := norm_sub_le _ _
    _ ≤ (‖A‖ + ‖star A‖) + ‖D‖ := by gcongr; exact norm_add_le _ _
    _ = 2 * ‖A‖ + ‖D‖ := by rw [norm_star]; ring
    _ ≤ 2 * (K * Real.sqrt (∑ i ∈ s, k i ^ 2)) +
        K * Real.sqrt (∑ i ∈ s, k i ^ 2) := by gcongr
    _ = _ := by ring

end FreeSum

open scoped BigOperators ENNReal
open ConjugateSectors CoordinateProjection

 theorem operator_eq_zero_of_single {α : Type uα} [DecidableEq α]
    (T : GroupOperator α) (hT : ∀ g, T (lp.single 2 g 1) = 0) : T = 0 := by
  apply operator_matrix_ext
  intro g
  simpa only [zero_apply] using hT g

 theorem sector_compression {ι : Type uι} [DecidableEq ι] (i : FreeGroup ι)
    (T : groupVonNeumann (FreeGroup (Option ι)))
    (hsupport : ∀ g, ((T : GroupOperator _) (lp.single 2 1 1)) g ≠ 0 →
      ∃ k : ℤ, k ≠ 0 ∧ g = conjugate i ^ k) :
    (1 - proj (sector i)) * (T : GroupOperator _) * (1 - proj (sector i)) = 0 := by
  classical
  apply operator_eq_zero_of_single
  intro y
  have hQ : (1 - proj (sector i)) (lp.single 2 y 1) =
      if y ∈ sector i then 0 else lp.single 2 y 1 := by
    ext x
    by_cases hy : y ∈ sector i <;> by_cases hx : x ∈ sector i <;>
      simp_all [Set.indicator, lp.single_apply, Pi.single_apply] <;>
      intro he <;> subst x <;> contradiction
  change (1 - proj (sector i)) ((T : GroupOperator _)
    ((1 - proj (sector i)) (lp.single 2 y 1))) = 0
  rw [hQ]
  split_ifs with hy
  · simp
  · ext x
    change ((1 - proj (sector i)) ((T : GroupOperator _) (lp.single 2 y 1))) x = 0
    rw [complement_apply]
    by_cases hx : x ∈ sector i
    · simp [Set.indicator, hx]
    · simp only [Set.indicator_of_mem (Set.mem_compl hx)]
      rw [groupVN_matrix]
      by_contra hne
      obtain ⟨k, hk, he⟩ := hsupport (x * y⁻¹) (by rwa [deltaOne_eq] at hne)
      have hx' : x = conjugate i ^ k * y := by
        rw [← he, inv_mul_cancel_right]
      exact hx (hx'.symm ▸ sector_prefix i y hy k hk)

 theorem concrete_free_sum {ι : Type uι} [DecidableEq ι]
    (s : Finset (FreeGroup ι)) (T : FreeGroup ι → groupVonNeumann (FreeGroup (Option ι)))
    (k : FreeGroup ι → ℝ) (K : ℝ) (hK : 0 ≤ K)
    (hsa : ∀ i ∈ s, star (T i) = T i) (hn : ∀ i ∈ s, ‖T i‖ ≤ K)
    (hsupport : ∀ i ∈ s, ∀ g, ((T i : GroupOperator (FreeGroup (Option ι))) (lp.single 2 1 1)) g ≠ 0 →
      ∃ m : ℤ, m ≠ 0 ∧ g = conjugate i ^ m) :
    ‖∑ i ∈ s, (k i : ℂ) • (T i : GroupOperator (FreeGroup (Option ι)))‖ ≤
      3 * K * Real.sqrt (∑ i ∈ s, k i ^ 2) := by
  apply FreeSum.three_block_bound s (fun i => proj (sector i))
    (fun i => (T i : GroupOperator (FreeGroup (Option ι)))) k K hK
  · intro i _; exact star_proj _
  · intro i _; exact norm_proj_le _
  · intro i hi; exact congrArg Subtype.val (hsa i hi)
  · exact hn
  · intro i _ j _ hij x y
    exact proj_orthogonal _ _ (sector_disjoint hij) x y
  · intro i hi
    exact sector_compression i (T i) (hsupport i hi)

open scoped BigOperators

@[simp] theorem groupUnitary_mul {G : Type uG} [Group G] (g h : G) :
    groupUnitary (g*h) = groupUnitary g * groupUnitary h := by
  apply Subtype.ext
  exact leftRegular_mul g h

@[simp] theorem groupUnitary_inv {G : Type uG} [Group G] (g : G) :
    groupUnitary g⁻¹ = star (groupUnitary g) := by
  apply Subtype.ext
  exact (leftRegular_star g).symm

@[simp] theorem groupUnitary_one {G : Type uG} [Group G] : groupUnitary (1 : G) = 1 := by
  apply Subtype.ext
  exact leftRegular_one

def groupLaurent {G : Type uG} [Group G] (g : G) (l : ℤ →₀ ℂ) : groupVonNeumann G :=
  l.sum (fun m c => c • groupUnitary (g^m))

theorem groupLaurent_conjugate {G : Type uG} [Group G] (g c : G) (l : ℤ →₀ ℂ) :
    groupLaurent (g*c*g⁻¹) l = groupUnitary g * groupLaurent c l * star (groupUnitary g) := by
  classical
  simp only [groupLaurent, Finsupp.sum, Finset.mul_sum, Finset.sum_mul,
    mul_smul_comm, smul_mul_assoc]
  apply Finset.sum_congr rfl
  intro m _hm
  rw [conj_zpow, groupUnitary_mul, groupUnitary_mul, groupUnitary_inv]

theorem groupLaurent_coe {G : Type uG} [Group G] (c : G) (l : ℤ →₀ ℂ) :
    (groupLaurent c l : GroupOperator G) = ∑ m ∈ l.support, l m • leftRegular (c^m) := by
  change (groupVonNeumann G).subtype (∑ m ∈ l.support, l m • groupUnitary (c^m)) = _
  simp only [map_sum, map_smul]
  rfl

theorem groupLaurent_support {G : Type uG} [Group G] [DecidableEq G]
    (c : G) (l : ℤ →₀ ℂ) (h0 : l 0 = 0) (x : G)
    (hne : ((groupLaurent c l : GroupOperator G) (lp.single 2 1 1)) x ≠ 0) :
    ∃ m : ℤ, m ≠ 0 ∧ x = c^m := by
  classical
  by_contra! hn
  apply hne
  rw [groupLaurent_coe]
  simp only [sum_apply, smul_apply,
    lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul, Pi.smul_apply, smul_eq_mul]
  apply Finset.sum_eq_zero
  intro m hm
  have hm0 : m ≠ 0 := by
    intro he
    subst m
    exact (Finsupp.mem_support_iff.mp hm) h0
  simp [leftRegular_apply, lp.single_apply, inv_mul_eq_one, (hn m hm0).symm]

theorem centered_laurent_free_sum {ι : Type uι} [DecidableEq ι]
    (l : ℤ →₀ ℂ) (h0 : l 0 = 0)
    (hsa : IsSelfAdjoint (groupLaurent (FreeGroup.of (none : Option ι)) l))
    (K : ℝ) (hK : 0 ≤ K)
    (hn : ‖groupLaurent (FreeGroup.of (none : Option ι)) l‖ ≤ K)
    (k : FreeGroup ι →₀ ℝ) :
    ‖k.sum (fun g r => (r : ℂ) • groupLaurent (ConjugateSectors.conjugate g) l)‖ ≤
      3*K*Real.sqrt (k.sum (fun _ r => r^2)) := by
  classical
  have he (g : FreeGroup ι) := groupLaurent_conjugate
    (FreeGroup.map Option.some g) (FreeGroup.of (none : Option ι)) l
  change ‖(groupVonNeumann (FreeGroup (Option ι))).subtype
    (∑ g ∈ k.support, (k g : ℂ) • groupLaurent (ConjugateSectors.conjugate g) l)‖ ≤ _
  simp only [map_sum, map_smul]
  apply concrete_free_sum k.support (fun g => groupLaurent (ConjugateSectors.conjugate g) l)
    k K hK
  · intro g _hg
    rw [ConjugateSectors.conjugate] at *
    rw [he, star_mul, star_mul, star_star, hsa.star_eq, mul_assoc]
  · intro g _hg
    change ‖(groupLaurent (ConjugateSectors.conjugate g) l : GroupOperator (FreeGroup (Option ι)))‖ ≤ _
    rw [ConjugateSectors.conjugate, he]
    change ‖leftRegular _ * (groupLaurent (FreeGroup.of (none : Option ι)) l :
      GroupOperator (FreeGroup (Option ι))) * star (leftRegular _)‖ ≤ _
    rw [CStarRing.norm_mul_mem_unitary _ (Unitary.star_mem (leftRegular_unitary _)),
      CStarRing.norm_mem_unitary_mul _ (leftRegular_unitary _)]
    exact hn
  · intro g _hg x hx
    exact groupLaurent_support _ l h0 x hx

end

end FreeGroupFactorMain

end OAI