File: Mathlib/GroupTheory/Abelianization.lean

full_name: commutator
code: /-- The commutator subgroup of a group G is the normal subgroup
  generated by the commutators [p,q]=`p*q*p⁻¹*q⁻¹`. -/
def commutator : Subgroup G 
goal: Subgroup G

full_name: instNormalCommutator
code: instance : Subgroup.Normal (commutator G) 
goal: (commutator G).Normal

full_name: commutator_def
code: theorem commutator_def : commutator G = ⁅(⊤ : Subgroup G), ⊤⁆ 
goal: commutator G = ⁅⊤, ⊤⁆

full_name: commutator_eq_closure
code: theorem commutator_eq_closure : commutator G = Subgroup.closure (commutatorSet G) 
goal: commutator G = Subgroup.closure (commutatorSet G)

full_name: commutator_eq_normalClosure
code: theorem commutator_eq_normalClosure : commutator G = Subgroup.normalClosure (commutatorSet G) 
goal: commutator G = Subgroup.normalClosure (commutatorSet G)

full_name: commutator_characteristic
code: instance commutator_characteristic : (commutator G).Characteristic 
goal: (commutator G).Characteristic

full_name: instFGSubtypeMemSubgroupCommutatorOfFiniteElemCommutatorSet
code: instance [Finite (commutatorSet G)] : Group.FG (commutator G) 
goal: Group.FG ↥(commutator G)

full_name: rank_commutator_le_card
code: theorem rank_commutator_le_card [Finite (commutatorSet G)] :
    Group.rank (commutator G) ≤ Nat.card (commutatorSet G) 
goal: Group.rank ↥(commutator G) ≤ Nat.card ↑(commutatorSet G)

full_name: commutator_centralizer_commutator_le_center
code: theorem commutator_centralizer_commutator_le_center :
    ⁅centralizer (commutator G : Set G), centralizer (commutator G)⁆ ≤ Subgroup.center G 
goal: ⁅Subgroup.centralizer ↑(commutator G), Subgroup.centralizer ↑(commutator G)⁆ ≤ Subgroup.center G

full_name: Abelianization
code: /-- The abelianization of G is the quotient of G by its commutator subgroup. -/
def Abelianization : Type u 
goal: Type u

full_name: Abelianization.commGroup
code: instance commGroup : CommGroup (Abelianization G) 
goal: CommGroup (Abelianization G)

full_name: Abelianization.instInhabited
code: instance : Inhabited (Abelianization G) 
goal: Inhabited (Abelianization G)

full_name: Abelianization.instUnique
code: instance [Unique G] : Unique (Abelianization G) 
goal: Unique (Abelianization G)

full_name: Abelianization.instFintypeOfDecidablePredMemSubgroupCommutator
code: instance [Fintype G] [DecidablePred (· ∈ commutator G)] : Fintype (Abelianization G) 
goal: Fintype (Abelianization G)

full_name: Abelianization.instFinite
code: instance [Finite G] : Finite (Abelianization G) 
goal: Finite (Abelianization G)

full_name: Abelianization.of
code: /-- `of` is the canonical projection from G to its abelianization. -/
def of : G →* Abelianization G 
goal: G →* Abelianization G

full_name: Abelianization.mk_eq_of
code: @[simp]
theorem mk_eq_of (a : G) : Quot.mk _ a = of a 
goal: Quot.mk Setoid.r a = Abelianization.of a

full_name: Abelianization.commutator_subset_ker
code: theorem commutator_subset_ker : commutator G ≤ f.ker 
goal: commutator G ≤ f.ker

full_name: Abelianization.lift
code: /-- If `f : G → A` is a group homomorphism to an abelian group, then `lift f` is the unique map
  from the abelianization of a `G` to `A` that factors through `f`. -/
def lift : (G →* A) ≃ (Abelianization G →* A) 
goal: (G →* A) ≃ (Abelianization G →* A)

