ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/RingTheory/LocalRing/Basic.lean

full_name: LocalRing.of_isUnit_or_isUnit_of_isUnit_add
code: theorem of_isUnit_or_isUnit_of_isUnit_add [Nontrivial R]
    (h : ∀ a b : R, IsUnit (a + b) → IsUnit a ∨ IsUnit b) : LocalRing R 
goal: LocalRing R

full_name: LocalRing.of_nonunits_add
code: /-- A semiring is local if it is nontrivial and the set of nonunits is closed under the addition. -/
theorem of_nonunits_add [Nontrivial R]
    (h : ∀ a b : R, a ∈ nonunits R → b ∈ nonunits R → a + b ∈ nonunits R) : LocalRing R 
goal: LocalRing R

full_name: LocalRing.of_unique_max_ideal
code: /-- A semiring is local if it has a unique maximal ideal. -/
theorem of_unique_max_ideal (h : ∃! I : Ideal R, I.IsMaximal) : LocalRing R 
goal: LocalRing R

full_name: LocalRing.of_unique_nonzero_prime
code: theorem of_unique_nonzero_prime (h : ∃! P : Ideal R, P ≠ ⊥ ∧ Ideal.IsPrime P) : LocalRing R 
goal: LocalRing R

full_name: LocalRing.isUnit_or_isUnit_of_isUnit_add
code: theorem isUnit_or_isUnit_of_isUnit_add {a b : R} (h : IsUnit (a + b)) : IsUnit a ∨ IsUnit b 
goal: IsUnit a ∨ IsUnit b

full_name: LocalRing.nonunits_add
code: theorem nonunits_add {a b : R} (ha : a ∈ nonunits R) (hb : b ∈ nonunits R) : a + b ∈ nonunits R 
goal: a + b ∈ nonunits R

full_name: LocalRing.of_isUnit_or_isUnit_one_sub_self
code: theorem of_isUnit_or_isUnit_one_sub_self [Nontrivial R] (h : ∀ a : R, IsUnit a ∨ IsUnit (1 - a)) :
    LocalRing R 
goal: LocalRing R

full_name: LocalRing.isUnit_or_isUnit_one_sub_self
code: theorem isUnit_or_isUnit_one_sub_self (a : R) : IsUnit a ∨ IsUnit (1 - a) 
goal: IsUnit a ∨ IsUnit (1 - a)

full_name: LocalRing.isUnit_of_mem_nonunits_one_sub_self
code: theorem isUnit_of_mem_nonunits_one_sub_self (a : R) (h : 1 - a ∈ nonunits R) : IsUnit a 
goal: IsUnit a

full_name: LocalRing.isUnit_one_sub_self_of_mem_nonunits
code: theorem isUnit_one_sub_self_of_mem_nonunits (a : R) (h : a ∈ nonunits R) : IsUnit (1 - a) 
goal: IsUnit (1 - a)

full_name: LocalRing.of_surjective'
code: theorem of_surjective' [CommRing S] [Nontrivial S] (f : R →+* S) (hf : Function.Surjective f) :
    LocalRing S 
goal: LocalRing S

full_name: Field.instLocalRing
code: instance (priority := 100) : LocalRing K 
goal: LocalRing K
File: Mathlib/RingTheory/LocalRing/Defs.lean

full_name: LocalRing.of_is_unit_or_is_unit_of_add_one
code: /-- A semiring is local if it is nontrivial and `a` or `b` is a unit whenever `a + b = 1`.
Note that `LocalRing` is a predicate. -/
class LocalRing (R : Type*) [Semiring R] extends Nontrivial R : Prop where
  of_is_unit_or_is_unit_of_add_one ::
  /-- in a local ring `R`, if `a + b = 1`, then either `a` is a unit or `b` is a unit. In another
    word, for every `a : R`, either `a` is a unit or `1 - a` is a unit. -/
  isUnit_or_isUnit_of_add_one {a b : R} (h : a + b = 1) : IsUnit a ∨ IsUnit b
goal: LocalRing R

