ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Lie/Derivation/AdjointAction.lean

full_name: LieDerivation.ad
code: /-- The adjoint action of a Lie algebra `L` on itself, seen as a morphism of Lie algebras from
`L` to its derivations.
Note the minus sign: this is chosen to so that `ad ⁅x, y⁆ = ⁅ad x, ad y⁆`. -/
@[simps!]
def ad : L →ₗ⁅R⁆ LieDerivation R L L 
goal: L →ₗ⁅R⁆ LieDerivation R L L

full_name: LieDerivation.ad_apply_apply
code: /-- The adjoint action of a Lie algebra `L` on itself, seen as a morphism of Lie algebras from
`L` to its derivations.
Note the minus sign: this is chosen to so that `ad ⁅x, y⁆ = ⁅ad x, ad y⁆`. -/
@[simps!]
def ad : L →ₗ⁅R⁆ LieDerivation R L L 
goal: ∀ (a_1 : L), ((LieDerivation.ad R L) a) a_1 = ⁅a, a_1⁆

full_name: LieDerivation.coe_ad_apply_eq_ad_apply
code: /-- The definitions `LieDerivation.ad` and `LieAlgebra.ad` agree. -/
@[simp] lemma coe_ad_apply_eq_ad_apply (x : L) : ad R L x = LieAlgebra.ad R L x 
goal: ↑((LieDerivation.ad R L) x) = (LieAlgebra.ad R L) x

full_name: LieDerivation.ad_apply_lieDerivation
code: lemma ad_apply_lieDerivation (x : L) (D : LieDerivation R L L) : ad R L (D x) = - ⁅x, D⁆ 
goal: (LieDerivation.ad R L) (D x) = -⁅x, D⁆

full_name: LieDerivation.lie_ad
code: lemma lie_ad (x : L) (D : LieDerivation R L L) : ⁅ad R L x, D⁆ = ⁅x, D⁆ 
goal: ⁅(LieDerivation.ad R L) x, D⁆ = ⁅x, D⁆

full_name: LieDerivation.ad_ker_eq_center
code: /-- The kernel of the adjoint action on a Lie algebra is equal to its center. -/
lemma ad_ker_eq_center : (ad R L).ker = LieAlgebra.center R L 
goal: (LieDerivation.ad R L).ker = LieAlgebra.center R L

full_name: LieDerivation.injective_ad_of_center_eq_bot
code: /-- If the center of a Lie algebra is trivial, then the adjoint action is injective. -/
lemma injective_ad_of_center_eq_bot (h : LieAlgebra.center R L = ⊥) :
    Function.Injective (ad R L) 
goal: Function.Injective ⇑(LieDerivation.ad R L)

full_name: LieDerivation.lie_der_ad_eq_ad_der
code: /-- The commutator of a derivation `D` and a derivation of the form `ad x` is `ad (D x)`. -/
lemma lie_der_ad_eq_ad_der (D : LieDerivation R L L) (x : L) : ⁅D, ad R L x⁆ = ad R L (D x) 
goal: ⁅D, (LieDerivation.ad R L) x⁆ = (LieDerivation.ad R L) (D x)

full_name: LieDerivation.ad_isIdealMorphism
code: /-- The range of the adjoint action homomorphism from a Lie algebra `L` to the Lie algebra of its
derivations is an ideal of the latter. -/
lemma ad_isIdealMorphism : (ad R L).IsIdealMorphism 
goal: (LieDerivation.ad R L).IsIdealMorphism

full_name: LieDerivation.mem_ad_idealRange_iff
code: /-- A derivation `D` belongs to the ideal range of the adjoint action iff it is of the form `ad x`
for some `x` in the Lie algebra `L`. -/
lemma mem_ad_idealRange_iff {D : LieDerivation R L L} :
    D ∈ (ad R L).idealRange ↔ ∃ x : L, ad R L x = D 
goal: D ∈ (LieDerivation.ad R L).idealRange ↔ ∃ x, (LieDerivation.ad R L) x = D

full_name: LieDerivation.maxTrivSubmodule_eq_bot_of_center_eq_bot
code: lemma maxTrivSubmodule_eq_bot_of_center_eq_bot (h : LieAlgebra.center R L = ⊥) :
    LieModule.maxTrivSubmodule R L (LieDerivation R L L) = ⊥ 
