import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.GroupTheory.Subgroup.Basic
import Mathlib.GroupTheory.Subgroup.Actions
import Mathlib.GroupTheory.Commutator
import Mathlib.Topology.Basic
import Mathlib.Topology.Algebra.ConstMulAction
import Mathlib.Data.Fintype.Perm
import Mathlib.Tactic.FinCases
import Mathlib.Tactic.IntervalCases

import Rubin.RigidStabilizer
import Rubin.SmulImage
import Rubin.Topology
import Rubin.FaithfulAction
import Rubin.Period
import Rubin.LocallyDense

namespace Rubin

variable {G : Type _} [Group G]

theorem Commute.conj (f g h : G) : Commute (f * g * f⁻¹) h ↔ Commute g (f⁻¹ * h * f) := by
  suffices ∀ (f g h : G), Commute (f * g * f⁻¹) h → Commute g (f⁻¹ * h * f) by
    constructor
    · apply this
    · intro cg
      symm
      nth_rw 1 [<-inv_inv f]
      apply this
      symm
      rw [inv_inv]
      exact cg

  intro f g h fgf_h_comm
  unfold Commute SemiconjBy at *
  rw [<-mul_assoc, <-mul_assoc]
  rw [<-mul_assoc, <-mul_assoc] at fgf_h_comm
  have gfh_eq : g * f⁻¹ * h = f⁻¹ * h * f * g * f⁻¹ := by
    repeat rw [mul_assoc f⁻¹]
    rw [<-fgf_h_comm]
    group
  rw [gfh_eq]
  group

theorem Commute.conj' (f g h : G) : Commute (f⁻¹ * g * f) h ↔ Commute g (f * h * f⁻¹) := by
  nth_rw 2 [<-inv_inv f]
  nth_rw 3 [<-inv_inv f]
  apply Commute.conj


structure AlgebraicallyDisjointElem (f g h : G) :=
  non_commute: ¬Commute f h
  fst : G
  snd : G
  fst_commute : Commute fst g
  snd_commute : Commute snd g
  comm_elem_commute : Commute ⁅fst, ⁅snd, h⁆⁆ g
  comm_elem_nontrivial : ⁅fst, ⁅snd, h⁆⁆ ≠ 1

namespace AlgebraicallyDisjointElem

def comm_elem {f g h : G} (disj_elem : AlgebraicallyDisjointElem f g h) : G :=
  ⁅disj_elem.fst, ⁅disj_elem.snd, h⁆⁆

@[simp]
theorem comm_elem_eq {f g h : G} (disj_elem : AlgebraicallyDisjointElem f g h) :
  disj_elem.comm_elem = ⁅disj_elem.fst, ⁅disj_elem.snd, h⁆⁆ :=
by
  unfold comm_elem
  simp

lemma comm_elem_conj (f g h i : G) :
  ⁅i * f * i⁻¹, ⁅i * g * i⁻¹, i * h * i⁻¹⁆⁆ = i * ⁅f, ⁅g, h⁆⁆ * i⁻¹ := by group

theorem conj {f g h : G} (disj_elem : AlgebraicallyDisjointElem f g h) (i : G): AlgebraicallyDisjointElem (i * f * i⁻¹) (i * g * i⁻¹) (i * h * i⁻¹) where
  non_commute := by
    rw [Commute.conj]
    group
    exact disj_elem.non_commute
  fst := i * disj_elem.fst * i⁻¹
  snd := i * disj_elem.snd * i⁻¹
  fst_commute := by
    rw [Commute.conj]
    group
    exact disj_elem.fst_commute
  snd_commute := by
    rw [Commute.conj]
    group
    exact disj_elem.snd_commute
  comm_elem_nontrivial := by
    intro eq_one
    apply disj_elem.comm_elem_nontrivial
    rw [comm_elem_conj, <-mul_right_inv i] at eq_one
    apply mul_right_cancel at eq_one
    nth_rw 2 [<-mul_one i] at eq_one
    apply mul_left_cancel at eq_one
    exact eq_one
  comm_elem_commute := by
    rw [comm_elem_conj, Commute.conj]
    rw [(by group : i⁻¹ * (i * g * i⁻¹) * i = g)]
    exact disj_elem.comm_elem_commute