full_name: LocalRing.isUnit_or_isUnit_of_add_one
code: /-- A semiring is local if it is nontrivial and `a` or `b` is a unit whenever `a + b = 1`.
Note that `LocalRing` is a predicate. -/
class LocalRing (R : Type*) [Semiring R] extends Nontrivial R : Prop where
  of_is_unit_or_is_unit_of_add_one ::
  /-- in a local ring `R`, if `a + b = 1`, then either `a` is a unit or `b` is a unit. In another
    word, for every `a : R`, either `a` is a unit or `1 - a` is a unit. -/
  isUnit_or_isUnit_of_add_one {a b : R} (h : a + b = 1) : IsUnit a ∨ IsUnit b
goal: IsUnit a ∨ IsUnit b

full_name: LocalRing
code: /-- A semiring is local if it is nontrivial and `a` or `b` is a unit whenever `a + b = 1`.
Note that `LocalRing` is a predicate. -/
class LocalRing (R : Type*) [Semiring R] extends Nontrivial R : Prop where
  of_is_unit_or_is_unit_of_add_one ::
  /-- in a local ring `R`, if `a + b = 1`, then either `a` is a unit or `b` is a unit. In another
    word, for every `a : R`, either `a` is a unit or `1 - a` is a unit. -/
  isUnit_or_isUnit_of_add_one {a b : R} (h : a + b = 1) : IsUnit a ∨ IsUnit b
goal: Prop
File: Mathlib/RingTheory/LocalRing/RingHom/Defs.lean

full_name: IsLocalRingHom.map_nonunit
code: /-- A local ring homomorphism is a homomorphism `f` between local rings such that `a` in the domain
  is a unit if `f a` is a unit for any `a`. See `LocalRing.local_hom_TFAE` for other equivalent
  definitions. -/
class IsLocalRingHom {R S : Type*} [Semiring R] [Semiring S] (f : R →+* S) : Prop where
  /-- A local ring homomorphism `f : R ⟶ S` will send nonunits of `R` to nonunits of `S`. -/
  map_nonunit : ∀ a, IsUnit (f a) → IsUnit a
goal: IsUnit (f a) → IsUnit a

full_name: IsLocalRingHom
code: /-- A local ring homomorphism is a homomorphism `f` between local rings such that `a` in the domain
  is a unit if `f a` is a unit for any `a`. See `LocalRing.local_hom_TFAE` for other equivalent
  definitions. -/
class IsLocalRingHom {R S : Type*} [Semiring R] [Semiring S] (f : R →+* S) : Prop where
  /-- A local ring homomorphism `f : R ⟶ S` will send nonunits of `R` to nonunits of `S`. -/
  map_nonunit : ∀ a, IsUnit (f a) → IsUnit a
goal: Prop
File: Mathlib/RingTheory/Localization/BaseChange.lean

full_name: IsLocalizedModule.isBaseChange
code: /-- The forward direction of `isLocalizedModule_iff_isBaseChange`. It is also used to prove the
other direction. -/
theorem IsLocalizedModule.isBaseChange [IsLocalizedModule S f] : IsBaseChange A f 
goal: IsBaseChange A f

full_name: isLocalizedModule_iff_isBaseChange
code: /-- The map `(f : M →ₗ[R] M')` is a localization of modules iff the map
`(localization S) × M → N, (s, m) ↦ s • f m` is the tensor product (insomuch as it is the universal
bilinear map).
In particular, there is an isomorphism between `LocalizedModule S M` and `(Localization S) ⊗[R] M`
given by `m/s ↦ (1/s) ⊗ₜ m`.
-/
theorem isLocalizedModule_iff_isBaseChange : IsLocalizedModule S f ↔ IsBaseChange A f 
goal: IsLocalizedModule S f ↔ IsBaseChange A f
File: Mathlib/RingTheory/LocalRing/MaximalIdeal/Defs.lean

full_name: LocalRing.maximalIdeal
code: /-- The ideal of elements that are not units. -/
def maximalIdeal : Ideal R 
goal: Ideal R
File: Mathlib/RingTheory/LocalRing/ResidueField/Defs.lean

