ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/RingTheory/WittVector/Domain.lean

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_Domain___unexpand_WittVector_1
code: local notation "𝕎" => WittVector p
goal: Lean.PrettyPrinter.Unexpander

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_Domain___macroRules_WittVector_term𝕎_1
code: local notation "𝕎" => WittVector p
goal: Lean.Macro

full_name: WittVector.shift
code: /--
`WittVector.verschiebung` translates the entries of a Witt vector upward, inserting 0s in the gaps.
`WittVector.shift` does the opposite, removing the first entries.
This is mainly useful as an auxiliary construction for `WittVector.verschiebung_nonzero`.
-/
def shift (x : 𝕎 R) (n : ℕ) : 𝕎 R 
goal: WittVector p R

full_name: WittVector.shift_coeff
code: theorem shift_coeff (x : 𝕎 R) (n k : ℕ) : (x.shift n).coeff k = x.coeff (n + k) 
goal: (x.shift n).coeff k = x.coeff (n + k)

full_name: WittVector.verschiebung_shift
code: theorem verschiebung_shift (x : 𝕎 R) (k : ℕ) (h : ∀ i < k + 1, x.coeff i = 0) :
    verschiebung (x.shift k.succ) = x.shift k 
goal: WittVector.verschiebung (x.shift k.succ) = x.shift k

full_name: WittVector.eq_iterate_verschiebung
code: theorem eq_iterate_verschiebung {x : 𝕎 R} {n : ℕ} (h : ∀ i < n, x.coeff i = 0) :
    x = verschiebung^[n] (x.shift n) 
goal: x = (⇑WittVector.verschiebung)^[n] (x.shift n)

full_name: WittVector.verschiebung_nonzero
code: theorem verschiebung_nonzero {x : 𝕎 R} (hx : x ≠ 0) :
    ∃ n : ℕ, ∃ x' : 𝕎 R, x'.coeff 0 ≠ 0 ∧ x = verschiebung^[n] x' 
goal: ∃ n x', x'.coeff 0 ≠ 0 ∧ x = (⇑WittVector.verschiebung)^[n] x'

full_name: WittVector.instNoZeroDivisorsOfCharP
code: instance [CharP R p] [NoZeroDivisors R] : NoZeroDivisors (𝕎 R) 
goal: NoZeroDivisors (WittVector p R)

full_name: WittVector.instIsDomain
code: instance instIsDomain [CharP R p] [IsDomain R] : IsDomain (𝕎 R) 
goal: IsDomain (WittVector p R)
File: Mathlib/RingTheory/WittVector/MulP.lean

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_MulP___macroRules_WittVector_term𝕎_1
code: local notation "𝕎" => WittVector p
goal: Lean.Macro

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_MulP___unexpand_WittVector_1
code: local notation "𝕎" => WittVector p
goal: Lean.PrettyPrinter.Unexpander

full_name: WittVector.wittMulN
code: /-- `wittMulN p n` is the family of polynomials that computes
the coefficients of `x * n` in terms of the coefficients of the Witt vector `x`. -/
noncomputable def wittMulN : ℕ → ℕ → MvPolynomial ℕ ℤ
  
goal: ℕ → ℕ → MvPolynomial ℕ ℤ

full_name: WittVector.mulN_coeff
code: theorem mulN_coeff (n : ℕ) (x : 𝕎 R) (k : ℕ) :
    (x * n).coeff k = aeval x.coeff (wittMulN p n k) 
goal: (x * ↑n).coeff k = (MvPolynomial.aeval x.coeff) (WittVector.wittMulN p n k)

full_name: WittVector.mulN_isPoly
code: /-- Multiplication by `n` is a polynomial function. -/
@[is_poly]
theorem mulN_isPoly (n : ℕ) : IsPoly p fun R _Rcr x => x * n 
goal: WittVector.IsPoly p fun R _Rcr x => x * ↑n

full_name: WittVector.bind₁_wittMulN_wittPolynomial
code: @[simp]
theorem bind₁_wittMulN_wittPolynomial (n k : ℕ) :
    bind₁ (wittMulN p n) (wittPolynomial p ℤ k) = n * wittPolynomial p ℤ k 