full_name: Abelianization.lift.of
code: @[simp]
theorem lift.of (x : G) : lift f (of x) = f x 
goal: (Abelianization.lift f) (Abelianization.of x) = f x

full_name: Abelianization.lift.unique
code: theorem lift.unique (φ : Abelianization G →* A)
    -- hφ : φ agrees with f on the image of G in Gᵃᵇ
    (hφ : ∀ x : G, φ (Abelianization.of x) = f x)
    {x : Abelianization G} : φ x = lift f x 
goal: φ x = (Abelianization.lift f) x

full_name: Abelianization.lift_of
code: @[simp]
theorem lift_of : lift of = MonoidHom.id (Abelianization G) 
goal: Abelianization.lift Abelianization.of = MonoidHom.id (Abelianization G)

full_name: Abelianization.hom_ext
code: /-- See note [partially-applied ext lemmas]. -/
@[ext]
theorem hom_ext (φ ψ : Abelianization G →* A) (h : φ.comp of = ψ.comp of) : φ = ψ 
goal: φ = ψ

full_name: Abelianization.map
code: /-- The map operation of the `Abelianization` functor -/
def map : Abelianization G →* Abelianization H 
goal: Abelianization G →* Abelianization H

full_name: Abelianization.lift_of_comp
code: /-- Use `map` as the preferred simp normal form. -/
@[simp] theorem lift_of_comp :
    Abelianization.lift (Abelianization.of.comp f) = Abelianization.map f 
goal: Abelianization.lift (Abelianization.of.comp f) = Abelianization.map f

full_name: Abelianization.map_of
code: @[simp]
theorem map_of (x : G) : map f (of x) = of (f x) 
goal: (Abelianization.map f) (Abelianization.of x) = Abelianization.of (f x)

full_name: Abelianization.map_id
code: @[simp]
theorem map_id : map (MonoidHom.id G) = MonoidHom.id (Abelianization G) 
goal: Abelianization.map (MonoidHom.id G) = MonoidHom.id (Abelianization G)

full_name: Abelianization.map_comp
code: @[simp]
theorem map_comp {I : Type w} [Group I] (g : H →* I) : (map g).comp (map f) = map (g.comp f) 
goal: (Abelianization.map g).comp (Abelianization.map f) = Abelianization.map (g.comp f)

full_name: Abelianization.map_map_apply
code: @[simp]
theorem map_map_apply {I : Type w} [Group I] {g : H →* I} {x : Abelianization G} :
    map g (map f x) = map (g.comp f) x 
goal: (Abelianization.map g) ((Abelianization.map f) x) = (Abelianization.map (g.comp f)) x

full_name: MulEquiv.abelianizationCongr
code: /-- Equivalent groups have equivalent abelianizations -/
def MulEquiv.abelianizationCongr : Abelianization G ≃* Abelianization H 
goal: Abelianization G ≃* Abelianization H

full_name: abelianizationCongr_of
code: @[simp]
theorem abelianizationCongr_of (x : G) :
    e.abelianizationCongr (Abelianization.of x) = Abelianization.of (e x) 
goal: e.abelianizationCongr (Abelianization.of x) = Abelianization.of (e x)

full_name: abelianizationCongr_refl
code: @[simp]
theorem abelianizationCongr_refl :
    (MulEquiv.refl G).abelianizationCongr = MulEquiv.refl (Abelianization G) 
goal: (MulEquiv.refl G).abelianizationCongr = MulEquiv.refl (Abelianization G)

full_name: abelianizationCongr_symm
code: @[simp]
theorem abelianizationCongr_symm : e.abelianizationCongr.symm = e.symm.abelianizationCongr 
goal: e.abelianizationCongr.symm = e.symm.abelianizationCongr

full_name: abelianizationCongr_trans
code: @[simp]
theorem abelianizationCongr_trans {I : Type v} [Group I] (e₂ : H ≃* I) :
    e.abelianizationCongr.trans e₂.abelianizationCongr = (e.trans e₂).abelianizationCongr 