full_name: LocalRing.ResidueField
code: /-- The residue field of a local ring is the quotient of the ring by its maximal ideal. -/
def ResidueField 
goal: Type u_1

full_name: LocalRing.ResidueFieldCommRing
code: instance ResidueFieldCommRing : CommRing (ResidueField R) 
goal: CommRing (LocalRing.ResidueField R)

full_name: LocalRing.ResidueFieldInhabited
code: instance ResidueFieldInhabited : Inhabited (ResidueField R) 
goal: Inhabited (LocalRing.ResidueField R)

full_name: LocalRing.ResidueField.field
code: noncomputable instance ResidueField.field : Field (ResidueField R) 
goal: Field (LocalRing.ResidueField R)

full_name: LocalRing.residue
code: /-- The quotient map from a local ring to its residue field. -/
def residue : R →+* ResidueField R 
goal: R →+* LocalRing.ResidueField R
File: Mathlib/RingTheory/LocalRing/MaximalIdeal/Basic.lean

full_name: LocalRing.maximalIdeal.isMaximal
code: instance maximalIdeal.isMaximal : (maximalIdeal R).IsMaximal 
goal: (LocalRing.maximalIdeal R).IsMaximal

full_name: LocalRing.maximal_ideal_unique
code: theorem maximal_ideal_unique : ∃! I : Ideal R, I.IsMaximal 
goal: ∃! I, I.IsMaximal

full_name: LocalRing.eq_maximalIdeal
code: theorem eq_maximalIdeal {I : Ideal R} (hI : I.IsMaximal) : I = maximalIdeal R 
goal: I = LocalRing.maximalIdeal R

full_name: LocalRing.le_maximalIdeal
code: theorem le_maximalIdeal {J : Ideal R} (hJ : J ≠ ⊤) : J ≤ maximalIdeal R 
goal: J ≤ LocalRing.maximalIdeal R

full_name: LocalRing.mem_maximalIdeal
code: @[simp]
theorem mem_maximalIdeal (x) : x ∈ maximalIdeal R ↔ x ∈ nonunits R 
goal: x ∈ LocalRing.maximalIdeal R ↔ x ∈ nonunits R

full_name: LocalRing.isField_iff_maximalIdeal_eq
code: theorem isField_iff_maximalIdeal_eq : IsField R ↔ maximalIdeal R = ⊥ 
goal: IsField R ↔ LocalRing.maximalIdeal R = ⊥

full_name: LocalRing.maximalIdeal_le_jacobson
code: theorem maximalIdeal_le_jacobson (I : Ideal R) :
    LocalRing.maximalIdeal R ≤ I.jacobson 
goal: LocalRing.maximalIdeal R ≤ I.jacobson

full_name: LocalRing.jacobson_eq_maximalIdeal
code: theorem jacobson_eq_maximalIdeal (I : Ideal R) (h : I ≠ ⊤) :
    I.jacobson = LocalRing.maximalIdeal R 
goal: I.jacobson = LocalRing.maximalIdeal R

full_name: LocalRing.ker_eq_maximalIdeal
code: theorem ker_eq_maximalIdeal [Field K] (φ : R →+* K) (hφ : Function.Surjective φ) :
    RingHom.ker φ = maximalIdeal R 
goal: RingHom.ker φ = LocalRing.maximalIdeal R

full_name: LocalRing.maximalIdeal_eq_bot
code: theorem LocalRing.maximalIdeal_eq_bot {R : Type*} [Field R] : LocalRing.maximalIdeal R = ⊥ 
goal: LocalRing.maximalIdeal R = ⊥
File: Mathlib/RingTheory/Fintype.lean

full_name: Finset.univ_of_card_le_two
code: lemma Finset.univ_of_card_le_two (h : Fintype.card R ≤ 2) :
    (univ : Finset R) = {0, 1} 
goal: Finset.univ = {0, 1}

