ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LaurentSeries.single_order_mul_powerSeriesPart
@[simp]
theorem single_order_mul_powerSeriesPart (x : LaurentSeries R) :
    (single x.order 1 : LaurentSeries R) * x.powerSeriesPart = x 
Arguments: {R : Type u_1} [Semiring R] (x : LaurentSeries R)
Goal: (HahnSeries.single (HahnSeries.order x)) 1 * (HahnSeries.ofPowerSeries ℤ R) x.powerSeriesPart = x
-- LaurentSeries.ofPowerSeries_powerSeriesPart
theorem ofPowerSeries_powerSeriesPart (x : LaurentSeries R) :
    ofPowerSeries ℤ R x.powerSeriesPart = single (-x.order) 1 * x 
Arguments: {R : Type u_1} [Semiring R] (x : LaurentSeries R)
Goal: (HahnSeries.ofPowerSeries ℤ R) x.powerSeriesPart = (HahnSeries.single (-HahnSeries.order x)) 1 * x
-- LaurentSeries.coe_algebraMap
@[simp]
theorem coe_algebraMap [CommSemiring R] :
    ⇑(algebraMap (PowerSeries R) (LaurentSeries R)) = HahnSeries.ofPowerSeries ℤ R 
Arguments: {R : Type u_1} [CommSemiring R]
Goal: ⇑(algebraMap (PowerSeries R) (LaurentSeries R)) = ⇑(HahnSeries.ofPowerSeries ℤ R)
-- PowerSeries.coe_zero
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_zero : ((0 : PowerSeries R) : LaurentSeries R) = 0 
Arguments: {R : Type u_1} [Semiring R]
Goal: (HahnSeries.ofPowerSeries ℤ R) 0 = 0
-- PowerSeries.coe_one
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_one : ((1 : PowerSeries R) : LaurentSeries R) = 1 
Arguments: {R : Type u_1} [Semiring R]
Goal: (HahnSeries.ofPowerSeries ℤ R) 1 = 1
-- PowerSeries.coe_add
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_add : ((f + g : PowerSeries R) : LaurentSeries R) = f + g 
Arguments: {R : Type u_1} [Semiring R] (f g : PowerSeries R)
Goal: (HahnSeries.ofPowerSeries ℤ R) (f + g) = (HahnSeries.ofPowerSeries ℤ R) f + (HahnSeries.ofPowerSeries ℤ R) g
-- PowerSeries.coe_sub
@[norm_cast]
theorem coe_sub : ((f' - g' : PowerSeries R') : LaurentSeries R') = f' - g' 
Arguments: {R' : Type u_2} [Ring R'] (f' g' : PowerSeries R')
Goal: (HahnSeries.ofPowerSeries ℤ R') (f' - g') = (HahnSeries.ofPowerSeries ℤ R') f' - (HahnSeries.ofPowerSeries ℤ R') g'
-- PowerSeries.coe_neg
@[norm_cast]
theorem coe_neg : ((-f' : PowerSeries R') : LaurentSeries R') = -f' 
Arguments: {R' : Type u_2} [Ring R'] (f' : PowerSeries R')
Goal: (HahnSeries.ofPowerSeries ℤ R') (-f') = -(HahnSeries.ofPowerSeries ℤ R') f'
-- PowerSeries.coe_mul
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_mul : ((f * g : PowerSeries R) : LaurentSeries R) = f * g 
Arguments: {R : Type u_1} [Semiring R] (f g : PowerSeries R)
Goal: (HahnSeries.ofPowerSeries ℤ R) (f * g) = (HahnSeries.ofPowerSeries ℤ R) f * (HahnSeries.ofPowerSeries ℤ R) g
-- PowerSeries.coeff_coe
theorem coeff_coe (i : ℤ) :
    ((f : PowerSeries R) : LaurentSeries R).coeff i =
      if i < 0 then 0 else PowerSeries.coeff R i.natAbs f 
Arguments: {R : Type u_1} [Semiring R] (f : PowerSeries R) (i : ℤ)
Goal: ((HahnSeries.ofPowerSeries ℤ R) f).coeff i = if i < 0 then 0 else (PowerSeries.coeff R i.natAbs) f
-- PowerSeries.coe_C
theorem coe_C (r : R) : ((C R r : PowerSeries R) : LaurentSeries R) = HahnSeries.C r 
Arguments: {R : Type u_1} [Semiring R] (r : R)
Goal: (HahnSeries.ofPowerSeries ℤ R) ((PowerSeries.C R) r) = HahnSeries.C r
-- PowerSeries.coe_X
theorem coe_X : ((X : PowerSeries R) : LaurentSeries R) = single 1 1 
Arguments: {R : Type u_1} [Semiring R]
Goal: (HahnSeries.ofPowerSeries ℤ R) PowerSeries.X = (HahnSeries.single 1) 1
-- PowerSeries.coe_smul
@[simp, norm_cast]
theorem coe_smul {S : Type*} [Semiring S] [Module R S] (r : R) (x : PowerSeries S) :
    ((r • x : PowerSeries S) : LaurentSeries S) = r • (ofPowerSeries ℤ S x) 
Arguments: {R : Type u_1} [Semiring R] {S : Type u_3} [Semiring S] [Module R S] (r : R) (x : PowerSeries S)
Goal: (HahnSeries.ofPowerSeries ℤ S) (r • x) = r • (HahnSeries.ofPowerSeries ℤ S) x
-- PowerSeries.coe_pow
@[norm_cast]
theorem coe_pow (n : ℕ) : ((f ^ n : PowerSeries R) : LaurentSeries R) = (ofPowerSeries ℤ R f) ^ n 
Arguments: {R : Type u_1} [Semiring R] (f : PowerSeries R) (n : ℕ)
Goal: (HahnSeries.ofPowerSeries ℤ R) (f ^ n) = (HahnSeries.ofPowerSeries ℤ R) f ^ n
-- RatFunc.coe_def
theorem coe_def : (f : LaurentSeries F) = coeAlgHom F f 
Arguments: {F : Type u} [Field F] (f : RatFunc F)
Goal: ↑f = (RatFunc.coeAlgHom F) f
-- RatFunc.coe_num_denom
theorem coe_num_denom : (f : LaurentSeries F) = f.num / f.denom 
Arguments: {F : Type u} [Field F] (f : RatFunc F)
Goal: ↑f = (HahnSeries.ofPowerSeries ℤ F) ↑f.num / (HahnSeries.ofPowerSeries ℤ F) ↑f.denom
-- RatFunc.coe_injective
theorem coe_injective : Function.Injective ((↑) : RatFunc F → LaurentSeries F) 
Arguments: {F : Type u} [Field F]
Goal: Function.Injective RatFunc.coeToLaurentSeries_fun
-- RatFunc.coe_apply
@[simp]
theorem coe_apply : coeAlgHom F f = f 
Arguments: {F : Type u} [Field F] (f : RatFunc F)
Goal: (RatFunc.coeAlgHom F) f = ↑f
-- RatFunc.coe_coe
theorem coe_coe (P : Polynomial F) : ((P : PowerSeries F) : LaurentSeries F) = (P : RatFunc F) 
Arguments: {F : Type u} [Field F] (P : F[X])
Goal: (HahnSeries.ofPowerSeries ℤ F) ↑P = ↑↑P
-- RatFunc.coe_zero
@[simp, norm_cast]
theorem coe_zero : ((0 : RatFunc F) : LaurentSeries F) = 0 
Arguments: {F : Type u} [Field F]
Goal: ↑0 = 0
-- RatFunc.coe_ne_zero
theorem coe_ne_zero {f : Polynomial F} (hf : f ≠ 0) : (↑f : PowerSeries F) ≠ 0 
Arguments: {F : Type u} [Field F] {f : F[X]} (hf : f ≠ 0)
Goal: ↑f ≠ 0
-- RatFunc.coe_one
@[simp, norm_cast]
theorem coe_one : ((1 : RatFunc F) : LaurentSeries F) = 1 
Arguments: {F : Type u} [Field F]
Goal: ↑1 = 1
-- RatFunc.coe_add
@[simp, norm_cast]
theorem coe_add : ((f + g : RatFunc F) : LaurentSeries F) = f + g 
Arguments: {F : Type u} [Field F] (f g : RatFunc F)
Goal: ↑(f + g) = ↑f + ↑g
-- RatFunc.coe_sub
@[simp, norm_cast]
theorem coe_sub : ((f - g : RatFunc F) : LaurentSeries F) = f - g 
Arguments: {F : Type u} [Field F] (f g : RatFunc F)
Goal: ↑(f - g) = ↑f - ↑g
-- RatFunc.coe_neg
@[simp, norm_cast]
theorem coe_neg : ((-f : RatFunc F) : LaurentSeries F) = -f 
Arguments: {F : Type u} [Field F] (f : RatFunc F)
Goal: ↑(-f) = -↑f
-- RatFunc.coe_mul
@[simp, norm_cast]
theorem coe_mul : ((f * g : RatFunc F) : LaurentSeries F) = f * g 
Arguments: {F : Type u} [Field F] (f g : RatFunc F)
Goal: ↑(f * g) = ↑f * ↑g
-- RatFunc.coe_pow
@[simp, norm_cast]
theorem coe_pow (n : ℕ) : ((f ^ n : RatFunc F) : LaurentSeries F) = (f : LaurentSeries F) ^ n 
Arguments: {F : Type u} [Field F] (f : RatFunc F) (n : ℕ)
Goal: ↑(f ^ n) = ↑f ^ n
-- RatFunc.coe_div
@[simp, norm_cast]
theorem coe_div :
    ((f / g : RatFunc F) : LaurentSeries F) = (f : LaurentSeries F) / (g : LaurentSeries F) 
Arguments: {F : Type u} [Field F] (f g : RatFunc F)
Goal: ↑(f / g) = ↑f / ↑g
-- RatFunc.coe_C
@[simp, norm_cast]
theorem coe_C (r : F) : ((RatFunc.C r : RatFunc F) : LaurentSeries F) = HahnSeries.C r 
Arguments: {F : Type u} [Field F] (r : F)
Goal: ↑(RatFunc.C r) = HahnSeries.C r
-- RatFunc.coe_smul
@[simp, norm_cast]
theorem coe_smul (r : F) : ((r • f : RatFunc F) : LaurentSeries F) = r • (f : LaurentSeries F) 
Arguments: {F : Type u} [Field F] (f : RatFunc F) (r : F)
Goal: ↑(r • f) = r • ↑f
-- RatFunc.coe_X
@[simp]
theorem coe_X : ((X : RatFunc F) : LaurentSeries F) = single 1 1 
Arguments: {F : Type u} [Field F]
Goal: ↑RatFunc.X = (HahnSeries.single 1) 1
-- RatFunc.single_one_eq_pow
theorem single_one_eq_pow {R : Type _} [Ring R] (n : ℕ) :
    single (n : ℤ) (1 : R) = single (1 : ℤ) 1 ^ n 
Arguments: {R : Type u_2} [Ring R] (n : ℕ)
Goal: (HahnSeries.single ↑n) 1 = (HahnSeries.single 1) 1 ^ n
-- RatFunc.single_inv
theorem single_inv (d : ℤ) {α : F} (hα : α ≠ 0) :
    single (-d) (α⁻¹ : F) = (single (d : ℤ) (α : F))⁻¹ 
Arguments: {F : Type u} [Field F] (d : ℤ) {α : F} (hα : α ≠ 0)
Goal: (HahnSeries.single (-d)) α⁻¹ = ((HahnSeries.single d) α)⁻¹
-- RatFunc.single_zpow
theorem single_zpow (n : ℤ) :
    single (n : ℤ) (1 : F) = single (1 : ℤ) 1 ^ n 
Arguments: {F : Type u} [Field F] (n : ℤ)
Goal: (HahnSeries.single n) 1 = (HahnSeries.single 1) 1 ^ n
-- RatFunc.algebraMap_apply_div
theorem algebraMap_apply_div :
    algebraMap (RatFunc F) (LaurentSeries F) (algebraMap _ _ p / algebraMap _ _ q) =
      algebraMap F[X] (LaurentSeries F) p / algebraMap _ _ q 
Arguments: {F : Type u} [Field F] (p q : F[X])
Goal: (algebraMap (RatFunc F) (LaurentSeries F)) ((algebraMap F[X] (RatFunc F)) p / (algebraMap F[X] (RatFunc F)) q) =
  (algebraMap F[X] (LaurentSeries F)) p / (algebraMap F[X] (LaurentSeries F)) q
-- PowerSeries.intValuation_eq_of_coe
theorem intValuation_eq_of_coe (P : K[X]) :
    (Polynomial.idealX K).intValuation P = (idealX K).intValuation (P : K⟦X⟧) 
Arguments: {K : Type u_2} [Field K] (P : K[X])
Goal: (Polynomial.idealX K).intValuation P = (PowerSeries.idealX K).intValuation ↑P
-- PowerSeries.intValuation_X
@[simp]
theorem intValuation_X : (idealX K).intValuationDef X = ↑(Multiplicative.ofAdd (-1 : ℤ)) 
Arguments: {K : Type u_2} [Field K]
Goal: (PowerSeries.idealX K).intValuationDef PowerSeries.X = ↑(Multiplicative.ofAdd (-1))
-- RatFunc.valuation_eq_LaurentSeries_valuation
theorem valuation_eq_LaurentSeries_valuation (P : RatFunc K) :
    (Polynomial.idealX K).valuation P = (PowerSeries.idealX K).valuation (P : LaurentSeries K) 
Arguments: (K : Type u_2) [Field K] (P : RatFunc K)
Goal: (Polynomial.idealX K).valuation P = (PowerSeries.idealX K).valuation ↑P
-- LaurentSeries.valuation_X_pow
theorem valuation_X_pow (s : ℕ) :
    Valued.v (((X : K⟦X⟧) : LaurentSeries K) ^ s) = Multiplicative.ofAdd (-(s : ℤ)) 
Arguments: (K : Type u_2) [Field K] (s : ℕ)
Goal: Valued.v ((HahnSeries.ofPowerSeries ℤ K) PowerSeries.X ^ s) = ↑(Multiplicative.ofAdd (-↑s))
-- LaurentSeries.valuation_single_zpow
theorem valuation_single_zpow (s : ℤ) :
    Valued.v (HahnSeries.single s (1 : K) : LaurentSeries K) =
      Multiplicative.ofAdd (-(s : ℤ)) 
Arguments: (K : Type u_2) [Field K] (s : ℤ)
Goal: Valued.v ((HahnSeries.single s) 1) = ↑(Multiplicative.ofAdd (-s))
-- LaurentSeries.coeff_zero_of_lt_intValuation
theorem coeff_zero_of_lt_intValuation {n d : ℕ} {f : K⟦X⟧}
    (H : Valued.v (f : LaurentSeries K) ≤ Multiplicative.ofAdd (-d : ℤ)) :
    n < d → coeff K n f = 0 
Arguments: (K : Type u_2) [Field K] {n d : ℕ} {f : PowerSeries K} (H : Valued.v ((HahnSeries.ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d)))
Goal: n < d → (PowerSeries.coeff K n) f = 0
-- LaurentSeries.intValuation_le_iff_coeff_lt_eq_zero
theorem intValuation_le_iff_coeff_lt_eq_zero {d : ℕ} (f : K⟦X⟧) :
    Valued.v (f : LaurentSeries K) ≤ Multiplicative.ofAdd (-d : ℤ) ↔
      ∀ n : ℕ, n < d → coeff K n f = 0 
Arguments: (K : Type u_2) [Field K] {d : ℕ} (f : PowerSeries K)
Goal: Valued.v ((HahnSeries.ofPowerSeries ℤ K) f) ≤ ↑(Multiplicative.ofAdd (-↑d)) ↔ ∀ n < d, (PowerSeries.coeff K n) f = 0
-- LaurentSeries.coeff_zero_of_lt_valuation
theorem coeff_zero_of_lt_valuation {n D : ℤ} {f : LaurentSeries K}
    (H : Valued.v f ≤ Multiplicative.ofAdd (-D)) : n < D → f.coeff n = 0 
Arguments: (K : Type u_2) [Field K] {n D : ℤ} {f : LaurentSeries K} (H : Valued.v f ≤ ↑(Multiplicative.ofAdd (-D)))
Goal: n < D → f.coeff n = 0
-- LaurentSeries.valuation_le_iff_coeff_lt_eq_zero
theorem valuation_le_iff_coeff_lt_eq_zero {D : ℤ} {f : LaurentSeries K} :
    Valued.v f ≤ ↑(Multiplicative.ofAdd (-D : ℤ)) ↔ ∀ n : ℤ, n < D → f.coeff n = 0 
Arguments: (K : Type u_2) [Field K] {D : ℤ} {f : LaurentSeries K}
Goal: Valued.v f ≤ ↑(Multiplicative.ofAdd (-D)) ↔ ∀ n < D, f.coeff n = 0
-- LaurentSeries.eq_coeff_of_valuation_sub_lt
theorem eq_coeff_of_valuation_sub_lt {d n : ℤ} {f g : LaurentSeries K}
    (H : Valued.v (g - f) ≤ ↑(Multiplicative.ofAdd (-d))) : n < d → g.coeff n = f.coeff n 
Arguments: (K : Type u_2) [Field K] {d n : ℤ} {f g : LaurentSeries K} (H : Valued.v (g - f) ≤ ↑(Multiplicative.ofAdd (-d)))
Goal: n < d → g.coeff n = f.coeff n
-- LaurentSeries.val_le_one_iff_eq_coe
theorem val_le_one_iff_eq_coe (f : LaurentSeries K) : Valued.v f ≤ (1 : ℤₘ₀) ↔
    ∃ F : PowerSeries K, F = f 
Arguments: (K : Type u_2) [Field K] (f : LaurentSeries K)
Goal: Valued.v f ≤ 1 ↔ ∃ F, (HahnSeries.ofPowerSeries ℤ K) F = f
-- Module.Free.exists_basis
class Module.Free : Prop where
  exists_basis : Nonempty <| (I : Type v) × Basis I R M
Arguments: {R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] [self : Module.Free R M]
Goal: Nonempty ((I : Type v) × Basis I R M)
-- Module.free_def
theorem Module.free_def [Small.{w,v} M] :
    Module.Free R M ↔ ∃ I : Type w, Nonempty (Basis I R M) 
Arguments: (R : Type u) (M : Type v) [Semiring R] [AddCommMonoid M] [Module R M] [Small.{w, v} M]
Goal: Module.Free R M ↔ ∃ I, Nonempty (Basis I R M)
-- Module.free_iff_set
theorem Module.free_iff_set : Module.Free R M ↔ ∃ S : Set M, Nonempty (Basis S R M) 
Arguments: (R : Type u) (M : Type v) [Semiring R] [AddCommMonoid M] [Module R M]
Goal: Module.Free R M ↔ ∃ S, Nonempty (Basis (↑S) R M)
-- Module.Free.of_basis
theorem Module.Free.of_basis {ι : Type w} (b : Basis ι R M) : Module.Free R M 
Arguments: {R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] {ι : Type w} (b : Basis ι R M)
Goal: Module.Free R M
-- Module.Free.infinite
theorem infinite [Infinite R] [Nontrivial M] : Infinite M 
Arguments: (R : Type u) (M : Type v) [Semiring R] [AddCommMonoid M] [Module R M] [Module.Free R M] [Infinite R] [Nontrivial M]
Goal: Infinite M
-- Module.Free.of_equiv
theorem of_equiv (e : M ≃ₗ[R] N) : Module.Free R N 
Arguments: {R : Type u} {M : Type v} {N : Type z} [Semiring R] [AddCommMonoid M] [Module R M] [Module.Free R M] [AddCommMonoid N] [Module R N] (e : M ≃ₗ[R] N)
Goal: Module.Free R N
-- Module.Free.of_equiv'
theorem of_equiv' {P : Type v} [AddCommMonoid P] [Module R P] (_ : Module.Free R P)
    (e : P ≃ₗ[R] N) : Module.Free R N 
Arguments: {R : Type u} {N : Type z} [Semiring R] [AddCommMonoid N] [Module R N] {P : Type v} [AddCommMonoid P] [Module R P]
Goal: Module.Free R P → (P ≃ₗ[R] N) → Module.Free R N
-- RingEquiv.isSemisimpleRing
theorem RingEquiv.isSemisimpleRing (e : R ≃+* S) [IsSemisimpleRing R] : IsSemisimpleRing S 
Arguments: (R : Type u_2) (S : Type u_3) [Ring R] [Ring S] (e : R ≃+* S) [IsSemisimpleRing R]
Goal: IsSemisimpleRing S
-- IsSimpleModule.nontrivial
theorem IsSimpleModule.nontrivial [IsSimpleModule R M] : Nontrivial M 
Arguments: (R : Type u_2) [Ring R] (M : Type u_4) [AddCommGroup M] [Module R M] [IsSimpleModule R M]
Goal: Nontrivial M
-- LinearMap.isSimpleModule_iff_of_bijective
theorem LinearMap.isSimpleModule_iff_of_bijective [Module S N] {σ : R →+* S} [RingHomSurjective σ]
    (l : M →ₛₗ[σ] N) (hl : Function.Bijective l) : IsSimpleModule R M ↔ IsSimpleModule S N 
Arguments: {R : Type u_2} {S : Type u_3} [Ring R] [Ring S] {M : Type u_4} [AddCommGroup M] [Module R M] {N : Type u_5} [AddCommGroup N] [Module S N] {σ : R →+* S} [RingHomSurjective σ] (l : M →ₛₗ[σ] N) (hl : Function.Bijective ⇑l)
Goal: IsSimpleModule R M ↔ IsSimpleModule S N
-- IsSimpleModule.congr
theorem IsSimpleModule.congr (l : M ≃ₗ[R] N) [IsSimpleModule R N] : IsSimpleModule R M 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {N : Type u_5} [AddCommGroup N] [Module R N] (l : M ≃ₗ[R] N) [IsSimpleModule R N]
Goal: IsSimpleModule R M
-- isSimpleModule_iff_isAtom
theorem isSimpleModule_iff_isAtom : IsSimpleModule R m ↔ IsAtom m 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {m : Submodule R M}
Goal: IsSimpleModule R ↥m ↔ IsAtom m
-- isSimpleModule_iff_isCoatom
theorem isSimpleModule_iff_isCoatom : IsSimpleModule R (M ⧸ m) ↔ IsCoatom m 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {m : Submodule R M}
Goal: IsSimpleModule R (M ⧸ m) ↔ IsCoatom m
-- covBy_iff_quot_is_simple
theorem covBy_iff_quot_is_simple {A B : Submodule R M} (hAB : A ≤ B) :
    A ⋖ B ↔ IsSimpleModule R (B ⧸ Submodule.comap B.subtype A) 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {A B : Submodule R M} (hAB : A ≤ B)
Goal: A ⋖ B ↔ IsSimpleModule R (↥B ⧸ Submodule.comap B.subtype A)
-- IsSimpleModule.isAtom
@[simp]
theorem isAtom [IsSimpleModule R m] : IsAtom m 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {m : Submodule R M} [IsSimpleModule R ↥m]
Goal: IsAtom m
-- IsSimpleModule.span_singleton_eq_top
theorem span_singleton_eq_top {m : M} (hm : m ≠ 0) : Submodule.span R {m} = ⊤ 
Arguments: (R : Type u_2) [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] [IsSimpleModule R M] {m : M} (hm : m ≠ 0)
Goal: Submodule.span R {m} = ⊤
-- IsSimpleModule.toSpanSingleton_surjective
theorem toSpanSingleton_surjective {m : M} (hm : m ≠ 0) :
    Function.Surjective (toSpanSingleton R M m) 
Arguments: (R : Type u_2) [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] [IsSimpleModule R M] {m : M} (hm : m ≠ 0)
Goal: Function.Surjective ⇑(LinearMap.toSpanSingleton R M m)
-- IsSimpleModule.ker_toSpanSingleton_isMaximal
theorem ker_toSpanSingleton_isMaximal {m : M} (hm : m ≠ 0) :
    Ideal.IsMaximal (ker (toSpanSingleton R M m)) 
Arguments: (R : Type u_2) [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] [IsSimpleModule R M] {m : M} (hm : m ≠ 0)
Goal: Ideal.IsMaximal (LinearMap.ker (LinearMap.toSpanSingleton R M m))
-- isSimpleModule_iff_quot_maximal
theorem isSimpleModule_iff_quot_maximal :
    IsSimpleModule R M ↔ ∃ I : Ideal R, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I) 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M]
Goal: IsSimpleModule R M ↔ ∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)
-- IsSimpleModule.annihilator_isMaximal
theorem IsSimpleModule.annihilator_isMaximal {R} [CommRing R] [Module R M]
    [simple : IsSimpleModule R M] : (Module.annihilator R M).IsMaximal 
