File: Mathlib/Algebra/Ring/Equiv.lean

full_name: NonUnitalRingHom.inverse
code: /-- makes a `NonUnitalRingHom` from the bijective inverse of a `NonUnitalRingHom` -/
@[simps] def NonUnitalRingHom.inverse
    [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S]
    (f : R →ₙ+* S) (g : S → R)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : S →ₙ+* R 
goal: S →ₙ+* R

full_name: NonUnitalRingHom.inverse_apply
code: /-- makes a `NonUnitalRingHom` from the bijective inverse of a `NonUnitalRingHom` -/
@[simps] def NonUnitalRingHom.inverse
    [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S]
    (f : R →ₙ+* S) (g : S → R)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : S →ₙ+* R 
goal: ∀ (a : S), (f.inverse g h₁ h₂) a = g a

full_name: RingHom.inverse
code: /-- makes a `RingHom` from the bijective inverse of a `RingHom` -/
@[simps] def RingHom.inverse [NonAssocSemiring R] [NonAssocSemiring S]
    (f : RingHom R S) (g : S → R)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : S →+* R 
goal: S →+* R

full_name: RingHom.inverse_apply
code: /-- makes a `RingHom` from the bijective inverse of a `RingHom` -/
@[simps] def RingHom.inverse [NonAssocSemiring R] [NonAssocSemiring S]
    (f : RingHom R S) (g : S → R)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : S →+* R 
goal: ∀ (a : S), (f.inverse g h₁ h₂) a = g a

full_name: RingEquiv
code: /-- An equivalence between two (non-unital non-associative semi)rings that preserves the
algebraic structure. -/
structure RingEquiv (R S : Type*) [Mul R] [Mul S] [Add R] [Add S] extends R ≃ S, R ≃* S, R ≃+ S
goal: Type (max u_7 u_8)

full_name: «_aux_Mathlib_Algebra_Ring_Equiv___macroRules_term_≃+*__1»
code: /-- Notation for `RingEquiv`. -/
infixl:25 " ≃+* " => RingEquiv
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Ring_Equiv___unexpand_RingEquiv_1
code: /-- Notation for `RingEquiv`. -/
infixl:25 " ≃+* " => RingEquiv
goal: Lean.PrettyPrinter.Unexpander

full_name: RingEquivClass.map_add
code: /-- `RingEquivClass F R S` states that `F` is a type of ring structure preserving equivalences.
You should extend this class when you extend `RingEquiv`. -/
class RingEquivClass (F R S : Type*) [Mul R] [Add R] [Mul S] [Add S] [EquivLike F R S]
  extends MulEquivClass F R S : Prop where
  /-- By definition, a ring isomorphism preserves the additive structure. -/
  map_add : ∀ (f : F) (a b), f (a + b) = f a + f b
goal: f (a + b) = f a + f b

full_name: RingEquivClass
code: /-- `RingEquivClass F R S` states that `F` is a type of ring structure preserving equivalences.
You should extend this class when you extend `RingEquiv`. -/
class RingEquivClass (F R S : Type*) [Mul R] [Add R] [Mul S] [Add S] [EquivLike F R S]
  extends MulEquivClass F R S : Prop where
  /-- By definition, a ring isomorphism preserves the additive structure. -/
  map_add : ∀ (f : F) (a b), f (a + b) = f a + f b
goal: Prop

full_name: RingEquivClass.toAddEquivClass
code: instance (priority := 100) toAddEquivClass [Mul R] [Add R]
    [Mul S] [Add S] [h : RingEquivClass F R S] : AddEquivClass F R S 
goal: AddEquivClass F R S

full_name: RingEquivClass.toRingHomClass
code: instance (priority := 100) toRingHomClass [NonAssocSemiring R] [NonAssocSemiring S]
    [h : RingEquivClass F R S] : RingHomClass F R S 
goal: RingHomClass F R S

full_name: RingEquivClass.toNonUnitalRingHomClass
code: instance (priority := 100) toNonUnitalRingHomClass [NonUnitalNonAssocSemiring R]
    [NonUnitalNonAssocSemiring S] [h : RingEquivClass F R S] : NonUnitalRingHomClass F R S 
goal: NonUnitalRingHomClass F R S

full_name: RingEquivClass.toRingEquiv
code: /-- Turn an element of a type `F` satisfying `RingEquivClass F α β` into an actual
`RingEquiv`. This is declared as the default coercion from `F` to `α ≃+* β`. -/
@[coe]
def toRingEquiv [Mul α] [Add α] [Mul β] [Add β] [EquivLike F α β] [RingEquivClass F α β] (f : F) :
    α ≃+* β 
goal: α ≃+* β

full_name: instCoeTCRingEquivOfRingEquivClass
code: /-- Any type satisfying `RingEquivClass` can be cast into `RingEquiv` via
`RingEquivClass.toRingEquiv`. -/
instance [Mul α] [Add α] [Mul β] [Add β] [EquivLike F α β] [RingEquivClass F α β] :
    CoeTC F (α ≃+* β) 
goal: CoeTC F (α ≃+* β)

full_name: RingEquiv.instEquivLike
code: instance : EquivLike (R ≃+* S) R S 
goal: EquivLike (R ≃+* S) R S

full_name: RingEquiv.instRingEquivClass
code: instance : RingEquivClass (R ≃+* S) R S 
goal: RingEquivClass (R ≃+* S) R S

full_name: RingEquiv.toEquiv_eq_coe
code: @[simp]
theorem toEquiv_eq_coe (f : R ≃+* S) : f.toEquiv = f 
goal: f.toEquiv = ↑f

full_name: RingEquiv.coe_toEquiv
code: @[simp]
theorem coe_toEquiv (f : R ≃+* S) : ⇑(f : R ≃ S) = f 
goal: ⇑↑f = ⇑f