end AlgebraicallyDisjointElem

-- Also known as `η_G(f)`.

/--
A pair (f, g) is said to be "algebraically disjoint" if it can produce an instance of
[`AlgebraicallyDisjointElem`] for any element `h ∈ G` such that `f` and `h` don't commute.

In other words, `g` is algebraically disjoint from `f` if `∀ h ∈ G`, with `⁅f, h⁆ ≠ 1`,
there exists a pair `f₁, f₂ ∈ Centralizer(g, G)`,
so that `⁅f₁, ⁅f₂, h⁆⁆` is a nontrivial element of `Centralizer(g, G)`.

Here the definition of `k ∈ Centralizer(g, G)` is directly unrolled as `Commute k g`.

This is a slightly weaker proposition than plain disjointness,
but it is easier to derive from the hypothesis of Rubin's theorem.
-/
def AlgebraicallyDisjoint {G : Type _} [Group G] (f g : G) :=
  ∀ (h : G), ¬Commute f h → AlgebraicallyDisjointElem f g h

theorem AlgebraicallyDisjoint_mk {G : Type _} [Group G] {f g : G}
  (mk_thm : ∀ h : G, ¬Commute f h →
    ∃ f₁ f₂ : G, Commute f₁ g ∧ Commute f₂ g ∧ Commute ⁅f₁, ⁅f₂, h⁆⁆ g ∧ ⁅f₁, ⁅f₂, h⁆⁆ ≠ 1
  ) : AlgebraicallyDisjoint f g :=
fun (h : G) (nc : ¬Commute f h) => {
  non_commute := nc,
  fst := (mk_thm h nc).choose
  snd := (mk_thm h nc).choose_spec.choose
  fst_commute := (mk_thm h nc).choose_spec.choose_spec.left
  snd_commute := (mk_thm h nc).choose_spec.choose_spec.right.left
  comm_elem_commute := (mk_thm h nc).choose_spec.choose_spec.right.right.left
  comm_elem_nontrivial := by
    exact (mk_thm h nc).choose_spec.choose_spec.right.right.right
}

/--
This definition simply wraps `AlgebraicallyDisjoint` as a `Prop`.
It is equivalent to it, although since `AlgebraicallyDisjoint` isn't a `Prop`,
an `↔` (iff) statement joining the two cannot be written.

You should consider using it when proving `↔`/`∧` kinds of theorems, or when tools like `cases` are needed,
as the base `AlgebraicallyDisjoint` isn't a `Prop` and won't work with those.

The two `Coe` and `CoeFn` instances provided around this type make it essentially transparent —
you can use an instance of `AlgebraicallyDisjoint` in place of a `IsAlgebraicallyDisjoint` and vice-versa.
You might need to add the odd `↑` (coe) operator to make Lean happy.
--/
def IsAlgebraicallyDisjoint {G : Type _} [Group G] (f g : G): Prop :=
  ∀ (h : G), ¬Commute f h → ∃ (f₁ f₂ : G), ∃ (elem : AlgebraicallyDisjointElem f g h), elem.fst = f₁ ∧ elem.snd = f₂

namespace IsAlgebraicallyDisjoint

variable {G : Type _} [Group G]
variable {f g: G}

noncomputable def elim
  (is_alg_disj: IsAlgebraicallyDisjoint f g) :
  AlgebraicallyDisjoint f g :=
fun h nc => (is_alg_disj h nc).choose_spec.choose_spec.choose

def mk (alg_disj : AlgebraicallyDisjoint f g) : IsAlgebraicallyDisjoint f g :=
fun h nc =>
  let elem := alg_disj h nc
  ⟨
    elem.fst,
    elem.snd,
    elem,
    rfl,
    rfl
  ⟩