Arguments: {M : Type u_4} [AddCommGroup M] {R : Type u_6} [CommRing R] [Module R M] [simple : IsSimpleModule R M]
Goal: (Module.annihilator R M).IsMaximal
-- isSimpleModule_iff_toSpanSingleton_surjective
theorem isSimpleModule_iff_toSpanSingleton_surjective : IsSimpleModule R M ↔
    Nontrivial M ∧ ∀ x : M, x ≠ 0 → Function.Surjective (LinearMap.toSpanSingleton R M x) 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M]
Goal: IsSimpleModule R M ↔ Nontrivial M ∧ ∀ (x : M), x ≠ 0 → Function.Surjective ⇑(LinearMap.toSpanSingleton R M x)
-- isSimpleModule_self_iff_isUnit
theorem isSimpleModule_self_iff_isUnit :
    IsSimpleModule R R ↔ Nontrivial R ∧ ∀ x : R, x ≠ 0 → IsUnit x 
Arguments: {R : Type u_2} [Ring R]
Goal: IsSimpleModule R R ↔ Nontrivial R ∧ ∀ (x : R), x ≠ 0 → IsUnit x
-- isSimpleModule_iff_finrank_eq_one
theorem isSimpleModule_iff_finrank_eq_one {R} [DivisionRing R] [Module R M] :
    IsSimpleModule R M ↔ FiniteDimensional.finrank R M = 1 