goal: (MvPolynomial.bind₁ (WittVector.wittMulN p n)) (wittPolynomial p ℤ k) = ↑n * wittPolynomial p ℤ k
File: Mathlib/RingTheory/RingHom/FinitePresentation.lean

full_name: RingHom.finitePresentation_localizationPreserves
code: /-- Being finitely-presented is preserved by localizations. -/
theorem finitePresentation_localizationPreserves : LocalizationPreserves @FinitePresentation 
goal: RingHom.LocalizationPreserves @RingHom.FinitePresentation

full_name: RingHom.finitePresentation_stableUnderComposition
code: /-- Being finitely-presented is stable under composition. -/
theorem finitePresentation_stableUnderComposition : StableUnderComposition @FinitePresentation 
goal: RingHom.StableUnderComposition @RingHom.FinitePresentation

full_name: RingHom.finitePresentation_holdsForLocalizationAway
code: /-- If `R` is a ring, then `Rᵣ` is `R`-finitely-presented for any `r : R`. -/
theorem finitePresentation_holdsForLocalizationAway :
    HoldsForLocalizationAway @FinitePresentation 
goal: RingHom.HoldsForLocalizationAway @RingHom.FinitePresentation

full_name: RingHom.finitePresentation_ofLocalizationSpanTarget_aux
code: /--
If `S` is an `R`-algebra with a surjection from a finitely-presented `R`-algebra `A`, such that
localized at a spanning set `{ r }` of elements of `A`, `Sᵣ` is finitely-presented, then
`S` is finitely presented.
This is almost `finitePresentation_ofLocalizationSpanTarget`. The difference is,
that here the set `t` generates the unit ideal of `A`, while in the general version,
it only generates a quotient of `A`.
-/
lemma finitePresentation_ofLocalizationSpanTarget_aux
    {R S A : Type*} [CommRing R] [CommRing S] [CommRing A] [Algebra R S] [Algebra R A]
    [Algebra.FinitePresentation R A] (f : A →ₐ[R] S) (hf : Function.Surjective f)
    (t : Finset A) (ht : Ideal.span (t : Set A) = ⊤)
    (H : ∀ g : t, Algebra.FinitePresentation R (Localization.Away (f g))) :
    Algebra.FinitePresentation R S 
goal: Algebra.FinitePresentation R S

full_name: RingHom.finitePresentation_ofLocalizationSpanTarget
code: /-- Finite-presentation can be checked on a standard covering of the target. -/
theorem finitePresentation_ofLocalizationSpanTarget :
    OfLocalizationSpanTarget @FinitePresentation 
goal: RingHom.OfLocalizationSpanTarget @RingHom.FinitePresentation

full_name: RingHom.finitePresentation_isLocal
code: /-- Being finitely-presented is a local property of rings. -/
theorem finitePresentation_isLocal : PropertyIsLocal @FinitePresentation 
goal: RingHom.PropertyIsLocal @RingHom.FinitePresentation

full_name: RingHom.finitePresentation_respectsIso
code: /-- Being finitely-presented respects isomorphisms. -/
theorem finitePresentation_respectsIso : RingHom.RespectsIso @RingHom.FinitePresentation 
goal: RingHom.RespectsIso @RingHom.FinitePresentation

full_name: RingHom.finitePresentation_stableUnderBaseChange
code: /-- Being finitely-presented is stable under base change. -/
theorem finitePresentation_stableUnderBaseChange : StableUnderBaseChange @FinitePresentation 
goal: RingHom.StableUnderBaseChange @RingHom.FinitePresentation
File: Mathlib/RingTheory/WittVector/DiscreteValuationRing.lean

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_DiscreteValuationRing___unexpand_WittVector_1
code: local notation "𝕎" => WittVector p
goal: Lean.PrettyPrinter.Unexpander

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_DiscreteValuationRing___macroRules_WittVector_term𝕎_1
code: local notation "𝕎" => WittVector p
goal: Lean.Macro

