ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/RingTheory/Polynomial/RationalRoot.lean

full_name: scaleRoots_aeval_eq_zero_of_aeval_mk'_eq_zero
code: theorem scaleRoots_aeval_eq_zero_of_aeval_mk'_eq_zero {p : A[X]} {r : A} {s : M}
    (hr : aeval (mk' S r s) p = 0) : aeval (algebraMap A S r) (scaleRoots p s) = 0 
goal: (Polynomial.aeval ((algebraMap A S) r)) (p.scaleRoots ↑s) = 0

full_name: num_isRoot_scaleRoots_of_aeval_eq_zero
code: theorem num_isRoot_scaleRoots_of_aeval_eq_zero [UniqueFactorizationMonoid A] {p : A[X]} {x : K}
    (hr : aeval x p = 0) : IsRoot (scaleRoots p (den A x)) (num A x) 
goal: (p.scaleRoots ↑(IsFractionRing.den A x)).IsRoot (IsFractionRing.num A x)

full_name: num_dvd_of_is_root
code: /-- **Rational root theorem** part 1:
if `r : f.codomain` is a root of a polynomial over the ufd `A`,
then the numerator of `r` divides the constant coefficient -/
theorem num_dvd_of_is_root {p : A[X]} {r : K} (hr : aeval r p = 0) : num A r ∣ p.coeff 0 
goal: IsFractionRing.num A r ∣ p.coeff 0

full_name: den_dvd_of_is_root
code: /-- Rational root theorem part 2:
if `r : f.codomain` is a root of a polynomial over the ufd `A`,
then the denominator of `r` divides the leading coefficient -/
theorem den_dvd_of_is_root {p : A[X]} {r : K} (hr : aeval r p = 0) :
    (den A r : A) ∣ p.leadingCoeff 
goal: ↑(IsFractionRing.den A r) ∣ p.leadingCoeff

full_name: isInteger_of_is_root_of_monic
code: /-- **Integral root theorem**:
if `r : f.codomain` is a root of a monic polynomial over the ufd `A`,
then `r` is an integer -/
theorem isInteger_of_is_root_of_monic {p : A[X]} (hp : Monic p) {r : K} (hr : aeval r p = 0) :
    IsInteger A r 
goal: IsLocalization.IsInteger A r

full_name: exists_integer_of_is_root_of_monic
code: theorem exists_integer_of_is_root_of_monic {p : A[X]} (hp : Monic p) {r : K} (hr : aeval r p = 0) :
    ∃ r' : A, r = algebraMap A K r' ∧ r' ∣ p.coeff 0 
goal: ∃ r', r = (algebraMap A K) r' ∧ r' ∣ p.coeff 0

full_name: UniqueFactorizationMonoid.integer_of_integral
code: theorem integer_of_integral {x : K} : IsIntegral A x → IsInteger A x 
goal: IsIntegral A x → IsLocalization.IsInteger A x

full_name: UniqueFactorizationMonoid.instIsIntegrallyClosed
code: instance (priority := 100) instIsIntegrallyClosed : IsIntegrallyClosed A 
goal: IsIntegrallyClosed A
File: Mathlib/RingTheory/Polynomial/Wronskian.lean

full_name: Polynomial.wronskian
code: /-- Wronskian of a pair of polynomials, `W(a, b) = ab' - a'b`. -/
def wronskian (a b : R[X]) : R[X] 
goal: R[X]

full_name: Polynomial.wronskianBilin
code: /-- `Polynomial.wronskian` as a bilinear map. -/
def wronskianBilin : R[X] →ₗ[R] R[X] →ₗ[R] R[X] 
goal: R[X] →ₗ[R] R[X] →ₗ[R] R[X]

full_name: Polynomial.wronskianBilin_apply
code: @[simp]
theorem wronskianBilin_apply (a b : R[X]) : wronskianBilin R a b = wronskian a b 
goal: ((Polynomial.wronskianBilin R) a) b = a.wronskian b

full_name: Polynomial.wronskian_zero_left
code: @[simp]
theorem wronskian_zero_left (a : R[X]) : wronskian 0 a = 0 
goal: Polynomial.wronskian 0 a = 0

full_name: Polynomial.wronskian_zero_right
code: @[simp]
theorem wronskian_zero_right (a : R[X]) : wronskian a 0 = 0 
goal: a.wronskian 0 = 0

full_name: Polynomial.wronskian_neg_left
code: theorem wronskian_neg_left (a b : R[X]) : wronskian (-a) b = -wronskian a b 
goal: (-a).wronskian b = -a.wronskian b

full_name: Polynomial.wronskian_neg_right
code: theorem wronskian_neg_right (a b : R[X]) : wronskian a (-b) = -wronskian a b 
goal: a.wronskian (-b) = -a.wronskian b

full_name: Polynomial.wronskian_add_right
code: theorem wronskian_add_right (a b c : R[X]) : wronskian a (b + c) = wronskian a b + wronskian a c 
goal: a.wronskian (b + c) = a.wronskian b + a.wronskian c

full_name: Polynomial.wronskian_add_left
code: theorem wronskian_add_left (a b c : R[X]) : wronskian (a + b) c = wronskian a c + wronskian b c 
goal: (a + b).wronskian c = a.wronskian c + b.wronskian c

full_name: Polynomial.wronskian_self_eq_zero
code: theorem wronskian_self_eq_zero (a : R[X]) : wronskian a a = 0 
goal: a.wronskian a = 0

full_name: Polynomial.isAlt_wronskianBilin
code: theorem isAlt_wronskianBilin : (wronskianBilin R).IsAlt 
goal: (Polynomial.wronskianBilin R).IsAlt

full_name: Polynomial.wronskian_neg_eq
code: theorem wronskian_neg_eq (a b : R[X]) : -wronskian a b = wronskian b a 
goal: -a.wronskian b = b.wronskian a

full_name: Polynomial.wronskian_eq_of_sum_zero
code: theorem wronskian_eq_of_sum_zero {a b c : R[X]} (hAdd : a + b + c = 0) :
    wronskian a b = wronskian b c 
goal: a.wronskian b = b.wronskian c

full_name: Polynomial.degree_wronskian_lt_add
code: /-- Degree of `W(a,b)` is strictly less than the sum of degrees of `a` and `b` (both nonzero). -/
theorem degree_wronskian_lt_add {a b : R[X]} (ha : a ≠ 0) (hb : b ≠ 0) :
    (wronskian a b).degree < a.degree + b.degree 
goal: (a.wronskian b).degree < a.degree + b.degree

full_name: Polynomial.natDegree_wronskian_lt_add
code: /--
`natDegree` version of the above theorem.
Note this would be false with just `(ha : a ≠ 0) (hb : b ≠ 0),
as when `a = b = 1` we have `(wronskian a b).natDegree = a.natDegree = b.natDegree = 0`.
-/
theorem natDegree_wronskian_lt_add {a b : R[X]} (hw : wronskian a b ≠ 0) :
    (wronskian a b).natDegree < a.natDegree + b.natDegree 
goal: (a.wronskian b).natDegree < a.natDegree + b.natDegree
File: Mathlib/RingTheory/AdicCompletion/Exactness.lean

full_name: _private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimageDelta
code: private noncomputable def mapPreimageDelta (x : AdicCauchySequence I N)
    {n : ℕ} {y yₙ : M} (hy : f y = x (n + 1)) (hyₙ : f yₙ = x n) :
    { d : (I ^ n • ⊤ : Submodule R M) | f d = f (yₙ - y) } 
goal: ↑{d | f ↑d = f (yₙ - y)}

full_name: _private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimage
code: private noncomputable def mapPreimage (x : AdicCauchySequence I N) :
    (n : ℕ) → f ⁻¹' {x n}
  
goal: ↑(⇑f ⁻¹' {↑x n})

full_name: AdicCompletion.map_surjective
code: /-- Adic completion preserves surjectivity -/
theorem map_surjective : Function.Surjective (map I f) 
goal: Function.Surjective ⇑(AdicCompletion.map I f)

full_name: AdicCompletion.map_injective
code: /-- Adic completion preserves injectivity of finite modules over a Noetherian ring. -/
theorem map_injective {f : M →ₗ[R] N} (hf : Function.Injective f) :
    Function.Injective (map I f) 
goal: Function.Injective ⇑(AdicCompletion.map I f)

full_name: _private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapExactAuxDelta
code: private noncomputable def mapExactAuxDelta {n : ℕ} {d : N}
    (hdmem : d ∈ (I ^ (k + n + 1) • ⊤ : Submodule R N)) {y yₙ : M}
    (hd : f y = x (k + n + 1) - d) (hyₙ : f yₙ - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N)) :
    { d : (I ^ n • ⊤ : Submodule R M)
      | f (yₙ + d) - x (k + n + 1) ∈ (I ^ (k + n + 1) • ⊤ : Submodule R N) } 
goal: ↑{d | f (yₙ + ↑d) - ↑x (k + n + 1) ∈ I ^ (k + n + 1) • ⊤}

full_name: _private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapExactAux.h1
code: private noncomputable def mapExactAux :
    (n : ℕ) → { a : M | f a - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N) }
  
goal: g (↑x (k + n)) ∈ Submodule.map g (I ^ (k + n) • ⊤)

full_name: _private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapExactAux
code: private noncomputable def mapExactAux :
    (n : ℕ) → { a : M | f a - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N) }
  
goal: ↑{a | f a - ↑x (k + n) ∈ I ^ (k + n) • ⊤}

full_name: _private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapExactAux.h2
code: private noncomputable def mapExactAux :
    (n : ℕ) → { a : M | f a - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N) }
  
goal: ∃ d y, d ∈ I ^ (k + n) • ⊤ ∧ f y = ↑x (k + n) - d

full_name: AdicCompletion.map_exact
code: /-- `AdicCompletion` over a Noetherian ring is exact on finitely generated modules. -/
theorem map_exact : Function.Exact (map I f) (map I g) 
goal: Function.Exact ⇑(AdicCompletion.map I f) ⇑(AdicCompletion.map I g)
File: Mathlib/RingTheory/Polynomial/Hermite/Gaussian.lean

full_name: Polynomial.deriv_gaussian_eq_hermite_mul_gaussian
code: /-- `hermite n` is (up to sign) the factor appearing in `deriv^[n]` of a gaussian -/
theorem deriv_gaussian_eq_hermite_mul_gaussian (n : ℕ) (x : ℝ) :
    deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x =
    (-1 : ℝ) ^ n * aeval x (hermite n) * Real.exp (-(x ^ 2 / 2)) 
goal: deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x =
  (-1) ^ n * (Polynomial.aeval x) (Polynomial.hermite n) * Real.exp (-(x ^ 2 / 2))

full_name: Polynomial.hermite_eq_deriv_gaussian
code: theorem hermite_eq_deriv_gaussian (n : ℕ) (x : ℝ) : aeval x (hermite n) =
    (-1 : ℝ) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x / Real.exp (-(x ^ 2 / 2)) 
goal: (Polynomial.aeval x) (Polynomial.hermite n) =
  (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x / Real.exp (-(x ^ 2 / 2))

full_name: Polynomial.hermite_eq_deriv_gaussian'
code: theorem hermite_eq_deriv_gaussian' (n : ℕ) (x : ℝ) : aeval x (hermite n) =
    (-1 : ℝ) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x * Real.exp (x ^ 2 / 2) 
goal: (Polynomial.aeval x) (Polynomial.hermite n) =
  (-1) ^ n * deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x * Real.exp (x ^ 2 / 2)
File: Mathlib/RingTheory/RingInvo.lean

full_name: RingInvo
code: /-- A ring involution -/
structure RingInvo [Semiring R] extends R ≃+* Rᵐᵒᵖ where
  /-- The requirement that the ring homomorphism is its own inverse -/
  involution' : ∀ x, (toFun (toFun x).unop).unop = x
goal: Type u_2

full_name: RingInvo.involution'
code: /-- A ring involution -/
structure RingInvo [Semiring R] extends R ≃+* Rᵐᵒᵖ where
  /-- The requirement that the ring homomorphism is its own inverse -/
  involution' : ∀ x, (toFun (toFun x).unop).unop = x
goal: MulOpposite.unop (self.toFun (MulOpposite.unop (self.toFun x))) = x

full_name: RingInvoClass.involution
code: /-- `RingInvoClass F R` states that `F` is a type of ring involutions.
You should extend this class when you extend `RingInvo`. -/
class RingInvoClass (F R : Type*) [Semiring R] [EquivLike F R Rᵐᵒᵖ]
  extends RingEquivClass F R Rᵐᵒᵖ : Prop where
  /-- Every ring involution must be its own inverse -/
  involution : ∀ (f : F) (x), (f (f x).unop).unop = x
goal: MulOpposite.unop (f (MulOpposite.unop (f x))) = x

full_name: RingInvoClass
code: /-- `RingInvoClass F R` states that `F` is a type of ring involutions.
You should extend this class when you extend `RingInvo`. -/
class RingInvoClass (F R : Type*) [Semiring R] [EquivLike F R Rᵐᵒᵖ]
  extends RingEquivClass F R Rᵐᵒᵖ : Prop where
  /-- Every ring involution must be its own inverse -/
  involution : ∀ (f : F) (x), (f (f x).unop).unop = x
goal: Prop

full_name: RingInvoClass.toRingInvo
code: /-- Turn an element of a type `F` satisfying `RingInvoClass F R` into an actual
`RingInvo`. This is declared as the default coercion from `F` to `RingInvo R`. -/
@[coe]
def RingInvoClass.toRingInvo {R} [Semiring R] [EquivLike F R Rᵐᵒᵖ] [RingInvoClass F R] (f : F) :
    RingInvo R 
goal: RingInvo R

full_name: RingInvo.instCoeTCOfRingInvoClass
code: /-- Any type satisfying `RingInvoClass` can be cast into `RingInvo` via
`RingInvoClass.toRingInvo`. -/
instance [RingInvoClass F R] : CoeTC F (RingInvo R) 
goal: CoeTC F (RingInvo R)

full_name: RingInvo.instEquivLikeMulOpposite
code: instance : EquivLike (RingInvo R) R Rᵐᵒᵖ 
goal: EquivLike (RingInvo R) R Rᵐᵒᵖ

full_name: RingInvo.instRingInvoClass
code: instance : RingInvoClass (RingInvo R) R 
goal: RingInvoClass (RingInvo R) R

full_name: RingInvo.mk'
code: /-- Construct a ring involution from a ring homomorphism. -/
def mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) : RingInvo R 
goal: RingInvo R

full_name: RingInvo.involution
code: @[simp]
theorem involution (f : RingInvo R) (x : R) : (f (f x).unop).unop = x 
goal: MulOpposite.unop (f (MulOpposite.unop (f x))) = x

full_name: RingInvo.coe_ringEquiv
code: @[norm_cast]
theorem coe_ringEquiv (f : RingInvo R) (a : R) : (f : R ≃+* Rᵐᵒᵖ) a = f a 
goal: ↑f a = f a

full_name: RingInvo.map_eq_zero_iff
code: theorem map_eq_zero_iff (f : RingInvo R) {x : R} : f x = 0 ↔ x = 0 
goal: f x = 0 ↔ x = 0

full_name: RingInvo.id
code: /-- The identity function of a `CommRing` is a ring involution. -/
protected def RingInvo.id : RingInvo R 
goal: RingInvo R

full_name: instInhabitedRingInvo
code: instance : Inhabited (RingInvo R) 
goal: Inhabited (RingInvo R)
File: Mathlib/RingTheory/RingHom/Integral.lean

full_name: RingHom.isIntegral_stableUnderComposition
code: theorem isIntegral_stableUnderComposition : StableUnderComposition fun f => f.IsIntegral 
goal: RingHom.StableUnderComposition fun {R S} [CommRing R] [CommRing S] f => f.IsIntegral

full_name: RingHom.isIntegral_respectsIso
code: theorem isIntegral_respectsIso : RespectsIso fun f => f.IsIntegral 
goal: RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] f => f.IsIntegral

full_name: RingHom.isIntegral_stableUnderBaseChange
code: theorem isIntegral_stableUnderBaseChange : StableUnderBaseChange fun f => f.IsIntegral 
goal: RingHom.StableUnderBaseChange fun {R S} [CommRing R] [CommRing S] f => f.IsIntegral
File: Mathlib/RingTheory/RingHom/Finite.lean

full_name: RingHom.finite_stableUnderComposition
code: theorem finite_stableUnderComposition : StableUnderComposition @Finite 
goal: RingHom.StableUnderComposition @RingHom.Finite

full_name: RingHom.finite_respectsIso
code: theorem finite_respectsIso : RespectsIso @Finite 
goal: RingHom.RespectsIso @RingHom.Finite

full_name: RingHom.finite_stableUnderBaseChange
code: theorem finite_stableUnderBaseChange : StableUnderBaseChange @Finite 
goal: RingHom.StableUnderBaseChange @RingHom.Finite
File: Mathlib/RingTheory/RingHom/Surjective.lean

full_name: RingHom._aux_Mathlib_RingTheory_RingHom_Surjective___macroRules_RingHom_termSurjective_1
code: local notation "surjective" => fun {X Y : Type _} [CommRing X] [CommRing Y] => fun f : X →+* Y =>
  Function.Surjective f
goal: Lean.Macro

full_name: RingHom.surjective_stableUnderComposition
code: theorem surjective_stableUnderComposition : StableUnderComposition surjective 
goal: RingHom.StableUnderComposition fun {X Y} [CommRing X] [CommRing Y] f => Function.Surjective ⇑f

full_name: RingHom.surjective_respectsIso
code: theorem surjective_respectsIso : RespectsIso surjective 
goal: RingHom.RespectsIso fun {X Y} [CommRing X] [CommRing Y] f => Function.Surjective ⇑f

full_name: RingHom.surjective_stableUnderBaseChange
code: theorem surjective_stableUnderBaseChange : StableUnderBaseChange surjective 
goal: RingHom.StableUnderBaseChange fun {X Y} [CommRing X] [CommRing Y] f => Function.Surjective ⇑f

full_name: RingHom.surjective_ofLocalizationSpan
code: theorem surjective_ofLocalizationSpan : OfLocalizationSpan surjective 
goal: RingHom.OfLocalizationSpan fun {X Y} [CommRing X] [CommRing Y] f => Function.Surjective ⇑f
File: Mathlib/RingTheory/RingHom/FiniteType.lean

full_name: RingHom.finiteType_stableUnderComposition
code: theorem finiteType_stableUnderComposition : StableUnderComposition @FiniteType 
goal: RingHom.StableUnderComposition @RingHom.FiniteType

full_name: RingHom.finiteType_holdsForLocalizationAway
code: theorem finiteType_holdsForLocalizationAway : HoldsForLocalizationAway @FiniteType 
goal: RingHom.HoldsForLocalizationAway @RingHom.FiniteType

full_name: RingHom.finiteType_ofLocalizationSpanTarget
code: theorem finiteType_ofLocalizationSpanTarget : OfLocalizationSpanTarget @FiniteType 
goal: RingHom.OfLocalizationSpanTarget @RingHom.FiniteType

full_name: RingHom.finiteType_is_local
code: theorem finiteType_is_local : PropertyIsLocal @FiniteType 
goal: RingHom.PropertyIsLocal @RingHom.FiniteType

full_name: RingHom.finiteType_respectsIso
code: theorem finiteType_respectsIso : RingHom.RespectsIso @RingHom.FiniteType 
goal: RingHom.RespectsIso @RingHom.FiniteType

full_name: RingHom.finiteType_stableUnderBaseChange
code: theorem finiteType_stableUnderBaseChange : StableUnderBaseChange @FiniteType 
goal: RingHom.StableUnderBaseChange @RingHom.FiniteType
File: Mathlib/RingTheory/Valuation/ExtendToLocalization.lean

full_name: Valuation.extendToLocalization
code: /-- We can extend a valuation `v` on a ring to a localization at a submonoid of
the complement of `v.supp`. -/
noncomputable def Valuation.extendToLocalization : Valuation B Γ 
goal: Valuation B Γ

full_name: Valuation.extendToLocalization_apply_map_apply
code: @[simp]
theorem Valuation.extendToLocalization_apply_map_apply (a : A) :
    v.extendToLocalization hS B (algebraMap A B a) = v a 
goal: (v.extendToLocalization hS B) ((algebraMap A B) a) = v a
File: Mathlib/RingTheory/Valuation/RankOne.lean

full_name: Valuation.RankOne.nontrivial'
code: /-- A valuation has rank one if it is nontrivial and its image is contained in `ℝ≥0`.
  Note that this class includes the data of an inclusion morphism `Γ₀ → ℝ≥0`. -/
class RankOne (v : Valuation R Γ₀) where
  /-- The inclusion morphism from `Γ₀` to `ℝ≥0`. -/
  hom : Γ₀ →*₀ ℝ≥0
  strictMono' : StrictMono hom
  nontrivial' : ∃ r : R, v r ≠ 0 ∧ v r ≠ 1
goal: ∃ r, v r ≠ 0 ∧ v r ≠ 1

full_name: Valuation.RankOne
code: /-- A valuation has rank one if it is nontrivial and its image is contained in `ℝ≥0`.
  Note that this class includes the data of an inclusion morphism `Γ₀ → ℝ≥0`. -/
class RankOne (v : Valuation R Γ₀) where
  /-- The inclusion morphism from `Γ₀` to `ℝ≥0`. -/
  hom : Γ₀ →*₀ ℝ≥0
  strictMono' : StrictMono hom
  nontrivial' : ∃ r : R, v r ≠ 0 ∧ v r ≠ 1
goal: Type u_2

full_name: Valuation.RankOne.hom
code: /-- A valuation has rank one if it is nontrivial and its image is contained in `ℝ≥0`.
  Note that this class includes the data of an inclusion morphism `Γ₀ → ℝ≥0`. -/
class RankOne (v : Valuation R Γ₀) where
  /-- The inclusion morphism from `Γ₀` to `ℝ≥0`. -/
  hom : Γ₀ →*₀ ℝ≥0
  strictMono' : StrictMono hom
  nontrivial' : ∃ r : R, v r ≠ 0 ∧ v r ≠ 1
goal: Γ₀ →*₀ ℝ≥0

full_name: Valuation.RankOne.strictMono'
code: /-- A valuation has rank one if it is nontrivial and its image is contained in `ℝ≥0`.
  Note that this class includes the data of an inclusion morphism `Γ₀ → ℝ≥0`. -/
class RankOne (v : Valuation R Γ₀) where
  /-- The inclusion morphism from `Γ₀` to `ℝ≥0`. -/
  hom : Γ₀ →*₀ ℝ≥0
  strictMono' : StrictMono hom
  nontrivial' : ∃ r : R, v r ≠ 0 ∧ v r ≠ 1
goal: StrictMono ⇑(Valuation.RankOne.hom v)

full_name: Valuation.RankOne.strictMono
code: lemma strictMono : StrictMono (hom v) 
goal: StrictMono ⇑(Valuation.RankOne.hom v)

full_name: Valuation.RankOne.nontrivial
code: lemma nontrivial : ∃ r : R, v r ≠ 0 ∧ v r ≠ 1 
goal: ∃ r, v r ≠ 0 ∧ v r ≠ 1

full_name: Valuation.RankOne.zero_of_hom_zero
code: /-- If `v` is a rank one valuation and `x : Γ₀` has image `0` under `RankOne.hom v`, then
  `x = 0`. -/
theorem zero_of_hom_zero {x : Γ₀} (hx : hom v x = 0) : x = 0 
goal: x = 0

full_name: Valuation.RankOne.hom_eq_zero_iff
code: /-- If `v` is a rank one valuation, then`x : Γ₀` has image `0` under `RankOne.hom v` if and
  only if `x = 0`. -/
theorem hom_eq_zero_iff {x : Γ₀} : RankOne.hom v x = 0 ↔ x = 0 
goal: (Valuation.RankOne.hom v) x = 0 ↔ x = 0

full_name: Valuation.RankOne.unit
code: /-- A nontrivial unit of `Γ₀`, given that there exists a rank one `v : Valuation R Γ₀`. -/
def unit : Γ₀ˣ 
goal: Γ₀ˣ

full_name: Valuation.RankOne.unit_ne_one
code: /-- A proof that `RankOne.unit v ≠ 1`. -/
theorem unit_ne_one : unit v ≠ 1 
goal: Valuation.RankOne.unit v ≠ 1
File: Mathlib/RingTheory/Valuation/Integral.lean

full_name: Valuation.Integers.mem_of_integral
code: theorem mem_of_integral {x : R} (hx : IsIntegral O x) : x ∈ v.integer 
goal: x ∈ v.integer

full_name: Valuation.Integers.integralClosure
code: protected theorem integralClosure : integralClosure O R = ⊥ 
goal: integralClosure O R = ⊥

full_name: Valuation.Integers.integrallyClosed
code: theorem integrallyClosed : IsIntegrallyClosed O 
goal: IsIntegrallyClosed O
File: Mathlib/RingTheory/Valuation/RamificationGroup.lean

full_name: ValuationSubring.decompositionSubgroup
code: /-- The decomposition subgroup defined as the stabilizer of the action
on the type of all valuation subrings of the field. -/
abbrev decompositionSubgroup (A : ValuationSubring L) : Subgroup (L ≃ₐ[K] L) 
goal: Subgroup (L ≃ₐ[K] L)

full_name: ValuationSubring.subMulAction
code: /-- The valuation subring `A` (considered as a subset of `L`)
is stable under the action of the decomposition group. -/
def subMulAction (A : ValuationSubring L) : SubMulAction (A.decompositionSubgroup K) L 
goal: SubMulAction (↥(ValuationSubring.decompositionSubgroup K A)) L

full_name: ValuationSubring.decompositionSubgroupMulSemiringAction
code: /-- The multiplicative action of the decomposition subgroup on `A`. -/
instance decompositionSubgroupMulSemiringAction (A : ValuationSubring L) :
    MulSemiringAction (A.decompositionSubgroup K) A 
goal: MulSemiringAction ↥(ValuationSubring.decompositionSubgroup K A) ↥A

full_name: ValuationSubring.inertiaSubgroup
code: /-- The inertia subgroup defined as the kernel of the group homomorphism from
the decomposition subgroup to the group of automorphisms of the residue field of `A`. -/
def inertiaSubgroup (A : ValuationSubring L) : Subgroup (A.decompositionSubgroup K) 
goal: Subgroup ↥(ValuationSubring.decompositionSubgroup K A)
File: Mathlib/RingTheory/Valuation/PrimeMultiplicity.lean

full_name: multiplicity.addValuation
code: /-- `multiplicity` of a prime in an integral domain as an additive valuation to `PartENat`. -/
noncomputable def multiplicity.addValuation (hp : Prime p) : AddValuation R PartENat 
goal: AddValuation R PartENat

full_name: multiplicity.addValuation_apply
code: @[simp]
theorem multiplicity.addValuation_apply {hp : Prime p} {r : R} :
    addValuation hp r = multiplicity p r 
goal: (multiplicity.addValuation hp) r = multiplicity p r
File: Mathlib/RingTheory/MvPowerSeries/Trunc.lean

full_name: MvPowerSeries.truncFun
code: /-- Auxiliary definition for the truncation function. -/
def truncFun (φ : MvPowerSeries σ R) : MvPolynomial σ R 
goal: MvPolynomial σ R

full_name: MvPowerSeries.coeff_truncFun
code: theorem coeff_truncFun (m : σ →₀ ℕ) (φ : MvPowerSeries σ R) :
    (truncFun n φ).coeff m = if m < n then coeff R m φ else 0 
goal: MvPolynomial.coeff m (MvPowerSeries.truncFun n φ) = if m < n then (MvPowerSeries.coeff R m) φ else 0

full_name: MvPowerSeries.trunc
code: /-- The `n`th truncation of a multivariate formal power series to a multivariate polynomial -/
def trunc : MvPowerSeries σ R →+ MvPolynomial σ R 
goal: MvPowerSeries σ R →+ MvPolynomial σ R

full_name: MvPowerSeries.coeff_trunc
code: theorem coeff_trunc (m : σ →₀ ℕ) (φ : MvPowerSeries σ R) :
    (trunc R n φ).coeff m = if m < n then coeff R m φ else 0 
goal: MvPolynomial.coeff m ((MvPowerSeries.trunc R n) φ) = if m < n then (MvPowerSeries.coeff R m) φ else 0

full_name: MvPowerSeries.trunc_one
code: @[simp]
theorem trunc_one (n : σ →₀ ℕ) (hnn : n ≠ 0) : trunc R n 1 = 1 
goal: (MvPowerSeries.trunc R n) 1 = 1

full_name: MvPowerSeries.trunc_c
code: @[simp]
theorem trunc_c (n : σ →₀ ℕ) (hnn : n ≠ 0) (a : R) : trunc R n (C σ R a) = MvPolynomial.C a 
goal: (MvPowerSeries.trunc R n) ((MvPowerSeries.C σ R) a) = MvPolynomial.C a
File: Mathlib/RingTheory/MvPowerSeries/NoZeroDivisors.lean

full_name: MvPowerSeries.mem_nonZeroDivisors_of_constantCoeff
code: /-- A multivariate power series is not a zero divisor
  when its constant coefficient is not a zero divisor -/
theorem mem_nonZeroDivisors_of_constantCoeff {φ : MvPowerSeries σ R}
    (hφ : constantCoeff σ R φ ∈ nonZeroDivisors R) :
    φ ∈ nonZeroDivisors (MvPowerSeries σ R) 
goal: φ ∈ nonZeroDivisors (MvPowerSeries σ R)