l3lab/ntp-mathlib huggingface dataset:
theorem of_exists_root (H : ∀ p : k[X], p.Monic → Irreducible p → ∃ x, p.eval x = 0) :
    IsAlgClosed k := by
  refine ⟨fun p ↦ Or.inr ?_⟩
  intro q hq _
  have : Irreducible (q * C (leadingCoeff q)⁻¹) := by
    rw [← coe_normUnit_of_ne_zero hq.ne_zero]
    exact (associated_normalize _).irreducible hq
  obtain ⟨x, hx⟩ := H (q * C (leadingCoeff q)⁻¹) (monic_mul_leadingCoeff_inv hq.ne_zero) this
  

Proof state:
case intro
k : Type u
inst✝ : Field k
H : ∀ (p : k[X]), Monic p → Irreducible p → ∃ x, eval x p = 0
p q : k[X]
hq : Irreducible q
a✝ : q ∣ map (RingHom.id k) p
this : Irreducible (q * C (leadingCoeff q)⁻¹)
x : k
hx : eval x (q * C (leadingCoeff q)⁻¹) = 0
⊢ degree q = 1

Next tactic:
exact degree_mul_leadingCoeff_inv q hq.ne_zero ▸ degree_eq_one_of_irreducible_of_root this hx
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  

Proof state:
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
⊢ IsAlgClosed k'

Next tactic:
apply IsAlgClosed.of_exists_root
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  