full_name: WittVector.succNthValUnits
code: /-- This is the `n+1`st coefficient of our inverse. -/
def succNthValUnits (n : ℕ) (a : Units k) (A : 𝕎 k) (bs : Fin (n + 1) → k) : k 
goal: k

full_name: WittVector.inverseCoeff
code: /--
Recursively defines the sequence of coefficients for the inverse to a Witt vector whose first entry
is a unit.
-/
noncomputable def inverseCoeff (a : Units k) (A : 𝕎 k) : ℕ → k
  
goal: ℕ → k

full_name: WittVector.mkUnit
code: /--
Upgrade a Witt vector `A` whose first entry `A.coeff 0` is a unit to be, itself, a unit in `𝕎 k`.
-/
def mkUnit {a : Units k} {A : 𝕎 k} (hA : A.coeff 0 = a) : Units (𝕎 k) 
goal: (WittVector p k)ˣ

full_name: WittVector.coe_mkUnit
code: @[simp]
theorem coe_mkUnit {a : Units k} {A : 𝕎 k} (hA : A.coeff 0 = a) : (mkUnit hA : 𝕎 k) = A 
goal: ↑(WittVector.mkUnit hA) = A

full_name: WittVector.isUnit_of_coeff_zero_ne_zero
code: theorem isUnit_of_coeff_zero_ne_zero (x : 𝕎 k) (hx : x.coeff 0 ≠ 0) : IsUnit x 
goal: IsUnit x

full_name: WittVector.irreducible
code: theorem irreducible : Irreducible (p : 𝕎 k) 
goal: Irreducible ↑p

full_name: WittVector.exists_eq_pow_p_mul
code: theorem exists_eq_pow_p_mul (a : 𝕎 k) (ha : a ≠ 0) :
    ∃ (m : ℕ) (b : 𝕎 k), b.coeff 0 ≠ 0 ∧ a = (p : 𝕎 k) ^ m * b 
goal: ∃ m b, b.coeff 0 ≠ 0 ∧ a = ↑p ^ m * b

full_name: WittVector.exists_eq_pow_p_mul'
code: theorem exists_eq_pow_p_mul' (a : 𝕎 k) (ha : a ≠ 0) :
    ∃ (m : ℕ) (b : Units (𝕎 k)), a = (p : 𝕎 k) ^ m * b 
goal: ∃ m b, a = ↑p ^ m * ↑b

full_name: WittVector.discreteValuationRing
code: /-- The ring of Witt Vectors of a perfect field of positive characteristic is a DVR.
-/
theorem discreteValuationRing : DiscreteValuationRing (𝕎 k) 
goal: DiscreteValuationRing (WittVector p k)
File: Mathlib/RingTheory/FractionalIdeal/Norm.lean

full_name: FractionalIdeal.absNorm_div_norm_eq_absNorm_div_norm
code: theorem absNorm_div_norm_eq_absNorm_div_norm {I : FractionalIdeal R⁰ K} (a : R⁰) (I₀ : Ideal R)
    (h : a • (I : Submodule R K) = Submodule.map (Algebra.linearMap R K) I₀) :
    (Ideal.absNorm I.num : ℚ) / |Algebra.norm ℤ (I.den : R)| =
      (Ideal.absNorm I₀ : ℚ) / |Algebra.norm ℤ (a : R)| 
goal: ↑(Ideal.absNorm I.num) / ↑|(Algebra.norm ℤ) ↑I.den| = ↑(Ideal.absNorm I₀) / ↑|(Algebra.norm ℤ) ↑a|

full_name: FractionalIdeal.absNorm
code: /-- The absolute norm of the fractional ideal `I` extending by multiplicativity the absolute norm
on (integral) ideals. -/
noncomputable def absNorm : FractionalIdeal R⁰ K →*₀ ℚ 
goal: FractionalIdeal (nonZeroDivisors R) K →*₀ ℚ

full_name: FractionalIdeal.absNorm_eq
code: theorem absNorm_eq (I : FractionalIdeal R⁰ K) :
    absNorm I = (Ideal.absNorm I.num : ℚ) / |Algebra.norm ℤ (I.den : R)| 
