lean/OAI/RepresentationTheory/SignedTensor/Blocks.lean

import Mathlib
import OAI.RepresentationTheory.SignedTensor.Domination

namespace OAI

noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ComplexConjugate Matrix.Norms.L2Operator
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ComplexOrder MatrixOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ENNReal
open MeasureTheory

namespace CoordinateSweeps.SignedTensor
variable {B : Type} [Fintype B] [DecidableEq B]

/- Tensorization of finite density domination, preserving
finite probability normalization and the exact product of local dimensions. -/
theorem finite_block_density_domination (s p : ℕ) (hp : 0 < p) (hps : p ≤ s)
    (l : B → ℕ) (hl : ∀ i, l i ≤ s) (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (l i)))) :
    ∃ (K : Type) (_ : Fintype K) (_ : Nonempty K) (r : K → B → EvenDensity p),
      (((∏ i, ((ρ i).dimension : ℂ))*((s+1 : ℕ) : ℂ)^(Fintype.card B*(41*p^2))) •
        ((Fintype.card K : ℂ)⁻¹ • ∑ x, DependentTensor.tensor (fun i => densityPower (l i) (r x i).val))-
          DependentTensor.tensor (fun i => isotypic (p := p) (ρ i))).PosSemidef := by
  choose K fK nK r hr using fun i => finite_density_domination s p (l i) hp hps (hl i) (ρ i)
  let : ∀ i, Fintype (K i) := fK
  let : ∀ i, Nonempty (K i) := nK
  refine ⟨(∀ i, K i),inferInstance,inferInstance,fun x i => r i (x i),?_⟩
  have hh := DependentTensor.tensor_mono
    (fun i => isotypic (p := p) (ρ i))
    (fun i => (((ρ i).dimension : ℂ)*((s+1 : ℕ) : ℂ)^(41*p^2)) •
      ((Fintype.card (K i) : ℂ)⁻¹ • ∑ x, densityPower (l i) (r i x).val))
    (fun i => isotypic_posSemidef (ρ i)) hr
  rw [DependentTensor.tensor_smul] at hh
  have hm : DependentTensor.tensor (fun i => (Fintype.card (K i) : ℂ)⁻¹ •
      ∑ x, densityPower (l i) (r i x).val) =
      (Fintype.card (∀ i, K i) : ℂ)⁻¹ • ∑ x : ∀ i, K i,
        DependentTensor.tensor (fun i => densityPower (l i) (r i (x i)).val) := by
    simp only [Finset.smul_sum]
    rw [DependentTensor.tensor_mixture]
    rw [Fintype.card_pi,Nat.cast_prod,Finset.prod_inv_distrib]
  have hc : (∏ i, ((ρ i).dimension : ℂ)*((s+1 : ℕ) : ℂ)^(41*p^2)) =
      (∏ i, ((ρ i).dimension : ℂ))*((s+1 : ℕ) : ℂ)^(Fintype.card B*(41*p^2)) := by
    rw [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,← pow_mul,mul_comm (41*p^2)]
  rwa [hm,hc] at hh

end CoordinateSweeps.SignedTensor

noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder

noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable
namespace CoordinateSweeps.OrderedBlocks
variable {r : ℕ} (n : Fin r → ℕ)

def offset (i : Fin r) : ℕ := ∑ j ∈ Finset.Iio i, n j

lemma offset_next_le (i j : Fin r) (hij : i < j) : offset n i+n i ≤ offset n j := by
  have he : Finset.Iic i=insert i (Finset.Iio i) := by ext x; simp [le_iff_lt_or_eq,or_comm]
  have hh : ∑ k ∈ Finset.Iic i, n k ≤ ∑ k ∈ Finset.Iio j, n k :=
    Finset.sum_le_sum_of_subset (fun k hk => Finset.mem_Iio.mpr (lt_of_le_of_lt (Finset.mem_Iic.mp hk) hij))
  rw [he,Finset.sum_insert (by simp)] at hh
  simpa only [offset,add_comm] using hh

lemma offset_next_le_total (i : Fin r) : offset n i+n i ≤ ∑ j, n j := by
  have he : Finset.Iic i=insert i (Finset.Iio i) := by ext x; simp [le_iff_lt_or_eq,or_comm]
  have hh : ∑ k ∈ Finset.Iic i, n k ≤ ∑ k, n k := Finset.sum_le_sum_of_subset (Finset.subset_univ _)
  rw [he,Finset.sum_insert (by simp)] at hh
  simpa only [offset,add_comm] using hh

def encode (x : (i : Fin r) × Fin (n i)) : Fin (∑ i, n i) :=
  ⟨offset n x.1+x.2,lt_of_lt_of_le (Nat.add_lt_add_left x.2.isLt _) (offset_next_le_total n x.1)⟩

lemma encode_lt_of_block {i j : Fin r} (hij : i < j) (a : Fin (n i)) (b : Fin (n j)) :
    encode n ⟨i,a⟩ < encode n ⟨j,b⟩ := by
  change offset n i+a.val < offset n j+b.val
  have hh := offset_next_le n i j hij
  have ha := a.isLt
  omega

lemma encode_lt_same {i : Fin r} (a b : Fin (n i)) :
    encode n ⟨i,a⟩ < encode n ⟨i,b⟩ ↔ a < b := by
  change offset n i+a.val < offset n i+b.val ↔ a.val < b.val
  omega

lemma encode_injective : Function.Injective (encode n) := by
  rintro ⟨i,a⟩ ⟨j,b⟩ h
  have hi : i=j := by
    rcases lt_trichotomy i j with hij | hij | hij
    · exact False.elim ((ne_of_lt (encode_lt_of_block n hij a b)) h)
    · exact hij
    · exact False.elim ((ne_of_lt (encode_lt_of_block n hij b a)) h.symm)
  subst j
  have hab : a=b := Fin.ext (by have hh := congrArg Fin.val h; dsimp [encode] at hh; omega)
  subst b
  rfl

/- Explicit contiguous coordinate chart, including zero-length blocks. -/
def positions : ((i : Fin r) × Fin (n i)) ≃ Fin (∑ i, n i) :=
  Equiv.ofBijective (encode n) ((Fintype.bijective_iff_injective_and_card _).mpr
    ⟨encode_injective n,by simp [Fintype.card_sigma]⟩)

lemma positions_apply (x : (i : Fin r) × Fin (n i)) : positions n x=encode n x := rfl

lemma positions_lt_of_block {i j : Fin r} (hij : i < j) (a : Fin (n i)) (b : Fin (n j)) :
    positions n ⟨i,a⟩ < positions n ⟨j,b⟩ := encode_lt_of_block n hij a b

lemma positions_lt_same {i : Fin r} (a b : Fin (n i)) :
    positions n ⟨i,a⟩ < positions n ⟨i,b⟩ ↔ a < b := encode_lt_same n a b

def perm (σ : ∀ i, Equiv.Perm (Fin (n i))) : Equiv.Perm (Fin (∑ i, n i)) :=
  (positions n).permCongr (Equiv.sigmaCongrRight σ)

@[simp] lemma perm_apply (σ : ∀ i, Equiv.Perm (Fin (n i))) (i : Fin r) (j : Fin (n i)) :
    perm n σ (positions n ⟨i,j⟩)=positions n ⟨i,σ i j⟩ := by
  simp [perm,Equiv.permCongr_apply]

