File: Mathlib/GroupTheory/GroupAction/ConjAct.lean

full_name: ConjAct
code: /-- A type alias for a group `G`. `ConjAct G` acts on `G` by conjugation -/
def ConjAct : Type _ 
goal: Type u_3

full_name: ConjAct.instGroup
code: instance [Group G] : Group (ConjAct G) 
goal: Group (ConjAct G)

full_name: ConjAct.instDivInvMonoid
code: instance [DivInvMonoid G] : DivInvMonoid (ConjAct G) 
goal: DivInvMonoid (ConjAct G)

full_name: ConjAct.instGroupWithZero
code: instance [GroupWithZero G] : GroupWithZero (ConjAct G) 
goal: GroupWithZero (ConjAct G)

full_name: ConjAct.instFintype
code: instance [Fintype G] : Fintype (ConjAct G) 
goal: Fintype (ConjAct G)

full_name: ConjAct.card
code: @[simp]
theorem card [Fintype G] : Fintype.card (ConjAct G) = Fintype.card G 
goal: Fintype.card (ConjAct G) = Fintype.card G

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

full_name: ConjAct.ofConjAct
code: /-- Reinterpret `g : ConjAct G` as an element of `G`. -/
def ofConjAct : ConjAct G ≃* G 
goal: ConjAct G ≃* G

full_name: ConjAct.toConjAct
code: /-- Reinterpret `g : G` as an element of `ConjAct G`. -/
def toConjAct : G ≃* ConjAct G 
goal: G ≃* ConjAct G

full_name: ConjAct.rec
code: /-- A recursor for `ConjAct`, for use as `induction x` when `x : ConjAct G`. -/
@[elab_as_elim, cases_eliminator, induction_eliminator]
protected def rec {C : ConjAct G → Sort*} (h : ∀ g, C (toConjAct g)) : ∀ g, C g 
goal: C g

full_name: ConjAct.forall
code: @[simp]
theorem «forall» (p : ConjAct G → Prop) : (∀ x : ConjAct G, p x) ↔ ∀ x : G, p (toConjAct x) 
goal: (∀ (x : ConjAct G), p x) ↔ ∀ (x : G), p (ConjAct.toConjAct x)

full_name: ConjAct.of_mul_symm_eq
code: @[simp]
theorem of_mul_symm_eq : (@ofConjAct G _).symm = toConjAct 
goal: ConjAct.ofConjAct.symm = ConjAct.toConjAct

full_name: ConjAct.to_mul_symm_eq
code: @[simp]
theorem to_mul_symm_eq : (@toConjAct G _).symm = ofConjAct 
goal: ConjAct.toConjAct.symm = ConjAct.ofConjAct

full_name: ConjAct.toConjAct_ofConjAct
code: @[simp]
theorem toConjAct_ofConjAct (x : ConjAct G) : toConjAct (ofConjAct x) = x 
goal: ConjAct.toConjAct (ConjAct.ofConjAct x) = x

full_name: ConjAct.ofConjAct_toConjAct
code: @[simp]
theorem ofConjAct_toConjAct (x : G) : ofConjAct (toConjAct x) = x 
goal: ConjAct.ofConjAct (ConjAct.toConjAct x) = x

full_name: ConjAct.ofConjAct_one
code: theorem ofConjAct_one : ofConjAct (1 : ConjAct G) = 1 
goal: ConjAct.ofConjAct 1 = 1

full_name: ConjAct.toConjAct_one
code: theorem toConjAct_one : toConjAct (1 : G) = 1 
goal: ConjAct.toConjAct 1 = 1

full_name: ConjAct.ofConjAct_inv
code: @[simp]
theorem ofConjAct_inv (x : ConjAct G) : ofConjAct x⁻¹ = (ofConjAct x)⁻¹ 
goal: ConjAct.ofConjAct x⁻¹ = (ConjAct.ofConjAct x)⁻¹

