/-- Continuous constant functions as a `RingHom`. -/
def ContinuousMap.C : R →+* C(α, A) where
  toFun := fun c : R => ⟨fun _ : α => (algebraMap R A) c, continuous_const⟩
  map_one' := by ext _; exact (algebraMap R A).map_one
  map_mul' c₁ c₂ := by ext _; exact (algebraMap R A).map_mul _ _
  map_zero' := by ext _; exact (algebraMap R A).map_zero
  map_add' c₁ c₂ := by ext _; 

Proof state:
case h
α : Type u_1
inst✝⁹ : TopologicalSpace α
R : Type u_2
inst✝⁸ : CommSemiring R
A : Type u_3
inst✝⁷ : TopologicalSpace A
inst✝⁶ : Semiring A
inst✝⁵ : Algebra R A
inst✝⁴ : TopologicalSemiring A
A₂ : Type u_4
inst✝³ : TopologicalSpace A₂
inst✝² : Semiring A₂
inst✝¹ : Algebra R A₂
inst✝ : TopologicalSemiring A₂
c₁ c₂ : R
a✝ : α
⊢ (OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := fun c => mk fun x => (algebraMap R A) c,
                map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) },
            map_mul' :=
              (_ :
                ∀ (c₁ c₂ : R),
                  OneHom.toFun
                      { toFun := fun c => mk fun x => (algebraMap R A) c,
                        map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                      (c₁ * c₂) =
                    OneHom.toFun
                        { toFun := fun c => mk fun x => (algebraMap R A) c,
                          map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                        c₁ *
                      OneHom.toFun
                        { toFun := fun c => mk fun x => (algebraMap R A) c,
                          map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                        c₂) })
        (c₁ + c₂))
      a✝ =
    (OneHom.toFun
          (↑{
              toOneHom :=
                { toFun := fun c => mk fun x => (algebraMap R A) c,
                  map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) },
              map_mul' :=
                (_ :
                  ∀ (c₁ c₂ : R),
                    OneHom.toFun
                        { toFun := fun c => mk fun x => (algebraMap R A) c,
                          map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                        (c₁ * c₂) =
                      OneHom.toFun
                          { toFun := fun c => mk fun x => (algebraMap R A) c,
                            map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                          c₁ *
                        OneHom.toFun
                          { toFun := fun c => mk fun x => (algebraMap R A) c,
                            map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                          c₂) })
          c₁ +
        OneHom.toFun
          (↑{
              toOneHom :=
                { toFun := fun c => mk fun x => (algebraMap R A) c,
                  map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) },
              map_mul' :=
                (_ :
                  ∀ (c₁ c₂ : R),
                    OneHom.toFun
                        { toFun := fun c => mk fun x => (algebraMap R A) c,
                          map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                        (c₁ * c₂) =
                      OneHom.toFun
                          { toFun := fun c => mk fun x => (algebraMap R A) c,
                            map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                          c₁ *
                        OneHom.toFun
                          { toFun := fun c => mk fun x => (algebraMap R A) c,
                            map_one' := (_ : (fun c => mk fun x => (algebraMap R A) c) 1 = 1) }
                          c₂) })
          c₂)
      a✝

Next tactic:
exact (algebraMap R A).map_add _ _