File: Mathlib/Algebra/Ring/Subring/MulOpposite.lean

full_name: Subring.op_toSubsemiring
code: /-- Pull a subring back to an opposite subring along `MulOpposite.unop` -/
@[simps toSubsemiring]
protected def op (S : Subring R) : Subring Rᵐᵒᵖ 
goal: S.op.toSubsemiring = S.op

full_name: Subring.op
code: /-- Pull a subring back to an opposite subring along `MulOpposite.unop` -/
@[simps toSubsemiring]
protected def op (S : Subring R) : Subring Rᵐᵒᵖ 
goal: Subring Rᵐᵒᵖ

full_name: Subring.op_coe
code: @[simp, norm_cast]
theorem op_coe (S : Subring R) : S.op = MulOpposite.unop ⁻¹' (S : Set R) 
goal: ↑S.op = MulOpposite.unop ⁻¹' ↑S

full_name: Subring.mem_op
code: @[simp]
theorem mem_op {x : Rᵐᵒᵖ} {S : Subring R} : x ∈ S.op ↔ x.unop ∈ S 
goal: x ∈ S.op ↔ MulOpposite.unop x ∈ S

full_name: Subring.unop
code: /-- Pull an opposite subring back to a subring along `MulOpposite.op` -/
@[simps toSubsemiring]
protected def unop (S : Subring Rᵐᵒᵖ) : Subring R 
goal: Subring R

full_name: Subring.unop_toSubsemiring
code: /-- Pull an opposite subring back to a subring along `MulOpposite.op` -/
@[simps toSubsemiring]
protected def unop (S : Subring Rᵐᵒᵖ) : Subring R 
goal: S.unop.toSubsemiring = S.unop

full_name: Subring.unop_coe
code: @[simp, norm_cast]
theorem unop_coe (S : Subring Rᵐᵒᵖ) : S.unop = MulOpposite.op ⁻¹' (S : Set Rᵐᵒᵖ) 
goal: ↑S.unop = MulOpposite.op ⁻¹' ↑S

