File: Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean

full_name: minpoly.isIntegrallyClosed_eq_field_fractions
code: /-- For integrally closed domains, the minimal polynomial over the ring is the same as the minimal
polynomial over the fraction field. See `minpoly.isIntegrallyClosed_eq_field_fractions'` if
`S` is already a `K`-algebra. -/
theorem isIntegrallyClosed_eq_field_fractions [IsDomain S] {s : S} (hs : IsIntegral R s) :
    minpoly K (algebraMap S L s) = (minpoly R s).map (algebraMap R K) 
goal: minpoly K ((algebraMap S L) s) = Polynomial.map (algebraMap R K) (minpoly R s)

full_name: minpoly.isIntegrallyClosed_eq_field_fractions'
code: /-- For integrally closed domains, the minimal polynomial over the ring is the same as the minimal
polynomial over the fraction field. Compared to `minpoly.isIntegrallyClosed_eq_field_fractions`,
this version is useful if the element is in a ring that is already a `K`-algebra. -/
theorem isIntegrallyClosed_eq_field_fractions' [IsDomain S] [Algebra K S] [IsScalarTower R K S]
    {s : S} (hs : IsIntegral R s) : minpoly K s = (minpoly R s).map (algebraMap R K) 
goal: minpoly K s = Polynomial.map (algebraMap R K) (minpoly R s)

full_name: minpoly.isIntegrallyClosed_dvd
code: /-- For integrally closed rings, the minimal polynomial divides any polynomial that has the
  integral element as root. See also `minpoly.dvd` which relaxes the assumptions on `S`
  in exchange for stronger assumptions on `R`. -/
theorem isIntegrallyClosed_dvd {s : S} (hs : IsIntegral R s) {p : R[X]}
    (hp : Polynomial.aeval s p = 0) : minpoly R s ∣ p 
goal: minpoly R s ∣ p

full_name: minpoly.isIntegrallyClosed_dvd_iff
code: theorem isIntegrallyClosed_dvd_iff {s : S} (hs : IsIntegral R s) (p : R[X]) :
    Polynomial.aeval s p = 0 ↔ minpoly R s ∣ p 
goal: (Polynomial.aeval s) p = 0 ↔ minpoly R s ∣ p

full_name: minpoly.ker_eval
code: theorem ker_eval {s : S} (hs : IsIntegral R s) :
    RingHom.ker ((Polynomial.aeval s).toRingHom : R[X] →+* S) =
    Ideal.span ({minpoly R s} : Set R[X]) 
goal: RingHom.ker (Polynomial.aeval s).toRingHom = Ideal.span {minpoly R s}

full_name: minpoly.IsIntegrallyClosed.degree_le_of_ne_zero
code: /-- If an element `x` is a root of a nonzero polynomial `p`, then the degree of `p` is at least the
degree of the minimal polynomial of `x`. See also `minpoly.degree_le_of_ne_zero` which relaxes the
assumptions on `S` in exchange for stronger assumptions on `R`. -/
theorem IsIntegrallyClosed.degree_le_of_ne_zero {s : S} (hs : IsIntegral R s) {p : R[X]}
    (hp0 : p ≠ 0) (hp : Polynomial.aeval s p = 0) : degree (minpoly R s) ≤ degree p 
goal: (minpoly R s).degree ≤ p.degree

full_name: IsIntegrallyClosed.minpoly.unique
code: /-- The minimal polynomial of an element `x` is uniquely characterized by its defining property:
if there is another monic polynomial of minimal degree that has `x` as a root, then this polynomial
is equal to the minimal polynomial of `x`. See also `minpoly.unique` which relaxes the
assumptions on `S` in exchange for stronger assumptions on `R`. -/
theorem _root_.IsIntegrallyClosed.minpoly.unique {s : S} {P : R[X]} (hmo : P.Monic)
    (hP : Polynomial.aeval s P = 0)
    (Pmin : ∀ Q : R[X], Q.Monic → Polynomial.aeval s Q = 0 → degree P ≤ degree Q) :
    P = minpoly R s 
goal: P = minpoly R s

full_name: minpoly.prime_of_isIntegrallyClosed
code: theorem prime_of_isIntegrallyClosed {x : S} (hx : IsIntegral R x) : Prime (minpoly R x) 
goal: Prime (minpoly R x)