noncomputable instance coeFnAlgebraicallyDisjoint : CoeFun
  (IsAlgebraicallyDisjoint f g)
  (fun _ => AlgebraicallyDisjoint f g) where
  coe := elim

instance coeAlgebraicallyDisjoint : Coe (AlgebraicallyDisjoint f g) (IsAlgebraicallyDisjoint f g) where
  coe := mk

theorem conj (is_alg_disj : IsAlgebraicallyDisjoint f g) (h : G) :
  IsAlgebraicallyDisjoint (h * f * h⁻¹) (h * g * h⁻¹) :=
by
  apply elim at is_alg_disj
  apply mk
  intro i nc
  rw [Commute.conj] at nc
  rw [(by group : i = h * (h⁻¹ * i * h) * h⁻¹)]
  exact (is_alg_disj (h⁻¹ * i * h) nc).conj h

end IsAlgebraicallyDisjoint

-- TODO: find a better home for these lemmas
variable {G α : Type _}
variable [Group G]
variable [TopologicalSpace α]
variable [MulAction G α]
variable [ContinuousConstSMul G α]
variable [FaithfulSMul G α]

-- Kind of a boring lemma but okay
lemma rewrite_Union (f : Fin 2 × Fin 2 → Set α) :
  (⋃(i : Fin 2 × Fin 2), f i) = (f (0,0) ∪ f (0,1)) ∪ (f (1,0) ∪ f (1,1)) :=
by
  ext x
  simp only [Set.mem_iUnion, Set.mem_union]
  constructor
  · rewrite [forall_exists_index]
    intro i
    fin_cases i
      <;> simp only [Fin.zero_eta, Fin.mk_one]
      <;> intro h
      <;> simp only [h, true_or, or_true]
  · rintro ((h|h)|(h|h)) <;> exact ⟨_, h⟩

lemma smul_inj_moves {ι : Type*} [Fintype ι] [T2Space α]
  {f : ι → G} {x : α} {i j : ι} (i_ne_j : i ≠ j)
  (f_smul_inj : Function.Injective (fun i : ι => (f i) • x)) :
  ((f j)⁻¹ * f i) • x ≠ x := by
    by_contra h
    apply i_ne_j
    apply f_smul_inj
    group_action
    group at h
    exact h

def smul_inj_nbhd {ι : Type*} [Fintype ι] [T2Space α]
  {f : ι → G} {x : α} {i j : ι} (i_ne_j : i ≠ j)
  (f_smul_inj : Function.Injective (fun i : ι => (f i) • x)) :
  Set α :=
  (disjoint_nbhd (smul_inj_moves i_ne_j f_smul_inj)).choose

lemma smul_inj_nbhd_open {ι : Type*} [Fintype ι] [T2Space α]
  {f : ι → G} {x : α} {i j : ι} (i_ne_j : i ≠ j)
  (f_smul_inj : Function.Injective (fun i : ι => (f i) • x)) :
  IsOpen (smul_inj_nbhd i_ne_j f_smul_inj) :=
by
  exact (disjoint_nbhd (smul_inj_moves i_ne_j f_smul_inj)).choose_spec.1

lemma smul_inj_nbhd_mem {ι : Type*} [Fintype ι] [T2Space α]
  {f : ι → G} {x : α} {i j : ι} (i_ne_j : i ≠ j)
  (f_smul_inj : Function.Injective (fun i : ι => (f i) • x)) :
  x ∈ (smul_inj_nbhd i_ne_j f_smul_inj) :=
by
  exact (disjoint_nbhd (smul_inj_moves i_ne_j f_smul_inj)).choose_spec.2.1

lemma smul_inj_nbhd_disjoint {ι : Type*} [Fintype ι] [T2Space α]
  {f : ι → G} {x : α} {i j : ι} (i_ne_j : i ≠ j)
  (f_smul_inj : Function.Injective (fun i : ι => (f i) • x)) :
  Disjoint
    (smul_inj_nbhd i_ne_j f_smul_inj)
    ((f j)⁻¹ * f i •'' (smul_inj_nbhd i_ne_j f_smul_inj)) :=
