/-- The canonical ring homomorphism to a step with a greater index. -/
def toStepOfLE (m n : ℕ) (h : m ≤ n) : Step k m →+* Step k n where
  toFun := toStepOfLE' k m n h
  map_one' := by
-- Porting note: original proof was `induction' h with n h ih; · exact Nat.leRecOn_self 1`
--                                   `rw [Nat.leRecOn_succ h, ih, RingHom.map_one]`
    induction' h with a h ih
    · exact Nat.leRecOn_self 1
    · rw [toStepOfLE'.succ k m a h]; simp [ih]
  map_mul' x y := by
-- Porting note: original proof was `induction' h with n h ih; · simp_rw [Nat.leRecOn_self]`
--                                   `simp_rw [Nat.leRecOn_succ h, ih, RingHom.map_mul]`
    induction' h with a h ih
    · dsimp [toStepOfLE']; simp_rw [Nat.leRecOn_self]
    · simp_rw [toStepOfLE'.succ k m a h]; simp only at ih; simp [ih]
-- Porting note: original proof was `induction' h with n h ih; · exact Nat.leRecOn_self 0`
--                                   `rw [Nat.leRecOn_succ h, ih, RingHom.map_zero]`
  map_zero' := by
    induction' h with a h ih
    · exact Nat.leRecOn_self 0
    · simp_rw [toStepOfLE'.succ k m a h]; simp only at ih; simp [ih]
  map_add' x y := by
-- Porting note: original proof was `induction' h with n h ih; · simp_rw [Nat.leRecOn_self]`
--                                   `simp_rw [Nat.leRecOn_succ h, ih, RingHom.map_add]`
    induction' h with a h ih
    · 

Proof state:
case refl
k : Type u
inst✝ : Field k
m n : ℕ
x y : Step k m
⊢ OneHom.toFun
      (↑{
          toOneHom :=
            { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
              map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) },
          map_mul' :=
            (_ :
              ∀ (x y : Step k m),
                OneHom.toFun
                    { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                      map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                    (x * y) =
                  OneHom.toFun
                      { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                        map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                      x *
                    OneHom.toFun
                      { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                        map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                      y) })
      (x + y) =
    OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) },
            map_mul' :=
              (_ :
                ∀ (x y : Step k m),
                  OneHom.toFun
                      { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                        map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                      (x * y) =
                    OneHom.toFun
                        { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                          map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                        x *
                      OneHom.toFun
                        { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                          map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                        y) })
        x +
      OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) },
            map_mul' :=
              (_ :
                ∀ (x y : Step k m),
                  OneHom.toFun
                      { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                        map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                      (x * y) =
                    OneHom.toFun
                        { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                          map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                        x *
                      OneHom.toFun
                        { toFun := AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m),
                          map_one' := (_ : AlgebraicClosure.toStepOfLE' k m m (_ : Nat.le m m) 1 = 1) }
                        y) })
        y

Next tactic:
dsimp [toStepOfLE']