Theorem: solvableByRad.induction3
File: Mathlib/FieldTheory/AbelRuffini.lean

tactic: let p := minpoly F (α ^ n)
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
⊢ P α
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
⊢ P α

tactic: apply gal_isSolvable_of_splits
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ P α
state_after: case x
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ Fact (Splits (algebraMap F ?q.SplittingField) (minpoly F α))

case hq
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ IsSolvable ?q.Gal

case q
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ F[X]

tactic: intro h
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
⊢ p.comp (X ^ n) ≠ 0
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
h : p.comp (X ^ n) = 0
⊢ False

tactic: cases' comp_eq_zero_iff.mp h with h' h'
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
h : p.comp (X ^ n) = 0
⊢ False
state_after: case inl
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
h : p.comp (X ^ n) = 0
h' : p = 0
⊢ False

case inr
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
h : p.comp (X ^ n) = 0
h' : eval ((X ^ n).coeff 0) p = 0 ∧ X ^ n = C ((X ^ n).coeff 0)
⊢ False

tactic: exact minpoly.ne_zero (isIntegral (α ^ n)) h'
state_before: case inl
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
h : p.comp (X ^ n) = 0
h' : p = 0
⊢ False
state_after: no goals

tactic: exact hn (by rw [← @natDegree_C F, ← h'.2, natDegree_X_pow])
state_before: case inr
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
h : p.comp (X ^ n) = 0
h' : eval ((X ^ n).coeff 0) p = 0 ∧ X ^ n = C ((X ^ n).coeff 0)
⊢ False
state_after: no goals

tactic: rw [← @natDegree_C F, ← h'.2, natDegree_X_pow]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
h : p.comp (X ^ n) = 0
h' : eval ((X ^ n).coeff 0) p = 0 ∧ X ^ n = C ((X ^ n).coeff 0)
⊢ n = 0
state_after: no goals

tactic: exact ⟨splits_of_splits_of_dvd _ hp (SplittingField.splits (p.comp (X ^ n)))
  (minpoly.dvd F α (by rw [aeval_comp, aeval_X_pow, minpoly.aeval]))⟩
state_before: case x
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ Fact (Splits (algebraMap F ?q.SplittingField) (minpoly F α))
state_after: no goals

tactic: rw [aeval_comp, aeval_X_pow, minpoly.aeval]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ (aeval α) (p.comp (X ^ n)) = 0
state_after: no goals

tactic: refine gal_isSolvable_tower p (p.comp (X ^ n)) ?_ hα ?_
state_before: case hq
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ IsSolvable (p.comp (X ^ n)).Gal
state_after: case hq.refine_1
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ Splits (algebraMap F (p.comp (X ^ n)).SplittingField) p

case hq.refine_2
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ IsSolvable (Polynomial.map (algebraMap F p.SplittingField) (p.comp (X ^ n))).Gal

tactic: exact Gal.splits_in_splittingField_of_comp _ _ (by rwa [natDegree_X_pow])
state_before: case hq.refine_1
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ Splits (algebraMap F (p.comp (X ^ n)).SplittingField) p
state_after: no goals

tactic: rwa [natDegree_X_pow]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ (X ^ n).natDegree ≠ 0
state_after: no goals

tactic: obtain ⟨s, hs⟩ := (splits_iff_exists_multiset _).1 (SplittingField.splits p)
state_before: case hq.refine_2
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
⊢ IsSolvable (Polynomial.map (algebraMap F p.SplittingField) (p.comp (X ^ n))).Gal
state_after: case hq.refine_2.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ IsSolvable (Polynomial.map (algebraMap F p.SplittingField) (p.comp (X ^ n))).Gal

tactic: rw [map_comp, Polynomial.map_pow, map_X, hs, mul_comp, C_comp]
state_before: case hq.refine_2.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ IsSolvable (Polynomial.map (algebraMap F p.SplittingField) (p.comp (X ^ n))).Gal
state_after: case hq.refine_2.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ IsSolvable
    (C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod.comp (X ^ n)).Gal

tactic: apply gal_mul_isSolvable (gal_C_isSolvable _)
state_before: case hq.refine_2.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ IsSolvable
    (C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod.comp (X ^ n)).Gal
state_after: case hq.refine_2.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ IsSolvable ((Multiset.map (fun a => X - C a) s).prod.comp (X ^ n)).Gal

tactic: rw [multiset_prod_comp]
state_before: case hq.refine_2.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ IsSolvable ((Multiset.map (fun a => X - C a) s).prod.comp (X ^ n)).Gal
state_after: case hq.refine_2.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ IsSolvable (Multiset.map (fun p_1 => p_1.comp (X ^ n)) (Multiset.map (fun a => X - C a) s)).prod.Gal

tactic: apply gal_prod_isSolvable
state_before: case hq.refine_2.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ IsSolvable (Multiset.map (fun p_1 => p_1.comp (X ^ n)) (Multiset.map (fun a => X - C a) s)).prod.Gal
state_after: case hq.refine_2.intro.hs
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ ∀ p_1 ∈ Multiset.map (fun p_2 => p_2.comp (X ^ n)) (Multiset.map (fun a => X - C a) s), IsSolvable p_1.Gal

tactic: intro q hq
state_before: case hq.refine_2.intro.hs
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ ∀ p_1 ∈ Multiset.map (fun p_2 => p_2.comp (X ^ n)) (Multiset.map (fun a => X - C a) s), IsSolvable p_1.Gal
state_after: case hq.refine_2.intro.hs
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField[X]
hq : q ∈ Multiset.map (fun p_1 => p_1.comp (X ^ n)) (Multiset.map (fun a => X - C a) s)
⊢ IsSolvable q.Gal

tactic: rw [Multiset.mem_map] at hq
state_before: case hq.refine_2.intro.hs
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField[X]
hq : q ∈ Multiset.map (fun p_1 => p_1.comp (X ^ n)) (Multiset.map (fun a => X - C a) s)
⊢ IsSolvable q.Gal
state_after: case hq.refine_2.intro.hs
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField[X]
hq : ∃ a ∈ Multiset.map (fun a => X - C a) s, a.comp (X ^ n) = q
⊢ IsSolvable q.Gal

tactic: obtain ⟨q, hq, rfl⟩ := hq
state_before: case hq.refine_2.intro.hs
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField[X]
hq : ∃ a ∈ Multiset.map (fun a => X - C a) s, a.comp (X ^ n) = q
⊢ IsSolvable q.Gal
state_after: case hq.refine_2.intro.hs.intro.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField[X]
hq : q ∈ Multiset.map (fun a => X - C a) s
⊢ IsSolvable (q.comp (X ^ n)).Gal

tactic: rw [Multiset.mem_map] at hq
state_before: case hq.refine_2.intro.hs.intro.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField[X]
hq : q ∈ Multiset.map (fun a => X - C a) s
⊢ IsSolvable (q.comp (X ^ n)).Gal
state_after: case hq.refine_2.intro.hs.intro.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField[X]
hq : ∃ a ∈ s, X - C a = q
⊢ IsSolvable (q.comp (X ^ n)).Gal

tactic: obtain ⟨q, _, rfl⟩ := hq
state_before: case hq.refine_2.intro.hs.intro.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField[X]
hq : ∃ a ∈ s, X - C a = q
⊢ IsSolvable (q.comp (X ^ n)).Gal
state_after: case hq.refine_2.intro.hs.intro.intro.intro.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField
left✝ : q ∈ s
⊢ IsSolvable ((X - C q).comp (X ^ n)).Gal

tactic: rw [sub_comp, X_comp, C_comp]
state_before: case hq.refine_2.intro.hs.intro.intro.intro.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField
left✝ : q ∈ s
⊢ IsSolvable ((X - C q).comp (X ^ n)).Gal
state_after: case hq.refine_2.intro.hs.intro.intro.intro.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField
left✝ : q ∈ s
⊢ IsSolvable (X ^ n - C q).Gal

tactic: exact gal_X_pow_sub_C_isSolvable n q
state_before: case hq.refine_2.intro.hs.intro.intro.intro.intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α : ↥(solvableByRad F E)
n : ℕ
hn : n ≠ 0
hα : P (α ^ n)
p : F[X] := minpoly F (α ^ n)
hp : p.comp (X ^ n) ≠ 0
s : Multiset p.SplittingField
hs :
  Polynomial.map (algebraMap F p.SplittingField) p =
    C ((algebraMap F p.SplittingField) p.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
q : p.SplittingField
left✝ : q ∈ s
⊢ IsSolvable (X ^ n - C q).Gal
state_after: no goals