goal: LieModule.maxTrivSubmodule R L (LieDerivation R L L) = ⊥
File: Mathlib/Algebra/PEmptyInstances.lean

full_name: SemigroupPEmpty
code: @[to_additive]
instance SemigroupPEmpty : Semigroup PEmpty.{u + 1} 
goal: Semigroup PEmpty

full_name: AddSemigroupPEmpty
code: @[to_additive]
instance SemigroupPEmpty : Semigroup PEmpty.{u + 1} 
goal: AddSemigroup PEmpty
File: Mathlib/Algebra/Regular/Pow.lean

full_name: IsLeftRegular.pow
code: /-- Any power of a left-regular element is left-regular. -/
theorem IsLeftRegular.pow (n : ℕ) (rla : IsLeftRegular a) : IsLeftRegular (a ^ n) 
goal: IsLeftRegular (a ^ n)

full_name: IsRightRegular.pow
code: /-- Any power of a right-regular element is right-regular. -/
theorem IsRightRegular.pow (n : ℕ) (rra : IsRightRegular a) : IsRightRegular (a ^ n) 
goal: IsRightRegular (a ^ n)

full_name: IsRegular.pow
code: /-- Any power of a regular element is regular. -/
theorem IsRegular.pow (n : ℕ) (ra : IsRegular a) : IsRegular (a ^ n) 
goal: IsRegular (a ^ n)

full_name: IsLeftRegular.pow_iff
code: /-- An element `a` is left-regular if and only if a positive power of `a` is left-regular. -/
theorem IsLeftRegular.pow_iff {n : ℕ} (n0 : 0 < n) : IsLeftRegular (a ^ n) ↔ IsLeftRegular a 
goal: IsLeftRegular (a ^ n) ↔ IsLeftRegular a

full_name: IsRightRegular.pow_iff
code: /-- An element `a` is right-regular if and only if a positive power of `a` is right-regular. -/
theorem IsRightRegular.pow_iff {n : ℕ} (n0 : 0 < n) :
    IsRightRegular (a ^ n) ↔ IsRightRegular a 
goal: IsRightRegular (a ^ n) ↔ IsRightRegular a

full_name: IsRegular.pow_iff
code: /-- An element `a` is regular if and only if a positive power of `a` is regular. -/
theorem IsRegular.pow_iff {n : ℕ} (n0 : 0 < n) : IsRegular (a ^ n) ↔ IsRegular a 
goal: IsRegular (a ^ n) ↔ IsRegular a

full_name: IsLeftRegular.prod
code: lemma IsLeftRegular.prod (h : ∀ i ∈ s, IsLeftRegular (f i)) :
    IsLeftRegular (∏ i ∈ s, f i) 
goal: IsLeftRegular (∏ i ∈ s, f i)

full_name: IsRightRegular.prod
code: lemma IsRightRegular.prod (h : ∀ i ∈ s, IsRightRegular (f i)) :
    IsRightRegular (∏ i ∈ s, f i) 
goal: IsRightRegular (∏ i ∈ s, f i)

full_name: IsRegular.prod
code: lemma IsRegular.prod (h : ∀ i ∈ s, IsRegular (f i)) :
    IsRegular (∏ i ∈ s, f i) 
goal: IsRegular (∏ i ∈ s, f i)
File: Mathlib/Algebra/EuclideanDomain/Int.lean

full_name: Int.euclideanDomain
code: instance Int.euclideanDomain : EuclideanDomain ℤ 
goal: EuclideanDomain ℤ
File: Mathlib/Algebra/EuclideanDomain/Field.lean

full_name: Field.toEuclideanDomain
code: instance (priority := 100) Field.toEuclideanDomain {K : Type*} [Field K] : EuclideanDomain K 
goal: EuclideanDomain K
File: Mathlib/Algebra/FreeNonUnitalNonAssocAlgebra.lean

full_name: FreeNonUnitalNonAssocAlgebra
code: /-- The free non-unital, non-associative algebra on the type `X` with coefficients in `R`. -/
abbrev FreeNonUnitalNonAssocAlgebra 
goal: Type (max u v)

