import Mathlib.Data.Finset.Basic import Mathlib.GroupTheory.Commutator import Mathlib.GroupTheory.Subgroup.Basic import Mathlib.GroupTheory.GroupAction.Basic import Mathlib.Topology.Basic import Rubin.MulActionExt import Rubin.SmulImage import Rubin.Tactic namespace Rubin /-- The support of a group action of `g: G` on `α` (here generalized to `SMul G α`) is the set of values `x` in `α` for which `g • x ≠ x`. This can also be thought of as the complement of the fixpoints of `(g •)`, which [`support_eq_not_fixed_by`] provides. --/ def Support {G : Type _} (α : Type _) [SMul G α] (g : G) := {x : α | g • x ≠ x} #align support Rubin.Support theorem SmulSupport_def {G : Type _} (α : Type _) [SMul G α] {g : G} : Support α g = {x : α | g • x ≠ x} := by tauto variable {G α: Type _} variable [Group G] variable [MulAction G α] variable {f g : G} variable {x : α} theorem support_eq_not_fixed_by : Support α g = (MulAction.fixedBy α g)ᶜ := by tauto #align support_eq_not_fixed_by Rubin.support_eq_not_fixed_by theorem support_compl_eq_fixed_by : (Support α g)ᶜ = MulAction.fixedBy α g := by rw [<-compl_compl (MulAction.fixedBy _ _)] exact congr_arg (·ᶜ) support_eq_not_fixed_by theorem mem_support : x ∈ Support α g ↔ g • x ≠ x := by tauto #align mem_support Rubin.mem_support theorem not_mem_support : x ∉ Support α g ↔ g • x = x := by rw [Rubin.mem_support, Classical.not_not] #align mem_not_support Rubin.not_mem_support theorem smul_mem_support : x ∈ Support α g → g • x ∈ Support α g := fun h => h ∘ smul_left_cancel g #align smul_in_support Rubin.smul_mem_support theorem inv_smul_mem_support : x ∈ Support α g → g⁻¹ • x ∈ Support α g := fun h k => h (smul_inv_smul g x ▸ smul_congr g k) #align inv_smul_in_support Rubin.inv_smul_mem_support theorem fixed_of_disjoint {U : Set α} : x ∈ U → Disjoint U (Support α g) → g • x = x := fun x_in_U disjoint_U_support => not_mem_support.mp (Set.disjoint_left.mp disjoint_U_support x_in_U) #align fixed_of_disjoint Rubin.fixed_of_disjoint theorem fixed_smulImage_in_support (g : G) {U : Set α} : Support α g ⊆ U → g •'' U = U := by intro support_in_U ext x cases' @or_not (x ∈ Support α g) with xmoved xfixed exact ⟨fun _ => support_in_U xmoved, fun _ => mem_smulImage.mpr (support_in_U (Rubin.inv_smul_mem_support xmoved))⟩ rw [Rubin.mem_smulImage, smul_eq_iff_inv_smul_eq.mp (not_mem_support.mp xfixed)] #align fixes_subset_within_support Rubin.fixed_smulImage_in_support theorem smulImage_subset_in_support (g : G) (U V : Set α) : U ⊆ V → Support α g ⊆ V → g •'' U ⊆ V := fun U_in_V support_in_V => Rubin.fixed_smulImage_in_support g support_in_V ▸ smulImage_mono g U_in_V #align moves_subset_within_support Rubin.smulImage_subset_in_support theorem support_mul (g h : G) (α : Type _) [MulAction G α] : Support α (g * h) ⊆ Support α g ∪ Support α h := by intro x x_in_support by_contra h_support let res := not_or.mp h_support exact x_in_support ((mul_smul g h x).trans ((congr_arg (g • ·) (not_mem_support.mp res.2)).trans <| not_mem_support.mp res.1)) #align support_mul Rubin.support_mul theorem support_conjugate (α : Type _) [MulAction G α] (g h : G) : Support α (h * g * h⁻¹) = h •'' Support α g := by ext x rw [Rubin.mem_support, Rubin.mem_smulImage, Rubin.mem_support, mul_smul, mul_smul] constructor · intro h1; by_contra h2; exact h1 ((congr_arg (h • ·) h2).trans (smul_inv_smul _ _)) · intro h1; by_contra h2; exact h1 (inv_smul_smul h (g • h⁻¹ • x) ▸ congr_arg (h⁻¹ • ·) h2) #align support_conjugate Rubin.support_conjugate theorem support_inv (α : Type _) [MulAction G α] (g : G) : Support α g⁻¹ = Support α g := by ext x rw [Rubin.mem_support, Rubin.mem_support] constructor · intro h1; by_contra h2; exact h1 (smul_eq_iff_inv_smul_eq.mp h2) · intro h1; by_contra h2; exact h1 (smul_eq_iff_inv_smul_eq.mpr h2) #align support_inv Rubin.support_inv theorem support_pow (α : Type _) [MulAction G α] (g : G) (j : ℕ) : Support α (g ^ j) ⊆ Support α g := by intro x xmoved by_contra xfixed rw [Rubin.mem_support] at xmoved induction j with | zero => apply xmoved; rw [pow_zero g, one_smul] | succ j j_ih => apply xmoved let j_ih := (congr_arg (g • ·) (not_not.mp j_ih)).trans (not_mem_support.mp xfixed) simp at j_ih group_action at j_ih rw [<-Nat.one_add, <-zpow_ofNat, Int.ofNat_add] exact j_ih -- TODO: address this pain point -- Alternatively: -- rw [Int.add_comm, Int.ofNat_add_one_out, zpow_ofNat] at j_ih -- exact j_ih #align support_pow Rubin.support_pow theorem support_comm (α : Type _) [MulAction G α] (g h : G) : Support α ⁅g, h⁆ ⊆ Support α h ∪ (g •'' Support α h) := by intro x x_in_support by_contra all_fixed rw [Set.mem_union] at all_fixed cases' @or_not (h • x = x) with xfixed xmoved · rw [Rubin.mem_support, commutatorElement_def, mul_smul, smul_eq_iff_inv_smul_eq.mp xfixed, ← Rubin.mem_support] at x_in_support exact ((Rubin.support_conjugate α h g).symm ▸ (not_or.mp all_fixed).2) x_in_support · exact all_fixed (Or.inl xmoved) #align support_comm Rubin.support_comm theorem disjoint_support_comm (f g : G) {U : Set α} : Support α f ⊆ U → Disjoint U (g •'' U) → ∀ x ∈ U, ⁅f, g⁆ • x = f • x := by intro support_in_U disjoint_U x x_in_U have support_conj : Support α (g * f⁻¹ * g⁻¹) ⊆ g •'' U := by rw [support_conjugate] apply smulImage_mono rw [support_inv] exact support_in_U have goal := (congr_arg (f • ·) (Rubin.fixed_of_disjoint x_in_U (Set.disjoint_of_subset_right support_conj disjoint_U))).symm simp at goal -- NOTE: the nth_rewrite must happen on the second occurence, or else group_action yields an incorrect f⁻² nth_rewrite 2 [goal] group_action #align disjoint_support_comm Rubin.disjoint_support_comm lemma empty_of_subset_disjoint {α : Type _} {U V : Set α} : Disjoint U V → U ⊆ V → U = ∅ := by intro disj subset apply Set.eq_of_subset_of_subset <;> try simp intro x x_in_U simp apply disjoint_not_mem disj exact x_in_U exact subset x_in_U theorem not_commute_of_disj_support_smulImage {G α : Type _} [Group G] [MulAction G α] [FaithfulSMul G α] {f g : G} {U : Set α} (f_ne_one : f ≠ 1) (subset : Support α f ⊆ U) (disj : Disjoint (Support α f) (g •'' U)) : ¬Commute f g := by intro h_comm have h₀ : ∀ x ∈ U, x ∉ Support α f := by intro x x_in_U unfold Commute SemiconjBy at h_comm have gx_in_img := (mem_smulImage' g).mpr x_in_U have h₁ : g • f • x = g • x := by have res := disjoint_not_mem₂ disj gx_in_img rw [not_mem_support] at res rw [<-mul_smul] at res rw [h_comm] at res rw [mul_smul] at res exact res have h₂ : f • x = x := by rw [<-one_smul G (f • x)] nth_rw 2 [<-one_smul G x] rw [<-mul_left_inv g] rw [mul_smul] rw [mul_smul] nth_rw 1 [h₁] rw [<-not_mem_support] at h₂ exact h₂ have h₀' : Disjoint (Support α f) U := by intro T; simp intro T_ss_supp T_ss_U intro x x_in_T apply h₀ exact T_ss_U x_in_T exact T_ss_supp x_in_T have support_empty : Support α f = ∅ := empty_of_subset_disjoint h₀' subset apply f_ne_one apply smul_left_injective' (α := α) ext x simp by_contra h rw [<-ne_eq, <-mem_support] at h apply Set.eq_empty_iff_forall_not_mem.mp support_empty exact h theorem support_eq: Support α f = Support α g ↔ ∀ (x : α), (f • x = x ∧ g • x = x) ∨ (f • x ≠ x ∧ g • x ≠ x) := by constructor · intro h intro x by_cases x_in? : x ∈ Support α f · right have gx_ne_x := by rw [h] at x_in?; exact x_in? exact ⟨x_in?, gx_ne_x⟩ · left have fx_eq_x : f • x = x := by rw [<-not_mem_support]; exact x_in? have gx_eq_x : g • x = x := by rw [<-not_mem_support, <-h]; exact x_in? exact ⟨fx_eq_x, gx_eq_x⟩ · intro h ext x constructor · intro fx_ne_x rw [mem_support] at fx_ne_x rw [mem_support] cases h x with | inl h₁ => exfalso; exact fx_ne_x h₁.left | inr h₁ => exact h₁.right · intro gx_ne_x rw [mem_support] at gx_ne_x rw [mem_support] cases h x with | inl h₁ => exfalso; exact gx_ne_x h₁.right | inr h₁ => exact h₁.left section Continuous variable {G α : Type _} variable [Group G] variable [TopologicalSpace α] variable [MulAction G α] variable [ContinuousMulAction G α] theorem img_open_open (g : G) (U : Set α) (h : IsOpen U): IsOpen (g •'' U) := by rw [Rubin.smulImage_eq_inv_preimage] exact Continuous.isOpen_preimage (Rubin.ContinuousMulAction.continuous g⁻¹) U h #align img_open_open Rubin.img_open_open theorem support_open (g : G) [TopologicalSpace α] [T2Space α] [ContinuousMulAction G α] : IsOpen (Support α g) := by apply isOpen_iff_forall_mem_open.mpr intro x xmoved rcases T2Space.t2 (g • x) x xmoved with ⟨U, V, open_U, open_V, gx_in_U, x_in_V, disjoint_U_V⟩ exact ⟨V ∩ (g⁻¹ •'' U), fun y yW => Disjoint.ne_of_mem disjoint_U_V (mem_inv_smulImage.mp (Set.mem_of_mem_inter_right yW)) (Set.mem_of_mem_inter_left yW), IsOpen.inter open_V (Rubin.img_open_open g⁻¹ U open_U), ⟨x_in_V, mem_inv_smulImage.mpr gx_in_U⟩ ⟩ #align support_open Rubin.support_open end Continuous end Rubin