Proof state:
case H
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
⊢ ∀ (p : k'[X]), Monic p → Irreducible p → ∃ x, eval x p = 0

Next tactic:
intro p hmp hp
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  

Proof state:
case H
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
⊢ ∃ x, eval x p = 0

Next tactic:
have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    

Proof state:
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
⊢ degree (map (RingEquiv.toRingHom (RingEquiv.symm e)) p) ≠ 0

Next tactic:
rw [degree_map]
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    

Proof state:
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
⊢ degree p ≠ 0

Next tactic:
exact ne_of_gt (degree_pos_of_irreducible hp)
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  

Proof state:
case H
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
hpe : degree (map (RingEquiv.toRingHom (RingEquiv.symm e)) p) ≠ 0
⊢ ∃ x, eval x p = 0

Next tactic:
rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  

Proof state:
case H.intro
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
hpe : degree (map (RingEquiv.toRingHom (RingEquiv.symm e)) p) ≠ 0
x : k
hx : IsRoot (map (↑(RingEquiv.symm e)) p) x
⊢ ∃ x, eval x p = 0

Next tactic:
use e x
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  use e x
  

Proof state:
case h
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
hpe : degree (map (RingEquiv.toRingHom (RingEquiv.symm e)) p) ≠ 0
x : k
hx : IsRoot (map (↑(RingEquiv.symm e)) p) x
⊢ eval (e x) p = 0

Next tactic:
rw [IsRoot] at hx
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  use e x
  rw [IsRoot] at hx
  

Proof state:
case h
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
hpe : degree (map (RingEquiv.toRingHom (RingEquiv.symm e)) p) ≠ 0
x : k
hx : eval x (map (↑(RingEquiv.symm e)) p) = 0
⊢ eval (e x) p = 0

Next tactic:
apply e.symm.injective
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  use e x
  rw [IsRoot] at hx
  apply e.symm.injective
  

Proof state:
case h.a
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
hpe : degree (map (RingEquiv.toRingHom (RingEquiv.symm e)) p) ≠ 0
x : k
hx : eval x (map (↑(RingEquiv.symm e)) p) = 0
⊢ (RingEquiv.symm e) (eval (e x) p) = (RingEquiv.symm e) 0

Next tactic:
rw [map_zero, ← hx]
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  use e x
  rw [IsRoot] at hx
  apply e.symm.injective
  rw [map_zero, ← hx]
  

Proof state:
case h.a
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
hmp : Monic p
hp : Irreducible p
hpe : degree (map (RingEquiv.toRingHom (RingEquiv.symm e)) p) ≠ 0
x : k
hx : eval x (map (↑(RingEquiv.symm e)) p) = 0
⊢ (RingEquiv.symm e) (eval (e x) p) = eval x (map (↑(RingEquiv.symm e)) p)

Next tactic:
clear hx hpe hp hmp
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  use e x
  rw [IsRoot] at hx
  apply e.symm.injective
  rw [map_zero, ← hx]
  clear hx hpe hp hmp
  

Proof state:
case h.a
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
p : k'[X]
x : k
⊢ (RingEquiv.symm e) (eval (e x) p) = eval x (map (↑(RingEquiv.symm e)) p)

Next tactic:
induction p using Polynomial.induction_on
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  use e x
  rw [IsRoot] at hx
  apply e.symm.injective
  rw [map_zero, ← hx]
  clear hx hpe hp hmp
  induction p using Polynomial.induction_on <;> 

Proof state:
case h.a.h_C
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
x : k
a✝ : k'
⊢ (RingEquiv.symm e) (eval (e x) (C a✝)) = eval x (map (↑(RingEquiv.symm e)) (C a✝))

Next tactic:
simp_all
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  use e x
  rw [IsRoot] at hx
  apply e.symm.injective
  rw [map_zero, ← hx]
  clear hx hpe hp hmp
  induction p using Polynomial.induction_on <;> 

Proof state:
case h.a.h_add
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
x : k
p✝ q✝ : k'[X]
a✝¹ : (RingEquiv.symm e) (eval (e x) p✝) = eval x (map (↑(RingEquiv.symm e)) p✝)
a✝ : (RingEquiv.symm e) (eval (e x) q✝) = eval x (map (↑(RingEquiv.symm e)) q✝)
⊢ (RingEquiv.symm e) (eval (e x) (p✝ + q✝)) = eval x (map (↑(RingEquiv.symm e)) (p✝ + q✝))

Next tactic:
simp_all
theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k' := by
  apply IsAlgClosed.of_exists_root
  intro p hmp hp
  have hpe : degree (p.map e.symm.toRingHom) ≠ 0 := by
    rw [degree_map]
    exact ne_of_gt (degree_pos_of_irreducible hp)
  rcases IsAlgClosed.exists_root (k := k) (p.map e.symm) hpe with ⟨x, hx⟩
  use e x
  rw [IsRoot] at hx
  apply e.symm.injective
  rw [map_zero, ← hx]
  clear hx hpe hp hmp
  induction p using Polynomial.induction_on <;> 

Proof state:
case h.a.h_monomial
k : Type u
inst✝² : Field k
k' : Type u
inst✝¹ : Field k'
e : k ≃+* k'
inst✝ : IsAlgClosed k
x : k
n✝ : ℕ
a✝¹ : k'
a✝ : (RingEquiv.symm e) (eval (e x) (C a✝¹ * X ^ n✝)) = eval x (map (↑(RingEquiv.symm e)) (C a✝¹ * X ^ n✝))
⊢ (RingEquiv.symm e) (eval (e x) (C a✝¹ * X ^ (n✝ + 1))) = eval x (map (↑(RingEquiv.symm e)) (C a✝¹ * X ^ (n✝ + 1)))

Next tactic:
simp_all
theorem algebraMap_surjective_of_isIntegral {k K : Type*} [Field k] [Ring K] [IsDomain K]
    [hk : IsAlgClosed k] [Algebra k K] (hf : Algebra.IsIntegral k K) :
    Function.Surjective (algebraMap k K) := by
  

Proof state:
k✝ : Type u
inst✝⁴ : Field k✝
k : Type u_1
K : Type u_2
inst✝³ : Field k
inst✝² : Ring K
inst✝¹ : IsDomain K
hk : IsAlgClosed k
inst✝ : Algebra k K
hf : Algebra.IsIntegral k K
⊢ Function.Surjective ⇑(algebraMap k K)

Next tactic:
refine' fun x => ⟨-(minpoly k x).coeff 0, _⟩
theorem algebraMap_surjective_of_isIntegral {k K : Type*} [Field k] [Ring K] [IsDomain K]
    [hk : IsAlgClosed k] [Algebra k K] (hf : Algebra.IsIntegral k K) :
    Function.Surjective (algebraMap k K) := by
  refine' fun x => ⟨-(minpoly k x).coeff 0, _⟩
  

Proof state:
k✝ : Type u
inst✝⁴ : Field k✝
k : Type u_1
K : Type u_2
inst✝³ : Field k
inst✝² : Ring K
inst✝¹ : IsDomain K
hk : IsAlgClosed k
inst✝ : Algebra k K
hf : Algebra.IsIntegral k K
x : K
⊢ (algebraMap k K) (-coeff (minpoly k x) 0) = x

Next tactic:
have hq : (minpoly k x).leadingCoeff = 1 := minpoly.monic (hf x)
theorem algebraMap_surjective_of_isIntegral {k K : Type*} [Field k] [Ring K] [IsDomain K]
    [hk : IsAlgClosed k] [Algebra k K] (hf : Algebra.IsIntegral k K) :
    Function.Surjective (algebraMap k K) := by
  refine' fun x => ⟨-(minpoly k x).coeff 0, _⟩
  have hq : (minpoly k x).leadingCoeff = 1 := minpoly.monic (hf x)
  

Proof state:
k✝ : Type u
inst✝⁴ : Field k✝
k : Type u_1
K : Type u_2
inst✝³ : Field k
inst✝² : Ring K
inst✝¹ : IsDomain K
hk : IsAlgClosed k
inst✝ : Algebra k K
hf : Algebra.IsIntegral k K
x : K
hq : leadingCoeff (minpoly k x) = 1
⊢ (algebraMap k K) (-coeff (minpoly k x) 0) = x

Next tactic:
have h : (minpoly k x).degree = 1 := degree_eq_one_of_irreducible k (minpoly.irreducible (hf x))
theorem algebraMap_surjective_of_isIntegral {k K : Type*} [Field k] [Ring K] [IsDomain K]
    [hk : IsAlgClosed k] [Algebra k K] (hf : Algebra.IsIntegral k K) :
    Function.Surjective (algebraMap k K) := by
  refine' fun x => ⟨-(minpoly k x).coeff 0, _⟩
  have hq : (minpoly k x).leadingCoeff = 1 := minpoly.monic (hf x)
  have h : (minpoly k x).degree = 1 := degree_eq_one_of_irreducible k (minpoly.irreducible (hf x))
  

Proof state:
k✝ : Type u
inst✝⁴ : Field k✝
k : Type u_1
K : Type u_2
inst✝³ : Field k
inst✝² : Ring K
inst✝¹ : IsDomain K
hk : IsAlgClosed k
inst✝ : Algebra k K
hf : Algebra.IsIntegral k K
x : K
hq : leadingCoeff (minpoly k x) = 1
h : degree (minpoly k x) = 1
⊢ (algebraMap k K) (-coeff (minpoly k x) 0) = x

Next tactic:
have : aeval x (minpoly k x) = 0 := minpoly.aeval k x
theorem algebraMap_surjective_of_isIntegral {k K : Type*} [Field k] [Ring K] [IsDomain K]
    [hk : IsAlgClosed k] [Algebra k K] (hf : Algebra.IsIntegral k K) :
    Function.Surjective (algebraMap k K) := by
  refine' fun x => ⟨-(minpoly k x).coeff 0, _⟩
  have hq : (minpoly k x).leadingCoeff = 1 := minpoly.monic (hf x)
  have h : (minpoly k x).degree = 1 := degree_eq_one_of_irreducible k (minpoly.irreducible (hf x))
  have : aeval x (minpoly k x) = 0 := minpoly.aeval k x
  

Proof state:
k✝ : Type u
inst✝⁴ : Field k✝
k : Type u_1
K : Type u_2
inst✝³ : Field k
inst✝² : Ring K
inst✝¹ : IsDomain K
hk : IsAlgClosed k
inst✝ : Algebra k K
hf : Algebra.IsIntegral k K
x : K
hq : leadingCoeff (minpoly k x) = 1
h : degree (minpoly k x) = 1
this : (aeval x) (minpoly k x) = 0
⊢ (algebraMap k K) (-coeff (minpoly k x) 0) = x

Next tactic:
rw [eq_X_add_C_of_degree_eq_one h, hq, C_1, one_mul, aeval_add, aeval_X, aeval_C,
    add_eq_zero_iff_eq_neg] at this
theorem algebraMap_surjective_of_isIntegral {k K : Type*} [Field k] [Ring K] [IsDomain K]
    [hk : IsAlgClosed k] [Algebra k K] (hf : Algebra.IsIntegral k K) :
    Function.Surjective (algebraMap k K) := by
  refine' fun x => ⟨-(minpoly k x).coeff 0, _⟩
  have hq : (minpoly k x).leadingCoeff = 1 := minpoly.monic (hf x)
  have h : (minpoly k x).degree = 1 := degree_eq_one_of_irreducible k (minpoly.irreducible (hf x))
  have : aeval x (minpoly k x) = 0 := minpoly.aeval k x
  rw [eq_X_add_C_of_degree_eq_one h, hq, C_1, one_mul, aeval_add, aeval_X, aeval_C,
    add_eq_zero_iff_eq_neg] at this
  

Proof state:
k✝ : Type u
inst✝⁴ : Field k✝
k : Type u_1
K : Type u_2
inst✝³ : Field k
inst✝² : Ring K
inst✝¹ : IsDomain K
hk : IsAlgClosed k
inst✝ : Algebra k K
hf : Algebra.IsIntegral k K
x : K
hq : leadingCoeff (minpoly k x) = 1
h : degree (minpoly k x) = 1
this : x = -(algebraMap k K) (coeff (minpoly k x) 0)
⊢ (algebraMap k K) (-coeff (minpoly k x) 0) = x

Next tactic:
exact (RingHom.map_neg (algebraMap k K) ((minpoly k x).coeff 0)).symm ▸ this.symm
private theorem 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) := by
  

