File: Mathlib/Algebra/Group/Submonoid/MulOpposite.lean

full_name: Submonoid.op
code: /-- Pull a submonoid back to an opposite submonoid along `MulOpposite.unop`-/
@[to_additive (attr := simps) "Pull an additive submonoid back to an opposite submonoid along
`AddOpposite.unop`"]
protected def op (x : Submonoid M) : Submonoid Mᵐᵒᵖ 
goal: Submonoid Mᵐᵒᵖ

full_name: AddSubmonoid.op_coe
code: /-- Pull a submonoid back to an opposite submonoid along `MulOpposite.unop`-/
@[to_additive (attr := simps) "Pull an additive submonoid back to an opposite submonoid along
`AddOpposite.unop`"]
protected def op (x : Submonoid M) : Submonoid Mᵐᵒᵖ 
goal: ↑x.op = AddOpposite.unop ⁻¹' ↑x

full_name: Submonoid.op_coe
code: /-- Pull a submonoid back to an opposite submonoid along `MulOpposite.unop`-/
@[to_additive (attr := simps) "Pull an additive submonoid back to an opposite submonoid along
`AddOpposite.unop`"]
protected def op (x : Submonoid M) : Submonoid Mᵐᵒᵖ 
goal: ↑x.op = MulOpposite.unop ⁻¹' ↑x

full_name: AddSubmonoid.op
code: /-- Pull a submonoid back to an opposite submonoid along `MulOpposite.unop`-/
@[to_additive (attr := simps) "Pull an additive submonoid back to an opposite submonoid along
`AddOpposite.unop`"]
protected def op (x : Submonoid M) : Submonoid Mᵐᵒᵖ 
goal: AddSubmonoid Mᵃᵒᵖ

full_name: AddSubmonoid.mem_op
code: @[to_additive (attr := simp)]
theorem mem_op {x : Mᵐᵒᵖ} {S : Submonoid M} : x ∈ S.op ↔ x.unop ∈ S 
goal: x ∈ S.op ↔ AddOpposite.unop x ∈ S

full_name: Submonoid.mem_op
code: @[to_additive (attr := simp)]
theorem mem_op {x : Mᵐᵒᵖ} {S : Submonoid M} : x ∈ S.op ↔ x.unop ∈ S 
goal: x ∈ S.op ↔ MulOpposite.unop x ∈ S

full_name: Submonoid.unop_coe
code: /-- Pull an opposite submonoid back to a submonoid along `MulOpposite.op`-/
@[to_additive (attr := simps) "Pull an opposite additive submonoid back to a submonoid along
`AddOpposite.op`"]
protected def unop (x : Submonoid Mᵐᵒᵖ) : Submonoid M 
goal: ↑x.unop = MulOpposite.op ⁻¹' ↑x

full_name: AddSubmonoid.unop_coe
code: /-- Pull an opposite submonoid back to a submonoid along `MulOpposite.op`-/
@[to_additive (attr := simps) "Pull an opposite additive submonoid back to a submonoid along
`AddOpposite.op`"]
protected def unop (x : Submonoid Mᵐᵒᵖ) : Submonoid M 
goal: ↑x.unop = AddOpposite.op ⁻¹' ↑x

full_name: Submonoid.unop
code: /-- Pull an opposite submonoid back to a submonoid along `MulOpposite.op`-/
@[to_additive (attr := simps) "Pull an opposite additive submonoid back to a submonoid along
`AddOpposite.op`"]
protected def unop (x : Submonoid Mᵐᵒᵖ) : Submonoid M 
goal: Submonoid M

full_name: AddSubmonoid.unop
code: /-- Pull an opposite submonoid back to a submonoid along `MulOpposite.op`-/
@[to_additive (attr := simps) "Pull an opposite additive submonoid back to a submonoid along
`AddOpposite.op`"]
protected def unop (x : Submonoid Mᵐᵒᵖ) : Submonoid M 
goal: AddSubmonoid M

full_name: Submonoid.mem_unop
code: @[to_additive (attr := simp)]
theorem mem_unop {x : M} {S : Submonoid Mᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S 
goal: x ∈ S.unop ↔ MulOpposite.op x ∈ S

full_name: AddSubmonoid.mem_unop
code: @[to_additive (attr := simp)]
theorem mem_unop {x : M} {S : Submonoid Mᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S 
goal: x ∈ S.unop ↔ AddOpposite.op x ∈ S

full_name: AddSubmonoid.unop_op
code: @[to_additive (attr := simp)]
theorem unop_op (S : Submonoid M) : S.op.unop = S 
goal: S.op.unop = S

full_name: Submonoid.unop_op
code: @[to_additive (attr := simp)]
theorem unop_op (S : Submonoid M) : S.op.unop = S 
goal: S.op.unop = S

full_name: Submonoid.op_unop
code: @[to_additive (attr := simp)]
theorem op_unop (S : Submonoid Mᵐᵒᵖ) : S.unop.op = S 
goal: S.unop.op = S

full_name: AddSubmonoid.op_unop
code: @[to_additive (attr := simp)]
theorem op_unop (S : Submonoid Mᵐᵒᵖ) : S.unop.op = S 
goal: S.unop.op = S

full_name: Submonoid.op_le_iff
code: @[to_additive]
theorem op_le_iff {S₁ : Submonoid M} {S₂ : Submonoid Mᵐᵒᵖ} : S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop 
goal: S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop

full_name: AddSubmonoid.op_le_iff
code: @[to_additive]
theorem op_le_iff {S₁ : Submonoid M} {S₂ : Submonoid Mᵐᵒᵖ} : S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop 
goal: S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop

full_name: Submonoid.le_op_iff
code: @[to_additive]
theorem le_op_iff {S₁ : Submonoid Mᵐᵒᵖ} {S₂ : Submonoid M} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ 
goal: S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂

full_name: AddSubmonoid.le_op_iff
code: @[to_additive]
theorem le_op_iff {S₁ : Submonoid Mᵐᵒᵖ} {S₂ : Submonoid M} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ 
goal: S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂

full_name: Submonoid.op_le_op_iff
code: @[to_additive (attr := simp)]
theorem op_le_op_iff {S₁ S₂ : Submonoid M} : S₁.op ≤ S₂.op ↔ S₁ ≤ S₂ 
goal: S₁.op ≤ S₂.op ↔ S₁ ≤ S₂

full_name: AddSubmonoid.op_le_op_iff
code: @[to_additive (attr := simp)]
theorem op_le_op_iff {S₁ S₂ : Submonoid M} : S₁.op ≤ S₂.op ↔ S₁ ≤ S₂ 
goal: S₁.op ≤ S₂.op ↔ S₁ ≤ S₂

full_name: Submonoid.unop_le_unop_iff
code: @[to_additive (attr := simp)]
theorem unop_le_unop_iff {S₁ S₂ : Submonoid Mᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂ 
goal: S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂

full_name: AddSubmonoid.unop_le_unop_iff
code: @[to_additive (attr := simp)]
theorem unop_le_unop_iff {S₁ S₂ : Submonoid Mᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂ 
goal: S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂

full_name: AddSubmonoid.opEquiv_symm_apply
code: /-- A submonoid `H` of `G` determines a submonoid `H.op` of the opposite group `Gᵐᵒᵖ`. -/
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
goal: (RelIso.symm AddSubmonoid.opEquiv) x = x.unop

full_name: AddSubmonoid.opEquiv_apply
code: /-- A submonoid `H` of `G` determines a submonoid `H.op` of the opposite group `Gᵐᵒᵖ`. -/
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
goal: AddSubmonoid.opEquiv x = x.op

full_name: Submonoid.opEquiv_apply
code: /-- A submonoid `H` of `G` determines a submonoid `H.op` of the opposite group `Gᵐᵒᵖ`. -/
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
goal: Submonoid.opEquiv x = x.op

full_name: Submonoid.opEquiv
code: /-- A submonoid `H` of `G` determines a submonoid `H.op` of the opposite group `Gᵐᵒᵖ`. -/
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
goal: Submonoid M ≃o Submonoid Mᵐᵒᵖ

full_name: Submonoid.opEquiv_symm_apply
code: /-- A submonoid `H` of `G` determines a submonoid `H.op` of the opposite group `Gᵐᵒᵖ`. -/
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
goal: (RelIso.symm Submonoid.opEquiv) x = x.unop

full_name: AddSubmonoid.opEquiv
code: /-- A submonoid `H` of `G` determines a submonoid `H.op` of the opposite group `Gᵐᵒᵖ`. -/
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
goal: AddSubmonoid M ≃o AddSubmonoid Mᵃᵒᵖ

full_name: AddSubmonoid.op_bot
code: @[to_additive (attr := simp)]
theorem op_bot : (⊥ : Submonoid M).op = ⊥ 
goal: ⊥.op = ⊥

full_name: Submonoid.op_bot
code: @[to_additive (attr := simp)]
theorem op_bot : (⊥ : Submonoid M).op = ⊥ 
goal: ⊥.op = ⊥

full_name: Submonoid.unop_bot
code: @[to_additive (attr := simp)]
theorem unop_bot : (⊥ : Submonoid Mᵐᵒᵖ).unop = ⊥ 
goal: ⊥.unop = ⊥

full_name: AddSubmonoid.unop_bot
code: @[to_additive (attr := simp)]
theorem unop_bot : (⊥ : Submonoid Mᵐᵒᵖ).unop = ⊥ 
goal: ⊥.unop = ⊥

full_name: AddSubmonoid.op_top
code: @[to_additive (attr := simp)]
theorem op_top : (⊤ : Submonoid M).op = ⊤ 
goal: ⊤.op = ⊤

full_name: Submonoid.op_top
code: @[to_additive (attr := simp)]
theorem op_top : (⊤ : Submonoid M).op = ⊤ 
goal: ⊤.op = ⊤

full_name: Submonoid.unop_top
code: @[to_additive (attr := simp)]
theorem unop_top : (⊤ : Submonoid Mᵐᵒᵖ).unop = ⊤ 
goal: ⊤.unop = ⊤

full_name: AddSubmonoid.unop_top
code: @[to_additive (attr := simp)]
theorem unop_top : (⊤ : Submonoid Mᵐᵒᵖ).unop = ⊤ 
goal: ⊤.unop = ⊤

full_name: Submonoid.op_sup
code: @[to_additive]
theorem op_sup (S₁ S₂ : Submonoid M) : (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op 
goal: (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op

full_name: AddSubmonoid.op_sup
code: @[to_additive]
theorem op_sup (S₁ S₂ : Submonoid M) : (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op 
goal: (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op

full_name: AddSubmonoid.unop_sup
code: @[to_additive]
theorem unop_sup (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop 
goal: (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop

full_name: Submonoid.unop_sup
code: @[to_additive]
theorem unop_sup (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop 
goal: (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop

full_name: AddSubmonoid.op_inf
code: @[to_additive]
theorem op_inf (S₁ S₂ : Submonoid M) : (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op 
goal: (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op

full_name: Submonoid.op_inf
code: @[to_additive]
theorem op_inf (S₁ S₂ : Submonoid M) : (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op 
goal: (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op

full_name: Submonoid.unop_inf
code: @[to_additive]
theorem unop_inf (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop 
goal: (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop

full_name: AddSubmonoid.unop_inf
code: @[to_additive]
theorem unop_inf (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop 
goal: (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop

full_name: AddSubmonoid.op_sSup
code: @[to_additive]
theorem op_sSup (S : Set (Submonoid M)) : (sSup S).op = sSup (.unop ⁻¹' S) 
goal: (sSup S).op = sSup (AddSubmonoid.unop ⁻¹' S)

full_name: Submonoid.op_sSup
code: @[to_additive]
theorem op_sSup (S : Set (Submonoid M)) : (sSup S).op = sSup (.unop ⁻¹' S) 
goal: (sSup S).op = sSup (Submonoid.unop ⁻¹' S)

full_name: AddSubmonoid.unop_sSup
code: @[to_additive]
theorem unop_sSup (S : Set (Submonoid Mᵐᵒᵖ)) : (sSup S).unop = sSup (.op ⁻¹' S) 
goal: (sSup S).unop = sSup (AddSubmonoid.op ⁻¹' S)

full_name: Submonoid.unop_sSup
code: @[to_additive]
theorem unop_sSup (S : Set (Submonoid Mᵐᵒᵖ)) : (sSup S).unop = sSup (.op ⁻¹' S) 
goal: (sSup S).unop = sSup (Submonoid.op ⁻¹' S)

full_name: Submonoid.op_sInf
code: @[to_additive]
theorem op_sInf (S : Set (Submonoid M)) : (sInf S).op = sInf (.unop ⁻¹' S) 
goal: (sInf S).op = sInf (Submonoid.unop ⁻¹' S)

full_name: AddSubmonoid.op_sInf
code: @[to_additive]
theorem op_sInf (S : Set (Submonoid M)) : (sInf S).op = sInf (.unop ⁻¹' S) 
goal: (sInf S).op = sInf (AddSubmonoid.unop ⁻¹' S)

full_name: AddSubmonoid.unop_sInf
code: @[to_additive]
theorem unop_sInf (S : Set (Submonoid Mᵐᵒᵖ)) : (sInf S).unop = sInf (.op ⁻¹' S) 
goal: (sInf S).unop = sInf (AddSubmonoid.op ⁻¹' S)

full_name: Submonoid.unop_sInf
code: @[to_additive]
theorem unop_sInf (S : Set (Submonoid Mᵐᵒᵖ)) : (sInf S).unop = sInf (.op ⁻¹' S) 
goal: (sInf S).unop = sInf (Submonoid.op ⁻¹' S)

full_name: AddSubmonoid.op_iSup
code: @[to_additive]
theorem op_iSup (S : ι → Submonoid M) : (iSup S).op = ⨆ i, (S i).op 
goal: (iSup S).op = ⨆ i, (S i).op

full_name: Submonoid.op_iSup
code: @[to_additive]
theorem op_iSup (S : ι → Submonoid M) : (iSup S).op = ⨆ i, (S i).op 
goal: (iSup S).op = ⨆ i, (S i).op

full_name: AddSubmonoid.unop_iSup
code: @[to_additive]
theorem unop_iSup (S : ι → Submonoid Mᵐᵒᵖ) : (iSup S).unop = ⨆ i, (S i).unop 
goal: (iSup S).unop = ⨆ i, (S i).unop

full_name: Submonoid.unop_iSup
code: @[to_additive]
theorem unop_iSup (S : ι → Submonoid Mᵐᵒᵖ) : (iSup S).unop = ⨆ i, (S i).unop 
goal: (iSup S).unop = ⨆ i, (S i).unop

full_name: Submonoid.op_iInf
code: @[to_additive]
theorem op_iInf (S : ι → Submonoid M) : (iInf S).op = ⨅ i, (S i).op 
goal: (iInf S).op = ⨅ i, (S i).op

full_name: AddSubmonoid.op_iInf
code: @[to_additive]
theorem op_iInf (S : ι → Submonoid M) : (iInf S).op = ⨅ i, (S i).op 
goal: (iInf S).op = ⨅ i, (S i).op

full_name: Submonoid.unop_iInf
code: @[to_additive]
theorem unop_iInf (S : ι → Submonoid Mᵐᵒᵖ) : (iInf S).unop = ⨅ i, (S i).unop 
goal: (iInf S).unop = ⨅ i, (S i).unop

full_name: AddSubmonoid.unop_iInf
code: @[to_additive]
theorem unop_iInf (S : ι → Submonoid Mᵐᵒᵖ) : (iInf S).unop = ⨅ i, (S i).unop 
goal: (iInf S).unop = ⨅ i, (S i).unop

full_name: Submonoid.op_closure
code: @[to_additive]
theorem op_closure (s : Set M) : (closure s).op = closure (MulOpposite.unop ⁻¹' s) 
goal: (Submonoid.closure s).op = Submonoid.closure (MulOpposite.unop ⁻¹' s)

full_name: AddSubmonoid.op_closure
code: @[to_additive]
theorem op_closure (s : Set M) : (closure s).op = closure (MulOpposite.unop ⁻¹' s) 
goal: (AddSubmonoid.closure s).op = AddSubmonoid.closure (AddOpposite.unop ⁻¹' s)

full_name: AddSubmonoid.unop_closure
code: @[to_additive]
theorem unop_closure (s : Set Mᵐᵒᵖ) : (closure s).unop = closure (MulOpposite.op ⁻¹' s) 
goal: (AddSubmonoid.closure s).unop = AddSubmonoid.closure (AddOpposite.op ⁻¹' s)

full_name: Submonoid.unop_closure
code: @[to_additive]
theorem unop_closure (s : Set Mᵐᵒᵖ) : (closure s).unop = closure (MulOpposite.op ⁻¹' s) 
goal: (Submonoid.closure s).unop = Submonoid.closure (MulOpposite.op ⁻¹' s)

full_name: Submonoid.equivOp
code: /-- Bijection between a submonoid `H` and its opposite. -/
@[to_additive (attr := simps!) "Bijection between an additive submonoid `H` and its opposite."]
def equivOp (H : Submonoid M) : H ≃ H.op 
goal: ↥H ≃ ↥H.op

full_name: AddSubmonoid.equivOp
code: /-- Bijection between a submonoid `H` and its opposite. -/
@[to_additive (attr := simps!) "Bijection between an additive submonoid `H` and its opposite."]
def equivOp (H : Submonoid M) : H ≃ H.op 
goal: ↥H ≃ ↥H.op

full_name: AddSubmonoid.equivOp_symm_apply_coe
code: /-- Bijection between a submonoid `H` and its opposite. -/
@[to_additive (attr := simps!) "Bijection between an additive submonoid `H` and its opposite."]
def equivOp (H : Submonoid M) : H ≃ H.op 
goal: ↑(H.equivOp.symm b) = AddOpposite.unop ↑b

full_name: AddSubmonoid.equivOp_apply_coe
code: /-- Bijection between a submonoid `H` and its opposite. -/
@[to_additive (attr := simps!) "Bijection between an additive submonoid `H` and its opposite."]
def equivOp (H : Submonoid M) : H ≃ H.op 
goal: ↑(H.equivOp a) = AddOpposite.op ↑a

full_name: Submonoid.equivOp_symm_apply_coe
code: /-- Bijection between a submonoid `H` and its opposite. -/
@[to_additive (attr := simps!) "Bijection between an additive submonoid `H` and its opposite."]
def equivOp (H : Submonoid M) : H ≃ H.op 
goal: ↑(H.equivOp.symm b) = MulOpposite.unop ↑b

full_name: Submonoid.equivOp_apply_coe
code: /-- Bijection between a submonoid `H` and its opposite. -/
@[to_additive (attr := simps!) "Bijection between an additive submonoid `H` and its opposite."]
def equivOp (H : Submonoid M) : H ≃ H.op 
goal: ↑(H.equivOp a) = MulOpposite.op ↑a