full_name: ConjAct.toConjAct_inv
code: @[simp]
theorem toConjAct_inv (x : G) : toConjAct x⁻¹ = (toConjAct x)⁻¹ 
goal: ConjAct.toConjAct x⁻¹ = (ConjAct.toConjAct x)⁻¹

full_name: ConjAct.ofConjAct_mul
code: theorem ofConjAct_mul (x y : ConjAct G) : ofConjAct (x * y) = ofConjAct x * ofConjAct y 
goal: ConjAct.ofConjAct (x * y) = ConjAct.ofConjAct x * ConjAct.ofConjAct y

full_name: ConjAct.toConjAct_mul
code: theorem toConjAct_mul (x y : G) : toConjAct (x * y) = toConjAct x * toConjAct y 
goal: ConjAct.toConjAct (x * y) = ConjAct.toConjAct x * ConjAct.toConjAct y

full_name: ConjAct.instSMul
code: instance : SMul (ConjAct G) G 
goal: SMul (ConjAct G) G

full_name: ConjAct.smul_def
code: theorem smul_def (g : ConjAct G) (h : G) : g • h = ofConjAct g * h * (ofConjAct g)⁻¹ 
goal: g • h = ConjAct.ofConjAct g * h * (ConjAct.ofConjAct g)⁻¹

full_name: ConjAct.toConjAct_smul
code: theorem toConjAct_smul (g h : G) : toConjAct g • h = g * h * g⁻¹ 
goal: ConjAct.toConjAct g • h = g * h * g⁻¹

full_name: ConjAct.unitsScalar
code: instance unitsScalar : SMul (ConjAct Mˣ) M 
goal: SMul (ConjAct Mˣ) M

full_name: ConjAct.units_smul_def
code: theorem units_smul_def (g : ConjAct Mˣ) (h : M) : g • h = ofConjAct g * h * ↑(ofConjAct g)⁻¹ 
goal: g • h = ↑(ConjAct.ofConjAct g) * h * ↑(ConjAct.ofConjAct g)⁻¹

full_name: ConjAct.unitsMulDistribMulAction
code: instance unitsMulDistribMulAction : MulDistribMulAction (ConjAct Mˣ) M 
goal: MulDistribMulAction (ConjAct Mˣ) M

full_name: ConjAct.unitsSMulCommClass
code: instance unitsSMulCommClass [SMul α M] [SMulCommClass α M M] [IsScalarTower α M M] :
    SMulCommClass α (ConjAct Mˣ) M 
goal: SMulCommClass α (ConjAct Mˣ) M

full_name: ConjAct.unitsSMulCommClass'
code: instance unitsSMulCommClass' [SMul α M] [SMulCommClass M α M] [IsScalarTower α M M] :
    SMulCommClass (ConjAct Mˣ) α M 
goal: SMulCommClass (ConjAct Mˣ) α M

full_name: ConjAct.unitsMulSemiringAction
code: instance unitsMulSemiringAction : MulSemiringAction (ConjAct Rˣ) R 
goal: MulSemiringAction (ConjAct Rˣ) R

full_name: ConjAct.ofConjAct_zero
code: theorem ofConjAct_zero : ofConjAct (0 : ConjAct G₀) = 0 
goal: ConjAct.ofConjAct 0 = 0

full_name: ConjAct.toConjAct_zero
code: theorem toConjAct_zero : toConjAct (0 : G₀) = 0 
goal: ConjAct.toConjAct 0 = 0

full_name: ConjAct.mulAction₀
code: instance mulAction₀ : MulAction (ConjAct G₀) G₀ 
goal: MulAction (ConjAct G₀) G₀

full_name: ConjAct.smulCommClass₀
code: instance smulCommClass₀ [SMul α G₀] [SMulCommClass α G₀ G₀] [IsScalarTower α G₀ G₀] :
    SMulCommClass α (ConjAct G₀) G₀ 
goal: SMulCommClass α (ConjAct G₀) G₀

