l3lab/ntp-mathlib huggingface dataset:
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  

Proof state:
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
⊢ P γ

Next tactic:
have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
    apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
    simp only [map_zero, _root_.map_eq_zero]
    -- Porting note: end of the proof was `exact minpoly.aeval F γ`.
    apply Subtype.val_injective
    -- This used to be `simp`, but we need `erw` and `simp` after leanprover/lean4#2644
    erw [Polynomial.aeval_subalgebra_coe (minpoly F γ)]
    simp
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    

Proof state:
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
⊢ minpoly F γ = minpoly F (f { val := γ, property := hγ })

Next tactic:
refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    

Proof state:
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
⊢ (aeval (f { val := γ, property := hγ })) (minpoly F γ) = 0

Next tactic:
suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      

Proof state:
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
this : (aeval { val := γ, property := hγ }) (minpoly F γ) = 0
⊢ (aeval (f { val := γ, property := hγ })) (minpoly F γ) = 0

Next tactic:
rw [aeval_algHom_apply, this, AlgHom.map_zero]
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    

Proof state:
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
⊢ (aeval { val := γ, property := hγ }) (minpoly F γ) = 0

Next tactic:
haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
    

Proof state:
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
this : Algebra ↥F⟮α, β⟯ ↥(solvableByRad F E)
⊢ (aeval { val := γ, property := hγ }) (minpoly F γ) = 0

Next tactic:
apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
    apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
    

Proof state:
case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
this : Algebra ↥F⟮α, β⟯ ↥(solvableByRad F E)
⊢ (algebraMap ↥F⟮α, β⟯ ↥(solvableByRad F E)) ((aeval { val := γ, property := hγ }) (minpoly F γ)) =
    (algebraMap ↥F⟮α, β⟯ ↥(solvableByRad F E)) 0

Next tactic:
simp only [map_zero, _root_.map_eq_zero]
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
    apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
    simp only [map_zero, _root_.map_eq_zero]
    -- Porting note: end of the proof was `exact minpoly.aeval F γ`.
    

Proof state:
case a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
this : Algebra ↥F⟮α, β⟯ ↥(solvableByRad F E)
⊢ (aeval { val := γ, property := hγ }) (minpoly F γ) = 0

Next tactic:
apply Subtype.val_injective
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
    apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
    simp only [map_zero, _root_.map_eq_zero]
    -- Porting note: end of the proof was `exact minpoly.aeval F γ`.
    apply Subtype.val_injective
    -- This used to be `simp`, but we need `erw` and `simp` after leanprover/lean4#2644
    

Proof state:
case a.a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
this : Algebra ↥F⟮α, β⟯ ↥(solvableByRad F E)
⊢ ↑((aeval { val := γ, property := hγ }) (minpoly F γ)) = ↑0

Next tactic:
erw [Polynomial.aeval_subalgebra_coe (minpoly F γ)]
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
    apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
    simp only [map_zero, _root_.map_eq_zero]
    -- Porting note: end of the proof was `exact minpoly.aeval F γ`.
    apply Subtype.val_injective
    -- This used to be `simp`, but we need `erw` and `simp` after leanprover/lean4#2644
    erw [Polynomial.aeval_subalgebra_coe (minpoly F γ)]
    

Proof state:
case a.a
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
this : Algebra ↥F⟮α, β⟯ ↥(solvableByRad F E)
⊢ (aeval ↑{ val := γ, property := hγ }) (minpoly F γ) = ↑0

Next tactic:
simp
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
    apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
    simp only [map_zero, _root_.map_eq_zero]
    -- Porting note: end of the proof was `exact minpoly.aeval F γ`.
    apply Subtype.val_injective
    -- This used to be `simp`, but we need `erw` and `simp` after leanprover/lean4#2644
    erw [Polynomial.aeval_subalgebra_coe (minpoly F γ)]
    simp
  

Proof state:
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
key : minpoly F γ = minpoly F (f { val := γ, property := hγ })
⊢ P γ

Next tactic:
rw [P, key]
/-- An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. -/
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
  let p := minpoly F α
  let q := minpoly F β
  have hpq := Polynomial.splits_of_splits_mul _
    (mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
    (SplittingField.splits (p * q))
  let f : ↥F⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
    Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
      intro x hx
      cases' hx with hx hx
      rw [hx]
      exact ⟨isIntegral α, hpq.1⟩
      cases hx
      exact ⟨isIntegral β, hpq.2⟩
  have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
    refine' minpoly.eq_of_irreducible_of_monic
      (minpoly.irreducible (isIntegral γ)) _ (minpoly.monic (isIntegral γ))
    suffices aeval (⟨γ, hγ⟩ : F⟮α, β⟯) (minpoly F γ) = 0 by
      rw [aeval_algHom_apply, this, AlgHom.map_zero]
    -- Porting note: this instance is needed for the following `apply`
    haveI := @IntermediateField.toAlgebra F (solvableByRad F E) _ _ _ F⟮α, β⟯
      (solvableByRad F E) _ (Algebra.id (solvableByRad F E))
    apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
    simp only [map_zero, _root_.map_eq_zero]
    -- Porting note: end of the proof was `exact minpoly.aeval F γ`.
    apply Subtype.val_injective
    -- This used to be `simp`, but we need `erw` and `simp` after leanprover/lean4#2644
    erw [Polynomial.aeval_subalgebra_coe (minpoly F γ)]
    simp
  rw [P, key]
  

Proof state:
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α✝ : E
α β γ : ↥(solvableByRad F E)
hγ : γ ∈ F⟮α, β⟯
hα : P α
hβ : P β
p : F[X] := minpoly F α
q : F[X] := minpoly F β
hpq :
  Splits (algebraMap F (SplittingField (p * q))) (minpoly F α) ∧
    Splits (algebraMap F (SplittingField (p * q))) (minpoly F β)
f : ↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q) := Classical.choice (_ : Nonempty (↥F⟮α, β⟯ →ₐ[F] SplittingField (p * q)))
key : minpoly F γ = minpoly F (f { val := γ, property := hγ })
⊢ IsSolvable (Gal (minpoly F (f { val := γ, property := hγ })))

Next tactic:
refine' gal_isSolvable_of_splits ⟨Normal.splits _ (f ⟨γ, hγ⟩)⟩ (gal_mul_isSolvable hα hβ)