lemma perm_inv (σ : ∀ i, Equiv.Perm (Fin (n i))) :
    (perm n σ)⁻¹=perm n (fun i => (σ i)⁻¹) := by
  apply Equiv.ext
  intro x
  obtain ⟨⟨i,j⟩,rfl⟩ := (positions n).surjective x
  apply (perm n σ).injective
  simp

def permHom : (∀ i, Equiv.Perm (Fin (n i))) →* Equiv.Perm (Fin (∑ i, n i)) where
  toFun := perm n
  map_one' := by
    apply Equiv.ext; intro x
    obtain ⟨⟨i,j⟩,rfl⟩ := (positions n).surjective x
    simp
  map_mul' σ τ := by
    apply Equiv.ext; intro x
    obtain ⟨⟨i,j⟩,rfl⟩ := (positions n).surjective x
    simp

end CoordinateSweeps.OrderedBlocks

namespace CoordinateSweeps.SignedTensor

lemma phase_double_prod {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l) :
    phase σ w=∏ i : Fin l, ∏ j : Fin l,
      if j < i ∧ odd (w i) ∧ odd (w j) ∧ σ i < σ j then (-1 : ℂ) else 1 := by
  have he : Equiv.Perm.finPairsLT l=(Finset.univ : Finset ((i : Fin l) × Fin l)).filter (fun x => x.2 < x.1) := by
    ext x
    simp only [Equiv.Perm.mem_finPairsLT,Finset.mem_filter,Finset.mem_univ,true_and]
  rw [phase_prod,he,Finset.prod_filter,Fintype.prod_sigma]
  apply Finset.prod_congr rfl
  intro i hi
  apply Finset.prod_congr rfl
  intro j hj
  split_ifs <;> simp_all

def blockPerm {m n : ℕ} (σ : Equiv.Perm (Fin m)) (τ : Equiv.Perm (Fin n)) :
    Equiv.Perm (Fin (m+n)) := finSumFinEquiv.permCongr (Equiv.Perm.sumCongr σ τ)

@[simp] lemma blockPerm_left {m n : ℕ} (σ : Equiv.Perm (Fin m)) (τ : Equiv.Perm (Fin n)) (i : Fin m) :
    blockPerm σ τ (Fin.castAdd n i)=Fin.castAdd n (σ i) := by
  simp [blockPerm,Equiv.permCongr_apply]

@[simp] lemma blockPerm_right {m n : ℕ} (σ : Equiv.Perm (Fin m)) (τ : Equiv.Perm (Fin n)) (i : Fin n) :
    blockPerm σ τ (Fin.natAdd m i)=Fin.natAdd m (τ i) := by
  simp [blockPerm,Equiv.permCongr_apply]

lemma blockPerm_inv {m n : ℕ} (σ : Equiv.Perm (Fin m)) (τ : Equiv.Perm (Fin n)) :
    (blockPerm σ τ)⁻¹=blockPerm σ⁻¹ τ⁻¹ := by
  apply Equiv.ext
  intro i
  apply (blockPerm σ τ).injective
  induction i using Fin.addCases <;> simp

lemma phase_blockPerm {p m n : ℕ} (σ : Equiv.Perm (Fin m)) (τ : Equiv.Perm (Fin n))
    (w : Word p (m+n)) :
    phase (blockPerm σ τ) w=phase σ (fun i => w (Fin.castAdd n i))*
      phase τ (fun i => w (Fin.natAdd m i)) := by
  have hlr (i : Fin m) (j : Fin n) : ¬ Fin.natAdd m j<Fin.castAdd n i := by
    simp only [Fin.lt_def,Fin.val_natAdd,Fin.val_castAdd]
    omega
  have hll (i j : Fin m) : Fin.castAdd n i<Fin.castAdd n j ↔ i<j := Iff.rfl
  have hrr (i j : Fin n) : Fin.natAdd m i<Fin.natAdd m j ↔ i<j := by
    simp only [Fin.lt_def,Fin.val_natAdd,Nat.add_lt_add_iff_left]
  simp only [phase_double_prod]
  rw [Fin.prod_univ_add]
  simp_rw [Fin.prod_univ_add]
  simp only [blockPerm_left,blockPerm_right,hlr,false_and,and_false,ite_false,
    Finset.prod_const_one,mul_one,one_mul,hll,hrr]

/- The explicit unitary reindexing between a concatenated tensor word and
its two block words. The Koszul signs are retained in phase_blockPerm. -/
def splitWord (p m n : ℕ) : Word p (m+n) ≃ Word p m × Word p n where
  toFun w := (fun i => w (Fin.castAdd n i),fun i => w (Fin.natAdd m i))
  invFun w := Fin.addCases w.1 w.2
  left_inv w := by funext i; induction i using Fin.addCases <;> simp
  right_inv w := by ext <;> simp

lemma splitWord_wordPerm {p m n : ℕ} (σ : Equiv.Perm (Fin m)) (τ : Equiv.Perm (Fin n))
    (w : Word p (m+n)) :
    splitWord p m n (wordPerm (blockPerm σ τ) w)=
      (wordPerm σ (splitWord p m n w).1,wordPerm τ (splitWord p m n w).2) := by
  ext i <;> simp [splitWord,wordPerm,blockPerm_inv]

def blockMatrix {p m n : ℕ} (A : Matrix (Word p m) (Word p m) ℂ)
    (B : Matrix (Word p n) (Word p n) ℂ) : Matrix (Word p (m+n)) (Word p (m+n)) ℂ :=
  fun u w => A (splitWord p m n u).1 (splitWord p m n w).1 *
    B (splitWord p m n u).2 (splitWord p m n w).2

/- Exact block multiplicativity of the signed permutation action. -/
theorem matrix_blockPerm {p m n : ℕ} (σ : Equiv.Perm (Fin m)) (τ : Equiv.Perm (Fin n)) :
    matrix (p := p) (blockPerm σ τ)=blockMatrix (matrix σ) (matrix τ) := by
  ext u w
  have he : u=wordPerm (blockPerm σ τ) w ↔
      (splitWord p m n u).1=wordPerm σ (splitWord p m n w).1 ∧
      (splitWord p m n u).2=wordPerm τ (splitWord p m n w).2 := by
    rw [← (splitWord p m n).injective.eq_iff,splitWord_wordPerm,Prod.mk.injEq]
  simp only [matrix,blockMatrix,he,phase_blockPerm]
  split_ifs <;> simp_all [splitWord]

end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
open OrderedBlocks
variable {p r : ℕ} (n : Fin r → ℕ)

lemma prod_positions (f : Fin (∑ i, n i) → ℂ) :
    ∏ x, f x=∏ i, ∏ j : Fin (n i), f (positions n ⟨i,j⟩) := by
  rw [← Equiv.prod_comp (positions n) f,Fintype.prod_sigma]

