File: Mathlib/Algebra/Algebra/Opposite.lean

full_name: MulOpposite.instAlgebra
code: instance instAlgebra : Algebra R Aᵐᵒᵖ 
goal: Algebra R Aᵐᵒᵖ

full_name: MulOpposite.algebraMap_apply
code: @[simp]
theorem algebraMap_apply (c : R) : algebraMap R Aᵐᵒᵖ c = op (algebraMap R A c) 
goal: (algebraMap R Aᵐᵒᵖ) c = MulOpposite.op ((algebraMap R A) c)

full_name: AlgEquiv.opOp
code: /-- An algebra is isomorphic to the opposite of its opposite. -/
@[simps!]
def opOp : A ≃ₐ[R] Aᵐᵒᵖᵐᵒᵖ 
goal: A ≃ₐ[R] Aᵐᵒᵖᵐᵒᵖ

full_name: AlgEquiv.opOp_apply
code: /-- An algebra is isomorphic to the opposite of its opposite. -/
@[simps!]
def opOp : A ≃ₐ[R] Aᵐᵒᵖᵐᵒᵖ 
goal: ∀ (a : A), (AlgEquiv.opOp R A) a = MulOpposite.op (MulOpposite.op a)

full_name: AlgEquiv.opOp_symm_apply
code: /-- An algebra is isomorphic to the opposite of its opposite. -/
@[simps!]
def opOp : A ≃ₐ[R] Aᵐᵒᵖᵐᵒᵖ 
goal: ∀ (a : Aᵐᵒᵖᵐᵒᵖ), (AlgEquiv.opOp R A).symm a = MulOpposite.unop (MulOpposite.unop a)

full_name: AlgEquiv.toRingEquiv_opOp
code: @[simp] theorem toRingEquiv_opOp : (opOp R A : A ≃+* Aᵐᵒᵖᵐᵒᵖ) = RingEquiv.opOp A 
goal: ↑(AlgEquiv.opOp R A) = RingEquiv.opOp A

full_name: AlgHom.fromOpposite_apply
code: /--
An algebra homomorphism `f : A →ₐ[R] B` such that `f x` commutes with `f y` for all `x, y` defines
an algebra homomorphism from `Aᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def fromOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) : Aᵐᵒᵖ →ₐ[R] B 
goal: ⇑(f.fromOpposite hf) = ⇑f ∘ MulOpposite.unop

full_name: AlgHom.fromOpposite
code: /--
An algebra homomorphism `f : A →ₐ[R] B` such that `f x` commutes with `f y` for all `x, y` defines
an algebra homomorphism from `Aᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def fromOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) : Aᵐᵒᵖ →ₐ[R] B 
goal: Aᵐᵒᵖ →ₐ[R] B

full_name: AlgHom.toLinearMap_fromOpposite
code: @[simp]
theorem toLinearMap_fromOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) :
    (f.fromOpposite hf).toLinearMap = f.toLinearMap ∘ₗ (opLinearEquiv R (M := A)).symm 
goal: (f.fromOpposite hf).toLinearMap = f.toLinearMap ∘ₗ ↑(MulOpposite.opLinearEquiv R).symm

full_name: AlgHom.toRingHom_fromOpposite
code: @[simp]
theorem toRingHom_fromOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) :
    (f.fromOpposite hf : Aᵐᵒᵖ →+* B) = (f : A →+* B).fromOpposite hf 
goal: ↑(f.fromOpposite hf) = (↑f).fromOpposite hf

