import Mathlib.Data.Finset.Basic
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.GroupTheory.GroupAction.FixingSubgroup

import Rubin.Support
import Rubin.MulActionExt

namespace Rubin

-- comment by Cedric: would be nicer to define just a subset, and then show it is a subgroup
def rigidStabilizer' (G : Type _) [Group G] [MulAction G α] (U : Set α) : Set G :=
  {g : G | ∀ x : α, g • x = x ∨ x ∈ U}
#align rigid_stabilizer' Rubin.rigidStabilizer'

-- TODO: rename to something else? Also check the literature on what this is called
/--
A "rigid stabilizer" is a subgroup of `G` associated with a set `U` for which `Support α g ⊆ U` is true for all of its elements.

In other words, a rigid stabilizer for a set `U` contains all elements of `G` that don't move points outside of `U`.

The notation for this subgroup is `G•[U]`.
You might sometimes find an expression written as `↑G•[U]` when `G•[U]` is used as a set.
--/
def RigidStabilizer (G : Type _) [Group G] [MulAction G α] (U : Set α) : Subgroup G
    where
  carrier := {g : G | ∀ (x) (_ : x ∉ U), g • x = x}
  mul_mem' ha hb x x_notin_U := by rw [mul_smul, hb x x_notin_U, ha x x_notin_U]
  inv_mem' hg x x_notin_U := smul_eq_iff_inv_smul_eq.mp (hg x x_notin_U)
  one_mem' x _ := one_smul G x
#align rigid_stabilizer Rubin.RigidStabilizer

notation:max G "•[" U "]" => RigidStabilizer G U

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

theorem rigidStabilizer_eq_fixingSubgroup_compl (U : Set α) :
  G•[U] = fixingSubgroup G Uᶜ :=
by
  ext g
  rw [mem_fixingSubgroup_iff, <-Subgroup.mem_carrier]
  unfold RigidStabilizer
  simp

theorem rigidStabilizer_support {g : G} {U : Set α} :
  g ∈ RigidStabilizer G U ↔ Support α g ⊆ U :=
⟨
  fun h x x_in_support =>
    by_contradiction (x_in_support ∘ h x),
  by
    intro support_sub
    rw [<-Subgroup.mem_carrier]
    unfold RigidStabilizer; simp
    intro x x_notin_U
    by_contra h
    exact x_notin_U (support_sub h)
⟩
#align rist_supported_in_set Rubin.rigidStabilizer_support

theorem rigidStabilizer_mono {U V : Set α} (V_ss_U : V ⊆ U) :
  (RigidStabilizer G V : Set G) ⊆ (RigidStabilizer G U : Set G) :=
by
  intro g g_in_ristV x x_notin_U
  have x_notin_V : x ∉ V := by intro x_in_V; exact x_notin_U (V_ss_U x_in_V)
  exact g_in_ristV x x_notin_V
#align rist_ss_rist Rubin.rigidStabilizer_mono

theorem monotone_rigidStabilizer : Monotone (RigidStabilizer (α := α) G) := fun _ _ => rigidStabilizer_mono

theorem rigidStabilizer_compl [FaithfulSMul G α] {U : Set α} {f : G} (f_ne_one : f ≠ 1) :
  f ∈ G•[Uᶜ] → f ∉ G•[U] :=
by
  intro f_in_rist_compl
  intro f_in_rist
  rw [rigidStabilizer_support] at f_in_rist_compl
  rw [rigidStabilizer_support] at f_in_rist
  rw [Set.subset_compl_iff_disjoint_left] at f_in_rist_compl
  have supp_empty : Support α f = ∅ := empty_of_subset_disjoint f_in_rist_compl.symm f_in_rist
  exact f_ne_one ((support_empty_iff f).mp supp_empty)

theorem commute_if_rigidStabilizer_and_disjoint {g h : G} {U : Set α} [FaithfulSMul G α] :
  g ∈ RigidStabilizer G U → Disjoint U (Support α h) → Commute g h :=