lemma phase_grouped (σ : ∀ i, Equiv.Perm (Fin (n i))) (w : Word p (∑ i, n i)) :
    phase (perm n σ) w=∏ i, phase (σ i) (fun j => w (positions n ⟨i,j⟩)) := by
  rw [phase_double_prod,prod_positions n]
  apply Finset.prod_congr rfl
  intro i hi
  rw [phase_double_prod]
  apply Finset.prod_congr rfl
  intro a ha
  rw [prod_positions n,Finset.prod_eq_single i]
  · apply Finset.prod_congr rfl
    intro b hb
    simp only [perm_apply,positions_lt_same]
  · intro j hj hji
    apply Finset.prod_eq_one
    intro b hb
    rcases lt_or_gt_of_ne hji with hlt | hgt
    · have hn : ¬ positions n ⟨i,σ i a⟩ < positions n ⟨j,σ j b⟩ :=
        not_lt_of_ge (positions_lt_of_block n hlt _ _).le
      simp [hn]
    · have hn : ¬ positions n ⟨j,b⟩ < positions n ⟨i,a⟩ :=
        not_lt_of_ge (positions_lt_of_block n hgt _ _).le
      simp [hn]
  · simp

def groupWord (p : ℕ) : Word p (∑ i, n i) ≃ (∀ i, Word p (n i)) where
  toFun w i j := w (positions n ⟨i,j⟩)
  invFun w x := w ((positions n).symm x).1 ((positions n).symm x).2
  left_inv w := by funext x; simp
  right_inv w := by
    funext i j
    change (fun x : (i : Fin r) × Fin (n i) => w x.1 x.2) ((positions n).symm (positions n ⟨i,j⟩)) = _
    rw [Equiv.symm_apply_apply]

lemma groupWord_wordPerm (σ : ∀ i, Equiv.Perm (Fin (n i))) (w : Word p (∑ i, n i)) :
    groupWord n p (wordPerm (perm n σ) w)=fun i => wordPerm (σ i) (groupWord n p w i) := by
  funext i j
  simp [groupWord,wordPerm,perm_inv]

/- Genuine product-subgroup action, with no suppressed Koszul signs. -/
theorem matrix_grouped (σ : ∀ i, Equiv.Perm (Fin (n i))) :
    matrix (p := p) (perm n σ)=
      Matrix.reindex (groupWord n p).symm (groupWord n p).symm
        (DependentTensor.tensor (fun i => matrix (σ i))) := by
  ext u w
  have he : u=wordPerm (perm n σ) w ↔
      ∀ i, groupWord n p u i=wordPerm (σ i) (groupWord n p w i) := by
    rw [← (groupWord n p).injective.eq_iff,groupWord_wordPerm]
    exact funext_iff
  change (if u=wordPerm (perm n σ) w then phase (perm n σ) w else 0)=
    ∏ i, if groupWord n p u i=wordPerm (σ i) (groupWord n p w i)
      then phase (σ i) (groupWord n p w i) else 0
  simp only [he]
  by_cases h : ∀ i, groupWord n p u i=wordPerm (σ i) (groupWord n p w i)
  · rw [ite_eq_left h,phase_grouped]
    simp only [h,ite_true]
    rfl
  · rw [ite_eq_right h]
    obtain ⟨i,hi⟩ := not_forall.mp h
    symm
    apply Finset.prod_eq_zero (Finset.mem_univ i)
    simp [hi]

end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
open OrderedBlocks UnitaryIrrep
variable {p r : ℕ} (n : Fin r → ℕ)

/- The subgroup operator is an actual group-algebra average on the full set
of slots, not an operator posited to factor. -/
def groupedAverage {Ω : Fin r → Type*} [∀ i, Fintype (Ω i)]
    (w : ∀ i, Ω i → ℂ) (g : ∀ i, Ω i → Equiv.Perm (Fin (n i))) :
    Matrix (Word p (∑ i, n i)) (Word p (∑ i, n i)) ℂ :=
  averageMatrix (action p (∑ i, n i)) (fun ω : ∀ i, Ω i => ∏ i, w i (ω i))
    (fun ω => perm n (fun i => g i (ω i)))

lemma groupedAverage_factor {Ω : Fin r → Type*} [∀ i, Fintype (Ω i)]
    (w : ∀ i, Ω i → ℂ) (g : ∀ i, Ω i → Equiv.Perm (Fin (n i))) :
    groupedAverage (p := p) n w g=
      Matrix.reindex (groupWord n p).symm (groupWord n p).symm
        (DependentTensor.tensor (fun i => averageMatrix (action p (n i)) (w i) (g i))) := by
  ext u v
  simp only [groupedAverage,averageMatrix,Matrix.reindex_apply,Matrix.submatrix_apply,
    Equiv.symm_symm,DependentTensor.tensor,Matrix.sum_apply,Matrix.smul_apply,smul_eq_mul]
  change (∑ ω : ∀ i, Ω i, (∏ i, w i (ω i))*
    matrix (perm n (fun i => g i (ω i))) u v)=
      ∏ i, ∑ ω : Ω i, w i ω*matrix (g i ω) (groupWord n p u i) (groupWord n p v i)
  have he (σ : ∀ i, Equiv.Perm (Fin (n i))) :
      matrix (perm n σ) u v=∏ i, matrix (σ i) (groupWord n p u i) (groupWord n p v i) := by
    have hh := congrArg (fun A : Matrix (Word p (∑ i, n i)) (Word p (∑ i, n i)) ℂ => A u v)
      (matrix_grouped (p := p) n σ)
    exact hh
  simp only [he]
  rw [Fintype.prod_sum]
  apply Finset.sum_congr rfl
  intro ω hω
  exact (Finset.prod_mul_distrib :
    (∏ i, w i (ω i)*matrix (g i (ω i)) (groupWord n p u i) (groupWord n p v i))=_).symm

def groupedProjector (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) :
    Matrix (Word p (∑ i, n i)) (Word p (∑ i, n i)) ℂ :=
  groupedAverage n (fun i => (ρ i).coefficient) (fun _ => id)

lemma groupedProjector_factor (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) :
    groupedProjector (p := p) n ρ=
      Matrix.reindex (groupWord n p).symm (groupWord n p).symm
        (DependentTensor.tensor (fun i => (ρ i).projector (action p (n i)))) := by
  exact groupedAverage_factor n _ _

lemma matrix_trace_reindex {X Y : Type*} [Fintype X] [Fintype Y] (e : X ≃ Y)
    (A : Matrix X X ℂ) : Matrix.trace (Matrix.reindex e e A)=Matrix.trace A := by
  exact Equiv.sum_comp e.symm (fun i => A i i)

lemma reindex_moment {X Y : Type*} [Fintype X] [Fintype Y] [DecidableEq X] [DecidableEq Y]
    (e : X ≃ Y) (A : Matrix X X ℂ) (q : ℕ) :
    Matrix.trace ((((Matrix.reindexAlgEquiv ℂ ℂ e A).conjTranspose)*(Matrix.reindexAlgEquiv ℂ ℂ e A))^q)=
      Matrix.trace ((A.conjTranspose*A)^q) := by
  have hs : (Matrix.reindexAlgEquiv ℂ ℂ e A).conjTranspose=
      Matrix.reindexAlgEquiv ℂ ℂ e A.conjTranspose := by ext i j; rfl
  rw [hs,← map_mul,← map_pow]
  exact matrix_trace_reindex e _