full_name: RingEquiv.map_mul
code: /-- A ring isomorphism preserves multiplication. -/
protected theorem map_mul (e : R ≃+* S) (x y : R) : e (x * y) = e x * e y 
goal: e (x * y) = e x * e y

full_name: RingEquiv.map_add
code: /-- A ring isomorphism preserves addition. -/
protected theorem map_add (e : R ≃+* S) (x y : R) : e (x + y) = e x + e y 
goal: e (x + y) = e x + e y

full_name: RingEquiv.ext
code: /-- Two ring isomorphisms agree if they are defined by the
    same underlying function. -/
@[ext]
theorem ext {f g : R ≃+* S} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: RingEquiv.coe_mk
code: @[simp]
theorem coe_mk (e h₃ h₄) : ⇑(⟨e, h₃, h₄⟩ : R ≃+* S) = e 
goal: ⇑{ toEquiv := e, map_mul' := h₃, map_add' := h₄ } = ⇑e

full_name: RingEquiv.mk_coe
code: @[simp]
theorem mk_coe (e : R ≃+* S) (e' h₁ h₂ h₃ h₄) : (⟨⟨e, e', h₁, h₂⟩, h₃, h₄⟩ : R ≃+* S) = e 
goal: { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄ } = e

full_name: RingEquiv.congr_arg
code: protected theorem congr_arg {f : R ≃+* S} {x x' : R} : x = x' → f x = f x' 
goal: x = x' → f x = f x'

full_name: RingEquiv.congr_fun
code: protected theorem congr_fun {f g : R ≃+* S} (h : f = g) (x : R) : f x = g x 
goal: f x = g x

full_name: RingEquiv.ext_iff
code: protected theorem ext_iff {f g : R ≃+* S} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : R), f x = g x

full_name: RingEquiv.toAddEquiv_eq_coe
code: @[simp]
theorem toAddEquiv_eq_coe (f : R ≃+* S) : f.toAddEquiv = ↑f 
goal: f.toAddEquiv = ↑f

full_name: RingEquiv.toMulEquiv_eq_coe
code: @[simp]
theorem toMulEquiv_eq_coe (f : R ≃+* S) : f.toMulEquiv = ↑f 
goal: f.toMulEquiv = ↑f

full_name: RingEquiv.coe_toMulEquiv
code: @[simp, norm_cast]
theorem coe_toMulEquiv (f : R ≃+* S) : ⇑(f : R ≃* S) = f 
goal: ⇑↑f = ⇑f

full_name: RingEquiv.coe_toAddEquiv
code: @[simp]
theorem coe_toAddEquiv (f : R ≃+* S) : ⇑(f : R ≃+ S) = f 
goal: ⇑↑f = ⇑f

full_name: RingEquiv.ringEquivOfUnique
code: /-- The `RingEquiv` between two semirings with a unique element. -/
def ringEquivOfUnique {M N} [Unique M] [Unique N] [Add M] [Mul M] [Add N] [Mul N] : M ≃+* N 
goal: M ≃+* N

full_name: RingEquiv.instUnique
code: instance {M N} [Unique M] [Unique N] [Add M] [Mul M] [Add N] [Mul N] :
    Unique (M ≃+* N) 
goal: Unique (M ≃+* N)

full_name: RingEquiv.refl
code: /-- The identity map is a ring isomorphism. -/
@[refl]
def refl : R ≃+* R 
goal: R ≃+* R

full_name: RingEquiv.refl_apply
code: @[simp]
theorem refl_apply (x : R) : RingEquiv.refl R x = x 
goal: (RingEquiv.refl R) x = x

full_name: RingEquiv.coe_addEquiv_refl
code: @[simp]
theorem coe_addEquiv_refl : (RingEquiv.refl R : R ≃+ R) = AddEquiv.refl R 
goal: ↑(RingEquiv.refl R) = AddEquiv.refl R

full_name: RingEquiv.coe_mulEquiv_refl
code: @[simp]
theorem coe_mulEquiv_refl : (RingEquiv.refl R : R ≃* R) = MulEquiv.refl R 
goal: ↑(RingEquiv.refl R) = MulEquiv.refl R

full_name: RingEquiv.instInhabited
code: instance : Inhabited (R ≃+* R) 
goal: Inhabited (R ≃+* R)

full_name: RingEquiv.symm
code: /-- The inverse of a ring isomorphism is a ring isomorphism. -/
@[symm]
protected def symm (e : R ≃+* S) : S ≃+* R 
goal: S ≃+* R

full_name: RingEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (e : R ≃+* S) : S → R 
goal: S → R

full_name: RingEquiv.invFun_eq_symm
code: @[simp]
theorem invFun_eq_symm (f : R ≃+* S) : EquivLike.inv f = f.symm 
goal: EquivLike.inv f = ⇑f.symm

full_name: RingEquiv.symm_symm
code: @[simp]
theorem symm_symm (e : R ≃+* S) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: RingEquiv.symm_refl
code: @[simp]
theorem symm_refl : (RingEquiv.refl R).symm = RingEquiv.refl R 
goal: (RingEquiv.refl R).symm = RingEquiv.refl R

full_name: RingEquiv.coe_toEquiv_symm
code: @[simp]
theorem coe_toEquiv_symm (e : R ≃+* S) : (e.symm : S ≃ R) = (e : R ≃ S).symm 
goal: ↑e.symm = (↑e).symm

full_name: RingEquiv.symm_bijective
code: theorem symm_bijective : Function.Bijective (RingEquiv.symm : (R ≃+* S) → S ≃+* R) 
goal: Function.Bijective RingEquiv.symm

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

full_name: RingEquiv.symm_mk.aux
code: /-- Auxilliary definition to avoid looping in `dsimp` with `RingEquiv.symm_mk`. -/
protected def symm_mk.aux (f : R → S) (g h₁ h₂ h₃ h₄) 
goal: S ≃+* R

