You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
rubin-lean4/Rubin/RigidStabilizer.lean

217 lines
6.4 KiB

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

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]
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
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 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