/- Exact isotypic child moment factorization, including the true Hom
multiplicities and all zero-length blocks. -/
theorem grouped_projected_moment {Ω : Fin r → Type*} [∀ i, Fintype (Ω i)]
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i))))
    (w : ∀ i, Ω i → ℂ) (g : ∀ i, Ω i → Equiv.Perm (Fin (n i)))
    {q : ℕ} (hq : q ≠ 0) :
    Matrix.trace (((groupedProjector (p := p) n ρ*groupedAverage n w g).conjTranspose*
      (groupedProjector n ρ*groupedAverage n w g))^q)=
      ∏ i, (Module.finrank ℂ ((ρ i).asRepresentation.IntertwiningMap
        (matrixRepresentation (action p (n i)))) : ℂ)*
        Matrix.trace (((averageMatrix (ρ i).matrix (w i) (g i)).conjTranspose*
          averageMatrix (ρ i).matrix (w i) (g i))^q) := by
  rw [groupedProjector_factor,groupedAverage_factor]
  let e := (groupWord n p).symm
  change Matrix.trace (((Matrix.reindexAlgEquiv ℂ ℂ e _*Matrix.reindexAlgEquiv ℂ ℂ e _).conjTranspose*
    (Matrix.reindexAlgEquiv ℂ ℂ e _*Matrix.reindexAlgEquiv ℂ ℂ e _))^q)=_
  rw [← map_mul,reindex_moment,← DependentTensor.tensor_mul,DependentTensor.tensor_moment]
  apply Finset.prod_congr rfl
  intro i hi
  exact (ρ i).projected_operator_moment _ (fun σ => (matrix_inv σ).symm) (w i) (g i) hq

end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
variable {p : ℕ}

def IsEven (A : Matrix (Letter p) (Letter p) ℂ) : Prop :=
  ∀ i j, (odd i ↔ ¬ odd j) → A i j=0

def grading (p : ℕ) : Matrix (Letter p) (Letter p) ℂ :=
  Matrix.diagonal (fun i => if odd i then 1 else 0)

lemma isEven_iff_commute (A : Matrix (Letter p) (Letter p) ℂ) :
    IsEven A ↔ Commute A (grading p) := by
  constructor
  · intro h
    show A*grading p=grading p*A
    ext i j
    simp only [grading,Matrix.mul_diagonal,Matrix.diagonal_mul]
    by_cases hi : odd i
    · by_cases hj : odd j
      · simp [hi,hj]
      · simp [hi,hj,h i j (by tauto)]
    · by_cases hj : odd j
      · simp [hi,hj,h i j (by tauto)]
      · simp [hi,hj]
  · intro h i j hij
    have hh := congrArg (fun M : Matrix (Letter p) (Letter p) ℂ => M i j) h.eq
    simp only [grading,Matrix.mul_diagonal,Matrix.diagonal_mul] at hh
    by_cases hi : odd i
    · have hj : ¬ odd j := hij.mp hi
      simpa [hi,hj] using hh.symm
    · have hj : odd j := by tauto
      simpa [hi,hj] using hh

lemma isEven_add {A B : Matrix (Letter p) (Letter p) ℂ} (hA : IsEven A) (hB : IsEven B) :
    IsEven (A+B) := by intro i j hij; simp only [Matrix.add_apply,hA i j hij,hB i j hij,add_zero]

lemma isEven_smul (c : ℂ) {A : Matrix (Letter p) (Letter p) ℂ} (hA : IsEven A) :
    IsEven (c • A) := by intro i j hij; simp only [Matrix.smul_apply,smul_eq_mul,hA i j hij,mul_zero]

lemma isEven_sum {I : Type*} [Fintype I] (A : I → Matrix (Letter p) (Letter p) ℂ)
    (hA : ∀ i, IsEven (A i)) : IsEven (∑ i, A i) := by
  intro i j hij
  simp only [Matrix.sum_apply]
  exact Finset.sum_eq_zero (fun a _ => hA a i j hij)

lemma isEven_one : IsEven (1 : Matrix (Letter p) (Letter p) ℂ) := by
  intro i j hij
  apply Matrix.one_apply_ne
  intro he
  subst j
  tauto

lemma densityPower_commute_of_even {l : ℕ} (r : Matrix (Letter p) (Letter p) ℂ)
    (hr : IsEven r) (σ : Equiv.Perm (Fin l)) :
    matrix σ*densityPower l r=densityPower l r*matrix σ := by
  have hpar {u w : Word p l} (h : densityPower l r u w ≠ 0) :
      ∀ i, odd (u i) ↔ odd (w i) := by
    intro i
    have he : r (u i) (w i) ≠ 0 := (Finset.prod_ne_zero_iff.mp h) i (Finset.mem_univ _)
    by_contra hn
    exact he (hr _ _ (by tauto))
  ext u w
  simp only [Matrix.mul_apply,matrix]
  rw [Finset.sum_eq_single ((wordPerm σ).symm u),Finset.sum_eq_single (wordPerm σ w)]
  · simp only [(wordPerm σ).apply_symm_apply,ite_true]
    have hd : densityPower l r u (wordPerm σ w)=densityPower l r ((wordPerm σ).symm u) w := by
      simpa using densityPower_permute σ r ((wordPerm σ).symm u) w
    rw [hd]
    by_cases hn : densityPower l r ((wordPerm σ).symm u) w=0
    · simp [hn]
    · rw [phase_eq_of_parity σ _ _ (hpar hn),mul_comm]
  · intro v hv hne; simp [hne]
  · simp
  · intro v hv hne
    have hh : u ≠ wordPerm σ v := by
      intro he
      exact hne ((Equiv.eq_symm_apply _).mpr he.symm)
    simp [hh]
  · simp

lemma densityPower_commute_lift {l : ℕ} (r : Matrix (Letter p) (Letter p) ℂ)
    (hr : IsEven r) (x : MonoidAlgebra ℂ (Equiv.Perm (Fin l))) :
    (MonoidAlgebra.lift ℂ _ _ (action p l) x)*densityPower l r =
      densityPower l r*(MonoidAlgebra.lift ℂ _ _ (action p l) x) := by
  induction x using MonoidAlgebra.induction_on with
  | of g => simpa [action] using densityPower_commute_of_even r hr g
  | add x y hx hy => simp only [map_add,add_mul,mul_add,hx,hy]
  | smul c x hx => simp only [map_smul,smul_mul_assoc,mul_smul_comm,hx]

/- Constructed even whitening of the regularized empirical row density. -/
theorem exists_even_whitening {R : Type*} [Fintype R] [Nonempty R]
    (r : R → EvenDensity p) {ε : ℝ} (hε : 0 < ε) :
    let B := (Fintype.card R : ℂ)⁻¹ • ∑ i, (r i).val + (ε : ℂ) • (1 : Matrix (Letter p) (Letter p) ℂ)
    ∃ A : Matrix (Letter p) (Letter p) ℂ, A.PosSemidef ∧ IsEven A ∧ A*B*A=1 ∧
      ((Fintype.card R : ℂ) • (1 : Matrix (Letter p) (Letter p) ℂ)-
        ∑ i, A*(r i).val*A).PosSemidef := by
  dsimp only
  let B := (Fintype.card R : ℂ)⁻¹ • ∑ i, (r i).val + (ε : ℂ) • (1 : Matrix (Letter p) (Letter p) ℂ)
  have hBp : B.PosDef := TensorBoard.average_regularization_posDef (fun i => (r i).val)
    (fun i => (r i).property.1) hε
  have hBe : IsEven B := isEven_add (isEven_smul _ (isEven_sum _ (fun i => (r i).property.2.2)))
    (isEven_smul _ isEven_one)
  obtain ⟨A,hA,hABA,hcomm⟩ := TensorBoard.exists_whitening B hBp
  refine ⟨A,hA,(isEven_iff_commute A).mpr (hcomm _ ((isEven_iff_commute B).mp hBe)),hABA,?_⟩
  apply TensorBoard.whitening_sum_bound _ B A hA.isHermitian hABA
  dsimp [B]
  convert (Matrix.PosSemidef.one (n := Letter p) (R := ℂ)).smul hε.le using 1
  module

