File: Mathlib/GroupTheory/GroupAction/Blocks.lean

full_name: MulAction.orbit.eq_or_disjoint
code: theorem orbit.eq_or_disjoint (a b : X) :
    orbit G a = orbit G b ∨ Disjoint (orbit G a) (orbit G b) 
goal: MulAction.orbit G a = MulAction.orbit G b ∨ Disjoint (MulAction.orbit G a) (MulAction.orbit G b)

full_name: MulAction.orbit.pairwiseDisjoint
code: theorem orbit.pairwiseDisjoint :
    (Set.range fun x : X => orbit G x).PairwiseDisjoint id 
goal: (Set.range fun x => MulAction.orbit G x).PairwiseDisjoint id

full_name: MulAction.IsPartition.of_orbits
code: /-- Orbits of an element form a partition -/
theorem IsPartition.of_orbits :
    Setoid.IsPartition (Set.range fun a : X => orbit G a) 
goal: Setoid.IsPartition (Set.range fun a => MulAction.orbit G a)

full_name: MulAction.IsFixedBlock
code: /-- For `SMul G X`, a fixed block is a `Set X` which is fully invariant:
  `g • B = B` for all `g : G` -/
def IsFixedBlock (B : Set X) 
goal: Prop

full_name: MulAction.IsInvariantBlock
code: /-- For `SMul G X`, an invariant block is a `Set X` which is stable:
  `g • B ⊆ B` for all `g : G` -/
def IsInvariantBlock (B : Set X) 
goal: Prop

full_name: MulAction.IsTrivialBlock
code: /-- A trivial block is a `Set X` which is either a subsingleton or ⊤
  (it is not necessarily a block…) -/
def IsTrivialBlock (B : Set X) 
goal: Prop

full_name: MulAction.IsBlock
code: /-- `For SMul G X`, a block is a `Set X` whose translates are pairwise disjoint -/
def IsBlock (B : Set X) 
goal: Prop

