/-- The **Gelfand transform** is an algebra homomorphism (over `𝕜`) from a topological `𝕜`-algebra
`A` into the `𝕜`-algebra of continuous `𝕜`-valued functions on the `characterSpace 𝕜 A`.
The character space itself consists of all algebra homomorphisms from `A` to `𝕜`.  -/
@[simps]
def gelfandTransform : A →ₐ[𝕜] C(characterSpace 𝕜 A, 𝕜) where
  toFun a :=
    { toFun := fun φ => φ a
      continuous_toFun := (eval_continuous a).comp continuous_induced_dom }
  map_one' := by ext a; simp only [coe_mk, coe_one, Pi.one_apply, map_one a]
  map_mul' a b := by ext; simp only [map_mul, coe_mk, coe_mul, Pi.mul_apply]
  map_zero' := by ext; simp only [map_zero, coe_mk, coe_mul, coe_zero, Pi.zero_apply]
  map_add' a b := by ext; simp only [map_add, coe_mk, coe_add, Pi.add_apply]
  commutes' k := by ext; 

Proof state:
case h
𝕜 : Type u_1
A : Type u_2
inst✝⁶ : CommRing 𝕜
inst✝⁵ : NoZeroDivisors 𝕜
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : TopologicalRing 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Semiring A
inst✝ : Algebra 𝕜 A
k : 𝕜
a✝ : ↑(characterSpace 𝕜 A)
⊢ (OneHom.toFun
        (↑↑{
              toMonoidHom :=
                { toOneHom := { toFun := fun a => mk fun φ => φ a, map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) },
                  map_mul' :=
                    (_ :
                      ∀ (a b : A),
                        OneHom.toFun
                            { toFun := fun a => mk fun φ => φ a, map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                            (a * b) =
                          OneHom.toFun
                              { toFun := fun a => mk fun φ => φ a, map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                              a *
                            OneHom.toFun
                              { toFun := fun a => mk fun φ => φ a, map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                              b) },
              map_zero' :=
                (_ :
                  OneHom.toFun
                      (↑{
                          toOneHom :=
                            { toFun := fun a => mk fun φ => φ a, map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) },
                          map_mul' :=
                            (_ :
                              ∀ (a b : A),
                                OneHom.toFun
                                    { toFun := fun a => mk fun φ => φ a,
                                      map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                    (a * b) =
                                  OneHom.toFun
                                      { toFun := fun a => mk fun φ => φ a,
                                        map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                      a *
                                    OneHom.toFun
                                      { toFun := fun a => mk fun φ => φ a,
                                        map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                      b) })
                      0 =
                    0),
              map_add' :=
                (_ :
                  ∀ (a b : A),
                    OneHom.toFun
                        (↑{
                            toOneHom :=
                              { toFun := fun a => mk fun φ => φ a, map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) },
                            map_mul' :=
                              (_ :
                                ∀ (a b : A),
                                  OneHom.toFun
                                      { toFun := fun a => mk fun φ => φ a,
                                        map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                      (a * b) =
                                    OneHom.toFun
                                        { toFun := fun a => mk fun φ => φ a,
                                          map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                        a *
                                      OneHom.toFun
                                        { toFun := fun a => mk fun φ => φ a,
                                          map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                        b) })
                        (a + b) =
                      OneHom.toFun
                          (↑{
                              toOneHom :=
                                { toFun := fun a => mk fun φ => φ a,
                                  map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) },
                              map_mul' :=
                                (_ :
                                  ∀ (a b : A),
                                    OneHom.toFun
                                        { toFun := fun a => mk fun φ => φ a,
                                          map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                        (a * b) =
                                      OneHom.toFun
                                          { toFun := fun a => mk fun φ => φ a,
                                            map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                          a *
                                        OneHom.toFun
                                          { toFun := fun a => mk fun φ => φ a,
                                            map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                          b) })
                          a +
                        OneHom.toFun
                          (↑{
                              toOneHom :=
                                { toFun := fun a => mk fun φ => φ a,
                                  map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) },
                              map_mul' :=
                                (_ :
                                  ∀ (a b : A),
                                    OneHom.toFun
                                        { toFun := fun a => mk fun φ => φ a,
                                          map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                        (a * b) =
                                      OneHom.toFun
                                          { toFun := fun a => mk fun φ => φ a,
                                            map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                          a *
                                        OneHom.toFun
                                          { toFun := fun a => mk fun φ => φ a,
                                            map_one' := (_ : (fun a => mk fun φ => φ a) 1 = 1) }
                                          b) })
                          b) })
        ((algebraMap 𝕜 A) k))
      a✝ =
    ((algebraMap 𝕜 C(↑(characterSpace 𝕜 A), 𝕜)) k) a✝

Next tactic:
simp [AlgHomClass.commutes]