Arguments: {M : Type u_4} [AddCommGroup M] {R : Type u_6} [DivisionRing R] [Module R M]
Goal: IsSimpleModule R M ↔ FiniteDimensional.finrank R M = 1
-- IsSemisimpleModule.of_sSup_simples_eq_top
theorem IsSemisimpleModule.of_sSup_simples_eq_top
    (h : sSup { m : Submodule R M | IsSimpleModule R m } = ⊤) : IsSemisimpleModule R M 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] (h : sSup {m | IsSimpleModule R ↥m} = ⊤)
Goal: IsSemisimpleModule R M
-- IsSemisimpleModule.eq_bot_or_exists_simple_le
theorem eq_bot_or_exists_simple_le (N : Submodule R M) : N = ⊥ ∨ ∃ m ≤ N, IsSimpleModule R m 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] [IsSemisimpleModule R M] (N : Submodule R M)
Goal: N = ⊥ ∨ ∃ m ≤ N, IsSimpleModule R ↥m
-- IsSemisimpleModule.sSup_simples_le
theorem sSup_simples_le (N : Submodule R M) :
    sSup { m : Submodule R M | IsSimpleModule R m ∧ m ≤ N } = N 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] [IsSemisimpleModule R M] (N : Submodule R M)
Goal: sSup {m | IsSimpleModule R ↥m ∧ m ≤ N} = N
-- IsSemisimpleModule.exists_simple_submodule
theorem exists_simple_submodule [Nontrivial M] : ∃ m : Submodule R M, IsSimpleModule R m 
Arguments: (R : Type u_2) [Ring R] (M : Type u_4) [AddCommGroup M] [Module R M] [IsSemisimpleModule R M] [Nontrivial M]
Goal: ∃ m, IsSimpleModule R ↥m
-- IsSemisimpleModule.sSup_simples_eq_top
theorem sSup_simples_eq_top : sSup { m : Submodule R M | IsSimpleModule R m } = ⊤ 
Arguments: (R : Type u_2) [Ring R] (M : Type u_4) [AddCommGroup M] [Module R M] [IsSemisimpleModule R M]
Goal: sSup {m | IsSimpleModule R ↥m} = ⊤
-- IsSemisimpleModule.annihilator_isRadical
theorem annihilator_isRadical (R) [CommRing R] [Module R M] [IsSemisimpleModule R M] :
    (Module.annihilator R M).IsRadical 
