File: Mathlib/GroupTheory/GroupAction/Quotient.lean

full_name: MulAction.QuotientAction
code: /-- A typeclass for when a `MulAction β α` descends to the quotient `α ⧸ H`. -/
class QuotientAction : Prop where
  /-- The action fulfils a normality condition on products that lie in `H`.
    This ensures that the action descends to an action on the quotient `α ⧸ H`. -/
  inv_mul_mem : ∀ (b : β) {a a' : α}, a⁻¹ * a' ∈ H → (b • a)⁻¹ * b • a' ∈ H
goal: Prop

full_name: MulAction.QuotientAction.inv_mul_mem
code: /-- A typeclass for when a `MulAction β α` descends to the quotient `α ⧸ H`. -/
class QuotientAction : Prop where
  /-- The action fulfils a normality condition on products that lie in `H`.
    This ensures that the action descends to an action on the quotient `α ⧸ H`. -/
  inv_mul_mem : ∀ (b : β) {a a' : α}, a⁻¹ * a' ∈ H → (b • a)⁻¹ * b • a' ∈ H
goal: a⁻¹ * a' ∈ H → (b • a)⁻¹ * b • a' ∈ H

full_name: AddAction.QuotientAction
code: /-- A typeclass for when an `AddAction β α` descends to the quotient `α ⧸ H`. -/
class _root_.AddAction.QuotientAction {α : Type u} (β : Type v) [AddGroup α] [AddMonoid β]
  [AddAction β α] (H : AddSubgroup α) : Prop where
  /-- The action fulfils a normality condition on summands that lie in `H`.
    This ensures that the action descends to an action on the quotient `α ⧸ H`. -/
  inv_mul_mem : ∀ (b : β) {a a' : α}, -a + a' ∈ H → -(b +ᵥ a) + (b +ᵥ a') ∈ H
goal: Prop

full_name: AddAction.QuotientAction.inv_mul_mem
code: /-- A typeclass for when an `AddAction β α` descends to the quotient `α ⧸ H`. -/
class _root_.AddAction.QuotientAction {α : Type u} (β : Type v) [AddGroup α] [AddMonoid β]
  [AddAction β α] (H : AddSubgroup α) : Prop where
  /-- The action fulfils a normality condition on summands that lie in `H`.
    This ensures that the action descends to an action on the quotient `α ⧸ H`. -/
  inv_mul_mem : ∀ (b : β) {a a' : α}, -a + a' ∈ H → -(b +ᵥ a) + (b +ᵥ a') ∈ H
goal: -a + a' ∈ H → -(b +ᵥ a) + (b +ᵥ a') ∈ H

full_name: MulAction.left_quotientAction
code: @[to_additive]
instance left_quotientAction : QuotientAction α H 
goal: MulAction.QuotientAction α H

full_name: AddAction.left_quotientAction
code: @[to_additive]
instance left_quotientAction : QuotientAction α H 
goal: AddAction.QuotientAction α H

full_name: MulAction.right_quotientAction
code: @[to_additive]
instance right_quotientAction : QuotientAction (normalizer H).op H 
goal: MulAction.QuotientAction (↥H.normalizer.op) H

full_name: AddAction.right_quotientAction
code: @[to_additive]
instance right_quotientAction : QuotientAction (normalizer H).op H 
goal: AddAction.QuotientAction (↥H.normalizer.op) H

full_name: MulAction.right_quotientAction'
code: @[to_additive]
instance right_quotientAction' [hH : H.Normal] : QuotientAction αᵐᵒᵖ H 
goal: MulAction.QuotientAction αᵐᵒᵖ H

full_name: AddAction.right_quotientAction'
code: @[to_additive]
instance right_quotientAction' [hH : H.Normal] : QuotientAction αᵐᵒᵖ H 
goal: AddAction.QuotientAction αᵃᵒᵖ H

full_name: MulAction.quotient
code: @[to_additive]
instance quotient [QuotientAction β H] : MulAction β (α ⧸ H) 
goal: MulAction β (α ⧸ H)

full_name: AddAction.quotient
code: @[to_additive]
instance quotient [QuotientAction β H] : MulAction β (α ⧸ H) 
goal: AddAction β (α ⧸ H)

full_name: MulAction.Quotient.smul_mk
code: @[to_additive (attr := simp)]
theorem Quotient.smul_mk [QuotientAction β H] (b : β) (a : α) :
    (b • QuotientGroup.mk a : α ⧸ H) = QuotientGroup.mk (b • a) 
goal: b • ↑a = ↑(b • a)

full_name: AddAction.Quotient.vadd_mk
code: @[to_additive (attr := simp)]
theorem Quotient.smul_mk [QuotientAction β H] (b : β) (a : α) :
    (b • QuotientGroup.mk a : α ⧸ H) = QuotientGroup.mk (b • a) 
goal: b +ᵥ ↑a = ↑(b +ᵥ a)

full_name: MulAction.Quotient.smul_coe
code: @[to_additive (attr := simp)]
theorem Quotient.smul_coe [QuotientAction β H] (b : β) (a : α) :
    b • (a : α ⧸ H) = (↑(b • a) : α ⧸ H) 
goal: b • ↑a = ↑(b • a)

full_name: AddAction.Quotient.vadd_coe
code: @[to_additive (attr := simp)]
theorem Quotient.smul_coe [QuotientAction β H] (b : β) (a : α) :
    b • (a : α ⧸ H) = (↑(b • a) : α ⧸ H) 
goal: b +ᵥ ↑a = ↑(b +ᵥ a)

full_name: AddAction.Quotient.mk_vadd_out'
code: @[to_additive (attr := simp)]
theorem Quotient.mk_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) :
    QuotientGroup.mk (b • q.out') = b • q 
goal: ↑(b +ᵥ Quotient.out' q) = b +ᵥ q

full_name: MulAction.Quotient.mk_smul_out'
code: @[to_additive (attr := simp)]
theorem Quotient.mk_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) :
    QuotientGroup.mk (b • q.out') = b • q 
goal: ↑(b • Quotient.out' q) = b • q

full_name: MulAction.Quotient.coe_smul_out'
code: @[to_additive]
theorem Quotient.coe_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) : ↑(b • q.out') = b • q 
goal: ↑(b • Quotient.out' q) = b • q

full_name: AddAction.Quotient.coe_vadd_out'
code: @[to_additive]
theorem Quotient.coe_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) : ↑(b • q.out') = b • q 
goal: ↑(b +ᵥ Quotient.out' q) = b +ᵥ q

full_name: QuotientGroup.out'_conj_pow_minimalPeriod_mem
code: theorem _root_.QuotientGroup.out'_conj_pow_minimalPeriod_mem (a : α) (q : α ⧸ H) :
    q.out'⁻¹ * a ^ Function.minimalPeriod (a • ·) q * q.out' ∈ H 
goal: (Quotient.out' q)⁻¹ * a ^ Function.minimalPeriod (fun x => a • x) q * Quotient.out' q ∈ H

full_name: MulActionHom.toQuotient
code: /-- The canonical map to the left cosets. -/
def _root_.MulActionHom.toQuotient (H : Subgroup α) : α →[α] α ⧸ H 
goal: α →ₑ[id] α ⧸ H

full_name: MulActionHom.toQuotient_apply
code: @[simp]
theorem _root_.MulActionHom.toQuotient_apply (H : Subgroup α) (g : α) :
    MulActionHom.toQuotient H g = g 
goal: (MulActionHom.toQuotient H) g = ↑g

full_name: AddAction.addLeftCosetsCompSubtypeVal
code: @[to_additive]
instance mulLeftCosetsCompSubtypeVal (H I : Subgroup α) : MulAction I (α ⧸ H) 
goal: AddAction (↥I) (α ⧸ H)

full_name: MulAction.mulLeftCosetsCompSubtypeVal
code: @[to_additive]
instance mulLeftCosetsCompSubtypeVal (H I : Subgroup α) : MulAction I (α ⧸ H) 
goal: MulAction (↥I) (α ⧸ H)

full_name: AddAction.ofQuotientStabilizer
code: /-- The canonical map from the quotient of the stabilizer to the set. -/
@[to_additive "The canonical map from the quotient of the stabilizer to the set. "]
def ofQuotientStabilizer (g : α ⧸ MulAction.stabilizer α x) : β 
goal: β

full_name: MulAction.ofQuotientStabilizer
code: /-- The canonical map from the quotient of the stabilizer to the set. -/
@[to_additive "The canonical map from the quotient of the stabilizer to the set. "]
def ofQuotientStabilizer (g : α ⧸ MulAction.stabilizer α x) : β 
goal: β

full_name: MulAction.ofQuotientStabilizer_mk
code: @[to_additive (attr := simp)]
theorem ofQuotientStabilizer_mk (g : α) : ofQuotientStabilizer α x (QuotientGroup.mk g) = g • x 
goal: MulAction.ofQuotientStabilizer α x ↑g = g • x

full_name: AddAction.ofQuotientStabilizer_mk
code: @[to_additive (attr := simp)]
theorem ofQuotientStabilizer_mk (g : α) : ofQuotientStabilizer α x (QuotientGroup.mk g) = g • x 
goal: AddAction.ofQuotientStabilizer α x ↑g = g +ᵥ x

full_name: AddAction.ofQuotientStabilizer_mem_orbit
code: @[to_additive]
theorem ofQuotientStabilizer_mem_orbit (g) : ofQuotientStabilizer α x g ∈ orbit α x 
goal: AddAction.ofQuotientStabilizer α x g ∈ AddAction.orbit α x

full_name: MulAction.ofQuotientStabilizer_mem_orbit
code: @[to_additive]
theorem ofQuotientStabilizer_mem_orbit (g) : ofQuotientStabilizer α x g ∈ orbit α x 
goal: MulAction.ofQuotientStabilizer α x g ∈ MulAction.orbit α x

full_name: AddAction.ofQuotientStabilizer_vadd
code: @[to_additive]
theorem ofQuotientStabilizer_smul (g : α) (g' : α ⧸ MulAction.stabilizer α x) :
    ofQuotientStabilizer α x (g • g') = g • ofQuotientStabilizer α x g' 
goal: AddAction.ofQuotientStabilizer α x (g +ᵥ g') = g +ᵥ AddAction.ofQuotientStabilizer α x g'

full_name: MulAction.ofQuotientStabilizer_smul
code: @[to_additive]
theorem ofQuotientStabilizer_smul (g : α) (g' : α ⧸ MulAction.stabilizer α x) :
    ofQuotientStabilizer α x (g • g') = g • ofQuotientStabilizer α x g' 
goal: MulAction.ofQuotientStabilizer α x (g • g') = g • MulAction.ofQuotientStabilizer α x g'

full_name: AddAction.injective_ofQuotientStabilizer
code: @[to_additive]
theorem injective_ofQuotientStabilizer : Function.Injective (ofQuotientStabilizer α x) 
goal: Function.Injective (AddAction.ofQuotientStabilizer α x)

full_name: MulAction.injective_ofQuotientStabilizer
code: @[to_additive]
theorem injective_ofQuotientStabilizer : Function.Injective (ofQuotientStabilizer α x) 
goal: Function.Injective (MulAction.ofQuotientStabilizer α x)

full_name: AddAction.orbitEquivQuotientStabilizer
code: /-- **Orbit-stabilizer theorem**. -/
@[to_additive "Orbit-stabilizer theorem."]
noncomputable def orbitEquivQuotientStabilizer (b : β) : orbit α b ≃ α ⧸ stabilizer α b 
goal: ↑(AddAction.orbit α b) ≃ α ⧸ AddAction.stabilizer α b

full_name: MulAction.orbitEquivQuotientStabilizer
code: /-- **Orbit-stabilizer theorem**. -/
@[to_additive "Orbit-stabilizer theorem."]
noncomputable def orbitEquivQuotientStabilizer (b : β) : orbit α b ≃ α ⧸ stabilizer α b 
goal: ↑(MulAction.orbit α b) ≃ α ⧸ MulAction.stabilizer α b

full_name: AddAction.orbitProdStabilizerEquivAddGroup
code: /-- Orbit-stabilizer theorem. -/
@[to_additive AddAction.orbitProdStabilizerEquivAddGroup "Orbit-stabilizer theorem."]
noncomputable def orbitProdStabilizerEquivGroup (b : β) : orbit α b × stabilizer α b ≃ α 
goal: ↑(AddAction.orbit α b) × ↥(AddAction.stabilizer α b) ≃ α

full_name: MulAction.orbitProdStabilizerEquivGroup
code: /-- Orbit-stabilizer theorem. -/
@[to_additive AddAction.orbitProdStabilizerEquivAddGroup "Orbit-stabilizer theorem."]
noncomputable def orbitProdStabilizerEquivGroup (b : β) : orbit α b × stabilizer α b ≃ α 
goal: ↑(MulAction.orbit α b) × ↥(MulAction.stabilizer α b) ≃ α

full_name: AddAction.card_orbit_mul_card_stabilizer_eq_card_addGroup
code: /-- Orbit-stabilizer theorem. -/
@[to_additive AddAction.card_orbit_mul_card_stabilizer_eq_card_addGroup "Orbit-stabilizer theorem."]
theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fintype <| orbit α b]
    [Fintype <| stabilizer α b] :
    Fintype.card (orbit α b) * Fintype.card (stabilizer α b) = Fintype.card α 
goal: Fintype.card ↑(AddAction.orbit α b) * Fintype.card ↥(AddAction.stabilizer α b) = Fintype.card α

full_name: MulAction.card_orbit_mul_card_stabilizer_eq_card_group
code: /-- Orbit-stabilizer theorem. -/
@[to_additive AddAction.card_orbit_mul_card_stabilizer_eq_card_addGroup "Orbit-stabilizer theorem."]
theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fintype <| orbit α b]
    [Fintype <| stabilizer α b] :
    Fintype.card (orbit α b) * Fintype.card (stabilizer α b) = Fintype.card α 
goal: Fintype.card ↑(MulAction.orbit α b) * Fintype.card ↥(MulAction.stabilizer α b) = Fintype.card α

full_name: AddAction.orbitEquivQuotientStabilizer_symm_apply
code: @[to_additive (attr := simp)]
theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :
    ((orbitEquivQuotientStabilizer α b).symm a : β) = a • b 
goal: ↑((AddAction.orbitEquivQuotientStabilizer α b).symm ↑a) = a +ᵥ b

full_name: MulAction.orbitEquivQuotientStabilizer_symm_apply
code: @[to_additive (attr := simp)]
theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :
    ((orbitEquivQuotientStabilizer α b).symm a : β) = a • b 
goal: ↑((MulAction.orbitEquivQuotientStabilizer α b).symm ↑a) = a • b

full_name: MulAction.stabilizer_quotient
code: @[to_additive (attr := simp)]
theorem stabilizer_quotient {G} [Group G] (H : Subgroup G) :
    MulAction.stabilizer G ((1 : G) : G ⧸ H) = H 
goal: MulAction.stabilizer G ↑1 = H

full_name: AddAction.stabilizer_quotient
code: @[to_additive (attr := simp)]
theorem stabilizer_quotient {G} [Group G] (H : Subgroup G) :
    MulAction.stabilizer G ((1 : G) : G ⧸ H) = H 
goal: AddAction.stabilizer G ↑0 = H

full_name: MulAction._aux_Mathlib_GroupTheory_GroupAction_Quotient___macroRules_MulAction_termΩ_1
code: local notation "Ω" => Quotient <| orbitRel α β
goal: Lean.Macro

full_name: MulAction.selfEquivSigmaOrbitsQuotientStabilizer'
code: /-- **Class formula** : given `G` a group acting on `X` and `φ` a function mapping each orbit of `X`
under this action (that is, each element of the quotient of `X` by the relation `orbitRel G X`) to
an element in this orbit, this gives a (noncomputable) bijection between `X` and the disjoint union
of `G/Stab(φ(ω))` over all orbits `ω`. In most cases you'll want `φ` to be `Quotient.out'`, so we
provide `MulAction.selfEquivSigmaOrbitsQuotientStabilizer'` as a special case. -/
@[to_additive
      "**Class formula** : given `G` an additive group acting on `X` and `φ` a function
      mapping each orbit of `X` under this action (that is, each element of the quotient of `X` by
      the relation `orbit_rel G X`) to an element in this orbit, this gives a (noncomputable)
      bijection between `X` and the disjoint union of `G/Stab(φ(ω))` over all orbits `ω`. In most
      cases you'll want `φ` to be `Quotient.out'`, so we provide
      `AddAction.selfEquivSigmaOrbitsQuotientStabilizer'` as a special case. "]
noncomputable def selfEquivSigmaOrbitsQuotientStabilizer' {φ : Ω → β}
    (hφ : LeftInverse Quotient.mk'' φ) : β ≃ Σω : Ω, α ⧸ stabilizer α (φ ω) 
goal: β ≃ (ω : Quotient (MulAction.orbitRel α β)) × α ⧸ MulAction.stabilizer α (φ ω)

full_name: AddAction.selfEquivSigmaOrbitsQuotientStabilizer'
code: /-- **Class formula** : given `G` a group acting on `X` and `φ` a function mapping each orbit of `X`
under this action (that is, each element of the quotient of `X` by the relation `orbitRel G X`) to
an element in this orbit, this gives a (noncomputable) bijection between `X` and the disjoint union
of `G/Stab(φ(ω))` over all orbits `ω`. In most cases you'll want `φ` to be `Quotient.out'`, so we
provide `MulAction.selfEquivSigmaOrbitsQuotientStabilizer'` as a special case. -/
@[to_additive
      "**Class formula** : given `G` an additive group acting on `X` and `φ` a function
      mapping each orbit of `X` under this action (that is, each element of the quotient of `X` by
      the relation `orbit_rel G X`) to an element in this orbit, this gives a (noncomputable)
      bijection between `X` and the disjoint union of `G/Stab(φ(ω))` over all orbits `ω`. In most
      cases you'll want `φ` to be `Quotient.out'`, so we provide
      `AddAction.selfEquivSigmaOrbitsQuotientStabilizer'` as a special case. "]
noncomputable def selfEquivSigmaOrbitsQuotientStabilizer' {φ : Ω → β}
    (hφ : LeftInverse Quotient.mk'' φ) : β ≃ Σω : Ω, α ⧸ stabilizer α (φ ω) 
goal: β ≃ (ω : Quotient (AddAction.orbitRel α β)) × α ⧸ AddAction.stabilizer α (φ ω)

full_name: MulAction.card_eq_sum_card_group_div_card_stabilizer'
code: /-- **Class formula** for a finite group acting on a finite type. See
`MulAction.card_eq_sum_card_group_div_card_stabilizer` for a specialized version using
`Quotient.out'`. -/
@[to_additive
      "**Class formula** for a finite group acting on a finite type. See
      `AddAction.card_eq_sum_card_addGroup_div_card_stabilizer` for a specialized version using
      `Quotient.out'`."]
theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [Fintype Ω]
    [∀ b : β, Fintype <| stabilizer α b] {φ : Ω → β} (hφ : LeftInverse Quotient.mk'' φ) :
    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) 
goal: Fintype.card β = ∑ ω : Quotient (MulAction.orbitRel α β), Fintype.card α / Fintype.card ↥(MulAction.stabilizer α (φ ω))

full_name: AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer'
code: /-- **Class formula** for a finite group acting on a finite type. See
`MulAction.card_eq_sum_card_group_div_card_stabilizer` for a specialized version using
`Quotient.out'`. -/
@[to_additive
      "**Class formula** for a finite group acting on a finite type. See
      `AddAction.card_eq_sum_card_addGroup_div_card_stabilizer` for a specialized version using
      `Quotient.out'`."]
theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [Fintype Ω]
    [∀ b : β, Fintype <| stabilizer α b] {φ : Ω → β} (hφ : LeftInverse Quotient.mk'' φ) :
    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) 
goal: Fintype.card β = ∑ ω : Quotient (AddAction.orbitRel α β), Fintype.card α / Fintype.card ↥(AddAction.stabilizer α (φ ω))

full_name: AddAction.selfEquivSigmaOrbitsQuotientStabilizer
code: /-- **Class formula**. This is a special case of
`MulAction.self_equiv_sigma_orbits_quotient_stabilizer'` with `φ = Quotient.out'`. -/
@[to_additive
      "**Class formula**. This is a special case of
      `AddAction.self_equiv_sigma_orbits_quotient_stabilizer'` with `φ = Quotient.out'`. "]
noncomputable def selfEquivSigmaOrbitsQuotientStabilizer : β ≃ Σω : Ω, α ⧸ stabilizer α ω.out' 
goal: β ≃ (ω : Quotient (AddAction.orbitRel α β)) × α ⧸ AddAction.stabilizer α ω.out'

full_name: MulAction.selfEquivSigmaOrbitsQuotientStabilizer
code: /-- **Class formula**. This is a special case of
`MulAction.self_equiv_sigma_orbits_quotient_stabilizer'` with `φ = Quotient.out'`. -/
@[to_additive
      "**Class formula**. This is a special case of
      `AddAction.self_equiv_sigma_orbits_quotient_stabilizer'` with `φ = Quotient.out'`. "]
noncomputable def selfEquivSigmaOrbitsQuotientStabilizer : β ≃ Σω : Ω, α ⧸ stabilizer α ω.out' 
goal: β ≃ (ω : Quotient (MulAction.orbitRel α β)) × α ⧸ MulAction.stabilizer α ω.out'

full_name: MulAction.card_eq_sum_card_group_div_card_stabilizer
code: /-- **Class formula** for a finite group acting on a finite type. -/
@[to_additive "**Class formula** for a finite group acting on a finite type."]
theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fintype Ω]
    [∀ b : β, Fintype <| stabilizer α b] :
    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α ω.out') 
goal: Fintype.card β = ∑ ω : Quotient (MulAction.orbitRel α β), Fintype.card α / Fintype.card ↥(MulAction.stabilizer α ω.out')

full_name: AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer
code: /-- **Class formula** for a finite group acting on a finite type. -/
@[to_additive "**Class formula** for a finite group acting on a finite type."]
theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fintype Ω]
    [∀ b : β, Fintype <| stabilizer α b] :
    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α ω.out') 
goal: Fintype.card β = ∑ ω : Quotient (AddAction.orbitRel α β), Fintype.card α / Fintype.card ↥(AddAction.stabilizer α ω.out')

full_name: AddAction.sigmaFixedByEquivOrbitsProdAddGroup
code: /-- **Burnside's lemma** : a (noncomputable) bijection between the disjoint union of all
`{x ∈ X | g • x = x}` for `g ∈ G` and the product `G × X/G`, where `G` is a group acting on `X` and
`X/G` denotes the quotient of `X` by the relation `orbitRel G X`. -/
@[to_additive AddAction.sigmaFixedByEquivOrbitsProdAddGroup
      "**Burnside's lemma** : a (noncomputable) bijection between the disjoint union of all
      `{x ∈ X | g • x = x}` for `g ∈ G` and the product `G × X/G`, where `G` is an additive group
      acting on `X` and `X/G`denotes the quotient of `X` by the relation `orbitRel G X`. "]
noncomputable def sigmaFixedByEquivOrbitsProdGroup : (Σa : α, fixedBy β a) ≃ Ω × α 
goal: (a : α) × ↑(AddAction.fixedBy β a) ≃ Quotient (AddAction.orbitRel α β) × α

full_name: MulAction.sigmaFixedByEquivOrbitsProdGroup
code: /-- **Burnside's lemma** : a (noncomputable) bijection between the disjoint union of all
`{x ∈ X | g • x = x}` for `g ∈ G` and the product `G × X/G`, where `G` is a group acting on `X` and
`X/G` denotes the quotient of `X` by the relation `orbitRel G X`. -/
@[to_additive AddAction.sigmaFixedByEquivOrbitsProdAddGroup
      "**Burnside's lemma** : a (noncomputable) bijection between the disjoint union of all
      `{x ∈ X | g • x = x}` for `g ∈ G` and the product `G × X/G`, where `G` is an additive group
      acting on `X` and `X/G`denotes the quotient of `X` by the relation `orbitRel G X`. "]
noncomputable def sigmaFixedByEquivOrbitsProdGroup : (Σa : α, fixedBy β a) ≃ Ω × α 
goal: (a : α) × ↑(MulAction.fixedBy β a) ≃ Quotient (MulAction.orbitRel α β) × α

full_name: MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group
code: /-- **Burnside's lemma** : given a finite group `G` acting on a set `X`, the average number of
elements fixed by each `g ∈ G` is the number of orbits. -/
@[to_additive AddAction.sum_card_fixedBy_eq_card_orbits_mul_card_addGroup
      "**Burnside's lemma** : given a finite additive group `G` acting on a set `X`,
      the average number of elements fixed by each `g ∈ G` is the number of orbits. "]
theorem sum_card_fixedBy_eq_card_orbits_mul_card_group [Fintype α] [∀ a : α, Fintype <| fixedBy β a]
    [Fintype Ω] : (∑ a : α, Fintype.card (fixedBy β a)) = Fintype.card Ω * Fintype.card α 
goal: ∑ a : α, Fintype.card ↑(MulAction.fixedBy β a) = Fintype.card (Quotient (MulAction.orbitRel α β)) * Fintype.card α

full_name: AddAction.sum_card_fixedBy_eq_card_orbits_mul_card_addGroup
code: /-- **Burnside's lemma** : given a finite group `G` acting on a set `X`, the average number of
elements fixed by each `g ∈ G` is the number of orbits. -/
@[to_additive AddAction.sum_card_fixedBy_eq_card_orbits_mul_card_addGroup
      "**Burnside's lemma** : given a finite additive group `G` acting on a set `X`,
      the average number of elements fixed by each `g ∈ G` is the number of orbits. "]
theorem sum_card_fixedBy_eq_card_orbits_mul_card_group [Fintype α] [∀ a : α, Fintype <| fixedBy β a]
    [Fintype Ω] : (∑ a : α, Fintype.card (fixedBy β a)) = Fintype.card Ω * Fintype.card α 
goal: ∑ a : α, Fintype.card ↑(AddAction.fixedBy β a) = Fintype.card (Quotient (AddAction.orbitRel α β)) * Fintype.card α

full_name: AddAction.isPretransitive_quotient
code: @[to_additive]
instance isPretransitive_quotient (G) [Group G] (H : Subgroup G) : IsPretransitive G (G ⧸ H) 
goal: AddAction.IsPretransitive G (G ⧸ H)

full_name: MulAction.isPretransitive_quotient
code: @[to_additive]
instance isPretransitive_quotient (G) [Group G] (H : Subgroup G) : IsPretransitive G (G ⧸ H) 
goal: MulAction.IsPretransitive G (G ⧸ H)

full_name: AddAction.finite_quotient_of_pretransitive_of_finite_quotient
code: @[to_additive]
instance finite_quotient_of_pretransitive_of_finite_quotient [IsPretransitive α β] {H : Subgroup α}
    [Finite (α ⧸ H)] : Finite <| orbitRel.Quotient H β 
goal: Finite (AddAction.orbitRel.Quotient (↥H) β)

full_name: MulAction.finite_quotient_of_pretransitive_of_finite_quotient
code: @[to_additive]
instance finite_quotient_of_pretransitive_of_finite_quotient [IsPretransitive α β] {H : Subgroup α}
    [Finite (α ⧸ H)] : Finite <| orbitRel.Quotient H β 
goal: Finite (MulAction.orbitRel.Quotient (↥H) β)

full_name: AddAction.equivAddSubgroupOrbitsSetoidComap
code: /-- A bijection between the quotient of the action of a subgroup `H` on an orbit, and a
corresponding quotient expressed in terms of `Setoid.comap Subtype.val`. -/
@[to_additive "A bijection between the quotient of the action of an additive subgroup `H` on an
orbit, and a corresponding quotient expressed in terms of `Setoid.comap Subtype.val`."]
noncomputable def equivSubgroupOrbitsSetoidComap (H : Subgroup α) (ω : Ω) :
    orbitRel.Quotient H (orbitRel.Quotient.orbit ω) ≃
      Quotient ((orbitRel H β).comap (Subtype.val : Quotient.mk (orbitRel α β) ⁻¹' {ω} → β)) 
goal: AddAction.orbitRel.Quotient ↥H ↑(AddAction.orbitRel.Quotient.orbit ω) ≃
  Quotient (Setoid.comap Subtype.val (AddAction.orbitRel (↥H) β))

full_name: MulAction.equivSubgroupOrbitsSetoidComap
code: /-- A bijection between the quotient of the action of a subgroup `H` on an orbit, and a
corresponding quotient expressed in terms of `Setoid.comap Subtype.val`. -/
@[to_additive "A bijection between the quotient of the action of an additive subgroup `H` on an
orbit, and a corresponding quotient expressed in terms of `Setoid.comap Subtype.val`."]
noncomputable def equivSubgroupOrbitsSetoidComap (H : Subgroup α) (ω : Ω) :
    orbitRel.Quotient H (orbitRel.Quotient.orbit ω) ≃
      Quotient ((orbitRel H β).comap (Subtype.val : Quotient.mk (orbitRel α β) ⁻¹' {ω} → β)) 
goal: MulAction.orbitRel.Quotient ↥H ↑(MulAction.orbitRel.Quotient.orbit ω) ≃
  Quotient (Setoid.comap Subtype.val (MulAction.orbitRel (↥H) β))

full_name: MulAction.equivSubgroupOrbits
code: /-- A bijection between the orbits under the action of a subgroup `H` on `β`, and the orbits
under the action of `H` on each orbit under the action of `G`. -/
@[to_additive "A bijection between the orbits under the action of an additive subgroup `H` on `β`,
and the orbits under the action of `H` on each orbit under the action of `G`."]
noncomputable def equivSubgroupOrbits (H : Subgroup α) :
    orbitRel.Quotient H β ≃ Σω : Ω, orbitRel.Quotient H (orbitRel.Quotient.orbit ω) 
goal: MulAction.orbitRel.Quotient (↥H) β ≃
  (ω : Quotient (MulAction.orbitRel α β)) × MulAction.orbitRel.Quotient ↥H ↑(MulAction.orbitRel.Quotient.orbit ω)

full_name: AddAction.equivAddSubgroupOrbits
code: /-- A bijection between the orbits under the action of a subgroup `H` on `β`, and the orbits
under the action of `H` on each orbit under the action of `G`. -/
@[to_additive "A bijection between the orbits under the action of an additive subgroup `H` on `β`,
and the orbits under the action of `H` on each orbit under the action of `G`."]
noncomputable def equivSubgroupOrbits (H : Subgroup α) :
    orbitRel.Quotient H β ≃ Σω : Ω, orbitRel.Quotient H (orbitRel.Quotient.orbit ω) 
goal: AddAction.orbitRel.Quotient (↥H) β ≃
  (ω : Quotient (AddAction.orbitRel α β)) × AddAction.orbitRel.Quotient ↥H ↑(AddAction.orbitRel.Quotient.orbit ω)

full_name: MulAction.finite_quotient_of_finite_quotient_of_finite_quotient
code: @[to_additive]
instance finite_quotient_of_finite_quotient_of_finite_quotient {H : Subgroup α}
    [Finite (orbitRel.Quotient α β)] [Finite (α ⧸ H)] :
    Finite <| orbitRel.Quotient H β 
goal: Finite (MulAction.orbitRel.Quotient (↥H) β)

full_name: AddAction.finite_quotient_of_finite_quotient_of_finite_quotient
code: @[to_additive]
instance finite_quotient_of_finite_quotient_of_finite_quotient {H : Subgroup α}
    [Finite (orbitRel.Quotient α β)] [Finite (α ⧸ H)] :
    Finite <| orbitRel.Quotient H β 
goal: Finite (AddAction.orbitRel.Quotient (↥H) β)

full_name: ConjClasses.card_carrier
code: theorem ConjClasses.card_carrier {G : Type*} [Group G] [Fintype G] (g : G)
    [Fintype (ConjClasses.mk g).carrier] [Fintype <| MulAction.stabilizer (ConjAct G) g] :
    Fintype.card (ConjClasses.mk g).carrier =
      Fintype.card G / Fintype.card (MulAction.stabilizer (ConjAct G) g) 
goal: Fintype.card ↑(ConjClasses.mk g).carrier = Fintype.card G / Fintype.card ↥(MulAction.stabilizer (ConjAct G) g)

full_name: Subgroup.normalCore_eq_ker
code: theorem normalCore_eq_ker : H.normalCore = (MulAction.toPermHom G (G ⧸ H)).ker 
goal: H.normalCore = (MulAction.toPermHom G (G ⧸ H)).ker

full_name: Subgroup.quotientCentralizerEmbedding
code: /-- Cosets of the centralizer of an element embed into the set of commutators. -/
noncomputable def quotientCentralizerEmbedding (g : G) :
    G ⧸ centralizer (zpowers (g : G)) ↪ commutatorSet G 
goal: G ⧸ Subgroup.centralizer ↑(Subgroup.zpowers g) ↪ ↑(commutatorSet G)

full_name: Subgroup.quotientCentralizerEmbedding_apply
code: theorem quotientCentralizerEmbedding_apply (g : G) (x : G) :
    quotientCentralizerEmbedding g x = ⟨⁅x, g⁆, x, g, rfl⟩ 
goal: (Subgroup.quotientCentralizerEmbedding g) ↑x = ⟨⁅x, g⁆, ⋯⟩

full_name: Subgroup.quotientCenterEmbedding
code: /-- If `G` is generated by `S`, then the quotient by the center embeds into `S`-indexed sequences
of commutators. -/
noncomputable def quotientCenterEmbedding {S : Set G} (hS : closure S = ⊤) :
    G ⧸ center G ↪ S → commutatorSet G 
goal: G ⧸ Subgroup.center G ↪ ↑S → ↑(commutatorSet G)

full_name: Subgroup.quotientCenterEmbedding_apply
code: theorem quotientCenterEmbedding_apply {S : Set G} (hS : closure S = ⊤) (g : G) (s : S) :
    quotientCenterEmbedding hS g s = ⟨⁅g, s⁆, g, s, rfl⟩ 
goal: (Subgroup.quotientCenterEmbedding hS) (↑g) s = ⟨⁅g, ↑s⁆, ⋯⟩

full_name: card_comm_eq_card_conjClasses_mul_card
code: theorem card_comm_eq_card_conjClasses_mul_card (G : Type*) [Group G] :
    Nat.card { p : G × G // Commute p.1 p.2 } = Nat.card (ConjClasses G) * Nat.card G 
goal: Nat.card { p // Commute p.1 p.2 } = Nat.card (ConjClasses G) * Nat.card G