/-- Smooth constant functions as a `RingHom`. -/
def C : 𝕜 →+* C^∞⟮I, N; 𝓘(𝕜, A), A⟯ where
  toFun := fun c : 𝕜 => ⟨fun _ => (algebraMap 𝕜 A) c, smooth_const⟩
  map_one' := by ext; exact (algebraMap 𝕜 A).map_one
  map_mul' c₁ c₂ := by ext; exact (algebraMap 𝕜 A).map_mul _ _
  map_zero' := by ext; exact (algebraMap 𝕜 A).map_zero
  map_add' c₁ c₂ := by ext; 

Proof state:
case h
𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹³ : NormedAddCommGroup E'
inst✝¹² : NormedSpace 𝕜 E'
H : Type u_4
inst✝¹¹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝¹⁰ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
N : Type u_6
inst✝⁹ : TopologicalSpace N
inst✝⁸ : ChartedSpace H N
E'' : Type u_7
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedSpace 𝕜 E''
H'' : Type u_8
inst✝⁵ : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
N' : Type u_9
inst✝⁴ : TopologicalSpace N'
inst✝³ : ChartedSpace H'' N'
A : Type u_10
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : SmoothRing 𝓘(𝕜, A) A
c₁ c₂ : 𝕜
x✝ : N
⊢ (OneHom.toFun
        (↑{
            toOneHom :=
              {
                toFun := fun c =>
                  { val := fun x => (algebraMap 𝕜 A) c,
                    property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                map_one' :=
                  (_ :
                    (fun c =>
                          { val := fun x => (algebraMap 𝕜 A) c,
                            property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                        1 =
                      1) },
            map_mul' :=
              (_ :
                ∀ (c₁ c₂ : 𝕜),
                  OneHom.toFun
                      {
                        toFun := fun c =>
                          { val := fun x => (algebraMap 𝕜 A) c,
                            property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                        map_one' :=
                          (_ :
                            (fun c =>
                                  { val := fun x => (algebraMap 𝕜 A) c,
                                    property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                1 =
                              1) }
                      (c₁ * c₂) =
                    OneHom.toFun
                        {
                          toFun := fun c =>
                            { val := fun x => (algebraMap 𝕜 A) c,
                              property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                          map_one' :=
                            (_ :
                              (fun c =>
                                    { val := fun x => (algebraMap 𝕜 A) c,
                                      property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                  1 =
                                1) }
                        c₁ *
                      OneHom.toFun
                        {
                          toFun := fun c =>
                            { val := fun x => (algebraMap 𝕜 A) c,
                              property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                          map_one' :=
                            (_ :
                              (fun c =>
                                    { val := fun x => (algebraMap 𝕜 A) c,
                                      property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                  1 =
                                1) }
                        c₂) })
        (c₁ + c₂))
      x✝ =
    (OneHom.toFun
          (↑{
              toOneHom :=
                {
                  toFun := fun c =>
                    { val := fun x => (algebraMap 𝕜 A) c,
                      property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                  map_one' :=
                    (_ :
                      (fun c =>
                            { val := fun x => (algebraMap 𝕜 A) c,
                              property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                          1 =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (c₁ c₂ : 𝕜),
                    OneHom.toFun
                        {
                          toFun := fun c =>
                            { val := fun x => (algebraMap 𝕜 A) c,
                              property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                          map_one' :=
                            (_ :
                              (fun c =>
                                    { val := fun x => (algebraMap 𝕜 A) c,
                                      property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                  1 =
                                1) }
                        (c₁ * c₂) =
                      OneHom.toFun
                          {
                            toFun := fun c =>
                              { val := fun x => (algebraMap 𝕜 A) c,
                                property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                            map_one' :=
                              (_ :
                                (fun c =>
                                      { val := fun x => (algebraMap 𝕜 A) c,
                                        property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                    1 =
                                  1) }
                          c₁ *
                        OneHom.toFun
                          {
                            toFun := fun c =>
                              { val := fun x => (algebraMap 𝕜 A) c,
                                property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                            map_one' :=
                              (_ :
                                (fun c =>
                                      { val := fun x => (algebraMap 𝕜 A) c,
                                        property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                    1 =
                                  1) }
                          c₂) })
          c₁ +
        OneHom.toFun
          (↑{
              toOneHom :=
                {
                  toFun := fun c =>
                    { val := fun x => (algebraMap 𝕜 A) c,
                      property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                  map_one' :=
                    (_ :
                      (fun c =>
                            { val := fun x => (algebraMap 𝕜 A) c,
                              property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                          1 =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (c₁ c₂ : 𝕜),
                    OneHom.toFun
                        {
                          toFun := fun c =>
                            { val := fun x => (algebraMap 𝕜 A) c,
                              property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                          map_one' :=
                            (_ :
                              (fun c =>
                                    { val := fun x => (algebraMap 𝕜 A) c,
                                      property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                  1 =
                                1) }
                        (c₁ * c₂) =
                      OneHom.toFun
                          {
                            toFun := fun c =>
                              { val := fun x => (algebraMap 𝕜 A) c,
                                property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                            map_one' :=
                              (_ :
                                (fun c =>
                                      { val := fun x => (algebraMap 𝕜 A) c,
                                        property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                    1 =
                                  1) }
                          c₁ *
                        OneHom.toFun
                          {
                            toFun := fun c =>
                              { val := fun x => (algebraMap 𝕜 A) c,
                                property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) },
                            map_one' :=
                              (_ :
                                (fun c =>
                                      { val := fun x => (algebraMap 𝕜 A) c,
                                        property := (_ : Smooth I 𝓘(𝕜, A) fun x => (algebraMap 𝕜 A) c) })
                                    1 =
                                  1) }
                          c₂) })
          c₂)
      x✝

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