Arguments: (M : Type u_4) [AddCommGroup M] (R : Type u_6) [CommRing R] [Module R M] [IsSemisimpleModule R M]
Goal: (Module.annihilator R M).IsRadical
-- IsSemisimpleModule.congr
theorem congr [IsSemisimpleModule R N] (e : M ≃ₗ[R] N) : IsSemisimpleModule R M 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {N : Type u_5} [AddCommGroup N] [Module R N] [IsSemisimpleModule R N] (e : M ≃ₗ[R] N)
Goal: IsSemisimpleModule R M
-- IsSemisimpleModule.range
protected theorem range (f : M →ₗ[R] N) : IsSemisimpleModule R (range f) 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {N : Type u_5} [AddCommGroup N] [Module R N] [IsSemisimpleModule R M] (f : M →ₗ[R] N)
Goal: IsSemisimpleModule R ↥(LinearMap.range f)
-- LinearMap.isSemisimpleModule_iff_of_bijective
theorem _root_.LinearMap.isSemisimpleModule_iff_of_bijective (hl : Function.Bijective l) :
    IsSemisimpleModule R M ↔ IsSemisimpleModule S N 
Arguments: {R : Type u_2} {S : Type u_3} [Ring R] [Ring S] {M : Type u_4} [AddCommGroup M] [Module R M] {N : Type u_5} [AddCommGroup N] [Module S N] {σ : R →+* S} [RingHomSurjective σ] (l : M →ₛₗ[σ] N) (hl : Function.Bijective ⇑l)
Goal: IsSemisimpleModule R M ↔ IsSemisimpleModule S N
-- sSup_simples_eq_top_iff_isSemisimpleModule
theorem sSup_simples_eq_top_iff_isSemisimpleModule :
    sSup { m : Submodule R M | IsSimpleModule R m } = ⊤ ↔ IsSemisimpleModule R M 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M]
