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

full_name: RingHom.RespectsIso
code: /-- A property `RespectsIso` if it still holds when composed with an isomorphism -/
def RespectsIso : Prop 
goal: Prop

full_name: RingHom.RespectsIso.cancel_left_isIso
code: theorem RespectsIso.cancel_left_isIso (hP : RespectsIso @P) {R S T : CommRingCat} (f : R ⟶ S)
    (g : S ⟶ T) [IsIso f] : P (f ≫ g) ↔ P g 
goal: P (f ≫ g) ↔ P g

full_name: RingHom.RespectsIso.cancel_right_isIso
code: theorem RespectsIso.cancel_right_isIso (hP : RespectsIso @P) {R S T : CommRingCat} (f : R ⟶ S)
    (g : S ⟶ T) [IsIso g] : P (f ≫ g) ↔ P f 
goal: P (f ≫ g) ↔ P f

full_name: RingHom.RespectsIso.is_localization_away_iff
code: theorem RespectsIso.is_localization_away_iff (hP : RingHom.RespectsIso @P) {R S : Type u}
    (R' S' : Type u) [CommRing R] [CommRing S] [CommRing R'] [CommRing S'] [Algebra R R']
    [Algebra S S'] (f : R →+* S) (r : R) [IsLocalization.Away r R'] [IsLocalization.Away (f r) S'] :
    P (Localization.awayMap f r) ↔ P (IsLocalization.Away.map R' S' f r) 
goal: P (Localization.awayMap f r) ↔ P (IsLocalization.Away.map R' S' f r)

full_name: RingHom.StableUnderComposition
code: /-- A property is `StableUnderComposition` if the composition of two such morphisms
still falls in the class. -/
def StableUnderComposition : Prop 
goal: Prop

full_name: RingHom.StableUnderComposition.respectsIso
code: theorem StableUnderComposition.respectsIso (hP : RingHom.StableUnderComposition @P)
    (hP' : ∀ {R S : Type u} [CommRing R] [CommRing S] (e : R ≃+* S), P e.toRingHom) :
    RingHom.RespectsIso @P 
goal: RingHom.RespectsIso P

full_name: RingHom.StableUnderBaseChange
code: /-- A morphism property `P` is `StableUnderBaseChange` if `P(S →+* A)` implies
`P(B →+* A ⊗[S] B)`. -/
def StableUnderBaseChange : Prop 
goal: Prop

full_name: RingHom.StableUnderBaseChange.mk
code: theorem StableUnderBaseChange.mk (h₁ : RespectsIso @P)
    (h₂ :
      ∀ ⦃R S T⦄ [CommRing R] [CommRing S] [CommRing T],
        ∀ [Algebra R S] [Algebra R T],
          P (algebraMap R T) →
            P (Algebra.TensorProduct.includeLeftRingHom : S →+* TensorProduct R S T)) :
    StableUnderBaseChange @P 
goal: RingHom.StableUnderBaseChange P

full_name: RingHom.StableUnderBaseChange.pushout_inl
code: theorem StableUnderBaseChange.pushout_inl (hP : RingHom.StableUnderBaseChange @P)
    (hP' : RingHom.RespectsIso @P) {R S T : CommRingCat} (f : R ⟶ S) (g : R ⟶ T) (H : P g) :
    P (pushout.inl _ _ : S ⟶ pushout f g) 
goal: P (CategoryTheory.Limits.pushout.inl f g)

full_name: RingHom.toMorphismProperty
code: /-- The categorical `MorphismProperty` associated to a property of ring homs expressed
non-categorical terms. -/
def toMorphismProperty : MorphismProperty CommRingCat 
goal: CategoryTheory.MorphismProperty CommRingCat

full_name: RingHom.toMorphismProperty_respectsIso_iff
code: lemma toMorphismProperty_respectsIso_iff :
    RespectsIso P ↔ (toMorphismProperty P).RespectsIso 
goal: (RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P) ↔
  (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
File: Mathlib/RingTheory/Flat/Algebra.lean

full_name: Algebra.Flat.out
code: /-- An `R`-algebra `S` is flat if it is flat as `R`-module. -/
class Algebra.Flat (R : Type u) (S : Type v) [CommRing R] [CommRing S] [Algebra R S] : Prop where
  out : Module.Flat R S
goal: Module.Flat R S

full_name: Algebra.Flat
code: /-- An `R`-algebra `S` is flat if it is flat as `R`-module. -/
class Algebra.Flat (R : Type u) (S : Type v) [CommRing R] [CommRing S] [Algebra R S] : Prop where
  out : Module.Flat R S
goal: Prop

full_name: Algebra.Flat.self
code: instance self (R : Type u) [CommRing R] : Algebra.Flat R R 
goal: Algebra.Flat R R

full_name: Algebra.Flat.comp
code: /-- If `T` is a flat `S`-algebra and `S` is a flat `R`-algebra,
then `T` is a flat `R`-algebra. -/
theorem comp (T : Type w) [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T]
    [IsScalarTower R S T] [Algebra.Flat R S] [Algebra.Flat S T] : Algebra.Flat R T 
goal: Algebra.Flat R T

full_name: Algebra.Flat.baseChange
code: /-- If `S` is a flat `R`-algebra and `T` is any `R`-algebra,
then `T ⊗[R] S` is a flat `T`-algebra. -/
instance baseChange (T : Type w) [CommRing T] [Algebra R S] [Algebra R T] [Algebra.Flat R S] :
    Algebra.Flat T (T ⊗[R] S) 
goal: Algebra.Flat T (T ⊗[R] S)

full_name: Algebra.Flat.isBaseChange
code: /-- A base change of a flat algebra is flat. -/
theorem isBaseChange [Algebra R S] (R' : Type w) (S' : Type t) [CommRing R'] [CommRing S']
    [Algebra R R'] [Algebra S S'] [Algebra R' S'] [Algebra R S'] [IsScalarTower R R' S']
    [IsScalarTower R S S'] [h : IsPushout R S R' S'] [Algebra.Flat R R'] : Algebra.Flat S S' 
goal: Algebra.Flat S S'

full_name: RingHom.Flat
code: /-- A ring homomorphism `f : R →+* S` is flat if `S` is flat as an `R` algebra. -/
class RingHom.Flat {R : Type u} {S : Type v} [CommRing R] [CommRing S] (f : R →+* S) : Prop where
  out : f.toAlgebra.Flat := by infer_instance
goal: Prop

full_name: RingHom.Flat.out
code: /-- A ring homomorphism `f : R →+* S` is flat if `S` is flat as an `R` algebra. -/
class RingHom.Flat {R : Type u} {S : Type v} [CommRing R] [CommRing S] (f : R →+* S) : Prop where
  out : f.toAlgebra.Flat := by infer_instance
goal: Algebra.Flat R S

full_name: RingHom.Flat.identity
code: /-- The identity of a ring is flat. -/
instance identity (R : Type u) [CommRing R] : RingHom.Flat (1 : R →+* R) 
goal: RingHom.Flat 1

full_name: RingHom.Flat.comp
code: /-- Composition of flat ring homomorphisms is flat. -/
instance comp [RingHom.Flat f] [RingHom.Flat g] : RingHom.Flat (g.comp f) 
goal: (g.comp f).Flat
File: Mathlib/RingTheory/Flat/CategoryTheory.lean

full_name: Module.Flat.lTensor_shortComplex_exact
code: lemma lTensor_shortComplex_exact [Flat R M] (C : ShortComplex $ ModuleCat R) (hC : C.Exact) :
    C.map (tensorLeft M) |>.Exact 
goal: (C.map (CategoryTheory.MonoidalCategory.tensorLeft M)).Exact

full_name: Module.Flat.rTensor_shortComplex_exact
code: lemma rTensor_shortComplex_exact [Flat R M] (C : ShortComplex $ ModuleCat R) (hC : C.Exact) :
    C.map (tensorRight M) |>.Exact 
goal: (C.map (CategoryTheory.MonoidalCategory.tensorRight M)).Exact

full_name: Module.Flat.iff_lTensor_preserves_shortComplex_exact
code: lemma iff_lTensor_preserves_shortComplex_exact :
    Flat R M ↔
    ∀ (C : ShortComplex $ ModuleCat R) (_ : C.Exact), (C.map (tensorLeft M) |>.Exact) 
goal: Module.Flat R ↑M ↔
  ∀ (C : CategoryTheory.ShortComplex (ModuleCat R)),
    C.Exact → (C.map (CategoryTheory.MonoidalCategory.tensorLeft M)).Exact

full_name: Module.Flat.iff_rTensor_preserves_shortComplex_exact
code: lemma iff_rTensor_preserves_shortComplex_exact :
    Flat R M ↔
    ∀ (C : ShortComplex $ ModuleCat R) (_ : C.Exact), (C.map (tensorRight M) |>.Exact) 
goal: Module.Flat R ↑M ↔
  ∀ (C : CategoryTheory.ShortComplex (ModuleCat R)),
    C.Exact → (C.map (CategoryTheory.MonoidalCategory.tensorRight M)).Exact
File: Mathlib/RingTheory/ReesAlgebra.lean

full_name: reesAlgebra
code: /-- The Rees algebra of an ideal `I`, defined as the subalgebra of `R[X]` whose `i`-th coefficient
falls in `I ^ i`. -/
def reesAlgebra : Subalgebra R R[X] 
goal: Subalgebra R R[X]

full_name: mem_reesAlgebra_iff
code: theorem mem_reesAlgebra_iff (f : R[X]) : f ∈ reesAlgebra I ↔ ∀ i, f.coeff i ∈ I ^ i 
goal: f ∈ reesAlgebra I ↔ ∀ (i : ℕ), f.coeff i ∈ I ^ i

full_name: mem_reesAlgebra_iff_support
code: theorem mem_reesAlgebra_iff_support (f : R[X]) :
    f ∈ reesAlgebra I ↔ ∀ i ∈ f.support, f.coeff i ∈ I ^ i 
goal: f ∈ reesAlgebra I ↔ ∀ i ∈ f.support, f.coeff i ∈ I ^ i

full_name: reesAlgebra.monomial_mem
code: theorem reesAlgebra.monomial_mem {I : Ideal R} {i : ℕ} {r : R} :
    monomial i r ∈ reesAlgebra I ↔ r ∈ I ^ i 
goal: (Polynomial.monomial i) r ∈ reesAlgebra I ↔ r ∈ I ^ i

full_name: monomial_mem_adjoin_monomial
code: theorem monomial_mem_adjoin_monomial {I : Ideal R} {n : ℕ} {r : R} (hr : r ∈ I ^ n) :
    monomial n r ∈ Algebra.adjoin R (Submodule.map (monomial 1 : R →ₗ[R] R[X]) I : Set R[X]) 
goal: (Polynomial.monomial n) r ∈ Algebra.adjoin R ↑(Submodule.map (Polynomial.monomial 1) I)

full_name: adjoin_monomial_eq_reesAlgebra
code: theorem adjoin_monomial_eq_reesAlgebra :
    Algebra.adjoin R (Submodule.map (monomial 1 : R →ₗ[R] R[X]) I : Set R[X]) = reesAlgebra I 
goal: Algebra.adjoin R ↑(Submodule.map (Polynomial.monomial 1) I) = reesAlgebra I

full_name: reesAlgebra.fg
code: theorem reesAlgebra.fg (hI : I.FG) : (reesAlgebra I).FG 
goal: (reesAlgebra I).FG

full_name: instFiniteTypeSubtypePolynomialMemSubalgebraReesAlgebraOfIsNoetherianRing
code: instance [IsNoetherianRing R] : Algebra.FiniteType R (reesAlgebra I) 
goal: Algebra.FiniteType R ↥(reesAlgebra I)

full_name: instIsNoetherianRingSubtypePolynomialMemSubalgebraReesAlgebra
code: instance [IsNoetherianRing R] : IsNoetherianRing (reesAlgebra I) 
goal: IsNoetherianRing ↥(reesAlgebra I)
File: Mathlib/RingTheory/Nilpotent/Lemmas.lean

full_name: RingHom.ker_isRadical_iff_reduced_of_surjective
code: theorem RingHom.ker_isRadical_iff_reduced_of_surjective {S F} [CommSemiring R] [CommRing S]
    [FunLike F R S] [RingHomClass F R S] {f : F} (hf : Function.Surjective f) :
    (RingHom.ker f).IsRadical ↔ IsReduced S 
goal: (RingHom.ker f).IsRadical ↔ IsReduced S

full_name: isRadical_iff_span_singleton
code: theorem isRadical_iff_span_singleton [CommSemiring R] :
    IsRadical y ↔ (Ideal.span ({y} : Set R)).IsRadical 
goal: IsRadical y ↔ (Ideal.span {y}).IsRadical

full_name: nilradical
code: /-- The nilradical of a commutative semiring is the ideal of nilpotent elements. -/
def nilradical (R : Type*) [CommSemiring R] : Ideal R 
goal: Ideal R

full_name: mem_nilradical
code: theorem mem_nilradical : x ∈ nilradical R ↔ IsNilpotent x 
goal: x ∈ nilradical R ↔ IsNilpotent x

full_name: nilradical_eq_sInf
code: theorem nilradical_eq_sInf (R : Type*) [CommSemiring R] :
    nilradical R = sInf { J : Ideal R | J.IsPrime } 
goal: nilradical R = sInf {J | J.IsPrime}

full_name: nilpotent_iff_mem_prime
code: theorem nilpotent_iff_mem_prime : IsNilpotent x ↔ ∀ J : Ideal R, J.IsPrime → x ∈ J 
goal: IsNilpotent x ↔ ∀ (J : Ideal R), J.IsPrime → x ∈ J

full_name: nilradical_le_prime
code: theorem nilradical_le_prime (J : Ideal R) [H : J.IsPrime] : nilradical R ≤ J 
goal: nilradical R ≤ J

full_name: nilradical_eq_zero
code: @[simp]
theorem nilradical_eq_zero (R : Type*) [CommSemiring R] [IsReduced R] : nilradical R = 0 
goal: nilradical R = 0

full_name: LinearMap.isNilpotent_mulLeft_iff
code: @[simp]
theorem isNilpotent_mulLeft_iff (a : A) : IsNilpotent (mulLeft R a) ↔ IsNilpotent a 
goal: IsNilpotent (LinearMap.mulLeft R a) ↔ IsNilpotent a

full_name: LinearMap.isNilpotent_mulRight_iff
code: @[simp]
theorem isNilpotent_mulRight_iff (a : A) : IsNilpotent (mulRight R a) ↔ IsNilpotent a 
goal: IsNilpotent (LinearMap.mulRight R a) ↔ IsNilpotent a

full_name: LinearMap.isNilpotent_toMatrix_iff
code: @[simp]
lemma isNilpotent_toMatrix_iff (b : Basis ι R M) (f : M →ₗ[R] M) :
    IsNilpotent (toMatrix b b f) ↔ IsNilpotent f 
goal: IsNilpotent ((LinearMap.toMatrix b b) f) ↔ IsNilpotent f

full_name: Module.End.isNilpotent.restrict
code: lemma isNilpotent.restrict {R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
    {f : M →ₗ[R] M} {p : Submodule R M} (hf : MapsTo f p p) (hnil : IsNilpotent f) :
    IsNilpotent (f.restrict hf) 
goal: IsNilpotent (f.restrict hf)

full_name: Module.End.IsNilpotent.mapQ
code: theorem IsNilpotent.mapQ (hnp : IsNilpotent f) : IsNilpotent (p.mapQ p f hp) 
goal: IsNilpotent (p.mapQ p f hp)
File: Mathlib/RingTheory/EuclideanDomain.lean

full_name: gcd_ne_zero_of_left
code: theorem gcd_ne_zero_of_left (hp : p ≠ 0) : GCDMonoid.gcd p q ≠ 0 
goal: gcd p q ≠ 0

full_name: gcd_ne_zero_of_right
code: theorem gcd_ne_zero_of_right (hp : q ≠ 0) : GCDMonoid.gcd p q ≠ 0 
goal: gcd p q ≠ 0

full_name: left_div_gcd_ne_zero
code: theorem left_div_gcd_ne_zero {p q : R} (hp : p ≠ 0) : p / GCDMonoid.gcd p q ≠ 0 
goal: p / gcd p q ≠ 0

full_name: right_div_gcd_ne_zero
code: theorem right_div_gcd_ne_zero {p q : R} (hq : q ≠ 0) : q / GCDMonoid.gcd p q ≠ 0 
goal: q / gcd p q ≠ 0

full_name: isCoprime_div_gcd_div_gcd
code: theorem isCoprime_div_gcd_div_gcd (hq : q ≠ 0) :
    IsCoprime (p / GCDMonoid.gcd p q) (q / GCDMonoid.gcd p q) 
goal: IsCoprime (p / gcd p q) (q / gcd p q)

full_name: EuclideanDomain.gcdMonoid
code: /-- Create a `GCDMonoid` whose `GCDMonoid.gcd` matches `EuclideanDomain.gcd`. -/
-- Porting note: added `DecidableEq R`
def gcdMonoid (R) [EuclideanDomain R] [DecidableEq R] : GCDMonoid R 
goal: GCDMonoid R

full_name: EuclideanDomain.span_gcd
code: theorem span_gcd [DecidableEq α] (x y : α) :
    span ({gcd x y} : Set α) = span ({x, y} : Set α) 
goal: Ideal.span {EuclideanDomain.gcd x y} = Ideal.span {x, y}

full_name: EuclideanDomain.gcd_isUnit_iff
code: theorem gcd_isUnit_iff [DecidableEq α] {x y : α} : IsUnit (gcd x y) ↔ IsCoprime x y 
goal: IsUnit (EuclideanDomain.gcd x y) ↔ IsCoprime x y

full_name: EuclideanDomain.isCoprime_of_dvd
code: theorem isCoprime_of_dvd {x y : α} (nonzero : ¬(x = 0 ∧ y = 0))
    (H : ∀ z ∈ nonunits α, z ≠ 0 → z ∣ x → ¬z ∣ y) : IsCoprime x y 
goal: IsCoprime x y

full_name: EuclideanDomain.dvd_or_coprime
code: theorem dvd_or_coprime (x y : α) (h : Irreducible x) :
    x ∣ y ∨ IsCoprime x y 
goal: x ∣ y ∨ IsCoprime x y
File: Mathlib/RingTheory/Prime.lean

full_name: mul_eq_mul_prime_prod
code: /-- If `x * y = a * ∏ i ∈ s, p i` where `p i` is always prime, then
  `x` and `y` can both be written as a divisor of `a` multiplied by
  a product over a subset of `s`  -/
theorem mul_eq_mul_prime_prod {α : Type*} [DecidableEq α] {x y a : R} {s : Finset α} {p : α → R}
    (hp : ∀ i ∈ s, Prime (p i)) (hx : x * y = a * ∏ i ∈ s, p i) :
    ∃ (t u : Finset α) (b c : R),
      t ∪ u = s ∧ Disjoint t u ∧ a = b * c ∧ (x = b * ∏ i ∈ t, p i) ∧ y = c * ∏ i ∈ u, p i 
goal: ∃ t u b c, t ∪ u = s ∧ Disjoint t u ∧ a = b * c ∧ x = b * ∏ i ∈ t, p i ∧ y = c * ∏ i ∈ u, p i

full_name: mul_eq_mul_prime_pow
code: /-- If `x * y = a * p ^ n` where `p` is prime, then `x` and `y` can both be written
  as the product of a power of `p` and a divisor of `a`. -/
theorem mul_eq_mul_prime_pow {x y a p : R} {n : ℕ} (hp : Prime p) (hx : x * y = a * p ^ n) :
    ∃ (i j : ℕ) (b c : R), i + j = n ∧ a = b * c ∧ x = b * p ^ i ∧ y = c * p ^ j 
goal: ∃ i j b c, i + j = n ∧ a = b * c ∧ x = b * p ^ i ∧ y = c * p ^ j

full_name: Prime.neg
code: theorem Prime.neg {p : α} (hp : Prime p) : Prime (-p) 
goal: Prime (-p)

full_name: Prime.abs
code: theorem Prime.abs [LinearOrder α] {p : α} (hp : Prime p) : Prime (abs p) 
goal: Prime |p|
File: Mathlib/RingTheory/Ideal/IsPrimary.lean

full_name: Ideal.IsPrimary
code: /-- A proper ideal `I` is primary iff `xy ∈ I` implies `x ∈ I` or `y ∈ radical I`. -/
def IsPrimary (I : Ideal R) : Prop 
goal: Prop

full_name: Ideal.IsPrime.isPrimary
code: theorem IsPrime.isPrimary {I : Ideal R} (hi : IsPrime I) : IsPrimary I 
goal: I.IsPrimary

full_name: Ideal.isPrime_radical
code: theorem isPrime_radical {I : Ideal R} (hi : IsPrimary I) : IsPrime (radical I) 
goal: I.radical.IsPrime

full_name: Ideal.isPrimary_inf
code: theorem isPrimary_inf {I J : Ideal R} (hi : IsPrimary I) (hj : IsPrimary J)
    (hij : radical I = radical J) : IsPrimary (I ⊓ J) 
goal: (I ⊓ J).IsPrimary
File: Mathlib/RingTheory/Flat/Stability.lean

full_name: _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.auxRightMul
code: private noncomputable abbrev auxRightMul (I : Ideal R) : M ⊗[R] I →ₗ[S] M 
goal: M ⊗[R] ↥I →ₗ[S] M

full_name: _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.J
code: private noncomputable abbrev J (I : Ideal R) : Ideal S 
goal: Ideal S

full_name: _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.auxIso
code: private noncomputable abbrev auxIso [Module.Flat R S] {I : Ideal R} :
    S ⊗[R] I ≃ₗ[S] J R S I 
goal: S ⊗[R] ↥I ≃ₗ[S] ↥(Module.Flat.J R S I)

full_name: _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.auxLTensor
code: private noncomputable abbrev auxLTensor [Module.Flat R S] (I : Ideal R) :
    M ⊗[R] I →ₗ[S] M 
goal: M ⊗[R] ↥I →ₗ[S] M

full_name: _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.auxLTensor_eq
code: private lemma auxLTensor_eq [Module.Flat R S] {I : Ideal R} :
    (auxLTensor R S M I : M ⊗[R] I →ₗ[R] M) =
    TensorProduct.rid R M ∘ₗ lTensor M (I.subtype) 
goal: ↑R (Module.Flat.auxLTensor R S M I) = ↑(TensorProduct.rid R M) ∘ₗ LinearMap.lTensor M (Submodule.subtype I)

full_name: Module.Flat.comp
code: /-- If `S` is a flat `R`-algebra, then any flat `S`-Module is also `R`-flat. -/
theorem comp [Module.Flat R S] [Module.Flat S M] : Module.Flat R M 
goal: Module.Flat R M

full_name: _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.auxRTensorBaseChange
code: private noncomputable abbrev auxRTensorBaseChange (I : Ideal S) :
    I ⊗[S] (S ⊗[R] M) →ₗ[S] S ⊗[S] (S ⊗[R] M) 
goal: ↥I ⊗[S] S ⊗[R] M →ₗ[S] S ⊗[S] S ⊗[R] M

full_name: _private.Mathlib.RingTheory.Flat.Stability.0.Module.Flat.auxRTensorBaseChange_eq
code: private lemma auxRTensorBaseChange_eq (I : Ideal S) :
    auxRTensorBaseChange R S M I = rTensor (S ⊗[R] M) (Submodule.subtype I) 
goal: Module.Flat.auxRTensorBaseChange R S M I = LinearMap.rTensor (S ⊗[R] M) (Submodule.subtype I)

full_name: Module.Flat.baseChange
code: /-- If `M` is a flat `R`-module and `S` is any `R`-algebra, `S ⊗[R] M` is `S`-flat. -/
instance baseChange [Module.Flat R M] : Module.Flat S (S ⊗[R] M) 
goal: Module.Flat S (S ⊗[R] M)

full_name: Module.Flat.isBaseChange
code: /-- A base change of a flat module is flat. -/
theorem isBaseChange [Module.Flat R M] (N : Type t) [AddCommGroup N] [Module R N] [Module S N]
    [IsScalarTower R S N] {f : M →ₗ[R] N} (h : IsBaseChange S f) :
    Module.Flat S N 
goal: Module.Flat S N

full_name: Module.Flat.localizedModule
code: instance localizedModule [Module.Flat R M] (S : Submonoid R) : Module.Flat (Localization S)
    (LocalizedModule S M) 
goal: Module.Flat (Localization S) (LocalizedModule S M)

full_name: Module.Flat.of_isLocalizedModule
code: theorem of_isLocalizedModule [Module.Flat R M] (S : Submonoid R) [IsLocalization S Rp]
    (f : M →ₗ[R] Mp) [h : IsLocalizedModule S f] : Module.Flat Rp Mp 
goal: Module.Flat Rp Mp
File: Mathlib/RingTheory/Ideal/IdempotentFG.lean

full_name: Ideal.isIdempotentElem_iff_of_fg
code: /-- A finitely generated idempotent ideal is generated by an idempotent element -/
theorem isIdempotentElem_iff_of_fg {R : Type*} [CommRing R] (I : Ideal R) (h : I.FG) :
    IsIdempotentElem I ↔ ∃ e : R, IsIdempotentElem e ∧ I = R ∙ e 
goal: IsIdempotentElem I ↔ ∃ e, IsIdempotentElem e ∧ I = Submodule.span R {e}

full_name: Ideal.isIdempotentElem_iff_eq_bot_or_top
code: theorem isIdempotentElem_iff_eq_bot_or_top {R : Type*} [CommRing R] [IsDomain R] (I : Ideal R)
    (h : I.FG) : IsIdempotentElem I ↔ I = ⊥ ∨ I = ⊤ 
goal: IsIdempotentElem I ↔ I = ⊥ ∨ I = ⊤
File: Mathlib/RingTheory/Ideal/Basis.lean

full_name: Ideal.basisSpanSingleton
code: /-- A basis on `S` gives a basis on `Ideal.span {x}`, by multiplying everything by `x`. -/
noncomputable def basisSpanSingleton (b : Basis ι R S) {x : S} (hx : x ≠ 0) :
    Basis ι R (span ({x} : Set S)) 
goal: Basis ι R ↥(Ideal.span {x})

full_name: Ideal.basisSpanSingleton_apply
code: @[simp]
theorem basisSpanSingleton_apply (b : Basis ι R S) {x : S} (hx : x ≠ 0) (i : ι) :
    (basisSpanSingleton b hx i : S) = x * b i 
goal: ↑((Ideal.basisSpanSingleton b hx) i) = x * b i

full_name: Ideal.constr_basisSpanSingleton
code: @[simp]
theorem constr_basisSpanSingleton {N : Type*} [Semiring N] [Module N S] [SMulCommClass R N S]
    (b : Basis ι R S) {x : S} (hx : x ≠ 0) :
    (b.constr N).toFun (((↑) : _ → S) ∘ (basisSpanSingleton b hx)) = Algebra.lmul R S x 
goal: (↑(b.constr N)).toFun (Subtype.val ∘ ⇑(Ideal.basisSpanSingleton b hx)) = (Algebra.lmul R S) x

full_name: Basis.mem_ideal_iff
code: /-- If `I : Ideal S` has a basis over `R`,
`x ∈ I` iff it is a linear combination of basis vectors. -/
theorem Basis.mem_ideal_iff {ι R S : Type*} [CommRing R] [CommRing S] [Algebra R S] {I : Ideal S}
    (b : Basis ι R I) {x : S} : x ∈ I ↔ ∃ c : ι →₀ R, x = Finsupp.sum c fun i x => x • (b i : S) 
goal: x ∈ I ↔ ∃ c, x = c.sum fun i x => x • ↑(b i)

full_name: Basis.mem_ideal_iff'
code: /-- If `I : Ideal S` has a finite basis over `R`,
`x ∈ I` iff it is a linear combination of basis vectors. -/
theorem Basis.mem_ideal_iff' {ι R S : Type*} [Fintype ι] [CommRing R] [CommRing S] [Algebra R S]
    {I : Ideal S} (b : Basis ι R I) {x : S} : x ∈ I ↔ ∃ c : ι → R, x = ∑ i, c i • (b i : S) 
goal: x ∈ I ↔ ∃ c, x = ∑ i : ι, c i • ↑(b i)
File: Mathlib/RingTheory/Ideal/Colon.lean

full_name: Submodule.colon
code: /-- `N.colon P` is the ideal of all elements `r : R` such that `r • P ⊆ N`. -/
def colon (N P : Submodule R M) : Ideal R 
goal: Ideal R

full_name: Submodule.mem_colon
code: theorem mem_colon {r} : r ∈ N.colon P ↔ ∀ p ∈ P, r • p ∈ N 
goal: r ∈ N.colon P ↔ ∀ p ∈ P, r • p ∈ N

full_name: Submodule.mem_colon'
code: theorem mem_colon' {r} : r ∈ N.colon P ↔ P ≤ comap (r • (LinearMap.id : M →ₗ[R] M)) N 
goal: r ∈ N.colon P ↔ P ≤ Submodule.comap (r • LinearMap.id) N

full_name: Submodule.colon_top
code: @[simp]
theorem colon_top {I : Ideal R} : I.colon ⊤ = I 
goal: Submodule.colon I ⊤ = I

full_name: Submodule.colon_bot
code: @[simp]
theorem colon_bot : colon ⊥ N = N.annihilator 
goal: ⊥.colon N = N.annihilator

full_name: Submodule.colon_mono
code: theorem colon_mono (hn : N₁ ≤ N₂) (hp : P₁ ≤ P₂) : N₁.colon P₂ ≤ N₂.colon P₁ 
goal: N₁.colon P₂ ≤ N₂.colon P₁

full_name: Submodule.iInf_colon_iSup
code: theorem iInf_colon_iSup (ι₁ : Sort*) (f : ι₁ → Submodule R M) (ι₂ : Sort*)
    (g : ι₂ → Submodule R M) : (⨅ i, f i).colon (⨆ j, g j) = ⨅ (i) (j), (f i).colon (g j) 
goal: (⨅ i, f i).colon (⨆ j, g j) = ⨅ i, ⨅ j, (f i).colon (g j)

full_name: Submodule.mem_colon_singleton
code: @[simp]
theorem mem_colon_singleton {N : Submodule R M} {x : M} {r : R} :
    r ∈ N.colon (Submodule.span R {x}) ↔ r • x ∈ N 
goal: r ∈ N.colon (Submodule.span R {x}) ↔ r • x ∈ N

full_name: Ideal.mem_colon_singleton
code: @[simp]
theorem _root_.Ideal.mem_colon_singleton {I : Ideal R} {x r : R} :
    r ∈ I.colon (Ideal.span {x}) ↔ r * x ∈ I 
goal: r ∈ Submodule.colon I (Ideal.span {x}) ↔ r * x ∈ I

full_name: Submodule.annihilator_quotient
code: theorem annihilator_quotient {N : Submodule R M} :
    Module.annihilator R (M ⧸ N) = N.colon ⊤ 
goal: Module.annihilator R (M ⧸ N) = N.colon ⊤

full_name: Ideal.annihilator_quotient
code: theorem _root_.Ideal.annihilator_quotient {I : Ideal R} : Module.annihilator R (R ⧸ I) = I 
goal: Module.annihilator R (R ⧸ I) = I
File: Mathlib/RingTheory/IntegralClosure/IsIntegral/Defs.lean

full_name: RingHom.IsIntegralElem
code: /-- An element `x` of `A` is said to be integral over `R` with respect to `f`
if it is a root of a monic polynomial `p : R[X]` evaluated under `f` -/
def RingHom.IsIntegralElem (f : R →+* A) (x : A) 
goal: Prop

full_name: RingHom.IsIntegral
code: /-- A ring homomorphism `f : R →+* A` is said to be integral
if every element `A` is integral with respect to the map `f` -/
def RingHom.IsIntegral (f : R →+* A) 
goal: Prop

full_name: IsIntegral
code: /-- An element `x` of an algebra `A` over a commutative ring `R` is said to be *integral*,
if it is a root of some monic polynomial `p : R[X]`.
Equivalently, the element is integral over `R` with respect to the induced `algebraMap` -/
def IsIntegral (x : A) : Prop 
goal: Prop