full_name: ConjAct.smulCommClass₀'
code: instance smulCommClass₀' [SMul α G₀] [SMulCommClass G₀ α G₀] [IsScalarTower α G₀ G₀] :
    SMulCommClass (ConjAct G₀) α G₀ 
goal: SMulCommClass (ConjAct G₀) α G₀

full_name: ConjAct.distribMulAction₀
code: instance distribMulAction₀ : DistribMulAction (ConjAct K) K 
goal: DistribMulAction (ConjAct K) K

full_name: ConjAct.instMulDistribMulAction
code: instance : MulDistribMulAction (ConjAct G) G 
goal: MulDistribMulAction (ConjAct G) G

full_name: ConjAct.smulCommClass
code: instance smulCommClass [SMul α G] [SMulCommClass α G G] [IsScalarTower α G G] :
    SMulCommClass α (ConjAct G) G 
goal: SMulCommClass α (ConjAct G) G

full_name: ConjAct.smulCommClass'
code: instance smulCommClass' [SMul α G] [SMulCommClass G α G] [IsScalarTower α G G] :
    SMulCommClass (ConjAct G) α G 
goal: SMulCommClass (ConjAct G) α G

full_name: ConjAct.smul_eq_mulAut_conj
code: theorem smul_eq_mulAut_conj (g : ConjAct G) (h : G) : g • h = MulAut.conj (ofConjAct g) h 
goal: g • h = (MulAut.conj (ConjAct.ofConjAct g)) h

full_name: ConjAct.fixedPoints_eq_center
code: /-- The set of fixed points of the conjugation action of `G` on itself is the center of `G`. -/
theorem fixedPoints_eq_center : fixedPoints (ConjAct G) G = center G 
goal: MulAction.fixedPoints (ConjAct G) G = ↑(Subgroup.center G)

full_name: ConjAct.mem_orbit_conjAct
code: @[simp]
theorem mem_orbit_conjAct {g h : G} : g ∈ orbit (ConjAct G) h ↔ IsConj g h 
goal: g ∈ MulAction.orbit (ConjAct G) h ↔ IsConj g h

full_name: ConjAct.orbitRel_conjAct
code: theorem orbitRel_conjAct : (orbitRel (ConjAct G) G).Rel = IsConj 
goal: (MulAction.orbitRel (ConjAct G) G).Rel = IsConj

full_name: ConjAct.orbit_eq_carrier_conjClasses
code: theorem orbit_eq_carrier_conjClasses (g : G) :
    orbit (ConjAct G) g = (ConjClasses.mk g).carrier 
goal: MulAction.orbit (ConjAct G) g = (ConjClasses.mk g).carrier

full_name: ConjAct.stabilizer_eq_centralizer
code: theorem stabilizer_eq_centralizer (g : G) :
    stabilizer (ConjAct G) g = centralizer (zpowers (toConjAct g) : Set (ConjAct G)) 
goal: MulAction.stabilizer (ConjAct G) g = Subgroup.centralizer ↑(Subgroup.zpowers (ConjAct.toConjAct g))

full_name: ConjAct.Subgroup.conjAction
code: /-- As normal subgroups are closed under conjugation, they inherit the conjugation action
  of the underlying group. -/
instance Subgroup.conjAction {H : Subgroup G} [hH : H.Normal] : SMul (ConjAct G) H 
goal: SMul (ConjAct G) ↥H

full_name: ConjAct.Subgroup.val_conj_smul
code: theorem Subgroup.val_conj_smul {H : Subgroup G} [H.Normal] (g : ConjAct G) (h : H) :
    ↑(g • h) = g • (h : G) 
goal: ↑(g • h) = g • ↑h

full_name: ConjAct.Subgroup.conjMulDistribMulAction
code: instance Subgroup.conjMulDistribMulAction {H : Subgroup G} [H.Normal] :
    MulDistribMulAction (ConjAct G) H 
goal: MulDistribMulAction (ConjAct G) ↥H