full_name: FreeNonUnitalNonAssocAlgebra.of
code: /-- The embedding of `X` into the free algebra with coefficients in `R`. -/
def of : X → FreeNonUnitalNonAssocAlgebra R X 
goal: X → FreeNonUnitalNonAssocAlgebra R X

full_name: FreeNonUnitalNonAssocAlgebra.lift
code: /-- The functor `X ↦ FreeNonUnitalNonAssocAlgebra R X` from the category of types to the
category of non-unital, non-associative algebras over `R` is adjoint to the forgetful functor in the
other direction. -/
def lift : (X → A) ≃ (FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) 
goal: (X → A) ≃ (FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A)

full_name: FreeNonUnitalNonAssocAlgebra.lift_symm_apply
code: @[simp]
theorem lift_symm_apply (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) :
    (lift R).symm F = F ∘ of R 
goal: (FreeNonUnitalNonAssocAlgebra.lift R).symm F = ⇑F ∘ FreeNonUnitalNonAssocAlgebra.of R

full_name: FreeNonUnitalNonAssocAlgebra.of_comp_lift
code: @[simp]
theorem of_comp_lift (f : X → A) : lift R f ∘ of R = f 
goal: ⇑((FreeNonUnitalNonAssocAlgebra.lift R) f) ∘ FreeNonUnitalNonAssocAlgebra.of R = f

full_name: FreeNonUnitalNonAssocAlgebra.lift_unique
code: @[simp]
theorem lift_unique (f : X → A) (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) :
    F ∘ of R = f ↔ F = lift R f 
goal: ⇑F ∘ FreeNonUnitalNonAssocAlgebra.of R = f ↔ F = (FreeNonUnitalNonAssocAlgebra.lift R) f

full_name: FreeNonUnitalNonAssocAlgebra.lift_of_apply
code: @[simp]
theorem lift_of_apply (f : X → A) (x) : lift R f (of R x) = f x 
goal: ((FreeNonUnitalNonAssocAlgebra.lift R) f) (FreeNonUnitalNonAssocAlgebra.of R x) = f x

full_name: FreeNonUnitalNonAssocAlgebra.lift_comp_of
code: @[simp]
theorem lift_comp_of (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) : lift R (F ∘ of R) = F 
goal: (FreeNonUnitalNonAssocAlgebra.lift R) (⇑F ∘ FreeNonUnitalNonAssocAlgebra.of R) = F

full_name: FreeNonUnitalNonAssocAlgebra.hom_ext
code: @[ext]
theorem hom_ext {F₁ F₂ : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A}
    (h : ∀ x, F₁ (of R x) = F₂ (of R x)) : F₁ = F₂ 
goal: F₁ = F₂
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

full_name: Commute.div_eq_div_iff
code: /-- The `MonoidWithZero` version of `div_eq_div_iff_mul_eq_mul`. -/
protected lemma div_eq_div_iff (hbd : Commute b d) (hb : b ≠ 0) (hd : d ≠ 0) :
    a / b = c / d ↔ a * d = c * b 
goal: a / b = c / d ↔ a * d = c * b

full_name: map_ne_zero
code: theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 
goal: f a ≠ 0 ↔ a ≠ 0

full_name: map_eq_zero
code: @[simp]
theorem map_eq_zero : f a = 0 ↔ a = 0 
goal: f a = 0 ↔ a = 0