full_name: Subring.mem_unop
code: @[simp]
theorem mem_unop {x : R} {S : Subring Rᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S 
goal: x ∈ S.unop ↔ MulOpposite.op x ∈ S

full_name: Subring.unop_op
code: @[simp]
theorem unop_op (S : Subring R) : S.op.unop = S 
goal: S.op.unop = S

full_name: Subring.op_unop
code: @[simp]
theorem op_unop (S : Subring Rᵐᵒᵖ) : S.unop.op = S 
goal: S.unop.op = S

full_name: Subring.op_le_iff
code: theorem op_le_iff {S₁ : Subring R} {S₂ : Subring Rᵐᵒᵖ} : S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop 
goal: S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop

full_name: Subring.le_op_iff
code: theorem le_op_iff {S₁ : Subring Rᵐᵒᵖ} {S₂ : Subring R} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ 
goal: S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂

full_name: Subring.op_le_op_iff
code: @[simp]
theorem op_le_op_iff {S₁ S₂ : Subring R} : S₁.op ≤ S₂.op ↔ S₁ ≤ S₂ 
goal: S₁.op ≤ S₂.op ↔ S₁ ≤ S₂

full_name: Subring.unop_le_unop_iff
code: @[simp]
theorem unop_le_unop_iff {S₁ S₂ : Subring Rᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂ 
goal: S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂

full_name: Subring.opEquiv_apply
code: /-- A subring `S` of `R` determines a subring `S.op` of the opposite ring `Rᵐᵒᵖ`. -/
@[simps]
def opEquiv : Subring R ≃o Subring Rᵐᵒᵖ 
goal: Subring.opEquiv S = S.op

full_name: Subring.opEquiv
code: /-- A subring `S` of `R` determines a subring `S.op` of the opposite ring `Rᵐᵒᵖ`. -/
@[simps]
def opEquiv : Subring R ≃o Subring Rᵐᵒᵖ 
goal: Subring R ≃o Subring Rᵐᵒᵖ

full_name: Subring.opEquiv_symm_apply
code: /-- A subring `S` of `R` determines a subring `S.op` of the opposite ring `Rᵐᵒᵖ`. -/
@[simps]
def opEquiv : Subring R ≃o Subring Rᵐᵒᵖ 
goal: (RelIso.symm Subring.opEquiv) S = S.unop

full_name: Subring.op_bot
code: @[simp]
theorem op_bot : (⊥ : Subring R).op = ⊥ 
goal: ⊥.op = ⊥

full_name: Subring.unop_bot
code: @[simp]
theorem unop_bot : (⊥ : Subring Rᵐᵒᵖ).unop = ⊥ 
goal: ⊥.unop = ⊥

full_name: Subring.op_top
code: @[simp]
theorem op_top : (⊤ : Subring R).op = ⊤ 
goal: ⊤.op = ⊤

full_name: Subring.unop_top
code: @[simp]
theorem unop_top : (⊤ : Subring Rᵐᵒᵖ).unop = ⊤ 
goal: ⊤.unop = ⊤

full_name: Subring.op_sup
code: theorem op_sup (S₁ S₂ : Subring R) : (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op 
goal: (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op

full_name: Subring.unop_sup
code: theorem unop_sup (S₁ S₂ : Subring Rᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop 
goal: (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop

full_name: Subring.op_inf
code: theorem op_inf (S₁ S₂ : Subring R) : (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op 
goal: (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op

full_name: Subring.unop_inf
code: theorem unop_inf (S₁ S₂ : Subring Rᵐᵒᵖ) : (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop 
goal: (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop

full_name: Subring.op_sSup
code: theorem op_sSup (S : Set (Subring R)) : (sSup S).op = sSup (.unop ⁻¹' S) 
goal: (sSup S).op = sSup (Subring.unop ⁻¹' S)

full_name: Subring.unop_sSup
code: theorem unop_sSup (S : Set (Subring Rᵐᵒᵖ)) : (sSup S).unop = sSup (.op ⁻¹' S) 
goal: (sSup S).unop = sSup (Subring.op ⁻¹' S)

full_name: Subring.op_sInf
code: theorem op_sInf (S : Set (Subring R)) : (sInf S).op = sInf (.unop ⁻¹' S) 
goal: (sInf S).op = sInf (Subring.unop ⁻¹' S)

full_name: Subring.unop_sInf
code: theorem unop_sInf (S : Set (Subring Rᵐᵒᵖ)) : (sInf S).unop = sInf (.op ⁻¹' S) 
goal: (sInf S).unop = sInf (Subring.op ⁻¹' S)

full_name: Subring.op_iSup
code: theorem op_iSup (S : ι → Subring R) : (iSup S).op = ⨆ i, (S i).op 
goal: (iSup S).op = ⨆ i, (S i).op

full_name: Subring.unop_iSup
code: theorem unop_iSup (S : ι → Subring Rᵐᵒᵖ) : (iSup S).unop = ⨆ i, (S i).unop 
goal: (iSup S).unop = ⨆ i, (S i).unop

full_name: Subring.op_iInf
code: theorem op_iInf (S : ι → Subring R) : (iInf S).op = ⨅ i, (S i).op 
goal: (iInf S).op = ⨅ i, (S i).op

full_name: Subring.unop_iInf
code: theorem unop_iInf (S : ι → Subring Rᵐᵒᵖ) : (iInf S).unop = ⨅ i, (S i).unop 
goal: (iInf S).unop = ⨅ i, (S i).unop

full_name: Subring.op_closure
code: theorem op_closure (s : Set R) : (closure s).op = closure (MulOpposite.unop ⁻¹' s) 
goal: (Subring.closure s).op = Subring.closure (MulOpposite.unop ⁻¹' s)

full_name: Subring.unop_closure
code: theorem unop_closure (s : Set Rᵐᵒᵖ) : (closure s).unop = closure (MulOpposite.op ⁻¹' s) 
goal: (Subring.closure s).unop = Subring.closure (MulOpposite.op ⁻¹' s)

full_name: Subring.addEquivOp_symm_apply_coe
code: /-- Bijection between a subring `S` and its opposite. -/
@[simps!]
def addEquivOp (S : Subring R) : S ≃+ S.op 
goal: ↑(S.addEquivOp.symm b) = MulOpposite.unop ↑b

full_name: Subring.addEquivOp
code: /-- Bijection between a subring `S` and its opposite. -/
@[simps!]
def addEquivOp (S : Subring R) : S ≃+ S.op 
goal: ↥S ≃+ ↥S.op

full_name: Subring.addEquivOp_apply_coe
code: /-- Bijection between a subring `S` and its opposite. -/
@[simps!]
def addEquivOp (S : Subring R) : S ≃+ S.op 
goal: ↑(S.addEquivOp a) = MulOpposite.op ↑a

full_name: Subring.ringEquivOpMop_apply
code: /-- Bijection between a subring `S` and `MulOpposite` of its opposite. -/
@[simps!]
def ringEquivOpMop (S : Subring R) : S ≃+* (S.op)ᵐᵒᵖ 
goal: ∀ (a : ↥S.toSubsemiring), S.ringEquivOpMop a = MulOpposite.op (S.addEquivOp a)

full_name: Subring.ringEquivOpMop_symm_apply_coe
code: /-- Bijection between a subring `S` and `MulOpposite` of its opposite. -/
@[simps!]
def ringEquivOpMop (S : Subring R) : S ≃+* (S.op)ᵐᵒᵖ 
goal: ∀ (a : (↥S.op)ᵐᵒᵖ), ↑(S.ringEquivOpMop.symm a) = MulOpposite.unop ↑(MulOpposite.unop a)

full_name: Subring.ringEquivOpMop
code: /-- Bijection between a subring `S` and `MulOpposite` of its opposite. -/
@[simps!]
def ringEquivOpMop (S : Subring R) : S ≃+* (S.op)ᵐᵒᵖ 
goal: ↥S ≃+* (↥S.op)ᵐᵒᵖ

full_name: Subring.mopRingEquivOp
code: /-- Bijection between `MulOpposite` of a subring `S` and its opposite. -/
@[simps!]
def mopRingEquivOp (S : Subring R) : Sᵐᵒᵖ ≃+* S.op 
goal: (↥S)ᵐᵒᵖ ≃+* ↥S.op

full_name: Subring.mopRingEquivOp_apply_coe
code: /-- Bijection between `MulOpposite` of a subring `S` and its opposite. -/
@[simps!]
def mopRingEquivOp (S : Subring R) : Sᵐᵒᵖ ≃+* S.op 
goal: ∀ (a : (↥S.toSubsemiring)ᵐᵒᵖ), ↑(S.mopRingEquivOp a) = MulOpposite.op ↑(MulOpposite.unop a)

full_name: Subring.mopRingEquivOp_symm_apply
code: /-- Bijection between `MulOpposite` of a subring `S` and its opposite. -/
@[simps!]
def mopRingEquivOp (S : Subring R) : Sᵐᵒᵖ ≃+* S.op 
goal: ∀ (a : ↥S.op), S.mopRingEquivOp.symm a = MulOpposite.op (S.addEquivOp.symm a)