full_name: AlgHom.toOpposite
code: /--
An algebra homomorphism `f : A →ₐ[R] B` such that `f x` commutes with `f y` for all `x, y` defines
an algebra homomorphism to `Bᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def toOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) : A →ₐ[R] Bᵐᵒᵖ 
goal: A →ₐ[R] Bᵐᵒᵖ

full_name: AlgHom.toOpposite_apply
code: /--
An algebra homomorphism `f : A →ₐ[R] B` such that `f x` commutes with `f y` for all `x, y` defines
an algebra homomorphism to `Bᵐᵒᵖ`. -/
@[simps (config := .asFn)]
def toOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) : A →ₐ[R] Bᵐᵒᵖ 
goal: ⇑(f.toOpposite hf) = MulOpposite.op ∘ ⇑f

full_name: AlgHom.toLinearMap_toOpposite
code: @[simp]
theorem toLinearMap_toOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) :
    (f.toOpposite hf).toLinearMap = (opLinearEquiv R : B ≃ₗ[R] Bᵐᵒᵖ) ∘ₗ f.toLinearMap 
goal: (f.toOpposite hf).toLinearMap = ↑(MulOpposite.opLinearEquiv R) ∘ₗ f.toLinearMap

full_name: AlgHom.toRingHom_toOpposite
code: @[simp]
theorem toRingHom_toOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) :
    (f.toOpposite hf : A →+* Bᵐᵒᵖ) = (f : A →+* B).toOpposite hf 
goal: ↑(f.toOpposite hf) = (↑f).toOpposite hf

full_name: AlgHom.op_apply_apply
code: /-- An algebra hom `A →ₐ[R] B` can equivalently be viewed as an algebra hom `Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ`.
This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
protected def op : (A →ₐ[R] B) ≃ (Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ) 
goal: ∀ (a : Aᵐᵒᵖ), (AlgHom.op f) a = MulOpposite.op (f (MulOpposite.unop a))

full_name: AlgHom.op_symm_apply_apply
code: /-- An algebra hom `A →ₐ[R] B` can equivalently be viewed as an algebra hom `Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ`.
This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
protected def op : (A →ₐ[R] B) ≃ (Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ) 
goal: ∀ (a : A), (AlgHom.op.symm f) a = MulOpposite.unop (f (MulOpposite.op a))

full_name: AlgHom.op
code: /-- An algebra hom `A →ₐ[R] B` can equivalently be viewed as an algebra hom `Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ`.
This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
protected def op : (A →ₐ[R] B) ≃ (Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ) 
goal: (A →ₐ[R] B) ≃ (Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ)

full_name: AlgHom.toRingHom_op
code: theorem toRingHom_op (f : A →ₐ[R] B) : f.op.toRingHom = RingHom.op f.toRingHom 
goal: (AlgHom.op f).toRingHom = RingHom.op f.toRingHom

full_name: AlgHom.unop
code: /-- The 'unopposite' of an algebra hom `Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ`. Inverse to `RingHom.op`. -/
abbrev unop : (Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ) ≃ (A →ₐ[R] B) 
goal: (Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ) ≃ (A →ₐ[R] B)

full_name: AlgHom.toRingHom_unop
code: theorem toRingHom_unop (f : Aᵐᵒᵖ →ₐ[R] Bᵐᵒᵖ) : f.unop.toRingHom = RingHom.unop f.toRingHom 
goal: (AlgHom.unop f).toRingHom = RingHom.unop f.toRingHom

full_name: AlgHom.opComm_symm_apply_apply
code: /-- Swap the `ᵐᵒᵖ` on an algebra hom to the opposite side. -/
@[simps!]
def opComm : (A →ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ →ₐ[R] B) 
goal: ∀ (a : Aᵐᵒᵖ →ₐ[R] B) (a_1 : A), (AlgHom.opComm.symm a) a_1 = MulOpposite.op (a (MulOpposite.op a_1))

full_name: AlgHom.opComm
code: /-- Swap the `ᵐᵒᵖ` on an algebra hom to the opposite side. -/
@[simps!]
def opComm : (A →ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ →ₐ[R] B) 
goal: (A →ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ →ₐ[R] B)

full_name: AlgHom.opComm_apply_apply
code: /-- Swap the `ᵐᵒᵖ` on an algebra hom to the opposite side. -/
@[simps!]
def opComm : (A →ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ →ₐ[R] B) 
goal: ∀ (a : A →ₐ[R] Bᵐᵒᵖ) (a_1 : Aᵐᵒᵖ), (AlgHom.opComm a) a_1 = MulOpposite.unop (a (MulOpposite.unop a_1))

full_name: AlgEquiv.op_apply_apply
code: /-- An algebra iso `A ≃ₐ[R] B` can equivalently be viewed as an algebra iso `Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ`.
This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
def op : (A ≃ₐ[R] B) ≃ Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ 
goal: ∀ (a : Aᵐᵒᵖ), (AlgEquiv.op f) a = MulOpposite.op (f (MulOpposite.unop a))

full_name: AlgEquiv.op_symm_apply_apply
code: /-- An algebra iso `A ≃ₐ[R] B` can equivalently be viewed as an algebra iso `Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ`.
This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
def op : (A ≃ₐ[R] B) ≃ Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ 
goal: ∀ (a : A), (AlgEquiv.op.symm f) a = MulOpposite.unop (f (MulOpposite.op a))

full_name: AlgEquiv.op_apply_symm_apply
code: /-- An algebra iso `A ≃ₐ[R] B` can equivalently be viewed as an algebra iso `Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ`.
This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
def op : (A ≃ₐ[R] B) ≃ Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ 
goal: ∀ (a : Bᵐᵒᵖ), (AlgEquiv.op f).symm a = MulOpposite.op ((↑↑f).symm (MulOpposite.unop a))

full_name: AlgEquiv.op_symm_apply_symm_apply
code: /-- An algebra iso `A ≃ₐ[R] B` can equivalently be viewed as an algebra iso `Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ`.
This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
def op : (A ≃ₐ[R] B) ≃ Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ 
goal: ∀ (a : B), (AlgEquiv.op.symm f).symm a = MulOpposite.unop ((↑↑f).symm (MulOpposite.op a))

full_name: AlgEquiv.op
code: /-- An algebra iso `A ≃ₐ[R] B` can equivalently be viewed as an algebra iso `Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ`.
This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[simps!]
def op : (A ≃ₐ[R] B) ≃ Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ 
goal: (A ≃ₐ[R] B) ≃ Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ

full_name: AlgEquiv.toAlgHom_op
code: theorem toAlgHom_op (f : A ≃ₐ[R] B) :
    (AlgEquiv.op f).toAlgHom = AlgHom.op f.toAlgHom 
goal: ↑(AlgEquiv.op f) = AlgHom.op ↑f

full_name: AlgEquiv.toRingEquiv_op
code: theorem toRingEquiv_op (f : A ≃ₐ[R] B) :
    (AlgEquiv.op f).toRingEquiv = RingEquiv.op f.toRingEquiv 
goal: (AlgEquiv.op f).toRingEquiv = RingEquiv.op f.toRingEquiv

full_name: AlgEquiv.unop
code: /-- The 'unopposite' of an algebra iso `Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ`. Inverse to `AlgEquiv.op`. -/
abbrev unop : (Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ) ≃ A ≃ₐ[R] B 
goal: (Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ) ≃ A ≃ₐ[R] B

full_name: AlgEquiv.toAlgHom_unop
code: theorem toAlgHom_unop (f : Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ) : f.unop.toAlgHom = AlgHom.unop f.toAlgHom 
goal: ↑(AlgEquiv.unop f) = AlgHom.unop ↑f

full_name: AlgEquiv.toRingEquiv_unop
code: theorem toRingEquiv_unop (f : Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ) :
    (AlgEquiv.unop f).toRingEquiv = RingEquiv.unop f.toRingEquiv 
goal: (AlgEquiv.unop f).toRingEquiv = RingEquiv.unop f.toRingEquiv

full_name: AlgEquiv.opComm_apply_apply
code: /-- Swap the `ᵐᵒᵖ` on an algebra isomorphism to the opposite side. -/
@[simps!]
def opComm : (A ≃ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ ≃ₐ[R] B) 
goal: ∀ (a : A ≃ₐ[R] Bᵐᵒᵖ) (a_1 : Aᵐᵒᵖ), (AlgEquiv.opComm a) a_1 = MulOpposite.unop (a (MulOpposite.unop a_1))

full_name: AlgEquiv.opComm_symm_apply_symm_apply
code: /-- Swap the `ᵐᵒᵖ` on an algebra isomorphism to the opposite side. -/
@[simps!]
def opComm : (A ≃ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ ≃ₐ[R] B) 
goal: ∀ (a : Aᵐᵒᵖ ≃ₐ[R] B) (a_1 : Bᵐᵒᵖ),
  (AlgEquiv.opComm.symm a).symm a_1 =
    MulOpposite.unop ((↑↑(AlgEquiv.refl.trans (a.trans (AlgEquiv.opOp R B)))).symm (MulOpposite.op a_1))

full_name: AlgEquiv.opComm_apply_symm_apply
code: /-- Swap the `ᵐᵒᵖ` on an algebra isomorphism to the opposite side. -/
@[simps!]
def opComm : (A ≃ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ ≃ₐ[R] B) 
goal: ∀ (a : A ≃ₐ[R] Bᵐᵒᵖ) (a_1 : B),
  (AlgEquiv.opComm a).symm a_1 = (↑↑AlgEquiv.refl).symm ((↑↑((AlgEquiv.op a).trans (AlgEquiv.opOp R B).symm)).symm a_1)

full_name: AlgEquiv.opComm_symm_apply_apply
code: /-- Swap the `ᵐᵒᵖ` on an algebra isomorphism to the opposite side. -/
@[simps!]
def opComm : (A ≃ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ ≃ₐ[R] B) 
goal: ∀ (a : Aᵐᵒᵖ ≃ₐ[R] B) (a_1 : A), (AlgEquiv.opComm.symm a) a_1 = MulOpposite.op (a (MulOpposite.op a_1))

full_name: AlgEquiv.opComm
code: /-- Swap the `ᵐᵒᵖ` on an algebra isomorphism to the opposite side. -/
@[simps!]
def opComm : (A ≃ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ ≃ₐ[R] B) 
goal: (A ≃ₐ[R] Bᵐᵒᵖ) ≃ Aᵐᵒᵖ ≃ₐ[R] B

full_name: AlgEquiv.toOpposite_apply
code: /-- A commutative algebra is isomorphic to its opposite. -/
@[simps!]
def toOpposite : A ≃ₐ[R] Aᵐᵒᵖ 
goal: ∀ (a : A), (AlgEquiv.toOpposite R A) a = MulOpposite.op a

full_name: AlgEquiv.toOpposite_symm_apply
code: /-- A commutative algebra is isomorphic to its opposite. -/
@[simps!]
def toOpposite : A ≃ₐ[R] Aᵐᵒᵖ 
goal: ∀ (a : Aᵐᵒᵖ), (AlgEquiv.toOpposite R A).symm a = MulOpposite.unop a

full_name: AlgEquiv.toOpposite
code: /-- A commutative algebra is isomorphic to its opposite. -/
@[simps!]
def toOpposite : A ≃ₐ[R] Aᵐᵒᵖ 
goal: A ≃ₐ[R] Aᵐᵒᵖ

full_name: AlgEquiv.toRingEquiv_toOpposite
code: @[simp] lemma toRingEquiv_toOpposite : (toOpposite R A : A ≃+* Aᵐᵒᵖ) = RingEquiv.toOpposite A 
goal: ↑(AlgEquiv.toOpposite R A) = RingEquiv.toOpposite A

full_name: AlgEquiv.toLinearEquiv_toOpposite
code: @[simp] lemma toLinearEquiv_toOpposite : toLinearEquiv (toOpposite R A) = opLinearEquiv R 
goal: (AlgEquiv.toOpposite R A).toLinearEquiv = MulOpposite.opLinearEquiv R