import Mathlib

namespace OAI

section
noncomputable section
open Set Function
open scoped Classical Pointwise BigOperators

namespace CriticalPercolation.LinearGrowth
variable {G R : Type*} [Group G] [CommRing R]
variable {n : Type*} [Fintype n] [DecidableEq n]

lemma exists_finiteType_matrix_ring [Group.FG G] (ρ : G →* GL n R) :
    ∃ D : Subalgebra ℤ R, Algebra.FiniteType ℤ D ∧ ∀ g i j, ρ g i j∈D := by
  obtain ⟨S,hS,hSf⟩ := Group.fg_iff.mp (inferInstance : Group.FG G)
  let T := hSf.toFinset ∪ hSf.toFinset⁻¹
  let E := T.biUnion (fun g => Finset.univ.biUnion (fun i => Finset.univ.image (fun j => ρ g i j)))
  let D := Algebra.adjoin ℤ (E : Set R)
  have hD : Algebra.FiniteType ℤ D := (Subalgebra.fg_iff_finiteType _).mp (Subalgebra.fg_adjoin_finset E)
  have hgen (g : G) (hg : g∈T) (i j : n) : ρ g i j∈D := by
    apply Algebra.subset_adjoin
    exact Finset.mem_biUnion.mpr ⟨g,hg,Finset.mem_biUnion.mpr
      ⟨i,Finset.mem_univ _,Finset.mem_image.mpr ⟨j,Finset.mem_univ _,rfl⟩⟩⟩
  refine ⟨D,hD,?_⟩
  intro g
  have hg : g∈Subgroup.closure S := by rw [hS]; trivial
  induction hg using Subgroup.closure_induction'' with
  | mem a ha => exact hgen a (Finset.mem_union_left _ (hSf.mem_toFinset.mpr ha))
  | inv_mem a ha =>
    apply hgen a⁻¹
    apply Finset.mem_union_right
    simpa using hSf.mem_toFinset.mpr ha
  | one =>
    intro i j
    rw [map_one]
    by_cases h : i=j <;> simp [h,D.zero_mem,D.one_mem]
  | mul a b ha hb iha ihb =>
    intro i j
    rw [map_mul]
    change (∑ l, ρ a i l*ρ b l j)∈D
    exact D.sum_mem (fun l _ => D.mul_mem (iha i l) (ihb l j))

variable (ρ : G →* GL n R) (D : Subalgebra ℤ R) (hD : ∀ g i j, ρ g i j∈D)

def liftMatrix (g : G) : Matrix n n D := fun i j => ⟨ρ g i j,hD g i j⟩

@[simp] lemma liftMatrix_map (g : G) :
    (D.val.toRingHom.mapMatrix) (liftMatrix ρ D hD g)=(ρ g).val := rfl

lemma liftMatrix_one : liftMatrix ρ D hD 1=1 := by
  apply Matrix.map_injective (f := D.val) Subtype.val_injective
  change D.val.toRingHom.mapMatrix (liftMatrix ρ D hD 1)=D.val.toRingHom.mapMatrix 1
  rw [map_one]
  change (ρ 1).val=1
  rw [map_one]
  rfl

lemma liftMatrix_mul (g h : G) : liftMatrix ρ D hD (g*h)=liftMatrix ρ D hD g*liftMatrix ρ D hD h := by
  apply Matrix.map_injective (f := D.val) Subtype.val_injective
  change D.val.toRingHom.mapMatrix (liftMatrix ρ D hD (g*h))=D.val.toRingHom.mapMatrix _
  rw [map_mul]
  change (ρ (g*h)).val=(ρ g).val*(ρ h).val
  rw [map_mul]
  rfl

def liftMatrixGroup : G →* GL n D where
  toFun g := ⟨liftMatrix ρ D hD g,liftMatrix ρ D hD g⁻¹,
    by rw [←liftMatrix_mul,mul_inv_cancel,liftMatrix_one],
    by rw [←liftMatrix_mul,inv_mul_cancel,liftMatrix_one]⟩
  map_one' := Units.ext (liftMatrix_one ρ D hD)
  map_mul' g h := Units.ext (liftMatrix_mul ρ D hD g h)

@[simp] lemma liftMatrixGroup_map (g : G) :
    Matrix.GeneralLinearGroup.map D.val.toRingHom (liftMatrixGroup ρ D hD g)=ρ g := by
  apply Units.ext
  rfl

lemma liftMatrixGroup_injective (hρ : Injective ρ) : Injective (liftMatrixGroup ρ D hD) := by
  intro x y he
  apply hρ
  apply Units.ext
  ext i j
  exact congrArg (fun M : GL n D => ((M i j : D) : R)) he

end CriticalPercolation.LinearGrowth
end
end

end OAI