File: Mathlib/Algebra/AddConstMap/Equiv.lean

full_name: AddConstEquiv
code: /-- An equivalence between `G` and `H` conjugating `(· + a)` to `(· + b)`. -/
structure AddConstEquiv (G H : Type*) [Add G] [Add H] (a : G) (b : H)
  extends G ≃ H, G →+c[a, b] H
goal: Type (max u_1 u_2)

full_name: AddConstMap._aux_Mathlib_Algebra_AddConstMap_Equiv___unexpand_AddConstEquiv_1
code: @[inherit_doc]
scoped [AddConstMap] notation:25 G " ≃+c[" a ", " b "] " H => AddConstEquiv G H a b
goal: Lean.PrettyPrinter.Unexpander

full_name: AddConstMap.«_aux_Mathlib_Algebra_AddConstMap_Equiv___macroRules_AddConstMap_term_≃+c[_,_]__1»
code: @[inherit_doc]
scoped [AddConstMap] notation:25 G " ≃+c[" a ", " b "] " H => AddConstEquiv G H a b
goal: Lean.Macro

full_name: AddConstEquiv.toEquiv_injective
code: lemma toEquiv_injective : Injective (toEquiv : (G ≃+c[a, b] H) → G ≃ H)
  
goal: Function.Injective AddConstEquiv.toEquiv

full_name: AddConstEquiv.instEquivLike
code: instance {G H : Type*} [Add G] [Add H] {a : G} {b : H} :
    EquivLike (G ≃+c[a, b] H) G H 
goal: EquivLike (G ≃+c[a, b] H) G H

full_name: AddConstEquiv.instAddConstMapClass
code: instance {G H : Type*} [Add G] [Add H] {a : G} {b : H} :
    AddConstMapClass (G ≃+c[a, b] H) G H a b 
goal: AddConstMapClass (G ≃+c[a, b] H) G H a b

full_name: AddConstEquiv.ext
code: @[ext] lemma ext {e₁ e₂ : G ≃+c[a, b] H} (h : ∀ x, e₁ x = e₂ x) : e₁ = e₂ 
goal: e₁ = e₂

full_name: AddConstEquiv.toEquiv_inj
code: @[simp]
lemma toEquiv_inj {e₁ e₂ : G ≃+c[a, b] H} : e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂ 
goal: e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂

full_name: AddConstEquiv.coe_toEquiv
code: @[simp] lemma coe_toEquiv (e : G ≃+c[a, b] H) : ⇑e.toEquiv = e 
goal: ⇑e.toEquiv = ⇑e

full_name: AddConstEquiv.symm
code: /-- Inverse map of an `AddConstEquiv`, as an `AddConstEquiv`. -/
def symm (e : G ≃+c[a, b] H) : H ≃+c[b, a] G 
goal: H ≃+c[b, a] G

full_name: AddConstEquiv.Simps.symm_apply
code: /-- A custom projection for `simps`. -/
def Simps.symm_apply (e : G ≃+c[a, b] H) : H → G 
goal: H → G

full_name: AddConstEquiv.symm_symm
code: @[simp] lemma symm_symm (e : G ≃+c[a, b] H) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: AddConstEquiv.refl_toEquiv
code: /-- The identity map as an `AddConstEquiv`. -/
@[simps! toEquiv apply]
def refl (a : G) : G ≃+c[a, a] G 
goal: (AddConstEquiv.refl a).toEquiv = Equiv.refl G

full_name: AddConstEquiv.refl_apply
code: /-- The identity map as an `AddConstEquiv`. -/
@[simps! toEquiv apply]
def refl (a : G) : G ≃+c[a, a] G 
goal: ∀ (a_1 : G), (AddConstEquiv.refl a) a_1 = a_1

full_name: AddConstEquiv.refl
code: /-- The identity map as an `AddConstEquiv`. -/
@[simps! toEquiv apply]
def refl (a : G) : G ≃+c[a, a] G 
goal: G ≃+c[a, a] G

full_name: AddConstEquiv.symm_refl
code: @[simp] lemma symm_refl (a : G) : (refl a).symm = refl a 
goal: (AddConstEquiv.refl a).symm = AddConstEquiv.refl a

full_name: AddConstEquiv.trans
code: /-- Composition of `AddConstEquiv`s, as an `AddConstEquiv`. -/
@[simps! (config := { simpRhs := true }) toEquiv apply]
def trans (e₁ : G ≃+c[a, b] H) (e₂ : H ≃+c[b, c] K) : G ≃+c[a, c] K 
goal: G ≃+c[a, c] K

full_name: AddConstEquiv.trans_toEquiv
code: /-- Composition of `AddConstEquiv`s, as an `AddConstEquiv`. -/
@[simps! (config := { simpRhs := true }) toEquiv apply]
def trans (e₁ : G ≃+c[a, b] H) (e₂ : H ≃+c[b, c] K) : G ≃+c[a, c] K 
goal: (e₁.trans e₂).toEquiv = e₁.trans e₂.toEquiv

full_name: AddConstEquiv.trans_apply
code: /-- Composition of `AddConstEquiv`s, as an `AddConstEquiv`. -/
@[simps! (config := { simpRhs := true }) toEquiv apply]
def trans (e₁ : G ≃+c[a, b] H) (e₂ : H ≃+c[b, c] K) : G ≃+c[a, c] K 
goal: ∀ (a_1 : G), (e₁.trans e₂) a_1 = e₂ (e₁ a_1)

full_name: AddConstEquiv.trans_refl
code: @[simp] lemma trans_refl (e : G ≃+c[a, b] H) : e.trans (.refl b) = e 
goal: e.trans (AddConstEquiv.refl b) = e