by
  exact (disjoint_nbhd (smul_inj_moves i_ne_j f_smul_inj)).choose_spec.2.2


lemma disjoint_nbhd_fin {ι : Type*} [Fintype ι] [T2Space α]
  {f : ι → G} {x : α} (f_smul_inj : Function.Injective (fun i : ι => (f i) • x)):
  ∃ U : Set α,
  IsOpen U ∧ x ∈ U ∧ (∀ (i j : ι), i ≠ j → Disjoint (f i •'' U) (f j •'' U)) :=
by
  let ι₂ := { p : ι × ι | p.1 ≠ p.2 }
  let U := ⋂(p : ι₂), smul_inj_nbhd p.prop f_smul_inj
  use U

  repeat' apply And.intro
  · apply isOpen_iInter_of_finite
    intro ⟨⟨i, j⟩, i_ne_j⟩
    apply smul_inj_nbhd_open
  · apply Set.mem_iInter.mpr
    intro ⟨⟨i, j⟩, i_ne_j⟩
    apply smul_inj_nbhd_mem
  · intro i j i_ne_j

    -- We transform `Disjoint (f i •'' U) (f j •'' U)` into `Disjoint N ((f i)⁻¹ * f j •'' N)`
    let N := smul_inj_nbhd i_ne_j f_smul_inj
    have U_subset_N : U ⊆ N := Set.iInter_subset
      (fun (⟨⟨i, j⟩, i_ne_j⟩ : ι₂) => (smul_inj_nbhd i_ne_j f_smul_inj))
      ⟨⟨i, j⟩, i_ne_j⟩

    rw [disjoint_comm, smulImage_disjoint_mul]

    apply Set.disjoint_of_subset U_subset_N
    · apply smulImage_mono
      exact U_subset_N
    · exact smul_inj_nbhd_disjoint i_ne_j f_smul_inj

lemma moves_inj {g : G} {x : α} {n : ℕ} (period_ge_n : ∀ (k : ℤ), 1 ≤ k → k < n → g^k • x ≠ x) :
  Function.Injective (fun (i : Fin n) => g^(i : ℤ) • x) :=
by
  intro a b same_img
  by_contra a_ne_b

  let abs_diff := |(a : ℤ) - (b : ℤ)|

  apply period_ge_n abs_diff _ _ _
  {
    show 1 ≤ abs_diff
    unfold_let
    rw [<-zero_add 1, Int.add_one_le_iff]
    apply abs_pos.mpr
    apply sub_ne_zero.mpr
    simp
    apply Fin.vne_of_ne
    apply a_ne_b
  }
  {
    show abs_diff < (n : ℤ)
    apply abs_lt.mpr
    constructor
    · rw [<-zero_sub]
      apply Int.sub_lt_sub_of_le_of_lt <;> simp
    · rw [<-sub_zero (n : ℤ)]
      apply Int.sub_lt_sub_of_lt_of_le <;> simp
  }
  {
    show g^abs_diff • x = x

    simp at same_img
    group_action at same_img
    rw [neg_add_eq_sub] at same_img

    cases abs_cases ((a : ℤ) - (b : ℤ)) with
    | inl h =>
      unfold_let
      rw [h.1]
      exact same_img
    | inr h =>
      unfold_let
      rw [h.1]
      rw [smul_eq_iff_eq_inv_smul]
      group
      symm
      exact same_img
  }

-- Note: this can be strengthened to `k ≥ 0`
lemma natAbs_eq_of_pos' (k : ℤ) (k_ge_one : k ≥ 1) : k = k.natAbs := by
  cases Int.natAbs_eq k with
  | inl _ => assumption
  | inr h =>
    exfalso
    have k_lt_one : k < 1 := by
      calc
        k ≤ 0 := by
          rw [h]
          apply nonpos_of_neg_nonneg
          rw [neg_neg]
          apply Int.ofNat_nonneg
        _ < 1 := by norm_num
    exact ((lt_iff_not_ge _ _).mp k_lt_one) k_ge_one

