ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Module.Baer.iff_injective
protected theorem iff_injective [Small.{v} R] : Module.Baer R Q ↔ Module.Injective R Q 
Arguments: {R : Type u} [Ring R] {Q : Type v} [AddCommGroup Q] [Module R Q] [Small.{v, u} R]
Goal: Module.Baer R Q ↔ Module.Injective R Q
-- Module.ulift_injective_of_injective
lemma Module.ulift_injective_of_injective [Small.{v} R]
    (inj : Module.Injective R M) :
    Module.Injective R (ULift.{v'} M) 
Arguments: (R : Type u) [Ring R] {M : Type v} [AddCommGroup M] [Module R M] [Small.{v, u} R] (inj : Module.Injective R M)
Goal: Module.Injective R (ULift.{v', v} M)
-- Module.injective_of_ulift_injective
lemma Module.injective_of_ulift_injective
    (inj : Module.Injective R (ULift.{v'} M)) :
    Module.Injective R M 
Arguments: (R : Type u) [Ring R] {M : Type v} [AddCommGroup M] [Module R M] (inj : Module.Injective R (ULift.{v', v} M))
Goal: Module.Injective R M
-- Module.injective_iff_ulift_injective
lemma Module.injective_iff_ulift_injective :
    Module.Injective R M ↔ Module.Injective R (ULift.{v'} M) 
Arguments: (R : Type u) [Ring R] (M : Type v) [AddCommGroup M] [Module R M] [Small.{v, u} R]
Goal: Module.Injective R M ↔ Module.Injective R (ULift.{v', v} M)
-- Module.Injective.extension_property
lemma Module.Injective.extension_property
    (f : P →ₗ[R] P') (hf : Function.Injective f)
    (g : P →ₗ[R] M) : ∃ h : P' →ₗ[R] M, h ∘ₗ f = g 
Arguments: (R : Type uR) [Ring R] [Small.{uM, uR} R] (M : Type uM) [AddCommGroup M] [Module R M] [inj : Module.Injective R M] (P : Type uP) [AddCommGroup P] [Module R P] (P' : Type uP') [AddCommGroup P'] [Module R P'] (f : P →ₗ[R] P') (hf : Function.Injective ⇑f) (g : P →ₗ[R] M)
Goal: ∃ h, h ∘ₗ f = g
-- CentroidHom.star_apply
@[simp] lemma star_apply (f : CentroidHom α) (a : α) : (star f) a = star (f (star a)) 
Arguments: {α : Type u_1} [NonUnitalNonAssocSemiring α] [StarRing α] (f : CentroidHom α) (a : α)
Goal: (star f) a = star (f (star a))
-- CentroidHom.star_centerToCentroidCenter
theorem star_centerToCentroidCenter (z : NonUnitalStarSubsemiring.center α) :
    star (centerToCentroidCenter z) =
      (centerToCentroidCenter (star z : NonUnitalStarSubsemiring.center α)) 
Arguments: {α : Type u_1} [NonUnitalNonAssocSemiring α] [StarRing α] (z : ↥(NonUnitalStarSubsemiring.center α))
Goal: star (CentroidHom.centerToCentroidCenter z) = CentroidHom.centerToCentroidCenter (star z)
-- CentroidHom.starCenterToCentroid_apply
lemma starCenterToCentroid_apply (z : NonUnitalStarSubsemiring.center α) (a : α) :
    (starCenterToCentroid z) a = z * a 
Arguments: {α : Type u_1} [NonUnitalNonAssocSemiring α] [StarRing α] (z : ↥(NonUnitalStarSubsemiring.center α)) (a : α)
Goal: (CentroidHom.starCenterToCentroid z) a = ↑z * a
-- CentroidHom.starCenterIsoCentroid_apply
@[simp]
lemma starCenterIsoCentroid_apply (a : ↥(NonUnitalStarSubsemiring.center α)) :
    CentroidHom.starCenterIsoCentroid a = CentroidHom.starCenterToCentroid a 
Arguments: {α : Type u_1} [NonAssocSemiring α] [StarRing α] (a : ↥(NonUnitalStarSubsemiring.center α))
Goal: CentroidHom.starCenterIsoCentroid a = CentroidHom.starCenterToCentroid a
-- CentroidHom.starCenterIsoCentroid_symm_apply_coe
@[simp]
lemma starCenterIsoCentroid_symm_apply_coe (T : CentroidHom α) :
    ↑(CentroidHom.starCenterIsoCentroid.symm T) = T 1 
Arguments: {α : Type u_1} [NonAssocSemiring α] [StarRing α] (T : CentroidHom α)
Goal: ↑(CentroidHom.starCenterIsoCentroid.symm T) = T 1
-- StarMemClass.star_mem
class StarMemClass (S R : Type*) [Star R] [SetLike S R] : Prop where
    star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s
Arguments: {S : Type u_1} {R : Type u_2} [Star R] [SetLike S R] [self : StarMemClass S R] {s : S} {r : R}
Goal: r ∈ s → star r ∈ s
-- StarMemClass.coe_star
@[simp] lemma coe_star (x : s) : star x = star (x : R) 
Arguments: {R : Type u} {S : Type w} [Star R] [SetLike S R] [hS : StarMemClass S R] (s : S) (x : ↥s)
Goal: ↑(star x) = star ↑x
-- InvolutiveStar.star_involutive
class InvolutiveStar (R : Type u) extends Star R where
    star_involutive : Function.Involutive star
Arguments: {R : Type u} [self : InvolutiveStar R]
Goal: Function.Involutive star
-- star_star
@[simp]
theorem star_star [InvolutiveStar R] (r : R) : star (star r) = r 
Arguments: {R : Type u} [InvolutiveStar R] (r : R)
Goal: star (star r) = r
-- star_injective
theorem star_injective [InvolutiveStar R] : Function.Injective (star : R → R) 
Arguments: {R : Type u} [InvolutiveStar R]
Goal: Function.Injective star
-- star_inj
@[simp]
theorem star_inj [InvolutiveStar R] {x y : R} : star x = star y ↔ x = y 
Arguments: {R : Type u} [InvolutiveStar R] {x y : R}
Goal: star x = star y ↔ x = y
-- eq_star_of_eq_star
theorem eq_star_of_eq_star [InvolutiveStar R] {r s : R} (h : r = star s) : s = star r 
Arguments: {R : Type u} [InvolutiveStar R] {r s : R} (h : r = star s)
Goal: s = star r
-- eq_star_iff_eq_star
theorem eq_star_iff_eq_star [InvolutiveStar R] {r s : R} : r = star s ↔ s = star r 
Arguments: {R : Type u} [InvolutiveStar R] {r s : R}
Goal: r = star s ↔ s = star r
-- star_eq_iff_star_eq
theorem star_eq_iff_star_eq [InvolutiveStar R] {r s : R} : star r = s ↔ star s = r 
Arguments: {R : Type u} [InvolutiveStar R] {r s : R}
Goal: star r = s ↔ star s = r
-- TrivialStar.star_trivial
class TrivialStar (R : Type u) [Star R] : Prop where
    star_trivial : ∀ r : R, star r = r
Arguments: {R : Type u} [Star R] [self : TrivialStar R] (r : R)
Goal: star r = r
-- StarMul.star_mul
class StarMul (R : Type u) [Mul R] extends InvolutiveStar R where
    star_mul : ∀ r s : R, star (r * s) = star s * star r
Arguments: {R : Type u} [Mul R] [self : StarMul R] (r s : R)
Goal: star (r * s) = star s * star r
-- star_star_mul
theorem star_star_mul (x y : R) : star (star x * y) = star y * x 
Arguments: {R : Type u} [Mul R] [StarMul R] (x y : R)
Goal: star (star x * y) = star y * x
-- star_mul_star
theorem star_mul_star (x y : R) : star (x * star y) = y * star x 
Arguments: {R : Type u} [Mul R] [StarMul R] (x y : R)
Goal: star (x * star y) = y * star x
-- semiconjBy_star_star_star
@[simp]
theorem semiconjBy_star_star_star {x y z : R} :
    SemiconjBy (star x) (star z) (star y) ↔ SemiconjBy x y z 
Arguments: {R : Type u} [Mul R] [StarMul R] {x y z : R}
Goal: SemiconjBy (star x) (star z) (star y) ↔ SemiconjBy x y z
-- commute_star_star
@[simp]
theorem commute_star_star {x y : R} : Commute (star x) (star y) ↔ Commute x y 
Arguments: {R : Type u} [Mul R] [StarMul R] {x y : R}
Goal: Commute (star x) (star y) ↔ Commute x y
-- commute_star_comm
theorem commute_star_comm {x y : R} : Commute (star x) y ↔ Commute x (star y) 
Arguments: {R : Type u} [Mul R] [StarMul R] {x y : R}
Goal: Commute (star x) y ↔ Commute x (star y)
-- star_mul'
@[simp]
theorem star_mul' [CommSemigroup R] [StarMul R] (x y : R) : star (x * y) = star x * star y 
Arguments: {R : Type u} [CommSemigroup R] [StarMul R] (x y : R)
Goal: star (x * y) = star x * star y
-- starMulEquiv_apply
@[simps apply]
def starMulEquiv [Mul R] [StarMul R] : R ≃* Rᵐᵒᵖ 
Arguments: {R : Type u} [Mul R] [StarMul R] (x : R)
Goal: starMulEquiv x = MulOpposite.op (star x)
-- starMulAut_apply
@[simps apply]
def starMulAut [CommSemigroup R] [StarMul R] : MulAut R 
Arguments: {R : Type u} [CommSemigroup R] [StarMul R]
Goal: ∀ (a : R), starMulAut a = star a
-- star_one
@[simp]
theorem star_one [MulOneClass R] [StarMul R] : star (1 : R) = 1 
Arguments: (R : Type u) [MulOneClass R] [StarMul R]
Goal: star 1 = 1
-- star_pow
@[simp]
theorem star_pow [Monoid R] [StarMul R] (x : R) (n : ℕ) : star (x ^ n) = star x ^ n 
Arguments: {R : Type u} [Monoid R] [StarMul R] (x : R) (n : ℕ)
Goal: star (x ^ n) = star x ^ n
-- star_inv
@[simp]
theorem star_inv [Group R] [StarMul R] (x : R) : star x⁻¹ = (star x)⁻¹ 
Arguments: {R : Type u} [Group R] [StarMul R] (x : R)
Goal: star x⁻¹ = (star x)⁻¹
-- star_zpow
@[simp]
theorem star_zpow [Group R] [StarMul R] (x : R) (z : ℤ) : star (x ^ z) = star x ^ z 
Arguments: {R : Type u} [Group R] [StarMul R] (x : R) (z : ℤ)
Goal: star (x ^ z) = star x ^ z
-- star_div
@[simp]
theorem star_div [CommGroup R] [StarMul R] (x y : R) : star (x / y) = star x / star y 
Arguments: {R : Type u} [CommGroup R] [StarMul R] (x y : R)
Goal: star (x / y) = star x / star y
-- star_id_of_comm
theorem star_id_of_comm {R : Type*} [CommSemiring R] {x : R} : star x = x 
Arguments: {R : Type u_1} [CommSemiring R] {x : R}
Goal: star x = x
-- StarAddMonoid.star_add
class StarAddMonoid (R : Type u) [AddMonoid R] extends InvolutiveStar R where
    star_add : ∀ r s : R, star (r + s) = star r + star s
Arguments: {R : Type u} [AddMonoid R] [self : StarAddMonoid R] (r s : R)
Goal: star (r + s) = star r + star s
-- starAddEquiv_apply
@[simps apply]
def starAddEquiv [AddMonoid R] [StarAddMonoid R] : R ≃+ R 
Arguments: {R : Type u} [AddMonoid R] [StarAddMonoid R]
Goal: ∀ (a : R), starAddEquiv a = star a
-- star_zero
@[simp]
theorem star_zero [AddMonoid R] [StarAddMonoid R] : star (0 : R) = 0 
Arguments: (R : Type u) [AddMonoid R] [StarAddMonoid R]
Goal: star 0 = 0
-- star_eq_zero
@[simp]
theorem star_eq_zero [AddMonoid R] [StarAddMonoid R] {x : R} : star x = 0 ↔ x = 0 
Arguments: {R : Type u} [AddMonoid R] [StarAddMonoid R] {x : R}
Goal: star x = 0 ↔ x = 0
-- star_ne_zero
theorem star_ne_zero [AddMonoid R] [StarAddMonoid R] {x : R} : star x ≠ 0 ↔ x ≠ 0 
Arguments: {R : Type u} [AddMonoid R] [StarAddMonoid R] {x : R}
Goal: star x ≠ 0 ↔ x ≠ 0
-- star_neg
@[simp]
theorem star_neg [AddGroup R] [StarAddMonoid R] (r : R) : star (-r) = -star r 
Arguments: {R : Type u} [AddGroup R] [StarAddMonoid R] (r : R)
Goal: star (-r) = -star r
-- star_sub
@[simp]
theorem star_sub [AddGroup R] [StarAddMonoid R] (r s : R) : star (r - s) = star r - star s 
Arguments: {R : Type u} [AddGroup R] [StarAddMonoid R] (r s : R)
Goal: star (r - s) = star r - star s
-- star_nsmul
@[simp]
theorem star_nsmul [AddMonoid R] [StarAddMonoid R] (x : R) (n : ℕ) : star (n • x) = n • star x 
Arguments: {R : Type u} [AddMonoid R] [StarAddMonoid R] (x : R) (n : ℕ)
Goal: star (n • x) = n • star x
-- star_zsmul
@[simp]
theorem star_zsmul [AddGroup R] [StarAddMonoid R] (x : R) (n : ℤ) : star (n • x) = n • star x 
Arguments: {R : Type u} [AddGroup R] [StarAddMonoid R] (x : R) (n : ℤ)
Goal: star (n • x) = n • star x
-- StarRing.star_add
class StarRing (R : Type u) [NonUnitalNonAssocSemiring R] extends StarMul R where
    star_add : ∀ r s : R, star (r + s) = star r + star s
Arguments: {R : Type u} [NonUnitalNonAssocSemiring R] [self : StarRing R] (r s : R)
Goal: star (r + s) = star r + star s
-- starRingEquiv_apply
@[simps apply]
def starRingEquiv [NonUnitalNonAssocSemiring R] [StarRing R] : R ≃+* Rᵐᵒᵖ 
Arguments: {R : Type u} [NonUnitalNonAssocSemiring R] [StarRing R] (x : R)
Goal: starRingEquiv x = MulOpposite.op (star x)
-- star_natCast
@[simp, norm_cast]
theorem star_natCast [NonAssocSemiring R] [StarRing R] (n : ℕ) : star (n : R) = n 
Arguments: {R : Type u} [NonAssocSemiring R] [StarRing R] (n : ℕ)
Goal: star ↑n = ↑n
-- star_ofNat
@[simp]
theorem star_ofNat [NonAssocSemiring R] [StarRing R] (n : ℕ) [n.AtLeastTwo] :
    star (no_index (OfNat.ofNat n) : R) = OfNat.ofNat n 
Arguments: {R : Type u} [NonAssocSemiring R] [StarRing R] (n : ℕ) [n.AtLeastTwo]
Goal: star (OfNat.ofNat n) = OfNat.ofNat n
-- star_intCast
@[simp, norm_cast]
theorem star_intCast [Ring R] [StarRing R] (z : ℤ) : star (z : R) = z 
Arguments: {R : Type u} [Ring R] [StarRing R] (z : ℤ)
Goal: star ↑z = ↑z
-- starRingAut_apply
@[simps apply]
def starRingAut : RingAut R 
Arguments: {R : Type u} [CommSemiring R] [StarRing R]
Goal: ∀ (a : R), starRingAut a = star a
-- starRingEnd_apply
theorem starRingEnd_apply (x : R) : starRingEnd R x = star x 
Arguments: {R : Type u} [CommSemiring R] [StarRing R] (x : R)
Goal: (starRingEnd R) x = star x
-- starRingEnd_self_apply
theorem starRingEnd_self_apply (x : R) : starRingEnd R (starRingEnd R x) = x 
Arguments: {R : Type u} [CommSemiring R] [StarRing R] (x : R)
Goal: (starRingEnd R) ((starRingEnd R) x) = x
-- RingHom.star_def
theorem RingHom.star_def {S : Type*} [NonAssocSemiring S] (f : S →+* R) :
    Star.star f = RingHom.comp (starRingEnd R) f 
Arguments: {R : Type u} [CommSemiring R] [StarRing R] {S : Type u_1} [NonAssocSemiring S] (f : S →+* R)
Goal: star f = (starRingEnd R).comp f
-- RingHom.star_apply
theorem RingHom.star_apply {S : Type*} [NonAssocSemiring S] (f : S →+* R) (s : S) :
    star f s = star (f s) 
Arguments: {R : Type u} [CommSemiring R] [StarRing R] {S : Type u_1} [NonAssocSemiring S] (f : S →+* R) (s : S)
Goal: (star f) s = star (f s)
-- conj_trivial
@[simp] lemma conj_trivial [TrivialStar R] (a : R) : conj a = a 
Arguments: {R : Type u} [CommSemiring R] [StarRing R] [TrivialStar R] (a : R)
Goal: (starRingEnd R) a = a
-- star_inv'
@[simp]
theorem star_inv' [DivisionSemiring R] [StarRing R] (x : R) : star x⁻¹ = (star x)⁻¹ 
Arguments: {R : Type u} [DivisionSemiring R] [StarRing R] (x : R)
Goal: star x⁻¹ = (star x)⁻¹
-- star_zpow₀
@[simp]
theorem star_zpow₀ [DivisionSemiring R] [StarRing R] (x : R) (z : ℤ) : star (x ^ z) = star x ^ z 
Arguments: {R : Type u} [DivisionSemiring R] [StarRing R] (x : R) (z : ℤ)
Goal: star (x ^ z) = star x ^ z
-- star_div'
@[simp]
theorem star_div' [Semifield R] [StarRing R] (x y : R) : star (x / y) = star x / star y 
Arguments: {R : Type u} [Semifield R] [StarRing R] (x y : R)
Goal: star (x / y) = star x / star y
-- StarModule.star_smul

class StarModule (R : Type u) (A : Type v) [Star R] [Star A] [SMul R A] : Prop where
    star_smul : ∀ (r : R) (a : A), star (r • a) = star r • star a
Arguments: {R : Type u} {A : Type v} [Star R] [Star A] [SMul R A] [self : StarModule R A] (r : R) (a : A)
Goal: star (r • a) = star r • star a
-- StarHomClass.map_star
class StarHomClass (F : Type*) (R S : outParam Type*) [Star R] [Star S] [FunLike F R S] : Prop where
    map_star : ∀ (f : F) (r : R), f (star r) = star (f r)
Arguments: {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} [Star R] [Star S] [FunLike F R S] [self : StarHomClass F R S] (f : F) (r : R)
Goal: f (star r) = star (f r)
-- Units.coe_star
@[simp]
theorem coe_star (u : Rˣ) : ↑(star u) = (star ↑u : R) 
Arguments: {R : Type u} [Monoid R] [StarMul R] (u : Rˣ)
Goal: ↑(star u) = star ↑u
-- Units.coe_star_inv
@[simp]
theorem coe_star_inv (u : Rˣ) : ↑(star u)⁻¹ = (star ↑u⁻¹ : R) 
Arguments: {R : Type u} [Monoid R] [StarMul R] (u : Rˣ)
Goal: ↑(star u)⁻¹ = star ↑u⁻¹
-- IsUnit.star
protected theorem IsUnit.star [Monoid R] [StarMul R] {a : R} : IsUnit a → IsUnit (star a)
  
Arguments: {R : Type u} [Monoid R] [StarMul R] {a : R}
Goal: IsUnit a → IsUnit (star a)
-- isUnit_star
@[simp]
theorem isUnit_star [Monoid R] [StarMul R] {a : R} : IsUnit (star a) ↔ IsUnit a 
Arguments: {R : Type u} [Monoid R] [StarMul R] {a : R}
Goal: IsUnit (star a) ↔ IsUnit a
-- Ring.inverse_star
theorem Ring.inverse_star [Semiring R] [StarRing R] (a : R) :
    Ring.inverse (star a) = star (Ring.inverse a) 
Arguments: {R : Type u} [Semiring R] [StarRing R] (a : R)
Goal: Ring.inverse (star a) = star (Ring.inverse a)
-- star_invOf
theorem star_invOf {R : Type*} [Monoid R] [StarMul R] (r : R) [Invertible r]
    [Invertible (star r)] : star (⅟ r) = ⅟ (star r) 
Arguments: {R : Type u_1} [Monoid R] [StarMul R] (r : R) [Invertible r] [Invertible (star r)]
Goal: star ⅟r = ⅟(star r)
-- IsLeftRegular.star
protected theorem IsLeftRegular.star [Mul R] [StarMul R] {x : R} (hx : IsLeftRegular x) :
    IsRightRegular (star x) 
Arguments: {R : Type u} [Mul R] [StarMul R] {x : R} (hx : IsLeftRegular x)
Goal: IsRightRegular (star x)
-- IsRightRegular.star
protected theorem IsRightRegular.star [Mul R] [StarMul R] {x : R} (hx : IsRightRegular x) :
    IsLeftRegular (star x) 
Arguments: {R : Type u} [Mul R] [StarMul R] {x : R} (hx : IsRightRegular x)
Goal: IsLeftRegular (star x)
-- IsRegular.star
protected theorem IsRegular.star [Mul R] [StarMul R] {x : R} (hx : IsRegular x) :
    IsRegular (star x) 
Arguments: {R : Type u} [Mul R] [StarMul R] {x : R} (hx : IsRegular x)
Goal: IsRegular (star x)
-- isRightRegular_star_iff
@[simp]
theorem isRightRegular_star_iff [Mul R] [StarMul R] {x : R} :
    IsRightRegular (star x) ↔ IsLeftRegular x 
Arguments: {R : Type u} [Mul R] [StarMul R] {x : R}
Goal: IsRightRegular (star x) ↔ IsLeftRegular x
-- isLeftRegular_star_iff
@[simp]
theorem isLeftRegular_star_iff [Mul R] [StarMul R] {x : R} :
    IsLeftRegular (star x) ↔ IsRightRegular x 
Arguments: {R : Type u} [Mul R] [StarMul R] {x : R}
Goal: IsLeftRegular (star x) ↔ IsRightRegular x
-- isRegular_star_iff
@[simp]
theorem isRegular_star_iff [Mul R] [StarMul R] {x : R} :
    IsRegular (star x) ↔ IsRegular x 
Arguments: {R : Type u} [Mul R] [StarMul R] {x : R}
Goal: IsRegular (star x) ↔ IsRegular x
-- MulOpposite.unop_star
@[simp]
theorem unop_star [Star R] (r : Rᵐᵒᵖ) : unop (star r) = star (unop r) 
Arguments: {R : Type u} [Star R] (r : Rᵐᵒᵖ)
Goal: MulOpposite.unop (star r) = star (MulOpposite.unop r)
-- MulOpposite.op_star
@[simp]
theorem op_star [Star R] (r : R) : op (star r) = star (op r) 
Arguments: {R : Type u} [Star R] (r : R)
Goal: MulOpposite.op (star r) = star (MulOpposite.op r)
-- Pi.star_apply
@[simp]
theorem star_apply [∀ i, Star (f i)] (x : ∀ i, f i) (i : I) : star x i = star (x i) 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Star (f i)] (x : (i : I) → f i) (i : I)
Goal: star x i = star (x i)
-- Pi.star_def
theorem star_def [∀ i, Star (f i)] (x : ∀ i, f i) : star x = fun i => star (x i) 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Star (f i)] (x : (i : I) → f i)
Goal: star x = fun i => star (x i)
-- Pi.single_star
theorem single_star [∀ i, AddMonoid (f i)] [∀ i, StarAddMonoid (f i)] [DecidableEq I] (i : I)
    (a : f i) : Pi.single i (star a) = star (Pi.single i a) 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → AddMonoid (f i)] [(i : I) → StarAddMonoid (f i)] [DecidableEq I] (i : I) (a : f i)
Goal: Pi.single i (star a) = star (Pi.single i a)
-- Pi.conj_apply
@[simp]
lemma conj_apply {ι : Type*} {α : ι → Type*} [∀ i, CommSemiring (α i)] [∀ i, StarRing (α i)]
    (f : ∀ i, α i) (i : ι) : conj f i = conj (f i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [(i : ι) → CommSemiring (α i)] [(i : ι) → StarRing (α i)] (f : (i : ι) → α i) (i : ι)
Goal: (starRingEnd ((i : ι) → α i)) f i = (starRingEnd (α i)) (f i)
-- Function.update_star
theorem update_star [∀ i, Star (f i)] [DecidableEq I] (h : ∀ i : I, f i) (i : I) (a : f i) :
    Function.update (star h) i (star a) = star (Function.update h i a) 
Arguments: {I : Type u} {f : I → Type v} [(i : I) → Star (f i)] [DecidableEq I] (h : (i : I) → f i) (i : I) (a : f i)
Goal: Function.update (star h) i (star a) = star (Function.update h i a)
-- Function.star_sum_elim
theorem star_sum_elim {I J α : Type*} (x : I → α) (y : J → α) [Star α] :
    star (Sum.elim x y) = Sum.elim (star x) (star y) 
Arguments: {I : Type u_1} {J : Type u_2} {α : Type u_3} (x : I → α) (y : J → α) [Star α]
Goal: star (Sum.elim x y) = Sum.elim (star x) (star y)
-- Prod.fst_star
@[simp]
theorem fst_star [Star R] [Star S] (x : R × S) : (star x).1 = star x.1 
Arguments: {R : Type u} {S : Type v} [Star R] [Star S] (x : R × S)
Goal: (star x).1 = star x.1
-- Prod.snd_star
@[simp]
theorem snd_star [Star R] [Star S] (x : R × S) : (star x).2 = star x.2 
Arguments: {R : Type u} {S : Type v} [Star R] [Star S] (x : R × S)
Goal: (star x).2 = star x.2
-- Prod.star_def
theorem star_def [Star R] [Star S] (x : R × S) : star x = (star x.1, star x.2) 
Arguments: {R : Type u} {S : Type v} [Star R] [Star S] (x : R × S)
Goal: star x = (star x.1, star x.2)
-- Units.embed_product_star
theorem Units.embed_product_star [Monoid R] [StarMul R] (u : Rˣ) :
    Units.embedProduct R (star u) = star (Units.embedProduct R u) 
Arguments: {R : Type u} [Monoid R] [StarMul R] (u : Rˣ)
Goal: (Units.embedProduct R) (star u) = star ((Units.embedProduct R) u)
-- Submodule.isSemisimple_torsionBy_of_irreducible
theorem Submodule.isSemisimple_torsionBy_of_irreducible {a : R} (h : Irreducible a) :
    IsSemisimpleModule R (torsionBy R M a) 
Arguments: {R : Type u} [CommRing R] [IsPrincipalIdealRing R] {M : Type v} [AddCommGroup M] [Module R M] {a : R} (h : Irreducible a)
Goal: IsSemisimpleModule R ↥(Submodule.torsionBy R M a)
-- Submodule.isInternal_prime_power_torsion_of_pid
theorem Submodule.isInternal_prime_power_torsion_of_pid [Module.Finite R M]
    (hM : Module.IsTorsion R M) :
    DirectSum.IsInternal fun p : (factors (⊤ : Submodule R M).annihilator).toFinset =>
      torsionBy R M
        (IsPrincipal.generator (p : Ideal R) ^
          (factors (⊤ : Submodule R M).annihilator).count ↑p) 
Arguments: {R : Type u} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {M : Type v} [AddCommGroup M] [Module R M] [Module.Finite R M] (hM : Module.IsTorsion R M)
Goal: DirectSum.IsInternal fun p =>
  Submodule.torsionBy R M
    (Submodule.IsPrincipal.generator ↑p ^ Multiset.count (↑p) (UniqueFactorizationMonoid.factors ⊤.annihilator))
-- Submodule.exists_isInternal_prime_power_torsion_of_pid
theorem Submodule.exists_isInternal_prime_power_torsion_of_pid [Module.Finite R M]
    (hM : Module.IsTorsion R M) :
    ∃ (ι : Type u) (_ : Fintype ι) (_ : DecidableEq ι) (p : ι → R) (_ : ∀ i, Irreducible <| p i)
        (e : ι → ℕ), DirectSum.IsInternal fun i => torsionBy R M <| p i ^ e i 
Arguments: {R : Type u} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {M : Type v} [AddCommGroup M] [Module R M] [Module.Finite R M] (hM : Module.IsTorsion R M)
Goal: ∃ ι x x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, DirectSum.IsInternal fun i => Submodule.torsionBy R M (p i ^ e i)
-- Ideal.torsionOf_eq_span_pow_pOrder
theorem _root_.Ideal.torsionOf_eq_span_pow_pOrder (x : M) :
    torsionOf R M x = span {p ^ pOrder hM x} 
Arguments: {R : Type u} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {M : Type v} [AddCommGroup M] [Module R M] {p : R} (hp : Irreducible p) (hM : Module.IsTorsion' M ↥(Submonoid.powers p)) [dec : (x : M) → Decidable (x = 0)] (x : M)
Goal: Ideal.torsionOf R M x = Ideal.span {p ^ Submodule.pOrder hM x}
-- Module.p_pow_smul_lift
theorem p_pow_smul_lift {x y : M} {k : ℕ} (hM' : Module.IsTorsionBy R M (p ^ pOrder hM y))
    (h : p ^ k • x ∈ R ∙ y) : ∃ a : R, p ^ k • x = p ^ k • a • y 
Arguments: {R : Type u} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {M : Type v} [AddCommGroup M] [Module R M] {p : R} (hp : Irreducible p) (hM : Module.IsTorsion' M ↥(Submonoid.powers p)) [dec : (x : M) → Decidable (x = 0)] {x y : M} {k : ℕ} (hM' : Module.IsTorsionBy R M (p ^ Submodule.pOrder hM y)) (h : p ^ k • x ∈ Submodule.span R {y})
Goal: ∃ a, p ^ k • x = p ^ k • a • y
-- Module.exists_smul_eq_zero_and_mk_eq
theorem exists_smul_eq_zero_and_mk_eq {z : M} (hz : Module.IsTorsionBy R M (p ^ pOrder hM z))
    {k : ℕ} (f : (R ⧸ R ∙ p ^ k) →ₗ[R] M ⧸ R ∙ z) :
    ∃ x : M, p ^ k • x = 0 ∧ Submodule.Quotient.mk (p := span R {z}) x = f 1 
Arguments: {R : Type u} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {M : Type v} [AddCommGroup M] [Module R M] {p : R} (hp : Irreducible p) (hM : Module.IsTorsion' M ↥(Submonoid.powers p)) [dec : (x : M) → Decidable (x = 0)] {z : M} (hz : Module.IsTorsionBy R M (p ^ Submodule.pOrder hM z)) {k : ℕ} (f : R ⧸ Submodule.span R {p ^ k} →ₗ[R] M ⧸ Submodule.span R {z})
Goal: ∃ x, p ^ k • x = 0 ∧ Submodule.Quotient.mk x = f 1
-- Module.torsion_by_prime_power_decomposition
theorem torsion_by_prime_power_decomposition (hN : Module.IsTorsion' N (Submonoid.powers p))
    [h' : Module.Finite R N] :
    ∃ (d : ℕ) (k : Fin d → ℕ), Nonempty <| N ≃ₗ[R] ⨁ i : Fin d, R ⧸ R ∙ p ^ (k i : ℕ) 
Arguments: {R : Type u} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {N : Type (max u v)} [AddCommGroup N] [Module R N] {p : R} (hp : Irreducible p) (hN : Module.IsTorsion' N ↥(Submonoid.powers p)) [h' : Module.Finite R N]
Goal: ∃ d k, Nonempty (N ≃ₗ[R] ⨁ (i : Fin d), R ⧸ Submodule.span R {p ^ k i})
-- Module.equiv_directSum_of_isTorsion
theorem equiv_directSum_of_isTorsion [h' : Module.Finite R N] (hN : Module.IsTorsion R N) :
    ∃ (ι : Type u) (_ : Fintype ι) (p : ι → R) (_ : ∀ i, Irreducible <| p i) (e : ι → ℕ),
      Nonempty <| N ≃ₗ[R] ⨁ i : ι, R ⧸ R ∙ p i ^ e i 
Arguments: {R : Type u} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {N : Type (max u v)} [AddCommGroup N] [Module R N] [h' : Module.Finite R N] (hN : Module.IsTorsion R N)
Goal: ∃ ι x p, ∃ (_ : ∀ (i : ι), Irreducible (p i)), ∃ e, Nonempty (N ≃ₗ[R] ⨁ (i : ι), R ⧸ Submodule.span R {p i ^ e i})