File: Mathlib/FieldTheory/SplittingField/Construction.lean

full_name: Polynomial.factor
code: /-- Non-computably choose an irreducible factor from a polynomial. -/
def factor (f : K[X]) : K[X] 
goal: K[X]

full_name: Polynomial.irreducible_factor
code: theorem irreducible_factor (f : K[X]) : Irreducible (factor f) 
goal: Irreducible f.factor

full_name: Polynomial.fact_irreducible_factor
code: /-- See note [fact non-instances]. -/
theorem fact_irreducible_factor (f : K[X]) : Fact (Irreducible (factor f)) 
goal: Fact (Irreducible f.factor)

full_name: Polynomial.factor_dvd_of_not_isUnit
code: theorem factor_dvd_of_not_isUnit {f : K[X]} (hf1 : ¬IsUnit f) : factor f ∣ f 
goal: f.factor ∣ f

full_name: Polynomial.factor_dvd_of_degree_ne_zero
code: theorem factor_dvd_of_degree_ne_zero {f : K[X]} (hf : f.degree ≠ 0) : factor f ∣ f 
goal: f.factor ∣ f

full_name: Polynomial.factor_dvd_of_natDegree_ne_zero
code: theorem factor_dvd_of_natDegree_ne_zero {f : K[X]} (hf : f.natDegree ≠ 0) : factor f ∣ f 
goal: f.factor ∣ f

full_name: Polynomial.isCoprime_iff_aeval_ne_zero
code: lemma isCoprime_iff_aeval_ne_zero (f g : K[X]) : IsCoprime f g ↔ ∀ {A : Type v} [CommRing A]
    [IsDomain A] [Algebra K A] (a : A), aeval a f ≠ 0 ∨ aeval a g ≠ 0 
goal: IsCoprime f g ↔
  ∀ {A : Type v} [inst : CommRing A] [inst_1 : IsDomain A] [inst_2 : Algebra K A] (a : A),
    (Polynomial.aeval a) f ≠ 0 ∨ (Polynomial.aeval a) g ≠ 0

full_name: Polynomial.removeFactor
code: /-- Divide a polynomial f by `X - C r` where `r` is a root of `f` in a bigger field extension. -/
def removeFactor (f : K[X]) : Polynomial (AdjoinRoot <| factor f) 
goal: (AdjoinRoot f.factor)[X]

full_name: Polynomial.X_sub_C_mul_removeFactor
code: theorem X_sub_C_mul_removeFactor (f : K[X]) (hf : f.natDegree ≠ 0) :
    (X - C (AdjoinRoot.root f.factor)) * f.removeFactor = map (AdjoinRoot.of f.factor) f 
goal: (Polynomial.X - Polynomial.C (AdjoinRoot.root f.factor)) * f.removeFactor = Polynomial.map (AdjoinRoot.of f.factor) f

full_name: Polynomial.natDegree_removeFactor
code: theorem natDegree_removeFactor (f : K[X]) : f.removeFactor.natDegree = f.natDegree - 1 
goal: f.removeFactor.natDegree = f.natDegree - 1

full_name: Polynomial.natDegree_removeFactor'
code: theorem natDegree_removeFactor' {f : K[X]} {n : ℕ} (hfn : f.natDegree = n + 1) :
    f.removeFactor.natDegree = n 
goal: f.removeFactor.natDegree = n

full_name: Polynomial.SplittingFieldAuxAux
code: /-- Auxiliary construction to a splitting field of a polynomial, which removes
`n` (arbitrarily-chosen) factors.

It constructs the type, proves that is a field and algebra over the base field.

Uses recursion on the degree.
-/
def SplittingFieldAuxAux (n : ℕ) : ∀ {K : Type u} [Field K], K[X] →
    Σ (L : Type u) (_ : Field L), Algebra K L 
goal: K[X] → (L : Type u) × (x : Field L) × Algebra K L

full_name: Polynomial.SplittingFieldAux
code: /-- Auxiliary construction to a splitting field of a polynomial, which removes
`n` (arbitrarily-chosen) factors. It is the type constructed in `SplittingFieldAuxAux`.
-/
def SplittingFieldAux (n : ℕ) {K : Type u} [Field K] (f : K[X]) : Type u 
goal: Type u

full_name: Polynomial.SplittingFieldAux.field
code: instance SplittingFieldAux.field (n : ℕ) {K : Type u} [Field K] (f : K[X]) :
    Field (SplittingFieldAux n f) 
