File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

full_name: IsAlgClosed
code: /-- Typeclass for algebraically closed fields.

To show `Polynomial.Splits p f` for an arbitrary ring homomorphism `f`,
see `IsAlgClosed.splits_codomain` and `IsAlgClosed.splits_domain`.
-/
class IsAlgClosed : Prop where
  splits : ∀ p : k[X], p.Splits <| RingHom.id k
goal: Prop

full_name: IsAlgClosed.splits
code: /-- Typeclass for algebraically closed fields.

To show `Polynomial.Splits p f` for an arbitrary ring homomorphism `f`,
see `IsAlgClosed.splits_codomain` and `IsAlgClosed.splits_domain`.
-/
class IsAlgClosed : Prop where
  splits : ∀ p : k[X], p.Splits <| RingHom.id k
goal: Polynomial.Splits (RingHom.id k) p

full_name: IsAlgClosed.splits_codomain
code: /-- Every polynomial splits in the field extension `f : K →+* k` if `k` is algebraically closed.

See also `IsAlgClosed.splits_domain` for the case where `K` is algebraically closed.
-/
theorem IsAlgClosed.splits_codomain {k K : Type*} [Field k] [IsAlgClosed k] [Field K] {f : K →+* k}
    (p : K[X]) : p.Splits f 
goal: Polynomial.Splits f p

full_name: IsAlgClosed.splits_domain
code: /-- Every polynomial splits in the field extension `f : K →+* k` if `K` is algebraically closed.

See also `IsAlgClosed.splits_codomain` for the case where `k` is algebraically closed.
-/
theorem IsAlgClosed.splits_domain {k K : Type*} [Field k] [IsAlgClosed k] [Field K] {f : k →+* K}
    (p : k[X]) : p.Splits f 
goal: Polynomial.Splits f p

full_name: IsAlgClosed.exists_root
code: theorem exists_root [IsAlgClosed k] (p : k[X]) (hp : p.degree ≠ 0) : ∃ x, IsRoot p x 
goal: ∃ x, p.IsRoot x

full_name: IsAlgClosed.exists_pow_nat_eq
code: theorem exists_pow_nat_eq [IsAlgClosed k] (x : k) {n : ℕ} (hn : 0 < n) : ∃ z, z ^ n = x 
goal: ∃ z, z ^ n = x

full_name: IsAlgClosed.exists_eq_mul_self
code: theorem exists_eq_mul_self [IsAlgClosed k] (x : k) : ∃ z, x = z * z 
goal: ∃ z, x = z * z

full_name: IsAlgClosed.roots_eq_zero_iff
code: theorem roots_eq_zero_iff [IsAlgClosed k] {p : k[X]} :
    p.roots = 0 ↔ p = Polynomial.C (p.coeff 0) 
goal: p.roots = 0 ↔ p = Polynomial.C (p.coeff 0)

full_name: IsAlgClosed.exists_eval₂_eq_zero_of_injective
code: theorem exists_eval₂_eq_zero_of_injective {R : Type*} [Ring R] [IsAlgClosed k] (f : R →+* k)
    (hf : Function.Injective f) (p : R[X]) (hp : p.degree ≠ 0) : ∃ x, p.eval₂ f x = 0 
goal: ∃ x, Polynomial.eval₂ f x p = 0

full_name: IsAlgClosed.exists_eval₂_eq_zero
code: theorem exists_eval₂_eq_zero {R : Type*} [Field R] [IsAlgClosed k] (f : R →+* k) (p : R[X])
    (hp : p.degree ≠ 0) : ∃ x, p.eval₂ f x = 0 
goal: ∃ x, Polynomial.eval₂ f x p = 0

full_name: IsAlgClosed.exists_aeval_eq_zero_of_injective
code: theorem exists_aeval_eq_zero_of_injective {R : Type*} [CommRing R] [IsAlgClosed k] [Algebra R k]
    (hinj : Function.Injective (algebraMap R k)) (p : R[X]) (hp : p.degree ≠ 0) :
    ∃ x : k, aeval x p = 0 
goal: ∃ x, (Polynomial.aeval x) p = 0

full_name: IsAlgClosed.exists_aeval_eq_zero
code: theorem exists_aeval_eq_zero {R : Type*} [Field R] [IsAlgClosed k] [Algebra R k] (p : R[X])
    (hp : p.degree ≠ 0) : ∃ x : k, aeval x p = 0 