full_name: eq_on_inv₀
code: theorem eq_on_inv₀ [MonoidWithZeroHomClass F' G₀ M₀'] (f g : F') (h : f a = g a) :
    f a⁻¹ = g a⁻¹ 
goal: f a⁻¹ = g a⁻¹

full_name: map_inv₀
code: /-- A monoid homomorphism between groups with zeros sending `0` to `0` sends `a⁻¹` to `(f a)⁻¹`. -/
@[simp]
theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ 
goal: f a⁻¹ = (f a)⁻¹

full_name: map_div₀
code: @[simp]
theorem map_div₀ : f (a / b) = f a / f b 
goal: f (a / b) = f a / f b

full_name: MonoidWithZero.inverse
code: /-- We define the inverse as a `MonoidWithZeroHom` by extending the inverse map by zero
on non-units. -/
noncomputable def MonoidWithZero.inverse {M : Type*} [CommMonoidWithZero M] :
    M →*₀ M 
goal: M →*₀ M

full_name: MonoidWithZero.coe_inverse
code: @[simp]
theorem MonoidWithZero.coe_inverse {M : Type*} [CommMonoidWithZero M] :
    (MonoidWithZero.inverse : M → M) = Ring.inverse 
goal: ⇑MonoidWithZero.inverse = Ring.inverse

full_name: MonoidWithZero.inverse_apply
code: @[simp]
theorem MonoidWithZero.inverse_apply {M : Type*} [CommMonoidWithZero M] (a : M) :
    MonoidWithZero.inverse a = Ring.inverse a 
goal: MonoidWithZero.inverse a = Ring.inverse a

full_name: invMonoidWithZeroHom
code: /-- Inversion on a commutative group with zero, considered as a monoid with zero homomorphism. -/
def invMonoidWithZeroHom {G₀ : Type*} [CommGroupWithZero G₀] : G₀ →*₀ G₀ 
goal: G₀ →*₀ G₀

full_name: Units.smul_mk0
code: @[simp]
theorem smul_mk0 {α : Type*} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α) : mk0 g hg • a = g • a 
goal: Units.mk0 g hg • a = g • a