goal: FractionalIdeal.absNorm I = ↑(Ideal.absNorm I.num) / ↑|(Algebra.norm ℤ) ↑I.den|

full_name: FractionalIdeal.absNorm_eq'
code: theorem absNorm_eq' {I : FractionalIdeal R⁰ K} (a : R⁰) (I₀ : Ideal R)
    (h : a • (I : Submodule R K) = Submodule.map (Algebra.linearMap R K) I₀) :
    absNorm I = (Ideal.absNorm I₀ : ℚ) / |Algebra.norm ℤ (a : R)| 
goal: FractionalIdeal.absNorm I = ↑(Ideal.absNorm I₀) / ↑|(Algebra.norm ℤ) ↑a|

full_name: FractionalIdeal.absNorm_nonneg
code: theorem absNorm_nonneg (I : FractionalIdeal R⁰ K) : 0 ≤ absNorm I 
goal: 0 ≤ FractionalIdeal.absNorm I

full_name: FractionalIdeal.absNorm_bot
code: theorem absNorm_bot : absNorm (⊥ : FractionalIdeal R⁰ K) = 0 
goal: FractionalIdeal.absNorm ⊥ = 0

full_name: FractionalIdeal.absNorm_one
code: theorem absNorm_one : absNorm (1 : FractionalIdeal R⁰ K) = 1 
goal: FractionalIdeal.absNorm 1 = 1

full_name: FractionalIdeal.absNorm_eq_zero_iff
code: theorem absNorm_eq_zero_iff [NoZeroDivisors K] {I : FractionalIdeal R⁰ K} :
    absNorm I = 0 ↔ I = 0 
goal: FractionalIdeal.absNorm I = 0 ↔ I = 0

full_name: FractionalIdeal.coeIdeal_absNorm
code: theorem coeIdeal_absNorm (I₀ : Ideal R) :
    absNorm (I₀ : FractionalIdeal R⁰ K) = Ideal.absNorm I₀ 
goal: FractionalIdeal.absNorm ↑I₀ = ↑(Ideal.absNorm I₀)

full_name: FractionalIdeal.abs_det_basis_change
code: theorem abs_det_basis_change [NoZeroDivisors K] {ι : Type*} [Fintype ι]
    [DecidableEq ι] (b : Basis ι ℤ R) (I : FractionalIdeal R⁰ K) (bI : Basis ι ℤ I) :
    |(b.localizationLocalization ℚ ℤ⁰ K).det ((↑) ∘ bI)| = absNorm I 
goal: |(Basis.localizationLocalization ℚ (nonZeroDivisors ℤ) K b).det (Subtype.val ∘ ⇑bI)| = FractionalIdeal.absNorm I

full_name: FractionalIdeal.absNorm_span_singleton
code: @[simp]
theorem absNorm_span_singleton [Module.Finite ℚ K] (x : K) :
    absNorm (spanSingleton R⁰ x) = |(Algebra.norm ℚ x)| 
goal: FractionalIdeal.absNorm (FractionalIdeal.spanSingleton (nonZeroDivisors R) x) = |(Algebra.norm ℚ) x|
File: Mathlib/RingTheory/GradedAlgebra/Noetherian.lean

full_name: GradedRing.GradeZero.isNoetherianRing
code: /-- If the internally graded ring `A` is Noetherian, then `𝒜 0` is a Noetherian ring. -/
instance GradeZero.isNoetherianRing : IsNoetherianRing (𝒜 0) 
goal: IsNoetherianRing ↥(𝒜 0)
File: Mathlib/RingTheory/FreeRing.lean

full_name: FreeRing
code: /-- The free ring over a type `α`. -/
def FreeRing (α : Type u) : Type u 
goal: Type u

full_name: instRingFreeRing
code: instance (α : Type u) : Ring (FreeRing α) 
goal: Ring (FreeRing α)

full_name: instInhabitedFreeRing
code: instance (α : Type u) : Inhabited (FreeRing α) 
goal: Inhabited (FreeRing α)