end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
variable {p l : ℕ}

/- Even inhomogeneous site tensors transform by the *signed* permutation
matrix with no residual phase. This is what permits regrouping deleted rows
and columns without identifying the two Koszul charts by an unsigned map. -/
lemma tensor_covariance (A : Fin l → Matrix (Letter p) (Letter p) ℂ)
    (hA : ∀ i, IsEven (A i)) (σ : Equiv.Perm (Fin l)) :
    matrix σ*TensorBoard.tensor A=
      TensorBoard.tensor (fun i => A (σ⁻¹ i))*matrix σ := by
  have hpar {u w : Word p l} (h : TensorBoard.tensor A u w ≠ 0) :
      ∀ i, odd (u i) ↔ odd (w i) := by
    intro i
    have he : A i (u i) (w i) ≠ 0 := (Finset.prod_ne_zero_iff.mp h) i (Finset.mem_univ _)
    by_contra hn
    exact he (hA i _ _ (by tauto))
  ext u w
  simp only [Matrix.mul_apply,matrix]
  rw [Finset.sum_eq_single ((wordPerm σ).symm u),Finset.sum_eq_single (wordPerm σ w)]
  · simp only [(wordPerm σ).apply_symm_apply,ite_true]
    have hd : TensorBoard.tensor (fun i => A (σ⁻¹ i)) u (wordPerm σ w)=
        TensorBoard.tensor A ((wordPerm σ).symm u) w := by
      change (∏ i, A (σ⁻¹ i) (u i) (w (σ⁻¹ i)))=∏ i, A i (u (σ i)) (w i)
      simpa using (Equiv.prod_comp σ (fun i => A (σ⁻¹ i) (u i) (w (σ⁻¹ i)))).symm
    rw [hd]
    by_cases hn : TensorBoard.tensor A ((wordPerm σ).symm u) w=0
    · simp [hn]
    · rw [phase_eq_of_parity σ _ _ (hpar hn),mul_comm]
  · intro v hv hne; simp [hne]
  · simp
  · intro v hv hne
    have hh : u ≠ wordPerm σ v := by
      intro he
      exact hne ((Equiv.eq_symm_apply _).mpr he.symm)
    simp [hh]
  · simp

lemma tensor_signed_conjugate (A : Fin l → Matrix (Letter p) (Letter p) ℂ)
    (hA : ∀ i, IsEven (A i)) (σ : Equiv.Perm (Fin l)) :
    matrix σ*TensorBoard.tensor A*(matrix σ).conjTranspose=
      TensorBoard.tensor (fun i => A (σ⁻¹ i)) := by
  rw [tensor_covariance A hA σ,mul_assoc,← matrix_inv,← matrix_mul,mul_inv_cancel,matrix_one,mul_one]

end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
open OrderedBlocks
variable {p r : ℕ} (n : Fin r → ℕ)

def groupedSite (a : Fin r → EvenDensity p) (k : Fin (∑ i, n i)) : EvenDensity p :=
  a ((positions n).symm k).1

lemma grouped_densityPower (a : Fin r → EvenDensity p) :
    (DependentTensor.tensor (fun i => densityPower (n i) (a i).val)).submatrix
      (groupWord n p) (groupWord n p)=TensorBoard.tensor (fun k => (groupedSite n a k).val) := by
  ext u v
  change (∏ i, ∏ j : Fin (n i), (a i).val (u (positions n ⟨i,j⟩)) (v (positions n ⟨i,j⟩)))=
    ∏ k, (a ((positions n).symm k).1).val (u k) (v k)
  rw [prod_positions]
  apply Finset.prod_congr rfl
  intro i _
  apply Finset.prod_congr rfl
  intro j _
  rw [Equiv.symm_apply_apply]

/- Literal contiguous-block projectors are dominated by independent finite
mixtures of even site densities, with all local dimension factors. -/
theorem finite_grouped_density_domination (s : ℕ) (hp : 0 < p) (hps : p ≤ s)
    (hn : ∀ i, n i ≤ s) (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) :
    ∃ (K : Type) (_ : Fintype K) (_ : Nonempty K) (a : K → Fin r → EvenDensity p),
      (((∏ i, ((ρ i).dimension : ℂ))*((s+1 : ℕ) : ℂ)^(r*(41*p^2))) •
        ((Fintype.card K : ℂ)⁻¹ • ∑ x,
          TensorBoard.tensor (fun k => (groupedSite n (a x) k).val))-
          groupedProjector (p := p) n ρ).PosSemidef := by
  obtain ⟨K,hK,nK,a,ha⟩ := finite_block_density_domination s p hp hps n hn ρ
  let := hK
  let := nK
  refine ⟨K,hK,nK,a,?_⟩
  have hh := ha.submatrix (groupWord n p)
  have hm : (∑ x, DependentTensor.tensor (fun i => densityPower (n i) (a x i).val)).submatrix
      (groupWord n p) (groupWord n p)=∑ x, TensorBoard.tensor (fun k => (groupedSite n (a x) k).val) := by
    ext u v
    simp only [Matrix.submatrix_apply,Matrix.sum_apply]
    apply Finset.sum_congr rfl
    intro x _
    exact congrArg (fun M => M u v) (grouped_densityPower n (a x))
  simp only [Fintype.card_fin,Matrix.submatrix_sub,Matrix.submatrix_smul,
    Pi.sub_apply,Pi.smul_apply,hm] at hh
  have he : (DependentTensor.tensor (fun i => isotypic (p := p) (ρ i))).submatrix
      (groupWord n p) (groupWord n p)=groupedProjector (p := p) n ρ := by
    simp only [groupedProjector_factor,isotypic_eq_projector]
    rfl
  rwa [he] at hh

/- The same domination after an arbitrary *signed* change of slot chart. -/
theorem finite_regrouped_density_domination (s : ℕ) (hp : 0 < p) (hps : p ≤ s)
    (hn : ∀ i, n i ≤ s) (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i))))
    (σ : Equiv.Perm (Fin (∑ i, n i))) :
    ∃ (K : Type) (_ : Fintype K) (_ : Nonempty K) (a : K → Fin r → EvenDensity p),
      (((∏ i, ((ρ i).dimension : ℂ))*((s+1 : ℕ) : ℂ)^(r*(41*p^2))) •
        ((Fintype.card K : ℂ)⁻¹ • ∑ x,
          TensorBoard.tensor (fun k => (groupedSite n (a x) (σ⁻¹ k)).val))-
          matrix σ*groupedProjector (p := p) n ρ*(matrix σ).conjTranspose).PosSemidef := by
  obtain ⟨K,hK,nK,a,ha⟩ := finite_grouped_density_domination n s hp hps hn ρ
  let := hK
  let := nK
  refine ⟨K,hK,nK,a,?_⟩
  have hh := ha.mul_mul_conjTranspose_same (matrix σ)
  simp only [mul_sub,sub_mul,Matrix.mul_smul,Matrix.smul_mul,Matrix.mul_sum,Matrix.sum_mul] at hh
  have ht (x : K) : matrix σ*TensorBoard.tensor (fun k => (groupedSite n (a x) k).val)*(matrix σ).conjTranspose=
      TensorBoard.tensor (fun k => (groupedSite n (a x) (σ⁻¹ k)).val) :=
    tensor_signed_conjugate _ (fun k => (groupedSite n (a x) k).property.2.2) σ
  simpa only [ht] using hh