full_name: map_zpow₀
code: /-- If a monoid homomorphism `f` between two `GroupWithZero`s maps `0` to `0`, then it maps `x^n`,
`n : ℤ`, to `(f x)^n`. -/
@[simp]
theorem map_zpow₀ {F G₀ G₀' : Type*} [GroupWithZero G₀] [GroupWithZero G₀'] [FunLike F G₀ G₀']
    [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ) : f (x ^ n) = f x ^ n 
goal: f (x ^ n) = f x ^ n
File: Mathlib/Algebra/GroupWithZero/Conj.lean

full_name: isConj_iff₀
code: @[simp] lemma isConj_iff₀ : IsConj a b ↔ ∃ c : α, c ≠ 0 ∧ c * a * c⁻¹ = b 
goal: IsConj a b ↔ ∃ c, c ≠ 0 ∧ c * a * c⁻¹ = b
File: Mathlib/Algebra/GroupWithZero/Units/Equiv.lean

full_name: Equiv.mulLeft₀_apply
code: /-- Left multiplication by a nonzero element in a `GroupWithZero` is a permutation of the
underlying type. -/
@[simps! (config := .asFn)]
protected def mulLeft₀ (a : G) (ha : a ≠ 0) : Perm G 
goal: ⇑(Equiv.mulLeft₀ a ha) = fun x => a * x

full_name: Equiv.mulLeft₀_symm_apply
code: /-- Left multiplication by a nonzero element in a `GroupWithZero` is a permutation of the
underlying type. -/
@[simps! (config := .asFn)]
protected def mulLeft₀ (a : G) (ha : a ≠ 0) : Perm G 
goal: ⇑(Equiv.symm (Equiv.mulLeft₀ a ha)) = fun x => a⁻¹ * x

full_name: Equiv.mulLeft₀
code: /-- Left multiplication by a nonzero element in a `GroupWithZero` is a permutation of the
underlying type. -/
@[simps! (config := .asFn)]
protected def mulLeft₀ (a : G) (ha : a ≠ 0) : Perm G 
goal: Equiv.Perm G

full_name: mulLeft_bijective₀
code: theorem _root_.mulLeft_bijective₀ (a : G) (ha : a ≠ 0) : Function.Bijective (a * · : G → G) 
goal: Function.Bijective fun x => a * x

full_name: Equiv.mulRight₀
code: /-- Right multiplication by a nonzero element in a `GroupWithZero` is a permutation of the
underlying type. -/
@[simps! (config := .asFn)]
protected def mulRight₀ (a : G) (ha : a ≠ 0) : Perm G 
goal: Equiv.Perm G

full_name: Equiv.mulRight₀_apply
code: /-- Right multiplication by a nonzero element in a `GroupWithZero` is a permutation of the
underlying type. -/
@[simps! (config := .asFn)]
protected def mulRight₀ (a : G) (ha : a ≠ 0) : Perm G 
goal: ⇑(Equiv.mulRight₀ a ha) = fun x => x * a

full_name: Equiv.mulRight₀_symm_apply
code: /-- Right multiplication by a nonzero element in a `GroupWithZero` is a permutation of the
underlying type. -/
@[simps! (config := .asFn)]
protected def mulRight₀ (a : G) (ha : a ≠ 0) : Perm G 
goal: ⇑(Equiv.symm (Equiv.mulRight₀ a ha)) = fun x => x * a⁻¹

full_name: mulRight_bijective₀
code: theorem _root_.mulRight_bijective₀ (a : G) (ha : a ≠ 0) : Function.Bijective ((· * a) : G → G) 
goal: Function.Bijective fun x => x * a
File: Mathlib/Algebra/GroupWithZero/Action/Opposite.lean

full_name: MulOpposite.instDistribMulAction
code: instance instDistribMulAction [Monoid M] [AddMonoid α] [DistribMulAction M α] :
    DistribMulAction M αᵐᵒᵖ 
goal: DistribMulAction M αᵐᵒᵖ

full_name: MulOpposite.instMulDistribMulAction
code: instance instMulDistribMulAction [Monoid M] [Monoid α] [MulDistribMulAction M α] :
    MulDistribMulAction M αᵐᵒᵖ 
goal: MulDistribMulAction M αᵐᵒᵖ

full_name: CancelMonoidWithZero.toFaithfulSMul_opposite
code: /-- `Monoid.toOppositeMulAction` is faithful on nontrivial cancellative monoids with zero. -/
instance CancelMonoidWithZero.toFaithfulSMul_opposite [CancelMonoidWithZero α]
    [Nontrivial α] : FaithfulSMul αᵐᵒᵖ α 
goal: FaithfulSMul αᵐᵒᵖ α
File: Mathlib/Algebra/GroupWithZero/Opposite.lean

full_name: MulOpposite.instMulZeroClass
code: instance instMulZeroClass [MulZeroClass α] : MulZeroClass αᵐᵒᵖ 
goal: MulZeroClass αᵐᵒᵖ

full_name: MulOpposite.instMulZeroOneClass
code: instance instMulZeroOneClass [MulZeroOneClass α] : MulZeroOneClass αᵐᵒᵖ 
goal: MulZeroOneClass αᵐᵒᵖ

full_name: MulOpposite.instSemigroupWithZero
code: instance instSemigroupWithZero [SemigroupWithZero α] : SemigroupWithZero αᵐᵒᵖ 
goal: SemigroupWithZero αᵐᵒᵖ

full_name: MulOpposite.instMonoidWithZero
code: instance instMonoidWithZero [MonoidWithZero α] : MonoidWithZero αᵐᵒᵖ 
goal: MonoidWithZero αᵐᵒᵖ

full_name: MulOpposite.instNoZeroDivisors
code: instance instNoZeroDivisors [Zero α] [Mul α] [NoZeroDivisors α] : NoZeroDivisors αᵐᵒᵖ 
goal: NoZeroDivisors αᵐᵒᵖ

full_name: AddOpposite.instMulZeroClass
code: instance instMulZeroClass [MulZeroClass α] : MulZeroClass αᵃᵒᵖ 
goal: MulZeroClass αᵃᵒᵖ

full_name: AddOpposite.instMulZeroOneClass
code: instance instMulZeroOneClass [MulZeroOneClass α] : MulZeroOneClass αᵃᵒᵖ 
goal: MulZeroOneClass αᵃᵒᵖ

full_name: AddOpposite.instSemigroupWithZero
code: instance instSemigroupWithZero [SemigroupWithZero α] : SemigroupWithZero αᵃᵒᵖ 
goal: SemigroupWithZero αᵃᵒᵖ

full_name: AddOpposite.instMonoidWithZero
code: instance instMonoidWithZero [MonoidWithZero α] : MonoidWithZero αᵃᵒᵖ 
goal: MonoidWithZero αᵃᵒᵖ

full_name: AddOpposite.instNoZeroDivisors
code: instance instNoZeroDivisors [Zero α] [Mul α] [NoZeroDivisors α] : NoZeroDivisors αᵃᵒᵖ 
goal: NoZeroDivisors αᵃᵒᵖ

full_name: AddOpposite.instGroupWithZero
code: instance instGroupWithZero [GroupWithZero α] : GroupWithZero αᵃᵒᵖ 
goal: GroupWithZero αᵃᵒᵖ
File: Mathlib/Algebra/GroupWithZero/Semiconj.lean

full_name: SemiconjBy.zero_right
code: @[simp]
theorem zero_right [MulZeroClass G₀] (a : G₀) : SemiconjBy a 0 0 
goal: SemiconjBy a 0 0

full_name: SemiconjBy.zero_left
code: @[simp]
theorem zero_left [MulZeroClass G₀] (x y : G₀) : SemiconjBy 0 x y 
goal: SemiconjBy 0 x y

full_name: SemiconjBy.inv_symm_left_iff₀
code: @[simp]
theorem inv_symm_left_iff₀ : SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x 
goal: SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x

full_name: SemiconjBy.inv_symm_left₀
code: theorem inv_symm_left₀ (h : SemiconjBy a x y) : SemiconjBy a⁻¹ y x 
goal: SemiconjBy a⁻¹ y x

full_name: SemiconjBy.inv_right₀
code: theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ 
goal: SemiconjBy a x⁻¹ y⁻¹

full_name: SemiconjBy.inv_right_iff₀
code: @[simp]
theorem inv_right_iff₀ : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y 
goal: SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y

full_name: SemiconjBy.div_right
code: theorem div_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x / x') (y / y') 
goal: SemiconjBy a (x / x') (y / y')