full_name: FreeRing.of
code: /-- The canonical map from α to `FreeRing α`. -/
def of (x : α) : FreeRing α 
goal: FreeRing α

full_name: FreeRing.of_injective
code: theorem of_injective : Function.Injective (of : α → FreeRing α) 
goal: Function.Injective FreeRing.of

full_name: FreeRing.induction_on
code: @[elab_as_elim, induction_eliminator]
protected theorem induction_on {C : FreeRing α → Prop} (z : FreeRing α) (hn1 : C (-1))
    (hb : ∀ b, C (of b)) (ha : ∀ x y, C x → C y → C (x + y)) (hm : ∀ x y, C x → C y → C (x * y)) :
    C z 
goal: C z

full_name: FreeRing.lift
code: /-- The ring homomorphism `FreeRing α →+* R` induced from a map `α → R`. -/
def lift : (α → R) ≃ (FreeRing α →+* R) 
goal: (α → R) ≃ (FreeRing α →+* R)

full_name: FreeRing.lift_of
code: @[simp]
theorem lift_of (x : α) : lift f (of x) = f x 
goal: (FreeRing.lift f) (FreeRing.of x) = f x

full_name: FreeRing.lift_comp_of
code: @[simp]
theorem lift_comp_of (f : FreeRing α →+* R) : lift (f ∘ of) = f 
goal: FreeRing.lift (⇑f ∘ FreeRing.of) = f

full_name: FreeRing.hom_ext
code: @[ext]
theorem hom_ext ⦃f g : FreeRing α →+* R⦄ (h : ∀ x, f (of x) = g (of x)) : f = g 
goal: f = g

full_name: FreeRing.map
code: /-- The canonical ring homomorphism `FreeRing α →+* FreeRing β` generated by a map `α → β`. -/
def map : FreeRing α →+* FreeRing β 
goal: FreeRing α →+* FreeRing β

full_name: FreeRing.map_of
code: @[simp]
theorem map_of (x : α) : map f (of x) = of (f x) 
goal: (FreeRing.map f) (FreeRing.of x) = FreeRing.of (f x)
File: Mathlib/RingTheory/QuotientNoetherian.lean

full_name: Ideal.Quotient.isNoetherianRing
code: instance Ideal.Quotient.isNoetherianRing {R : Type*} [CommRing R] [IsNoetherianRing R]
    (I : Ideal R) : IsNoetherianRing (R ⧸ I) 
goal: IsNoetherianRing (R ⧸ I)
File: Mathlib/RingTheory/NormTrace.lean

full_name: Algebra.norm_one_add_smul
code: lemma Algebra.norm_one_add_smul {A B} [CommRing A] [CommRing B] [Algebra A B]
    [Module.Free A B] [Module.Finite A B] (a : A) (x : B) :
    ∃ r : A, Algebra.norm A (1 + a • x) = 1 + Algebra.trace A B x * a + r * a ^ 2 
goal: ∃ r, (Algebra.norm A) (1 + a • x) = 1 + (Algebra.trace A B) x * a + r * a ^ 2
File: Mathlib/RingTheory/Localization/Away/AdjoinRoot.lean

full_name: Localization.awayEquivAdjoin
code: /-- The `R`-`AlgEquiv` between the localization of `R` away from `r` and
    `R` with an inverse of `r` adjoined. -/
noncomputable def Localization.awayEquivAdjoin (r : R) : Away r ≃ₐ[R] AdjoinRoot (C r * X - 1) 
goal: Localization.Away r ≃ₐ[R] AdjoinRoot (Polynomial.C r * Polynomial.X - 1)

full_name: IsLocalization.adjoin_inv
code: theorem IsLocalization.adjoin_inv (r : R) : IsLocalization.Away r (AdjoinRoot <| C r * X - 1) 
goal: IsLocalization.Away r (AdjoinRoot (Polynomial.C r * Polynomial.X - 1))

full_name: IsLocalization.Away.finitePresentation
code: theorem IsLocalization.Away.finitePresentation (r : R) {S} [CommRing S] [Algebra R S]
    [IsLocalization.Away r S] : Algebra.FinitePresentation R S 