full_name: minpoly.ToAdjoin.injective
code: theorem ToAdjoin.injective (hx : IsIntegral R x) : Function.Injective (Minpoly.toAdjoin R x) 
goal: Function.Injective ⇑(AdjoinRoot.Minpoly.toAdjoin R x)

full_name: minpoly.equivAdjoin_apply
code: /-- The algebra isomorphism `AdjoinRoot (minpoly R x) ≃ₐ[R] adjoin R x` -/
@[simps!]
def equivAdjoin (hx : IsIntegral R x) : AdjoinRoot (minpoly R x) ≃ₐ[R] adjoin R ({x} : Set S) 
goal: (minpoly.equivAdjoin hx) a =
  (QuotientAddGroup.lift (Submodule.toAddSubgroup (Ideal.span {minpoly R x}))
      ↑(Polynomial.eval₂RingHom (algebraMap R ↥(Algebra.adjoin R {x})) ⟨x, ⋯⟩) ⋯)
    a

full_name: minpoly.equivAdjoin_symm_apply
code: /-- The algebra isomorphism `AdjoinRoot (minpoly R x) ≃ₐ[R] adjoin R x` -/
@[simps!]
def equivAdjoin (hx : IsIntegral R x) : AdjoinRoot (minpoly R x) ≃ₐ[R] adjoin R ({x} : Set S) 
goal: (minpoly.equivAdjoin hx).symm b = Function.surjInv ⋯ b

full_name: minpoly.equivAdjoin
code: /-- The algebra isomorphism `AdjoinRoot (minpoly R x) ≃ₐ[R] adjoin R x` -/
@[simps!]
def equivAdjoin (hx : IsIntegral R x) : AdjoinRoot (minpoly R x) ≃ₐ[R] adjoin R ({x} : Set S) 
goal: AdjoinRoot (minpoly R x) ≃ₐ[R] ↥(Algebra.adjoin R {x})

full_name: Algebra.adjoin.powerBasis'
code: /-- The `PowerBasis` of `adjoin R {x}` given by `x`. See `Algebra.adjoin.powerBasis` for a version
over a field. -/
def _root_.Algebra.adjoin.powerBasis' (hx : IsIntegral R x) :
    PowerBasis R (Algebra.adjoin R ({x} : Set S)) 
goal: PowerBasis R ↥(Algebra.adjoin R {x})

full_name: Algebra.adjoin.powerBasis'_dim
code: @[simp]
theorem _root_.Algebra.adjoin.powerBasis'_dim (hx : IsIntegral R x) :
    (Algebra.adjoin.powerBasis' hx).dim = (minpoly R x).natDegree 
goal: (Algebra.adjoin.powerBasis' hx).dim = (minpoly R x).natDegree

full_name: Algebra.adjoin.powerBasis'_gen
code: @[simp]
theorem _root_.Algebra.adjoin.powerBasis'_gen (hx : IsIntegral R x) :
    (adjoin.powerBasis' hx).gen = ⟨x, SetLike.mem_coe.1 <| subset_adjoin <| mem_singleton x⟩ 
goal: (Algebra.adjoin.powerBasis' hx).gen = ⟨x, ⋯⟩

full_name: PowerBasis.ofGenMemAdjoin'
code: /-- The power basis given by `x` if `B.gen ∈ adjoin R {x}`. -/
noncomputable def _root_.PowerBasis.ofGenMemAdjoin' (B : PowerBasis R S) (hint : IsIntegral R x)
    (hx : B.gen ∈ adjoin R ({x} : Set S)) : PowerBasis R S 
goal: PowerBasis R S

full_name: PowerBasis.ofGenMemAdjoin'_dim
code: @[simp]
theorem _root_.PowerBasis.ofGenMemAdjoin'_dim (B : PowerBasis R S) (hint : IsIntegral R x)
    (hx : B.gen ∈ adjoin R ({x} : Set S)) :
    (B.ofGenMemAdjoin' hint hx).dim = (minpoly R x).natDegree 
goal: (B.ofGenMemAdjoin' hint hx).dim = (minpoly R x).natDegree

full_name: PowerBasis.ofGenMemAdjoin'_gen
code: @[simp]
theorem _root_.PowerBasis.ofGenMemAdjoin'_gen (B : PowerBasis R S) (hint : IsIntegral R x)
    (hx : B.gen ∈ adjoin R ({x} : Set S)) :
    (B.ofGenMemAdjoin' hint hx).gen = x 
goal: (B.ofGenMemAdjoin' hint hx).gen = x