/-- Given an algebra between two fields, create an algebra between their two rings of integers. -/
instance inst_ringOfIntegersAlgebra [Algebra K L] : Algebra (𝓞 K) (𝓞 L) :=
  RingHom.toAlgebra
    { toFun := fun k => ⟨algebraMap K L k, IsIntegral.algebraMap k.2⟩
      map_zero' := Subtype.ext <| by simp only [Subtype.coe_mk, Subalgebra.coe_zero, map_zero]
      map_one' := Subtype.ext <| by simp only [Subtype.coe_mk, Subalgebra.coe_one, map_one]
      map_add' := fun x y =>
        Subtype.ext <| by 

Proof state:
K : Type u_1
L : Type u_2
inst✝² : Field K
inst✝¹ : Field L
nf : NumberField K
inst✝ : Algebra K L
x y : ↥(𝓞 K)
⊢ ↑(OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := fun k => { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                map_one' :=
                  (_ :
                    (fun k => { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) }) 1 =
                      1) },
            map_mul' :=
              (_ :
                ∀ (x y : ↥(𝓞 K)),
                  OneHom.toFun
                      {
                        toFun := fun k =>
                          { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                        map_one' :=
                          (_ :
                            (fun k =>
                                  { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                1 =
                              1) }
                      (x * y) =
                    OneHom.toFun
                        {
                          toFun := fun k =>
                            { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                          map_one' :=
                            (_ :
                              (fun k =>
                                    { val := (algebraMap K L) ↑k,
                                      property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                  1 =
                                1) }
                        x *
                      OneHom.toFun
                        {
                          toFun := fun k =>
                            { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                          map_one' :=
                            (_ :
                              (fun k =>
                                    { val := (algebraMap K L) ↑k,
                                      property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                  1 =
                                1) }
                        y) })
        (x + y)) =
    ↑(OneHom.toFun
          (↑{
              toOneHom :=
                {
                  toFun := fun k =>
                    { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                  map_one' :=
                    (_ :
                      (fun k => { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                          1 =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : ↥(𝓞 K)),
                    OneHom.toFun
                        {
                          toFun := fun k =>
                            { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                          map_one' :=
                            (_ :
                              (fun k =>
                                    { val := (algebraMap K L) ↑k,
                                      property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                  1 =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun k =>
                              { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                            map_one' :=
                              (_ :
                                (fun k =>
                                      { val := (algebraMap K L) ↑k,
                                        property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                    1 =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun k =>
                              { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                            map_one' :=
                              (_ :
                                (fun k =>
                                      { val := (algebraMap K L) ↑k,
                                        property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                    1 =
                                  1) }
                          y) })
          x +
        OneHom.toFun
          (↑{
              toOneHom :=
                {
                  toFun := fun k =>
                    { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                  map_one' :=
                    (_ :
                      (fun k => { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                          1 =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : ↥(𝓞 K)),
                    OneHom.toFun
                        {
                          toFun := fun k =>
                            { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                          map_one' :=
                            (_ :
                              (fun k =>
                                    { val := (algebraMap K L) ↑k,
                                      property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                  1 =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun k =>
                              { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                            map_one' :=
                              (_ :
                                (fun k =>
                                      { val := (algebraMap K L) ↑k,
                                        property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                    1 =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun k =>
                              { val := (algebraMap K L) ↑k, property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) },
                            map_one' :=
                              (_ :
                                (fun k =>
                                      { val := (algebraMap K L) ↑k,
                                        property := (_ : IsIntegral ℤ ((algebraMap K L) ↑k)) })
                                    1 =
                                  1) }
                          y) })
          y)

Next tactic:
simp only [map_add, Subalgebra.coe_add, Subtype.coe_mk]