goal: Algebra.FinitePresentation R S
File: Mathlib/RingTheory/GradedAlgebra/Radical.lean

full_name: Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem
code: theorem Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem {I : Ideal A} (hI : I.IsHomogeneous 𝒜)
    (I_ne_top : I ≠ ⊤)
    (homogeneous_mem_or_mem :
      ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I) :
    Ideal.IsPrime I 
goal: I.IsPrime

full_name: Ideal.IsHomogeneous.isPrime_iff
code: theorem Ideal.IsHomogeneous.isPrime_iff {I : Ideal A} (h : I.IsHomogeneous 𝒜) :
    I.IsPrime ↔
      I ≠ ⊤ ∧
        ∀ {x y : A},
          SetLike.Homogeneous 𝒜 x → SetLike.Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I 
goal: I.IsPrime ↔ I ≠ ⊤ ∧ ∀ {x y : A}, SetLike.Homogeneous 𝒜 x → SetLike.Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I

full_name: Ideal.IsPrime.homogeneousCore
code: theorem Ideal.IsPrime.homogeneousCore {I : Ideal A} (h : I.IsPrime) :
    (I.homogeneousCore 𝒜).toIdeal.IsPrime 
goal: (Ideal.homogeneousCore 𝒜 I).toIdeal.IsPrime

full_name: Ideal.IsHomogeneous.radical_eq
code: theorem Ideal.IsHomogeneous.radical_eq {I : Ideal A} (hI : I.IsHomogeneous 𝒜) :
    I.radical = InfSet.sInf { J | Ideal.IsHomogeneous 𝒜 J ∧ I ≤ J ∧ J.IsPrime } 
goal: I.radical = sInf {J | Ideal.IsHomogeneous 𝒜 J ∧ I ≤ J ∧ J.IsPrime}

full_name: Ideal.IsHomogeneous.radical
code: theorem Ideal.IsHomogeneous.radical {I : Ideal A} (h : I.IsHomogeneous 𝒜) :
    I.radical.IsHomogeneous 𝒜 
goal: Ideal.IsHomogeneous 𝒜 I.radical

full_name: HomogeneousIdeal.radical
code: /-- The radical of a homogenous ideal, as another homogenous ideal. -/
def HomogeneousIdeal.radical (I : HomogeneousIdeal 𝒜) : HomogeneousIdeal 𝒜 
goal: HomogeneousIdeal 𝒜

full_name: HomogeneousIdeal.coe_radical
code: @[simp]
theorem HomogeneousIdeal.coe_radical (I : HomogeneousIdeal 𝒜) :
    I.radical.toIdeal = I.toIdeal.radical 
goal: I.radical.toIdeal = I.toIdeal.radical
File: Mathlib/RingTheory/Localization/NormTrace.lean

full_name: Algebra.map_leftMulMatrix_localization
code: theorem Algebra.map_leftMulMatrix_localization {ι : Type*} [Fintype ι] [DecidableEq ι]
    (b : Basis ι R S) (a : S) :
    (algebraMap R Rₘ).mapMatrix (leftMulMatrix b a) =
    leftMulMatrix (b.localizationLocalization Rₘ M Sₘ) (algebraMap S Sₘ a) 
goal: (algebraMap R Rₘ).mapMatrix ((Algebra.leftMulMatrix b) a) =
  (Algebra.leftMulMatrix (Basis.localizationLocalization Rₘ M Sₘ b)) ((algebraMap S Sₘ) a)

full_name: Algebra.norm_localization
code: /-- Let `S` be an extension of `R` and `Rₘ Sₘ` be localizations at `M` of `R S` respectively.
Then the norm of `a : Sₘ` over `Rₘ` is the norm of `a : S` over `R` if `S` is free as `R`-module.
-/
theorem Algebra.norm_localization [Module.Free R S] [Module.Finite R S] (a : S) :
    Algebra.norm Rₘ (algebraMap S Sₘ a) = algebraMap R Rₘ (Algebra.norm R a) 