end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
variable {p r : ℕ} (n : Fin r → ℕ)

lemma groupedProjector_posSemidef (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) :
    (groupedProjector (p := p) n ρ).PosSemidef := by
  rw [groupedProjector_factor]
  exact (DependentTensor.tensor_posSemidef _ (fun i => (ρ i).projector_posSemidef _
    (fun σ => (matrix_inv σ).symm))).submatrix _

lemma groupedProjector_idempotent (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) :
    groupedProjector (p := p) n ρ*groupedProjector n ρ=groupedProjector n ρ := by
  rw [groupedProjector_factor]
  change Matrix.reindexAlgEquiv ℂ ℂ (groupWord n p).symm _*
    Matrix.reindexAlgEquiv ℂ ℂ (groupWord n p).symm _=Matrix.reindexAlgEquiv ℂ ℂ (groupWord n p).symm _
  rw [← map_mul,← DependentTensor.tensor_mul]
  simp only [UnitaryIrrep.projector_idempotent]

end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
open OrderedBlocks UnitaryIrrep
variable {p r l : ℕ} (n : Fin r → ℕ)

def lengthMatrix {a b : ℕ} (h : a=b) (M : Matrix (Word p a) (Word p a) ℂ) :
    Matrix (Word p b) (Word p b) ℂ := h ▸ M

def ambientProjector (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) : Matrix (Word p l) (Word p l) ℂ :=
  matrix σ*lengthMatrix h (groupedProjector n ρ)*(matrix σ).conjTranspose

def ambientProjectorAlgebra (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) : MonoidAlgebra ℂ (Equiv.Perm (Fin l)) :=
  averageAlgebra (fun ω : ∀ i, Equiv.Perm (Fin (n i)) => ∏ i, (ρ i).coefficient (ω i))
    (fun ω => σ*(Equiv.permCongr (finCongr h) (perm n ω))*σ⁻¹)

lemma ambientProjectorAlgebra_lift (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) :
    MonoidAlgebra.lift ℂ _ _ (action p l) (ambientProjectorAlgebra n h σ ρ)=
      ambientProjector (p := p) n h σ ρ := by
  subst l
  simp only [ambientProjectorAlgebra,lift_averageAlgebra,averageMatrix,ambientProjector,
    lengthMatrix,groupedProjector,groupedAverage,Matrix.mul_sum,Matrix.sum_mul,Matrix.mul_smul,Matrix.smul_mul]
  apply Finset.sum_congr rfl
  intro ω _
  congr 1
  change matrix (σ*(Equiv.permCongr (finCongr rfl) (perm n ω))*σ⁻¹)=_
  simp only [finCongr_refl,matrix_mul,matrix_inv]
  rfl

lemma ambientProjector_posSemidef (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) :
    (ambientProjector (p := p) n h σ ρ).PosSemidef := by
  subst l
  exact (groupedProjector_posSemidef n ρ).mul_mul_conjTranspose_same (matrix σ)

lemma ambientProjector_idempotent (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) :
    ambientProjector (p := p) n h σ ρ*ambientProjector n h σ ρ=ambientProjector n h σ ρ := by
  subst l
  unfold ambientProjector lengthMatrix
  calc
    _ = matrix σ*(groupedProjector n ρ*((matrix σ).conjTranspose*matrix σ)*groupedProjector n ρ)*
      (matrix (p := p) σ).conjTranspose := by noncomm_ring
    _ = _ := by rw [matrix_unitary,mul_one,groupedProjector_idempotent]

/- Actual ambient projectors, not hypothesized density mixtures. -/
theorem finite_ambient_density_domination (s : ℕ) (hp : 0 < p) (hps : p ≤ s)
    (hn : ∀ i, n i ≤ s) (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i))))
    (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l)) :
    ∃ (K : Type) (_ : Fintype K) (_ : Nonempty K) (a : K → Fin r → EvenDensity p),
      (((∏ i, ((ρ i).dimension : ℂ))*((s+1 : ℕ) : ℂ)^(r*(41*p^2))) •
        ((Fintype.card K : ℂ)⁻¹ • ∑ x,
          TensorBoard.tensor (fun k => (groupedSite n (a x) ((finCongr h).symm (σ⁻¹ k))).val))-
          ambientProjector (p := p) n h σ ρ).PosSemidef := by
  subst l
  simpa [ambientProjector,lengthMatrix] using
    finite_regrouped_density_domination n s hp hps hn ρ σ

end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
open OrderedBlocks UnitaryIrrep
variable {p r l : ℕ} (n : Fin r → ℕ)