full_name: Finset.univ_of_card_le_three
code: lemma Finset.univ_of_card_le_three (h : Fintype.card R ≤ 3) :
    (univ : Finset R) = {0, 1, -1} 
goal: Finset.univ = {0, 1, -1}

full_name: card_units_lt
code: theorem card_units_lt (M₀ : Type*) [MonoidWithZero M₀] [Nontrivial M₀] [Fintype M₀] :
    Fintype.card M₀ˣ < Fintype.card M₀ 
goal: Fintype.card M₀ˣ < Fintype.card M₀
File: Mathlib/RingTheory/Unramified/Derivations.lean

full_name: Algebra.FormallyUnramified.subsingleton_kaehlerDifferential
code: instance FormallyUnramified.subsingleton_kaehlerDifferential [FormallyUnramified R S] :
    Subsingleton (Ω[S⁄R]) 
goal: Subsingleton (Ω[S⁄R])

full_name: Algebra.FormallyUnramified.iff_subsingleton_kaehlerDifferential
code: theorem FormallyUnramified.iff_subsingleton_kaehlerDifferential :
    FormallyUnramified R S ↔ Subsingleton (Ω[S⁄R]) 
goal: Algebra.FormallyUnramified R S ↔ Subsingleton (Ω[S⁄R])
File: Mathlib/RingTheory/Complex.lean

full_name: Algebra.leftMulMatrix_complex
code: theorem Algebra.leftMulMatrix_complex (z : ℂ) :
    Algebra.leftMulMatrix Complex.basisOneI z = !![z.re, -z.im; z.im, z.re] 
goal: (Algebra.leftMulMatrix Complex.basisOneI) z = !![z.re, -z.im; z.im, z.re]

full_name: Algebra.trace_complex_apply
code: theorem Algebra.trace_complex_apply (z : ℂ) : Algebra.trace ℝ ℂ z = 2 * z.re 
goal: (Algebra.trace ℝ ℂ) z = 2 * z.re

full_name: Algebra.norm_complex_apply
code: theorem Algebra.norm_complex_apply (z : ℂ) : Algebra.norm ℝ z = Complex.normSq z 
goal: (Algebra.norm ℝ) z = Complex.normSq z

full_name: Algebra.norm_complex_eq
code: theorem Algebra.norm_complex_eq : Algebra.norm ℝ = normSq.toMonoidHom 
goal: Algebra.norm ℝ = ↑Complex.normSq
File: Mathlib/RingTheory/MvPolynomial/Ideal.lean

full_name: MvPolynomial.mem_ideal_span_monomial_image
code: /-- `x` is in a monomial ideal generated by `s` iff every element of its support dominates one of
the generators. Note that `si ≤ xi` is analogous to saying that the monomial corresponding to `si`
divides the monomial corresponding to `xi`. -/
theorem mem_ideal_span_monomial_image {x : MvPolynomial σ R} {s : Set (σ →₀ ℕ)} :
    x ∈ Ideal.span ((fun s => monomial s (1 : R)) '' s) ↔ ∀ xi ∈ x.support, ∃ si ∈ s, si ≤ xi 
goal: x ∈ Ideal.span ((fun s => (MvPolynomial.monomial s) 1) '' s) ↔ ∀ xi ∈ x.support, ∃ si ∈ s, si ≤ xi

full_name: MvPolynomial.mem_ideal_span_monomial_image_iff_dvd
code: theorem mem_ideal_span_monomial_image_iff_dvd {x : MvPolynomial σ R} {s : Set (σ →₀ ℕ)} :
    x ∈ Ideal.span ((fun s => monomial s (1 : R)) '' s) ↔
      ∀ xi ∈ x.support, ∃ si ∈ s, monomial si 1 ∣ monomial xi (x.coeff xi) 
goal: x ∈ Ideal.span ((fun s => (MvPolynomial.monomial s) 1) '' s) ↔
  ∀ xi ∈ x.support, ∃ si ∈ s, (MvPolynomial.monomial si) 1 ∣ (MvPolynomial.monomial xi) (MvPolynomial.coeff xi x)

