ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddHom.srangeRestrict_surjective
@[to_additive]
theorem srangeRestrict_surjective (f : M →ₙ* N) : Function.Surjective f.srangeRestrict 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (f : AddHom M N)
Goal: Function.Surjective ⇑f.srangeRestrict
-- MulHom.srangeRestrict_surjective
@[to_additive]
theorem srangeRestrict_surjective (f : M →ₙ* N) : Function.Surjective f.srangeRestrict 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (f : M →ₙ* N)
Goal: Function.Surjective ⇑f.srangeRestrict
-- MulHom.prod_map_comap_prod'
@[to_additive prod_map_comap_prod']
theorem prod_map_comap_prod' {M' : Type*} {N' : Type*} [Mul M'] [Mul N'] (f : M →ₙ* N)
    (g : M' →ₙ* N') (S : Subsemigroup N) (S' : Subsemigroup N') :
    (S.prod S').comap (prodMap f g) = (S.comap f).prod (S'.comap g) 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] {M' : Type u_5} {N' : Type u_6} [Mul M'] [Mul N'] (f : M →ₙ* N) (g : M' →ₙ* N') (S : Subsemigroup N) (S' : Subsemigroup N')
Goal: Subsemigroup.comap (f.prodMap g) (S.prod S') = (Subsemigroup.comap f S).prod (Subsemigroup.comap g S')
-- AddHom.prod_map_comap_prod'
@[to_additive prod_map_comap_prod']
theorem prod_map_comap_prod' {M' : Type*} {N' : Type*} [Mul M'] [Mul N'] (f : M →ₙ* N)
    (g : M' →ₙ* N') (S : Subsemigroup N) (S' : Subsemigroup N') :
    (S.prod S').comap (prodMap f g) = (S.comap f).prod (S'.comap g) 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] {M' : Type u_5} {N' : Type u_6} [Add M'] [Add N'] (f : AddHom M N) (g : AddHom M' N') (S : AddSubsemigroup N) (S' : AddSubsemigroup N')
Goal: AddSubsemigroup.comap (f.prodMap g) (S.prod S') = (AddSubsemigroup.comap f S).prod (AddSubsemigroup.comap g S')
-- MulHom.subsemigroupComap_apply_coe
@[to_additive (attr := simps)
  "The `AddHom` from the preimage of an additive subsemigroup to itself."]
def subsemigroupComap (f : M →ₙ* N) (N' : Subsemigroup N) :
    N'.comap f →ₙ* N' 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (f : M →ₙ* N) (N' : Subsemigroup N) (x : ↥(Subsemigroup.comap f N'))