full_name: RingEquiv.symm_mk
code: @[simp]
theorem symm_mk (f : R → S) (g h₁ h₂ h₃ h₄) :
    (mk ⟨f, g, h₁, h₂⟩ h₃ h₄).symm =
      { symm_mk.aux f g h₁ h₂ h₃ h₄ with
        toFun := g
        invFun := f } 
goal: { toFun := f, invFun := g, left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄ }.symm =
  let __src := RingEquiv.symm_mk.aux f g h₁ h₂ h₃ h₄;
  { toFun := g, invFun := f, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯, map_add' := ⋯ }

full_name: RingEquiv.trans
code: /-- Transitivity of `RingEquiv`. -/
@[trans]
protected def trans (e₁ : R ≃+* S) (e₂ : S ≃+* S') : R ≃+* S' 
goal: R ≃+* S'

full_name: RingEquiv.trans_apply
code: theorem trans_apply (e₁ : R ≃+* S) (e₂ : S ≃+* S') (a : R) : e₁.trans e₂ a = e₂ (e₁ a) 
goal: (e₁.trans e₂) a = e₂ (e₁ a)

full_name: RingEquiv.coe_trans
code: @[simp]
theorem coe_trans (e₁ : R ≃+* S) (e₂ : S ≃+* S') : (e₁.trans e₂ : R → S') = e₂ ∘ e₁ 
goal: ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁

full_name: RingEquiv.symm_trans_apply
code: @[simp]
theorem symm_trans_apply (e₁ : R ≃+* S) (e₂ : S ≃+* S') (a : S') :
    (e₁.trans e₂).symm a = e₁.symm (e₂.symm a) 
goal: (e₁.trans e₂).symm a = e₁.symm (e₂.symm a)

full_name: RingEquiv.symm_trans
code: theorem symm_trans (e₁ : R ≃+* S) (e₂ : S ≃+* S') : (e₁.trans e₂).symm = e₂.symm.trans e₁.symm 
goal: (e₁.trans e₂).symm = e₂.symm.trans e₁.symm

full_name: RingEquiv.bijective
code: protected theorem bijective (e : R ≃+* S) : Function.Bijective e 
goal: Function.Bijective ⇑e

full_name: RingEquiv.injective
code: protected theorem injective (e : R ≃+* S) : Function.Injective e 
goal: Function.Injective ⇑e

full_name: RingEquiv.surjective
code: protected theorem surjective (e : R ≃+* S) : Function.Surjective e 
goal: Function.Surjective ⇑e

full_name: RingEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : R ≃+* S) : ∀ x, e (e.symm x) = x 
goal: e (e.symm x) = x

full_name: RingEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : R ≃+* S) : ∀ x, e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: RingEquiv.image_eq_preimage
code: theorem image_eq_preimage (e : R ≃+* S) (s : Set R) : e '' s = e.symm ⁻¹' s 
goal: ⇑e '' s = ⇑e.symm ⁻¹' s

full_name: RingEquiv.coe_mulEquiv_trans
code: @[simp]
theorem coe_mulEquiv_trans (e₁ : R ≃+* S) (e₂ : S ≃+* S') :
    (e₁.trans e₂ : R ≃* S') = (e₁ : R ≃* S).trans ↑e₂ 
goal: ↑(e₁.trans e₂) = (↑e₁).trans ↑e₂

full_name: RingEquiv.coe_addEquiv_trans
code: @[simp]
theorem coe_addEquiv_trans (e₁ : R ≃+* S) (e₂ : S ≃+* S') :
    (e₁.trans e₂ : R ≃+ S') = (e₁ : R ≃+ S).trans ↑e₂ 
goal: ↑(e₁.trans e₂) = (↑e₁).trans ↑e₂

full_name: RingEquiv.op_apply_symm_apply
code: /-- A ring iso `α ≃+* β` can equivalently be viewed as a ring iso `αᵐᵒᵖ ≃+* βᵐᵒᵖ`. -/
@[simps! symm_apply_apply symm_apply_symm_apply apply_apply apply_symm_apply]
protected def op {α β} [Add α] [Mul α] [Add β] [Mul β] :
    α ≃+* β ≃ (αᵐᵒᵖ ≃+* βᵐᵒᵖ) 
goal: ∀ (a : βᵐᵒᵖ), (RingEquiv.op f).symm a = MulOpposite.op ((↑f).symm (MulOpposite.unop a))

full_name: RingEquiv.op_symm_apply_symm_apply
code: /-- A ring iso `α ≃+* β` can equivalently be viewed as a ring iso `αᵐᵒᵖ ≃+* βᵐᵒᵖ`. -/
@[simps! symm_apply_apply symm_apply_symm_apply apply_apply apply_symm_apply]
protected def op {α β} [Add α] [Mul α] [Add β] [Mul β] :
    α ≃+* β ≃ (αᵐᵒᵖ ≃+* βᵐᵒᵖ) 
goal: ∀ (a : β), (RingEquiv.op.symm f).symm a = MulOpposite.unop ((↑f).symm (MulOpposite.op a))

full_name: RingEquiv.op_symm_apply_apply
code: /-- A ring iso `α ≃+* β` can equivalently be viewed as a ring iso `αᵐᵒᵖ ≃+* βᵐᵒᵖ`. -/
@[simps! symm_apply_apply symm_apply_symm_apply apply_apply apply_symm_apply]
protected def op {α β} [Add α] [Mul α] [Add β] [Mul β] :
    α ≃+* β ≃ (αᵐᵒᵖ ≃+* βᵐᵒᵖ) 
goal: ∀ (a : α), (RingEquiv.op.symm f) a = MulOpposite.unop (f (MulOpposite.op a))

full_name: RingEquiv.op
code: /-- A ring iso `α ≃+* β` can equivalently be viewed as a ring iso `αᵐᵒᵖ ≃+* βᵐᵒᵖ`. -/
@[simps! symm_apply_apply symm_apply_symm_apply apply_apply apply_symm_apply]
protected def op {α β} [Add α] [Mul α] [Add β] [Mul β] :
    α ≃+* β ≃ (αᵐᵒᵖ ≃+* βᵐᵒᵖ) 
goal: α ≃+* β ≃ (αᵐᵒᵖ ≃+* βᵐᵒᵖ)

full_name: RingEquiv.op_apply_apply
code: /-- A ring iso `α ≃+* β` can equivalently be viewed as a ring iso `αᵐᵒᵖ ≃+* βᵐᵒᵖ`. -/
@[simps! symm_apply_apply symm_apply_symm_apply apply_apply apply_symm_apply]
protected def op {α β} [Add α] [Mul α] [Add β] [Mul β] :
    α ≃+* β ≃ (αᵐᵒᵖ ≃+* βᵐᵒᵖ) 
goal: ∀ (a : αᵐᵒᵖ), (RingEquiv.op f) a = MulOpposite.op (f (MulOpposite.unop a))

full_name: RingEquiv.unop
code: /-- The 'unopposite' of a ring iso `αᵐᵒᵖ ≃+* βᵐᵒᵖ`. Inverse to `RingEquiv.op`. -/
@[simp]
protected def unop {α β} [Add α] [Mul α] [Add β] [Mul β] : αᵐᵒᵖ ≃+* βᵐᵒᵖ ≃ (α ≃+* β) 
goal: αᵐᵒᵖ ≃+* βᵐᵒᵖ ≃ (α ≃+* β)

full_name: RingEquiv.opOp
code: /-- A ring is isomorphic to the opposite of its opposite. -/
@[simps!]
def opOp (R : Type*) [Add R] [Mul R] : R ≃+* Rᵐᵒᵖᵐᵒᵖ 
goal: R ≃+* Rᵐᵒᵖᵐᵒᵖ

full_name: RingEquiv.opOp_apply
code: /-- A ring is isomorphic to the opposite of its opposite. -/
@[simps!]
def opOp (R : Type*) [Add R] [Mul R] : R ≃+* Rᵐᵒᵖᵐᵒᵖ 
goal: ∀ (a : R), (RingEquiv.opOp R) a = MulOpposite.op (MulOpposite.op a)

full_name: RingEquiv.opOp_symm_apply
code: /-- A ring is isomorphic to the opposite of its opposite. -/
@[simps!]
def opOp (R : Type*) [Add R] [Mul R] : R ≃+* Rᵐᵒᵖᵐᵒᵖ 
goal: ∀ (a : Rᵐᵒᵖᵐᵒᵖ), (RingEquiv.opOp R).symm a = MulOpposite.unop (MulOpposite.unop a)

full_name: RingEquiv.toOpposite
code: /-- A non-unital commutative ring is isomorphic to its opposite. -/
def toOpposite : R ≃+* Rᵐᵒᵖ 
goal: R ≃+* Rᵐᵒᵖ

full_name: RingEquiv.toOpposite_apply
code: @[simp]
theorem toOpposite_apply (r : R) : toOpposite R r = op r 
goal: (RingEquiv.toOpposite R) r = MulOpposite.op r

full_name: RingEquiv.toOpposite_symm_apply
code: @[simp]
theorem toOpposite_symm_apply (r : Rᵐᵒᵖ) : (toOpposite R).symm r = unop r 
goal: (RingEquiv.toOpposite R).symm r = MulOpposite.unop r

full_name: RingEquiv.map_zero
code: /-- A ring isomorphism sends zero to zero. -/
protected theorem map_zero : f 0 = 0 
goal: f 0 = 0

full_name: RingEquiv.map_eq_zero_iff
code: protected theorem map_eq_zero_iff : f x = 0 ↔ x = 0 
goal: f x = 0 ↔ x = 0

full_name: RingEquiv.map_ne_zero_iff
code: theorem map_ne_zero_iff : f x ≠ 0 ↔ x ≠ 0 
goal: f x ≠ 0 ↔ x ≠ 0

full_name: RingEquiv.ofBijective
code: /-- Produce a ring isomorphism from a bijective ring homomorphism. -/
noncomputable def ofBijective [NonUnitalRingHomClass F R S] (f : F) (hf : Function.Bijective f) :
    R ≃+* S 
goal: R ≃+* S

full_name: RingEquiv.coe_ofBijective
code: @[simp]
theorem coe_ofBijective [NonUnitalRingHomClass F R S] (f : F) (hf : Function.Bijective f) :
    (ofBijective f hf : R → S) = f 
goal: ⇑(RingEquiv.ofBijective f hf) = ⇑f

full_name: RingEquiv.ofBijective_apply
code: theorem ofBijective_apply [NonUnitalRingHomClass F R S] (f : F) (hf : Function.Bijective f)
    (x : R) : ofBijective f hf x = f x 
goal: (RingEquiv.ofBijective f hf) x = f x

full_name: RingEquiv.piCongrRight
code: /-- A family of ring isomorphisms `∀ j, (R j ≃+* S j)` generates a
ring isomorphisms between `∀ j, R j` and `∀ j, S j`.

This is the `RingEquiv` version of `Equiv.piCongrRight`, and the dependent version of
`RingEquiv.arrowCongr`.
-/
@[simps apply]
def piCongrRight {ι : Type*} {R S : ι → Type*} [∀ i, NonUnitalNonAssocSemiring (R i)]
    [∀ i, NonUnitalNonAssocSemiring (S i)] (e : ∀ i, R i ≃+* S i) : (∀ i, R i) ≃+* ∀ i, S i 
goal: ((i : ι) → R i) ≃+* ((i : ι) → S i)

full_name: RingEquiv.piCongrRight_apply
code: /-- A family of ring isomorphisms `∀ j, (R j ≃+* S j)` generates a
ring isomorphisms between `∀ j, R j` and `∀ j, S j`.

This is the `RingEquiv` version of `Equiv.piCongrRight`, and the dependent version of
`RingEquiv.arrowCongr`.
-/
@[simps apply]
def piCongrRight {ι : Type*} {R S : ι → Type*} [∀ i, NonUnitalNonAssocSemiring (R i)]
    [∀ i, NonUnitalNonAssocSemiring (S i)] (e : ∀ i, R i ≃+* S i) : (∀ i, R i) ≃+* ∀ i, S i 
goal: (RingEquiv.piCongrRight e) x j = (e j) (x j)

full_name: RingEquiv.piCongrRight_refl
code: @[simp]
theorem piCongrRight_refl {ι : Type*} {R : ι → Type*} [∀ i, NonUnitalNonAssocSemiring (R i)] :
    (piCongrRight fun i => RingEquiv.refl (R i)) = RingEquiv.refl _ 
goal: (RingEquiv.piCongrRight fun i => RingEquiv.refl (R i)) = RingEquiv.refl ((i : ι) → R i)

full_name: RingEquiv.piCongrRight_symm
code: @[simp]
theorem piCongrRight_symm {ι : Type*} {R S : ι → Type*} [∀ i, NonUnitalNonAssocSemiring (R i)]
    [∀ i, NonUnitalNonAssocSemiring (S i)] (e : ∀ i, R i ≃+* S i) :
    (piCongrRight e).symm = piCongrRight fun i => (e i).symm 
goal: (RingEquiv.piCongrRight e).symm = RingEquiv.piCongrRight fun i => (e i).symm

full_name: RingEquiv.piCongrRight_trans
code: @[simp]
theorem piCongrRight_trans {ι : Type*} {R S T : ι → Type*}
    [∀ i, NonUnitalNonAssocSemiring (R i)] [∀ i, NonUnitalNonAssocSemiring (S i)]
    [∀ i, NonUnitalNonAssocSemiring (T i)] (e : ∀ i, R i ≃+* S i) (f : ∀ i, S i ≃+* T i) :
    (piCongrRight e).trans (piCongrRight f) = piCongrRight fun i => (e i).trans (f i) 
goal: (RingEquiv.piCongrRight e).trans (RingEquiv.piCongrRight f) = RingEquiv.piCongrRight fun i => (e i).trans (f i)

full_name: RingEquiv.map_one
code: /-- A ring isomorphism sends one to one. -/
protected theorem map_one : f 1 = 1 
goal: f 1 = 1

full_name: RingEquiv.map_eq_one_iff
code: protected theorem map_eq_one_iff : f x = 1 ↔ x = 1 
goal: f x = 1 ↔ x = 1

full_name: RingEquiv.map_ne_one_iff
code: theorem map_ne_one_iff : f x ≠ 1 ↔ x ≠ 1 
goal: f x ≠ 1 ↔ x ≠ 1

full_name: RingEquiv.coe_monoidHom_refl
code: theorem coe_monoidHom_refl : (RingEquiv.refl R : R →* R) = MonoidHom.id R 
goal: ↑(RingEquiv.refl R) = MonoidHom.id R

full_name: RingEquiv.coe_addMonoidHom_refl
code: @[simp]
theorem coe_addMonoidHom_refl : (RingEquiv.refl R : R →+ R) = AddMonoidHom.id R 
goal: ↑(RingEquiv.refl R) = AddMonoidHom.id R

full_name: RingEquiv.coe_ringHom_refl
code: @[simp]
theorem coe_ringHom_refl : (RingEquiv.refl R : R →+* R) = RingHom.id R 
goal: ↑(RingEquiv.refl R) = RingHom.id R

full_name: RingEquiv.coe_monoidHom_trans
code: @[simp]
theorem coe_monoidHom_trans [NonAssocSemiring S'] (e₁ : R ≃+* S) (e₂ : S ≃+* S') :
    (e₁.trans e₂ : R →* S') = (e₂ : S →* S').comp ↑e₁ 
goal: ↑(e₁.trans e₂) = (↑e₂).comp ↑e₁

full_name: RingEquiv.coe_addMonoidHom_trans
code: @[simp]
theorem coe_addMonoidHom_trans [NonAssocSemiring S'] (e₁ : R ≃+* S) (e₂ : S ≃+* S') :
    (e₁.trans e₂ : R →+ S') = (e₂ : S →+ S').comp ↑e₁ 
goal: ↑(e₁.trans e₂) = (↑e₂).comp ↑e₁

full_name: RingEquiv.coe_ringHom_trans
code: @[simp]
theorem coe_ringHom_trans [NonAssocSemiring S'] (e₁ : R ≃+* S) (e₂ : S ≃+* S') :
    (e₁.trans e₂ : R →+* S') = (e₂ : S →+* S').comp ↑e₁ 
goal: ↑(e₁.trans e₂) = (↑e₂).comp ↑e₁

full_name: RingEquiv.comp_symm
code: @[simp]
theorem comp_symm (e : R ≃+* S) : (e : R →+* S).comp (e.symm : S →+* R) = RingHom.id S 
goal: (↑e).comp ↑e.symm = RingHom.id S

full_name: RingEquiv.symm_comp
code: @[simp]
theorem symm_comp (e : R ≃+* S) : (e.symm : S →+* R).comp (e : R →+* S) = RingHom.id R 
goal: (↑e.symm).comp ↑e = RingHom.id R

full_name: RingEquiv.map_neg
code: protected theorem map_neg : f (-x) = -f x 
goal: f (-x) = -f x

full_name: RingEquiv.map_sub
code: protected theorem map_sub : f (x - y) = f x - f y 
goal: f (x - y) = f x - f y

full_name: RingEquiv.map_neg_one
code: theorem map_neg_one : f (-1) = -1 
goal: f (-1) = -1

full_name: RingEquiv.map_eq_neg_one_iff
code: theorem map_eq_neg_one_iff {x : R} : f x = -1 ↔ x = -1 
goal: f x = -1 ↔ x = -1

full_name: RingEquiv.toNonUnitalRingHom
code: /-- Reinterpret a ring equivalence as a non-unital ring homomorphism. -/
def toNonUnitalRingHom (e : R ≃+* S) : R →ₙ+* S 
goal: R →ₙ+* S

full_name: RingEquiv.toNonUnitalRingHom_injective
code: theorem toNonUnitalRingHom_injective :
    Function.Injective (toNonUnitalRingHom : R ≃+* S → R →ₙ+* S) 
goal: Function.Injective RingEquiv.toNonUnitalRingHom

full_name: RingEquiv.toNonUnitalRingHom_eq_coe
code: theorem toNonUnitalRingHom_eq_coe (f : R ≃+* S) : f.toNonUnitalRingHom = ↑f 
goal: f.toNonUnitalRingHom = ↑f

full_name: RingEquiv.coe_toNonUnitalRingHom
code: @[simp, norm_cast]
theorem coe_toNonUnitalRingHom (f : R ≃+* S) : ⇑(f : R →ₙ+* S) = f 
goal: ⇑↑f = ⇑f

full_name: RingEquiv.coe_nonUnitalRingHom_inj_iff
code: theorem coe_nonUnitalRingHom_inj_iff {R S : Type*} [NonUnitalNonAssocSemiring R]
    [NonUnitalNonAssocSemiring S] (f g : R ≃+* S) : f = g ↔ (f : R →ₙ+* S) = g 
goal: f = g ↔ ↑f = ↑g

full_name: RingEquiv.toNonUnitalRingHom_refl
code: @[simp]
theorem toNonUnitalRingHom_refl :
    (RingEquiv.refl R).toNonUnitalRingHom = NonUnitalRingHom.id R 
goal: (RingEquiv.refl R).toNonUnitalRingHom = NonUnitalRingHom.id R

full_name: RingEquiv.toNonUnitalRingHom_apply_symm_toNonUnitalRingHom_apply
code: @[simp]
theorem toNonUnitalRingHom_apply_symm_toNonUnitalRingHom_apply (e : R ≃+* S) :
    ∀ y : S, e.toNonUnitalRingHom (e.symm.toNonUnitalRingHom y) = y 
goal: e.toNonUnitalRingHom (e.symm.toNonUnitalRingHom y) = y

full_name: RingEquiv.symm_toNonUnitalRingHom_apply_toNonUnitalRingHom_apply
code: @[simp]
theorem symm_toNonUnitalRingHom_apply_toNonUnitalRingHom_apply (e : R ≃+* S) :
    ∀ x : R, e.symm.toNonUnitalRingHom (e.toNonUnitalRingHom x) = x 
goal: e.symm.toNonUnitalRingHom (e.toNonUnitalRingHom x) = x

full_name: RingEquiv.toNonUnitalRingHom_trans
code: @[simp]
theorem toNonUnitalRingHom_trans (e₁ : R ≃+* S) (e₂ : S ≃+* S') :
    (e₁.trans e₂).toNonUnitalRingHom = e₂.toNonUnitalRingHom.comp e₁.toNonUnitalRingHom 
goal: (e₁.trans e₂).toNonUnitalRingHom = e₂.toNonUnitalRingHom.comp e₁.toNonUnitalRingHom

full_name: RingEquiv.toNonUnitalRingHomm_comp_symm_toNonUnitalRingHom
code: @[simp]
theorem toNonUnitalRingHomm_comp_symm_toNonUnitalRingHom (e : R ≃+* S) :
    e.toNonUnitalRingHom.comp e.symm.toNonUnitalRingHom = NonUnitalRingHom.id _ 
goal: e.toNonUnitalRingHom.comp e.symm.toNonUnitalRingHom = NonUnitalRingHom.id S

full_name: RingEquiv.symm_toNonUnitalRingHom_comp_toNonUnitalRingHom
code: @[simp]
theorem symm_toNonUnitalRingHom_comp_toNonUnitalRingHom (e : R ≃+* S) :
    e.symm.toNonUnitalRingHom.comp e.toNonUnitalRingHom = NonUnitalRingHom.id _ 
goal: e.symm.toNonUnitalRingHom.comp e.toNonUnitalRingHom = NonUnitalRingHom.id R

full_name: RingEquiv.toRingHom
code: /-- Reinterpret a ring equivalence as a ring homomorphism. -/
def toRingHom (e : R ≃+* S) : R →+* S 
goal: R →+* S

full_name: RingEquiv.toRingHom_injective
code: theorem toRingHom_injective : Function.Injective (toRingHom : R ≃+* S → R →+* S) 
goal: Function.Injective RingEquiv.toRingHom

full_name: RingEquiv.toRingHom_eq_coe
code: @[simp] theorem toRingHom_eq_coe (f : R ≃+* S) : f.toRingHom = ↑f 
goal: f.toRingHom = ↑f

full_name: RingEquiv.coe_toRingHom
code: @[simp, norm_cast]
theorem coe_toRingHom (f : R ≃+* S) : ⇑(f : R →+* S) = f 
goal: ⇑↑f = ⇑f

full_name: RingEquiv.coe_ringHom_inj_iff
code: theorem coe_ringHom_inj_iff {R S : Type*} [NonAssocSemiring R] [NonAssocSemiring S]
    (f g : R ≃+* S) : f = g ↔ (f : R →+* S) = g 
goal: f = g ↔ ↑f = ↑g

full_name: RingEquiv.toNonUnitalRingHom_commutes
code: /-- The two paths coercion can take to a `NonUnitalRingEquiv` are equivalent -/
@[simp, norm_cast]
theorem toNonUnitalRingHom_commutes (f : R ≃+* S) :
    ((f : R →+* S) : R →ₙ+* S) = (f : R →ₙ+* S) 
goal: ↑↑f = ↑f

full_name: RingEquiv.toMonoidHom
code: /-- Reinterpret a ring equivalence as a monoid homomorphism. -/
abbrev toMonoidHom (e : R ≃+* S) : R →* S 
goal: R →* S

full_name: RingEquiv.toAddMonoidHom
code: /-- Reinterpret a ring equivalence as an `AddMonoid` homomorphism. -/
abbrev toAddMonoidHom (e : R ≃+* S) : R →+ S 
goal: R →+ S

full_name: RingEquiv.toAddMonoidMom_commutes
code: /-- The two paths coercion can take to an `AddMonoidHom` are equivalent -/
theorem toAddMonoidMom_commutes (f : R ≃+* S) :
    (f : R →+* S).toAddMonoidHom = (f : R ≃+ S).toAddMonoidHom 
goal: (↑f).toAddMonoidHom = (↑f).toAddMonoidHom

full_name: RingEquiv.toMonoidHom_commutes
code: /-- The two paths coercion can take to a `MonoidHom` are equivalent -/
theorem toMonoidHom_commutes (f : R ≃+* S) :
    (f : R →+* S).toMonoidHom = (f : R ≃* S).toMonoidHom 
goal: ↑↑f = (↑f).toMonoidHom

full_name: RingEquiv.toEquiv_commutes
code: /-- The two paths coercion can take to an `Equiv` are equivalent -/
theorem toEquiv_commutes (f : R ≃+* S) : (f : R ≃+ S).toEquiv = (f : R ≃* S).toEquiv 
goal: (↑f).toEquiv = (↑f).toEquiv

full_name: RingEquiv.toRingHom_refl
code: @[simp]
theorem toRingHom_refl : (RingEquiv.refl R).toRingHom = RingHom.id R 
goal: (RingEquiv.refl R).toRingHom = RingHom.id R

full_name: RingEquiv.toMonoidHom_refl
code: @[simp]
theorem toMonoidHom_refl : (RingEquiv.refl R).toMonoidHom = MonoidHom.id R 
goal: (RingEquiv.refl R).toMonoidHom = MonoidHom.id R

full_name: RingEquiv.toAddMonoidHom_refl
code: @[simp]
theorem toAddMonoidHom_refl : (RingEquiv.refl R).toAddMonoidHom = AddMonoidHom.id R 
goal: (RingEquiv.refl R).toAddMonoidHom = AddMonoidHom.id R

full_name: RingEquiv.toRingHom_apply_symm_toRingHom_apply
code: theorem toRingHom_apply_symm_toRingHom_apply (e : R ≃+* S) :
    ∀ y : S, e.toRingHom (e.symm.toRingHom y) = y 
goal: e.toRingHom (e.symm.toRingHom y) = y

full_name: RingEquiv.symm_toRingHom_apply_toRingHom_apply
code: theorem symm_toRingHom_apply_toRingHom_apply (e : R ≃+* S) :
    ∀ x : R, e.symm.toRingHom (e.toRingHom x) = x 
goal: e.symm.toRingHom (e.toRingHom x) = x

full_name: RingEquiv.toRingHom_trans
code: @[simp]
theorem toRingHom_trans (e₁ : R ≃+* S) (e₂ : S ≃+* S') :
    (e₁.trans e₂).toRingHom = e₂.toRingHom.comp e₁.toRingHom 
goal: (e₁.trans e₂).toRingHom = e₂.toRingHom.comp e₁.toRingHom

full_name: RingEquiv.toRingHom_comp_symm_toRingHom
code: theorem toRingHom_comp_symm_toRingHom (e : R ≃+* S) :
    e.toRingHom.comp e.symm.toRingHom = RingHom.id _ 
goal: e.toRingHom.comp e.symm.toRingHom = RingHom.id S

full_name: RingEquiv.symm_toRingHom_comp_toRingHom
code: theorem symm_toRingHom_comp_toRingHom (e : R ≃+* S) :
    e.symm.toRingHom.comp e.toRingHom = RingHom.id _ 
goal: e.symm.toRingHom.comp e.toRingHom = RingHom.id R

full_name: RingEquiv.ofHomInv'_apply
code: /-- Construct an equivalence of rings from homomorphisms in both directions, which are inverses.
-/
@[simps]
def ofHomInv' {R S F G : Type*} [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S]
    [FunLike F R S] [FunLike G S R]
    [NonUnitalRingHomClass F R S] [NonUnitalRingHomClass G S R] (hom : F) (inv : G)
    (hom_inv_id : (inv : S →ₙ+* R).comp (hom : R →ₙ+* S) = NonUnitalRingHom.id R)
    (inv_hom_id : (hom : R →ₙ+* S).comp (inv : S →ₙ+* R) = NonUnitalRingHom.id S) :
    R ≃+* S 
goal: (RingEquiv.ofHomInv' hom inv hom_inv_id inv_hom_id) a = hom a

full_name: RingEquiv.ofHomInv'
code: /-- Construct an equivalence of rings from homomorphisms in both directions, which are inverses.
-/
@[simps]
def ofHomInv' {R S F G : Type*} [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S]
    [FunLike F R S] [FunLike G S R]
    [NonUnitalRingHomClass F R S] [NonUnitalRingHomClass G S R] (hom : F) (inv : G)
    (hom_inv_id : (inv : S →ₙ+* R).comp (hom : R →ₙ+* S) = NonUnitalRingHom.id R)
    (inv_hom_id : (hom : R →ₙ+* S).comp (inv : S →ₙ+* R) = NonUnitalRingHom.id S) :
    R ≃+* S 
goal: R ≃+* S

full_name: RingEquiv.ofHomInv'_symm_apply
code: /-- Construct an equivalence of rings from homomorphisms in both directions, which are inverses.
-/
@[simps]
def ofHomInv' {R S F G : Type*} [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S]
    [FunLike F R S] [FunLike G S R]
    [NonUnitalRingHomClass F R S] [NonUnitalRingHomClass G S R] (hom : F) (inv : G)
    (hom_inv_id : (inv : S →ₙ+* R).comp (hom : R →ₙ+* S) = NonUnitalRingHom.id R)
    (inv_hom_id : (hom : R →ₙ+* S).comp (inv : S →ₙ+* R) = NonUnitalRingHom.id S) :
    R ≃+* S 
goal: (RingEquiv.ofHomInv' hom inv hom_inv_id inv_hom_id).symm a = inv a

full_name: RingEquiv.ofHomInv
code: /--
Construct an equivalence of rings from unital homomorphisms in both directions, which are inverses.
-/
@[simps]
def ofHomInv {R S F G : Type*} [NonAssocSemiring R] [NonAssocSemiring S]
    [FunLike F R S] [FunLike G S R] [RingHomClass F R S]
    [RingHomClass G S R] (hom : F) (inv : G)
    (hom_inv_id : (inv : S →+* R).comp (hom : R →+* S) = RingHom.id R)
    (inv_hom_id : (hom : R →+* S).comp (inv : S →+* R) = RingHom.id S) :
    R ≃+* S 
goal: R ≃+* S

full_name: RingEquiv.ofHomInv_symm_apply
code: /--
Construct an equivalence of rings from unital homomorphisms in both directions, which are inverses.
-/
@[simps]
def ofHomInv {R S F G : Type*} [NonAssocSemiring R] [NonAssocSemiring S]
    [FunLike F R S] [FunLike G S R] [RingHomClass F R S]
    [RingHomClass G S R] (hom : F) (inv : G)
    (hom_inv_id : (inv : S →+* R).comp (hom : R →+* S) = RingHom.id R)
    (inv_hom_id : (hom : R →+* S).comp (inv : S →+* R) = RingHom.id S) :
    R ≃+* S 
goal: (RingEquiv.ofHomInv hom inv hom_inv_id inv_hom_id).symm a = inv a

full_name: RingEquiv.ofHomInv_apply
code: /--
Construct an equivalence of rings from unital homomorphisms in both directions, which are inverses.
-/
@[simps]
def ofHomInv {R S F G : Type*} [NonAssocSemiring R] [NonAssocSemiring S]
    [FunLike F R S] [FunLike G S R] [RingHomClass F R S]
    [RingHomClass G S R] (hom : F) (inv : G)
    (hom_inv_id : (inv : S →+* R).comp (hom : R →+* S) = RingHom.id R)
    (inv_hom_id : (hom : R →+* S).comp (inv : S →+* R) = RingHom.id S) :
    R ≃+* S 
goal: (RingEquiv.ofHomInv hom inv hom_inv_id inv_hom_id) a = hom a

full_name: RingEquiv.map_pow
code: protected theorem map_pow (f : R ≃+* S) (a) : ∀ n : ℕ, f (a ^ n) = f a ^ n 
goal: f (a ^ n) = f a ^ n

full_name: RingEquiv.isUnit_iff
code: protected theorem isUnit_iff (f : R ≃+* S) {a} : IsUnit (f a) ↔ IsUnit a 
goal: IsUnit (f a) ↔ IsUnit a

full_name: MulEquiv.toRingEquiv
code: /-- Gives a `RingEquiv` from an element of a `MulEquivClass` preserving addition. -/
def toRingEquiv {R S F : Type*} [Add R] [Add S] [Mul R] [Mul S] [EquivLike F R S]
    [MulEquivClass F R S] (f : F)
    (H : ∀ x y : R, f (x + y) = f x + f y) : R ≃+* S 
goal: R ≃+* S

full_name: AddEquiv.toRingEquiv
code: /-- Gives a `RingEquiv` from an element of an `AddEquivClass` preserving addition. -/
def toRingEquiv {R S F : Type*} [Add R] [Add S] [Mul R] [Mul S] [EquivLike F R S]
    [AddEquivClass F R S] (f : F)
    (H : ∀ x y : R, f (x * y) = f x * f y) : R ≃+* S 
goal: R ≃+* S

full_name: RingEquiv.self_trans_symm
code: @[simp]
theorem self_trans_symm (e : R ≃+* S) : e.trans e.symm = RingEquiv.refl R 
goal: e.trans e.symm = RingEquiv.refl R

full_name: RingEquiv.symm_trans_self
code: @[simp]
theorem symm_trans_self (e : R ≃+* S) : e.symm.trans e = RingEquiv.refl S 
goal: e.symm.trans e = RingEquiv.refl S

full_name: MulEquiv.noZeroDivisors
code: /-- If two rings are isomorphic, and the second doesn't have zero divisors,
then so does the first. -/
protected theorem noZeroDivisors {A : Type*} (B : Type*) [MulZeroClass A] [MulZeroClass B]
    [NoZeroDivisors B] (e : A ≃* B) : NoZeroDivisors A 
goal: NoZeroDivisors A

full_name: MulEquiv.isDomain
code: /-- If two rings are isomorphic, and the second is a domain, then so is the first. -/
protected theorem isDomain {A : Type*} (B : Type*) [Semiring A] [Semiring B] [IsDomain B]
    (e : A ≃* B) : IsDomain A 
goal: IsDomain A