goal: Field (Polynomial.SplittingFieldAux n f)

full_name: Polynomial.instInhabitedSplittingFieldAux
code: instance (n : ℕ) {K : Type u} [Field K] (f : K[X]) : Inhabited (SplittingFieldAux n f) 
goal: Inhabited (Polynomial.SplittingFieldAux n f)

full_name: Polynomial.SplittingFieldAux.algebra
code: instance SplittingFieldAux.algebra (n : ℕ) {K : Type u} [Field K] (f : K[X]) :
    Algebra K (SplittingFieldAux n f) 
goal: Algebra K (Polynomial.SplittingFieldAux n f)

full_name: Polynomial.SplittingFieldAux.succ
code: theorem succ (n : ℕ) (f : K[X]) :
    SplittingFieldAux (n + 1) f = SplittingFieldAux n f.removeFactor 
goal: Polynomial.SplittingFieldAux (n + 1) f = Polynomial.SplittingFieldAux n f.removeFactor

full_name: Polynomial.SplittingFieldAux.algebra'''
code: instance algebra''' {n : ℕ} {f : K[X]} :
    Algebra (AdjoinRoot f.factor) (SplittingFieldAux n f.removeFactor) 
goal: Algebra (AdjoinRoot f.factor) (Polynomial.SplittingFieldAux n f.removeFactor)

full_name: Polynomial.SplittingFieldAux.algebra'
code: instance algebra' {n : ℕ} {f : K[X]} : Algebra (AdjoinRoot f.factor) (SplittingFieldAux n.succ f) 
goal: Algebra (AdjoinRoot f.factor) (Polynomial.SplittingFieldAux n.succ f)

full_name: Polynomial.SplittingFieldAux.algebra''
code: instance algebra'' {n : ℕ} {f : K[X]} : Algebra K (SplittingFieldAux n f.removeFactor) 
goal: Algebra K (Polynomial.SplittingFieldAux n f.removeFactor)

full_name: Polynomial.SplittingFieldAux.scalar_tower'
code: instance scalar_tower' {n : ℕ} {f : K[X]} :
    IsScalarTower K (AdjoinRoot f.factor) (SplittingFieldAux n f.removeFactor) 
goal: IsScalarTower K (AdjoinRoot f.factor) (Polynomial.SplittingFieldAux n f.removeFactor)

full_name: Polynomial.SplittingFieldAux.algebraMap_succ
code: theorem algebraMap_succ (n : ℕ) (f : K[X]) :
    algebraMap K (SplittingFieldAux (n + 1) f) =
      (algebraMap (AdjoinRoot f.factor) (SplittingFieldAux n f.removeFactor)).comp
        (AdjoinRoot.of f.factor) 
goal: algebraMap K (Polynomial.SplittingFieldAux (n + 1) f) =
  (algebraMap (AdjoinRoot f.factor) (Polynomial.SplittingFieldAux n f.removeFactor)).comp (AdjoinRoot.of f.factor)

full_name: Polynomial.SplittingFieldAux.splits
code: protected theorem splits (n : ℕ) :
    ∀ {K : Type u} [Field K],
      ∀ (f : K[X]) (_hfn : f.natDegree = n), Splits (algebraMap K <| SplittingFieldAux n f) f 
goal: Polynomial.Splits (algebraMap K (Polynomial.SplittingFieldAux n f)) f

full_name: Polynomial.SplittingFieldAux.adjoin_rootSet
code: theorem adjoin_rootSet (n : ℕ) :
    ∀ {K : Type u} [Field K],
      ∀ (f : K[X]) (_hfn : f.natDegree = n),
        Algebra.adjoin K (f.rootSet (SplittingFieldAux n f)) = ⊤ 
goal: Algebra.adjoin K (f.rootSet (Polynomial.SplittingFieldAux n f)) = ⊤

full_name: Polynomial.SplittingFieldAux.instIsSplittingFieldNatDegree
code: instance (f : K[X]) : IsSplittingField K (SplittingFieldAux f.natDegree f) f 
goal: Polynomial.IsSplittingField K (Polynomial.SplittingFieldAux f.natDegree f) f

full_name: Polynomial.SplittingField
code: /-- A splitting field of a polynomial. -/
def SplittingField (f : K[X]) 
goal: Type v