goal: ∃ x, (Polynomial.aeval x) p = 0

full_name: IsAlgClosed.of_exists_root
code: theorem of_exists_root (H : ∀ p : k[X], p.Monic → Irreducible p → ∃ x, p.eval x = 0) :
    IsAlgClosed k 
goal: IsAlgClosed k

full_name: IsAlgClosed.of_ringEquiv
code: theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' 
goal: IsAlgClosed k'

full_name: IsAlgClosed.degree_eq_one_of_irreducible
code: theorem degree_eq_one_of_irreducible [IsAlgClosed k] {p : k[X]} (hp : Irreducible p) :
    p.degree = 1 
goal: p.degree = 1

full_name: IsAlgClosed.algebraMap_surjective_of_isIntegral
code: theorem algebraMap_surjective_of_isIntegral {k K : Type*} [Field k] [Ring K] [IsDomain K]
    [hk : IsAlgClosed k] [Algebra k K] [Algebra.IsIntegral k K] :
    Function.Surjective (algebraMap k K) 
goal: Function.Surjective ⇑(algebraMap k K)

full_name: IsAlgClosed.algebraMap_surjective_of_isIntegral'
code: theorem algebraMap_surjective_of_isIntegral' {k K : Type*} [Field k] [CommRing K] [IsDomain K]
    [IsAlgClosed k] (f : k →+* K) (hf : f.IsIntegral) : Function.Surjective f 
goal: Function.Surjective ⇑f

full_name: IsAlgClosed.algebraMap_surjective_of_isAlgebraic
code: /--
Deprecated: `algebraMap_surjective_of_isIntegral` is identical apart from the `IsIntegral` argument,
which can be found by instance synthesis
-/
@[deprecated algebraMap_surjective_of_isIntegral (since := "2024-05-08")]
theorem algebraMap_surjective_of_isAlgebraic {k K : Type*} [Field k] [Ring K] [IsDomain K]
    [IsAlgClosed k] [Algebra k K] [Algebra.IsAlgebraic k K] :
    Function.Surjective (algebraMap k K) 
goal: Function.Surjective ⇑(algebraMap k K)

full_name: IntermediateField.eq_bot_of_isAlgClosed_of_isAlgebraic
code: /-- If `k` is algebraically closed, `K / k` is a field extension, `L / k` is an intermediate field
which is algebraic, then `L` is equal to `k`. A corollary of
`IsAlgClosed.algebraMap_surjective_of_isAlgebraic`. -/
theorem IntermediateField.eq_bot_of_isAlgClosed_of_isAlgebraic {k K : Type*} [Field k] [Field K]
    [IsAlgClosed k] [Algebra k K] (L : IntermediateField k K) [Algebra.IsAlgebraic k L] :
    L = ⊥ 
goal: L = ⊥

full_name: Polynomial.isCoprime_iff_aeval_ne_zero_of_isAlgClosed
code: lemma Polynomial.isCoprime_iff_aeval_ne_zero_of_isAlgClosed (K : Type v) [Field K] [IsAlgClosed K]
    [Algebra k K] (p q : k[X]) : IsCoprime p q ↔ ∀ a : K, aeval a p ≠ 0 ∨ aeval a q ≠ 0 
goal: IsCoprime p q ↔ ∀ (a : K), (Polynomial.aeval a) p ≠ 0 ∨ (Polynomial.aeval a) q ≠ 0

full_name: IsAlgClosure.algebraic
code: /-- Typeclass for an extension being an algebraic closure. -/
class IsAlgClosure (R : Type u) (K : Type v) [CommRing R] [Field K] [Algebra R K]
    [NoZeroSMulDivisors R K] : Prop where
  alg_closed : IsAlgClosed K
  algebraic : Algebra.IsAlgebraic R K
goal: Algebra.IsAlgebraic R K

full_name: IsAlgClosure
code: /-- Typeclass for an extension being an algebraic closure. -/
class IsAlgClosure (R : Type u) (K : Type v) [CommRing R] [Field K] [Algebra R K]
    [NoZeroSMulDivisors R K] : Prop where
  alg_closed : IsAlgClosed K
  algebraic : Algebra.IsAlgebraic R K
goal: Prop

