/-- 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 

Proof state:
𝕜 : 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₂ : 𝕜
⊢ 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₂) =
    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₂

Next tactic:
ext