Proof state:
k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
⊢ Algebra.IsAlgebraic (FractionRing R) (FractionRing S)

Next tactic:
letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
private theorem 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) := by
  letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
  

Proof state:
k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
this : IsDomain R := Function.Injective.isDomain (algebraMap R S) (NoZeroSMulDivisors.algebraMap_injective R S)
⊢ Algebra.IsAlgebraic (FractionRing R) (FractionRing S)

Next tactic:
letI : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R _
private theorem 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) := by
  letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
  letI : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R _
  

Proof state:
k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
this✝ : IsDomain R := Function.Injective.isDomain (algebraMap R S) (NoZeroSMulDivisors.algebraMap_injective R S)
this : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R (FractionRing S)
⊢ Algebra.IsAlgebraic (FractionRing R) (FractionRing S)

Next tactic:
have := FractionRing.isScalarTower_liftAlgebra R (FractionRing S)
private theorem 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) := by
  letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
  letI : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R _
  have := FractionRing.isScalarTower_liftAlgebra R (FractionRing S)
  

Proof state:
k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
this✝¹ : IsDomain R := Function.Injective.isDomain (algebraMap R S) (NoZeroSMulDivisors.algebraMap_injective R S)
this✝ : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R (FractionRing S)
this : IsScalarTower R (FractionRing R) (FractionRing S)
⊢ Algebra.IsAlgebraic (FractionRing R) (FractionRing S)