full_name: AddConstEquiv.refl_trans
code: @[simp] lemma refl_trans (e : G ≃+c[a, b] H) : (refl a).trans e = e 
goal: (AddConstEquiv.refl a).trans e = e

full_name: AddConstEquiv.self_trans_symm
code: @[simp]
lemma self_trans_symm (e : G ≃+c[a, b] H) : e.trans e.symm = .refl a 
goal: e.trans e.symm = AddConstEquiv.refl a

full_name: AddConstEquiv.symm_trans_self
code: @[simp]
lemma symm_trans_self (e : G ≃+c[a, b] H) : e.symm.trans e = .refl b 
goal: e.symm.trans e = AddConstEquiv.refl b

full_name: AddConstEquiv.instOne
code: instance instOne : One (G ≃+c[a, a] G) 
goal: One (G ≃+c[a, a] G)

full_name: AddConstEquiv.instMul
code: instance instMul : Mul (G ≃+c[a, a] G) 
goal: Mul (G ≃+c[a, a] G)

full_name: AddConstEquiv.instInv
code: instance instInv : Inv (G ≃+c[a, a] G) 
goal: Inv (G ≃+c[a, a] G)

full_name: AddConstEquiv.instDiv
code: instance instDiv : Div (G ≃+c[a, a] G) 
goal: Div (G ≃+c[a, a] G)

full_name: AddConstEquiv.instPowNat
code: instance instPowNat : Pow (G ≃+c[a, a] G) ℕ 
goal: Pow (G ≃+c[a, a] G) ℕ

full_name: AddConstEquiv.instPowInt
code: instance instPowInt : Pow (G ≃+c[a, a] G) ℤ 
goal: Pow (G ≃+c[a, a] G) ℤ

full_name: AddConstEquiv.instGroup
code: instance instGroup : Group (G ≃+c[a, a] G) 
goal: Group (G ≃+c[a, a] G)

full_name: AddConstEquiv.toPerm
code: /-- Projection from `G ≃+c[a, a] G` to permutations `G ≃ G`, as a monoid homomorphism. -/
@[simps! apply]
def toPerm : (G ≃+c[a, a] G) →* Equiv.Perm G 
goal: (G ≃+c[a, a] G) →* Equiv.Perm G

full_name: AddConstEquiv.toPerm_apply
code: /-- Projection from `G ≃+c[a, a] G` to permutations `G ≃ G`, as a monoid homomorphism. -/
@[simps! apply]
def toPerm : (G ≃+c[a, a] G) →* Equiv.Perm G 
goal: AddConstEquiv.toPerm self = self.toEquiv

full_name: AddConstEquiv.toAddConstMapHom_apply
code: /-- Projection from `G ≃+c[a, a] G` to `G →+c[a, a] G`, as a monoid homomorphism. -/
@[simps! apply]
def toAddConstMapHom : (G ≃+c[a, a] G) →* (G →+c[a, a] G) 
goal: AddConstEquiv.toAddConstMapHom self = self.toAddConstMap

full_name: AddConstEquiv.toAddConstMapHom
code: /-- Projection from `G ≃+c[a, a] G` to `G →+c[a, a] G`, as a monoid homomorphism. -/
@[simps! apply]
def toAddConstMapHom : (G ≃+c[a, a] G) →* (G →+c[a, a] G) 
goal: (G ≃+c[a, a] G) →* G →+c[a, a] G

full_name: AddConstEquiv.coe_val_inv_equivUnits_apply
code: /-- Group equivalence between `G ≃+c[a, a] G` and the units of `G →+c[a, a] G`. -/
@[simps!]
def equivUnits : (G ≃+c[a, a] G) ≃* (G →+c[a, a] G)ˣ 
goal: ∀ (a_1 : G ≃+c[a, a] G) (a_2 : G), ↑(AddConstEquiv.equivUnits a_1)⁻¹ a_2 = a_1⁻¹ a_2

full_name: AddConstEquiv.equivUnits
code: /-- Group equivalence between `G ≃+c[a, a] G` and the units of `G →+c[a, a] G`. -/
@[simps!]
def equivUnits : (G ≃+c[a, a] G) ≃* (G →+c[a, a] G)ˣ 
goal: (G ≃+c[a, a] G) ≃* (G →+c[a, a] G)ˣ

full_name: AddConstEquiv.equivUnits_symm_apply_symm_apply
code: /-- Group equivalence between `G ≃+c[a, a] G` and the units of `G →+c[a, a] G`. -/
@[simps!]
def equivUnits : (G ≃+c[a, a] G) ≃* (G →+c[a, a] G)ˣ 
goal: ⇑(AddConstEquiv.equivUnits.symm u).symm = ⇑↑u⁻¹

full_name: AddConstEquiv.coe_val_equivUnits_apply
code: /-- Group equivalence between `G ≃+c[a, a] G` and the units of `G →+c[a, a] G`. -/
@[simps!]
def equivUnits : (G ≃+c[a, a] G) ≃* (G →+c[a, a] G)ˣ 
goal: ∀ (a_1 : G ≃+c[a, a] G) (a_2 : G), ↑(AddConstEquiv.equivUnits a_1) a_2 = a_1 a_2

full_name: AddConstEquiv.equivUnits_symm_apply_apply
code: /-- Group equivalence between `G ≃+c[a, a] G` and the units of `G →+c[a, a] G`. -/
@[simps!]
def equivUnits : (G ≃+c[a, a] G) ≃* (G →+c[a, a] G)ˣ 
goal: ⇑(AddConstEquiv.equivUnits.symm u) = ⇑↑u