goal: (Algebra.norm Rₘ) ((algebraMap S Sₘ) a) = (algebraMap R Rₘ) ((Algebra.norm R) a)

full_name: Algebra.norm_eq_iff
code: /-- The norm of `a : S` in `R` can be computed in `Sₘ`. -/
lemma Algebra.norm_eq_iff [Module.Free R S] [Module.Finite R S] {a : S} {b : R}
    (hM : M ≤ nonZeroDivisors R) : Algebra.norm R a = b ↔
      (Algebra.norm Rₘ) ((algebraMap S Sₘ) a) = algebraMap R Rₘ b 
goal: (Algebra.norm R) a = b ↔ (Algebra.norm Rₘ) ((algebraMap S Sₘ) a) = (algebraMap R Rₘ) b

full_name: Algebra.trace_localization
code: /-- Let `S` be an extension of `R` and `Rₘ Sₘ` be localizations at `M` of `R S` respectively.
Then the trace of `a : Sₘ` over `Rₘ` is the trace of `a : S` over `R` if `S` is free as `R`-module.
-/
theorem Algebra.trace_localization [Module.Free R S] [Module.Finite R S] (a : S) :
    Algebra.trace Rₘ Sₘ (algebraMap S Sₘ a) = algebraMap R Rₘ (Algebra.trace R S a) 
goal: (Algebra.trace Rₘ Sₘ) ((algebraMap S Sₘ) a) = (algebraMap R Rₘ) ((Algebra.trace R S) a)

full_name: Algebra.traceMatrix_localizationLocalization
code: theorem Algebra.traceMatrix_localizationLocalization (b : Basis ι R S) :
    Algebra.traceMatrix Rₘ (b.localizationLocalization Rₘ M Sₘ) =
      (algebraMap R Rₘ).mapMatrix (Algebra.traceMatrix R b) 
goal: Algebra.traceMatrix Rₘ ⇑(Basis.localizationLocalization Rₘ M Sₘ b) =
  (algebraMap R Rₘ).mapMatrix (Algebra.traceMatrix R ⇑b)

full_name: Algebra.discr_localizationLocalization
code: /-- Let `S` be an extension of `R` and `Rₘ Sₘ` be localizations at `M` of `R S` respectively. Let
`b` be a `R`-basis of `S`. Then discriminant of the `Rₘ`-basis of `Sₘ` induced by `b` is the
discriminant of `b`.
-/
theorem Algebra.discr_localizationLocalization (b : Basis ι R S) :
    Algebra.discr Rₘ (b.localizationLocalization Rₘ M Sₘ) =
    algebraMap R Rₘ (Algebra.discr R b) 
goal: Algebra.discr Rₘ ⇑(Basis.localizationLocalization Rₘ M Sₘ b) = (algebraMap R Rₘ) (Algebra.discr R ⇑b)
File: Mathlib/RingTheory/Localization/InvSubmonoid.lean

full_name: IsLocalization.invSubmonoid
code: /-- The submonoid of `S = M⁻¹R` consisting of `{ 1 / x | x ∈ M }`. -/
def invSubmonoid : Submonoid S 
goal: Submonoid S

full_name: IsLocalization.submonoid_map_le_is_unit
code: theorem submonoid_map_le_is_unit : M.map (algebraMap R S) ≤ IsUnit.submonoid S 
goal: Submonoid.map (algebraMap R S) M ≤ IsUnit.submonoid S

full_name: IsLocalization.equivInvSubmonoid
code: /-- There is an equivalence of monoids between the image of `M` and `invSubmonoid`. -/
noncomputable abbrev equivInvSubmonoid : M.map (algebraMap R S) ≃* invSubmonoid M S 
goal: ↥(Submonoid.map (algebraMap R S) M) ≃* ↥(IsLocalization.invSubmonoid M S)

full_name: IsLocalization.toInvSubmonoid
code: /-- There is a canonical map from `M` to `invSubmonoid` sending `x` to `1 / x`. -/
noncomputable def toInvSubmonoid : M →* invSubmonoid M S 
goal: ↥M →* ↥(IsLocalization.invSubmonoid M S)

