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

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

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

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

full_name: AddSubgroup.op
code: /-- Pull a subgroup back to an opposite subgroup along `MulOpposite.unop`-/
@[to_additive (attr := simps)
"Pull an additive subgroup back to an opposite additive subgroup along `AddOpposite.unop`"]
protected def op (H : Subgroup G) : Subgroup Gᵐᵒᵖ 
goal: AddSubgroup Gᵃᵒᵖ

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

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

full_name: Subgroup.op_toSubmonoid
code: @[to_additive (attr := simp)] lemma op_toSubmonoid (H : Subgroup G) :
    H.op.toSubmonoid = H.toSubmonoid.op 
goal: H.op.toSubmonoid = H.op

full_name: AddSubgroup.op_toAddSubmonoid
code: @[to_additive (attr := simp)] lemma op_toSubmonoid (H : Subgroup G) :
    H.op.toSubmonoid = H.toSubmonoid.op 
goal: H.op.toAddSubmonoid = H.op

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

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

full_name: AddSubgroup.unop
code: /-- Pull an opposite subgroup back to a subgroup along `MulOpposite.op`-/
@[to_additive (attr := simps)
"Pull an opposite additive subgroup back to an additive subgroup along `AddOpposite.op`"]
protected def unop (H : Subgroup Gᵐᵒᵖ) : Subgroup G 
goal: AddSubgroup G

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

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

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

full_name: Subgroup.unop_toSubmonoid
code: @[to_additive (attr := simp)] lemma unop_toSubmonoid (H : Subgroup Gᵐᵒᵖ) :
    H.unop.toSubmonoid = H.toSubmonoid.unop 
goal: H.unop.toSubmonoid = H.unop

full_name: AddSubgroup.unop_toAddSubmonoid
code: @[to_additive (attr := simp)] lemma unop_toSubmonoid (H : Subgroup Gᵐᵒᵖ) :
    H.unop.toSubmonoid = H.toSubmonoid.unop 
goal: H.unop.toAddSubmonoid = H.unop

full_name: AddSubgroup.unop_op
code: @[to_additive (attr := simp)]
theorem unop_op (S : Subgroup G) : S.op.unop = S 
goal: S.op.unop = S

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: AddSubgroup.op_bot
code: @[to_additive (attr := simp)]
theorem op_bot : (⊥ : Subgroup G).op = ⊥ 
goal: ⊥.op = ⊥

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

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

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

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

full_name: AddSubgroup.op_top
code: @[to_additive (attr := simp)]
theorem op_top : (⊤ : Subgroup G).op = ⊤ 
goal: ⊤.op = ⊤

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

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

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

full_name: AddSubgroup.op_sup
code: @[to_additive]
theorem op_sup (S₁ S₂ : Subgroup G) : (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op 
goal: (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op

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

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

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

full_name: AddSubgroup.op_inf
code: @[to_additive]
theorem op_inf (S₁ S₂ : Subgroup G) : (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op 
goal: (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: AddSubgroup.instEncodableSubtypeAddOppositeMemOp
code: @[to_additive]
instance (H : Subgroup G) [Encodable H] : Encodable H.op 
goal: Encodable ↥H.op

full_name: Subgroup.instEncodableSubtypeMulOppositeMemOp
code: @[to_additive]
instance (H : Subgroup G) [Encodable H] : Encodable H.op 
goal: Encodable ↥H.op

full_name: Subgroup.instCountableSubtypeMulOppositeMemOp
code: @[to_additive]
instance (H : Subgroup G) [Countable H] : Countable H.op 
goal: Countable ↥H.op

full_name: AddSubgroup.instCountableSubtypeAddOppositeMemOp
code: @[to_additive]
instance (H : Subgroup G) [Countable H] : Countable H.op 
goal: Countable ↥H.op

full_name: Subgroup.smul_opposite_mul
code: @[to_additive]
theorem smul_opposite_mul {H : Subgroup G} (x g : G) (h : H.op) :
    h • (g * x) = g * h • x 
goal: h • (g * x) = g * h • x

full_name: AddSubgroup.vadd_opposite_add
code: @[to_additive]
theorem smul_opposite_mul {H : Subgroup G} (x g : G) (h : H.op) :
    h • (g * x) = g * h • x 
goal: h +ᵥ (g + x) = g + (h +ᵥ x)