ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Ring/Semireal/Defs.lean

full_name: isSemireal
code: /--
A semireal ring is a non-trivial commutative ring (with unit) in which `-1` is *not* a sum of
squares. Note that `-1` does not make sense in a semiring. Below we define the class `isSemiReal R`
for all additive monoid `R` equipped with a multiplication, a multiplicative unit and a negation.
-/
@[mk_iff]
class isSemireal [AddMonoid R] [Mul R] [One R] [Neg R] : Prop where
  non_trivial        : (0 : R) ≠ 1
  neg_one_not_SumSq  : ¬isSumSq (-1 : R)
goal: Prop

full_name: isSemireal_iff
code: /--
A semireal ring is a non-trivial commutative ring (with unit) in which `-1` is *not* a sum of
squares. Note that `-1` does not make sense in a semiring. Below we define the class `isSemiReal R`
for all additive monoid `R` equipped with a multiplication, a multiplicative unit and a negation.
-/
@[mk_iff]
class isSemireal [AddMonoid R] [Mul R] [One R] [Neg R] : Prop where
  non_trivial        : (0 : R) ≠ 1
  neg_one_not_SumSq  : ¬isSumSq (-1 : R)
goal: isSemireal R ↔ 0 ≠ 1 ∧ ¬isSumSq (-1)

full_name: isSemireal.non_trivial
code: /--
A semireal ring is a non-trivial commutative ring (with unit) in which `-1` is *not* a sum of
squares. Note that `-1` does not make sense in a semiring. Below we define the class `isSemiReal R`
for all additive monoid `R` equipped with a multiplication, a multiplicative unit and a negation.
-/
@[mk_iff]
class isSemireal [AddMonoid R] [Mul R] [One R] [Neg R] : Prop where
  non_trivial        : (0 : R) ≠ 1
  neg_one_not_SumSq  : ¬isSumSq (-1 : R)
goal: 0 ≠ 1

full_name: isSemireal.neg_one_not_SumSq
code: /--
A semireal ring is a non-trivial commutative ring (with unit) in which `-1` is *not* a sum of
squares. Note that `-1` does not make sense in a semiring. Below we define the class `isSemiReal R`
for all additive monoid `R` equipped with a multiplication, a multiplicative unit and a negation.
-/
@[mk_iff]
class isSemireal [AddMonoid R] [Mul R] [One R] [Neg R] : Prop where
  non_trivial        : (0 : R) ≠ 1
  neg_one_not_SumSq  : ¬isSumSq (-1 : R)
goal: ¬isSumSq (-1)

full_name: instIsSemireal
code: instance [LinearOrderedField R] : isSemireal R 
goal: isSemireal R
File: Mathlib/Algebra/Ring/Aut.lean

full_name: RingAut
code: /-- The group of ring automorphisms. -/
abbrev RingAut (R : Type*) [Mul R] [Add R] 
goal: Type u_1

full_name: RingAut.instGroup
code: /-- The group operation on automorphisms of a ring is defined by
`fun g h => RingEquiv.trans h g`.
This means that multiplication agrees with composition, `(g*h)(x) = g (h x)`. -/
instance : Group (RingAut R) 
goal: Group (RingAut R)

full_name: RingAut.instInhabited
code: instance : Inhabited (RingAut R) 
goal: Inhabited (RingAut R)

full_name: RingAut.toAddAut
code: /-- Monoid homomorphism from ring automorphisms to additive automorphisms. -/
def toAddAut : RingAut R →* AddAut R 
goal: RingAut R →* AddAut R

full_name: RingAut.toMulAut
code: /-- Monoid homomorphism from ring automorphisms to multiplicative automorphisms. -/
def toMulAut : RingAut R →* MulAut R 
goal: RingAut R →* MulAut R

full_name: RingAut.toPerm
code: /-- Monoid homomorphism from ring automorphisms to permutations. -/
def toPerm : RingAut R →* Equiv.Perm R 
goal: RingAut R →* Equiv.Perm R