lemma period_ge_n_cast {g : G} {x : α} {n : ℕ} :
  (∀ (k : ℕ), 1 ≤ k → k < n → g ^ k • x ≠ x) →
  (∀ (k : ℤ), 1 ≤ k → k < n → g ^ k • x ≠ x) :=
by
  intro period_ge_n'
  intro k one_le_k k_lt_n

  have one_le_abs_k : 1 ≤ k.natAbs := by
    rw [<-Nat.cast_le (α := ℤ)]
    norm_num
    calc
      1 ≤ k := one_le_k
      _ ≤ |k| := le_abs_self k
  have abs_k_lt_n : k.natAbs < n := by
    rw [<-Nat.cast_lt (α := ℤ)]
    norm_num
    calc
      |k| = k := abs_of_pos one_le_k
      _ < n := k_lt_n
  have res := period_ge_n' k.natAbs one_le_abs_k abs_k_lt_n

  rw [<-zpow_ofNat, Int.coe_natAbs, abs_of_pos _] at res
  exact res
  exact one_le_k

instance {g : G} {x : α} {n : ℕ} :
  Coe
    (∀ (k : ℕ), 1 ≤ k → k < n → g ^ k • x ≠ x)
    (∀ (k : ℤ), 1 ≤ k → k < n → g ^ k • x ≠ x)
where
  coe := period_ge_n_cast

-- TODO: remove the unneeded `n` parameter
theorem smul_injective_within_period {g : G} {p : α} {n : ℕ}
  (period_eq_n : Period.period p g = n) :
  Function.Injective (fun (i : Fin n) => g ^ (i : ℕ) • p) :=
by
  simp only [<-zpow_coe_nat]
  apply moves_inj
  intro k one_le_k k_lt_n

  apply Period.moves_within_period'
  exact one_le_k
  rw [period_eq_n]
  exact k_lt_n
#align moves_inj_period Rubin.smul_injective_within_period


/-
The algebraic centralizer (and its associated basis) allow for a purely group-theoretic construction of the
`RegularSupport` sets.
They are defined as the centralizers of the subgroups `{g^12 | g ∈ G ∧ AlgebraicallyDisjoint f g}`
-/
section AlgebraicCentralizer

variable {G : Type _}
variable [Group G]

-- TODO: prove this is a subgroup?
-- This is referred to as `ξ_G^12(f)`
def AlgebraicSubgroup (f : G) : Set G :=
  (fun g : G => g^12) '' { g : G | IsAlgebraicallyDisjoint f g }

def AlgebraicCentralizer (f : G) : Subgroup G :=
  Subgroup.centralizer (AlgebraicSubgroup f)

theorem AlgebraicSubgroup.conj (f g : G) :
  (fun h => g * h * g⁻¹) '' AlgebraicSubgroup f = AlgebraicSubgroup (g * f * g⁻¹) :=
by
  unfold AlgebraicSubgroup
  rw [Set.image_image]
  have gxg12_eq : ∀ x : G, g * x^12 * g⁻¹ = (g * x * g⁻¹)^12 := by
    simp
  simp only [gxg12_eq]
  ext x
  simp
  constructor
  · intro ⟨y, y_disj, x_eq⟩
    use g * y * g⁻¹
    rw [<-gxg12_eq]
    exact ⟨y_disj.conj g, x_eq⟩
  · intro ⟨y, y_disj, x_eq⟩
    use g⁻¹ * y * g
    constructor
    · convert y_disj.conj g⁻¹ using 1
      all_goals group
    · nth_rw 3 [<-inv_inv g]
      simp only [conj_pow]
      rw [x_eq]
      group

@[simp]
theorem AlgebraicCentralizer.conj (f g : G) :
  (fun h => g * h * g⁻¹) '' AlgebraicCentralizer f = AlgebraicCentralizer (g * f * g⁻¹) :=