goal: e.abelianizationCongr.trans e₂.abelianizationCongr = (e.trans e₂).abelianizationCongr

full_name: Abelianization.equivOfComm
code: /-- An Abelian group is equivalent to its own abelianization. -/
@[simps]
def Abelianization.equivOfComm {H : Type*} [CommGroup H] : H ≃* Abelianization H 
goal: H ≃* Abelianization H

full_name: Abelianization.equivOfComm_symm_apply
code: /-- An Abelian group is equivalent to its own abelianization. -/
@[simps]
def Abelianization.equivOfComm {H : Type*} [CommGroup H] : H ≃* Abelianization H 
goal: Abelianization.equivOfComm.symm a = (Abelianization.lift (MonoidHom.id H)) a

full_name: Abelianization.equivOfComm_apply
code: /-- An Abelian group is equivalent to its own abelianization. -/
@[simps]
def Abelianization.equivOfComm {H : Type*} [CommGroup H] : H ≃* Abelianization H 
goal: Abelianization.equivOfComm a = Abelianization.of a

full_name: commutatorRepresentatives
code: /-- Representatives `(g₁, g₂) : G × G` of commutators `⁅g₁, g₂⁆ ∈ G`. -/
def commutatorRepresentatives : Set (G × G) 
goal: Set (G × G)

full_name: instFiniteElemProdCommutatorRepresentativesOfCommutatorSet
code: instance [Finite (commutatorSet G)] : Finite (commutatorRepresentatives G) 
goal: Finite ↑(commutatorRepresentatives G)

full_name: closureCommutatorRepresentatives
code: /-- Subgroup generated by representatives `g₁ g₂ : G` of commutators `⁅g₁, g₂⁆ ∈ G`. -/
def closureCommutatorRepresentatives : Subgroup G 
goal: Subgroup G

full_name: closureCommutatorRepresentatives_fg
code: instance closureCommutatorRepresentatives_fg [Finite (commutatorSet G)] :
    Group.FG (closureCommutatorRepresentatives G) 
goal: Group.FG ↥(closureCommutatorRepresentatives G)

full_name: rank_closureCommutatorRepresentatives_le
code: theorem rank_closureCommutatorRepresentatives_le [Finite (commutatorSet G)] :
    Group.rank (closureCommutatorRepresentatives G) ≤ 2 * Nat.card (commutatorSet G) 
goal: Group.rank ↥(closureCommutatorRepresentatives G) ≤ 2 * Nat.card ↑(commutatorSet G)

full_name: image_commutatorSet_closureCommutatorRepresentatives
code: theorem image_commutatorSet_closureCommutatorRepresentatives :
    (closureCommutatorRepresentatives G).subtype ''
        commutatorSet (closureCommutatorRepresentatives G) =
      commutatorSet G 
goal: ⇑(closureCommutatorRepresentatives G).subtype '' commutatorSet ↥(closureCommutatorRepresentatives G) = commutatorSet G

full_name: card_commutatorSet_closureCommutatorRepresentatives
code: theorem card_commutatorSet_closureCommutatorRepresentatives :
    Nat.card (commutatorSet (closureCommutatorRepresentatives G)) = Nat.card (commutatorSet G) 
goal: Nat.card ↑(commutatorSet ↥(closureCommutatorRepresentatives G)) = Nat.card ↑(commutatorSet G)

full_name: card_commutator_closureCommutatorRepresentatives
code: theorem card_commutator_closureCommutatorRepresentatives :
    Nat.card (commutator (closureCommutatorRepresentatives G)) = Nat.card (commutator G) 
goal: Nat.card ↥(commutator ↥(closureCommutatorRepresentatives G)) = Nat.card ↥(commutator G)

full_name: instFiniteElemSubtypeMemSubgroupClosureCommutatorRepresentativesCommutatorSet
code: instance [Finite (commutatorSet G)] :
    Finite (commutatorSet (closureCommutatorRepresentatives G)) 
goal: Finite ↑(commutatorSet ↥(closureCommutatorRepresentatives G))