File: Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean

full_name: IsIntegral.map_of_comp_eq
code: theorem IsIntegral.map_of_comp_eq {R S T U : Type*} [CommRing R] [Ring S]
    [CommRing T] [Ring U] [Algebra R S] [Algebra T U] (φ : R →+* T) (ψ : S →+* U)
    (h : (algebraMap T U).comp φ = ψ.comp (algebraMap R S)) {a : S} (ha : IsIntegral R a) :
    IsIntegral T (ψ a) 
goal: IsIntegral T (ψ a)

full_name: Algebra.IsIntegral.of_injective
code: theorem Algebra.IsIntegral.of_injective [Algebra.IsIntegral R B] : Algebra.IsIntegral R A 
goal: Algebra.IsIntegral R A

full_name: isIntegral_algEquiv
code: @[simp]
theorem isIntegral_algEquiv {A B : Type*} [Ring A] [Ring B] [Algebra R A] [Algebra R B]
    (f : A ≃ₐ[R] B) {x : A} : IsIntegral R (f x) ↔ IsIntegral R x 
goal: IsIntegral R (f x) ↔ IsIntegral R x

full_name: IsIntegral.tower_top
code: /-- If `R → A → B` is an algebra tower,
then if the entire tower is an integral extension so is `A → B`. -/
theorem IsIntegral.tower_top [Algebra A B] [IsScalarTower R A B] {x : B}
    (hx : IsIntegral R x) : IsIntegral A x 
goal: IsIntegral A x

full_name: map_isIntegral_int
code: theorem map_isIntegral_int {B C F : Type*} [Ring B] [Ring C] {b : B}
    [FunLike F B C] [RingHomClass F B C] (f : F)
    (hb : IsIntegral ℤ b) : IsIntegral ℤ (f b) 
goal: IsIntegral ℤ (f b)

full_name: IsIntegral.of_subring
code: theorem IsIntegral.of_subring {x : B} (T : Subring R) (hx : IsIntegral T x) : IsIntegral R x 
goal: IsIntegral R x

full_name: IsIntegral.algebraMap
code: protected theorem IsIntegral.algebraMap [Algebra A B] [IsScalarTower R A B] {x : A}
    (h : IsIntegral R x) : IsIntegral R (algebraMap A B x) 
goal: IsIntegral R ((algebraMap A B) x)

full_name: isIntegral_algebraMap_iff
code: theorem isIntegral_algebraMap_iff [Algebra A B] [IsScalarTower R A B] {x : A}
    (hAB : Function.Injective (algebraMap A B)) :
    IsIntegral R (algebraMap A B x) ↔ IsIntegral R x 
goal: IsIntegral R ((algebraMap A B) x) ↔ IsIntegral R x

full_name: isIntegral_iff_isIntegral_closure_finite
code: theorem isIntegral_iff_isIntegral_closure_finite {r : B} :
    IsIntegral R r ↔ ∃ s : Set R, s.Finite ∧ IsIntegral (Subring.closure s) r 
goal: IsIntegral R r ↔ ∃ s, s.Finite ∧ IsIntegral (↥(Subring.closure s)) r

full_name: fg_adjoin_of_finite
code: theorem fg_adjoin_of_finite {s : Set A} (hfs : s.Finite) (his : ∀ x ∈ s, IsIntegral R x) :
    (Algebra.adjoin R s).toSubmodule.FG 
goal: (Subalgebra.toSubmodule (Algebra.adjoin R s)).FG

full_name: isNoetherian_adjoin_finset
code: theorem isNoetherian_adjoin_finset [IsNoetherianRing R] (s : Finset A)
    (hs : ∀ x ∈ s, IsIntegral R x) : IsNoetherian R (Algebra.adjoin R (s : Set A)) 
goal: IsNoetherian R ↥(Algebra.adjoin R ↑s)

full_name: isIntegral_of_noetherian
code: theorem isIntegral_of_noetherian (_ : IsNoetherian R B) (x : B) : IsIntegral R x 
goal: IsNoetherian R B → ∀ (x : B), IsIntegral R x

full_name: isIntegral_of_submodule_noetherian
code: theorem isIntegral_of_submodule_noetherian (S : Subalgebra R B)
    (H : IsNoetherian R (Subalgebra.toSubmodule S)) (x : B) (hx : x ∈ S) : IsIntegral R x 