full_name: SemiconjBy.zpow_right₀
code: lemma zpow_right₀ {a x y : G₀} (h : SemiconjBy a x y) : ∀ m : ℤ, SemiconjBy a (x ^ m) (y ^ m)
  
goal: SemiconjBy a (x ^ m) (y ^ m)

full_name: Commute.zpow_right₀
code: lemma zpow_right₀ (h : Commute a b) : ∀ m : ℤ, Commute a (b ^ m) 
goal: Commute a (b ^ m)

full_name: Commute.zpow_left₀
code: lemma zpow_left₀ (h : Commute a b) (m : ℤ) : Commute (a ^ m) b 
goal: Commute (a ^ m) b

full_name: Commute.zpow_zpow₀
code: lemma zpow_zpow₀ (h : Commute a b) (m n : ℤ) : Commute (a ^ m) (b ^ n) 
goal: Commute (a ^ m) (b ^ n)

full_name: Commute.zpow_self₀
code: lemma zpow_self₀ (a : G₀) (n : ℤ) : Commute (a ^ n) a 
goal: Commute (a ^ n) a

full_name: Commute.self_zpow₀
code: lemma self_zpow₀ (a : G₀) (n : ℤ) : Commute a (a ^ n) 
goal: Commute a (a ^ n)

full_name: Commute.zpow_zpow_self₀
code: lemma zpow_zpow_self₀ (a : G₀) (m n : ℤ) : Commute (a ^ m) (a ^ n) 
goal: Commute (a ^ m) (a ^ n)
File: Mathlib/Algebra/GroupWithZero/Action/Units.lean

full_name: AddUnits.instVAdd_1
code: @[to_additive]
instance [Monoid M] [SMul M α] : SMul Mˣ α 
goal: VAdd (AddUnits M) α

full_name: Units.instSMul_1
code: @[to_additive]
instance [Monoid M] [SMul M α] : SMul Mˣ α 
goal: SMul Mˣ α

full_name: Units.instSMulZeroClass
code: instance instSMulZeroClass [Monoid M] [Zero α] [SMulZeroClass M α] : SMulZeroClass Mˣ α 
goal: SMulZeroClass Mˣ α

full_name: Units.instDistribSMulUnits
code: instance instDistribSMulUnits [Monoid M] [AddZeroClass α] [DistribSMul M α] :
    DistribSMul Mˣ α 
goal: DistribSMul Mˣ α

full_name: Units.instDistribMulAction
code: instance instDistribMulAction [Monoid M] [AddMonoid α] [DistribMulAction M α] :
    DistribMulAction Mˣ α 
goal: DistribMulAction Mˣ α

full_name: Units.instMulDistribMulAction
code: instance instMulDistribMulAction [Monoid M] [Monoid α] [MulDistribMulAction M α] :
    MulDistribMulAction Mˣ α 
goal: MulDistribMulAction Mˣ α

