File: Mathlib/Algebra/Algebra/Equiv.lean

full_name: AlgEquiv
code: /-- An equivalence of algebras is an equivalence of rings commuting with the actions of scalars. -/
structure AlgEquiv (R : Type u) (A : Type v) (B : Type w) [CommSemiring R] [Semiring A] [Semiring B]
  [Algebra R A] [Algebra R B] extends A ≃ B, A ≃* B, A ≃+ B, A ≃+* B where
  /-- An equivalence of algebras commutes with the action of scalars. -/
  protected commutes' : ∀ r : R, toFun (algebraMap R A r) = algebraMap R B r
goal: Type (max v w)

full_name: AlgEquiv.commutes'
code: /-- An equivalence of algebras is an equivalence of rings commuting with the actions of scalars. -/
structure AlgEquiv (R : Type u) (A : Type v) (B : Type w) [CommSemiring R] [Semiring A] [Semiring B]
  [Algebra R A] [Algebra R B] extends A ≃ B, A ≃* B, A ≃+ B, A ≃+* B where
  /-- An equivalence of algebras commutes with the action of scalars. -/
  protected commutes' : ∀ r : R, toFun (algebraMap R A r) = algebraMap R B r
goal: self.toFun ((algebraMap R A) r) = (algebraMap R B) r

full_name: «_aux_Mathlib_Algebra_Algebra_Equiv___macroRules_term_≃ₐ[_]__1»
code: @[inherit_doc]
notation:50 A " ≃ₐ[" R "] " A' => AlgEquiv R A A'
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Algebra_Equiv___unexpand_AlgEquiv_1
code: @[inherit_doc]
notation:50 A " ≃ₐ[" R "] " A' => AlgEquiv R A A'
goal: Lean.PrettyPrinter.Unexpander

full_name: AlgEquivClass
code: /-- `AlgEquivClass F R A B` states that `F` is a type of algebra structure preserving
  equivalences. You should extend this class when you extend `AlgEquiv`. -/
class AlgEquivClass (F : Type*) (R A B : outParam Type*) [CommSemiring R] [Semiring A]
    [Semiring B] [Algebra R A] [Algebra R B] [EquivLike F A B]
    extends RingEquivClass F A B : Prop where
  /-- An equivalence of algebras commutes with the action of scalars. -/
  commutes : ∀ (f : F) (r : R), f (algebraMap R A r) = algebraMap R B r
goal: Prop

full_name: AlgEquivClass.commutes
code: /-- `AlgEquivClass F R A B` states that `F` is a type of algebra structure preserving
  equivalences. You should extend this class when you extend `AlgEquiv`. -/
class AlgEquivClass (F : Type*) (R A B : outParam Type*) [CommSemiring R] [Semiring A]
    [Semiring B] [Algebra R A] [Algebra R B] [EquivLike F A B]
    extends RingEquivClass F A B : Prop where
  /-- An equivalence of algebras commutes with the action of scalars. -/
  commutes : ∀ (f : F) (r : R), f (algebraMap R A r) = algebraMap R B r
goal: f ((algebraMap R A) r) = (algebraMap R B) r

full_name: AlgEquivClass.toAlgHomClass
code: instance (priority := 100) toAlgHomClass (F R A B : Type*) [CommSemiring R] [Semiring A]
    [Semiring B] [Algebra R A] [Algebra R B] [EquivLike F A B] [h : AlgEquivClass F R A B] :
    AlgHomClass F R A B 
goal: AlgHomClass F R A B

full_name: AlgEquivClass.toLinearEquivClass
code: instance (priority := 100) toLinearEquivClass (F R A B : Type*) [CommSemiring R]
    [Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
    [EquivLike F A B] [h : AlgEquivClass F R A B] : LinearEquivClass F R A B 
goal: LinearEquivClass F R A B

full_name: AlgEquivClass.toAlgEquiv
code: /-- Turn an element of a type `F` satisfying `AlgEquivClass F R A B` into an actual `AlgEquiv`.
This is declared as the default coercion from `F` to `A ≃ₐ[R] B`. -/
@[coe]
def toAlgEquiv {F R A B : Type*} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A]
    [Algebra R B] [EquivLike F A B] [AlgEquivClass F R A B] (f : F) : A ≃ₐ[R] B 
goal: A ≃ₐ[R] B