goal: IsIntegral R x

full_name: isIntegral_of_smul_mem_submodule
code: /-- Suppose `A` is an `R`-algebra, `M` is an `A`-module such that `a • m ≠ 0` for all non-zero `a`
and `m`. If `x : A` fixes a nontrivial f.g. `R`-submodule `N` of `M`, then `x` is `R`-integral. -/
theorem isIntegral_of_smul_mem_submodule {M : Type*} [AddCommGroup M] [Module R M] [Module A M]
    [IsScalarTower R A M] [NoZeroSMulDivisors A M] (N : Submodule R M) (hN : N ≠ ⊥) (hN' : N.FG)
    (x : A) (hx : ∀ n ∈ N, x • n ∈ N) : IsIntegral R x 
goal: IsIntegral R x

full_name: RingHom.Finite.to_isIntegral
code: theorem RingHom.Finite.to_isIntegral (h : f.Finite) : f.IsIntegral 
goal: f.IsIntegral

full_name: Algebra.IsIntegral.finite
code: /-- The [Kurosh problem](https://en.wikipedia.org/wiki/Kurosh_problem) asks to show that
  this is still true when `A` is not necessarily commutative and `R` is a field, but it has
  been solved in the negative. See https://arxiv.org/pdf/1706.02383.pdf for criteria for a
  finitely generated algebraic (= integral) algebra over a field to be finite dimensional.

This could be an `instance`, but we tend to go from `Module.Finite` to `IsIntegral`/`IsAlgebraic`,
and making it an instance will cause the search to be complicated a lot.
-/
theorem Algebra.IsIntegral.finite [Algebra.IsIntegral R A] [h' : Algebra.FiniteType R A] :
    Module.Finite R A 
goal: Module.Finite R A

full_name: Algebra.finite_iff_isIntegral_and_finiteType
code: /-- finite = integral + finite type -/
theorem Algebra.finite_iff_isIntegral_and_finiteType :
    Module.Finite R A ↔ Algebra.IsIntegral R A ∧ Algebra.FiniteType R A 
goal: Module.Finite R A ↔ Algebra.IsIntegral R A ∧ Algebra.FiniteType R A

full_name: RingHom.IsIntegral.to_finite
code: theorem RingHom.IsIntegral.to_finite (h : f.IsIntegral) (h' : f.FiniteType) : f.Finite 
goal: f.Finite

full_name: RingHom.finite_iff_isIntegral_and_finiteType
code: /-- finite = integral + finite type -/
theorem RingHom.finite_iff_isIntegral_and_finiteType : f.Finite ↔ f.IsIntegral ∧ f.FiniteType 
goal: f.Finite ↔ f.IsIntegral ∧ f.FiniteType

full_name: mem_integralClosure_iff_mem_fg
code: theorem mem_integralClosure_iff_mem_fg {r : A} :
    r ∈ integralClosure R A ↔ ∃ M : Subalgebra R A, M.toSubmodule.FG ∧ r ∈ M 
goal: r ∈ integralClosure R A ↔ ∃ M, (Subalgebra.toSubmodule M).FG ∧ r ∈ M

full_name: adjoin_le_integralClosure
code: theorem adjoin_le_integralClosure {x : A} (hx : IsIntegral R x) :
    Algebra.adjoin R {x} ≤ integralClosure R A 
goal: Algebra.adjoin R {x} ≤ integralClosure R A

full_name: le_integralClosure_iff_isIntegral
code: theorem le_integralClosure_iff_isIntegral {S : Subalgebra R A} :
    S ≤ integralClosure R A ↔ Algebra.IsIntegral R S 
goal: S ≤ integralClosure R A ↔ Algebra.IsIntegral R ↥S

full_name: Algebra.isIntegral_sup
code: theorem Algebra.isIntegral_sup {S T : Subalgebra R A} :
    Algebra.IsIntegral R (S ⊔ T : Subalgebra R A) ↔
      Algebra.IsIntegral R S ∧ Algebra.IsIntegral R T 
goal: Algebra.IsIntegral R ↥(S ⊔ T) ↔ Algebra.IsIntegral R ↥S ∧ Algebra.IsIntegral R ↥T

full_name: integralClosure_map_algEquiv
code: /-- Mapping an integral closure along an `AlgEquiv` gives the integral closure. -/
theorem integralClosure_map_algEquiv [Algebra R S] (f : A ≃ₐ[R] S) :
    (integralClosure R A).map (f : A →ₐ[R] S) = integralClosure R S 
goal: Subalgebra.map (↑f) (integralClosure R A) = integralClosure R S

full_name: AlgHom.mapIntegralClosure
code: /-- An `AlgHom` between two rings restrict to an `AlgHom` between the integral closures inside
them. -/
def AlgHom.mapIntegralClosure [Algebra R S] (f : A →ₐ[R] S) :
    integralClosure R A →ₐ[R] integralClosure R S 
goal: ↥(integralClosure R A) →ₐ[R] ↥(integralClosure R S)

full_name: AlgHom.coe_mapIntegralClosure
code: @[simp]
theorem AlgHom.coe_mapIntegralClosure [Algebra R S] (f : A →ₐ[R] S)
    (x : integralClosure R A) : (f.mapIntegralClosure x : S) = f (x : A) 
goal: ↑(f.mapIntegralClosure x) = f ↑x

full_name: AlgEquiv.mapIntegralClosure
code: /-- An `AlgEquiv` between two rings restrict to an `AlgEquiv` between the integral closures inside
them. -/
def AlgEquiv.mapIntegralClosure [Algebra R S] (f : A ≃ₐ[R] S) :
    integralClosure R A ≃ₐ[R] integralClosure R S 
goal: ↥(integralClosure R A) ≃ₐ[R] ↥(integralClosure R S)

full_name: AlgEquiv.coe_mapIntegralClosure
code: @[simp]
theorem AlgEquiv.coe_mapIntegralClosure [Algebra R S] (f : A ≃ₐ[R] S)
    (x : integralClosure R A) : (f.mapIntegralClosure x : S) = f (x : A) 
goal: ↑(f.mapIntegralClosure x) = f ↑x

full_name: integralClosure.isIntegral
code: theorem integralClosure.isIntegral (x : integralClosure R A) : IsIntegral R x 
goal: IsIntegral R x

full_name: integralClosure.AlgebraIsIntegral
code: instance integralClosure.AlgebraIsIntegral : Algebra.IsIntegral R (integralClosure R A) 
goal: Algebra.IsIntegral R ↥(integralClosure R A)

full_name: IsIntegral.of_mul_unit
code: theorem IsIntegral.of_mul_unit {x y : B} {r : R} (hr : algebraMap R B r * y = 1)
    (hx : IsIntegral R (x * y)) : IsIntegral R x 
goal: IsIntegral R x

full_name: RingHom.IsIntegralElem.of_mul_unit
code: theorem RingHom.IsIntegralElem.of_mul_unit (x y : S) (r : R) (hr : f r * y = 1)
    (hx : f.IsIntegralElem (x * y)) : f.IsIntegralElem x 
goal: f.IsIntegralElem x

full_name: IsIntegral.of_mem_closure'
code: /-- Generalization of `IsIntegral.of_mem_closure` bootstrapped up from that lemma -/
theorem IsIntegral.of_mem_closure' (G : Set A) (hG : ∀ x ∈ G, IsIntegral R x) :
    ∀ x ∈ Subring.closure G, IsIntegral R x 
goal: x ∈ Subring.closure G → IsIntegral R x

full_name: IsIntegral.of_mem_closure''
code: theorem IsIntegral.of_mem_closure'' {S : Type*} [CommRing S] {f : R →+* S} (G : Set S)
    (hG : ∀ x ∈ G, f.IsIntegralElem x) : ∀ x ∈ Subring.closure G, f.IsIntegralElem x 
goal: x ∈ Subring.closure G → f.IsIntegralElem x

full_name: IsIntegral.pow
code: theorem IsIntegral.pow {x : B} (h : IsIntegral R x) (n : ℕ) : IsIntegral R (x ^ n) 
goal: IsIntegral R (x ^ n)

full_name: IsIntegral.nsmul
code: theorem IsIntegral.nsmul {x : B} (h : IsIntegral R x) (n : ℕ) : IsIntegral R (n • x) 
goal: IsIntegral R (n • x)

full_name: IsIntegral.zsmul
code: theorem IsIntegral.zsmul {x : B} (h : IsIntegral R x) (n : ℤ) : IsIntegral R (n • x) 
goal: IsIntegral R (n • x)

full_name: IsIntegral.multiset_prod
code: theorem IsIntegral.multiset_prod {s : Multiset A} (h : ∀ x ∈ s, IsIntegral R x) :
    IsIntegral R s.prod 
goal: IsIntegral R s.prod

full_name: IsIntegral.multiset_sum
code: theorem IsIntegral.multiset_sum {s : Multiset A} (h : ∀ x ∈ s, IsIntegral R x) :
    IsIntegral R s.sum 
goal: IsIntegral R s.sum

full_name: IsIntegral.prod
code: theorem IsIntegral.prod {α : Type*} {s : Finset α} (f : α → A) (h : ∀ x ∈ s, IsIntegral R (f x)) :
    IsIntegral R (∏ x ∈ s, f x) 
goal: IsIntegral R (∏ x ∈ s, f x)

full_name: IsIntegral.sum
code: theorem IsIntegral.sum {α : Type*} {s : Finset α} (f : α → A) (h : ∀ x ∈ s, IsIntegral R (f x)) :
    IsIntegral R (∑ x ∈ s, f x) 
goal: IsIntegral R (∑ x ∈ s, f x)

full_name: IsIntegral.det
code: theorem IsIntegral.det {n : Type*} [Fintype n] [DecidableEq n] {M : Matrix n n A}
    (h : ∀ i j, IsIntegral R (M i j)) : IsIntegral R M.det 
goal: IsIntegral R M.det

full_name: IsIntegral.pow_iff
code: @[simp]
theorem IsIntegral.pow_iff {x : A} {n : ℕ} (hn : 0 < n) : IsIntegral R (x ^ n) ↔ IsIntegral R x 
goal: IsIntegral R (x ^ n) ↔ IsIntegral R x

full_name: IsIntegral.tmul
code: theorem IsIntegral.tmul (x : A) {y : B} (h : IsIntegral R y) : IsIntegral A (x ⊗ₜ[R] y) 
goal: IsIntegral A (x ⊗ₜ[R] y)

full_name: normalizeScaleRoots
code: /-- The monic polynomial whose roots are `p.leadingCoeff * x` for roots `x` of `p`. -/
noncomputable def normalizeScaleRoots (p : R[X]) : R[X] 
goal: R[X]

full_name: normalizeScaleRoots_coeff_mul_leadingCoeff_pow
code: theorem normalizeScaleRoots_coeff_mul_leadingCoeff_pow (i : ℕ) (hp : 1 ≤ natDegree p) :
    (normalizeScaleRoots p).coeff i * p.leadingCoeff ^ i =
      p.coeff i * p.leadingCoeff ^ (p.natDegree - 1) 
goal: (normalizeScaleRoots p).coeff i * p.leadingCoeff ^ i = p.coeff i * p.leadingCoeff ^ (p.natDegree - 1)

full_name: leadingCoeff_smul_normalizeScaleRoots
code: theorem leadingCoeff_smul_normalizeScaleRoots (p : R[X]) :
    p.leadingCoeff • normalizeScaleRoots p = scaleRoots p p.leadingCoeff 
goal: p.leadingCoeff • normalizeScaleRoots p = p.scaleRoots p.leadingCoeff

full_name: normalizeScaleRoots_support
code: theorem normalizeScaleRoots_support : (normalizeScaleRoots p).support ≤ p.support 
goal: (normalizeScaleRoots p).support ≤ p.support

full_name: normalizeScaleRoots_degree
code: theorem normalizeScaleRoots_degree : (normalizeScaleRoots p).degree = p.degree 
goal: (normalizeScaleRoots p).degree = p.degree

full_name: normalizeScaleRoots_eval₂_leadingCoeff_mul
code: theorem normalizeScaleRoots_eval₂_leadingCoeff_mul (h : 1 ≤ p.natDegree) (f : R →+* S) (x : S) :
    (normalizeScaleRoots p).eval₂ f (f p.leadingCoeff * x) =
      f p.leadingCoeff ^ (p.natDegree - 1) * p.eval₂ f x 
goal: Polynomial.eval₂ f (f p.leadingCoeff * x) (normalizeScaleRoots p) =
  f p.leadingCoeff ^ (p.natDegree - 1) * Polynomial.eval₂ f x p

full_name: normalizeScaleRoots_monic
code: theorem normalizeScaleRoots_monic (h : p ≠ 0) : (normalizeScaleRoots p).Monic 
goal: (normalizeScaleRoots p).Monic

full_name: RingHom.isIntegralElem_leadingCoeff_mul
code: /-- Given a `p : R[X]` and a `x : S` such that `p.eval₂ f x = 0`,
`f p.leadingCoeff * x` is integral. -/
theorem RingHom.isIntegralElem_leadingCoeff_mul (h : p.eval₂ f x = 0) :
    f.IsIntegralElem (f p.leadingCoeff * x) 
goal: f.IsIntegralElem (f p.leadingCoeff * x)

full_name: isIntegral_leadingCoeff_smul
code: /-- Given a `p : R[X]` and a root `x : S`,
then `p.leadingCoeff • x : S` is integral over `R`. -/
theorem isIntegral_leadingCoeff_smul [Algebra R S] (h : aeval x p = 0) :
    IsIntegral R (p.leadingCoeff • x) 
goal: IsIntegral R (p.leadingCoeff • x)

full_name: integralClosure.isIntegralClosure
code: instance integralClosure.isIntegralClosure (R A : Type*) [CommRing R] [CommRing A] [Algebra R A] :
    IsIntegralClosure (integralClosure R A) R A 
goal: IsIntegralClosure (↥(integralClosure R A)) R A

full_name: IsIntegralClosure.algebraMap_injective
code: theorem algebraMap_injective (A R B : Type*) [CommRing R] [CommSemiring A] [CommRing B]
    [Algebra R B] [Algebra A B] [IsIntegralClosure A R B] : Function.Injective (algebraMap A B) 
goal: Function.Injective ⇑(algebraMap A B)

full_name: IsIntegralClosure.isIntegral
code: protected theorem isIntegral [Algebra R A] [IsScalarTower R A B] (x : A) : IsIntegral R x 
goal: IsIntegral R x

full_name: IsIntegralClosure.isIntegral_algebra
code: theorem isIntegral_algebra [Algebra R A] [IsScalarTower R A B] : Algebra.IsIntegral R A 
goal: Algebra.IsIntegral R A

full_name: IsIntegralClosure.noZeroSMulDivisors
code: theorem noZeroSMulDivisors [Algebra R A] [IsScalarTower R A B] [NoZeroSMulDivisors R B] :
    NoZeroSMulDivisors R A 
goal: NoZeroSMulDivisors R A

full_name: IsIntegralClosure.mk'
code: /-- If `x : B` is integral over `R`, then it is an element of the integral closure of `R` in `B`. -/
noncomputable def mk' (x : B) (hx : IsIntegral R x) : A 
goal: A

full_name: IsIntegralClosure.algebraMap_mk'
code: @[simp]
theorem algebraMap_mk' (x : B) (hx : IsIntegral R x) : algebraMap A B (mk' A x hx) = x 
goal: (algebraMap A B) (IsIntegralClosure.mk' A x hx) = x

full_name: IsIntegralClosure.mk'_one
code: @[simp]
theorem mk'_one (h : IsIntegral R (1 : B) := isIntegral_one) : mk' A 1 h = 1 
goal: IsIntegralClosure.mk' A 1 h = 1

full_name: IsIntegralClosure.mk'_zero
code: @[simp]
theorem mk'_zero (h : IsIntegral R (0 : B) := isIntegral_zero) : mk' A 0 h = 0 
goal: IsIntegralClosure.mk' A 0 h = 0

full_name: IsIntegralClosure.mk'_add
code: theorem mk'_add (x y : B) (hx : IsIntegral R x) (hy : IsIntegral R y) :
    mk' A (x + y) (hx.add hy) = mk' A x hx + mk' A y hy 
goal: IsIntegralClosure.mk' A (x + y) ⋯ = IsIntegralClosure.mk' A x hx + IsIntegralClosure.mk' A y hy

full_name: IsIntegralClosure.mk'_mul
code: theorem mk'_mul (x y : B) (hx : IsIntegral R x) (hy : IsIntegral R y) :
    mk' A (x * y) (hx.mul hy) = mk' A x hx * mk' A y hy 
goal: IsIntegralClosure.mk' A (x * y) ⋯ = IsIntegralClosure.mk' A x hx * IsIntegralClosure.mk' A y hy

full_name: IsIntegralClosure.mk'_algebraMap
code: @[simp]
theorem mk'_algebraMap [Algebra R A] [IsScalarTower R A B] (x : R)
    (h : IsIntegral R (algebraMap R B x) := isIntegral_algebraMap) :
    IsIntegralClosure.mk' A (algebraMap R B x) h = algebraMap R A x 
goal: IsIntegralClosure.mk' A ((algebraMap R B) x) h = (algebraMap R A) x

full_name: IsIntegralClosure.lift
code: /-- If `B / S / R` is a tower of ring extensions where `S` is integral over `R`,
then `S` maps (uniquely) into an integral closure `B / A / R`. -/
noncomputable def lift : S →ₐ[R] A 
goal: S →ₐ[R] A

full_name: IsIntegralClosure.algebraMap_lift
code: @[simp]
theorem algebraMap_lift (x : S) : algebraMap A B (lift R A B x) = algebraMap S B x 
goal: (algebraMap A B) ((IsIntegralClosure.lift R A B) x) = (algebraMap S B) x

full_name: IsIntegralClosure.equiv
code: /-- Integral closures are all isomorphic to each other. -/
noncomputable def equiv : A ≃ₐ[R] A' 
goal: A ≃ₐ[R] A'

full_name: IsIntegralClosure.algebraMap_equiv
code: @[simp]
theorem algebraMap_equiv (x : A) : algebraMap A' B (equiv R A B A' x) = algebraMap A B x 
goal: (algebraMap A' B) ((IsIntegralClosure.equiv R A B A') x) = (algebraMap A B) x

full_name: isIntegral_trans
code: /-- If A is an R-algebra all of whose elements are integral over R,
and x is an element of an A-algebra that is integral over A, then x is integral over R. -/
theorem isIntegral_trans [Algebra.IsIntegral R A] (x : B) (hx : IsIntegral A x) :
    IsIntegral R x 
goal: IsIntegral R x

full_name: Algebra.IsIntegral.trans
code: /-- If A is an R-algebra all of whose elements are integral over R,
and B is an A-algebra all of whose elements are integral over A,
then all elements of B are integral over R. -/
protected theorem Algebra.IsIntegral.trans
    [Algebra.IsIntegral R A] [Algebra.IsIntegral A B] : Algebra.IsIntegral R B 
goal: Algebra.IsIntegral R B

full_name: RingHom.IsIntegral.trans
code: protected theorem RingHom.IsIntegral.trans
    (hf : f.IsIntegral) (hg : g.IsIntegral) : (g.comp f).IsIntegral 
goal: (g.comp f).IsIntegral

full_name: IsIntegralClosure.tower_top
code: /-- If `R → A → B` is an algebra tower, `C` is the integral closure of `R` in `B`
and `A` is integral over `R`, then `C` is the integral closure of `A` in `B`. -/
lemma IsIntegralClosure.tower_top {B C : Type*} [CommRing C] [CommRing B]
    [Algebra R B] [Algebra A B] [Algebra C B] [IsScalarTower R A B]
    [IsIntegralClosure C R B] [Algebra.IsIntegral R A] :
    IsIntegralClosure C A B 
goal: IsIntegralClosure C A B

full_name: RingHom.isIntegral_of_surjective
code: theorem RingHom.isIntegral_of_surjective (hf : Function.Surjective f) : f.IsIntegral 
goal: f.IsIntegral

full_name: Algebra.isIntegral_of_surjective
code: theorem Algebra.isIntegral_of_surjective (h : Function.Surjective (algebraMap R A)) :
    Algebra.IsIntegral R A 
goal: Algebra.IsIntegral R A

full_name: IsIntegral.tower_bot
code: /-- If `R → A → B` is an algebra tower with `A → B` injective,
then if the entire tower is an integral extension so is `R → A` -/
theorem IsIntegral.tower_bot (H : Function.Injective (algebraMap A B)) {x : A}
    (h : IsIntegral R (algebraMap A B x)) : IsIntegral R x 
goal: IsIntegral R x

full_name: RingHom.IsIntegral.tower_bot
code: nonrec theorem RingHom.IsIntegral.tower_bot (hg : Function.Injective g)
    (hfg : (g.comp f).IsIntegral) : f.IsIntegral 
goal: f.IsIntegral

full_name: IsIntegral.tower_bot_of_field
code: theorem IsIntegral.tower_bot_of_field {R A B : Type*} [CommRing R] [Field A]
    [CommRing B] [Nontrivial B] [Algebra R A] [Algebra A B] [Algebra R B] [IsScalarTower R A B]
    {x : A} (h : IsIntegral R (algebraMap A B x)) : IsIntegral R x 
goal: IsIntegral R x

full_name: RingHom.isIntegralElem.of_comp
code: theorem RingHom.isIntegralElem.of_comp {x : T} (h : (g.comp f).IsIntegralElem x) :
    g.IsIntegralElem x 
goal: g.IsIntegralElem x

full_name: RingHom.IsIntegral.tower_top
code: theorem RingHom.IsIntegral.tower_top (h : (g.comp f).IsIntegral) : g.IsIntegral 
goal: g.IsIntegral

full_name: RingHom.IsIntegral.quotient
code: theorem RingHom.IsIntegral.quotient {I : Ideal S} (hf : f.IsIntegral) :
    (Ideal.quotientMap I f le_rfl).IsIntegral 
goal: (Ideal.quotientMap I f ⋯).IsIntegral

full_name: Algebra.IsIntegral.quotient
code: instance Algebra.IsIntegral.quotient {I : Ideal A} [Algebra.IsIntegral R A] :
    Algebra.IsIntegral (R ⧸ I.comap (algebraMap R A)) (A ⧸ I) 
goal: Algebra.IsIntegral (R ⧸ Ideal.comap (algebraMap R A) I) (A ⧸ I)

full_name: isIntegral_quotientMap_iff
code: theorem isIntegral_quotientMap_iff {I : Ideal S} :
    (Ideal.quotientMap I f le_rfl).IsIntegral ↔
      ((Ideal.Quotient.mk I).comp f : R →+* S ⧸ I).IsIntegral 
goal: (Ideal.quotientMap I f ⋯).IsIntegral ↔ ((Ideal.Quotient.mk I).comp f).IsIntegral

full_name: isField_of_isIntegral_of_isField
code: /-- If the integral extension `R → S` is injective, and `S` is a field, then `R` is also a field. -/
theorem isField_of_isIntegral_of_isField {R S : Type*} [CommRing R] [CommRing S]
    [Algebra R S] [Algebra.IsIntegral R S]
    (hRS : Function.Injective (algebraMap R S)) (hS : IsField S) : IsField R 
goal: IsField R

full_name: isField_of_isIntegral_of_isField'
code: theorem isField_of_isIntegral_of_isField' {R S : Type*} [CommRing R] [CommRing S] [IsDomain S]
    [Algebra R S] [Algebra.IsIntegral R S] (hR : IsField R) : IsField S 
goal: IsField S

full_name: Algebra.IsIntegral.isField_iff_isField
code: theorem Algebra.IsIntegral.isField_iff_isField {R S : Type*} [CommRing R]
    [CommRing S] [IsDomain S] [Algebra R S] [Algebra.IsIntegral R S]
    (hRS : Function.Injective (algebraMap R S)) : IsField R ↔ IsField S 
goal: IsField R ↔ IsField S

full_name: integralClosure_idem
code: theorem integralClosure_idem {R A : Type*} [CommRing R] [CommRing A] [Algebra R A] :
    integralClosure (integralClosure R A : Set A) A = ⊥ 
goal: integralClosure (↑↑(integralClosure R A)) A = ⊥

full_name: instIsDomainSubtypeMemSubalgebraIntegralClosure
code: instance : IsDomain (integralClosure R S) 
goal: IsDomain ↥(integralClosure R S)

full_name: roots_mem_integralClosure
code: theorem roots_mem_integralClosure {f : R[X]} (hf : f.Monic) {a : S}
    (ha : a ∈ f.aroots S) : a ∈ integralClosure R S 
goal: a ∈ integralClosure R S