by
  unfold AlgebraicCentralizer

  ext x
  simp [Subgroup.mem_centralizer_iff]

  constructor
  · intro ⟨y, ⟨x_comm, x_eq⟩⟩
    intro h h_in_alg
    rw [<-AlgebraicSubgroup.conj] at h_in_alg
    simp at h_in_alg
    let ⟨i, i_in_alg, gig_eq_h⟩ := h_in_alg
    specialize x_comm i i_in_alg
    rw [<-gig_eq_h, <-x_eq]
    group
    rw [mul_assoc _ i, x_comm, <-mul_assoc]
  · intro x_comm
    use g⁻¹ * x * g
    group
    simp
    intro h h_in_alg
    simp [<-AlgebraicSubgroup.conj] at x_comm
    specialize x_comm h h_in_alg
    have h₁ : g⁻¹ * x * g * h = g⁻¹ * (g * h * g⁻¹ * x) * g := by
      rw [x_comm]
      group
    rw [h₁]
    group

/--
Finite intersections of [`AlgebraicCentralizer`].
--/
def AlgebraicCentralizerInter (S : Finset G) : Subgroup G :=
  ⨅ (g ∈ S), AlgebraicCentralizer g

def AlgebraicCentralizerBasis (G : Type _) [Group G] : Set (Set G) :=
  { S : Set G | S ≠ {1} ∧ ∃ seed : Finset G,
    S = AlgebraicCentralizerInter seed
  }

theorem AlgebraicCentralizerBasis.mem_iff (S : Set G) :
  S ∈ AlgebraicCentralizerBasis G ↔
    S ≠ {1} ∧ ∃ seed : Finset G, S = AlgebraicCentralizerInter seed
:= by rfl

theorem AlgebraicCentralizerBasis.subgroup_mem_iff (S : Subgroup G) :
  (S : Set G) ∈ AlgebraicCentralizerBasis G ↔
    S ≠ ⊥ ∧ ∃ seed : Finset G, S = AlgebraicCentralizerInter seed :=
by
  rw [mem_iff, <-Subgroup.coe_bot, ne_eq, SetLike.coe_set_eq]
  simp

theorem AlgebraicCentralizerBasis.empty_not_mem : ∅ ∉ AlgebraicCentralizerBasis G := by
  simp [AlgebraicCentralizerBasis]
  intro _ _
  rw [<-ne_eq]
  symm
  rw [<-Set.nonempty_iff_ne_empty]
  exact Subgroup.coe_nonempty _

theorem AlgebraicCentralizerBasis.to_subgroup {S : Set G} (S_in_basis : S ∈ AlgebraicCentralizerBasis G):
  ∃ S' : Subgroup G, S = S' :=
by
  rw [mem_iff] at S_in_basis
  let ⟨_, ⟨seed, S_eq⟩⟩ := S_in_basis
  use AlgebraicCentralizerInter seed

theorem Set.image_equiv_eq {α β : Type _} (S : Set α) (T : Set β) (f : α ≃ β) :
  f '' S = T ↔ S = f.symm '' T :=
by
  constructor
  · intro fS_eq_T
    ext x
    rw [<-fS_eq_T]
    simp
  · intro S_eq_fT
    ext x
    rw [S_eq_fT]
    simp

theorem AlgebraicCentralizerBasis.univ_mem (ex_non_trivial : ∃ g : G, g ≠ 1): Set.univ ∈ AlgebraicCentralizerBasis G := by
  rw [mem_iff]
  constructor
  symm
  exact Set.nonempty_compl.mp ex_non_trivial
  use ∅
  simp [AlgebraicCentralizerInter]

theorem AlgebraicCentralizerBasis.conj_mem {S : Set G} (S_in_basis : S ∈ AlgebraicCentralizerBasis G)
  (h : G) : (fun g => h * g * h⁻¹) '' S ∈ AlgebraicCentralizerBasis G :=
