File: Mathlib/Algebra/Group/Conj.lean

full_name: IsConj
code: /-- We say that `a` is conjugate to `b` if for some unit `c` we have `c * a * c⁻¹ = b`. -/
def IsConj (a b : α) 
goal: Prop

full_name: IsConj.refl
code: @[refl]
theorem IsConj.refl (a : α) : IsConj a a 
goal: IsConj a a

full_name: IsConj.symm
code: @[symm]
theorem IsConj.symm {a b : α} : IsConj a b → IsConj b a
  
goal: IsConj a b → IsConj b a

full_name: isConj_comm
code: theorem isConj_comm {g h : α} : IsConj g h ↔ IsConj h g 
goal: IsConj g h ↔ IsConj h g

full_name: IsConj.trans
code: @[trans]
theorem IsConj.trans {a b c : α} : IsConj a b → IsConj b c → IsConj a c
  
goal: IsConj a b → IsConj b c → IsConj a c

full_name: isConj_iff_eq
code: @[simp]
theorem isConj_iff_eq {α : Type*} [CommMonoid α] {a b : α} : IsConj a b ↔ a = b 
goal: IsConj a b ↔ a = b

full_name: MonoidHom.map_isConj
code: protected theorem MonoidHom.map_isConj (f : α →* β) {a b : α} : IsConj a b → IsConj (f a) (f b)
  
goal: IsConj a b → IsConj (f a) (f b)

full_name: isConj_one_right
code: @[simp]
theorem isConj_one_right {a : α} : IsConj 1 a ↔ a = 1 
goal: IsConj 1 a ↔ a = 1

full_name: isConj_one_left
code: @[simp]
theorem isConj_one_left {a : α} : IsConj a 1 ↔ a = 1 
goal: IsConj a 1 ↔ a = 1

full_name: isConj_iff
code: @[simp]
theorem isConj_iff {a b : α} : IsConj a b ↔ ∃ c : α, c * a * c⁻¹ = b 
goal: IsConj a b ↔ ∃ c, c * a * c⁻¹ = b