full_name: MvPolynomial.mem_ideal_span_X_image
code: /-- `x` is in a monomial ideal generated by variables `X` iff every element of its support
has a component in `s`. -/
theorem mem_ideal_span_X_image {x : MvPolynomial σ R} {s : Set σ} :
    x ∈ Ideal.span (MvPolynomial.X '' s : Set (MvPolynomial σ R)) ↔
      ∀ m ∈ x.support, ∃ i ∈ s, (m : σ →₀ ℕ) i ≠ 0 
goal: x ∈ Ideal.span (MvPolynomial.X '' s) ↔ ∀ m ∈ x.support, ∃ i ∈ s, m i ≠ 0
File: Mathlib/RingTheory/MvPolynomial/Tower.lean

full_name: MvPolynomial.aeval_map_algebraMap
code: theorem aeval_map_algebraMap (x : σ → B) (p : MvPolynomial σ R) :
    aeval x (map (algebraMap R A) p) = aeval x p 
goal: (MvPolynomial.aeval x) ((MvPolynomial.map (algebraMap R A)) p) = (MvPolynomial.aeval x) p

full_name: MvPolynomial.aeval_algebraMap_apply
code: theorem aeval_algebraMap_apply (x : σ → A) (p : MvPolynomial σ R) :
    aeval (algebraMap A B ∘ x) p = algebraMap A B (MvPolynomial.aeval x p) 
goal: (MvPolynomial.aeval (⇑(algebraMap A B) ∘ x)) p = (algebraMap A B) ((MvPolynomial.aeval x) p)

full_name: MvPolynomial.aeval_algebraMap_eq_zero_iff
code: theorem aeval_algebraMap_eq_zero_iff [NoZeroSMulDivisors A B] [Nontrivial B] (x : σ → A)
    (p : MvPolynomial σ R) : aeval (algebraMap A B ∘ x) p = 0 ↔ aeval x p = 0 
goal: (MvPolynomial.aeval (⇑(algebraMap A B) ∘ x)) p = 0 ↔ (MvPolynomial.aeval x) p = 0

full_name: MvPolynomial.aeval_algebraMap_eq_zero_iff_of_injective
code: theorem aeval_algebraMap_eq_zero_iff_of_injective {x : σ → A} {p : MvPolynomial σ R}
    (h : Function.Injective (algebraMap A B)) :
    aeval (algebraMap A B ∘ x) p = 0 ↔ aeval x p = 0 
goal: (MvPolynomial.aeval (⇑(algebraMap A B) ∘ x)) p = 0 ↔ (MvPolynomial.aeval x) p = 0

full_name: Subalgebra.mvPolynomial_aeval_coe
code: @[simp]
theorem mvPolynomial_aeval_coe (S : Subalgebra R A) (x : σ → S) (p : MvPolynomial σ R) :
    aeval (fun i => (x i : A)) p = aeval x p 
goal: (MvPolynomial.aeval fun i => ↑(x i)) p = ↑((MvPolynomial.aeval x) p)
File: Mathlib/RingTheory/Congruence/BigOperators.lean

full_name: RingCon.listSum
code: /-- Congruence relation of a ring preserves finite sum indexed by a list. -/
protected lemma listSum {ι S : Type*} [AddMonoid S] [Mul S]
    (t : RingCon S) (l : List ι) {f g : ι → S} (h : ∀ i ∈ l, t (f i) (g i)) :
    t (l.map f).sum (l.map g).sum 
goal: t (List.map f l).sum (List.map g l).sum

full_name: RingCon.multisetSum
code: /-- Congruence relation of a ring preserves finite sum indexed by a multiset. -/
protected lemma multisetSum {ι S : Type*} [AddCommMonoid S] [Mul S] (t : RingCon S)
    (s : Multiset ι) {f g : ι → S} (h : ∀ i ∈ s, t (f i) (g i)) :
    t (s.map f).sum (s.map g).sum 
