import OAI.Analysis.GroupDeterminants.ModularLifting

namespace OAI

noncomputable section
open scoped BigOperators

namespace GroupRingDeterminant

section RegularAction
open scoped ENNReal
variable {G : Type} [Group G] {n : ℕ}

def reindex (e : (Fin n × G) ≃ (Fin n × G)) : Hilbert G n →ₗᵢ[ℂ] Hilbert G n where
  toFun ξ := ⟨fun a => ξ (e a), memℓp_gen
    (((lp.memℓp ξ).summable (by norm_num)).comp_injective e.injective)⟩
  map_add' ξ η := by ext a; rfl
  map_smul' z ξ := by ext a; rfl
  norm_map' ξ := by
    rw [lp.norm_eq_tsum_rpow (by norm_num), lp.norm_eq_tsum_rpow (by norm_num)]
    congr 1
    exact e.tsum_eq (fun a => ‖ξ a‖ ^ (2 : ℝ≥0∞).toReal)

def cutComponent (i : Fin n) : Hilbert G n →L[ℂ] Hilbert G n := by
  classical
  let f : Hilbert G n →ₗ[ℂ] Hilbert G n := {
    toFun ξ := ⟨fun a => if a.1 = i then ξ a else 0,
      (lp.memℓp ξ).mono' (fun a => by split_ifs <;> simp)⟩
    map_add' ξ η := by
      ext a
      change (if a.1 = i then ξ a + η a else 0) =
        (if a.1 = i then ξ a else 0) + (if a.1 = i then η a else 0)
      split_ifs <;> simp
    map_smul' z ξ := by
      ext a
      change (if a.1 = i then z • ξ a else 0) = z • (if a.1 = i then ξ a else 0)
      split_ifs <;> simp }
  exact f.mkContinuous 1 (fun ξ => by
    simpa only [one_mul] using lp.norm_mono (by norm_num : (2 : ℝ≥0∞) ≠ 0)
      (x := f ξ) (y := ξ) (fun a => by
        change ‖ite (a.1 = i) (ξ a) 0‖ ≤ ‖ξ a‖
        split_ifs <;> simp))

omit [Group G] in
@[simp] theorem cutComponent_apply (i : Fin n) (ξ : Hilbert G n) (a : Fin n × G) :
    cutComponent i ξ a = if a.1 = i then ξ a else 0 := rfl

def elementaryOperator (i j : Fin n) (g : G) : Hilbert G n →L[ℂ] Hilbert G n :=
  (cutComponent i).comp (reindex
    (Equiv.prodCongr (Equiv.swap i j) (Equiv.mulLeft g⁻¹))).toContinuousLinearMap

theorem elementaryOperator_apply (i j : Fin n) (g : G) (ξ : Hilbert G n)
    (a : Fin n) (h : G) :
    elementaryOperator i j g ξ (a, h) = if a = i then ξ (j, g⁻¹ * h) else 0 := by
  classical
  by_cases hi : a = i
  · subst a
    simp [elementaryOperator, reindex, cutComponent_apply]
  · simp [elementaryOperator, cutComponent_apply, hi]

def regularOperator (A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℤ G)) :
    Hilbert G n →L[ℂ] Hilbert G n :=
  ∑ i : Fin n, ∑ j : Fin n, (A i j).coeff.sum
    (fun g z => (z : ℂ) • elementaryOperator i j g)

theorem regularOperator_spec (A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℤ G)) :
    IsRegularOperator A (regularOperator A) := by
  classical
  intro ξ i h
  simp only [regularOperator, Finsupp.sum, sum_apply,
    smul_apply, lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul,
    Pi.smul_apply, smul_eq_mul, elementaryOperator_apply]
  rw [Finset.sum_eq_single i]
  · simp
  · intro b _ hbi
    simp [Ne.symm hbi]
  · simp

theorem exists_regularOperator (A : Matrix (Fin n) (Fin n) (MonoidAlgebra ℤ G)) :
    ∃ T, IsRegularOperator A T := ⟨regularOperator A, regularOperator_spec A⟩

end RegularAction

end GroupRingDeterminant

end

end OAI