ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- addLeftEmbedding_apply
@[to_additive (attr := simps)
      "If left-addition by any element is cancellative, left-addition by `g` is an
        embedding."]
def mulLeftEmbedding [Mul G] [IsLeftCancelMul G] (g : G) : G ↪ G 
Arguments: {G : Type u_1} [Add G] [IsLeftCancelAdd G] (g h : G)
Goal: (addLeftEmbedding g) h = g + h
-- addRightEmbedding_apply
@[to_additive (attr := simps)
      "If right-addition by any element is cancellative, right-addition by `g` is an
        embedding."]
def mulRightEmbedding [Mul G] [IsRightCancelMul G] (g : G) : G ↪ G 
Arguments: {G : Type u_1} [Add G] [IsRightCancelAdd G] (g h : G)
Goal: (addRightEmbedding g) h = h + g
-- mulRightEmbedding_apply
@[to_additive (attr := simps)
      "If right-addition by any element is cancellative, right-addition by `g` is an
        embedding."]
def mulRightEmbedding [Mul G] [IsRightCancelMul G] (g : G) : G ↪ G 
Arguments: {G : Type u_1} [Mul G] [IsRightCancelMul G] (g h : G)
Goal: (mulRightEmbedding g) h = h * g
-- mulLeftEmbedding_eq_mulRightEmbedding
@[to_additive]
theorem mulLeftEmbedding_eq_mulRightEmbedding [CommSemigroup G] [IsCancelMul G] (g : G) :
    mulLeftEmbedding g = mulRightEmbedding g 
Arguments: {G : Type u_1} [CommSemigroup G] [IsCancelMul G] (g : G)
Goal: mulLeftEmbedding g = mulRightEmbedding g
-- addLeftEmbedding_eq_addRightEmbedding
@[to_additive]
theorem mulLeftEmbedding_eq_mulRightEmbedding [CommSemigroup G] [IsCancelMul G] (g : G) :
    mulLeftEmbedding g = mulRightEmbedding g 
Arguments: {G : Type u_1} [AddCommSemigroup G] [IsCancelAdd G] (g : G)
Goal: addLeftEmbedding g = addRightEmbedding g
-- WithZero.coeAddHom_apply
@[to_additive (attr := simps apply) "`WithZero.coe` as a bundled morphism"]
def coeMulHom [Mul α] : α →ₙ* WithOne α 
Arguments: {α : Type u} [Add α]
Goal: ∀ (a : α), WithZero.coeAddHom a = ↑a
-- WithOne.coeMulHom_apply
@[to_additive (attr := simps apply) "`WithZero.coe` as a bundled morphism"]
def coeMulHom [Mul α] : α →ₙ* WithOne α 
Arguments: {α : Type u} [Mul α]
Goal: ∀ (a : α), WithOne.coeMulHom a = ↑a
-- WithZero.lift_coe
@[to_additive (attr := simp)]
theorem lift_coe (x : α) : lift f x = f x 
Arguments: {α : Type u} {β : Type v} [Add α] [AddZeroClass β] (f : AddHom α β) (x : α)
Goal: (WithZero.lift f) ↑x = f x
-- WithOne.lift_coe
@[to_additive (attr := simp)]
theorem lift_coe (x : α) : lift f x = f x 
Arguments: {α : Type u} {β : Type v} [Mul α] [MulOneClass β] (f : α →ₙ* β) (x : α)
Goal: (WithOne.lift f) ↑x = f x
-- WithOne.lift_one
@[to_additive]
theorem lift_one : lift f 1 = 1 
Arguments: {α : Type u} {β : Type v} [Mul α] [MulOneClass β] (f : α →ₙ* β)
Goal: (WithOne.lift f) 1 = 1
-- WithZero.lift_zero
@[to_additive]
theorem lift_one : lift f 1 = 1 
Arguments: {α : Type u} {β : Type v} [Add α] [AddZeroClass β] (f : AddHom α β)
Goal: (WithZero.lift f) 0 = 0
-- WithZero.lift_unique
@[to_additive]
theorem lift_unique (f : WithOne α →* β) : f = lift (f.toMulHom.comp coeMulHom) 
Arguments: {α : Type u} {β : Type v} [Add α] [AddZeroClass β] (f : WithZero α →+ β)
Goal: f = WithZero.lift ((↑f).comp WithZero.coeAddHom)
-- WithOne.lift_unique
@[to_additive]
theorem lift_unique (f : WithOne α →* β) : f = lift (f.toMulHom.comp coeMulHom) 
Arguments: {α : Type u} {β : Type v} [Mul α] [MulOneClass β] (f : WithOne α →* β)
Goal: f = WithOne.lift ((↑f).comp WithOne.coeMulHom)
-- WithOne.map_coe
@[to_additive (attr := simp)]
theorem map_coe (f : α →ₙ* β) (a : α) : map f (a : WithOne α) = f a 
Arguments: {α : Type u} {β : Type v} [Mul α] [Mul β] (f : α →ₙ* β) (a : α)
Goal: (WithOne.map f) ↑a = ↑(f a)
-- WithZero.map_coe
@[to_additive (attr := simp)]
theorem map_coe (f : α →ₙ* β) (a : α) : map f (a : WithOne α) = f a 
Arguments: {α : Type u} {β : Type v} [Add α] [Add β] (f : AddHom α β) (a : α)
Goal: (WithZero.map f) ↑a = ↑(f a)
-- WithZero.map_id
@[to_additive (attr := simp)]
theorem map_id : map (MulHom.id α) = MonoidHom.id (WithOne α) 
Arguments: {α : Type u} [Add α]
Goal: WithZero.map (AddHom.id α) = AddMonoidHom.id (WithZero α)
-- WithOne.map_id
@[to_additive (attr := simp)]
theorem map_id : map (MulHom.id α) = MonoidHom.id (WithOne α) 
Arguments: {α : Type u} [Mul α]
Goal: WithOne.map (MulHom.id α) = MonoidHom.id (WithOne α)
-- WithZero.map_map
@[to_additive]
theorem map_map (f : α →ₙ* β) (g : β →ₙ* γ) (x) : map g (map f x) = map (g.comp f) x 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [Add α] [Add β] [Add γ] (f : AddHom α β) (g : AddHom β γ) (x : WithZero α)
Goal: (WithZero.map g) ((WithZero.map f) x) = (WithZero.map (g.comp f)) x
-- WithOne.map_map
@[to_additive]
theorem map_map (f : α →ₙ* β) (g : β →ₙ* γ) (x) : map g (map f x) = map (g.comp f) x 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [Mul α] [Mul β] [Mul γ] (f : α →ₙ* β) (g : β →ₙ* γ) (x : WithOne α)
Goal: (WithOne.map g) ((WithOne.map f) x) = (WithOne.map (g.comp f)) x
-- WithZero.map_comp
@[to_additive (attr := simp)]
theorem map_comp (f : α →ₙ* β) (g : β →ₙ* γ) : map (g.comp f) = (map g).comp (map f) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [Add α] [Add β] [Add γ] (f : AddHom α β) (g : AddHom β γ)
Goal: WithZero.map (g.comp f) = (WithZero.map g).comp (WithZero.map f)
-- WithOne.map_comp
@[to_additive (attr := simp)]
theorem map_comp (f : α →ₙ* β) (g : β →ₙ* γ) : map (g.comp f) = (map g).comp (map f) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [Mul α] [Mul β] [Mul γ] (f : α →ₙ* β) (g : β →ₙ* γ)
Goal: WithOne.map (g.comp f) = (WithOne.map g).comp (WithOne.map f)
-- AddEquiv.withZeroCongr_apply
@[to_additive (attr := simps apply) "A version of `Equiv.optionCongr` for `WithZero`."]
def _root_.MulEquiv.withOneCongr (e : α ≃* β) : WithOne α ≃* WithOne β 
Arguments: {α : Type u} {β : Type v} [Add α] [Add β] (e : α ≃+ β) (a : WithZero α)
Goal: e.withZeroCongr a = (WithZero.map e.toAddHom) a
-- MulEquiv.withOneCongr_apply
@[to_additive (attr := simps apply) "A version of `Equiv.optionCongr` for `WithZero`."]
def _root_.MulEquiv.withOneCongr (e : α ≃* β) : WithOne α ≃* WithOne β 
Arguments: {α : Type u} {β : Type v} [Mul α] [Mul β] (e : α ≃* β) (a : WithOne α)
Goal: e.withOneCongr a = (WithOne.map e.toMulHom) a
-- AddEquiv.withZeroCongr_refl
@[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_refl : (MulEquiv.refl α).withOneCongr = MulEquiv.refl _ 
Arguments: {α : Type u} [Add α]
Goal: (AddEquiv.refl α).withZeroCongr = AddEquiv.refl (WithZero α)
-- MulEquiv.withOneCongr_refl
@[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_refl : (MulEquiv.refl α).withOneCongr = MulEquiv.refl _ 
Arguments: {α : Type u} [Mul α]
Goal: (MulEquiv.refl α).withOneCongr = MulEquiv.refl (WithOne α)
-- MulEquiv.withOneCongr_symm
@[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_symm (e : α ≃* β) :
    e.withOneCongr.symm = e.symm.withOneCongr 
Arguments: {α : Type u} {β : Type v} [Mul α] [Mul β] (e : α ≃* β)
Goal: e.withOneCongr.symm = e.symm.withOneCongr
-- AddEquiv.withZeroCongr_symm
@[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_symm (e : α ≃* β) :
    e.withOneCongr.symm = e.symm.withOneCongr 
Arguments: {α : Type u} {β : Type v} [Add α] [Add β] (e : α ≃+ β)
Goal: e.withZeroCongr.symm = e.symm.withZeroCongr
-- AddEquiv.withZeroCongr_trans
@[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_trans (e₁ : α ≃* β) (e₂ : β ≃* γ) :
    e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [Add α] [Add β] [Add γ] (e₁ : α ≃+ β) (e₂ : β ≃+ γ)
Goal: e₁.withZeroCongr.trans e₂.withZeroCongr = (e₁.trans e₂).withZeroCongr
-- MulEquiv.withOneCongr_trans
@[to_additive (attr := simp)]
theorem _root_.MulEquiv.withOneCongr_trans (e₁ : α ≃* β) (e₂ : β ≃* γ) :
    e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [Mul α] [Mul β] [Mul γ] (e₁ : α ≃* β) (e₂ : β ≃* γ)
Goal: e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr
-- even_add_self
@[to_additive (attr := simp)] lemma isSquare_mul_self (m : α) : IsSquare (m * m) 
Arguments: {α : Type u_2} [Add α] (m : α)
Goal: Even (m + m)
-- isSquare_mul_self
@[to_additive (attr := simp)] lemma isSquare_mul_self (m : α) : IsSquare (m * m) 
Arguments: {α : Type u_2} [Mul α] (m : α)
Goal: IsSquare (m * m)
-- isSquare_op_iff
@[to_additive]
lemma isSquare_op_iff {a : α} : IsSquare (op a) ↔ IsSquare a 
Arguments: {α : Type u_2} [Mul α] {a : α}
Goal: IsSquare (MulOpposite.op a) ↔ IsSquare a
-- even_op_iff
@[to_additive]
lemma isSquare_op_iff {a : α} : IsSquare (op a) ↔ IsSquare a 
Arguments: {α : Type u_2} [Add α] {a : α}
Goal: Even (AddOpposite.op a) ↔ Even a
-- isSquare_unop_iff
@[to_additive]
lemma isSquare_unop_iff {a : αᵐᵒᵖ} : IsSquare (unop a) ↔ IsSquare a 
Arguments: {α : Type u_2} [Mul α] {a : αᵐᵒᵖ}
Goal: IsSquare (MulOpposite.unop a) ↔ IsSquare a
-- even_unop_iff
@[to_additive]
lemma isSquare_unop_iff {a : αᵐᵒᵖ} : IsSquare (unop a) ↔ IsSquare a 
Arguments: {α : Type u_2} [Add α] {a : αᵃᵒᵖ}
Goal: Even (AddOpposite.unop a) ↔ Even a
-- even_ofMul_iff
@[simp]
lemma even_ofMul_iff {a : α} : Even (Additive.ofMul a) ↔ IsSquare a 
Arguments: {α : Type u_2} [Mul α] {a : α}
Goal: Even (Additive.ofMul a) ↔ IsSquare a
-- isSquare_toMul_iff
@[simp]
lemma isSquare_toMul_iff {a : Additive α} : IsSquare (Additive.toMul a) ↔ Even a 
Arguments: {α : Type u_2} [Mul α] {a : Additive α}
Goal: IsSquare (Additive.toMul a) ↔ Even a
-- isSquare_ofAdd_iff
@[simp] lemma isSquare_ofAdd_iff {a : α} : IsSquare (Multiplicative.ofAdd a) ↔ Even a 
Arguments: {α : Type u_2} [Add α] {a : α}
Goal: IsSquare (Multiplicative.ofAdd a) ↔ Even a
-- even_toAdd_iff
@[simp]
lemma even_toAdd_iff {a : Multiplicative α} : Even (Multiplicative.toAdd a) ↔ IsSquare a 
Arguments: {α : Type u_2} [Add α] {a : Multiplicative α}
Goal: Even (Multiplicative.toAdd a) ↔ IsSquare a
-- even_zero
@[to_additive (attr := simp)]
lemma isSquare_one [MulOneClass α] : IsSquare (1 : α) 
Arguments: {α : Type u_2} [AddZeroClass α]
Goal: Even 0
-- isSquare_one
@[to_additive (attr := simp)]
lemma isSquare_one [MulOneClass α] : IsSquare (1 : α) 
Arguments: {α : Type u_2} [MulOneClass α]
Goal: IsSquare 1
-- IsSquare.map
@[to_additive]
lemma IsSquare.map [MulOneClass α] [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β]
    {m : α} (f : F) :
    IsSquare m → IsSquare (f m) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [MulOneClass α] [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β] {m : α} (f : F)
Goal: IsSquare m → IsSquare (f m)
-- Even.map
@[to_additive]
lemma IsSquare.map [MulOneClass α] [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β]
    {m : α} (f : F) :
    IsSquare m → IsSquare (f m) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [AddMonoidHomClass F α β] {m : α} (f : F)
Goal: Even m → Even (f m)
-- even_iff_exists_two_nsmul
@[to_additive even_iff_exists_two_nsmul]
lemma isSquare_iff_exists_sq (m : α) : IsSquare m ↔ ∃ c, m = c ^ 2 
Arguments: {α : Type u_2} [AddMonoid α] (m : α)
Goal: Even m ↔ ∃ c, m = 2 • c
-- isSquare_iff_exists_sq
@[to_additive even_iff_exists_two_nsmul]
lemma isSquare_iff_exists_sq (m : α) : IsSquare m ↔ ∃ c, m = c ^ 2 
Arguments: {α : Type u_2} [Monoid α] (m : α)
Goal: IsSquare m ↔ ∃ c, m = c ^ 2
-- IsSquare.pow
@[to_additive] lemma IsSquare.pow (n : ℕ) : IsSquare a → IsSquare (a ^ n) 
Arguments: {α : Type u_2} [Monoid α] {a : α} (n : ℕ)
Goal: IsSquare a → IsSquare (a ^ n)
-- Even.nsmul
@[to_additive] lemma IsSquare.pow (n : ℕ) : IsSquare a → IsSquare (a ^ n) 
Arguments: {α : Type u_2} [AddMonoid α] {a : α} (n : ℕ)
Goal: Even a → Even (n • a)
-- Even.isSquare_pow
@[to_additive Even.nsmul'] lemma Even.isSquare_pow : Even n → ∀ a : α, IsSquare (a ^ n) 
Arguments: {α : Type u_2} [Monoid α] {n : ℕ}
Goal: Even n → ∀ (a : α), IsSquare (a ^ n)
-- Even.nsmul'
@[to_additive Even.nsmul'] lemma Even.isSquare_pow : Even n → ∀ a : α, IsSquare (a ^ n) 
Arguments: {α : Type u_2} [AddMonoid α] {n : ℕ}
Goal: Even n → ∀ (a : α), Even (n • a)
-- IsSquare_sq
@[to_additive even_two_nsmul] lemma IsSquare_sq (a : α) : IsSquare (a ^ 2) 
Arguments: {α : Type u_2} [Monoid α] (a : α)
Goal: IsSquare (a ^ 2)
-- even_two_nsmul
@[to_additive even_two_nsmul] lemma IsSquare_sq (a : α) : IsSquare (a ^ 2) 
Arguments: {α : Type u_2} [AddMonoid α] (a : α)
Goal: Even (2 • a)
-- Even.add
@[to_additive]
lemma IsSquare.mul [CommSemigroup α] {a b : α} : IsSquare a → IsSquare b → IsSquare (a * b) 
Arguments: {α : Type u_2} [AddCommSemigroup α] {a b : α}
Goal: Even a → Even b → Even (a + b)
-- IsSquare.mul
@[to_additive]
lemma IsSquare.mul [CommSemigroup α] {a b : α} : IsSquare a → IsSquare b → IsSquare (a * b) 
Arguments: {α : Type u_2} [CommSemigroup α] {a b : α}
Goal: IsSquare a → IsSquare b → IsSquare (a * b)
-- even_neg
@[to_additive (attr := simp)] lemma isSquare_inv : IsSquare a⁻¹ ↔ IsSquare a 
Arguments: {α : Type u_2} [SubtractionMonoid α] {a : α}
Goal: Even (-a) ↔ Even a
-- isSquare_inv
@[to_additive (attr := simp)] lemma isSquare_inv : IsSquare a⁻¹ ↔ IsSquare a 
Arguments: {α : Type u_2} [DivisionMonoid α] {a : α}
Goal: IsSquare a⁻¹ ↔ IsSquare a
-- IsSquare.zpow
@[to_additive] lemma IsSquare.zpow (n : ℤ) : IsSquare a → IsSquare (a ^ n) 
Arguments: {α : Type u_2} [DivisionMonoid α] {a : α} (n : ℤ)
Goal: IsSquare a → IsSquare (a ^ n)
-- Even.zsmul
@[to_additive] lemma IsSquare.zpow (n : ℤ) : IsSquare a → IsSquare (a ^ n) 
Arguments: {α : Type u_2} [SubtractionMonoid α] {a : α} (n : ℤ)
Goal: Even a → Even (n • a)
-- Even.sub
@[to_additive]
lemma IsSquare.div [DivisionCommMonoid α] {a b : α} (ha : IsSquare a) (hb : IsSquare b) :
    IsSquare (a / b) 
Arguments: {α : Type u_2} [SubtractionCommMonoid α] {a b : α} (ha : Even a) (hb : Even b)
Goal: Even (a - b)
-- IsSquare.div
@[to_additive]
lemma IsSquare.div [DivisionCommMonoid α] {a b : α} (ha : IsSquare a) (hb : IsSquare b) :
    IsSquare (a / b) 
Arguments: {α : Type u_2} [DivisionCommMonoid α] {a b : α} (ha : IsSquare a) (hb : IsSquare b)
Goal: IsSquare (a / b)
-- Even.zsmul'
@[to_additive (attr := simp) Even.zsmul']
lemma Even.isSquare_zpow [Group α] {n : ℤ} : Even n → ∀ a : α, IsSquare (a ^ n) 
Arguments: {α : Type u_2} [AddGroup α] {n : ℤ}
Goal: Even n → ∀ (a : α), Even (n • a)
-- Even.isSquare_zpow
@[to_additive (attr := simp) Even.zsmul']
lemma Even.isSquare_zpow [Group α] {n : ℤ} : Even n → ∀ a : α, IsSquare (a ^ n) 
Arguments: {α : Type u_2} [Group α] {n : ℤ}
Goal: Even n → ∀ (a : α), IsSquare (a ^ n)
-- inv_coe_set
@[to_additive (attr := simp, norm_cast)]
theorem inv_coe_set [InvolutiveInv G] [SetLike S G] [InvMemClass S G] {H : S} : (H : Set G)⁻¹ = H 
Arguments: {G : Type u_2} {S : Type u_4} [InvolutiveInv G] [SetLike S G] [InvMemClass S G] {H : S}
Goal: (↑H)⁻¹ = ↑H
-- neg_coe_set
@[to_additive (attr := simp, norm_cast)]
theorem inv_coe_set [InvolutiveInv G] [SetLike S G] [InvMemClass S G] {H : S} : (H : Set G)⁻¹ = H 
Arguments: {G : Type u_2} {S : Type u_4} [InvolutiveNeg G] [SetLike S G] [NegMemClass S G] {H : S}
Goal: -↑H = ↑H
-- vadd_coe_set
@[to_additive (attr := simp)]
lemma smul_coe_set [Group G] [SetLike S G] [SubgroupClass S G] {s : S} {a : G} (ha : a ∈ s) :
    a • (s : Set G) = s 
Arguments: {G : Type u_2} {S : Type u_4} [AddGroup G] [SetLike S G] [AddSubgroupClass S G] {s : S} {a : G} (ha : a ∈ s)
Goal: a +ᵥ ↑s = ↑s
-- smul_coe_set
@[to_additive (attr := simp)]
lemma smul_coe_set [Group G] [SetLike S G] [SubgroupClass S G] {s : S} {a : G} (ha : a ∈ s) :
    a • (s : Set G) = s 
Arguments: {G : Type u_2} {S : Type u_4} [Group G] [SetLike S G] [SubgroupClass S G] {s : S} {a : G} (ha : a ∈ s)
Goal: a • ↑s = ↑s
-- op_vadd_coe_set
@[to_additive (attr := simp)]
lemma op_smul_coe_set [Group G] [SetLike S G] [SubgroupClass S G] {s : S} {a : G} (ha : a ∈ s) :
    MulOpposite.op a • (s : Set G) = s 
Arguments: {G : Type u_2} {S : Type u_4} [AddGroup G] [SetLike S G] [AddSubgroupClass S G] {s : S} {a : G} (ha : a ∈ s)
Goal: AddOpposite.op a +ᵥ ↑s = ↑s
-- op_smul_coe_set
@[to_additive (attr := simp)]
lemma op_smul_coe_set [Group G] [SetLike S G] [SubgroupClass S G] {s : S} {a : G} (ha : a ∈ s) :
    MulOpposite.op a • (s : Set G) = s 
Arguments: {G : Type u_2} {S : Type u_4} [Group G] [SetLike S G] [SubgroupClass S G] {s : S} {a : G} (ha : a ∈ s)
Goal: MulOpposite.op a • ↑s = ↑s
-- coe_add_coe
@[to_additive (attr := simp, norm_cast)]
lemma coe_mul_coe [SetLike S G] [DivInvMonoid G] [SubgroupClass S G] (H : S) :
    H * H = (H : Set G) 
Arguments: {G : Type u_2} {S : Type u_4} [SetLike S G] [SubNegMonoid G] [AddSubgroupClass S G] (H : S)
Goal: ↑H + ↑H = ↑H
-- coe_mul_coe
@[to_additive (attr := simp, norm_cast)]
lemma coe_mul_coe [SetLike S G] [DivInvMonoid G] [SubgroupClass S G] (H : S) :
    H * H = (H : Set G) 
Arguments: {G : Type u_2} {S : Type u_4} [SetLike S G] [DivInvMonoid G] [SubgroupClass S G] (H : S)
Goal: ↑H * ↑H = ↑H
-- coe_sub_coe
@[to_additive (attr := simp, norm_cast)]
lemma coe_div_coe [SetLike S G] [DivisionMonoid G] [SubgroupClass S G] (H : S) :
    H / H = (H : Set G) 
Arguments: {G : Type u_2} {S : Type u_4} [SetLike S G] [SubtractionMonoid G] [AddSubgroupClass S G] (H : S)
Goal: ↑H - ↑H = ↑H
-- coe_div_coe
@[to_additive (attr := simp, norm_cast)]
lemma coe_div_coe [SetLike S G] [DivisionMonoid G] [SubgroupClass S G] (H : S) :
    H / H = (H : Set G) 
Arguments: {G : Type u_2} {S : Type u_4} [SetLike S G] [DivisionMonoid G] [SubgroupClass S G] (H : S)
Goal: ↑H / ↑H = ↑H
-- AddSubgroup.neg_subset_closure
@[to_additive (attr := simp)]
theorem inv_subset_closure (S : Set G) : S⁻¹ ⊆ closure S 
Arguments: {G : Type u_2} [AddGroup G] (S : Set G)
Goal: -S ⊆ ↑(AddSubgroup.closure S)
-- Subgroup.inv_subset_closure
@[to_additive (attr := simp)]
theorem inv_subset_closure (S : Set G) : S⁻¹ ⊆ closure S 
Arguments: {G : Type u_2} [Group G] (S : Set G)
Goal: S⁻¹ ⊆ ↑(Subgroup.closure S)
-- Subgroup.closure_toSubmonoid
@[to_additive]
theorem closure_toSubmonoid (S : Set G) :
    (closure S).toSubmonoid = Submonoid.closure (S ∪ S⁻¹) 
Arguments: {G : Type u_2} [Group G] (S : Set G)
Goal: (Subgroup.closure S).toSubmonoid = Submonoid.closure (S ∪ S⁻¹)
-- AddSubgroup.closure_toAddSubmonoid
@[to_additive]
theorem closure_toSubmonoid (S : Set G) :
    (closure S).toSubmonoid = Submonoid.closure (S ∪ S⁻¹) 
Arguments: {G : Type u_2} [AddGroup G] (S : Set G)
Goal: (AddSubgroup.closure S).toAddSubmonoid = AddSubmonoid.closure (S ∪ -S)
-- Subgroup.closure_induction_left
@[to_additive (attr := elab_as_elim)
  "For additive subgroups generated by a single element, see the simpler
  `zsmul_induction_left`."]
theorem closure_induction_left {p : (x : G) → x ∈ closure s → Prop} (one : p 1 (one_mem _))
    (mul_left : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy → p (x * y) (mul_mem (subset_closure hx) hy))
    (mul_left_inv : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy →
      p (x⁻¹ * y) (mul_mem (inv_mem (subset_closure hx)) hy))
    {x : G} (h : x ∈ closure s) : p x h 
Arguments: {G : Type u_2} [Group G] {s : Set G} {p : (x : G) → x ∈ Subgroup.closure s → Prop} (one : p 1 ⋯) (mul_left : ∀ (x : G) (hx : x ∈ s) (y : G) (hy : y ∈ Subgroup.closure s), p y hy → p (x * y) ⋯) (mul_left_inv : ∀ (x : G) (hx : x ∈ s) (y : G) (hy : y ∈ Subgroup.closure s), p y hy → p (x⁻¹ * y) ⋯) {x : G} (h : x ∈ Subgroup.closure s)
Goal: p x h
-- AddSubgroup.closure_induction_left
@[to_additive (attr := elab_as_elim)
  "For additive subgroups generated by a single element, see the simpler
  `zsmul_induction_left`."]
theorem closure_induction_left {p : (x : G) → x ∈ closure s → Prop} (one : p 1 (one_mem _))
    (mul_left : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy → p (x * y) (mul_mem (subset_closure hx) hy))
    (mul_left_inv : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy →
      p (x⁻¹ * y) (mul_mem (inv_mem (subset_closure hx)) hy))
    {x : G} (h : x ∈ closure s) : p x h 
Arguments: {G : Type u_2} [AddGroup G] {s : Set G} {p : (x : G) → x ∈ AddSubgroup.closure s → Prop} (one : p 0 ⋯) (mul_left : ∀ (x : G) (hx : x ∈ s) (y : G) (hy : y ∈ AddSubgroup.closure s), p y hy → p (x + y) ⋯) (mul_left_inv : ∀ (x : G) (hx : x ∈ s) (y : G) (hy : y ∈ AddSubgroup.closure s), p y hy → p (-x + y) ⋯) {x : G} (h : x ∈ AddSubgroup.closure s)
Goal: p x h
-- AddSubgroup.closure_induction_right
@[to_additive (attr := elab_as_elim)
  "For additive subgroups generated by a single element, see the simpler
  `zsmul_induction_right`."]
theorem closure_induction_right {p : (x : G) → x ∈ closure s → Prop} (one : p 1 (one_mem _))
    (mul_right : ∀ (x) hx, ∀ y (hy : y ∈ s), p x hx → p (x * y) (mul_mem hx (subset_closure hy)))
    (mul_right_inv : ∀ (x) hx, ∀ y (hy : y ∈ s), p x hx →
      p (x * y⁻¹) (mul_mem hx (inv_mem (subset_closure hy))))
    {x : G} (h : x ∈ closure s) : p x h 
Arguments: {G : Type u_2} [AddGroup G] {s : Set G} {p : (x : G) → x ∈ AddSubgroup.closure s → Prop} (one : p 0 ⋯) (mul_right : ∀ (x : G) (hx : x ∈ AddSubgroup.closure s) (y : G) (hy : y ∈ s), p x hx → p (x + y) ⋯) (mul_right_inv : ∀ (x : G) (hx : x ∈ AddSubgroup.closure s) (y : G) (hy : y ∈ s), p x hx → p (x + -y) ⋯) {x : G} (h : x ∈ AddSubgroup.closure s)
Goal: p x h
-- Subgroup.closure_induction_right
@[to_additive (attr := elab_as_elim)
  "For additive subgroups generated by a single element, see the simpler
  `zsmul_induction_right`."]
theorem closure_induction_right {p : (x : G) → x ∈ closure s → Prop} (one : p 1 (one_mem _))
    (mul_right : ∀ (x) hx, ∀ y (hy : y ∈ s), p x hx → p (x * y) (mul_mem hx (subset_closure hy)))
    (mul_right_inv : ∀ (x) hx, ∀ y (hy : y ∈ s), p x hx →
      p (x * y⁻¹) (mul_mem hx (inv_mem (subset_closure hy))))
    {x : G} (h : x ∈ closure s) : p x h 
Arguments: {G : Type u_2} [Group G] {s : Set G} {p : (x : G) → x ∈ Subgroup.closure s → Prop} (one : p 1 ⋯) (mul_right : ∀ (x : G) (hx : x ∈ Subgroup.closure s) (y : G) (hy : y ∈ s), p x hx → p (x * y) ⋯) (mul_right_inv : ∀ (x : G) (hx : x ∈ Subgroup.closure s) (y : G) (hy : y ∈ s), p x hx → p (x * y⁻¹) ⋯) {x : G} (h : x ∈ Subgroup.closure s)
Goal: p x h
-- Subgroup.closure_inv
@[to_additive (attr := simp)]
theorem closure_inv (s : Set G) : closure s⁻¹ = closure s 
Arguments: {G : Type u_2} [Group G] (s : Set G)
Goal: Subgroup.closure s⁻¹ = Subgroup.closure s
-- AddSubgroup.closure_neg
@[to_additive (attr := simp)]
theorem closure_inv (s : Set G) : closure s⁻¹ = closure s 
Arguments: {G : Type u_2} [AddGroup G] (s : Set G)
Goal: AddSubgroup.closure (-s) = AddSubgroup.closure s
-- Subgroup.closure_induction''
@[to_additive (attr := elab_as_elim)
  "An induction principle for additive closure membership. If `p` holds for `0` and all
  elements of `k` and their negation, and is preserved under addition, then `p` holds for all
  elements of the additive closure of `k`."]
theorem closure_induction'' {p : (g : G) → g ∈ closure s → Prop}
    (mem : ∀ x (hx : x ∈ s), p x (subset_closure hx))
    (inv_mem : ∀ x (hx : x ∈ s), p x⁻¹ (inv_mem (subset_closure hx)))
    (one : p 1 (one_mem _))
    (mul : ∀ x y hx hy, p x hx → p y hy → p (x * y) (mul_mem hx hy))
    {x} (h : x ∈ closure s) : p x h 
Arguments: {G : Type u_2} [Group G] {s : Set G} {p : (g : G) → g ∈ Subgroup.closure s → Prop} (mem : ∀ (x : G) (hx : x ∈ s), p x ⋯) (inv_mem : ∀ (x : G) (hx : x ∈ s), p x⁻¹ ⋯) (one : p 1 ⋯) (mul : ∀ (x y : G) (hx : x ∈ Subgroup.closure s) (hy : y ∈ Subgroup.closure s), p x hx → p y hy → p (x * y) ⋯) {x : G} (h : x ∈ Subgroup.closure s)
Goal: p x h
-- AddSubgroup.closure_induction''
@[to_additive (attr := elab_as_elim)
  "An induction principle for additive closure membership. If `p` holds for `0` and all
  elements of `k` and their negation, and is preserved under addition, then `p` holds for all
  elements of the additive closure of `k`."]
theorem closure_induction'' {p : (g : G) → g ∈ closure s → Prop}
    (mem : ∀ x (hx : x ∈ s), p x (subset_closure hx))
    (inv_mem : ∀ x (hx : x ∈ s), p x⁻¹ (inv_mem (subset_closure hx)))
    (one : p 1 (one_mem _))
    (mul : ∀ x y hx hy, p x hx → p y hy → p (x * y) (mul_mem hx hy))
    {x} (h : x ∈ closure s) : p x h 
Arguments: {G : Type u_2} [AddGroup G] {s : Set G} {p : (g : G) → g ∈ AddSubgroup.closure s → Prop} (mem : ∀ (x : G) (hx : x ∈ s), p x ⋯) (inv_mem : ∀ (x : G) (hx : x ∈ s), p (-x) ⋯) (one : p 0 ⋯) (mul : ∀ (x y : G) (hx : x ∈ AddSubgroup.closure s) (hy : y ∈ AddSubgroup.closure s), p x hx → p y hy → p (x + y) ⋯) {x : G} (h : x ∈ AddSubgroup.closure s)
Goal: p x h