full_name: IsAlgClosure.alg_closed
code: /-- Typeclass for an extension being an algebraic closure. -/
class IsAlgClosure (R : Type u) (K : Type v) [CommRing R] [Field K] [Algebra R K]
    [NoZeroSMulDivisors R K] : Prop where
  alg_closed : IsAlgClosed K
  algebraic : Algebra.IsAlgebraic R K
goal: IsAlgClosed K

full_name: isAlgClosure_iff
code: theorem isAlgClosure_iff (K : Type v) [Field K] [Algebra k K] :
    IsAlgClosure k K ↔ IsAlgClosed K ∧ Algebra.IsAlgebraic k K 
goal: IsAlgClosure k K ↔ IsAlgClosed K ∧ Algebra.IsAlgebraic k K

full_name: IsAlgClosure.normal
code: instance (priority := 100) IsAlgClosure.normal (R K : Type*) [Field R] [Field K] [Algebra R K]
    [IsAlgClosure R K] : Normal R K 
goal: Normal R K

full_name: IsAlgClosure.separable
code: instance (priority := 100) IsAlgClosure.separable (R K : Type*) [Field R] [Field K] [Algebra R K]
    [IsAlgClosure R K] [CharZero R] : Algebra.IsSeparable R K 
goal: Algebra.IsSeparable R K

full_name: IsAlgClosed.surjective_comp_algebraMap_of_isAlgebraic
code: /-- If E/L/K is a tower of field extensions with E/L algebraic, and if M is an algebraically
  closed extension of K, then any embedding of L/K into M/K extends to an embedding of E/K.
  Known as the extension lemma in https://math.stackexchange.com/a/687914. -/
theorem surjective_comp_algebraMap_of_isAlgebraic {E : Type*}
    [Field E] [Algebra K E] [Algebra L E] [IsScalarTower K L E] [Algebra.IsAlgebraic L E] :
    Function.Surjective fun φ : E →ₐ[K] M ↦ φ.comp (IsScalarTower.toAlgHom K L E) 
goal: Function.Surjective fun φ => φ.comp (IsScalarTower.toAlgHom K L E)

full_name: _private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosed.lift_aux_def
code: /-- Less general version of `lift`. -/
private noncomputable irreducible_def lift_aux : L →ₐ[K] M 
goal: IsAlgClosed.lift_aux K L M = Classical.choice ⋯

full_name: IsAlgClosed.wrapped._@.Mathlib.FieldTheory.IsAlgClosed.Basic._hyg.2294
code: /-- Less general version of `lift`. -/
private noncomputable irreducible_def lift_aux : L →ₐ[K] M 
goal: Subtype (Eq IsAlgClosed.definition✝)

full_name: IsAlgClosed.definition._@.Mathlib.FieldTheory.IsAlgClosed.Basic._hyg.2294
code: /-- Less general version of `lift`. -/
private noncomputable irreducible_def lift_aux : L →ₐ[K] M 
goal: L →ₐ[K] M

full_name: _private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosed.lift_aux
code: /-- Less general version of `lift`. -/
private noncomputable irreducible_def lift_aux : L →ₐ[K] M 
goal: L →ₐ[K] M

full_name: _private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosed.FractionRing.isAlgebraic
code: private instance FractionRing.isAlgebraic :
    letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
    letI : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R _
    Algebra.IsAlgebraic (FractionRing R) (FractionRing S) 
goal: Algebra.IsAlgebraic (FractionRing R) (FractionRing S)

full_name: IsAlgClosed.lift_def
code: /-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M 
goal: IsAlgClosed.lift =
  let_fun this := ⋯;
  let_fun this_1 := ⋯;
  let f := IsAlgClosed.lift_aux (FractionRing R) (FractionRing S) M;
  (AlgHom.restrictScalars R f).comp (AlgHom.restrictScalars R (Algebra.ofId S (FractionRing S)))

full_name: IsAlgClosed.definition._@.Mathlib.FieldTheory.IsAlgClosed.Basic._hyg.2975
code: /-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M 
goal: S →ₐ[R] M

full_name: IsAlgClosed.lift
code: /-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M 
goal: S →ₐ[R] M

full_name: IsAlgClosed.wrapped._@.Mathlib.FieldTheory.IsAlgClosed.Basic._hyg.2975
code: /-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M 
goal: Subtype (Eq @IsAlgClosed.definition✝)