full_name: MulAut.conjNormal
code: /-- Group conjugation on a normal subgroup. Analogous to `MulAut.conj`. -/
def _root_.MulAut.conjNormal {H : Subgroup G} [H.Normal] : G →* MulAut H 
goal: G →* MulAut ↥H

full_name: MulAut.conjNormal_apply
code: @[simp]
theorem _root_.MulAut.conjNormal_apply {H : Subgroup G} [H.Normal] (g : G) (h : H) :
    ↑(MulAut.conjNormal g h) = g * h * g⁻¹ 
goal: ↑((MulAut.conjNormal g) h) = g * ↑h * g⁻¹

full_name: MulAut.conjNormal_symm_apply
code: @[simp]
theorem _root_.MulAut.conjNormal_symm_apply {H : Subgroup G} [H.Normal] (g : G) (h : H) :
    ↑((MulAut.conjNormal g).symm h) = g⁻¹ * h * g 
goal: ↑((MulEquiv.symm (MulAut.conjNormal g)) h) = g⁻¹ * ↑h * g

full_name: MulAut.conjNormal_inv_apply
code: @[simp]
theorem _root_.MulAut.conjNormal_inv_apply {H : Subgroup G} [H.Normal] (g : G) (h : H) :
    ↑((MulAut.conjNormal g)⁻¹ h) = g⁻¹ * h * g 
goal: ↑((MulAut.conjNormal g)⁻¹ h) = g⁻¹ * ↑h * g

full_name: MulAut.conjNormal_val
code: theorem _root_.MulAut.conjNormal_val {H : Subgroup G} [H.Normal] {h : H} :
    MulAut.conjNormal ↑h = MulAut.conj h 
goal: MulAut.conjNormal ↑h = MulAut.conj h

full_name: ConjAct.normal_of_characteristic_of_normal
code: instance normal_of_characteristic_of_normal {H : Subgroup G} [hH : H.Normal] {K : Subgroup H}
    [h : K.Characteristic] : (K.map H.subtype).Normal 
goal: (Subgroup.map H.subtype K).Normal

full_name: val_unitsCentralizerEquiv_symm_apply_coe
code: /-- The stabilizer of `Mˣ` acting on itself by conjugation at `x : Mˣ` is exactly the
units of the centralizer of `x : M`. -/
@[simps! apply_coe_val symm_apply_val_coe]
def unitsCentralizerEquiv (x : Mˣ) :
    (Submonoid.centralizer ({↑x} : Set M))ˣ ≃* MulAction.stabilizer (ConjAct Mˣ) x 
goal: ∀ (a : ↥(MulAction.stabilizer (ConjAct Mˣ) x)), ↑↑((unitsCentralizerEquiv M x).symm a) = ↑(ConjAct.ofConjAct ↑a)

full_name: unitsCentralizerEquiv
code: /-- The stabilizer of `Mˣ` acting on itself by conjugation at `x : Mˣ` is exactly the
units of the centralizer of `x : M`. -/
@[simps! apply_coe_val symm_apply_val_coe]
def unitsCentralizerEquiv (x : Mˣ) :
    (Submonoid.centralizer ({↑x} : Set M))ˣ ≃* MulAction.stabilizer (ConjAct Mˣ) x 
goal: (↥(Submonoid.centralizer {↑x}))ˣ ≃* ↥(MulAction.stabilizer (ConjAct Mˣ) x)

full_name: val_unitsCentralizerEquiv_apply_coe
code: /-- The stabilizer of `Mˣ` acting on itself by conjugation at `x : Mˣ` is exactly the
units of the centralizer of `x : M`. -/
@[simps! apply_coe_val symm_apply_val_coe]
def unitsCentralizerEquiv (x : Mˣ) :
    (Submonoid.centralizer ({↑x} : Set M))ˣ ≃* MulAction.stabilizer (ConjAct Mˣ) x 
goal: ∀ (a : (↥(Submonoid.centralizer {↑x}))ˣ), ↑↑((unitsCentralizerEquiv M x) a) = ↑↑a