def ambientAverage (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    {Ω : Fin r → Type*} [∀ i, Fintype (Ω i)]
    (w : ∀ i, Ω i → ℂ) (g : ∀ i, Ω i → Equiv.Perm (Fin (n i))) :
    Matrix (Word p l) (Word p l) ℂ :=
  averageMatrix (action p l) (fun ω : ∀ i, Ω i => ∏ i, w i (ω i))
    (fun ω => σ*Equiv.permCongr (finCongr h) (perm n (fun i => g i (ω i)))*σ⁻¹)

lemma ambientAverage_factor (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    {Ω : Fin r → Type*} [∀ i, Fintype (Ω i)]
    (w : ∀ i, Ω i → ℂ) (g : ∀ i, Ω i → Equiv.Perm (Fin (n i))) :
    ambientAverage (p := p) n h σ w g=
      matrix σ*lengthMatrix h (groupedAverage n w g)*(matrix σ).conjTranspose := by
  subst l
  simp only [ambientAverage,averageMatrix,groupedAverage,lengthMatrix,
    Matrix.mul_sum,Matrix.sum_mul,Matrix.mul_smul,Matrix.smul_mul]
  apply Finset.sum_congr rfl
  intro ω _
  congr 1
  change matrix (σ*Equiv.permCongr (finCongr rfl) (perm n (fun i => g i (ω i)))*σ⁻¹)=_
  simp only [finCongr_refl,matrix_mul,matrix_inv]
  rfl

lemma matrix_unitary_reverse (σ : Equiv.Perm (Fin l)) :
    matrix (p := p) σ*(matrix σ).conjTranspose=1 := by
  rw [← matrix_inv,← matrix_mul,mul_inv_cancel,matrix_one]

lemma conjugate_mul {X : Type*} [Fintype X] [DecidableEq X]
    (U A B : Matrix X X ℂ) (hU : U.conjTranspose*U=1) :
    (U*A*U.conjTranspose)*(U*B*U.conjTranspose)=U*(A*B)*U.conjTranspose := by
  calc
    _ = U*A*(U.conjTranspose*U)*B*U.conjTranspose := by noncomm_ring
    _ = _ := by rw [hU,mul_one]; noncomm_ring

lemma conjugate_pow {X : Type*} [Fintype X] [DecidableEq X]
    (U A : Matrix X X ℂ) (hU : U.conjTranspose*U=1) (hU' : U*U.conjTranspose=1) (q : ℕ) :
    (U*A*U.conjTranspose)^q=U*A^q*U.conjTranspose := by
  induction q with
  | zero => simpa using hU'.symm
  | succ q ih => rw [pow_succ,ih,conjugate_mul U _ _ hU,pow_succ]

lemma conjugate_moment {X : Type*} [Fintype X] [DecidableEq X]
    (U A : Matrix X X ℂ) (hU : U.conjTranspose*U=1) (hU' : U*U.conjTranspose=1) (q : ℕ) :
    Matrix.trace (((U*A*U.conjTranspose).conjTranspose*(U*A*U.conjTranspose))^q)=
      Matrix.trace ((A.conjTranspose*A)^q) := by
  have hs : (U*A*U.conjTranspose).conjTranspose=U*A.conjTranspose*U.conjTranspose := by
    simp only [Matrix.conjTranspose_mul,Matrix.conjTranspose_conjTranspose]
    noncomm_ring
  rw [hs,conjugate_mul U _ _ hU,conjugate_pow U _ hU hU']
  rw [Matrix.trace_mul_cycle,hU,one_mul]

/- The child moment formula survives the literal slot chart, with actual Hom multiplicities. -/
theorem ambient_projected_moment (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    {Ω : Fin r → Type*} [∀ i, Fintype (Ω i)]
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i))))
    (w : ∀ i, Ω i → ℂ) (g : ∀ i, Ω i → Equiv.Perm (Fin (n i)))
    {q : ℕ} (hq : q ≠ 0) :
    Matrix.trace (((ambientProjector (p := p) n h σ ρ*ambientAverage n h σ w g).conjTranspose*
      (ambientProjector n h σ ρ*ambientAverage n h σ w g))^q)=
      ∏ i, (Module.finrank ℂ ((ρ i).asRepresentation.IntertwiningMap
        (matrixRepresentation (action p (n i)))) : ℂ)*
        Matrix.trace (((averageMatrix (ρ i).matrix (w i) (g i)).conjTranspose*
          averageMatrix (ρ i).matrix (w i) (g i))^q) := by
  subst l
  rw [ambientAverage_factor]
  unfold ambientProjector lengthMatrix
  rw [conjugate_mul _ _ _ (matrix_unitary σ),conjugate_moment _ _
    (matrix_unitary σ) (matrix_unitary_reverse σ)]
  exact grouped_projected_moment n ρ w g hq

end CoordinateSweeps.SignedTensor

/-!
All definitions are finite and use ordinary probability and trace normalizations.
-/

noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable

noncomputable section
attribute [local instance] Classical.propDecidable
namespace CoordinateSweeps.FiberBlocks
open OrderedBlocks
variable {L : Type*} [Fintype L] {r : ℕ} (f : L → Fin r)

def size (i : Fin r) : ℕ := Fintype.card {x : L // f x=i}
def cards (i : Fin r) : Fin (size f i) ≃ {x : L // f x=i} := (Fintype.equivFin _).symm

/- Contiguous finite label fibers give a genuine ordered slot chart. -/
def slots : Fin (∑ i, size f i) ≃ L :=
  (positions (size f)).symm.trans
    ((Equiv.sigmaCongrRight (cards f)).trans (Equiv.sigmaFiberEquiv f))

lemma total : ∑ i, size f i=Fintype.card L := by
  simpa only [Fintype.card_fin] using Fintype.card_congr (slots f)

lemma label_slots (k : Fin (∑ i, size f i)) :
    f (slots f k)=((positions (size f)).symm k).1 := by
  exact (cards f ((positions (size f)).symm k).1 ((positions (size f)).symm k).2).property

/- The same chart with the literal cardinal as ambient length. -/
def chart : Fin (Fintype.card L) ≃ L :=
  (finCongr (total f).symm).trans (slots f)

/- Permutation changing the contiguous fiber chart to any given ambient chart. -/
def regroup (e : Fin (Fintype.card L) ≃ L) : Equiv.Perm (Fin (Fintype.card L)) :=
  (chart f).trans e.symm

lemma label_regroup (e : Fin (Fintype.card L) ≃ L) (k : Fin (Fintype.card L)) :
    ((positions (size f)).symm ((finCongr (total f)).symm ((regroup f e)⁻¹ k))).1=f (e k) := by
  have he : slots f ((finCongr (total f)).symm ((regroup f e)⁻¹ k))=e k := by
    change chart f ((regroup f e).symm k)=e k
    simp [regroup]
  rw [← label_slots f,he]

end CoordinateSweeps.FiberBlocks

namespace CoordinateSweeps.FiberBlocks
open OrderedBlocks
variable {L : Type*} [Fintype L] {r : ℕ} (f : L → Fin r)

lemma slots_positions (i : Fin r) (j : Fin (size f i)) :
    slots f (positions (size f) ⟨i,j⟩)=(cards f i j).val := by
  simp [slots]

/- Independent permutations of the actual fibers, on the literal ambient set. -/
def action : (∀ i, Equiv.Perm (Fin (size f i))) →* Equiv.Perm L :=
  (slots f).permCongrHom.toMonoidHom.comp (permHom (size f))

lemma action_apply (σ : ∀ i, Equiv.Perm (Fin (size f i))) (i : Fin r) (j : Fin (size f i)) :
    action f σ (cards f i j).val=(cards f i (σ i j)).val := by
  rw [← slots_positions f i j,← slots_positions f i (σ i j)]
  change slots f (perm (size f) σ ((slots f).symm (slots f (positions (size f) ⟨i,j⟩))))=_
  rw [Equiv.symm_apply_apply,perm_apply]

lemma ambient_action (e : Fin (Fintype.card L) ≃ L)
    (σ : ∀ i, Equiv.Perm (Fin (size f i))) :
    Equiv.permCongr e.symm (action f σ)=
      regroup f e*Equiv.permCongr (finCongr (total f)) (perm (size f) σ)*(regroup f e)⁻¹ := by
  apply Equiv.ext
  intro x
  change e.symm (slots f (perm (size f) σ ((slots f).symm (e x))))=_
  simp only [Equiv.Perm.mul_apply,Equiv.permCongr_apply,regroup,chart,
    Equiv.trans_apply,Equiv.symm_trans_apply,Equiv.Perm.coe_inv]
  simp

/- A label-preserving permutation has genuine induced local permutations. -/
def restrict (σ : Equiv.Perm L) (hσ : ∀ x, f (σ x)=f x) (i : Fin r) : Equiv.Perm (Fin (size f i)) :=
  Equiv.permCongr (cards f i).symm (Equiv.subtypeEquiv σ (by
    intro x
    change f x=i ↔ f (σ x)=i
    rw [hσ x]))

lemma restrict_apply (σ : Equiv.Perm L) (hσ : ∀ x, f (σ x)=f x)
    (i : Fin r) (j : Fin (size f i)) :
    (cards f i (restrict f σ hσ i j)).val=σ (cards f i j).val := by
  simp [restrict,Equiv.permCongr_apply]

lemma action_restrict (σ : Equiv.Perm L) (hσ : ∀ x, f (σ x)=f x) :
    action f (restrict f σ hσ)=σ := by
  apply Equiv.ext
  intro x
  let i := f x
  let j := (cards f i).symm ⟨x,rfl⟩
  have hx : (cards f i j).val=x := congrArg Subtype.val ((cards f i).apply_symm_apply ⟨x,rfl⟩)
  rw [← hx,action_apply,restrict_apply]

end CoordinateSweeps.FiberBlocks
namespace CoordinateSweeps.SignedTensor
open UnitaryIrrep
variable {p r l : ℕ} (n : Fin r → ℕ)
lemma groupedProjector_commute_average {Ω : Fin r → Type*} [∀ i, Fintype (Ω i)]
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i))))
    (w : ∀ i, Ω i → ℂ) (g : ∀ i, Ω i → Equiv.Perm (Fin (n i))) :
    groupedProjector (p := p) n ρ*groupedAverage n w g=groupedAverage n w g*groupedProjector n ρ := by
  rw [groupedProjector_factor,groupedAverage_factor]
  change Matrix.reindexAlgEquiv ℂ ℂ (groupWord n p).symm _*
      Matrix.reindexAlgEquiv ℂ ℂ (groupWord n p).symm _=
    Matrix.reindexAlgEquiv ℂ ℂ (groupWord n p).symm _*
      Matrix.reindexAlgEquiv ℂ ℂ (groupWord n p).symm _
  rw [← map_mul,← map_mul,← DependentTensor.tensor_mul,← DependentTensor.tensor_mul]
  congr 1
  apply congrArg DependentTensor.tensor
  funext i
  simp only [averageMatrix,Matrix.mul_sum,Matrix.sum_mul,Matrix.mul_smul,Matrix.smul_mul]
  apply Finset.sum_congr rfl
  intro ω _
  exact congrArg (fun A => w i ω • A) ((ρ i).projector_commute (action p (n i)) (g i ω)).symm