Goal: sSup {m | IsSimpleModule R ↥m} = ⊤ ↔ IsSemisimpleModule R M
-- isSemisimpleModule_of_isSemisimpleModule_submodule
lemma isSemisimpleModule_of_isSemisimpleModule_submodule {s : Set ι} {p : ι → Submodule R M}
    (hp : ∀ i ∈ s, IsSemisimpleModule R (p i)) (hp' : ⨆ i ∈ s, p i = ⊤) :
    IsSemisimpleModule R M 
Arguments: {ι : Type u_1} {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {s : Set ι} {p : ι → Submodule R M} (hp : ∀ i ∈ s, IsSemisimpleModule R ↥(p i)) (hp' : ⨆ i ∈ s, p i = ⊤)
Goal: IsSemisimpleModule R M
-- isSemisimpleModule_biSup_of_isSemisimpleModule_submodule
lemma isSemisimpleModule_biSup_of_isSemisimpleModule_submodule {s : Set ι} {p : ι → Submodule R M}
    (hp : ∀ i ∈ s, IsSemisimpleModule R (p i)) :
    IsSemisimpleModule R ↥(⨆ i ∈ s, p i) 
Arguments: {ι : Type u_1} {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {s : Set ι} {p : ι → Submodule R M} (hp : ∀ i ∈ s, IsSemisimpleModule R ↥(p i))
Goal: IsSemisimpleModule R ↥(⨆ i ∈ s, p i)
-- isSemisimpleModule_of_isSemisimpleModule_submodule'
lemma isSemisimpleModule_of_isSemisimpleModule_submodule' {p : ι → Submodule R M}
    (hp : ∀ i, IsSemisimpleModule R (p i)) (hp' : ⨆ i, p i = ⊤) :
    IsSemisimpleModule R M 
Arguments: {ι : Type u_1} {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {p : ι → Submodule R M} (hp : ∀ (i : ι), IsSemisimpleModule R ↥(p i)) (hp' : ⨆ i, p i = ⊤)
Goal: IsSemisimpleModule R M
-- IsSemisimpleModule.sup
theorem IsSemisimpleModule.sup {p q : Submodule R M}
    (_ : IsSemisimpleModule R p) (_ : IsSemisimpleModule R q) :
    IsSemisimpleModule R ↥(p ⊔ q) 
Arguments: {R : Type u_2} [Ring R] {M : Type u_4} [AddCommGroup M] [Module R M] {p q : Submodule R M}
Goal: IsSemisimpleModule R ↥p → IsSemisimpleModule R ↥q → IsSemisimpleModule R ↥(p ⊔ q)
-- RingHom.isSemisimpleRing_of_surjective
theorem RingHom.isSemisimpleRing_of_surjective (f : R →+* S) (hf : Function.Surjective f)
    [IsSemisimpleRing R] : IsSemisimpleRing S 
Arguments: {R : Type u_2} {S : Type u_3} [Ring R] [Ring S] (f : R →+* S) (hf : Function.Surjective ⇑f) [IsSemisimpleRing R]
Goal: IsSemisimpleRing S
-- IsSemisimpleRing.ideal_eq_span_idempotent
theorem IsSemisimpleRing.ideal_eq_span_idempotent [IsSemisimpleRing R] (I : Ideal R) :
    ∃ e : R, IsIdempotentElem e ∧ I = .span {e} 
Arguments: {R : Type u_2} [Ring R] [IsSemisimpleRing R] (I : Ideal R)
Goal: ∃ e, IsIdempotentElem e ∧ I = Ideal.span {e}