full_name: AlgEquivClass.instCoeTCAlgEquiv
code: instance (F R A B : Type*) [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
    [EquivLike F A B] [AlgEquivClass F R A B] : CoeTC F (A ≃ₐ[R] B) 
goal: CoeTC F (A ≃ₐ[R] B)

full_name: AlgEquiv.instEquivLike
code: instance : EquivLike (A₁ ≃ₐ[R] A₂) A₁ A₂ 
goal: EquivLike (A₁ ≃ₐ[R] A₂) A₁ A₂

full_name: AlgEquiv.instFunLike
code: /-- Helper instance since the coercion is not always found. -/
instance : FunLike (A₁ ≃ₐ[R] A₂) A₁ A₂ 
goal: FunLike (A₁ ≃ₐ[R] A₂) A₁ A₂

full_name: AlgEquiv.instAlgEquivClass
code: instance : AlgEquivClass (A₁ ≃ₐ[R] A₂) R A₁ A₂ 
goal: AlgEquivClass (A₁ ≃ₐ[R] A₂) R A₁ A₂

full_name: AlgEquiv.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply (e : A₁ ≃ₐ[R] A₂) : A₁ → A₂ 
goal: A₁ → A₂

full_name: AlgEquiv.Simps.toEquiv
code: /-- See Note [custom simps projection] -/
def Simps.toEquiv (e : A₁ ≃ₐ[R] A₂) : A₁ ≃ A₂ 
goal: A₁ ≃ A₂

full_name: AlgEquiv.coe_coe
code: @[simp]
protected theorem coe_coe {F : Type*} [EquivLike F A₁ A₂] [AlgEquivClass F R A₁ A₂] (f : F) :
    ⇑(f : A₁ ≃ₐ[R] A₂) = f 
goal: ⇑↑f = ⇑f

full_name: AlgEquiv.ext
code: @[ext]
theorem ext {f g : A₁ ≃ₐ[R] A₂} (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: AlgEquiv.congr_arg
code: protected theorem congr_arg {f : A₁ ≃ₐ[R] A₂} {x x' : A₁} : x = x' → f x = f x' 
goal: x = x' → f x = f x'

full_name: AlgEquiv.congr_fun
code: protected theorem congr_fun {f g : A₁ ≃ₐ[R] A₂} (h : f = g) (x : A₁) : f x = g x 
goal: f x = g x

full_name: AlgEquiv.ext_iff
code: protected theorem ext_iff {f g : A₁ ≃ₐ[R] A₂} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : A₁), f x = g x

full_name: AlgEquiv.coe_fun_injective
code: theorem coe_fun_injective : @Function.Injective (A₁ ≃ₐ[R] A₂) (A₁ → A₂) fun e => (e : A₁ → A₂) 
goal: Function.Injective fun e => ⇑e

full_name: AlgEquiv.hasCoeToRingEquiv
code: instance hasCoeToRingEquiv : CoeOut (A₁ ≃ₐ[R] A₂) (A₁ ≃+* A₂) 
goal: CoeOut (A₁ ≃ₐ[R] A₂) (A₁ ≃+* A₂)

full_name: AlgEquiv.coe_mk
code: @[simp]
theorem coe_mk {toFun invFun left_inv right_inv map_mul map_add commutes} :
    ⇑(⟨⟨toFun, invFun, left_inv, right_inv⟩, map_mul, map_add, commutes⟩ : A₁ ≃ₐ[R] A₂) = toFun 
goal: ⇑{ toFun := toFun, invFun := invFun, left_inv := left_inv, right_inv := right_inv, map_mul' := map_mul,
      map_add' := map_add, commutes' := commutes } =
  toFun

full_name: AlgEquiv.mk_coe
code: @[simp]
theorem mk_coe (e : A₁ ≃ₐ[R] A₂) (e' h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨e, e', h₁, h₂⟩, h₃, h₄, h₅⟩ : A₁ ≃ₐ[R] A₂) = e 
goal: { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄, commutes' := h₅ } = e

full_name: AlgEquiv.toEquiv_eq_coe
code: @[simp]
theorem toEquiv_eq_coe : e.toEquiv = e 
goal: e.toEquiv = ↑e

full_name: AlgEquiv.toRingEquiv_eq_coe
code: @[simp]
theorem toRingEquiv_eq_coe : e.toRingEquiv = e 
goal: e.toRingEquiv = ↑e

full_name: AlgEquiv.toRingEquiv_toRingHom
code: @[simp, norm_cast]
lemma toRingEquiv_toRingHom : ((e : A₁ ≃+* A₂) : A₁ →+* A₂) = e 
goal: ↑↑e = ↑e

full_name: AlgEquiv.coe_ringEquiv
code: @[simp, norm_cast]
theorem coe_ringEquiv : ((e : A₁ ≃+* A₂) : A₁ → A₂) = e 
goal: ⇑↑e = ⇑e

full_name: AlgEquiv.coe_ringEquiv'
code: theorem coe_ringEquiv' : (e.toRingEquiv : A₁ → A₂) = e 
goal: ⇑e.toRingEquiv = ⇑e

full_name: AlgEquiv.coe_ringEquiv_injective
code: theorem coe_ringEquiv_injective : Function.Injective ((↑) : (A₁ ≃ₐ[R] A₂) → A₁ ≃+* A₂) 
goal: Function.Injective RingEquivClass.toRingEquiv

full_name: AlgEquiv.map_add
code: @[deprecated map_add (since := "2024-06-20")]
protected theorem map_add : ∀ x y, e (x + y) = e x + e y 
goal: e (x + y) = e x + e y

full_name: AlgEquiv.map_zero
code: @[deprecated map_zero (since := "2024-06-20")]
protected theorem map_zero : e 0 = 0 
goal: e 0 = 0

full_name: AlgEquiv.map_mul
code: @[deprecated map_mul (since := "2024-06-20")]
protected theorem map_mul : ∀ x y, e (x * y) = e x * e y 
goal: e (x * y) = e x * e y

full_name: AlgEquiv.map_one
code: @[deprecated map_one (since := "2024-06-20")]
protected theorem map_one : e 1 = 1 
goal: e 1 = 1

full_name: AlgEquiv.commutes
code: @[simp]
theorem commutes : ∀ r : R, e (algebraMap R A₁ r) = algebraMap R A₂ r 
goal: e ((algebraMap R A₁) r) = (algebraMap R A₂) r

full_name: AlgEquiv.map_smul
code: @[deprecated map_smul (since := "2024-06-20")]
protected theorem map_smul (r : R) (x : A₁) : e (r • x) = r • e x 
goal: e (r • x) = r • e x

full_name: AlgEquiv.map_sum
code: @[deprecated map_sum (since := "2023-12-26")]
protected theorem map_sum {ι : Type*} (f : ι → A₁) (s : Finset ι) :
    e (∑ x ∈ s, f x) = ∑ x ∈ s, e (f x) 
goal: e (∑ x ∈ s, f x) = ∑ x ∈ s, e (f x)

full_name: AlgEquiv.map_finsupp_sum
code: @[deprecated map_finsupp_sum (since := "2024-06-20")]
protected theorem map_finsupp_sum {α : Type*} [Zero α] {ι : Type*} (f : ι →₀ α) (g : ι → α → A₁) :
    e (f.sum g) = f.sum fun i b => e (g i b) 
goal: e (f.sum g) = f.sum fun i b => e (g i b)

full_name: AlgEquiv.toAlgHom
code: /-- Interpret an algebra equivalence as an algebra homomorphism.

This definition is included for symmetry with the other `to*Hom` projections.
The `simp` normal form is to use the coercion of the `AlgHomClass.coeTC` instance. -/
@[coe]
def toAlgHom : A₁ →ₐ[R] A₂ 
goal: A₁ →ₐ[R] A₂

full_name: AlgEquiv.toAlgHom_eq_coe
code: @[simp]
theorem toAlgHom_eq_coe : e.toAlgHom = e 
goal: ↑e = ↑e

full_name: AlgEquiv.coe_algHom
code: @[simp, norm_cast]
theorem coe_algHom : DFunLike.coe (e.toAlgHom) = DFunLike.coe e 
goal: ⇑↑e = ⇑e

full_name: AlgEquiv.coe_algHom_injective
code: theorem coe_algHom_injective : Function.Injective ((↑) : (A₁ ≃ₐ[R] A₂) → A₁ →ₐ[R] A₂) 
goal: Function.Injective AlgHomClass.toAlgHom

full_name: AlgEquiv.toAlgHom_toRingHom
code: @[simp, norm_cast]
lemma toAlgHom_toRingHom : ((e : A₁ →ₐ[R] A₂) : A₁ →+* A₂) = e 
goal: ↑↑e = ↑e

full_name: AlgEquiv.coe_ringHom_commutes
code: /-- The two paths coercion can take to a `RingHom` are equivalent -/
theorem coe_ringHom_commutes : ((e : A₁ →ₐ[R] A₂) : A₁ →+* A₂) = ((e : A₁ ≃+* A₂) : A₁ →+* A₂) 
goal: ↑↑e = ↑↑e

full_name: AlgEquiv.map_pow
code: @[deprecated map_pow (since := "2024-06-20")]
protected theorem map_pow : ∀ (x : A₁) (n : ℕ), e (x ^ n) = e x ^ n 
goal: e (x ^ n) = e x ^ n

full_name: AlgEquiv.injective
code: protected theorem injective : Function.Injective e 
goal: Function.Injective ⇑e

full_name: AlgEquiv.surjective
code: protected theorem surjective : Function.Surjective e 
goal: Function.Surjective ⇑e

full_name: AlgEquiv.bijective
code: protected theorem bijective : Function.Bijective e 
goal: Function.Bijective ⇑e

full_name: AlgEquiv.refl
code: /-- Algebra equivalences are reflexive. -/
@[refl]
def refl : A₁ ≃ₐ[R] A₁ 
goal: A₁ ≃ₐ[R] A₁

full_name: AlgEquiv.instInhabited
code: instance : Inhabited (A₁ ≃ₐ[R] A₁) 
goal: Inhabited (A₁ ≃ₐ[R] A₁)

full_name: AlgEquiv.refl_toAlgHom
code: @[simp]
theorem refl_toAlgHom : ↑(refl : A₁ ≃ₐ[R] A₁) = AlgHom.id R A₁ 
goal: ↑AlgEquiv.refl = AlgHom.id R A₁

full_name: AlgEquiv.coe_refl
code: @[simp]
theorem coe_refl : ⇑(refl : A₁ ≃ₐ[R] A₁) = id 
goal: ⇑AlgEquiv.refl = id

full_name: AlgEquiv.symm
code: /-- Algebra equivalences are symmetric. -/
@[symm]
def symm (e : A₁ ≃ₐ[R] A₂) : A₂ ≃ₐ[R] A₁ 
goal: A₂ ≃ₐ[R] A₁

full_name: AlgEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (e : A₁ ≃ₐ[R] A₂) : A₂ → A₁ 
goal: A₂ → A₁

full_name: AlgEquiv.coe_apply_coe_coe_symm_apply
code: theorem coe_apply_coe_coe_symm_apply {F : Type*} [EquivLike F A₁ A₂] [AlgEquivClass F R A₁ A₂]
    (f : F) (x : A₂) :
    f ((f : A₁ ≃ₐ[R] A₂).symm x) = x 
goal: f ((↑f).symm x) = x

full_name: AlgEquiv.coe_coe_symm_apply_coe_apply
code: theorem coe_coe_symm_apply_coe_apply {F : Type*} [EquivLike F A₁ A₂] [AlgEquivClass F R A₁ A₂]
    (f : F) (x : A₁) :
    (f : A₁ ≃ₐ[R] A₂).symm (f x) = x 
goal: (↑f).symm (f x) = x

full_name: AlgEquiv.symm_toEquiv_eq_symm
code: @[simp]
theorem symm_toEquiv_eq_symm {e : A₁ ≃ₐ[R] A₂} : (e : A₁ ≃ A₂).symm = e.symm 
goal: (↑e).symm = ↑e.symm

full_name: AlgEquiv.invFun_eq_symm
code: theorem invFun_eq_symm {e : A₁ ≃ₐ[R] A₂} : e.invFun = e.symm 
goal: e.invFun = ⇑e.symm

full_name: AlgEquiv.symm_symm
code: @[simp]
theorem symm_symm (e : A₁ ≃ₐ[R] A₂) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: AlgEquiv.symm_bijective
code: theorem symm_bijective : Function.Bijective (symm : (A₁ ≃ₐ[R] A₂) → A₂ ≃ₐ[R] A₁) 
goal: Function.Bijective AlgEquiv.symm

full_name: AlgEquiv.mk_coe'
code: @[simp]
theorem mk_coe' (e : A₁ ≃ₐ[R] A₂) (f h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨f, e, h₁, h₂⟩, h₃, h₄, h₅⟩ : A₂ ≃ₐ[R] A₁) = e.symm 
goal: { toFun := f, invFun := ⇑e, left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄, commutes' := h₅ } = e.symm

full_name: AlgEquiv.symm_mk.aux
code: /-- Auxilliary definition to avoid looping in `dsimp` with `AlgEquiv.symm_mk`. -/
protected def symm_mk.aux (f f') (h₁ h₂ h₃ h₄ h₅) 
goal: A₂ ≃ₐ[R] A₁

full_name: AlgEquiv.symm_mk
code: @[simp]
theorem symm_mk (f f') (h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨f, f', h₁, h₂⟩, h₃, h₄, h₅⟩ : A₁ ≃ₐ[R] A₂).symm =
      { symm_mk.aux f f' h₁ h₂ h₃ h₄ h₅ with
        toFun := f'
        invFun := f } 
goal: { toFun := f, invFun := f', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄, commutes' := h₅ }.symm =
  let __src := AlgEquiv.symm_mk.aux f f' h₁ h₂ h₃ h₄ h₅;
  { toFun := f', invFun := f, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }

full_name: AlgEquiv.refl_symm
code: @[simp]
theorem refl_symm : (AlgEquiv.refl : A₁ ≃ₐ[R] A₁).symm = AlgEquiv.refl 
goal: AlgEquiv.refl.symm = AlgEquiv.refl

full_name: AlgEquiv.toRingEquiv_symm
code: theorem toRingEquiv_symm (f : A₁ ≃ₐ[R] A₁) : (f : A₁ ≃+* A₁).symm = f.symm 
goal: (↑f).symm = ↑f.symm

full_name: AlgEquiv.symm_toRingEquiv
code: @[simp]
theorem symm_toRingEquiv : (e.symm : A₂ ≃+* A₁) = (e : A₁ ≃+* A₂).symm 
goal: ↑e.symm = (↑e).symm

full_name: AlgEquiv.trans
code: /-- Algebra equivalences are transitive. -/
@[trans]
def trans (e₁ : A₁ ≃ₐ[R] A₂) (e₂ : A₂ ≃ₐ[R] A₃) : A₁ ≃ₐ[R] A₃ 
goal: A₁ ≃ₐ[R] A₃

full_name: AlgEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : A₁ ≃ₐ[R] A₂) : ∀ x, e (e.symm x) = x 
goal: e (e.symm x) = x

full_name: AlgEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : A₁ ≃ₐ[R] A₂) : ∀ x, e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: AlgEquiv.symm_trans_apply
code: @[simp]
theorem symm_trans_apply (e₁ : A₁ ≃ₐ[R] A₂) (e₂ : A₂ ≃ₐ[R] A₃) (x : A₃) :
    (e₁.trans e₂).symm x = e₁.symm (e₂.symm x) 
goal: (e₁.trans e₂).symm x = e₁.symm (e₂.symm x)

full_name: AlgEquiv.coe_trans
code: @[simp]
theorem coe_trans (e₁ : A₁ ≃ₐ[R] A₂) (e₂ : A₂ ≃ₐ[R] A₃) : ⇑(e₁.trans e₂) = e₂ ∘ e₁ 
goal: ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁

full_name: AlgEquiv.trans_apply
code: @[simp]
theorem trans_apply (e₁ : A₁ ≃ₐ[R] A₂) (e₂ : A₂ ≃ₐ[R] A₃) (x : A₁) : (e₁.trans e₂) x = e₂ (e₁ x) 
goal: (e₁.trans e₂) x = e₂ (e₁ x)

full_name: AlgEquiv.comp_symm
code: @[simp]
theorem comp_symm (e : A₁ ≃ₐ[R] A₂) : AlgHom.comp (e : A₁ →ₐ[R] A₂) ↑e.symm = AlgHom.id R A₂ 
goal: (↑e).comp ↑e.symm = AlgHom.id R A₂

full_name: AlgEquiv.symm_comp
code: @[simp]
theorem symm_comp (e : A₁ ≃ₐ[R] A₂) : AlgHom.comp ↑e.symm (e : A₁ →ₐ[R] A₂) = AlgHom.id R A₁ 
goal: (↑e.symm).comp ↑e = AlgHom.id R A₁

full_name: AlgEquiv.leftInverse_symm
code: theorem leftInverse_symm (e : A₁ ≃ₐ[R] A₂) : Function.LeftInverse e.symm e 
goal: Function.LeftInverse ⇑e.symm ⇑e

full_name: AlgEquiv.rightInverse_symm
code: theorem rightInverse_symm (e : A₁ ≃ₐ[R] A₂) : Function.RightInverse e.symm e 
goal: Function.RightInverse ⇑e.symm ⇑e

full_name: AlgEquiv.arrowCongr_apply
code: /-- If `A₁` is equivalent to `A₁'` and `A₂` is equivalent to `A₂'`, then the type of maps
`A₁ →ₐ[R] A₂` is equivalent to the type of maps `A₁' →ₐ[R] A₂'`. -/
@[simps apply]
def arrowCongr (e₁ : A₁ ≃ₐ[R] A₁') (e₂ : A₂ ≃ₐ[R] A₂') : (A₁ →ₐ[R] A₂) ≃ (A₁' →ₐ[R] A₂') 
goal: (e₁.arrowCongr e₂) f = ((↑e₂).comp f).comp ↑e₁.symm

full_name: AlgEquiv.arrowCongr
code: /-- If `A₁` is equivalent to `A₁'` and `A₂` is equivalent to `A₂'`, then the type of maps
`A₁ →ₐ[R] A₂` is equivalent to the type of maps `A₁' →ₐ[R] A₂'`. -/
@[simps apply]
def arrowCongr (e₁ : A₁ ≃ₐ[R] A₁') (e₂ : A₂ ≃ₐ[R] A₂') : (A₁ →ₐ[R] A₂) ≃ (A₁' →ₐ[R] A₂') 
goal: (A₁ →ₐ[R] A₂) ≃ (A₁' →ₐ[R] A₂')

full_name: AlgEquiv.arrowCongr_comp
code: theorem arrowCongr_comp (e₁ : A₁ ≃ₐ[R] A₁') (e₂ : A₂ ≃ₐ[R] A₂')
    (e₃ : A₃ ≃ₐ[R] A₃') (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₃) :
    arrowCongr e₁ e₃ (g.comp f) = (arrowCongr e₂ e₃ g).comp (arrowCongr e₁ e₂ f) 
goal: (e₁.arrowCongr e₃) (g.comp f) = ((e₂.arrowCongr e₃) g).comp ((e₁.arrowCongr e₂) f)

full_name: AlgEquiv.arrowCongr_refl
code: @[simp]
theorem arrowCongr_refl : arrowCongr AlgEquiv.refl AlgEquiv.refl = Equiv.refl (A₁ →ₐ[R] A₂) 
goal: AlgEquiv.refl.arrowCongr AlgEquiv.refl = Equiv.refl (A₁ →ₐ[R] A₂)

full_name: AlgEquiv.arrowCongr_trans
code: @[simp]
theorem arrowCongr_trans (e₁ : A₁ ≃ₐ[R] A₂) (e₁' : A₁' ≃ₐ[R] A₂')
    (e₂ : A₂ ≃ₐ[R] A₃) (e₂' : A₂' ≃ₐ[R] A₃') :
    arrowCongr (e₁.trans e₂) (e₁'.trans e₂') = (arrowCongr e₁ e₁').trans (arrowCongr e₂ e₂') 
goal: (e₁.trans e₂).arrowCongr (e₁'.trans e₂') = (e₁.arrowCongr e₁').trans (e₂.arrowCongr e₂')

full_name: AlgEquiv.arrowCongr_symm
code: @[simp]
theorem arrowCongr_symm (e₁ : A₁ ≃ₐ[R] A₁') (e₂ : A₂ ≃ₐ[R] A₂') :
    (arrowCongr e₁ e₂).symm = arrowCongr e₁.symm e₂.symm 
goal: (e₁.arrowCongr e₂).symm = e₁.symm.arrowCongr e₂.symm

full_name: AlgEquiv.equivCongr_apply
code: /-- If `A₁` is equivalent to `A₂` and `A₁'` is equivalent to `A₂'`, then the type of maps
`A₁ ≃ₐ[R] A₁'` is equivalent to the type of maps `A₂ ≃ ₐ[R] A₂'`.

This is the `AlgEquiv` version of `AlgEquiv.arrowCongr`. -/
@[simps apply]
def equivCongr (e : A₁ ≃ₐ[R] A₂) (e' : A₁' ≃ₐ[R] A₂') : (A₁ ≃ₐ[R] A₁') ≃ A₂ ≃ₐ[R] A₂' 
goal: (e.equivCongr e') ψ = e.symm.trans (ψ.trans e')

full_name: AlgEquiv.equivCongr
code: /-- If `A₁` is equivalent to `A₂` and `A₁'` is equivalent to `A₂'`, then the type of maps
`A₁ ≃ₐ[R] A₁'` is equivalent to the type of maps `A₂ ≃ ₐ[R] A₂'`.

This is the `AlgEquiv` version of `AlgEquiv.arrowCongr`. -/
@[simps apply]
def equivCongr (e : A₁ ≃ₐ[R] A₂) (e' : A₁' ≃ₐ[R] A₂') : (A₁ ≃ₐ[R] A₁') ≃ A₂ ≃ₐ[R] A₂' 
goal: (A₁ ≃ₐ[R] A₁') ≃ A₂ ≃ₐ[R] A₂'

full_name: AlgEquiv.equivCongr_refl
code: @[simp]
theorem equivCongr_refl : equivCongr AlgEquiv.refl AlgEquiv.refl = Equiv.refl (A₁ ≃ₐ[R] A₁') 
goal: AlgEquiv.refl.equivCongr AlgEquiv.refl = Equiv.refl (A₁ ≃ₐ[R] A₁')

full_name: AlgEquiv.equivCongr_symm
code: @[simp]
theorem equivCongr_symm (e : A₁ ≃ₐ[R] A₂) (e' : A₁' ≃ₐ[R] A₂') :
    (equivCongr e e').symm = equivCongr e.symm e'.symm 
goal: (e.equivCongr e').symm = e.symm.equivCongr e'.symm

full_name: AlgEquiv.equivCongr_trans
code: @[simp]
theorem equivCongr_trans (e₁₂ : A₁ ≃ₐ[R] A₂) (e₁₂' : A₁' ≃ₐ[R] A₂')
    (e₂₃ : A₂ ≃ₐ[R] A₃) (e₂₃' : A₂' ≃ₐ[R] A₃') :
    (equivCongr e₁₂ e₁₂').trans (equivCongr e₂₃ e₂₃') =
      equivCongr (e₁₂.trans e₂₃) (e₁₂'.trans e₂₃') 
goal: (e₁₂.equivCongr e₁₂').trans (e₂₃.equivCongr e₂₃') = (e₁₂.trans e₂₃).equivCongr (e₁₂'.trans e₂₃')

full_name: AlgEquiv.ofAlgHom
code: /-- If an algebra morphism has an inverse, it is an algebra isomorphism. -/
@[simps]
def ofAlgHom (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ : f.comp g = AlgHom.id R A₂)
    (h₂ : g.comp f = AlgHom.id R A₁) : A₁ ≃ₐ[R] A₂ 
goal: A₁ ≃ₐ[R] A₂

full_name: AlgEquiv.ofAlgHom_symm_apply
code: /-- If an algebra morphism has an inverse, it is an algebra isomorphism. -/
@[simps]
def ofAlgHom (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ : f.comp g = AlgHom.id R A₂)
    (h₂ : g.comp f = AlgHom.id R A₁) : A₁ ≃ₐ[R] A₂ 
goal: (AlgEquiv.ofAlgHom f g h₁ h₂).symm a = g a

full_name: AlgEquiv.ofAlgHom_apply
code: /-- If an algebra morphism has an inverse, it is an algebra isomorphism. -/
@[simps]
def ofAlgHom (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ : f.comp g = AlgHom.id R A₂)
    (h₂ : g.comp f = AlgHom.id R A₁) : A₁ ≃ₐ[R] A₂ 
goal: (AlgEquiv.ofAlgHom f g h₁ h₂) a = f a

full_name: AlgEquiv.coe_algHom_ofAlgHom
code: theorem coe_algHom_ofAlgHom (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ h₂) :
    ↑(ofAlgHom f g h₁ h₂) = f 
goal: ↑(AlgEquiv.ofAlgHom f g h₁ h₂) = f

full_name: AlgEquiv.ofAlgHom_coe_algHom
code: @[simp]
theorem ofAlgHom_coe_algHom (f : A₁ ≃ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ h₂) :
    ofAlgHom (↑f) g h₁ h₂ = f 
goal: AlgEquiv.ofAlgHom (↑f) g h₁ h₂ = f

full_name: AlgEquiv.ofAlgHom_symm
code: theorem ofAlgHom_symm (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ h₂) :
    (ofAlgHom f g h₁ h₂).symm = ofAlgHom g f h₂ h₁ 
goal: (AlgEquiv.ofAlgHom f g h₁ h₂).symm = AlgEquiv.ofAlgHom g f h₂ h₁

full_name: AlgEquiv.ofBijective
code: /-- Promotes a bijective algebra homomorphism to an algebra equivalence. -/
noncomputable def ofBijective (f : A₁ →ₐ[R] A₂) (hf : Function.Bijective f) : A₁ ≃ₐ[R] A₂ 
goal: A₁ ≃ₐ[R] A₂

full_name: AlgEquiv.coe_ofBijective
code: @[simp]
theorem coe_ofBijective {f : A₁ →ₐ[R] A₂} {hf : Function.Bijective f} :
    (AlgEquiv.ofBijective f hf : A₁ → A₂) = f 
goal: ⇑(AlgEquiv.ofBijective f hf) = ⇑f

full_name: AlgEquiv.ofBijective_apply
code: theorem ofBijective_apply {f : A₁ →ₐ[R] A₂} {hf : Function.Bijective f} (a : A₁) :
    (AlgEquiv.ofBijective f hf) a = f a 
goal: (AlgEquiv.ofBijective f hf) a = f a

full_name: AlgEquiv.toLinearEquiv_apply
code: /-- Forgetting the multiplicative structures, an equivalence of algebras is a linear equivalence. -/
@[simps apply]
def toLinearEquiv (e : A₁ ≃ₐ[R] A₂) : A₁ ≃ₗ[R] A₂ 
goal: e.toLinearEquiv a = e a

full_name: AlgEquiv.toLinearEquiv
code: /-- Forgetting the multiplicative structures, an equivalence of algebras is a linear equivalence. -/
@[simps apply]
def toLinearEquiv (e : A₁ ≃ₐ[R] A₂) : A₁ ≃ₗ[R] A₂ 
goal: A₁ ≃ₗ[R] A₂

full_name: AlgEquiv.toLinearEquiv_refl
code: @[simp]
theorem toLinearEquiv_refl : (AlgEquiv.refl : A₁ ≃ₐ[R] A₁).toLinearEquiv = LinearEquiv.refl R A₁ 
goal: AlgEquiv.refl.toLinearEquiv = LinearEquiv.refl R A₁

full_name: AlgEquiv.toLinearEquiv_symm
code: @[simp]
theorem toLinearEquiv_symm (e : A₁ ≃ₐ[R] A₂) : e.toLinearEquiv.symm = e.symm.toLinearEquiv 
goal: e.toLinearEquiv.symm = e.symm.toLinearEquiv

full_name: AlgEquiv.toLinearEquiv_trans
code: @[simp]
theorem toLinearEquiv_trans (e₁ : A₁ ≃ₐ[R] A₂) (e₂ : A₂ ≃ₐ[R] A₃) :
    (e₁.trans e₂).toLinearEquiv = e₁.toLinearEquiv.trans e₂.toLinearEquiv 
goal: (e₁.trans e₂).toLinearEquiv = e₁.toLinearEquiv ≪≫ₗ e₂.toLinearEquiv

full_name: AlgEquiv.toLinearEquiv_injective
code: theorem toLinearEquiv_injective : Function.Injective (toLinearEquiv : _ → A₁ ≃ₗ[R] A₂) 
goal: Function.Injective AlgEquiv.toLinearEquiv

full_name: AlgEquiv.toLinearMap
code: /-- Interpret an algebra equivalence as a linear map. -/
def toLinearMap : A₁ →ₗ[R] A₂ 
goal: A₁ →ₗ[R] A₂

full_name: AlgEquiv.toAlgHom_toLinearMap
code: @[simp]
theorem toAlgHom_toLinearMap : (e : A₁ →ₐ[R] A₂).toLinearMap = e.toLinearMap 
goal: (↑e).toLinearMap = e.toLinearMap

full_name: AlgEquiv.toLinearMap_ofAlgHom
code: theorem toLinearMap_ofAlgHom (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ h₂) :
    (ofAlgHom f g h₁ h₂).toLinearMap = f.toLinearMap 
goal: (AlgEquiv.ofAlgHom f g h₁ h₂).toLinearMap = f.toLinearMap

full_name: AlgEquiv.toLinearEquiv_toLinearMap
code: @[simp]
theorem toLinearEquiv_toLinearMap : e.toLinearEquiv.toLinearMap = e.toLinearMap 
goal: ↑e.toLinearEquiv = e.toLinearMap

full_name: AlgEquiv.toLinearMap_apply
code: @[simp]
theorem toLinearMap_apply (x : A₁) : e.toLinearMap x = e x 
goal: e.toLinearMap x = e x

full_name: AlgEquiv.toLinearMap_injective
code: theorem toLinearMap_injective : Function.Injective (toLinearMap : _ → A₁ →ₗ[R] A₂) 
goal: Function.Injective AlgEquiv.toLinearMap

full_name: AlgEquiv.trans_toLinearMap
code: @[simp]
theorem trans_toLinearMap (f : A₁ ≃ₐ[R] A₂) (g : A₂ ≃ₐ[R] A₃) :
    (f.trans g).toLinearMap = g.toLinearMap.comp f.toLinearMap 
goal: (f.trans g).toLinearMap = g.toLinearMap ∘ₗ f.toLinearMap

full_name: AlgEquiv.ofLinearEquiv_apply
code: /--
Upgrade a linear equivalence to an algebra equivalence,
given that it distributes over multiplication and the identity
-/
@[simps apply]
def ofLinearEquiv : A₁ ≃ₐ[R] A₂ 
goal: (AlgEquiv.ofLinearEquiv l map_one map_mul) a = l a

full_name: AlgEquiv.ofLinearEquiv
code: /--
Upgrade a linear equivalence to an algebra equivalence,
given that it distributes over multiplication and the identity
-/
@[simps apply]
def ofLinearEquiv : A₁ ≃ₐ[R] A₂ 
goal: A₁ ≃ₐ[R] A₂

full_name: AlgEquiv.ofLinearEquiv_symm.aux
code: /-- Auxilliary definition to avoid looping in `dsimp` with `AlgEquiv.ofLinearEquiv_symm`. -/
protected def ofLinearEquiv_symm.aux 
goal: A₂ ≃ₐ[R] A₁

full_name: AlgEquiv.ofLinearEquiv_symm
code: @[simp]
theorem ofLinearEquiv_symm :
    (ofLinearEquiv l map_one map_mul).symm =
      ofLinearEquiv l.symm
        (_root_.map_one <| ofLinearEquiv_symm.aux l map_one map_mul)
        (_root_.map_mul <| ofLinearEquiv_symm.aux l map_one map_mul) 
goal: (AlgEquiv.ofLinearEquiv l map_one map_mul).symm = AlgEquiv.ofLinearEquiv l.symm ⋯ ⋯

full_name: AlgEquiv.ofLinearEquiv_toLinearEquiv
code: @[simp]
theorem ofLinearEquiv_toLinearEquiv (map_mul) (map_one) :
    ofLinearEquiv e.toLinearEquiv map_mul map_one = e 
goal: AlgEquiv.ofLinearEquiv e.toLinearEquiv map_mul map_one = e

full_name: AlgEquiv.toLinearEquiv_ofLinearEquiv
code: @[simp]
theorem toLinearEquiv_ofLinearEquiv : toLinearEquiv (ofLinearEquiv l map_one map_mul) = l 
goal: (AlgEquiv.ofLinearEquiv l map_one map_mul).toLinearEquiv = l

full_name: AlgEquiv.ofRingEquiv_apply
code: /-- Promotes a linear `RingEquiv` to an `AlgEquiv`. -/
@[simps apply symm_apply toEquiv] -- Porting note: don't want redundant `toEquiv_symm_apply` simps
def ofRingEquiv {f : A₁ ≃+* A₂} (hf : ∀ x, f (algebraMap R A₁ x) = algebraMap R A₂ x) :
    A₁ ≃ₐ[R] A₂ 
goal: (AlgEquiv.ofRingEquiv hf) a = f a

full_name: AlgEquiv.ofRingEquiv_symm_apply
code: /-- Promotes a linear `RingEquiv` to an `AlgEquiv`. -/
@[simps apply symm_apply toEquiv] -- Porting note: don't want redundant `toEquiv_symm_apply` simps
def ofRingEquiv {f : A₁ ≃+* A₂} (hf : ∀ x, f (algebraMap R A₁ x) = algebraMap R A₂ x) :
    A₁ ≃ₐ[R] A₂ 
goal: (AlgEquiv.ofRingEquiv hf).symm a = f.symm a

full_name: AlgEquiv.ofRingEquiv
code: /-- Promotes a linear `RingEquiv` to an `AlgEquiv`. -/
@[simps apply symm_apply toEquiv] -- Porting note: don't want redundant `toEquiv_symm_apply` simps
def ofRingEquiv {f : A₁ ≃+* A₂} (hf : ∀ x, f (algebraMap R A₁ x) = algebraMap R A₂ x) :
    A₁ ≃ₐ[R] A₂ 
goal: A₁ ≃ₐ[R] A₂

full_name: AlgEquiv.ofRingEquiv_toEquiv
code: /-- Promotes a linear `RingEquiv` to an `AlgEquiv`. -/
@[simps apply symm_apply toEquiv] -- Porting note: don't want redundant `toEquiv_symm_apply` simps
def ofRingEquiv {f : A₁ ≃+* A₂} (hf : ∀ x, f (algebraMap R A₁ x) = algebraMap R A₂ x) :
    A₁ ≃ₐ[R] A₂ 
goal: ↑(AlgEquiv.ofRingEquiv hf) = { toFun := ⇑f, invFun := ⇑f.symm, left_inv := ⋯, right_inv := ⋯ }

full_name: AlgEquiv.aut
code: instance aut : Group (A₁ ≃ₐ[R] A₁) 
goal: Group (A₁ ≃ₐ[R] A₁)

full_name: AlgEquiv.aut_mul
code: theorem aut_mul (ϕ ψ : A₁ ≃ₐ[R] A₁) : ϕ * ψ = ψ.trans ϕ 
goal: ϕ * ψ = ψ.trans ϕ

full_name: AlgEquiv.aut_one
code: theorem aut_one : 1 = AlgEquiv.refl (R := R) (A₁ := A₁) 
goal: 1 = AlgEquiv.refl

full_name: AlgEquiv.one_apply
code: @[simp]
theorem one_apply (x : A₁) : (1 : A₁ ≃ₐ[R] A₁) x = x 
goal: 1 x = x

full_name: AlgEquiv.mul_apply
code: @[simp]
theorem mul_apply (e₁ e₂ : A₁ ≃ₐ[R] A₁) (x : A₁) : (e₁ * e₂) x = e₁ (e₂ x) 
goal: (e₁ * e₂) x = e₁ (e₂ x)

full_name: AlgEquiv.autCongr
code: /-- An algebra isomorphism induces a group isomorphism between automorphism groups.

This is a more bundled version of `AlgEquiv.equivCongr`. -/
@[simps apply]
def autCongr (ϕ : A₁ ≃ₐ[R] A₂) : (A₁ ≃ₐ[R] A₁) ≃* A₂ ≃ₐ[R] A₂ 
goal: (A₁ ≃ₐ[R] A₁) ≃* A₂ ≃ₐ[R] A₂

full_name: AlgEquiv.autCongr_apply
code: /-- An algebra isomorphism induces a group isomorphism between automorphism groups.

This is a more bundled version of `AlgEquiv.equivCongr`. -/
@[simps apply]
def autCongr (ϕ : A₁ ≃ₐ[R] A₂) : (A₁ ≃ₐ[R] A₁) ≃* A₂ ≃ₐ[R] A₂ 
goal: ϕ.autCongr ψ = ϕ.symm.trans (ψ.trans ϕ)

full_name: AlgEquiv.autCongr_refl
code: @[simp]
theorem autCongr_refl : autCongr AlgEquiv.refl = MulEquiv.refl (A₁ ≃ₐ[R] A₁) 
goal: AlgEquiv.refl.autCongr = MulEquiv.refl (A₁ ≃ₐ[R] A₁)

full_name: AlgEquiv.autCongr_symm
code: @[simp]
theorem autCongr_symm (ϕ : A₁ ≃ₐ[R] A₂) : (autCongr ϕ).symm = autCongr ϕ.symm 
goal: ϕ.autCongr.symm = ϕ.symm.autCongr

full_name: AlgEquiv.autCongr_trans
code: @[simp]
theorem autCongr_trans (ϕ : A₁ ≃ₐ[R] A₂) (ψ : A₂ ≃ₐ[R] A₃) :
    (autCongr ϕ).trans (autCongr ψ) = autCongr (ϕ.trans ψ) 
goal: ϕ.autCongr.trans ψ.autCongr = (ϕ.trans ψ).autCongr

full_name: AlgEquiv.applyMulSemiringAction
code: /-- The tautological action by `A₁ ≃ₐ[R] A₁` on `A₁`.

This generalizes `Function.End.applyMulAction`. -/
instance applyMulSemiringAction : MulSemiringAction (A₁ ≃ₐ[R] A₁) A₁ 
goal: MulSemiringAction (A₁ ≃ₐ[R] A₁) A₁

full_name: AlgEquiv.smul_def
code: @[simp]
protected theorem smul_def (f : A₁ ≃ₐ[R] A₁) (a : A₁) : f • a = f a 
goal: f • a = f a

full_name: AlgEquiv.apply_faithfulSMul
code: instance apply_faithfulSMul : FaithfulSMul (A₁ ≃ₐ[R] A₁) A₁ 
goal: FaithfulSMul (A₁ ≃ₐ[R] A₁) A₁

full_name: AlgEquiv.apply_smulCommClass
code: instance apply_smulCommClass : SMulCommClass R (A₁ ≃ₐ[R] A₁) A₁ 
goal: SMulCommClass R (A₁ ≃ₐ[R] A₁) A₁

full_name: AlgEquiv.apply_smulCommClass'
code: instance apply_smulCommClass' : SMulCommClass (A₁ ≃ₐ[R] A₁) R A₁ 
goal: SMulCommClass (A₁ ≃ₐ[R] A₁) R A₁

full_name: AlgEquiv.instMulDistribMulActionUnits
code: instance : MulDistribMulAction (A₁ ≃ₐ[R] A₁) A₁ˣ 
goal: MulDistribMulAction (A₁ ≃ₐ[R] A₁) A₁ˣ

full_name: AlgEquiv.smul_units_def
code: @[simp]
theorem smul_units_def (f : A₁ ≃ₐ[R] A₁) (x : A₁ˣ) :
    f • x = Units.map f x 
goal: f • x = (Units.map ↑f) x

full_name: AlgEquiv.algebraMap_eq_apply
code: @[simp]
theorem algebraMap_eq_apply (e : A₁ ≃ₐ[R] A₂) {y : R} {x : A₁} :
    algebraMap R A₂ y = e x ↔ algebraMap R A₁ y = x 
goal: (algebraMap R A₂) y = e x ↔ (algebraMap R A₁) y = x

full_name: AlgEquiv.toLinearMapHom
code: /-- `AlgEquiv.toLinearMap` as a `MonoidHom`. -/
@[simps]
def toLinearMapHom (R A) [CommSemiring R] [Semiring A] [Algebra R A] :
    (A ≃ₐ[R] A) →* A →ₗ[R] A 
goal: (A ≃ₐ[R] A) →* A →ₗ[R] A

full_name: AlgEquiv.toLinearMapHom_apply
code: /-- `AlgEquiv.toLinearMap` as a `MonoidHom`. -/
@[simps]
def toLinearMapHom (R A) [CommSemiring R] [Semiring A] [Algebra R A] :
    (A ≃ₐ[R] A) →* A →ₗ[R] A 
goal: (AlgEquiv.toLinearMapHom R A) e = e.toLinearMap

full_name: AlgEquiv.pow_toLinearMap
code: lemma pow_toLinearMap (σ : A₁ ≃ₐ[R] A₁) (n : ℕ) :
    (σ ^ n).toLinearMap = σ.toLinearMap ^ n 
goal: (σ ^ n).toLinearMap = σ.toLinearMap ^ n

full_name: AlgEquiv.one_toLinearMap
code: @[simp]
lemma one_toLinearMap :
    (1 : A₁ ≃ₐ[R] A₁).toLinearMap = 1 
goal: AlgEquiv.toLinearMap 1 = 1

full_name: AlgEquiv.val_algHomUnitsEquiv_symm_apply
code: /-- The units group of `S →ₐ[R] S` is `S ≃ₐ[R] S`.
See `LinearMap.GeneralLinearGroup.generalLinearEquiv` for the linear map version. -/
@[simps]
def algHomUnitsEquiv (R S : Type*) [CommSemiring R] [Semiring S] [Algebra R S] :
    (S →ₐ[R] S)ˣ ≃* (S ≃ₐ[R] S) 
goal: ↑((AlgEquiv.algHomUnitsEquiv R S).symm f) = ↑f

full_name: AlgEquiv.algHomUnitsEquiv_apply_apply
code: /-- The units group of `S →ₐ[R] S` is `S ≃ₐ[R] S`.
See `LinearMap.GeneralLinearGroup.generalLinearEquiv` for the linear map version. -/
@[simps]
def algHomUnitsEquiv (R S : Type*) [CommSemiring R] [Semiring S] [Algebra R S] :
    (S →ₐ[R] S)ˣ ≃* (S ≃ₐ[R] S) 
goal: ∀ (a : S), ((AlgEquiv.algHomUnitsEquiv R S) f) a = (↑↑(↑f).toRingHom).toFun a

full_name: AlgEquiv.algHomUnitsEquiv
code: /-- The units group of `S →ₐ[R] S` is `S ≃ₐ[R] S`.
See `LinearMap.GeneralLinearGroup.generalLinearEquiv` for the linear map version. -/
@[simps]
def algHomUnitsEquiv (R S : Type*) [CommSemiring R] [Semiring S] [Algebra R S] :
    (S →ₐ[R] S)ˣ ≃* (S ≃ₐ[R] S) 
goal: (S →ₐ[R] S)ˣ ≃* S ≃ₐ[R] S

full_name: AlgEquiv.algHomUnitsEquiv_apply_symm_apply
code: /-- The units group of `S →ₐ[R] S` is `S ≃ₐ[R] S`.
See `LinearMap.GeneralLinearGroup.generalLinearEquiv` for the linear map version. -/
@[simps]
def algHomUnitsEquiv (R S : Type*) [CommSemiring R] [Semiring S] [Algebra R S] :
    (S →ₐ[R] S)ˣ ≃* (S ≃ₐ[R] S) 
goal: ((AlgEquiv.algHomUnitsEquiv R S) f).symm a = ↑↑f⁻¹ a

full_name: AlgEquiv.val_inv_algHomUnitsEquiv_symm_apply
code: /-- The units group of `S →ₐ[R] S` is `S ≃ₐ[R] S`.
See `LinearMap.GeneralLinearGroup.generalLinearEquiv` for the linear map version. -/
@[simps]
def algHomUnitsEquiv (R S : Type*) [CommSemiring R] [Semiring S] [Algebra R S] :
    (S →ₐ[R] S)ˣ ≃* (S ≃ₐ[R] S) 
goal: ↑((AlgEquiv.algHomUnitsEquiv R S).symm f)⁻¹ = ↑f.symm

full_name: AlgEquiv.map_prod
code: @[deprecated map_prod (since := "2024-06-20")]
protected theorem map_prod {ι : Type*} (f : ι → A₁) (s : Finset ι) :
    e (∏ x ∈ s, f x) = ∏ x ∈ s, e (f x) 
goal: e (∏ x ∈ s, f x) = ∏ x ∈ s, e (f x)

full_name: AlgEquiv.map_finsupp_prod
code: @[deprecated map_finsupp_prod (since := "2024-06-20")]
protected theorem map_finsupp_prod {α : Type*} [Zero α] {ι : Type*} (f : ι →₀ α) (g : ι → α → A₁) :
    e (f.prod g) = f.prod fun i a => e (g i a) 
goal: e (f.prod g) = f.prod fun i a => e (g i a)

full_name: AlgEquiv.map_neg
code: @[deprecated map_neg (since := "2024-06-20")]
protected theorem map_neg (x) : e (-x) = -e x 
goal: e (-x) = -e x

full_name: AlgEquiv.map_sub
code: @[deprecated map_sub (since := "2024-06-20")]
protected theorem map_sub (x y) : e (x - y) = e x - e y 
goal: e (x - y) = e x - e y

full_name: MulSemiringAction.toAlgEquiv_toEquiv
code: /-- Each element of the group defines an algebra equivalence.

This is a stronger version of `MulSemiringAction.toRingEquiv` and
`DistribMulAction.toLinearEquiv`. -/
@[simps! apply symm_apply toEquiv] -- Porting note: don't want redundant simps lemma `toEquiv_symm`
def toAlgEquiv (g : G) : A ≃ₐ[R] A 
goal: ↑(MulSemiringAction.toAlgEquiv R A g) = ↑(MulSemiringAction.toRingEquiv G A g)

full_name: MulSemiringAction.toAlgEquiv_symm_apply
code: /-- Each element of the group defines an algebra equivalence.

This is a stronger version of `MulSemiringAction.toRingEquiv` and
`DistribMulAction.toLinearEquiv`. -/
@[simps! apply symm_apply toEquiv] -- Porting note: don't want redundant simps lemma `toEquiv_symm`
def toAlgEquiv (g : G) : A ≃ₐ[R] A 
goal: ∀ (a : A), (MulSemiringAction.toAlgEquiv R A g).symm a = g⁻¹ • a

full_name: MulSemiringAction.toAlgEquiv
code: /-- Each element of the group defines an algebra equivalence.

This is a stronger version of `MulSemiringAction.toRingEquiv` and
`DistribMulAction.toLinearEquiv`. -/
@[simps! apply symm_apply toEquiv] -- Porting note: don't want redundant simps lemma `toEquiv_symm`
def toAlgEquiv (g : G) : A ≃ₐ[R] A 
goal: A ≃ₐ[R] A

full_name: MulSemiringAction.toAlgEquiv_apply
code: /-- Each element of the group defines an algebra equivalence.

This is a stronger version of `MulSemiringAction.toRingEquiv` and
`DistribMulAction.toLinearEquiv`. -/
@[simps! apply symm_apply toEquiv] -- Porting note: don't want redundant simps lemma `toEquiv_symm`
def toAlgEquiv (g : G) : A ≃ₐ[R] A 
goal: ∀ (a : A), (MulSemiringAction.toAlgEquiv R A g) a = g • a

full_name: MulSemiringAction.toAlgEquiv_injective
code: theorem toAlgEquiv_injective [FaithfulSMul G A] :
    Function.Injective (MulSemiringAction.toAlgEquiv R A : G → A ≃ₐ[R] A) 
goal: Function.Injective (MulSemiringAction.toAlgEquiv R A)