full_name: Polynomial.SplittingField.commRing
code: instance commRing : CommRing (SplittingField f) 
goal: CommRing f.SplittingField

full_name: Polynomial.SplittingField.inhabited
code: instance inhabited : Inhabited (SplittingField f) 
goal: Inhabited f.SplittingField

full_name: Polynomial.SplittingField.instSMulOfIsScalarTower
code: instance {S : Type*} [DistribSMul S K] [IsScalarTower S K K] : SMul S (SplittingField f) 
goal: SMul S f.SplittingField

full_name: Polynomial.SplittingField.algebra
code: instance algebra : Algebra K (SplittingField f) 
goal: Algebra K f.SplittingField

full_name: Polynomial.SplittingField.algebra'
code: instance algebra' {R : Type*} [CommSemiring R] [Algebra R K] : Algebra R (SplittingField f) 
goal: Algebra R f.SplittingField

full_name: Polynomial.SplittingField.isScalarTower
code: instance isScalarTower {R : Type*} [CommSemiring R] [Algebra R K] :
    IsScalarTower R K (SplittingField f) 
goal: IsScalarTower R K f.SplittingField

full_name: Polynomial.SplittingField.algEquivSplittingFieldAux
code: /-- The algebra equivalence with `SplittingFieldAux`,
which we will use to construct the field structure. -/
def algEquivSplittingFieldAux (f : K[X]) : SplittingField f ≃ₐ[K] SplittingFieldAux f.natDegree f 
goal: f.SplittingField ≃ₐ[K] Polynomial.SplittingFieldAux f.natDegree f

full_name: Polynomial.SplittingField.instGroupWithZero
code: instance instGroupWithZero : GroupWithZero (SplittingField f) 
goal: GroupWithZero f.SplittingField

full_name: Polynomial.SplittingField.instField
code: instance instField : Field (SplittingField f) 
goal: Field f.SplittingField

full_name: Polynomial.SplittingField.instCharZero
code: instance instCharZero [CharZero K] : CharZero (SplittingField f) 
goal: CharZero f.SplittingField

full_name: Polynomial.SplittingField.instCharP
code: instance instCharP (p : ℕ) [CharP K p] : CharP (SplittingField f) p 
goal: CharP f.SplittingField p

full_name: Polynomial.SplittingField.instExpChar
code: instance instExpChar (p : ℕ) [ExpChar K p] : ExpChar (SplittingField f) p 
goal: ExpChar f.SplittingField p

full_name: Polynomial.IsSplittingField.splittingField
code: instance _root_.Polynomial.IsSplittingField.splittingField (f : K[X]) :
    IsSplittingField K (SplittingField f) f 
goal: Polynomial.IsSplittingField K f.SplittingField f

full_name: Polynomial.SplittingField.splits
code: protected theorem splits : Splits (algebraMap K (SplittingField f)) f 
goal: Polynomial.Splits (algebraMap K f.SplittingField) f

full_name: Polynomial.SplittingField.lift
code: /-- Embeds the splitting field into any other field that splits the polynomial. -/
def lift : SplittingField f →ₐ[K] L 
goal: f.SplittingField →ₐ[K] L

full_name: Polynomial.SplittingField.adjoin_rootSet
code: theorem adjoin_rootSet : Algebra.adjoin K (f.rootSet (SplittingField f)) = ⊤ 
goal: Algebra.adjoin K (f.rootSet f.SplittingField) = ⊤

full_name: Polynomial.IsSplittingField.instFiniteDimensionalSplittingField
code: instance (f : K[X]) : FiniteDimensional K f.SplittingField 
goal: FiniteDimensional K f.SplittingField

full_name: Polynomial.IsSplittingField.instFintypeSplittingField
code: instance [Fintype K] (f : K[X]) : Fintype f.SplittingField 
goal: Fintype f.SplittingField

full_name: Polynomial.IsSplittingField.instNoZeroSMulDivisorsSplittingField
code: instance (f : K[X]) : NoZeroSMulDivisors K f.SplittingField 
goal: NoZeroSMulDivisors K f.SplittingField

full_name: Polynomial.IsSplittingField.algEquiv
code: /-- Any splitting field is isomorphic to `SplittingFieldAux f`. -/
def algEquiv (f : K[X]) [h : IsSplittingField K L f] : L ≃ₐ[K] SplittingField f 
goal: L ≃ₐ[K] f.SplittingField