full_name: IsAlgClosed.perfectRing
code: noncomputable instance (priority := 100) perfectRing (p : ℕ) [Fact p.Prime] [CharP k p]
    [IsAlgClosed k] : PerfectRing k p 
goal: PerfectRing k p

full_name: IsAlgClosed.perfectField
code: noncomputable instance (priority := 100) perfectField [IsAlgClosed k] : PerfectField k 
goal: PerfectField k

full_name: IsAlgClosed.instInfinite
code: /-- Algebraically closed fields are infinite since `Xⁿ⁺¹ - 1` is separable when `#K = n` -/
instance (priority := 500) {K : Type*} [Field K] [IsAlgClosed K] : Infinite K 
goal: Infinite K

full_name: IsAlgClosure.equiv
code: /-- A (random) isomorphism between two algebraic closures of `R`. -/
noncomputable def equiv : L ≃ₐ[R] M 
goal: L ≃ₐ[R] M

full_name: IsAlgClosure.ofAlgebraic
code: /-- If `J` is an algebraic extension of `K` and `L` is an algebraic closure of `J`, then it is
  also an algebraic closure of `K`. -/
theorem ofAlgebraic [hKJ : Algebra.IsAlgebraic K J] : IsAlgClosure K L 
goal: IsAlgClosure K L

full_name: IsAlgClosure.equivOfAlgebraic'
code: /-- A (random) isomorphism between an algebraic closure of `R` and an algebraic closure of
  an algebraic extension of `R` -/
noncomputable def equivOfAlgebraic' [Nontrivial S] [NoZeroSMulDivisors R S]
    [Algebra.IsAlgebraic R L] : L ≃ₐ[R] M 
goal: L ≃ₐ[R] M

full_name: IsAlgClosure.equivOfAlgebraic
code: /-- A (random) isomorphism between an algebraic closure of `K` and an algebraic closure
  of an algebraic extension of `K` -/
noncomputable def equivOfAlgebraic [hKJ : Algebra.IsAlgebraic K J] : L ≃ₐ[K] M 
goal: L ≃ₐ[K] M

