File: Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean

full_name: AlgebraicClosure.MonicIrreducible
code: /-- The subtype of monic irreducible polynomials -/
abbrev MonicIrreducible : Type u 
goal: Type u

full_name: AlgebraicClosure.evalXSelf
code: /-- Sends a monic irreducible polynomial `f` to `f(x_f)` where `x_f` is a formal indeterminate. -/
def evalXSelf (f : MonicIrreducible k) : MvPolynomial (MonicIrreducible k) k 
goal: MvPolynomial (AlgebraicClosure.MonicIrreducible k) k

full_name: AlgebraicClosure.spanEval
code: /-- The span of `f(x_f)` across monic irreducible polynomials `f` where `x_f` is an
indeterminate. -/
def spanEval : Ideal (MvPolynomial (MonicIrreducible k) k) 
goal: Ideal (MvPolynomial (AlgebraicClosure.MonicIrreducible k) k)

full_name: AlgebraicClosure.toSplittingField
code: /-- Given a finset of monic irreducible polynomials, construct an algebra homomorphism to the
splitting field of the product of the polynomials sending each indeterminate `x_f` represented by
the polynomial `f` in the finset to a root of `f`. -/
def toSplittingField (s : Finset (MonicIrreducible k)) :
    MvPolynomial (MonicIrreducible k) k →ₐ[k] SplittingField (∏ x ∈ s, x : k[X]) 
goal: MvPolynomial (AlgebraicClosure.MonicIrreducible k) k →ₐ[k] (∏ x ∈ s, ↑x).SplittingField

full_name: AlgebraicClosure.toSplittingField_evalXSelf
code: theorem toSplittingField_evalXSelf {s : Finset (MonicIrreducible k)} {f} (hf : f ∈ s) :
    toSplittingField k s (evalXSelf k f) = 0 
goal: (AlgebraicClosure.toSplittingField k s) (AlgebraicClosure.evalXSelf k f) = 0

full_name: AlgebraicClosure.spanEval_ne_top
code: theorem spanEval_ne_top : spanEval k ≠ ⊤ 
goal: AlgebraicClosure.spanEval k ≠ ⊤

full_name: AlgebraicClosure.maxIdeal
code: /-- A random maximal ideal that contains `spanEval k` -/
def maxIdeal : Ideal (MvPolynomial (MonicIrreducible k) k) 
goal: Ideal (MvPolynomial (AlgebraicClosure.MonicIrreducible k) k)

full_name: AlgebraicClosure.maxIdeal.isMaximal
code: instance maxIdeal.isMaximal : (maxIdeal k).IsMaximal 
goal: (AlgebraicClosure.maxIdeal k).IsMaximal

full_name: AlgebraicClosure.le_maxIdeal
code: theorem le_maxIdeal : spanEval k ≤ maxIdeal k 
goal: AlgebraicClosure.spanEval k ≤ AlgebraicClosure.maxIdeal k

full_name: AlgebraicClosure.AdjoinMonic
code: /-- The first step of constructing `AlgebraicClosure`: adjoin a root of all monic polynomials -/
def AdjoinMonic : Type u 
goal: Type u

full_name: AlgebraicClosure.AdjoinMonic.field
code: instance AdjoinMonic.field : Field (AdjoinMonic k) 
goal: Field (AlgebraicClosure.AdjoinMonic k)

full_name: AlgebraicClosure.AdjoinMonic.inhabited
code: instance AdjoinMonic.inhabited : Inhabited (AdjoinMonic k) 
goal: Inhabited (AlgebraicClosure.AdjoinMonic k)

full_name: AlgebraicClosure.toAdjoinMonic
code: /-- The canonical ring homomorphism to `AdjoinMonic k`. -/
def toAdjoinMonic : k →+* AdjoinMonic k 
goal: k →+* AlgebraicClosure.AdjoinMonic k

full_name: AlgebraicClosure.AdjoinMonic.algebra
code: instance AdjoinMonic.algebra : Algebra k (AdjoinMonic k) 
goal: Algebra k (AlgebraicClosure.AdjoinMonic k)

full_name: AlgebraicClosure.AdjoinMonic.algebraMap
code: theorem AdjoinMonic.algebraMap : algebraMap k (AdjoinMonic k) = (Ideal.Quotient.mk _).comp
    (C : k →+* MvPolynomial (MonicIrreducible k) k) 
