File: Mathlib/Algebra/Ring/Opposite.lean

full_name: MulOpposite.instDistrib
code: instance instDistrib [Distrib α] : Distrib αᵐᵒᵖ 
goal: Distrib αᵐᵒᵖ

full_name: MulOpposite.instNonUnitalNonAssocSemiring
code: instance instNonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring α] :
    NonUnitalNonAssocSemiring αᵐᵒᵖ 
goal: NonUnitalNonAssocSemiring αᵐᵒᵖ

full_name: MulOpposite.instNonUnitalSemiring
code: instance instNonUnitalSemiring [NonUnitalSemiring α] : NonUnitalSemiring αᵐᵒᵖ 
goal: NonUnitalSemiring αᵐᵒᵖ

full_name: MulOpposite.instNonAssocSemiring
code: instance instNonAssocSemiring [NonAssocSemiring α] : NonAssocSemiring αᵐᵒᵖ 
goal: NonAssocSemiring αᵐᵒᵖ

full_name: MulOpposite.instSemiring
code: instance instSemiring [Semiring α] : Semiring αᵐᵒᵖ 
goal: Semiring αᵐᵒᵖ

full_name: MulOpposite.instNonUnitalCommSemiring
code: instance instNonUnitalCommSemiring [NonUnitalCommSemiring α] : NonUnitalCommSemiring αᵐᵒᵖ 
goal: NonUnitalCommSemiring αᵐᵒᵖ

full_name: MulOpposite.instCommSemiring
code: instance instCommSemiring [CommSemiring α] : CommSemiring αᵐᵒᵖ 
goal: CommSemiring αᵐᵒᵖ

full_name: MulOpposite.instNonUnitalNonAssocRing
code: instance instNonUnitalNonAssocRing [NonUnitalNonAssocRing α] : NonUnitalNonAssocRing αᵐᵒᵖ 
goal: NonUnitalNonAssocRing αᵐᵒᵖ

full_name: MulOpposite.instNonUnitalRing
code: instance instNonUnitalRing [NonUnitalRing α] : NonUnitalRing αᵐᵒᵖ 
goal: NonUnitalRing αᵐᵒᵖ

full_name: MulOpposite.instNonAssocRing
code: instance instNonAssocRing [NonAssocRing α] : NonAssocRing αᵐᵒᵖ 
goal: NonAssocRing αᵐᵒᵖ

full_name: MulOpposite.instRing
code: instance instRing [Ring α] : Ring αᵐᵒᵖ 
goal: Ring αᵐᵒᵖ

full_name: MulOpposite.instNonUnitalCommRing
code: instance instNonUnitalCommRing [NonUnitalCommRing α] : NonUnitalCommRing αᵐᵒᵖ 
goal: NonUnitalCommRing αᵐᵒᵖ

full_name: MulOpposite.instCommRing
code: instance instCommRing [CommRing α] : CommRing αᵐᵒᵖ 
goal: CommRing αᵐᵒᵖ

full_name: MulOpposite.instIsDomain
code: instance instIsDomain [Ring α] [IsDomain α] : IsDomain αᵐᵒᵖ 
goal: IsDomain αᵐᵒᵖ

full_name: MulOpposite.instGroupWithZero
code: instance instGroupWithZero [GroupWithZero α] : GroupWithZero αᵐᵒᵖ 
goal: GroupWithZero αᵐᵒᵖ

full_name: AddOpposite.instDistrib
code: instance instDistrib [Distrib α] : Distrib αᵃᵒᵖ 
goal: Distrib αᵃᵒᵖ

full_name: AddOpposite.instNonUnitalNonAssocSemiring
code: instance instNonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring α] :
    NonUnitalNonAssocSemiring αᵃᵒᵖ 
goal: NonUnitalNonAssocSemiring αᵃᵒᵖ

full_name: AddOpposite.instNonUnitalSemiring
code: instance instNonUnitalSemiring [NonUnitalSemiring α] : NonUnitalSemiring αᵃᵒᵖ 
goal: NonUnitalSemiring αᵃᵒᵖ

full_name: AddOpposite.instNonAssocSemiring
code: instance instNonAssocSemiring [NonAssocSemiring α] : NonAssocSemiring αᵃᵒᵖ 
goal: NonAssocSemiring αᵃᵒᵖ

full_name: AddOpposite.instSemiring
code: instance instSemiring [Semiring α] : Semiring αᵃᵒᵖ 
goal: Semiring αᵃᵒᵖ

full_name: AddOpposite.instNonUnitalCommSemiring
code: instance instNonUnitalCommSemiring [NonUnitalCommSemiring α] : NonUnitalCommSemiring αᵃᵒᵖ 
goal: NonUnitalCommSemiring αᵃᵒᵖ

full_name: AddOpposite.instCommSemiring
code: instance instCommSemiring [CommSemiring α] : CommSemiring αᵃᵒᵖ 
goal: CommSemiring αᵃᵒᵖ