full_name: Units.mulDistribMulAction'
code: /-- A stronger form of `Units.mul_action'`. -/
instance mulDistribMulAction' [Group G] [Monoid M] [MulDistribMulAction G M] [SMulCommClass G M M]
    [IsScalarTower G M M] : MulDistribMulAction G Mˣ 
goal: MulDistribMulAction G Mˣ
File: Mathlib/Algebra/GroupWithZero/Action/Pi.lean

full_name: Pi.smulZeroClass
code: instance smulZeroClass (α) {n : ∀ i, Zero <| f i} [∀ i, SMulZeroClass α <| f i] :
  @SMulZeroClass α (∀ i : I, f i) (@Pi.instZero I f n) 
goal: SMulZeroClass α ((i : I) → f i)

full_name: Pi.smulZeroClass'
code: instance smulZeroClass' {g : I → Type*} {n : ∀ i, Zero <| g i} [∀ i, SMulZeroClass (f i) (g i)] :
  @SMulZeroClass (∀ i, f i) (∀ i : I, g i) (@Pi.instZero I g n) 
goal: SMulZeroClass ((i : I) → f i) ((i : I) → g i)

full_name: Pi.distribSMul
code: instance distribSMul (α) {n : ∀ i, AddZeroClass <| f i} [∀ i, DistribSMul α <| f i] :
  @DistribSMul α (∀ i : I, f i) (@Pi.addZeroClass I f n) 
goal: DistribSMul α ((i : I) → f i)

full_name: Pi.distribSMul'
code: instance distribSMul' {g : I → Type*} {n : ∀ i, AddZeroClass <| g i}
  [∀ i, DistribSMul (f i) (g i)] :
  @DistribSMul (∀ i, f i) (∀ i : I, g i) (@Pi.addZeroClass I g n) 
goal: DistribSMul ((i : I) → f i) ((i : I) → g i)

full_name: Pi.distribMulAction
code: instance distribMulAction (α) {m : Monoid α} {n : ∀ i, AddMonoid <| f i}
    [∀ i, DistribMulAction α <| f i] : @DistribMulAction α (∀ i : I, f i) m (@Pi.addMonoid I f n) 
goal: DistribMulAction α ((i : I) → f i)

full_name: Pi.distribMulAction'
code: instance distribMulAction' {g : I → Type*} {m : ∀ i, Monoid (f i)} {n : ∀ i, AddMonoid <| g i}
    [∀ i, DistribMulAction (f i) (g i)] :
    @DistribMulAction (∀ i, f i) (∀ i : I, g i) (@Pi.monoid I f m) (@Pi.addMonoid I g n) 
goal: DistribMulAction ((i : I) → f i) ((i : I) → g i)

full_name: Pi.single_smul
code: theorem single_smul {α} [Monoid α] [∀ i, AddMonoid <| f i] [∀ i, DistribMulAction α <| f i]
    [DecidableEq I] (i : I) (r : α) (x : f i) : single i (r • x) = r • single i x 
goal: Pi.single i (r • x) = r • Pi.single i x

full_name: Pi.single_smul'
code: /-- A version of `Pi.single_smul` for non-dependent functions. It is useful in cases where Lean
fails to apply `Pi.single_smul`. -/
theorem single_smul' {α β} [Monoid α] [AddMonoid β] [DistribMulAction α β] [DecidableEq I] (i : I)
    (r : α) (x : β) : single (f := fun _ => β) i (r • x) = r • single (f := fun _ => β) i x 
goal: Pi.single i (r • x) = r • Pi.single i x

full_name: Pi.single_smul₀
code: theorem single_smul₀ {g : I → Type*} [∀ i, MonoidWithZero (f i)] [∀ i, AddMonoid (g i)]
    [∀ i, DistribMulAction (f i) (g i)] [DecidableEq I] (i : I) (r : f i) (x : g i) :
    single i (r • x) = single i r • single i x 
goal: Pi.single i (r • x) = Pi.single i r • Pi.single i x

full_name: Pi.mulDistribMulAction
code: instance mulDistribMulAction (α) {m : Monoid α} {n : ∀ i, Monoid <| f i}
    [∀ i, MulDistribMulAction α <| f i] :
    @MulDistribMulAction α (∀ i : I, f i) m (@Pi.monoid I f n) 