goal: algebraMap k (AlgebraicClosure.AdjoinMonic k) = (Ideal.Quotient.mk (AlgebraicClosure.maxIdeal k)).comp MvPolynomial.C

full_name: AlgebraicClosure.AdjoinMonic.isIntegral
code: theorem AdjoinMonic.isIntegral (z : AdjoinMonic k) : IsIntegral k z 
goal: IsIntegral k z

full_name: AlgebraicClosure.AdjoinMonic.exists_root
code: theorem AdjoinMonic.exists_root {f : k[X]} (hfm : f.Monic) (hfi : Irreducible f) :
    ∃ x : AdjoinMonic k, f.eval₂ (toAdjoinMonic k) x = 0 
goal: ∃ x, Polynomial.eval₂ (AlgebraicClosure.toAdjoinMonic k) x f = 0

full_name: AlgebraicClosure.stepAux
code: /-- The `n`th step of constructing `AlgebraicClosure`, together with its `Field` instance. -/
def stepAux (n : ℕ) : Σ α : Type u, Field α 
goal: (α : Type u) × Field α

full_name: AlgebraicClosure.Step
code: /-- The `n`th step of constructing `AlgebraicClosure`. -/
def Step (n : ℕ) : Type u 
goal: Type u

full_name: AlgebraicClosure.Step.zero
code: theorem Step.zero : Step k 0 = k 
goal: AlgebraicClosure.Step k 0 = k

full_name: AlgebraicClosure.Step.field
code: instance Step.field (n : ℕ) : Field (Step k n) 
goal: Field (AlgebraicClosure.Step k n)

full_name: AlgebraicClosure.Step.succ
code: theorem Step.succ (n : ℕ) : Step k (n + 1) = AdjoinMonic (Step k n) 
goal: AlgebraicClosure.Step k (n + 1) = AlgebraicClosure.AdjoinMonic (AlgebraicClosure.Step k n)

full_name: AlgebraicClosure.Step.inhabited
code: instance Step.inhabited (n) : Inhabited (Step k n) 
goal: Inhabited (AlgebraicClosure.Step k n)

full_name: AlgebraicClosure.toStepZero
code: /-- The canonical inclusion to the `0`th step. -/
def toStepZero : k →+* Step k 0 
goal: k →+* AlgebraicClosure.Step k 0

full_name: AlgebraicClosure.toStepSucc
code: /-- The canonical ring homomorphism to the next step. -/
def toStepSucc (n : ℕ) : Step k n →+* (Step k (n + 1)) 
goal: AlgebraicClosure.Step k n →+* AlgebraicClosure.Step k (n + 1)

full_name: AlgebraicClosure.Step.algebraSucc
code: instance Step.algebraSucc (n) : Algebra (Step k n) (Step k (n + 1)) 
goal: Algebra (AlgebraicClosure.Step k n) (AlgebraicClosure.Step k (n + 1))

full_name: AlgebraicClosure.toStepSucc.exists_root
code: theorem toStepSucc.exists_root {n} {f : Polynomial (Step k n)} (hfm : f.Monic)
    (hfi : Irreducible f) : ∃ x : Step k (n + 1), f.eval₂ (toStepSucc k n) x = 0 
goal: ∃ x, Polynomial.eval₂ (AlgebraicClosure.toStepSucc k n) x f = 0

full_name: _private.Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure.0.AlgebraicClosure.toStepOfLE'
code: private def toStepOfLE' (m n : ℕ) (h : m ≤ n) : Step k m → Step k n 
goal: AlgebraicClosure.Step k m → AlgebraicClosure.Step k n

full_name: _private.Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure.0.AlgebraicClosure.toStepOfLE'.succ
code: private theorem toStepOfLE'.succ (m n : ℕ) (h : m ≤ n) :
    toStepOfLE' k m (Nat.succ n) (h.trans n.le_succ) =
    (toStepSucc k n) ∘ toStepOfLE' k m n h 
goal: AlgebraicClosure.toStepOfLE' k m n.succ ⋯ = ⇑(AlgebraicClosure.toStepSucc k n) ∘ AlgebraicClosure.toStepOfLE' k m n h

full_name: AlgebraicClosure.toStepOfLE
code: /-- The canonical ring homomorphism to a step with a greater index. -/
def toStepOfLE (m n : ℕ) (h : m ≤ n) : Step k m →+* Step k n 
goal: AlgebraicClosure.Step k m →+* AlgebraicClosure.Step k n