full_name: MulAction.IsBlock.def
code: /-- A set B is a block iff for all g, g',
the sets g • B and g' • B are either equal or disjoint -/
theorem IsBlock.def {B : Set X} :
    IsBlock G B ↔ ∀ g g' : G, g • B = g' • B ∨ Disjoint (g • B) (g' • B) 
goal: MulAction.IsBlock G B ↔ ∀ (g g' : G), g • B = g' • B ∨ Disjoint (g • B) (g' • B)

full_name: MulAction.IsBlock.mk_notempty
code: /-- Alternate definition of a block -/
theorem IsBlock.mk_notempty {B : Set X} :
    IsBlock G B ↔ ∀ g g' : G, g • B ∩ g' • B ≠ ∅ → g • B = g' • B 
goal: MulAction.IsBlock G B ↔ ∀ (g g' : G), g • B ∩ g' • B ≠ ∅ → g • B = g' • B

full_name: MulAction.IsFixedBlock.isBlock
code: /-- A fixed block is a block -/
theorem IsFixedBlock.isBlock {B : Set X} (hfB : IsFixedBlock G B) :
    IsBlock G B 
goal: MulAction.IsBlock G B

full_name: MulAction.isBlock_empty
code: /-- The empty set is a block -/
theorem isBlock_empty : IsBlock G (⊥ : Set X) 
goal: MulAction.IsBlock G ⊥

full_name: MulAction.isBlock_singleton
code: theorem isBlock_singleton (a : X) : IsBlock G ({a} : Set X) 
goal: MulAction.IsBlock G {a}

full_name: MulAction.isBlock_subsingleton
code: /-- Subsingletons are (trivial) blocks -/
theorem isBlock_subsingleton {B : Set X} (hB : B.Subsingleton) :
    IsBlock G B 
goal: MulAction.IsBlock G B

full_name: MulAction.IsBlock.smul_eq_or_disjoint
code: theorem IsBlock.smul_eq_or_disjoint {B : Set X} (hB : IsBlock G B) (g : G) :
    g • B = B ∨ Disjoint (g • B) B 
goal: g • B = B ∨ Disjoint (g • B) B

full_name: MulAction.IsBlock.def_one
code: theorem IsBlock.def_one {B : Set X} :
    IsBlock G B ↔ ∀ g : G, g • B = B ∨ Disjoint (g • B) B 
goal: MulAction.IsBlock G B ↔ ∀ (g : G), g • B = B ∨ Disjoint (g • B) B

full_name: MulAction.IsBlock.mk_notempty_one
code: theorem IsBlock.mk_notempty_one {B : Set X} :
    IsBlock G B ↔ ∀ g : G, g • B ∩ B ≠ ∅ → g • B = B 
goal: MulAction.IsBlock G B ↔ ∀ (g : G), g • B ∩ B ≠ ∅ → g • B = B

full_name: MulAction.IsBlock.mk_mem
code: theorem IsBlock.mk_mem {B : Set X} :
    IsBlock G B ↔ ∀ (g : G) (a : X) (_ : a ∈ B) (_ : g • a ∈ B), g • B = B 
goal: MulAction.IsBlock G B ↔ ∀ (g : G), ∀ a ∈ B, g • a ∈ B → g • B = B

full_name: MulAction.IsBlock.def_mem
code: theorem IsBlock.def_mem {B : Set X} (hB : IsBlock G B) {a : X} {g : G} :
    a ∈ B → g • a ∈ B → g • B = B 
goal: a ∈ B → g • a ∈ B → g • B = B

full_name: MulAction.IsBlock.mk_subset
code: theorem IsBlock.mk_subset {B : Set X} :
    IsBlock G B ↔ ∀ {g : G} {b : X} (_ : b ∈ B) (_ : b ∈ g • B), g • B ⊆ B 
goal: MulAction.IsBlock G B ↔ ∀ {g : G} {b : X}, b ∈ B → b ∈ g • B → g • B ⊆ B

full_name: MulAction.IsInvariantBlock.isFixedBlock
code: /-- An invariant block is a fixed block -/
theorem IsInvariantBlock.isFixedBlock {B : Set X} (hfB : IsInvariantBlock G B) :
    IsFixedBlock G B 
goal: MulAction.IsFixedBlock G B

full_name: MulAction.IsInvariantBlock.isBlock
code: /-- An invariant block is a block -/
theorem IsInvariantBlock.isBlock {B : Set X} (hfB : IsInvariantBlock G B) :
    IsBlock G B 
goal: MulAction.IsBlock G B

full_name: MulAction.isFixedBlock_orbit
code: /-- An orbit is a block -/
theorem isFixedBlock_orbit (a : X) : IsFixedBlock G (orbit G a) 
goal: MulAction.IsFixedBlock G (MulAction.orbit G a)

full_name: MulAction.isBlock_orbit
code: /-- An orbit is a block -/
theorem isBlock_orbit (a : X) : IsBlock G (orbit G a) 
goal: MulAction.IsBlock G (MulAction.orbit G a)

full_name: MulAction.isFixedBlock_top
code: /-- The full set is a (trivial) block -/
theorem isFixedBlock_top : IsFixedBlock G (⊤ : Set X) 
goal: MulAction.IsFixedBlock G ⊤

full_name: MulAction.isBlock_top
code: /-- The full set is a (trivial) block -/
theorem isBlock_top : IsBlock G (⊤ : Set X) 
goal: MulAction.IsBlock G ⊤

full_name: MulAction.IsBlock.subgroup
code: /-- Is `B` is a block for an action of `G`, it is a block for the action of any subgroup of `G` -/
theorem IsBlock.subgroup {H : Subgroup G} {B : Set X} (hfB : IsBlock G B) :
    IsBlock H B 
goal: MulAction.IsBlock (↥H) B

full_name: MulAction.IsBlock.preimage
code: theorem IsBlock.preimage {H Y : Type*} [Group H] [MulAction H Y]
    {φ : H → G} (j : Y →ₑ[φ] X) {B : Set X} (hB : IsBlock G B) :
    IsBlock H (j ⁻¹' B) 
goal: MulAction.IsBlock H (⇑j ⁻¹' B)

full_name: MulAction.IsBlock.image
code: theorem IsBlock.image {H Y : Type*} [Group H] [MulAction H Y]
    {φ : G →* H} (j : X →ₑ[φ] Y)
    (hφ : Function.Surjective φ) (hj : Function.Injective j)
    {B : Set X} (hB : IsBlock G B) :
    IsBlock H (j '' B) 
goal: MulAction.IsBlock H (⇑j '' B)

full_name: MulAction.IsBlock.subtype_val_preimage
code: theorem IsBlock.subtype_val_preimage {C : SubMulAction G X} {B : Set X} (hB : IsBlock G B) :
    IsBlock G (Subtype.val ⁻¹' B : Set C) 
goal: MulAction.IsBlock G (Subtype.val ⁻¹' B)

full_name: MulAction.IsBlock.iff_subtype_val
code: theorem IsBlock.iff_subtype_val {C : SubMulAction G X} {B : Set C} :
    IsBlock G B ↔ IsBlock G (Subtype.val '' B : Set X) 
goal: MulAction.IsBlock G B ↔ MulAction.IsBlock G (Subtype.val '' B)

full_name: MulAction.IsBlock.iff_top
code: theorem IsBlock.iff_top (B : Set X) :
    IsBlock G B ↔ IsBlock (⊤ : Subgroup G) B 
goal: MulAction.IsBlock G B ↔ MulAction.IsBlock (↥⊤) B

full_name: MulAction.IsBlock.inter
code: /-- The intersection of two blocks is a block -/
theorem IsBlock.inter {B₁ B₂ : Set X} (h₁ : IsBlock G B₁) (h₂ : IsBlock G B₂) :
    IsBlock G (B₁ ∩ B₂) 
goal: MulAction.IsBlock G (B₁ ∩ B₂)

full_name: MulAction.IsBlock.iInter
code: /-- An intersection of blocks is a block -/
theorem IsBlock.iInter {ι : Type*} {B : ι → Set X} (hB : ∀ i : ι, IsBlock G (B i)) :
    IsBlock G (⋂ i, B i) 
goal: MulAction.IsBlock G (⋂ i, B i)

full_name: MulAction.IsBlock.of_subgroup_of_conjugate
code: theorem IsBlock.of_subgroup_of_conjugate {B : Set X} {H : Subgroup G} (hB : IsBlock H B) (g : G) :
    IsBlock (Subgroup.map (MulEquiv.toMonoidHom (MulAut.conj g)) H) (g • B) 
goal: MulAction.IsBlock (↥(Subgroup.map (MulEquiv.toMonoidHom (MulAut.conj g)) H)) (g • B)

full_name: MulAction.IsBlock.translate
code: /-- A translate of a block is a block -/
theorem IsBlock.translate {B : Set X} (g : G) (hB : IsBlock G B) :
    IsBlock G (g • B) 
goal: MulAction.IsBlock G (g • B)

full_name: MulAction.IsBlockSystem
code: /-- For `SMul G X`, a block system of `X` is a partition of `X` into blocks
  for the action of `G` -/
def IsBlockSystem (B : Set (Set X)) 
goal: Prop

full_name: MulAction.IsBlock.isBlockSystem
code: /-- Translates of a block form a `block_system` -/
theorem IsBlock.isBlockSystem [hGX : MulAction.IsPretransitive G X]
    {B : Set X} (hB : IsBlock G B) (hBe : B.Nonempty) :
    IsBlockSystem G (Set.range fun g : G => g • B) 
goal: MulAction.IsBlockSystem G (Set.range fun g => g • B)

full_name: MulAction.smul_orbit_eq_orbit_smul
code: lemma smul_orbit_eq_orbit_smul (N : Subgroup G) [nN : N.Normal] (a : X) (g : G) :
    g • orbit N a = orbit N (g • a) 
goal: g • MulAction.orbit (↥N) a = MulAction.orbit (↥N) (g • a)

full_name: MulAction.orbit.isBlock_of_normal
code: /-- An orbit of a normal subgroup is a block -/
theorem orbit.isBlock_of_normal {N : Subgroup G} [N.Normal] (a : X) :
    IsBlock G (orbit N a) 
goal: MulAction.IsBlock G (MulAction.orbit (↥N) a)

full_name: MulAction.IsBlockSystem.of_normal
code: /-- The orbits of a normal subgroup form a block system -/
theorem IsBlockSystem.of_normal {N : Subgroup G} [N.Normal] :
    IsBlockSystem G (Set.range fun a : X => orbit N a) 
goal: MulAction.IsBlockSystem G (Set.range fun a => MulAction.orbit (↥N) a)

full_name: MulAction.IsBlock.of_orbit
code: /-- The orbit of `a` under a subgroup containing the stabilizer of `a` is a block -/
theorem IsBlock.of_orbit {H : Subgroup G} {a : X} (hH : stabilizer G a ≤ H) :
    IsBlock G (MulAction.orbit H a) 
goal: MulAction.IsBlock G (MulAction.orbit (↥H) a)

full_name: MulAction.IsBlock.stabilizer_le
code: /-- If `B` is a block containing `a`, then the stabilizer of `B` contains the stabilizer of `a` -/
theorem IsBlock.stabilizer_le {B : Set X} (hB : IsBlock G B) {a : X} (ha : a ∈ B) :
    stabilizer G a ≤ stabilizer G B 
goal: MulAction.stabilizer G a ≤ MulAction.stabilizer G B

full_name: MulAction.IsBlock.orbit_stabilizer_eq
code: /-- A block containing `a` is the orbit of `a` under its stabilizer -/
theorem IsBlock.orbit_stabilizer_eq
    [htGX : IsPretransitive G X] {B : Set X} (hB : IsBlock G B) {a : X} (ha : a ∈ B) :
    MulAction.orbit (stabilizer G B) a = B 
goal: MulAction.orbit (↥(MulAction.stabilizer G B)) a = B

full_name: MulAction.stabilizer_orbit_eq
code: /-- A subgroup containing the stabilizer of `a`
  is the stabilizer of the orbit of `a` under that subgroup -/
theorem stabilizer_orbit_eq {a : X} {H : Subgroup G} (hH : stabilizer G a ≤ H) :
    stabilizer G (orbit H a) = H 
goal: MulAction.stabilizer G (MulAction.orbit (↥H) a) = H

full_name: MulAction.block_stabilizerOrderIso
code: /-- Order equivalence between blocks in `X` containing a point `a`
 and subgroups of `G` containing the stabilizer of `a` (Wielandt, th. 7.5)-/
def block_stabilizerOrderIso [htGX : IsPretransitive G X] (a : X) :
    { B : Set X // a ∈ B ∧ IsBlock G B } ≃o Set.Ici (stabilizer G a) 
goal: { B // a ∈ B ∧ MulAction.IsBlock G B } ≃o ↑(Set.Ici (MulAction.stabilizer G a))