-- Mathlib/FieldTheory/AbelRuffini.lean
theorem splits_X_pow_sub_one_of_X_pow_sub_C {F : Type*} [Field F] {E : Type*} [Field E]
    (i : F →+* E) (n : ℕ) {a : F} (ha : a ≠ 0) (h : (X ^ n - C a).Splits i) :
    (X ^ n - 1 : F[X]).Splits i

Proof state:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b ≠ 0
s : Multiset E := (Polynomial.map i (X ^ n - C a)).roots
⊢ Splits i (X ^ n - 1)

Tactic:
have hs : _ = _ * (s.map _).prod := eq_prod_roots_of_splits h

Result:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b ≠ 0
s : Multiset E := (Polynomial.map i (X ^ n - C a)).roots
hs : Polynomial.map i (X ^ n - C a) = C (i (X ^ n - C a).leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ Splits i (X ^ n - 1)

Proof state:
case pos
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : n = 0
⊢ Splits i (X ^ n - 1)

Tactic:
rw [hn, pow_zero, sub_self]

Result:
case pos
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : n = 0
⊢ Splits i 0

Proof state:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b ≠ 0
s : Multiset E := (Polynomial.map i (X ^ n - C a)).roots
hs : Polynomial.map i (X ^ n - C a) = (Multiset.map (fun a => X - C a) s).prod
hs' : s.card = n
C_mul_C : C (i a⁻¹) * C (i a) = 1
key1 : Polynomial.map i (X ^ n - 1) = C (i a⁻¹) * (Polynomial.map i (X ^ n - C a)).comp (C b * X)
key2 : ((fun q => q.comp (C b * X)) ∘ fun c => X - C c) = fun c => C b * (X - C (c / b))
⊢ (Multiset.map (fun c => X - C (c / b)) s).prod = (Multiset.map ((fun a => X - C a) ∘ fun c => c / b) s).prod

Tactic:
rfl

Result:
no goals

Proof state:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : eval₂ i b (X ^ n - C a) = 0
⊢ Splits i (X ^ n - 1)

Tactic:
rw [eval₂_sub, eval₂_X_pow, eval₂_C, sub_eq_zero] at hb

Result:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
⊢ Splits i (X ^ n - 1)

Proof state:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b ≠ 0
s : Multiset E := (Polynomial.map i (X ^ n - C a)).roots
hs : Polynomial.map i (X ^ n - C a) = (Multiset.map (fun a => X - C a) s).prod
hs' : s.card = n
C_mul_C : C (i a⁻¹) * C (i a) = 1
key1 : Polynomial.map i (X ^ n - 1) = C (i a⁻¹) * (Polynomial.map i (X ^ n - C a)).comp (C b * X)
⊢ Polynomial.map i (X ^ n - 1) = (Multiset.map ((fun a => X - C a) ∘ fun c => c / b) s).prod

Tactic:
have key2 : ((fun q : E[X] => q.comp (C b * X)) ∘ fun c : E => X - C c) = fun c : E =>
    C b * (X - C (c / b)) := by
  ext1 c
  dsimp only [Function.comp_apply]
  rw [sub_comp, X_comp, C_comp, mul_sub, ← C_mul, mul_div_cancel₀ c hb']

Result:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b ≠ 0
s : Multiset E := (Polynomial.map i (X ^ n - C a)).roots
hs : Polynomial.map i (X ^ n - C a) = (Multiset.map (fun a => X - C a) s).prod
hs' : s.card = n
C_mul_C : C (i a⁻¹) * C (i a) = 1
key1 : Polynomial.map i (X ^ n - 1) = C (i a⁻¹) * (Polynomial.map i (X ^ n - C a)).comp (C b * X)
key2 : ((fun q => q.comp (C b * X)) ∘ fun c => X - C c) = fun c => C b * (X - C (c / b))
⊢ Polynomial.map i (X ^ n - 1) = (Multiset.map ((fun a => X - C a) ∘ fun c => c / b) s).prod

Proof state:
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b = 0
⊢ False

Tactic:
rw [hb', zero_pow hn] at hb

Result:
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : 0 = i a
hb' : b = 0
⊢ False

Proof state:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
⊢ Splits i (X ^ n - 1)

Tactic:
have hb' : b ≠ 0 := by
  intro hb'
  rw [hb', zero_pow hn] at hb
  exact ha' hb.symm

Result:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b ≠ 0
⊢ Splits i (X ^ n - 1)

Proof state:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b ≠ 0
s : Multiset E := (Polynomial.map i (X ^ n - C a)).roots
hs : Polynomial.map i (X ^ n - C a) = (Multiset.map (fun a => X - C a) s).prod
hs' : s.card = n
C_mul_C : C (i a⁻¹) * C (i a) = 1
key1 : Polynomial.map i (X ^ n - 1) = C (i a⁻¹) * (Polynomial.map i (X ^ n - C a)).comp (C b * X)
key2 : ((fun q => q.comp (C b * X)) ∘ fun c => X - C c) = fun c => C b * (X - C (c / b))
⊢ Polynomial.map i (X ^ n - 1) = (Multiset.map ((fun a => X - C a) ∘ fun c => c / b) s).prod

Tactic:
rw [key1, hs, multiset_prod_comp, Multiset.map_map, key2, Multiset.prod_map_mul,
  Function.const_def (α := E) (y := C b), Multiset.map_const, Multiset.prod_replicate,
  hs', ← C_pow, hb, ← mul_assoc, C_mul_C, one_mul]

Result:
case neg.intro
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
hn' : 0 < n
hn'' : (X ^ n - C a).degree ≠ 0
b : E
hb : b ^ n = i a
hb' : b ≠ 0
s : Multiset E := (Polynomial.map i (X ^ n - C a)).roots
hs : Polynomial.map i (X ^ n - C a) = (Multiset.map (fun a => X - C a) s).prod
hs' : s.card = n
C_mul_C : C (i a⁻¹) * C (i a) = 1
key1 : Polynomial.map i (X ^ n - 1) = C (i a⁻¹) * (Polynomial.map i (X ^ n - C a)).comp (C b * X)
key2 : ((fun q => q.comp (C b * X)) ∘ fun c => X - C c) = fun c => C b * (X - C (c / b))
⊢ (Multiset.map (fun c => X - C (c / b)) s).prod = (Multiset.map ((fun a => X - C a) ∘ fun c => c / b) s).prod

Proof state:
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
⊢ Splits i (X ^ n - 1)

Tactic:
by_cases hn : n = 0

Result:
case pos
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : n = 0
⊢ Splits i (X ^ n - 1)

case neg
F : Type u_3
inst✝¹ : Field F
E : Type u_4
inst✝ : Field E
i : F →+* E
n : ℕ
a : F
ha : a ≠ 0
h : Splits i (X ^ n - C a)
ha' : i a ≠ 0
hn : ¬n = 0
⊢ Splits i (X ^ n - 1)