lemma ambientProjector_commute_average (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l))
    {Ω : Fin r → Type*} [∀ i, Fintype (Ω i)]
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i))))
    (w : ∀ i, Ω i → ℂ) (g : ∀ i, Ω i → Equiv.Perm (Fin (n i))) :
    ambientProjector (p := p) n h σ ρ*ambientAverage n h σ w g=
      ambientAverage n h σ w g*ambientProjector n h σ ρ := by
  subst l
  rw [ambientAverage_factor]
  unfold ambientProjector lengthMatrix
  rw [conjugate_mul _ _ _ (matrix_unitary σ),conjugate_mul _ _ _ (matrix_unitary σ)]
  rw [groupedProjector_commute_average]
end CoordinateSweeps.SignedTensor

namespace CoordinateSweeps.SignedTensor
open UnitaryIrrep
variable {p r : ℕ} (n : Fin r → ℕ)
lemma child_product_bound (s : ℕ) (hn : ∀ i, n i ≤ s)
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (n i)))) (T E : Fin r → ℝ)
    (hT : ∀ i, 0 ≤ T i) (hE : ∀ i, T i ≤ Real.exp (E i)) :
    (∏ i, (Module.finrank ℂ ((ρ i).asRepresentation.IntertwiningMap
      (matrixRepresentation (action p (n i)))) : ℝ)*T i) ≤
        ((s+1 : ℕ) : ℝ)^(r*((2*p)*(2*p)))*Real.exp (∑ i, E i) := by
  rw [Finset.prod_mul_distrib]
  have hm : (∏ i, (Module.finrank ℂ ((ρ i).asRepresentation.IntertwiningMap
      (matrixRepresentation (action p (n i)))) : ℝ)) ≤ ((s+1 : ℕ) : ℝ)^(r*((2*p)*(2*p))) := by
    calc
      _ ≤ ∏ _ : Fin r, ((s+1 : ℕ) : ℝ)^((2*p)*(2*p)) := Finset.prod_le_prod₀
        (fun _ _ => Nat.cast_nonneg _) (fun i _ => by
          exact_mod_cast (multiplicity_le p (n i) (ρ i)).trans
            (Nat.pow_le_pow_left (Nat.add_le_add_right (hn i) 1) _))
      _ = _ := by rw [Finset.prod_const,Finset.card_univ,Fintype.card_fin,← pow_mul,Nat.mul_comm]
  have ht : (∏ i, T i) ≤ Real.exp (∑ i, E i) := by
    rw [Real.exp_sum]
    exact Finset.prod_le_prod₀ (fun i _ => hT i) (fun i _ => hE i)
  exact mul_le_mul hm ht (Finset.prod_nonneg (fun i _ => hT i)) (by positivity)
end CoordinateSweeps.SignedTensor
namespace CoordinateSweeps.SignedTensor
variable {p r : ℕ} {L : Type*} [Fintype L] (f : L → Fin r)

def fiberProjector (e : Fin (Fintype.card L) ≃ L)
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (FiberBlocks.size f i)))) :=
  ambientProjector (p := p) (FiberBlocks.size f) (FiberBlocks.total f) (FiberBlocks.regroup f e) ρ

def fiberProjectorAlgebra (e : Fin (Fintype.card L) ≃ L)
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (FiberBlocks.size f i)))) :=
  ambientProjectorAlgebra (FiberBlocks.size f) (FiberBlocks.total f) (FiberBlocks.regroup f e) ρ

lemma fiberProjectorAlgebra_lift (e : Fin (Fintype.card L) ≃ L)
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (FiberBlocks.size f i)))) :
    MonoidAlgebra.lift ℂ _ _ (action p (Fintype.card L)) (fiberProjectorAlgebra f e ρ)=
      fiberProjector (p := p) f e ρ := ambientProjectorAlgebra_lift _ _ _ _

lemma fiberProjector_posSemidef (e : Fin (Fintype.card L) ≃ L)
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (FiberBlocks.size f i)))) :
    (fiberProjector (p := p) f e ρ).PosSemidef := ambientProjector_posSemidef _ _ _ _

lemma fiberProjector_idempotent (e : Fin (Fintype.card L) ≃ L)
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (FiberBlocks.size f i)))) :
    fiberProjector (p := p) f e ρ*fiberProjector f e ρ=fiberProjector f e ρ :=
  ambientProjector_idempotent _ _ _ _

/- Exact regrouping connects local isotypic products to the literal site labels. -/
theorem finite_fiber_density_domination (e : Fin (Fintype.card L) ≃ L)
    (s : ℕ) (hp : 0 < p) (hps : p ≤ s) (hn : ∀ i, FiberBlocks.size f i ≤ s)
    (ρ : ∀ i, UnitaryIrrep (Equiv.Perm (Fin (FiberBlocks.size f i)))) :
    ∃ (K : Type) (_ : Fintype K) (_ : Nonempty K) (a : K → Fin r → EvenDensity p),
      (((∏ i, ((ρ i).dimension : ℂ))*((s+1 : ℕ) : ℂ)^(r*(41*p^2))) •
        ((Fintype.card K : ℂ)⁻¹ • ∑ x,
          TensorBoard.tensor (fun k => (a x (f (e k))).val))-fiberProjector (p := p) f e ρ).PosSemidef := by
  obtain ⟨K,hK,nK,a,ha⟩ := finite_ambient_density_domination (FiberBlocks.size f) s hp hps hn ρ
    (FiberBlocks.total f) (FiberBlocks.regroup f e)
  let := hK
  let := nK
  refine ⟨K,hK,nK,a,?_⟩
  simpa only [groupedSite,FiberBlocks.label_regroup,fiberProjector] using ha

end CoordinateSweeps.SignedTensor
end
end
end
end
end
end
end
end
open scoped Matrix.Norms.L2Operator

end OAI