Goal: ↑((f.subsemigroupComap N') x) = f ↑x
-- AddHom.subsemigroupComap_apply_coe
@[to_additive (attr := simps)
  "The `AddHom` from the preimage of an additive subsemigroup to itself."]
def subsemigroupComap (f : M →ₙ* N) (N' : Subsemigroup N) :
    N'.comap f →ₙ* N' 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (f : AddHom M N) (N' : AddSubsemigroup N) (x : ↥(AddSubsemigroup.comap f N'))
Goal: ↑((f.subsemigroupComap N') x) = f ↑x
-- AddHom.subsemigroupMap_apply_coe
@[to_additive (attr := simps)
      "the `AddHom` from an additive subsemigroup to its image. See
      `AddEquiv.addSubsemigroupMap` for a variant for `AddEquiv`s."]
def subsemigroupMap (f : M →ₙ* N) (M' : Subsemigroup M) :
    M' →ₙ* M'.map f 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (f : AddHom M N) (M' : AddSubsemigroup M) (x : ↥M')
Goal: ↑((f.subsemigroupMap M') x) = f ↑x
-- MulHom.subsemigroupMap_apply_coe
@[to_additive (attr := simps)
      "the `AddHom` from an additive subsemigroup to its image. See
      `AddEquiv.addSubsemigroupMap` for a variant for `AddEquiv`s."]
def subsemigroupMap (f : M →ₙ* N) (M' : Subsemigroup M) :
    M' →ₙ* M'.map f 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (f : M →ₙ* N) (M' : Subsemigroup M) (x : ↥M')
Goal: ↑((f.subsemigroupMap M') x) = f ↑x
-- MulHom.subsemigroupMap_surjective
@[to_additive]
theorem subsemigroupMap_surjective (f : M →ₙ* N) (M' : Subsemigroup M) :
    Function.Surjective (f.subsemigroupMap M') 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (f : M →ₙ* N) (M' : Subsemigroup M)
Goal: Function.Surjective ⇑(f.subsemigroupMap M')
-- AddHom.subsemigroupMap_surjective
@[to_additive]
theorem subsemigroupMap_surjective (f : M →ₙ* N) (M' : Subsemigroup M) :
    Function.Surjective (f.subsemigroupMap M') 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (f : AddHom M N) (M' : AddSubsemigroup M)
Goal: Function.Surjective ⇑(f.subsemigroupMap M')
-- Subsemigroup.srange_fst
@[to_additive (attr := simp)]
theorem srange_fst [Nonempty N] : (fst M N).srange = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] [Nonempty N]
Goal: (MulHom.fst M N).srange = ⊤
-- AddSubsemigroup.srange_fst
@[to_additive (attr := simp)]
theorem srange_fst [Nonempty N] : (fst M N).srange = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] [Nonempty N]
Goal: (AddHom.fst M N).srange = ⊤
-- AddSubsemigroup.srange_snd
@[to_additive (attr := simp)]
theorem srange_snd [Nonempty M] : (snd M N).srange = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] [Nonempty M]
Goal: (AddHom.snd M N).srange = ⊤
-- Subsemigroup.srange_snd
@[to_additive (attr := simp)]
theorem srange_snd [Nonempty M] : (snd M N).srange = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] [Nonempty M]
Goal: (MulHom.snd M N).srange = ⊤
-- Subsemigroup.prod_eq_top_iff
@[to_additive prod_eq_top_iff]
theorem prod_eq_top_iff [Nonempty M] [Nonempty N] {s : Subsemigroup M} {t : Subsemigroup N} :
    s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] [Nonempty M] [Nonempty N] {s : Subsemigroup M} {t : Subsemigroup N}
Goal: s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤
-- AddSubsemigroup.prod_eq_top_iff
@[to_additive prod_eq_top_iff]
theorem prod_eq_top_iff [Nonempty M] [Nonempty N] {s : Subsemigroup M} {t : Subsemigroup N} :
    s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] [Nonempty M] [Nonempty N] {s : AddSubsemigroup M} {t : AddSubsemigroup N}
Goal: s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤
-- AddSubsemigroup.range_subtype
@[to_additive (attr := simp)]
theorem range_subtype (s : Subsemigroup M) : (MulMemClass.subtype s).srange = s 
Arguments: {M : Type u_1} [Add M] (s : AddSubsemigroup M)
Goal: (AddMemClass.subtype s).srange = s
-- Subsemigroup.range_subtype
@[to_additive (attr := simp)]
theorem range_subtype (s : Subsemigroup M) : (MulMemClass.subtype s).srange = s 
Arguments: {M : Type u_1} [Mul M] (s : Subsemigroup M)
Goal: (MulMemClass.subtype s).srange = s
-- AddSubsemigroup.eq_top_iff'
@[to_additive]
theorem eq_top_iff' : S = ⊤ ↔ ∀ x : M, x ∈ S 
Arguments: {M : Type u_1} [Add M] (S : AddSubsemigroup M)
Goal: S = ⊤ ↔ ∀ (x : M), x ∈ S
-- Subsemigroup.eq_top_iff'
@[to_additive]
theorem eq_top_iff' : S = ⊤ ↔ ∀ x : M, x ∈ S 
Arguments: {M : Type u_1} [Mul M] (S : Subsemigroup M)
Goal: S = ⊤ ↔ ∀ (x : M), x ∈ S
-- AddEquiv.ofLeftInverse_apply
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive semigroup homomorphism `f : M →+ N` with a left-inverse
      `g : N → M` defines an additive equivalence between `M` and `f.srange`.
      This is a bidirectional version of `AddHom.srangeRestrict`. "]
def ofLeftInverse (f : M →ₙ* N) {g : N → M} (h : Function.LeftInverse g f) : M ≃* f.srange 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (f : AddHom M N) {g : N → M} (h : Function.LeftInverse g ⇑f) (a : M)
Goal: (AddEquiv.ofLeftInverse f h) a = f.srangeRestrict a
-- AddEquiv.ofLeftInverse_symm_apply
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive semigroup homomorphism `f : M →+ N` with a left-inverse
      `g : N → M` defines an additive equivalence between `M` and `f.srange`.
      This is a bidirectional version of `AddHom.srangeRestrict`. "]
def ofLeftInverse (f : M →ₙ* N) {g : N → M} (h : Function.LeftInverse g f) : M ≃* f.srange 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (f : AddHom M N) {g : N → M} (h : Function.LeftInverse g ⇑f)
Goal: ∀ (a : ↥f.srange), (AddEquiv.ofLeftInverse f h).symm a = g ↑a
-- MulEquiv.ofLeftInverse_symm_apply
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive semigroup homomorphism `f : M →+ N` with a left-inverse
      `g : N → M` defines an additive equivalence between `M` and `f.srange`.
      This is a bidirectional version of `AddHom.srangeRestrict`. "]
def ofLeftInverse (f : M →ₙ* N) {g : N → M} (h : Function.LeftInverse g f) : M ≃* f.srange 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (f : M →ₙ* N) {g : N → M} (h : Function.LeftInverse g ⇑f)
Goal: ∀ (a : ↥f.srange), (MulEquiv.ofLeftInverse f h).symm a = g ↑a
-- MulEquiv.ofLeftInverse_apply
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive semigroup homomorphism `f : M →+ N` with a left-inverse
      `g : N → M` defines an additive equivalence between `M` and `f.srange`.
      This is a bidirectional version of `AddHom.srangeRestrict`. "]
def ofLeftInverse (f : M →ₙ* N) {g : N → M} (h : Function.LeftInverse g f) : M ≃* f.srange 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (f : M →ₙ* N) {g : N → M} (h : Function.LeftInverse g ⇑f) (a : M)
Goal: (MulEquiv.ofLeftInverse f h) a = f.srangeRestrict a
-- AddEquiv.subsemigroupMap_symm_apply_coe
@[to_additive (attr := simps)
      "An `AddEquiv` `φ` between two additive semigroups `M` and `N` induces an `AddEquiv`
      between a subsemigroup `S ≤ M` and the subsemigroup `φ(S) ≤ N`.
      See `AddHom.addSubsemigroupMap` for a variant for `AddHom`s."]
def subsemigroupMap (e : M ≃* N) (S : Subsemigroup M) : S ≃* S.map (e : M →ₙ* N) 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (e : M ≃+ N) (S : AddSubsemigroup M) (x : ↥(AddSubsemigroup.map (↑e) S))
Goal: ↑((e.subsemigroupMap S).symm x) = e.symm ↑x
-- AddEquiv.subsemigroupMap_apply_coe
@[to_additive (attr := simps)
      "An `AddEquiv` `φ` between two additive semigroups `M` and `N` induces an `AddEquiv`
      between a subsemigroup `S ≤ M` and the subsemigroup `φ(S) ≤ N`.
      See `AddHom.addSubsemigroupMap` for a variant for `AddHom`s."]
def subsemigroupMap (e : M ≃* N) (S : Subsemigroup M) : S ≃* S.map (e : M →ₙ* N) 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (e : M ≃+ N) (S : AddSubsemigroup M) (x : ↥S)
Goal: ↑((e.subsemigroupMap S) x) = e ↑x
-- MulEquiv.subsemigroupMap_symm_apply_coe
@[to_additive (attr := simps)
      "An `AddEquiv` `φ` between two additive semigroups `M` and `N` induces an `AddEquiv`
      between a subsemigroup `S ≤ M` and the subsemigroup `φ(S) ≤ N`.
      See `AddHom.addSubsemigroupMap` for a variant for `AddHom`s."]
def subsemigroupMap (e : M ≃* N) (S : Subsemigroup M) : S ≃* S.map (e : M →ₙ* N) 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (e : M ≃* N) (S : Subsemigroup M) (x : ↥(Subsemigroup.map (↑e) S))
Goal: ↑((e.subsemigroupMap S).symm x) = e.symm ↑x
-- MulEquiv.subsemigroupMap_apply_coe
@[to_additive (attr := simps)
      "An `AddEquiv` `φ` between two additive semigroups `M` and `N` induces an `AddEquiv`
      between a subsemigroup `S ≤ M` and the subsemigroup `φ(S) ≤ N`.
      See `AddHom.addSubsemigroupMap` for a variant for `AddHom`s."]
def subsemigroupMap (e : M ≃* N) (S : Subsemigroup M) : S ≃* S.map (e : M →ₙ* N) 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (e : M ≃* N) (S : Subsemigroup M) (x : ↥S)
Goal: ↑((e.subsemigroupMap S) x) = e ↑x
-- Subsemigroup.map_comap_eq
@[to_additive]
theorem map_comap_eq (f : M →ₙ* N) (S : Subsemigroup N) : (S.comap f).map f = S ⊓ f.srange 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] (f : M →ₙ* N) (S : Subsemigroup N)
Goal: Subsemigroup.map f (Subsemigroup.comap f S) = S ⊓ f.srange
-- AddSubsemigroup.map_comap_eq
@[to_additive]
theorem map_comap_eq (f : M →ₙ* N) (S : Subsemigroup N) : (S.comap f).map f = S ⊓ f.srange 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] (f : AddHom M N) (S : AddSubsemigroup N)
Goal: AddSubsemigroup.map f (AddSubsemigroup.comap f S) = S ⊓ f.srange
-- Subsemigroup.map_comap_eq_self
@[to_additive]
theorem map_comap_eq_self {f : M →ₙ* N} {S : Subsemigroup N} (h : S ≤ f.srange) :
    (S.comap f).map f = S 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] {f : M →ₙ* N} {S : Subsemigroup N} (h : S ≤ f.srange)
Goal: Subsemigroup.map f (Subsemigroup.comap f S) = S
-- AddSubsemigroup.map_comap_eq_self
@[to_additive]
theorem map_comap_eq_self {f : M →ₙ* N} {S : Subsemigroup N} (h : S ≤ f.srange) :
    (S.comap f).map f = S 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] {f : AddHom M N} {S : AddSubsemigroup N} (h : S ≤ f.srange)
Goal: AddSubsemigroup.map f (AddSubsemigroup.comap f S) = S
-- val_toAddUnits_apply
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
Arguments: {G : Type u_10} [AddGroup G] (x : G)
Goal: ↑(toAddUnits x) = x
-- val_toUnits_apply
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
Arguments: {G : Type u_10} [Group G] (x : G)
Goal: ↑(toUnits x) = x
-- toUnits_symm_apply
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
Arguments: {G : Type u_10} [Group G] (x : Gˣ)
Goal: toUnits.symm x = ↑x
-- toAddUnits_symm_apply
@[to_additive (attr := simps apply_val symm_apply)
"An additive group is isomorphic to its group of additive units"]
def toUnits [Group G] : G ≃* Gˣ 
Arguments: {G : Type u_10} [AddGroup G] (x : AddUnits G)
Goal: toAddUnits.symm x = ↑x
-- toAddUnits_val_apply
@[to_additive (attr := simp)]
lemma toUnits_val_apply {G : Type*} [Group G] (x : Gˣ) : toUnits (x : G) = x 
Arguments: {G : Type u_12} [AddGroup G] (x : AddUnits G)
Goal: toAddUnits ↑x = x
-- toUnits_val_apply
@[to_additive (attr := simp)]
lemma toUnits_val_apply {G : Type*} [Group G] (x : Gˣ) : toUnits (x : G) = x 
Arguments: {G : Type u_12} [Group G] (x : Gˣ)
Goal: toUnits ↑x = x
-- Units.mapEquiv_symm
@[simp]
theorem mapEquiv_symm (h : M ≃* N) : (mapEquiv h).symm = mapEquiv h.symm 
Arguments: {M : Type u_6} {N : Type u_7} [Monoid M] [Monoid N] (h : M ≃* N)
Goal: (Units.mapEquiv h).symm = Units.mapEquiv h.symm
-- Units.coe_mapEquiv
@[simp]
theorem coe_mapEquiv (h : M ≃* N) (x : Mˣ) : (mapEquiv h x : N) = h x 
Arguments: {M : Type u_6} {N : Type u_7} [Monoid M] [Monoid N] (h : M ≃* N) (x : Mˣ)
Goal: ↑((Units.mapEquiv h) x) = h ↑x
-- AddUnits.addLeft_apply
@[to_additive (attr := simps (config := .asFn) apply)
  "Left addition of an additive unit is a permutation of the underlying type."]
def mulLeft (u : Mˣ) : Equiv.Perm M 
Arguments: {M : Type u_6} [AddMonoid M] (u : AddUnits M)
Goal: ⇑u.addLeft = fun x => ↑u + x
-- Units.mulLeft_apply
@[to_additive (attr := simps (config := .asFn) apply)
  "Left addition of an additive unit is a permutation of the underlying type."]
def mulLeft (u : Mˣ) : Equiv.Perm M 
Arguments: {M : Type u_6} [Monoid M] (u : Mˣ)
Goal: ⇑u.mulLeft = fun x => ↑u * x
-- Units.mulLeft_symm
@[to_additive (attr := simp)]
theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft 
Arguments: {M : Type u_6} [Monoid M] (u : Mˣ)
Goal: Equiv.symm u.mulLeft = u⁻¹.mulLeft
-- AddUnits.addLeft_symm
@[to_additive (attr := simp)]
theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft 
Arguments: {M : Type u_6} [AddMonoid M] (u : AddUnits M)
Goal: Equiv.symm u.addLeft = (-u).addLeft
-- Units.mulLeft_bijective
@[to_additive]
theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((a * ·) : M → M) 
Arguments: {M : Type u_6} [Monoid M] (a : Mˣ)
Goal: Function.Bijective fun x => ↑a * x
-- AddUnits.addLeft_bijective
@[to_additive]
theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((a * ·) : M → M) 
Arguments: {M : Type u_6} [AddMonoid M] (a : AddUnits M)
Goal: Function.Bijective fun x => ↑a + x
-- Units.mulRight_apply
@[to_additive (attr := simps (config := .asFn) apply)
"Right addition of an additive unit is a permutation of the underlying type."]
def mulRight (u : Mˣ) : Equiv.Perm M 
Arguments: {M : Type u_6} [Monoid M] (u : Mˣ)
Goal: ⇑u.mulRight = fun x => x * ↑u
-- AddUnits.addRight_apply
@[to_additive (attr := simps (config := .asFn) apply)
"Right addition of an additive unit is a permutation of the underlying type."]
def mulRight (u : Mˣ) : Equiv.Perm M 
Arguments: {M : Type u_6} [AddMonoid M] (u : AddUnits M)
Goal: ⇑u.addRight = fun x => x + ↑u
-- Units.mulRight_symm
@[to_additive (attr := simp)]
theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight 
Arguments: {M : Type u_6} [Monoid M] (u : Mˣ)
Goal: Equiv.symm u.mulRight = u⁻¹.mulRight
-- AddUnits.addRight_symm
@[to_additive (attr := simp)]
theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight 
Arguments: {M : Type u_6} [AddMonoid M] (u : AddUnits M)
Goal: Equiv.symm u.addRight = (-u).addRight
-- AddUnits.addRight_bijective
@[to_additive]
theorem mulRight_bijective (a : Mˣ) : Function.Bijective ((· * a) : M → M) 
Arguments: {M : Type u_6} [AddMonoid M] (a : AddUnits M)
Goal: Function.Bijective fun x => x + ↑a
-- Units.mulRight_bijective
@[to_additive]
theorem mulRight_bijective (a : Mˣ) : Function.Bijective ((· * a) : M → M) 
Arguments: {M : Type u_6} [Monoid M] (a : Mˣ)
Goal: Function.Bijective fun x => x * ↑a
-- Equiv.coe_mulLeft
@[to_additive (attr := simp)]
theorem coe_mulLeft (a : G) : ⇑(Equiv.mulLeft a) = (a * ·) 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: ⇑(Equiv.mulLeft a) = fun x => a * x
-- Equiv.coe_addLeft
@[to_additive (attr := simp)]
theorem coe_mulLeft (a : G) : ⇑(Equiv.mulLeft a) = (a * ·) 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: ⇑(Equiv.addLeft a) = fun x => a + x
-- Equiv.addLeft_symm_apply
@[to_additive "Extra simp lemma that `dsimp` can use. `simp` will never use this.",
  simp, nolint simpNF]
theorem mulLeft_symm_apply (a : G) : ((Equiv.mulLeft a).symm : G → G) = (a⁻¹ * ·) 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: ⇑(Equiv.symm (Equiv.addLeft a)) = fun x => -a + x
-- Equiv.mulLeft_symm_apply
@[to_additive "Extra simp lemma that `dsimp` can use. `simp` will never use this.",
  simp, nolint simpNF]
theorem mulLeft_symm_apply (a : G) : ((Equiv.mulLeft a).symm : G → G) = (a⁻¹ * ·) 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: ⇑(Equiv.symm (Equiv.mulLeft a)) = fun x => a⁻¹ * x
-- Equiv.mulLeft_symm
@[to_additive (attr := simp)]
theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: Equiv.symm (Equiv.mulLeft a) = Equiv.mulLeft a⁻¹
-- Equiv.addLeft_symm
@[to_additive (attr := simp)]
theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: Equiv.symm (Equiv.addLeft a) = Equiv.addLeft (-a)
-- Group.mulLeft_bijective
@[to_additive]
theorem _root_.Group.mulLeft_bijective (a : G) : Function.Bijective (a * ·) 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: Function.Bijective fun x => a * x
-- AddGroup.addLeft_bijective
@[to_additive]
theorem _root_.Group.mulLeft_bijective (a : G) : Function.Bijective (a * ·) 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: Function.Bijective fun x => a + x
-- Equiv.coe_mulRight
@[to_additive (attr := simp)]
theorem coe_mulRight (a : G) : ⇑(Equiv.mulRight a) = fun x => x * a 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: ⇑(Equiv.mulRight a) = fun x => x * a
-- Equiv.coe_addRight
@[to_additive (attr := simp)]
theorem coe_mulRight (a : G) : ⇑(Equiv.mulRight a) = fun x => x * a 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: ⇑(Equiv.addRight a) = fun x => x + a
-- Equiv.addRight_symm
@[to_additive (attr := simp)]
theorem mulRight_symm (a : G) : (Equiv.mulRight a).symm = Equiv.mulRight a⁻¹ 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: Equiv.symm (Equiv.addRight a) = Equiv.addRight (-a)
-- Equiv.mulRight_symm
@[to_additive (attr := simp)]
theorem mulRight_symm (a : G) : (Equiv.mulRight a).symm = Equiv.mulRight a⁻¹ 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: Equiv.symm (Equiv.mulRight a) = Equiv.mulRight a⁻¹
-- Equiv.addRight_symm_apply
@[to_additive "Extra simp lemma that `dsimp` can use. `simp` will never use this.",
  simp, nolint simpNF]
theorem mulRight_symm_apply (a : G) : ((Equiv.mulRight a).symm : G → G) = fun x => x * a⁻¹ 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: ⇑(Equiv.symm (Equiv.addRight a)) = fun x => x + -a
-- Equiv.mulRight_symm_apply
@[to_additive "Extra simp lemma that `dsimp` can use. `simp` will never use this.",
  simp, nolint simpNF]
theorem mulRight_symm_apply (a : G) : ((Equiv.mulRight a).symm : G → G) = fun x => x * a⁻¹ 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: ⇑(Equiv.symm (Equiv.mulRight a)) = fun x => x * a⁻¹
-- Group.mulRight_bijective
@[to_additive]
theorem _root_.Group.mulRight_bijective (a : G) : Function.Bijective (· * a) 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: Function.Bijective fun x => x * a
-- AddGroup.addRight_bijective
@[to_additive]
theorem _root_.Group.mulRight_bijective (a : G) : Function.Bijective (· * a) 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: Function.Bijective fun x => x + a
-- Equiv.divLeft_apply
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
Arguments: {G : Type u_10} [Group G] (a b : G)
Goal: (Equiv.divLeft a) b = a / b
-- Equiv.subLeft_symm_apply
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
Arguments: {G : Type u_10} [AddGroup G] (a b : G)
Goal: (Equiv.subLeft a).symm b = -b + a
-- Equiv.subLeft_apply
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
Arguments: {G : Type u_10} [AddGroup G] (a b : G)
Goal: (Equiv.subLeft a) b = a - b
-- Equiv.divLeft_symm_apply
@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
protected def divLeft (a : G) : G ≃ G 
Arguments: {G : Type u_10} [Group G] (a b : G)
Goal: (Equiv.divLeft a).symm b = b⁻¹ * a
-- Equiv.subLeft_eq_neg_trans_addLeft
@[to_additive]
theorem divLeft_eq_inv_trans_mulLeft (a : G) :
    Equiv.divLeft a = (Equiv.inv G).trans (Equiv.mulLeft a) 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: Equiv.subLeft a = Equiv.trans (Equiv.neg G) (Equiv.addLeft a)
-- Equiv.divLeft_eq_inv_trans_mulLeft
@[to_additive]
theorem divLeft_eq_inv_trans_mulLeft (a : G) :
    Equiv.divLeft a = (Equiv.inv G).trans (Equiv.mulLeft a) 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: Equiv.divLeft a = Equiv.trans (Equiv.inv G) (Equiv.mulLeft a)
-- Equiv.subRight_symm_apply
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
Arguments: {G : Type u_10} [AddGroup G] (a b : G)
Goal: (Equiv.subRight a).symm b = b + a
-- Equiv.subRight_apply
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
Arguments: {G : Type u_10} [AddGroup G] (a b : G)
Goal: (Equiv.subRight a) b = b - a
-- Equiv.divRight_symm_apply
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
Arguments: {G : Type u_10} [Group G] (a b : G)
Goal: (Equiv.divRight a).symm b = b * a
-- Equiv.divRight_apply
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G 
Arguments: {G : Type u_10} [Group G] (a b : G)
Goal: (Equiv.divRight a) b = b / a
-- Equiv.divRight_eq_mulRight_inv
@[to_additive]
theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹ 
Arguments: {G : Type u_10} [Group G] (a : G)
Goal: Equiv.divRight a = Equiv.mulRight a⁻¹
-- Equiv.subRight_eq_addRight_neg
@[to_additive]
theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹ 
Arguments: {G : Type u_10} [AddGroup G] (a : G)
Goal: Equiv.subRight a = Equiv.addRight (-a)
-- val_inv_unitsEquivProdSubtype_symm_apply
@[simps]
def unitsEquivProdSubtype [Monoid α] : αˣ ≃ {p : α × α // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1} 
Arguments: (α : Type u_2) [Monoid α] (p : { p // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1 })
Goal: ↑((unitsEquivProdSubtype α).symm p)⁻¹ = (↑p).2
-- unitsEquivProdSubtype_apply_coe
@[simps]
def unitsEquivProdSubtype [Monoid α] : αˣ ≃ {p : α × α // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1} 
Arguments: (α : Type u_2) [Monoid α] (u : αˣ)
Goal: ↑((unitsEquivProdSubtype α) u) = (↑u, ↑u⁻¹)