full_name: IsLocalization.toInvSubmonoid_surjective
code: theorem toInvSubmonoid_surjective : Function.Surjective (toInvSubmonoid M S) 
goal: Function.Surjective ⇑(IsLocalization.toInvSubmonoid M S)

full_name: IsLocalization.toInvSubmonoid_mul
code: @[simp]
theorem toInvSubmonoid_mul (m : M) : (toInvSubmonoid M S m : S) * algebraMap R S m = 1 
goal: ↑((IsLocalization.toInvSubmonoid M S) m) * (algebraMap R S) ↑m = 1

full_name: IsLocalization.mul_toInvSubmonoid
code: @[simp]
theorem mul_toInvSubmonoid (m : M) : algebraMap R S m * (toInvSubmonoid M S m : S) = 1 
goal: (algebraMap R S) ↑m * ↑((IsLocalization.toInvSubmonoid M S) m) = 1

full_name: IsLocalization.smul_toInvSubmonoid
code: @[simp]
theorem smul_toInvSubmonoid (m : M) : m • (toInvSubmonoid M S m : S) = 1 
goal: m • ↑((IsLocalization.toInvSubmonoid M S) m) = 1

full_name: IsLocalization.surj''
code: theorem surj'' (z : S) : ∃ (r : R) (m : M), z = r • (toInvSubmonoid M S m : S) 
goal: ∃ r m, z = r • ↑((IsLocalization.toInvSubmonoid M S) m)

full_name: IsLocalization.toInvSubmonoid_eq_mk'
code: theorem toInvSubmonoid_eq_mk' (x : M) : (toInvSubmonoid M S x : S) = mk' S 1 x 
goal: ↑((IsLocalization.toInvSubmonoid M S) x) = IsLocalization.mk' S 1 x

full_name: IsLocalization.mem_invSubmonoid_iff_exists_mk'
code: theorem mem_invSubmonoid_iff_exists_mk' (x : S) :
    x ∈ invSubmonoid M S ↔ ∃ m : M, mk' S 1 m = x 
goal: x ∈ IsLocalization.invSubmonoid M S ↔ ∃ m, IsLocalization.mk' S 1 m = x

full_name: IsLocalization.span_invSubmonoid
code: theorem span_invSubmonoid : Submodule.span R (invSubmonoid M S : Set S) = ⊤ 
goal: Submodule.span R ↑(IsLocalization.invSubmonoid M S) = ⊤

full_name: IsLocalization.finiteType_of_monoid_fg
code: theorem finiteType_of_monoid_fg [Monoid.FG M] : Algebra.FiniteType R S 
goal: Algebra.FiniteType R S
File: Mathlib/RingTheory/FiniteStability.lean

full_name: Algebra.FiniteType.baseChangeAux_surj
code: theorem baseChangeAux_surj {σ : Type*} {f : MvPolynomial σ R →ₐ[R] A} (hf : Function.Surjective f) :
    Function.Surjective (Algebra.TensorProduct.map (AlgHom.id B B) f) 
goal: Function.Surjective ⇑(Algebra.TensorProduct.map (AlgHom.id B B) f)

full_name: Algebra.FiniteType.baseChange
code: instance baseChange [hfa : FiniteType R A] : Algebra.FiniteType B (B ⊗[R] A) 
goal: Algebra.FiniteType B (B ⊗[R] A)

full_name: Algebra.FinitePresentation.baseChange
code: instance baseChange [FinitePresentation R A] : FinitePresentation B (B ⊗[R] A) 
goal: Algebra.FinitePresentation B (B ⊗[R] A)
File: Mathlib/RingTheory/Localization/Cardinality.lean

full_name: IsLocalization.card_le
code: /-- A localization always has cardinality less than or equal to the base ring. -/
theorem card_le : #L ≤ #R 
goal: #L ≤ #R

full_name: IsLocalization.card
code: /-- If you do not localize at any zero-divisors, localization preserves cardinality. -/
theorem card (hS : S ≤ R⁰) : #R = #L 
goal: #R = #L