goal: t (Multiset.map f s).sum (Multiset.map g s).sum

full_name: RingCon.finsetSum
code: /-- Congruence relation of a ring preserves finite sum. -/
protected lemma finsetSum {ι S : Type*} [AddCommMonoid S] [Mul S] (t : RingCon S) (s : Finset ι)
    {f g : ι → S} (h : ∀ i ∈ s, t (f i) (g i)) :
    t (s.sum f) (s.sum g) 
goal: t (s.sum f) (s.sum g)
File: Mathlib/RingTheory/Congruence/Opposite.lean

full_name: RingCon.op
code: /--
If `c` is a `RingCon R`, then `(a, b) ↦ c b.unop a.unop` is a `RingCon Rᵐᵒᵖ`.
-/
def op (c : RingCon R) : RingCon Rᵐᵒᵖ 
goal: RingCon Rᵐᵒᵖ

full_name: RingCon.op_iff
code: lemma op_iff {c : RingCon R} {x y : Rᵐᵒᵖ} : c.op x y ↔ c y.unop x.unop 
goal: c.op x y ↔ c (MulOpposite.unop y) (MulOpposite.unop x)

full_name: RingCon.unop
code: /--
If `c` is a `RingCon Rᵐᵒᵖ`, then `(a, b) ↦ c b.op a.op` is a `RingCon R`.
-/
def unop (c : RingCon Rᵐᵒᵖ) : RingCon R 
goal: RingCon R

full_name: RingCon.unop_iff
code: lemma unop_iff {c : RingCon Rᵐᵒᵖ} {x y : R} : c.unop x y ↔ c (.op y) (.op x) 
goal: c.unop x y ↔ c (MulOpposite.op y) (MulOpposite.op x)

full_name: RingCon.opOrderIso
code: /--
The congruences of a ring `R` biject to the congruences of the opposite ring `Rᵐᵒᵖ`.
-/
@[simps]
def opOrderIso : RingCon R ≃o RingCon Rᵐᵒᵖ 
goal: RingCon R ≃o RingCon Rᵐᵒᵖ

full_name: RingCon.opOrderIso_symm_apply
code: /--
The congruences of a ring `R` biject to the congruences of the opposite ring `Rᵐᵒᵖ`.
-/
@[simps]
def opOrderIso : RingCon R ≃o RingCon Rᵐᵒᵖ 
goal: (RelIso.symm RingCon.opOrderIso) c = c.unop

full_name: RingCon.opOrderIso_apply
code: /--
The congruences of a ring `R` biject to the congruences of the opposite ring `Rᵐᵒᵖ`.
-/
@[simps]
def opOrderIso : RingCon R ≃o RingCon Rᵐᵒᵖ 
goal: RingCon.opOrderIso c = c.op
File: Mathlib/RingTheory/MaximalSpectrum.lean

full_name: MaximalSpectrum.asIdeal
code: /-- The maximal spectrum of a commutative ring `R` is the type of all maximal ideals of `R`. -/
@[ext]
structure MaximalSpectrum where
  asIdeal : Ideal R
  IsMaximal : asIdeal.IsMaximal
goal: Ideal R

full_name: MaximalSpectrum.IsMaximal
code: /-- The maximal spectrum of a commutative ring `R` is the type of all maximal ideals of `R`. -/
@[ext]
structure MaximalSpectrum where
  asIdeal : Ideal R
  IsMaximal : asIdeal.IsMaximal
goal: self.asIdeal.IsMaximal

full_name: MaximalSpectrum
code: /-- The maximal spectrum of a commutative ring `R` is the type of all maximal ideals of `R`. -/
@[ext]
structure MaximalSpectrum where
  asIdeal : Ideal R
  IsMaximal : asIdeal.IsMaximal
goal: Type u

full_name: MaximalSpectrum.instNonemptyOfNontrivial
code: instance [Nontrivial R] : Nonempty <| MaximalSpectrum R 
goal: Nonempty (MaximalSpectrum R)