Next tactic:
intro
private theorem 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) := by
  letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
  letI : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R _
  have := FractionRing.isScalarTower_liftAlgebra R (FractionRing S)
  intro
  

Proof state:
k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
this✝¹ : IsDomain R := Function.Injective.isDomain (algebraMap R S) (NoZeroSMulDivisors.algebraMap_injective R S)
this✝ : Algebra (FractionRing R) (FractionRing S) := FractionRing.liftAlgebra R (FractionRing S)
this : IsScalarTower R (FractionRing R) (FractionRing S)
x✝ : FractionRing S
⊢ IsAlgebraic (FractionRing R) x✝

Next tactic:
exact
    (IsFractionRing.isAlgebraic_iff R (FractionRing R) (FractionRing S)).1
      ((IsFractionRing.isAlgebraic_iff' R S (FractionRing S)).1 hS _)
/-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M := by
  

Proof state:
k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
⊢ S →ₐ[R] M

Next tactic:
letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
/-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M := by
  letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
  

Proof state:
k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
this : IsDomain R := Function.Injective.isDomain (algebraMap R S) (NoZeroSMulDivisors.algebraMap_injective R S)
⊢ S →ₐ[R] M

Next tactic:
letI := FractionRing.liftAlgebra R M
/-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M := by
  letI : IsDomain R := (NoZeroSMulDivisors.algebraMap_injective R S).isDomain _
  letI := FractionRing.liftAlgebra R M
  

Proof state:
k : Type u
inst✝¹³ : Field k
K : Type u
inst✝¹² : Field K
L : Type v
M : Type w
inst✝¹¹ : Field L
inst✝¹⁰ : Algebra K L
inst✝⁹ : Field M
inst✝⁸ : Algebra K M
inst✝⁷ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
R : Type u
inst✝⁶ : CommRing R
S : Type v
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Algebra R S
inst✝² : Algebra R M
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : NoZeroSMulDivisors R M
hS : Algebra.IsAlgebraic R S
this✝ : IsDomain R := Function.Injective.isDomain (algebraMap R S) (NoZeroSMulDivisors.algebraMap_injective R S)
this : Algebra (FractionRing R) M := FractionRing.liftAlgebra R M
⊢ S →ₐ[R] M

Next tactic:
letI := FractionRing.liftAlgebra R (FractionRing S)