theorem isSolvable_of_isScalarTower [Normal F K₁] [h1 : IsSolvable (K₁ ≃ₐ[F] K₁)]
    [h2 : IsSolvable (E ≃ₐ[K₁] E)] : IsSolvable (E ≃ₐ[F] E) := by
  let f : (E ≃ₐ[K₁] E) →* E ≃ₐ[F] E :=
    { toFun := fun ϕ =>
        AlgEquiv.ofAlgHom (ϕ.toAlgHom.restrictScalars F) (ϕ.symm.toAlgHom.restrictScalars F)
          (AlgHom.ext fun x => ϕ.apply_symm_apply x) (AlgHom.ext fun x => ϕ.symm_apply_apply x)
      map_one' := AlgEquiv.ext fun _ => rfl
      map_mul' := fun _ _ => AlgEquiv.ext fun _ => rfl }
  

Proof state:
F : Type u_1
K : Type u_2
inst✝¹⁶ : Field F
inst✝¹⁵ : Field K
inst✝¹⁴ : Algebra F K
K₁ : Type u_3
K₂ : Type u_4
K₃ : Type u_5
inst✝¹³ : Field F
inst✝¹² : Field K₁
inst✝¹¹ : Field K₂
inst✝¹⁰ : Field K₃
inst✝⁹ : Algebra F K₁
inst✝⁸ : Algebra F K₂
inst✝⁷ : Algebra F K₃
ϕ : K₁ →ₐ[F] K₂
χ : K₁ ≃ₐ[F] K₂
ψ : K₂ →ₐ[F] K₃
ω : K₂ ≃ₐ[F] K₃
E : Type u_6
inst✝⁶ : Field E
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K₁ E
inst✝³ : Algebra K₂ E
inst✝² : IsScalarTower F K₁ E
inst✝¹ : IsScalarTower F K₂ E
inst✝ : Normal F K₁
h1 : IsSolvable (K₁ ≃ₐ[F] K₁)
h2 : IsSolvable (E ≃ₐ[K₁] E)
f : (E ≃ₐ[K₁] E) →* E ≃ₐ[F] E :=
  {
    toOneHom :=
      {
        toFun := fun ϕ =>
          AlgEquiv.ofAlgHom (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
            (_ :
              AlgHom.comp (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) = AlgHom.id F E)
            (_ :
              AlgHom.comp (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) (AlgHom.restrictScalars F ↑ϕ) = AlgHom.id F E),
        map_one' :=
          (_ :
            (fun ϕ =>
                  AlgEquiv.ofAlgHom (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                    (_ :
                      AlgHom.comp (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) =
                        AlgHom.id F E)
                    (_ :
                      AlgHom.comp (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) (AlgHom.restrictScalars F ↑ϕ) =
                        AlgHom.id F E))
                1 =
              1) },
    map_mul' :=
      (_ :
        ∀ (x x_1 : E ≃ₐ[K₁] E),
          OneHom.toFun
              {
                toFun := fun ϕ =>
                  AlgEquiv.ofAlgHom (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                    (_ :
                      AlgHom.comp (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) =
                        AlgHom.id F E)
                    (_ :
                      AlgHom.comp (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) (AlgHom.restrictScalars F ↑ϕ) =
                        AlgHom.id F E),
                map_one' :=
                  (_ :
                    (fun ϕ =>
                          AlgEquiv.ofAlgHom (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                            (_ :
                              AlgHom.comp (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) =
                                AlgHom.id F E)
                            (_ :
                              AlgHom.comp (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) (AlgHom.restrictScalars F ↑ϕ) =
                                AlgHom.id F E))
                        1 =
                      1) }
              (x * x_1) =
            OneHom.toFun
                {
                  toFun := fun ϕ =>
                    AlgEquiv.ofAlgHom (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                      (_ :
                        AlgHom.comp (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) =
                          AlgHom.id F E)
                      (_ :
                        AlgHom.comp (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) (AlgHom.restrictScalars F ↑ϕ) =
                          AlgHom.id F E),
                  map_one' :=
                    (_ :
                      (fun ϕ =>
                            AlgEquiv.ofAlgHom (AlgHom.restrictScalars F ↑ϕ)
                              (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                              (_ :
                                AlgHom.comp (AlgHom.restrictScalars F ↑ϕ)
                                    (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) =
                                  AlgHom.id F E)
                              (_ :
                                AlgHom.comp (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                                    (AlgHom.restrictScalars F ↑ϕ) =
                                  AlgHom.id F E))
                          1 =
                        1) }
                x *
              OneHom.toFun
                {
                  toFun := fun ϕ =>
                    AlgEquiv.ofAlgHom (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                      (_ :
                        AlgHom.comp (AlgHom.restrictScalars F ↑ϕ) (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) =
                          AlgHom.id F E)
                      (_ :
                        AlgHom.comp (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) (AlgHom.restrictScalars F ↑ϕ) =
                          AlgHom.id F E),
                  map_one' :=
                    (_ :
                      (fun ϕ =>
                            AlgEquiv.ofAlgHom (AlgHom.restrictScalars F ↑ϕ)
                              (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                              (_ :
                                AlgHom.comp (AlgHom.restrictScalars F ↑ϕ)
                                    (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ)) =
                                  AlgHom.id F E)
                              (_ :
                                AlgHom.comp (AlgHom.restrictScalars F ↑(AlgEquiv.symm ϕ))
                                    (AlgHom.restrictScalars F ↑ϕ) =
                                  AlgHom.id F E))
                          1 =
                        1) }
                x_1) }
⊢ IsSolvable (E ≃ₐ[F] E)

Next tactic:
refine'
    solvable_of_ker_le_range f (AlgEquiv.restrictNormalHom K₁) fun ϕ hϕ =>
      ⟨{ ϕ with commutes' := fun x => _ }, AlgEquiv.ext fun _ => rfl⟩