full_name: AlgebraicClosure.coe_toStepOfLE
code: @[simp]
theorem coe_toStepOfLE (m n : ℕ) (h : m ≤ n) :
    (toStepOfLE k m n h : Step k m → Step k n) = Nat.leRecOn h @fun n => toStepSucc k n 
goal: ⇑(AlgebraicClosure.toStepOfLE k m n h) = fun a => Nat.leRecOn h (fun n => ⇑(AlgebraicClosure.toStepSucc k n)) a

full_name: AlgebraicClosure.Step.algebra
code: instance Step.algebra (n) : Algebra k (Step k n) 
goal: Algebra k (AlgebraicClosure.Step k n)

full_name: AlgebraicClosure.Step.scalar_tower
code: instance Step.scalar_tower (n) : IsScalarTower k (Step k n) (Step k (n + 1)) 
goal: IsScalarTower k (AlgebraicClosure.Step k n) (AlgebraicClosure.Step k (n + 1))

full_name: _private.Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure.0.AlgebraicClosure.toStepOfLE.succ
code: private theorem toStepOfLE.succ (n : ℕ) (h : 0 ≤ n) :
    toStepOfLE k 0 (n + 1) (h.trans n.le_succ) =
    (toStepSucc k n).comp (toStepOfLE k 0 n h) 
goal: AlgebraicClosure.toStepOfLE k 0 (n + 1) ⋯ = (AlgebraicClosure.toStepSucc k n).comp (AlgebraicClosure.toStepOfLE k 0 n h)

full_name: AlgebraicClosure.Step.isIntegral
code: theorem Step.isIntegral (n) : ∀ z : Step k n, IsIntegral k z 
goal: IsIntegral k z

full_name: AlgebraicClosure.toStepOfLE.directedSystem
code: instance toStepOfLE.directedSystem : DirectedSystem (Step k) fun i j h => toStepOfLE k i j h 
goal: DirectedSystem (AlgebraicClosure.Step k) fun i j h => ⇑(AlgebraicClosure.toStepOfLE k i j h)

full_name: AlgebraicClosureAux
code: /-- Auxiliary construction for `AlgebraicClosure`. Although `AlgebraicClosureAux` does define
the algebraic closure of a field, it is redefined at `AlgebraicClosure` in order to make sure
certain instance diamonds commute by definition.
-/
def AlgebraicClosureAux [Field k] : Type u 
goal: Type u

full_name: AlgebraicClosureAux.field
code: /-- `AlgebraicClosureAux k` is a `Field` -/
local instance field : Field (AlgebraicClosureAux k) 
goal: Field (AlgebraicClosureAux k)

full_name: AlgebraicClosureAux.instInhabited
code: instance : Inhabited (AlgebraicClosureAux k) 
goal: Inhabited (AlgebraicClosureAux k)

full_name: AlgebraicClosureAux.ofStep
code: /-- The canonical ring embedding from the `n`th step to the algebraic closure. -/
def ofStep (n : ℕ) : Step k n →+* AlgebraicClosureAux k 
goal: AlgebraicClosure.Step k n →+* AlgebraicClosureAux k

full_name: AlgebraicClosureAux.ofStep_succ
code: theorem ofStep_succ (n : ℕ) : (ofStep k (n + 1)).comp (toStepSucc k n) = ofStep k n 
goal: (AlgebraicClosureAux.ofStep k (n + 1)).comp (AlgebraicClosure.toStepSucc k n) = AlgebraicClosureAux.ofStep k n

full_name: AlgebraicClosureAux.exists_ofStep
code: theorem exists_ofStep (z : AlgebraicClosureAux k) : ∃ n x, ofStep k n x = z 
goal: ∃ n x, (AlgebraicClosureAux.ofStep k n) x = z

full_name: AlgebraicClosureAux.exists_root
code: theorem exists_root {f : Polynomial (AlgebraicClosureAux k)}
    (hfm : f.Monic) (hfi : Irreducible f) : ∃ x : AlgebraicClosureAux k, f.eval x = 0 
goal: ∃ x, Polynomial.eval x f = 0

full_name: AlgebraicClosureAux.instIsAlgClosed
code: @[local instance] theorem instIsAlgClosed : IsAlgClosed (AlgebraicClosureAux k) 
goal: IsAlgClosed (AlgebraicClosureAux k)