full_name: AddOpposite.instNonUnitalNonAssocRing
code: instance instNonUnitalNonAssocRing [NonUnitalNonAssocRing α] : NonUnitalNonAssocRing αᵃᵒᵖ 
goal: NonUnitalNonAssocRing αᵃᵒᵖ

full_name: AddOpposite.instNonUnitalRing
code: instance instNonUnitalRing [NonUnitalRing α] : NonUnitalRing αᵃᵒᵖ 
goal: NonUnitalRing αᵃᵒᵖ

full_name: AddOpposite.instNonAssocRing
code: instance instNonAssocRing [NonAssocRing α] : NonAssocRing αᵃᵒᵖ 
goal: NonAssocRing αᵃᵒᵖ

full_name: AddOpposite.instRing
code: instance instRing [Ring α] : Ring αᵃᵒᵖ 
goal: Ring αᵃᵒᵖ

full_name: AddOpposite.instNonUnitalCommRing
code: instance instNonUnitalCommRing [NonUnitalCommRing α] : NonUnitalCommRing αᵃᵒᵖ 
goal: NonUnitalCommRing αᵃᵒᵖ

full_name: AddOpposite.instCommRing
code: instance instCommRing [CommRing α] : CommRing αᵃᵒᵖ 
goal: CommRing αᵃᵒᵖ

full_name: AddOpposite.instIsDomain
code: instance instIsDomain [Ring α] [IsDomain α] : IsDomain αᵃᵒᵖ 
goal: IsDomain αᵃᵒᵖ

full_name: NonUnitalRingHom.toOpposite
code: /-- A non-unital ring homomorphism `f : R →ₙ+* S` such that `f x` commutes with `f y` for all `x, y`
defines a non-unital ring homomorphism to `Sᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def NonUnitalRingHom.toOpposite {R S : Type*} [NonUnitalNonAssocSemiring R]
    [NonUnitalNonAssocSemiring S] (f : R →ₙ+* S) (hf : ∀ x y, Commute (f x) (f y)) : R →ₙ+* Sᵐᵒᵖ 
goal: R →ₙ+* Sᵐᵒᵖ

full_name: NonUnitalRingHom.toOpposite_apply
code: /-- A non-unital ring homomorphism `f : R →ₙ+* S` such that `f x` commutes with `f y` for all `x, y`
defines a non-unital ring homomorphism to `Sᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def NonUnitalRingHom.toOpposite {R S : Type*} [NonUnitalNonAssocSemiring R]
    [NonUnitalNonAssocSemiring S] (f : R →ₙ+* S) (hf : ∀ x y, Commute (f x) (f y)) : R →ₙ+* Sᵐᵒᵖ 
goal: ⇑(f.toOpposite hf) = MulOpposite.op ∘ ⇑f

full_name: NonUnitalRingHom.fromOpposite
code: /-- A non-unital ring homomorphism `f : R →ₙ* S` such that `f x` commutes with `f y` for all `x, y`
defines a non-unital ring homomorphism from `Rᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def NonUnitalRingHom.fromOpposite {R S : Type*} [NonUnitalNonAssocSemiring R]
    [NonUnitalNonAssocSemiring S] (f : R →ₙ+* S) (hf : ∀ x y, Commute (f x) (f y)) : Rᵐᵒᵖ →ₙ+* S 
goal: Rᵐᵒᵖ →ₙ+* S

full_name: NonUnitalRingHom.fromOpposite_apply
code: /-- A non-unital ring homomorphism `f : R →ₙ* S` such that `f x` commutes with `f y` for all `x, y`
defines a non-unital ring homomorphism from `Rᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def NonUnitalRingHom.fromOpposite {R S : Type*} [NonUnitalNonAssocSemiring R]
    [NonUnitalNonAssocSemiring S] (f : R →ₙ+* S) (hf : ∀ x y, Commute (f x) (f y)) : Rᵐᵒᵖ →ₙ+* S 
goal: ⇑(f.fromOpposite hf) = ⇑f ∘ MulOpposite.unop

full_name: NonUnitalRingHom.op
code: /-- A non-unital ring hom `α →ₙ+* β` can equivalently be viewed as a non-unital ring hom
`αᵐᵒᵖ →+* βᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps]
def NonUnitalRingHom.op {α β} [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β] :
    (α →ₙ+* β) ≃ (αᵐᵒᵖ →ₙ+* βᵐᵒᵖ) 
goal: (α →ₙ+* β) ≃ (αᵐᵒᵖ →ₙ+* βᵐᵒᵖ)

full_name: NonUnitalRingHom.op_symm_apply_apply
code: /-- A non-unital ring hom `α →ₙ+* β` can equivalently be viewed as a non-unital ring hom
`αᵐᵒᵖ →+* βᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps]
def NonUnitalRingHom.op {α β} [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β] :
    (α →ₙ+* β) ≃ (αᵐᵒᵖ →ₙ+* βᵐᵒᵖ) 
goal: ∀ (a : α), (NonUnitalRingHom.op.symm f) a = (↑(AddMonoidHom.mulUnop f.toAddMonoidHom)).toFun a