goal: MulDistribMulAction α ((i : I) → f i)

full_name: Pi.mulDistribMulAction'
code: instance mulDistribMulAction' {g : I → Type*} {m : ∀ i, Monoid (f i)} {n : ∀ i, Monoid <| g i}
    [∀ i, MulDistribMulAction (f i) (g i)] :
    @MulDistribMulAction (∀ i, f i) (∀ i : I, g i) (@Pi.monoid I f m) (@Pi.monoid I g n) 
goal: MulDistribMulAction ((i : I) → f i) ((i : I) → g i)
File: Mathlib/Algebra/Order/CauSeq/BigOperators.lean

full_name: IsCauSeq.of_abv_le
code: lemma of_abv_le (n : ℕ) (hm : ∀ m, n ≤ m → abv (f m) ≤ a m) :
    IsCauSeq abs (fun n ↦ ∑ i ∈ range n, a i) → IsCauSeq abv fun n ↦ ∑ i ∈ range n, f i 
goal: (IsCauSeq abs fun n => ∑ i ∈ Finset.range n, a i) → IsCauSeq abv fun n => ∑ i ∈ Finset.range n, f i

full_name: IsCauSeq.of_abv
code: lemma of_abv (hf : IsCauSeq abs fun m ↦ ∑ n ∈ range m, abv (f n)) :
    IsCauSeq abv fun m ↦ ∑ n ∈ range m, f n 
goal: IsCauSeq abv fun m => ∑ n ∈ Finset.range m, f n

full_name: cauchy_product
code: theorem _root_.cauchy_product (ha : IsCauSeq abs fun m ↦ ∑ n ∈ range m, abv (f n))
    (hb : IsCauSeq abv fun m ↦ ∑ n ∈ range m, g n) (ε : α) (ε0 : 0 < ε) :
    ∃ i : ℕ, ∀ j ≥ i,
      abv ((∑ k ∈ range j, f k) * ∑ k ∈ range j, g k -
        ∑ n ∈ range j, ∑ m ∈ range (n + 1), f m * g (n - m)) < ε 
goal: ∃ i,
  ∀ j ≥ i,
    abv
        ((∑ k ∈ Finset.range j, f k) * ∑ k ∈ Finset.range j, g k -
          ∑ n ∈ Finset.range j, ∑ m ∈ Finset.range (n + 1), f m * g (n - m)) <
      ε

full_name: IsCauSeq.of_decreasing_bounded
code: lemma of_decreasing_bounded (f : ℕ → α) {a : α} {m : ℕ} (ham : ∀ n ≥ m, |f n| ≤ a)
    (hnm : ∀ n ≥ m, f n.succ ≤ f n) : IsCauSeq abs f 
goal: IsCauSeq abs f

full_name: IsCauSeq.of_mono_bounded
code: lemma of_mono_bounded (f : ℕ → α) {a : α} {m : ℕ} (ham : ∀ n ≥ m, |f n| ≤ a)
    (hnm : ∀ n ≥ m, f n ≤ f n.succ) : IsCauSeq abs f 
goal: IsCauSeq abs f

full_name: IsCauSeq.geo_series
code: lemma geo_series [Nontrivial β] (x : β) (hx1 : abv x < 1) :
    IsCauSeq abv fun n ↦ ∑ m ∈ range n, x ^ m 
goal: IsCauSeq abv fun n => ∑ m ∈ Finset.range n, x ^ m

full_name: IsCauSeq.geo_series_const
code: lemma geo_series_const (a : α) {x : α} (hx1 : |x| < 1) :
    IsCauSeq abs fun m ↦ ∑ n ∈ range m, (a * x ^ n) 
goal: IsCauSeq abs fun m => ∑ n ∈ Finset.range m, a * x ^ n

full_name: IsCauSeq.series_ratio_test
code: lemma series_ratio_test {f : ℕ → β} (n : ℕ) (r : α) (hr0 : 0 ≤ r) (hr1 : r < 1)
    (h : ∀ m, n ≤ m → abv (f m.succ) ≤ r * abv (f m)) :
    IsCauSeq abv fun m ↦ ∑ n ∈ range m, f n 
goal: IsCauSeq abv fun m => ∑ n ∈ Finset.range m, f n