full_name: MaximalSpectrum.toPrimeSpectrum
code: /-- The natural inclusion from the maximal spectrum to the prime spectrum. -/
def toPrimeSpectrum (x : MaximalSpectrum R) : PrimeSpectrum R 
goal: PrimeSpectrum R

full_name: MaximalSpectrum.toPrimeSpectrum_injective
code: theorem toPrimeSpectrum_injective : (@toPrimeSpectrum R _).Injective 
goal: Function.Injective MaximalSpectrum.toPrimeSpectrum

full_name: MaximalSpectrum.iInf_localization_eq_bot
code: /-- An integral domain is equal to the intersection of its localizations at all its maximal ideals
viewed as subalgebras of its field of fractions. -/
theorem iInf_localization_eq_bot : (⨅ v : MaximalSpectrum R,
    Localization.subalgebra.ofField K _ v.asIdeal.primeCompl_le_nonZeroDivisors) = ⊥ 
goal: ⨅ v, Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯ = ⊥

full_name: PrimeSpectrum.iInf_localization_eq_bot
code: /-- An integral domain is equal to the intersection of its localizations at all its prime ideals
viewed as subalgebras of its field of fractions. -/
theorem iInf_localization_eq_bot : ⨅ v : PrimeSpectrum R,
    Localization.subalgebra.ofField K _ (v.asIdeal.primeCompl_le_nonZeroDivisors) = ⊥ 
goal: ⨅ v, Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯ = ⊥
File: Mathlib/RingTheory/EisensteinCriterion.lean

full_name: Polynomial.EisensteinCriterionAux.map_eq_C_mul_X_pow_of_forall_coeff_mem
code: theorem map_eq_C_mul_X_pow_of_forall_coeff_mem {f : R[X]} {P : Ideal R}
    (hfP : ∀ n : ℕ, ↑n < f.degree → f.coeff n ∈ P) :
    map (mk P) f = C ((mk P) f.leadingCoeff) * X ^ f.natDegree 
goal: Polynomial.map (Ideal.Quotient.mk P) f =
  Polynomial.C ((Ideal.Quotient.mk P) f.leadingCoeff) * Polynomial.X ^ f.natDegree

full_name: Polynomial.EisensteinCriterionAux.le_natDegree_of_map_eq_mul_X_pow
code: theorem le_natDegree_of_map_eq_mul_X_pow {n : ℕ} {P : Ideal R} (hP : P.IsPrime) {q : R[X]}
    {c : Polynomial (R ⧸ P)} (hq : map (mk P) q = c * X ^ n) (hc0 : c.degree = 0) :
    n ≤ q.natDegree 
goal: n ≤ q.natDegree

full_name: Polynomial.EisensteinCriterionAux.eval_zero_mem_ideal_of_eq_mul_X_pow
code: theorem eval_zero_mem_ideal_of_eq_mul_X_pow {n : ℕ} {P : Ideal R} {q : R[X]}
    {c : Polynomial (R ⧸ P)} (hq : map (mk P) q = c * X ^ n) (hn0 : n ≠ 0) : eval 0 q ∈ P 
goal: Polynomial.eval 0 q ∈ P

full_name: Polynomial.EisensteinCriterionAux.isUnit_of_natDegree_eq_zero_of_isPrimitive
code: theorem isUnit_of_natDegree_eq_zero_of_isPrimitive {p q : R[X]}
    -- Porting note: stated using `IsPrimitive` which is defeq to old statement.
    (hu : IsPrimitive (p * q)) (hpm : p.natDegree = 0) : IsUnit p 
goal: IsUnit p

full_name: Polynomial.irreducible_of_eisenstein_criterion
code: /-- If `f` is a non constant polynomial with coefficients in `R`, and `P` is a prime ideal in `R`,
then if every coefficient in `R` except the leading coefficient is in `P`, and
the trailing coefficient is not in `P^2` and no non units in `R` divide `f`, then `f` is
irreducible. -/
theorem irreducible_of_eisenstein_criterion {f : R[X]} {P : Ideal R} (hP : P.IsPrime)
    (hfl : f.leadingCoeff ∉ P) (hfP : ∀ n : ℕ, ↑n < degree f → f.coeff n ∈ P) (hfd0 : 0 < degree f)
    (h0 : f.coeff 0 ∉ P ^ 2) (hu : f.IsPrimitive) : Irreducible f 