full_name: NonUnitalRingHom.op_apply_apply
code: /-- A non-unital ring hom `α →ₙ+* β` can equivalently be viewed as a non-unital ring hom
`αᵐᵒᵖ →+* βᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps]
def NonUnitalRingHom.op {α β} [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β] :
    (α →ₙ+* β) ≃ (αᵐᵒᵖ →ₙ+* βᵐᵒᵖ) 
goal: ∀ (a : αᵐᵒᵖ), (NonUnitalRingHom.op f) a = (↑(AddMonoidHom.mulOp f.toAddMonoidHom)).toFun a

full_name: NonUnitalRingHom.unop
code: /-- The 'unopposite' of a non-unital ring hom `αᵐᵒᵖ →ₙ+* βᵐᵒᵖ`. Inverse to
`NonUnitalRingHom.op`. -/
@[simp]
def NonUnitalRingHom.unop {α β} [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β] :
    (αᵐᵒᵖ →ₙ+* βᵐᵒᵖ) ≃ (α →ₙ+* β) 
goal: (αᵐᵒᵖ →ₙ+* βᵐᵒᵖ) ≃ (α →ₙ+* β)

full_name: RingHom.toOpposite_apply
code: /-- A ring homomorphism `f : R →+* S` such that `f x` commutes with `f y` for all `x, y` defines
a ring homomorphism to `Sᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def RingHom.toOpposite {R S : Type*} [Semiring R] [Semiring S] (f : R →+* S)
    (hf : ∀ x y, Commute (f x) (f y)) : R →+* Sᵐᵒᵖ 
goal: ⇑(f.toOpposite hf) = MulOpposite.op ∘ ⇑f

full_name: RingHom.toOpposite
code: /-- A ring homomorphism `f : R →+* S` such that `f x` commutes with `f y` for all `x, y` defines
a ring homomorphism to `Sᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def RingHom.toOpposite {R S : Type*} [Semiring R] [Semiring S] (f : R →+* S)
    (hf : ∀ x y, Commute (f x) (f y)) : R →+* Sᵐᵒᵖ 
goal: R →+* Sᵐᵒᵖ

full_name: RingHom.fromOpposite_apply
code: /-- A ring homomorphism `f : R →+* S` such that `f x` commutes with `f y` for all `x, y` defines
a ring homomorphism from `Rᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def RingHom.fromOpposite {R S : Type*} [Semiring R] [Semiring S] (f : R →+* S)
    (hf : ∀ x y, Commute (f x) (f y)) : Rᵐᵒᵖ →+* S 
goal: ⇑(f.fromOpposite hf) = ⇑f ∘ MulOpposite.unop

full_name: RingHom.fromOpposite
code: /-- A ring homomorphism `f : R →+* S` such that `f x` commutes with `f y` for all `x, y` defines
a ring homomorphism from `Rᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def RingHom.fromOpposite {R S : Type*} [Semiring R] [Semiring S] (f : R →+* S)
    (hf : ∀ x y, Commute (f x) (f y)) : Rᵐᵒᵖ →+* S 
goal: Rᵐᵒᵖ →+* S

full_name: RingHom.op
code: /-- A ring hom `α →+* β` can equivalently be viewed as a ring hom `αᵐᵒᵖ →+* βᵐᵒᵖ`. This is the
action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
def RingHom.op {α β} [NonAssocSemiring α] [NonAssocSemiring β] :
    (α →+* β) ≃ (αᵐᵒᵖ →+* βᵐᵒᵖ) 
goal: (α →+* β) ≃ (αᵐᵒᵖ →+* βᵐᵒᵖ)

full_name: RingHom.op_symm_apply_apply
code: /-- A ring hom `α →+* β` can equivalently be viewed as a ring hom `αᵐᵒᵖ →+* βᵐᵒᵖ`. This is the
action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
def RingHom.op {α β} [NonAssocSemiring α] [NonAssocSemiring β] :
    (α →+* β) ≃ (αᵐᵒᵖ →+* βᵐᵒᵖ) 
goal: ∀ (a : α), (RingHom.op.symm f) a = MulOpposite.unop (f (MulOpposite.op a))

full_name: RingHom.op_apply_apply
code: /-- A ring hom `α →+* β` can equivalently be viewed as a ring hom `αᵐᵒᵖ →+* βᵐᵒᵖ`. This is the
action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
def RingHom.op {α β} [NonAssocSemiring α] [NonAssocSemiring β] :
    (α →+* β) ≃ (αᵐᵒᵖ →+* βᵐᵒᵖ) 
goal: ∀ (a : αᵐᵒᵖ), (RingHom.op f) a = MulOpposite.op (f (MulOpposite.unop a))

full_name: RingHom.unop
code: /-- The 'unopposite' of a ring hom `αᵐᵒᵖ →+* βᵐᵒᵖ`. Inverse to `RingHom.op`. -/
@[simp]
def RingHom.unop {α β} [NonAssocSemiring α] [NonAssocSemiring β] : (αᵐᵒᵖ →+* βᵐᵒᵖ) ≃ (α →+* β) 
goal: (αᵐᵒᵖ →+* βᵐᵒᵖ) ≃ (α →+* β)