by
  let ⟨S', S_eq⟩ := to_subgroup S_in_basis
  rw [S_eq]
  rw [S_eq, subgroup_mem_iff] at S_in_basis
  rw [mem_iff]

  have conj_eq : (fun g => h * g * h⁻¹) = (MulAut.conj h).toEquiv := by
    ext x
    simp

  constructor
  · rw [conj_eq]
    rw [ne_eq, Set.image_equiv_eq]
    simp
    rw [<-Subgroup.coe_bot, SetLike.coe_set_eq]
    exact S_in_basis.left
  · let ⟨seed, S'_eq⟩ := S_in_basis.right
    have dec_eq : DecidableEq G := Classical.typeDecidableEq _
    use Finset.image (fun g => h * g * h⁻¹) seed
    rw [S'_eq]
    unfold AlgebraicCentralizerInter
    ext g
    rw [conj_eq]
    rw [Set.mem_image_equiv]
    simp
    conv => {
      rhs
      intro
      intro
      rw [<-SetLike.mem_coe, <-AlgebraicCentralizer.conj, conj_eq, Set.mem_image_equiv]
    }

theorem AlgebraicCentralizerBasis.inter_closed
  {S T : Set G} (S_in_basis : S ∈ AlgebraicCentralizerBasis G) (T_in_basis : T ∈ AlgebraicCentralizerBasis G)
  (ST_ne_bot : S ∩ T ≠ {1}) :
  S ∩ T ∈ AlgebraicCentralizerBasis G :=
by
  let ⟨S', S_eq⟩ := to_subgroup S_in_basis
  rw [S_eq]
  rw [S_eq, subgroup_mem_iff] at S_in_basis
  let ⟨S'_ne_bot, ⟨S'_seed, S'_eq⟩⟩ := S_in_basis

  let ⟨T', T_eq⟩ := to_subgroup T_in_basis
  rw [T_eq]
  rw [T_eq, subgroup_mem_iff] at T_in_basis
  let ⟨T'_ne_bot, ⟨T'_seed, T'_eq⟩⟩ := T_in_basis

  rw [<-Subgroup.coe_inf, subgroup_mem_iff]
  rw [S_eq, T_eq, <-Subgroup.coe_inf, <-Subgroup.coe_bot, ne_eq, SetLike.coe_set_eq, <-ne_eq] at ST_ne_bot

  have dec_eq : DecidableEq G := Classical.typeDecidableEq G

  refine ⟨ST_ne_bot, ⟨S'_seed ∪ T'_seed, ?inter_eq⟩⟩

  unfold AlgebraicCentralizerInter

  simp only [<-Finset.mem_coe]
  rw [Finset.coe_union, iInf_union]
  rw [S'_eq, T'_eq]
  rfl


def MulAut.conj_order_iso (g : G) : Set G ≃o Set G := (MulAut.conj g).toEquiv.toOrderIsoSet

theorem AlgebraicCentralizerBasis.eq_conj_self (g : G) :
  (MulAut.conj_order_iso g) '' AlgebraicCentralizerBasis G = AlgebraicCentralizerBasis G :=
by
  ext S
  simp [MulAut.conj_order_iso]
  conv => {
    lhs
    congr; intro x
    rw [Equiv.toOrderIsoSet_apply]
  }
  simp
  constructor
  · intro ⟨T, T_in_basis, T_eq⟩
    rw [<-T_eq]
    exact conj_mem T_in_basis g
  · intro S_in_basis
    use (fun h => g⁻¹ * h * g⁻¹⁻¹) '' S
    refine ⟨conj_mem S_in_basis g⁻¹, ?S_eq⟩
    rw [Set.image_image]
    group
    rw [Set.image_id']

theorem AlgebraicCentralizerBasis.conj_mem' {S : Set G} (S_in_basis : S ∈ AlgebraicCentralizerBasis G) (g : G) :
  (MulAut.conj_order_iso g) S ∈ AlgebraicCentralizerBasis G :=
by
  show (fun i => g * i * g⁻¹) '' S ∈ AlgebraicCentralizerBasis G
  exact conj_mem S_in_basis g

end AlgebraicCentralizer

end Rubin