full_name: IsAlgClosure.equivOfEquivAux
code: /-- Used in the definition of `equivOfEquiv` -/
noncomputable def equivOfEquivAux (hSR : S ≃+* R) :
    { e : L ≃+* M // e.toRingHom.comp (algebraMap S L) = (algebraMap R M).comp hSR.toRingHom } 
goal: { e // e.toRingHom.comp (algebraMap S L) = (algebraMap R M).comp hSR.toRingHom }

full_name: IsAlgClosure.equivOfEquiv
code: /-- Algebraic closure of isomorphic fields are isomorphic -/
noncomputable def equivOfEquiv (hSR : S ≃+* R) : L ≃+* M 
goal: L ≃+* M

full_name: IsAlgClosure.equivOfEquiv_comp_algebraMap
code: @[simp]
theorem equivOfEquiv_comp_algebraMap (hSR : S ≃+* R) :
    (↑(equivOfEquiv L M hSR) : L →+* M).comp (algebraMap S L) = (algebraMap R M).comp hSR 
goal: (↑(IsAlgClosure.equivOfEquiv L M hSR)).comp (algebraMap S L) = (algebraMap R M).comp ↑hSR

full_name: IsAlgClosure.equivOfEquiv_algebraMap
code: @[simp]
theorem equivOfEquiv_algebraMap (hSR : S ≃+* R) (s : S) :
    equivOfEquiv L M hSR (algebraMap S L s) = algebraMap R M (hSR s) 
goal: (IsAlgClosure.equivOfEquiv L M hSR) ((algebraMap S L) s) = (algebraMap R M) (hSR s)

full_name: IsAlgClosure.equivOfEquiv_symm_algebraMap
code: @[simp]
theorem equivOfEquiv_symm_algebraMap (hSR : S ≃+* R) (r : R) :
    (equivOfEquiv L M hSR).symm (algebraMap R M r) = algebraMap S L (hSR.symm r) 
goal: (IsAlgClosure.equivOfEquiv L M hSR).symm ((algebraMap R M) r) = (algebraMap S L) (hSR.symm r)

full_name: IsAlgClosure.equivOfEquiv_symm_comp_algebraMap
code: @[simp]
theorem equivOfEquiv_symm_comp_algebraMap (hSR : S ≃+* R) :
    ((equivOfEquiv L M hSR).symm : M →+* L).comp (algebraMap R M) =
      (algebraMap S L).comp hSR.symm 
goal: (↑(IsAlgClosure.equivOfEquiv L M hSR).symm).comp (algebraMap R M) = (algebraMap S L).comp ↑hSR.symm

full_name: Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly
code: /-- Let `A` be an algebraically closed field and let `x ∈ K`, with `K/F` an algebraic extension
  of fields. Then the images of `x` by the `F`-algebra morphisms from `K` to `A` are exactly
  the roots in `A` of the minimal polynomial of `x` over `F`. -/
theorem Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly [IsAlgClosed A] (x : K) :
    (Set.range fun ψ : K →ₐ[F] A ↦ ψ x) = (minpoly F x).rootSet A 
goal: (Set.range fun ψ => ψ x) = (minpoly F x).rootSet A

full_name: IntermediateField.algHomEquivAlgHomOfSplits
code: /-- All `F`-embeddings of a field `K` into another field `A` factor through any intermediate
field of `A/F` in which the minimal polynomial of elements of `K` splits. -/
@[simps]
def IntermediateField.algHomEquivAlgHomOfSplits (L : IntermediateField F A)
    (hL : ∀ x : K, (minpoly F x).Splits (algebraMap F L)) :
    (K →ₐ[F] L) ≃ (K →ₐ[F] A) 
goal: (K →ₐ[F] ↥L) ≃ (K →ₐ[F] A)

full_name: IntermediateField.algHomEquivAlgHomOfSplits_symm_apply
code: /-- All `F`-embeddings of a field `K` into another field `A` factor through any intermediate
field of `A/F` in which the minimal polynomial of elements of `K` splits. -/
@[simps]
def IntermediateField.algHomEquivAlgHomOfSplits (L : IntermediateField F A)
    (hL : ∀ x : K, (minpoly F x).Splits (algebraMap F L)) :
    (K →ₐ[F] L) ≃ (K →ₐ[F] A) 
goal: (IntermediateField.algHomEquivAlgHomOfSplits A L hL).symm f = f.codRestrict L.toSubalgebra ⋯

full_name: IntermediateField.algHomEquivAlgHomOfSplits_apply
code: /-- All `F`-embeddings of a field `K` into another field `A` factor through any intermediate
field of `A/F` in which the minimal polynomial of elements of `K` splits. -/
@[simps]
def IntermediateField.algHomEquivAlgHomOfSplits (L : IntermediateField F A)
    (hL : ∀ x : K, (minpoly F x).Splits (algebraMap F L)) :
    (K →ₐ[F] L) ≃ (K →ₐ[F] A) 
goal: (IntermediateField.algHomEquivAlgHomOfSplits A L hL) φ₂ = L.val.comp φ₂

full_name: IntermediateField.algHomEquivAlgHomOfSplits_apply_apply
code: theorem IntermediateField.algHomEquivAlgHomOfSplits_apply_apply (L : IntermediateField F A)
    (hL : ∀ x : K, (minpoly F x).Splits (algebraMap F L)) (f : K →ₐ[F] L) (x : K) :
    algHomEquivAlgHomOfSplits A L hL f x = algebraMap L A (f x) 
goal: ((IntermediateField.algHomEquivAlgHomOfSplits A L hL) f) x = (algebraMap (↥L) A) (f x)

full_name: Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits
code: /-- All `F`-embeddings of a field `K` into another field `A` factor through any subextension
of `A/F` in which the minimal polynomial of elements of `K` splits. -/
noncomputable def Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits (L : Type*) [Field L]
    [Algebra F L] [Algebra L A] [IsScalarTower F L A]
    (hL : ∀ x : K, (minpoly F x).Splits (algebraMap F L)) :
    (K →ₐ[F] L) ≃ (K →ₐ[F] A) 
goal: (K →ₐ[F] L) ≃ (K →ₐ[F] A)

full_name: Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits_apply_apply
code: theorem Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits_apply_apply (L : Type*) [Field L]
    [Algebra F L] [Algebra L A] [IsScalarTower F L A]
    (hL : ∀ x : K, (minpoly F x).Splits (algebraMap F L)) (f : K →ₐ[F] L) (x : K) :
    Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits A L hL f x = algebraMap L A (f x) 
goal: ((Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits A L hL) f) x = (algebraMap L A) (f x)