full_name: RingAut.applyMulSemiringAction
code: /-- The tautological action by the group of automorphism of a ring `R` on `R`. -/
instance applyMulSemiringAction :
    MulSemiringAction (RingAut R) R 
goal: MulSemiringAction (RingAut R) R

full_name: RingAut.smul_def
code: @[simp]
protected theorem smul_def (f : RingAut R) (r : R) : f • r = f r 
goal: f • r = f r

full_name: RingAut.apply_faithfulSMul
code: instance apply_faithfulSMul : FaithfulSMul (RingAut R) R 
goal: FaithfulSMul (RingAut R) R

full_name: MulSemiringAction.toRingAut_apply
code: /-- Each element of the group defines a ring automorphism.

This is a stronger version of `DistribMulAction.toAddAut` and
`MulDistribMulAction.toMulAut`. -/
@[simps]
def _root_.MulSemiringAction.toRingAut [MulSemiringAction G R] :
    G →* RingAut R 
goal: (MulSemiringAction.toRingAut G R) x = MulSemiringAction.toRingEquiv G R x

full_name: MulSemiringAction.toRingAut
code: /-- Each element of the group defines a ring automorphism.

This is a stronger version of `DistribMulAction.toAddAut` and
`MulDistribMulAction.toMulAut`. -/
@[simps]
def _root_.MulSemiringAction.toRingAut [MulSemiringAction G R] :
    G →* RingAut R 
goal: G →* RingAut R
File: Mathlib/Algebra/MonoidAlgebra/NoZeroDivisors.lean

full_name: MonoidAlgebra.mul_apply_mul_eq_mul_of_uniqueMul
code: /-- The coefficient of a monomial in a product `f * g` that can be reached in at most one way
as a product of monomials in the supports of `f` and `g` is a product. -/
theorem mul_apply_mul_eq_mul_of_uniqueMul [Mul A] {f g : MonoidAlgebra R A} {a0 b0 : A}
    (h : UniqueMul f.support g.support a0 b0) :
    (f * g) (a0 * b0) = f a0 * g b0 
goal: (f * g) (a0 * b0) = f a0 * g b0

full_name: MonoidAlgebra.instNoZeroDivisorsOfUniqueProds
code: instance instNoZeroDivisorsOfUniqueProds [NoZeroDivisors R] [Mul A] [UniqueProds A] :
    NoZeroDivisors (MonoidAlgebra R A) 
goal: NoZeroDivisors (MonoidAlgebra R A)

full_name: AddMonoidAlgebra.mul_apply_add_eq_mul_of_uniqueAdd
code: /-- The coefficient of a monomial in a product `f * g` that can be reached in at most one way
as a product of monomials in the supports of `f` and `g` is a product. -/
theorem mul_apply_add_eq_mul_of_uniqueAdd [Add A] {f g : R[A]} {a0 b0 : A}
    (h : UniqueAdd f.support g.support a0 b0) :
    (f * g) (a0 + b0) = f a0 * g b0 
goal: (f * g) (a0 + b0) = f a0 * g b0

full_name: AddMonoidAlgebra.instNoZeroDivisorsOfUniqueSums
code: instance [NoZeroDivisors R] [Add A] [UniqueSums A] : NoZeroDivisors R[A] 
goal: NoZeroDivisors (AddMonoidAlgebra R A)
File: Mathlib/Algebra/MonoidAlgebra/Ideal.lean

full_name: MonoidAlgebra.mem_ideal_span_of_image
code: /-- If `x` belongs to the ideal generated by generators in `s`, then every element of the support of
`x` factors through an element of `s`.

We could spell `∃ d, m = d * m` as `MulOpposite.op m' ∣ MulOpposite.op m` but this would be worse.
-/
theorem MonoidAlgebra.mem_ideal_span_of_image [Monoid G] [Semiring k] {s : Set G}
    {x : MonoidAlgebra k G} :
    x ∈ Ideal.span (MonoidAlgebra.of k G '' s) ↔ ∀ m ∈ x.support, ∃ m' ∈ s, ∃ d, m = d * m' 