full_name: conj_inv
code: theorem conj_inv {a b : α} : (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹ 
goal: (b * a * b⁻¹)⁻¹ = b * a⁻¹ * b⁻¹

full_name: conj_mul
code: @[simp]
theorem conj_mul {a b c : α} : b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹ 
goal: b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹

full_name: conj_pow
code: @[simp]
theorem conj_pow {i : ℕ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ 
goal: (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹

full_name: conj_zpow
code: @[simp]
theorem conj_zpow {i : ℤ} {a b : α} : (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ 
goal: (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹

full_name: conj_injective
code: theorem conj_injective {x : α} : Function.Injective fun g : α => x * g * x⁻¹ 
goal: Function.Injective fun g => x * g * x⁻¹

full_name: IsConj.setoid
code: /-- The setoid of the relation `IsConj` iff there is a unit `u` such that `u * x = y * u` -/
protected def setoid (α : Type*) [Monoid α] : Setoid α 
goal: Setoid α

full_name: ConjClasses
code: /-- The quotient type of conjugacy classes of a group. -/
def ConjClasses (α : Type*) [Monoid α] : Type _ 
goal: Type u_1

full_name: ConjClasses.mk
code: /-- The canonical quotient map from a monoid `α` into the `ConjClasses` of `α` -/
protected def mk {α : Type*} [Monoid α] (a : α) : ConjClasses α 
goal: ConjClasses α

full_name: ConjClasses.instInhabited
code: instance : Inhabited (ConjClasses α) 
goal: Inhabited (ConjClasses α)

full_name: ConjClasses.mk_eq_mk_iff_isConj
code: theorem mk_eq_mk_iff_isConj {a b : α} : ConjClasses.mk a = ConjClasses.mk b ↔ IsConj a b 
goal: ConjClasses.mk a = ConjClasses.mk b ↔ IsConj a b

full_name: ConjClasses.quotient_mk_eq_mk
code: theorem quotient_mk_eq_mk (a : α) : ⟦a⟧ = ConjClasses.mk a 
goal: ⟦a⟧ = ConjClasses.mk a

full_name: ConjClasses.quot_mk_eq_mk
code: theorem quot_mk_eq_mk (a : α) : Quot.mk Setoid.r a = ConjClasses.mk a 
goal: Quot.mk Setoid.r a = ConjClasses.mk a

full_name: ConjClasses.forall_isConj
code: theorem forall_isConj {p : ConjClasses α → Prop} : (∀ a, p a) ↔ ∀ a, p (ConjClasses.mk a) 
goal: (∀ (a : ConjClasses α), p a) ↔ ∀ (a : α), p (ConjClasses.mk a)

full_name: ConjClasses.mk_surjective
code: theorem mk_surjective : Function.Surjective (@ConjClasses.mk α _) 
goal: Function.Surjective ConjClasses.mk

full_name: ConjClasses.instOne
code: instance : One (ConjClasses α) 
goal: One (ConjClasses α)

full_name: ConjClasses.one_eq_mk_one
code: theorem one_eq_mk_one : (1 : ConjClasses α) = ConjClasses.mk 1 
goal: 1 = ConjClasses.mk 1

full_name: ConjClasses.exists_rep
code: theorem exists_rep (a : ConjClasses α) : ∃ a0 : α, ConjClasses.mk a0 = a 
goal: ∃ a0, ConjClasses.mk a0 = a

full_name: ConjClasses.map
code: /-- A `MonoidHom` maps conjugacy classes of one group to conjugacy classes of another. -/
def map (f : α →* β) : ConjClasses α → ConjClasses β 
goal: ConjClasses α → ConjClasses β

full_name: ConjClasses.map_surjective
code: theorem map_surjective {f : α →* β} (hf : Function.Surjective f) :
    Function.Surjective (ConjClasses.map f) 
goal: Function.Surjective (ConjClasses.map f)

full_name: ConjClasses.instDecidableEqOfDecidableRelIsConj
code: instance (priority := 900) [DecidableRel (IsConj : α → α → Prop)] : DecidableEq (ConjClasses α) 
goal: DecidableEq (ConjClasses α)

full_name: ConjClasses.mk_injective
code: theorem mk_injective : Function.Injective (@ConjClasses.mk α _) 
goal: Function.Injective ConjClasses.mk

full_name: ConjClasses.mk_bijective
code: theorem mk_bijective : Function.Bijective (@ConjClasses.mk α _) 
goal: Function.Bijective ConjClasses.mk

full_name: ConjClasses.mkEquiv
code: /-- The bijection between a `CommGroup` and its `ConjClasses`. -/
def mkEquiv : α ≃ ConjClasses α 
goal: α ≃ ConjClasses α

full_name: conjugatesOf
code: /-- Given an element `a`, `conjugatesOf a` is the set of conjugates. -/
def conjugatesOf (a : α) : Set α 
goal: Set α

full_name: mem_conjugatesOf_self
code: theorem mem_conjugatesOf_self {a : α} : a ∈ conjugatesOf a 
goal: a ∈ conjugatesOf a

full_name: IsConj.conjugatesOf_eq
code: theorem IsConj.conjugatesOf_eq {a b : α} (ab : IsConj a b) : conjugatesOf a = conjugatesOf b 
goal: conjugatesOf a = conjugatesOf b

full_name: isConj_iff_conjugatesOf_eq
code: theorem isConj_iff_conjugatesOf_eq {a b : α} : IsConj a b ↔ conjugatesOf a = conjugatesOf b 
goal: IsConj a b ↔ conjugatesOf a = conjugatesOf b

full_name: ConjClasses.carrier
code: /-- Given a conjugacy class `a`, `carrier a` is the set it represents. -/
def carrier : ConjClasses α → Set α 
goal: ConjClasses α → Set α

full_name: ConjClasses.mem_carrier_mk
code: theorem mem_carrier_mk {a : α} : a ∈ carrier (ConjClasses.mk a) 
goal: a ∈ (ConjClasses.mk a).carrier

full_name: ConjClasses.mem_carrier_iff_mk_eq
code: theorem mem_carrier_iff_mk_eq {a : α} {b : ConjClasses α} :
    a ∈ carrier b ↔ ConjClasses.mk a = b 
goal: a ∈ b.carrier ↔ ConjClasses.mk a = b

full_name: ConjClasses.carrier_eq_preimage_mk
code: theorem carrier_eq_preimage_mk {a : ConjClasses α} : a.carrier = ConjClasses.mk ⁻¹' {a} 
goal: a.carrier = ConjClasses.mk ⁻¹' {a}