by
  intro g_in_rist U_disj
  unfold Commute
  unfold SemiconjBy
  apply eq_of_smul_eq_smul (α := α)
  intro x

  by_cases x_in_U?: x ∈ U
  {
    rw [rigidStabilizer_support] at g_in_rist
    have x_notin_support : x ∉ Support α h := disjoint_not_mem U_disj x_in_U?

    rw [mul_smul]
    rw [not_mem_support.mp x_notin_support]
    rw [mul_smul]

    by_cases gx_in_U?: g • x ∈ U
    {
      symm
      apply not_mem_support.mp
      apply disjoint_not_mem U_disj
      exact gx_in_U?
    }
    {
      have gx_notin_support : g • x ∉ Support α g := by
        intro h
        exact gx_in_U? (g_in_rist h)
      rw [<-support_inv] at gx_notin_support
      rw [not_mem_support] at gx_notin_support
      simp at gx_notin_support
      symm at gx_notin_support
      rw [fixes_inv] at gx_notin_support
      rw [<-gx_notin_support]
      symm
      group_action
      rw [not_mem_support.mp x_notin_support]
    }
  }
  {
    have x_fixed : g • x = x := g_in_rist _ x_in_U?
    repeat rw [mul_smul]
    rw [x_fixed]

    by_cases hx_in_U?: h • x ∈ U
    {
      have hx_notin_support := disjoint_not_mem U_disj hx_in_U?
      rw [<-support_inv] at hx_notin_support
      rw [not_mem_support] at hx_notin_support
      symm at hx_notin_support
      group_action at hx_notin_support
      rw [hx_notin_support]
      exact x_fixed
    }
    {
      rw [g_in_rist _ hx_in_U?]
    }
  }

theorem rigidStabilizer_inter (U V : Set α) :
  G•[U ∩ V] = G•[U] ⊓ G•[V] :=
by
  ext x
  simp
  repeat rw [rigidStabilizer_support]
  rw [Set.subset_inter_iff]

@[simp]
theorem rigidStabilizer_empty (G α: Type _) [Group G] [MulAction G α] [FaithfulSMul G α]:
  G•[(∅ : Set α)] = ⊥ :=
by
  rw [Subgroup.eq_bot_iff_forall]
  intro f f_in_rist
  rw [<-Subgroup.mem_carrier] at f_in_rist
  apply eq_of_smul_eq_smul (α := α)

  intro x
  rw [f_in_rist x (Set.not_mem_empty x)]
  simp

@[simp]
theorem rigidStabilizer_univ (G α: Type _) [Group G] [MulAction G α]:
  G•[(Set.univ : Set α)] = ⊤ :=
by
  ext g
  rw [rigidStabilizer_support]
  simp

theorem rigidStabilizer_sInter (S : Set (Set α)) :
  G•[⋂₀ S] = ⨅ T ∈ S, G•[T] :=
by
  ext x
  rw [rigidStabilizer_support]
  constructor
  · intro supp_ss_sInter
    rw [Subgroup.mem_iInf]
    intro T
    rw [Subgroup.mem_iInf]
    intro T_in_S
    rw [rigidStabilizer_support]
    rw [Set.subset_sInter_iff] at supp_ss_sInter
    exact supp_ss_sInter T T_in_S
  · intro x_in_rist
    rw [Set.subset_sInter_iff]
    intro T T_in_S
    rw [<-rigidStabilizer_support]
    rw [Subgroup.mem_iInf] at x_in_rist
    specialize x_in_rist T
    rw [Subgroup.mem_iInf] at x_in_rist
    exact x_in_rist T_in_S

theorem rigidStabilizer_smulImage (f g : G) (S : Set α) :
  g ∈ G•[f •'' S] ↔ f⁻¹ * g * f ∈ G•[S] :=
by
  repeat rw [rigidStabilizer_support]
  nth_rw 3 [<-inv_inv f]
  rw [support_conjugate]
  rw [smulImage_subset_inv]
  simp

theorem rigidStabilizer_conj_image_eq (S : Set α) (f : G) :
  (fun g => f * g * f⁻¹) '' G•[S] = G•[f •'' S] :=
by
  ext x
  have f_eq : (fun g => f * g * f⁻¹) = (MulAut.conj f).toEquiv := by
    ext x
    simp

  rw [f_eq, Set.mem_image_equiv]
  rw [MulEquiv.toEquiv_eq_coe, MulEquiv.coe_toEquiv_symm, MulAut.conj_symm_apply]
  simp [rigidStabilizer_smulImage]

theorem orbit_rigidStabilizer_subset {p : α} {U : Set α} (p_in_U : p ∈ U):
  MulAction.orbit G•[U] p ⊆ U :=
by
  intro q q_in_orbit
  have ⟨⟨h, h_in_rist⟩, hp_eq_q⟩ := MulAction.mem_orbit_iff.mp q_in_orbit
  simp at hp_eq_q
  rw [<-hp_eq_q]
  rw [rigidStabilizer_support] at h_in_rist
  rw [<-elem_moved_in_support' p h_in_rist]
  assumption

-- TODO: remov ethe need for FaithfulSMul?
theorem rigidStabilizer_neBot [FaithfulSMul G α] {U : Set α}:
  G•[U] ≠ ⊥ → Set.Nonempty U :=
by
  intro ne_bot
  by_contra empty
  apply ne_bot
  rw [Set.not_nonempty_iff_eq_empty] at empty
  rw [empty]
  exact rigidStabilizer_empty G α

end Rubin