goal: Irreducible f
File: Mathlib/RingTheory/Norm/Defs.lean

full_name: Algebra.norm
code: /-- The norm of an element `s` of an `R`-algebra is the determinant of `(*) s`. -/
noncomputable def norm : S →* R 
goal: S →* R

full_name: Algebra.norm_apply
code: theorem norm_apply (x : S) : norm R x = LinearMap.det (lmul R S x) 
goal: (Algebra.norm R) x = LinearMap.det ((Algebra.lmul R S) x)

full_name: Algebra.norm_eq_one_of_not_exists_basis
code: theorem norm_eq_one_of_not_exists_basis (h : ¬∃ s : Finset S, Nonempty (Basis s R S)) (x : S) :
    norm R x = 1 
goal: (Algebra.norm R) x = 1

full_name: Algebra.norm_eq_one_of_not_module_finite
code: theorem norm_eq_one_of_not_module_finite (h : ¬Module.Finite R S) (x : S) : norm R x = 1 
goal: (Algebra.norm R) x = 1

full_name: Algebra.norm_eq_matrix_det
code: theorem norm_eq_matrix_det [Fintype ι] [DecidableEq ι] (b : Basis ι R S) (s : S) :
    norm R s = Matrix.det (Algebra.leftMulMatrix b s) 
goal: (Algebra.norm R) s = ((Algebra.leftMulMatrix b) s).det

full_name: Algebra.norm_algebraMap_of_basis
code: /-- If `x` is in the base ring `K`, then the norm is `x ^ [L : K]`. -/
theorem norm_algebraMap_of_basis [Fintype ι] (b : Basis ι R S) (x : R) :
    norm R (algebraMap R S x) = x ^ Fintype.card ι 
goal: (Algebra.norm R) ((algebraMap R S) x) = x ^ Fintype.card ι

full_name: Algebra.norm_algebraMap
code: /-- If `x` is in the base field `K`, then the norm is `x ^ [L : K]`.

(If `L` is not finite-dimensional over `K`, then `norm = 1 = x ^ 0 = x ^ (finrank L K)`.)
-/
@[simp]
protected theorem norm_algebraMap {L : Type*} [Ring L] [Algebra K L] (x : K) :
    norm K (algebraMap K L x) = x ^ finrank K L 
goal: (Algebra.norm K) ((algebraMap K L) x) = x ^ FiniteDimensional.finrank K L
File: Mathlib/RingTheory/LittleWedderburn.lean

full_name: _private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp
code: private def InductionHyp : Prop 
goal: Prop

full_name: _private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field
code: private def field (hD : InductionHyp D) {R : Subring D} (hR : R < ⊤)
  [Fintype D] [DecidableEq D] [DecidablePred (· ∈ R)] :
    Field R 
goal: Field ↥R

full_name: _private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.center_eq_top
code: /-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤ 
goal: Subring.center D = ⊤

full_name: _private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.center_eq_top
code: private theorem center_eq_top [Finite D] : Subring.center D = ⊤ 
goal: Subring.center D = ⊤

full_name: littleWedderburn
code: /-- A finite division ring is a field. See `Finite.isDomain_to_isField` and
`Fintype.divisionRingOfIsDomain` for more general statements, but these create data, and therefore
may cause diamonds if used improperly. -/
instance (priority := 100) littleWedderburn (D : Type*) [DivisionRing D] [Finite D] : Field D 
goal: Field D

full_name: Finite.isDomain_to_isField
code: /-- A finite domain is a field. See also `littleWedderburn` and `Fintype.divisionRingOfIsDomain`. -/
theorem Finite.isDomain_to_isField (D : Type*) [Finite D] [Ring D] [IsDomain D] : IsField D 
goal: IsField D