Theorem: Polynomial.exists_finset_of_splits
File: Mathlib/FieldTheory/Separable.lean

tactic: obtain ⟨s, h⟩ := (splits_iff_exists_multiset _).1 sp
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
⊢ ∃ s, map i f = C (i f.leadingCoeff) * ∏ a ∈ s, (X - C a)
state_after: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ ∃ s, map i f = C (i f.leadingCoeff) * ∏ a ∈ s, (X - C a)

tactic: use s.toFinset
state_before: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ ∃ s, map i f = C (i f.leadingCoeff) * ∏ a ∈ s, (X - C a)
state_after: case h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ map i f = C (i f.leadingCoeff) * ∏ a ∈ s.toFinset, (X - C a)

tactic: rw [h, Finset.prod_eq_multiset_prod, ← Multiset.toFinset_eq]
state_before: case h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ map i f = C (i f.leadingCoeff) * ∏ a ∈ s.toFinset, (X - C a)
state_after: case h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ s.Nodup

tactic: apply nodup_of_separable_prod
state_before: case h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ s.Nodup
state_after: case h.hs
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ (Multiset.map (fun a => X - C a) s).prod.Separable

tactic: apply Separable.of_mul_right
state_before: case h.hs
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ (Multiset.map (fun a => X - C a) s).prod.Separable
state_after: case h.hs.h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ (?h.hs.f * (Multiset.map (fun a => X - C a) s).prod).Separable

case h.hs.f
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ K[X]

tactic: rw [← h]
state_before: case h.hs.h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ (?h.hs.f * (Multiset.map (fun a => X - C a) s).prod).Separable

case h.hs.f
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ K[X]
state_after: case h.hs.h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ (map i f).Separable

tactic: exact sep.map
state_before: case h.hs.h
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
i✝ i : F →+* K
f : F[X]
sep : f.Separable
sp : Splits i f
s : Multiset K
h : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
⊢ (map i f).Separable
state_after: no goals