goal: x ∈ Ideal.span (⇑(MonoidAlgebra.of k G) '' s) ↔ ∀ m ∈ x.support, ∃ m' ∈ s, ∃ d, m = d * m'

full_name: AddMonoidAlgebra.mem_ideal_span_of'_image
code: /-- If `x` belongs to the ideal generated by generators in `s`, then every element of the support of
`x` factors additively through an element of `s`.
-/
theorem AddMonoidAlgebra.mem_ideal_span_of'_image [AddMonoid A] [Semiring k] {s : Set A}
    {x : AddMonoidAlgebra k A} :
    x ∈ Ideal.span (AddMonoidAlgebra.of' k A '' s) ↔ ∀ m ∈ x.support, ∃ m' ∈ s, ∃ d, m = d + m' 
goal: x ∈ Ideal.span (AddMonoidAlgebra.of' k A '' s) ↔ ∀ m ∈ x.support, ∃ m' ∈ s, ∃ d, m = d + m'
File: Mathlib/Algebra/BigOperators/RingEquiv.lean

full_name: RingEquiv.map_list_prod
code: protected theorem map_list_prod [Semiring R] [Semiring S] (f : R ≃+* S) (l : List R) :
    f l.prod = (l.map f).prod 
goal: f l.prod = (List.map (⇑f) l).prod

full_name: RingEquiv.map_list_sum
code: protected theorem map_list_sum [NonAssocSemiring R] [NonAssocSemiring S] (f : R ≃+* S)
    (l : List R) : f l.sum = (l.map f).sum 
goal: f l.sum = (List.map (⇑f) l).sum

full_name: RingEquiv.unop_map_list_prod
code: /-- An isomorphism into the opposite ring acts on the product by acting on the reversed elements -/
protected theorem unop_map_list_prod [Semiring R] [Semiring S] (f : R ≃+* Sᵐᵒᵖ) (l : List R) :
    MulOpposite.unop (f l.prod) = (l.map (MulOpposite.unop ∘ f)).reverse.prod 
goal: MulOpposite.unop (f l.prod) = (List.map (MulOpposite.unop ∘ ⇑f) l).reverse.prod

full_name: RingEquiv.map_multiset_prod
code: protected theorem map_multiset_prod [CommSemiring R] [CommSemiring S] (f : R ≃+* S)
    (s : Multiset R) : f s.prod = (s.map f).prod 
goal: f s.prod = (Multiset.map (⇑f) s).prod

full_name: RingEquiv.map_multiset_sum
code: protected theorem map_multiset_sum [NonAssocSemiring R] [NonAssocSemiring S] (f : R ≃+* S)
    (s : Multiset R) : f s.sum = (s.map f).sum 
goal: f s.sum = (Multiset.map (⇑f) s).sum

full_name: RingEquiv.map_prod
code: protected theorem map_prod [CommSemiring R] [CommSemiring S] (g : R ≃+* S) (f : α → R)
    (s : Finset α) : g (∏ x ∈ s, f x) = ∏ x ∈ s, g (f x) 
goal: g (∏ x ∈ s, f x) = ∏ x ∈ s, g (f x)

full_name: RingEquiv.map_sum
code: protected theorem map_sum [NonAssocSemiring R] [NonAssocSemiring S] (g : R ≃+* S) (f : α → R)
    (s : Finset α) : g (∑ x ∈ s, f x) = ∑ x ∈ s, g (f x) 
goal: g (∑ x ∈ s, f x) = ∑ x ∈ s, g (f x)
File: Mathlib/Algebra/BigOperators/Option.lean

full_name: Finset.prod_insertNone
code: @[to_additive (attr := simp)]
theorem prod_insertNone (f : Option α → M) (s : Finset α) :
    ∏ x ∈ insertNone s, f x = f none * ∏ x ∈ s, f (some x) 
goal: ∏ x ∈ Finset.insertNone s, f x = f none * ∏ x ∈ s, f (some x)

full_name: Finset.sum_insertNone
code: @[to_additive (attr := simp)]
theorem prod_insertNone (f : Option α → M) (s : Finset α) :
    ∏ x ∈ insertNone s, f x = f none * ∏ x ∈ s, f (some x) 
goal: ∑ x ∈ Finset.insertNone s, f x = f none + ∑ x ∈ s, f (some x)

full_name: Finset.add_sum_eq_sum_insertNone
code: @[to_additive]
theorem mul_prod_eq_prod_insertNone (f : α → M) (x : M) (s : Finset α) :
    x * ∏ i ∈ s, f i = ∏ i ∈ insertNone s, i.elim x f 
goal: x + ∑ i ∈ s, f i = ∑ i ∈ Finset.insertNone s, i.elim x f

full_name: Finset.mul_prod_eq_prod_insertNone
code: @[to_additive]
theorem mul_prod_eq_prod_insertNone (f : α → M) (x : M) (s : Finset α) :
    x * ∏ i ∈ s, f i = ∏ i ∈ insertNone s, i.elim x f 
goal: x * ∏ i ∈ s, f i = ∏ i ∈ Finset.insertNone s, i.elim x f

full_name: Finset.prod_eraseNone
code: @[to_additive]
theorem prod_eraseNone (f : α → M) (s : Finset (Option α)) :
    ∏ x ∈ eraseNone s, f x = ∏ x ∈ s, Option.elim' 1 f x 
goal: ∏ x ∈ Finset.eraseNone s, f x = ∏ x ∈ s, Option.elim' 1 f x

full_name: Finset.sum_eraseNone
code: @[to_additive]
theorem prod_eraseNone (f : α → M) (s : Finset (Option α)) :
    ∏ x ∈ eraseNone s, f x = ∏ x ∈ s, Option.elim' 1 f x 
goal: ∑ x ∈ Finset.eraseNone s, f x = ∑ x ∈ s, Option.elim' 0 f x
File: Mathlib/Algebra/BigOperators/WithTop.lean

full_name: WithTop.coe_sum
code: @[simp, norm_cast] lemma coe_sum (s : Finset ι) (f : ι → α) :
    ∑ i ∈ s, f i = ∑ i ∈ s, (f i : WithTop α) 
goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

full_name: WithTop.sum_eq_top_iff
code: /-- A sum is infinite iff one term is infinite. -/
lemma sum_eq_top_iff : ∑ i ∈ s, f i = ⊤ ↔ ∃ i ∈ s, f i = ⊤ 
goal: ∑ i ∈ s, f i = ⊤ ↔ ∃ i ∈ s, f i = ⊤

full_name: WithTop.sum_lt_top_iff
code: /-- A sum is finite iff all terms are finite. -/
lemma sum_lt_top_iff : ∑ i ∈ s, f i < ⊤ ↔ ∀ i ∈ s, f i < ⊤ 
goal: ∑ i ∈ s, f i < ⊤ ↔ ∀ i ∈ s, f i < ⊤

full_name: WithTop.sum_lt_top
code: /-- A sum of finite terms is finite. -/
lemma sum_lt_top (h : ∀ i ∈ s, f i ≠ ⊤) : ∑ i ∈ s, f i < ⊤ 
goal: ∑ i ∈ s, f i < ⊤

full_name: WithTop.prod_lt_top
code: /-- A product of finite terms is finite. -/
lemma prod_lt_top [CommMonoidWithZero α] [NoZeroDivisors α] [Nontrivial α] [DecidableEq α] [LT α]
    {s : Finset ι} {f : ι → WithTop α} (h : ∀ i ∈ s, f i ≠ ⊤) : ∏ i ∈ s, f i < ⊤ 
goal: ∏ i ∈ s, f i < ⊤

full_name: WithBot.coe_sum
code: @[simp, norm_cast] lemma coe_sum (s : Finset ι) (f : ι → α) :
    ∑ i ∈ s, f i = ∑ i ∈ s, (f i : WithBot α) 
goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

full_name: WithBot.sum_eq_bot_iff
code: /-- A sum is infinite iff one term is infinite. -/
lemma sum_eq_bot_iff : ∑ i ∈ s, f i = ⊥ ↔ ∃ i ∈ s, f i = ⊥ 
goal: ∑ i ∈ s, f i = ⊥ ↔ ∃ i ∈ s, f i = ⊥

full_name: WithBot.bot_lt_sum_iff
code: /-- A sum is finite iff all terms are finite. -/
lemma bot_lt_sum_iff : ⊥ < ∑ i ∈ s, f i ↔ ∀ i ∈ s, ⊥ < f i 
goal: ⊥ < ∑ i ∈ s, f i ↔ ∀ i ∈ s, ⊥ < f i

full_name: WithBot.sum_lt_bot
code: /-- A sum of finite terms is finite. -/
lemma sum_lt_bot (h : ∀ i ∈ s, f i ≠ ⊥) : ⊥ < ∑ i ∈ s, f i 
goal: ⊥ < ∑ i ∈ s, f i

full_name: WithBot.prod_lt_bot
code: /-- A product of finite terms is finite. -/
lemma prod_lt_bot [CommMonoidWithZero α] [NoZeroDivisors α] [Nontrivial α] [DecidableEq α] [LT α]
    {s : Finset ι} {f : ι → WithBot α} (h : ∀ i ∈ s, f i ≠ ⊥) : ⊥ < ∏ i ∈ s, f i 
goal: ⊥ < ∏ i ∈ s, f i
File: Mathlib/Algebra/BigOperators/GroupWithZero/Finset.lean

full_name: Finset.prod_eq_zero
code: lemma prod_eq_zero (hi : i ∈ s) (h : f i = 0) : ∏ j ∈ s, f j = 0 
goal: ∏ j ∈ s, f j = 0

full_name: Finset.prod_boole
code: lemma prod_boole : ∏ i ∈ s, (ite (p i) 1 0 : M₀) = ite (∀ i ∈ s, p i) 1 0 
goal: (∏ i ∈ s, if p i then 1 else 0) = if ∀ i ∈ s, p i then 1 else 0

full_name: Finset.support_prod_subset
code: lemma support_prod_subset (s : Finset ι) (f : ι → κ → M₀) :
    support (fun x ↦ ∏ i ∈ s, f i x) ⊆ ⋂ i ∈ s, support (f i) 
goal: (Function.support fun x => ∏ i ∈ s, f i x) ⊆ ⋂ i ∈ s, Function.support (f i)

full_name: Finset.prod_eq_zero_iff
code: lemma prod_eq_zero_iff : ∏ x ∈ s, f x = 0 ↔ ∃ a ∈ s, f a = 0 
goal: ∏ x ∈ s, f x = 0 ↔ ∃ a ∈ s, f a = 0

full_name: Finset.prod_ne_zero_iff
code: lemma prod_ne_zero_iff : ∏ x ∈ s, f x ≠ 0 ↔ ∀ a ∈ s, f a ≠ 0 
goal: ∏ x ∈ s, f x ≠ 0 ↔ ∀ a ∈ s, f a ≠ 0

full_name: Finset.support_prod
code: lemma support_prod (s : Finset ι) (f : ι → κ → M₀) :
    support (fun j ↦ ∏ i ∈ s, f i j) = ⋂ i ∈ s, support (f i) 
goal: (Function.support fun j => ∏ i ∈ s, f i j) = ⋂ i ∈ s, Function.support (f i)

full_name: Fintype.prod_boole
code: lemma prod_boole : ∏ i, (ite (p i) 1 0 : M₀) = ite (∀ i, p i) 1 0 
goal: (∏ i : ι, if p i then 1 else 0) = if ∀ (i : ι), p i then 1 else 0

full_name: Units.mk0_prod
code: lemma Units.mk0_prod [CommGroupWithZero G₀] (s : Finset ι) (f : ι → G₀) (h) :
    Units.mk0 (∏ i ∈ s, f i) h =
      ∏ i ∈ s.attach, Units.mk0 (f i) fun hh ↦ h (Finset.prod_eq_zero i.2 hh) 
goal: Units.mk0 (∏ i ∈ s, f i) h = ∏ i ∈ s.attach, Units.mk0 (f ↑i) ⋯
File: Mathlib/Algebra/BigOperators/Ring/Nat.lean

full_name: Finset.even_sum_iff_even_card_odd
code: lemma even_sum_iff_even_card_odd {s : Finset ι} (f : ι → ℕ) :
    Even (∑ i ∈ s, f i) ↔ Even (s.filter fun x ↦ Odd (f x)).card 
goal: Even (∑ i ∈ s, f i) ↔ Even (Finset.filter (fun x => Odd (f x)) s).card

full_name: Finset.odd_sum_iff_odd_card_odd
code: lemma odd_sum_iff_odd_card_odd {s : Finset ι} (f : ι → ℕ) :
    Odd (∑ i ∈ s, f i) ↔ Odd (s.filter fun x ↦ Odd (f x)).card 
goal: Odd (∑ i ∈ s, f i) ↔ Odd (Finset.filter (fun x => Odd (f x)) s).card
File: Mathlib/Algebra/BigOperators/Ring/List.lean

full_name: Commute.list_sum_right
code: lemma list_sum_right (a : R) (l : List R) (h : ∀ b ∈ l, Commute a b) : Commute a l.sum 
goal: Commute a l.sum

full_name: Commute.list_sum_left
code: lemma list_sum_left (b : R) (l : List R) (h : ∀ a ∈ l, Commute a b) : Commute l.sum b 
goal: Commute l.sum b

full_name: List.prod_map_neg
code: @[simp]
lemma prod_map_neg (l : List M) :
    (l.map Neg.neg).prod = (-1) ^ l.length * l.prod 
goal: (List.map Neg.neg l).prod = (-1) ^ l.length * l.prod

full_name: List.prod_eq_zero
code: /-- If zero is an element of a list `l`, then `List.prod l = 0`. If the domain is a nontrivial
monoid with zero with no divisors, then this implication becomes an `iff`, see
`List.prod_eq_zero_iff`. -/
lemma prod_eq_zero : ∀ {l : List M₀}, (0 : M₀) ∈ l → l.prod = 0
  -- |  absurd h (not_mem_nil _)
  
goal: 0 ∈ l → l.prod = 0

full_name: List.prod_eq_zero_iff
code: /-- Product of elements of a list `l` equals zero if and only if `0 ∈ l`. See also
`List.prod_eq_zero` for an implication that needs weaker typeclass assumptions. -/
@[simp] lemma prod_eq_zero_iff : ∀ {l : List M₀}, l.prod = 0 ↔ (0 : M₀) ∈ l
  
goal: l.prod = 0 ↔ 0 ∈ l

full_name: List.prod_ne_zero
code: lemma prod_ne_zero (hL : (0 : M₀) ∉ l) : l.prod ≠ 0 
goal: l.prod ≠ 0

full_name: List.sum_map_mul_left
code: lemma sum_map_mul_left : (l.map fun b ↦ r * f b).sum = r * (l.map f).sum 
goal: (List.map (fun b => r * f b) l).sum = r * (List.map f l).sum

full_name: List.sum_map_mul_right
code: lemma sum_map_mul_right : (l.map fun b ↦ f b * r).sum = (l.map f).sum * r 
goal: (List.map (fun b => f b * r) l).sum = (List.map f l).sum * r

full_name: List.dvd_sum
code: lemma dvd_sum [NonUnitalSemiring R] {a} {l : List R} (h : ∀ x ∈ l, a ∣ x) : a ∣ l.sum 
goal: a ∣ l.sum

full_name: List.sum_zipWith_distrib_left
code: @[simp] lemma sum_zipWith_distrib_left [Semiring R] (f : ι → κ → R) (a : R) :
    ∀ (l₁ : List ι) (l₂ : List κ),
      (zipWith (fun i j ↦ a * f i j) l₁ l₂).sum = a * (zipWith f l₁ l₂).sum
  
goal: (List.zipWith (fun i j => a * f i j) l₁ l₂).sum = a * (List.zipWith f l₁ l₂).sum
File: Mathlib/Algebra/BigOperators/Ring/Multiset.lean

full_name: Multiset.prod_map_neg
code: @[simp] lemma prod_map_neg (s : Multiset α) : (s.map Neg.neg).prod = (-1) ^ card s * s.prod 
goal: (Multiset.map Neg.neg s).prod = (-1) ^ Multiset.card s * s.prod

full_name: Multiset.prod_eq_zero
code: lemma prod_eq_zero (h : (0 : α) ∈ s) : s.prod = 0 
goal: s.prod = 0

full_name: Multiset.prod_eq_zero_iff
code: @[simp] lemma prod_eq_zero_iff : s.prod = 0 ↔ (0 : α) ∈ s 
goal: s.prod = 0 ↔ 0 ∈ s

full_name: Multiset.prod_ne_zero
code: lemma prod_ne_zero (h : (0 : α) ∉ s) : s.prod ≠ 0 
goal: s.prod ≠ 0

full_name: Multiset.sum_map_mul_left
code: lemma sum_map_mul_left : sum (s.map fun i ↦ a * f i) = a * sum (s.map f) 
goal: (Multiset.map (fun i => a * f i) s).sum = a * (Multiset.map f s).sum

full_name: Multiset.sum_map_mul_right
code: lemma sum_map_mul_right : sum (s.map fun i ↦ f i * a) = sum (s.map f) * a 
goal: (Multiset.map (fun i => f i * a) s).sum = (Multiset.map f s).sum * a

full_name: Multiset.dvd_sum
code: lemma dvd_sum : (∀ x ∈ s, a ∣ x) → a ∣ s.sum 
goal: (∀ x ∈ s, a ∣ x) → a ∣ s.sum

full_name: Multiset.prod_map_sum
code: lemma prod_map_sum {s : Multiset (Multiset α)} :
    prod (s.map sum) = sum ((Sections s).map prod) 
goal: (Multiset.map Multiset.sum s).prod = (Multiset.map Multiset.prod s.Sections).sum

full_name: Multiset.prod_map_add
code: lemma prod_map_add {s : Multiset ι} {f g : ι → α} :
    prod (s.map fun i ↦ f i + g i) =
      sum ((antidiagonal s).map fun p ↦ (p.1.map f).prod * (p.2.map g).prod) 
goal: (Multiset.map (fun i => f i + g i) s).prod =
  (Multiset.map (fun p => (Multiset.map f p.1).prod * (Multiset.map g p.2).prod) s.antidiagonal).sum

full_name: Commute.multiset_sum_right
code: theorem multiset_sum_right (a : α) (h : ∀ b ∈ s, Commute a b) : Commute a s.sum 
goal: Commute a s.sum

full_name: Commute.multiset_sum_left
code: theorem multiset_sum_left (b : α) (h : ∀ a ∈ s, Commute a b) : Commute s.sum b 
goal: Commute s.sum b
File: Mathlib/Algebra/CharP/Quotient.lean

full_name: CharP.quotient
code: theorem quotient (R : Type u) [CommRing R] (p : ℕ) [hp1 : Fact p.Prime] (hp2 : ↑p ∈ nonunits R) :
    CharP (R ⧸ (Ideal.span ({(p : R)} : Set R) : Ideal R)) p 
goal: CharP (R ⧸ Ideal.span {↑p}) p

full_name: CharP.quotient'
code: /-- If an ideal does not contain any coercions of natural numbers other than zero, then its quotient
inherits the characteristic of the underlying ring. -/
theorem quotient' {R : Type*} [CommRing R] (p : ℕ) [CharP R p] (I : Ideal R)
    (h : ∀ x : ℕ, (x : R) ∈ I → (x : R) = 0) : CharP (R ⧸ I) p 
goal: CharP (R ⧸ I) p

full_name: CharP.quotient_iff
code: /-- `CharP.quotient'` as an `Iff`. -/
theorem quotient_iff {R : Type*} [CommRing R] (n : ℕ) [CharP R n] (I : Ideal R) :
    CharP (R ⧸ I) n ↔ ∀ x : ℕ, ↑x ∈ I → (x : R) = 0 
goal: CharP (R ⧸ I) n ↔ ∀ (x : ℕ), ↑x ∈ I → ↑x = 0

full_name: CharP.quotient_iff_le_ker_natCast
code: /-- `CharP.quotient_iff`, but stated in terms of inclusions of ideals. -/
theorem quotient_iff_le_ker_natCast {R : Type*} [CommRing R] (n : ℕ) [CharP R n] (I : Ideal R) :
    CharP (R ⧸ I) n ↔ I.comap (Nat.castRingHom R) ≤ RingHom.ker (Nat.castRingHom R) 
goal: CharP (R ⧸ I) n ↔ Ideal.comap (Nat.castRingHom R) I ≤ RingHom.ker (Nat.castRingHom R)

full_name: Ideal.Quotient.index_eq_zero
code: theorem Ideal.Quotient.index_eq_zero {R : Type*} [CommRing R] (I : Ideal R) :
    (↑I.toAddSubgroup.index : R ⧸ I) = 0 
goal: ↑(Submodule.toAddSubgroup I).index = 0
File: Mathlib/Algebra/CharP/Reduced.lean

full_name: iterateFrobenius_inj
code: theorem iterateFrobenius_inj : Function.Injective (iterateFrobenius R p n) 
goal: Function.Injective ⇑(iterateFrobenius R p n)

full_name: frobenius_inj
code: theorem frobenius_inj : Function.Injective (frobenius R p) 
goal: Function.Injective ⇑(frobenius R p)

full_name: isSquare_of_charTwo'
code: /-- If `ringChar R = 2`, where `R` is a finite reduced commutative ring,
then every `a : R` is a square. -/
theorem isSquare_of_charTwo' {R : Type*} [Finite R] [CommRing R] [IsReduced R] [CharP R 2]
    (a : R) : IsSquare a 
goal: IsSquare a

full_name: ExpChar.pow_prime_pow_mul_eq_one_iff
code: @[simp]
theorem ExpChar.pow_prime_pow_mul_eq_one_iff (p k m : ℕ) [ExpChar R p] (x : R) :
    x ^ (p ^ k * m) = 1 ↔ x ^ m = 1 
goal: x ^ (p ^ k * m) = 1 ↔ x ^ m = 1
File: Mathlib/Algebra/CharP/LocalRing.lean

full_name: charP_zero_or_prime_power
code: /-- In a local ring the characteristics is either zero or a prime power. -/
theorem charP_zero_or_prime_power (R : Type*) [CommRing R] [LocalRing R] (q : ℕ)
    [char_R_q : CharP R q] : q = 0 ∨ IsPrimePow q 
goal: q = 0 ∨ IsPrimePow q
File: Mathlib/Algebra/CharP/IntermediateField.lean

full_name: Subfield.charP
code: instance charP [CharP F p] : CharP L p 
goal: CharP (↥L) p

full_name: Subfield.expChar
code: instance expChar [ExpChar F p] : ExpChar L p 
goal: ExpChar (↥L) p

full_name: IntermediateField.charZero
code: instance charZero [CharZero F] : CharZero L 
goal: CharZero ↥L

full_name: IntermediateField.charP
code: instance charP [CharP F p] : CharP L p 
goal: CharP (↥L) p

full_name: IntermediateField.expChar
code: instance expChar [ExpChar F p] : ExpChar L p 
goal: ExpChar (↥L) p

full_name: IntermediateField.charP'
code: instance charP' [CharP E p] : CharP L p 
goal: CharP (↥L) p

full_name: IntermediateField.expChar'
code: instance expChar' [ExpChar E p] : ExpChar L p 
goal: ExpChar (↥L) p