full_name: AlgebraicClosureAux.instAlgebra
code: /-- `AlgebraicClosureAux k` is a `k`-`Algebra` -/
local instance instAlgebra : Algebra k (AlgebraicClosureAux k) 
goal: Algebra k (AlgebraicClosureAux k)

full_name: AlgebraicClosureAux.ofStepHom
code: /-- Canonical algebra embedding from the `n`th step to the algebraic closure. -/
def ofStepHom (n) : Step k n →ₐ[k] AlgebraicClosureAux k 
goal: AlgebraicClosure.Step k n →ₐ[k] AlgebraicClosureAux k

full_name: AlgebraicClosureAux.isAlgebraic
code: instance isAlgebraic : Algebra.IsAlgebraic k (AlgebraicClosureAux k) 
goal: Algebra.IsAlgebraic k (AlgebraicClosureAux k)

full_name: AlgebraicClosureAux.isAlgClosure
code: @[local instance] theorem isAlgClosure : IsAlgClosure k (AlgebraicClosureAux k) 
goal: IsAlgClosure k (AlgebraicClosureAux k)

full_name: AlgebraicClosure
code: /-- The canonical algebraic closure of a field, the direct limit of adding roots to the field for
each polynomial over the field. -/
def AlgebraicClosure : Type u 
goal: Type u

full_name: AlgebraicClosure.instCommRing
code: instance instCommRing : CommRing (AlgebraicClosure k) 
goal: CommRing (AlgebraicClosure k)

full_name: AlgebraicClosure.instInhabited
code: instance instInhabited : Inhabited (AlgebraicClosure k) 
goal: Inhabited (AlgebraicClosure k)

full_name: AlgebraicClosure.instSMulOfIsScalarTower
code: instance {S : Type*} [DistribSMul S k] [IsScalarTower S k k] : SMul S (AlgebraicClosure k) 
goal: SMul S (AlgebraicClosure k)

full_name: AlgebraicClosure.instAlgebra
code: instance instAlgebra {R : Type*} [CommSemiring R] [Algebra R k] : Algebra R (AlgebraicClosure k) 
goal: Algebra R (AlgebraicClosure k)

full_name: AlgebraicClosure.instIsScalarTower
code: instance {R S : Type*} [CommSemiring R] [CommSemiring S] [Algebra R S] [Algebra S k] [Algebra R k]
    [IsScalarTower R S k] : IsScalarTower R S (AlgebraicClosure k) 
goal: IsScalarTower R S (AlgebraicClosure k)

full_name: AlgebraicClosure.algEquivAlgebraicClosureAux
code: /-- The equivalence between `AlgebraicClosure` and `AlgebraicClosureAux`, which we use to transfer
properties of `AlgebraicClosureAux` to `AlgebraicClosure` -/
def algEquivAlgebraicClosureAux :
    AlgebraicClosure k ≃ₐ[k] AlgebraicClosureAux k 
goal: AlgebraicClosure k ≃ₐ[k] AlgebraicClosureAux k

full_name: AlgebraicClosure.instGroupWithZero
code: instance instGroupWithZero : GroupWithZero (AlgebraicClosure k) 
goal: GroupWithZero (AlgebraicClosure k)

full_name: AlgebraicClosure.instField
code: instance instField : Field (AlgebraicClosure k) 
goal: Field (AlgebraicClosure k)

full_name: AlgebraicClosure.isAlgClosed
code: instance isAlgClosed : IsAlgClosed (AlgebraicClosure k) 
goal: IsAlgClosed (AlgebraicClosure k)

full_name: AlgebraicClosure.instIsAlgClosure
code: instance : IsAlgClosure k (AlgebraicClosure k) 
goal: IsAlgClosure k (AlgebraicClosure k)

full_name: AlgebraicClosure.isAlgebraic
code: instance isAlgebraic : Algebra.IsAlgebraic k (AlgebraicClosure k) 
goal: Algebra.IsAlgebraic k (AlgebraicClosure k)

full_name: AlgebraicClosure.instCharZero
code: instance [CharZero k] : CharZero (AlgebraicClosure k) 
goal: CharZero (AlgebraicClosure k)

full_name: AlgebraicClosure.instCharP
code: instance {p : ℕ} [CharP k p] : CharP (AlgebraicClosure k) p 
goal: CharP (AlgebraicClosure k) p