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/Support.lean

297 lines
9.6 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.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