example {G G' : Type u} [TopologicalSpace G] [Group G] [TopologicalGroup G] [TopologicalSpace G']
    [Group G'] [TopologicalGroup G'] : TopologicalGroup.hSpace (G × G') = HSpace.prod G G' := by
  simp only [HSpace.prod]
  

Proof state:
G G' : Type u
inst✝⁵ : TopologicalSpace G
inst✝⁴ : Group G
inst✝³ : TopologicalGroup G
inst✝² : TopologicalSpace G'
inst✝¹ : Group G'
inst✝ : TopologicalGroup G'
⊢ hSpace (G × G') =
    { hmul := ContinuousMap.mk fun p => (HSpace.hmul (p.1.1, p.2.1), HSpace.hmul (p.1.2, p.2.2)),
      e := (HSpace.e, HSpace.e),
      hmul_e_e :=
        (_ :
          (ContinuousMap.mk fun p => (HSpace.hmul (p.1.1, p.2.1), HSpace.hmul (p.1.2, p.2.2)))
              ((HSpace.e, HSpace.e), HSpace.e, HSpace.e) =
            (HSpace.e, HSpace.e)),
      eHmul :=
        {
          toHomotopy :=
            { toContinuousMap := ContinuousMap.mk fun p => (HSpace.eHmul (p.1, p.2.1), HSpace.eHmul (p.1, p.2.2)),
              map_zero_left :=
                (_ :
                  ∀ (x : G × G'),
                    ContinuousMap.toFun
                        (ContinuousMap.mk fun p => (HSpace.eHmul (p.1, p.2.1), HSpace.eHmul (p.1, p.2.2))) (0, x) =
                      (comp (ContinuousMap.mk fun p => (HSpace.hmul (p.1.1, p.2.1), HSpace.hmul (p.1.2, p.2.2)))
                          (prodMk (const (G × G') (HSpace.e, HSpace.e)) (ContinuousMap.id (G × G'))))
                        x),
              map_one_left :=
                (_ :
                  ∀ (x : G × G'),
                    ContinuousMap.toFun
                        (ContinuousMap.mk fun p => (HSpace.eHmul (p.1, p.2.1), HSpace.eHmul (p.1, p.2.2))) (1, x) =
                      (ContinuousMap.id (G × G')) x) },
          prop' :=
            (_ :
              ∀ (t : ↑I),
                ∀ x ∈ {(HSpace.e, HSpace.e)},
                  (ContinuousMap.mk fun x =>
                        ContinuousMap.toFun
                          {
                              toContinuousMap :=
                                ContinuousMap.mk fun p => (HSpace.eHmul (p.1, p.2.1), HSpace.eHmul (p.1, p.2.2)),
                              map_zero_left :=
                                (_ :
                                  ∀ (x : G × G'),
                                    ContinuousMap.toFun
                                        (ContinuousMap.mk fun p =>
                                          (HSpace.eHmul (p.1, p.2.1), HSpace.eHmul (p.1, p.2.2)))
                                        (0, x) =
                                      (comp
                                          (ContinuousMap.mk fun p =>
                                            (HSpace.hmul (p.1.1, p.2.1), HSpace.hmul (p.1.2, p.2.2)))
                                          (prodMk (const (G × G') (HSpace.e, HSpace.e)) (ContinuousMap.id (G × G'))))
                                        x),
                              map_one_left :=
                                (_ :
                                  ∀ (x : G × G'),
                                    ContinuousMap.toFun
                                        (ContinuousMap.mk fun p =>
                                          (HSpace.eHmul (p.1, p.2.1), HSpace.eHmul (p.1, p.2.2)))
                                        (1, x) =
                                      (ContinuousMap.id (G × G')) x) }.toContinuousMap
                          (t, x))
                      x =
                    (comp (ContinuousMap.mk fun p => (HSpace.hmul (p.1.1, p.2.1), HSpace.hmul (p.1.2, p.2.2)))
                        (prodMk (const (G × G') (HSpace.e, HSpace.e)) (ContinuousMap.id (G × G'))))
                      x) },
      hmulE :=
        {
          toHomotopy :=
            { toContinuousMap := ContinuousMap.mk fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2)),
              map_zero_left :=
                (_ :
                  ∀ (x : G × G'),
                    ContinuousMap.toFun
                        (ContinuousMap.mk fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2))) (0, x) =
                      (comp (ContinuousMap.mk fun p => (HSpace.hmul (p.1.1, p.2.1), HSpace.hmul (p.1.2, p.2.2)))
                          (prodMk (ContinuousMap.id (G × G')) (const (G × G') (HSpace.e, HSpace.e))))
                        x),
              map_one_left :=
                (_ :
                  ∀ (x : G × G'),
                    ContinuousMap.toFun
                        (ContinuousMap.mk fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2))) (1, x) =
                      (ContinuousMap.id (G × G')) x) },
          prop' :=
            (_ :
              ∀ (t : ↑I),
                ∀ x ∈ {(HSpace.e, HSpace.e)},
                  (ContinuousMap.mk fun x =>
                        ContinuousMap.toFun
                          {
                              toContinuousMap :=
                                ContinuousMap.mk fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2)),
                              map_zero_left :=
                                (_ :
                                  ∀ (x : G × G'),
                                    ContinuousMap.toFun
                                        (ContinuousMap.mk fun p =>
                                          (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2)))
                                        (0, x) =
                                      (comp
                                          (ContinuousMap.mk fun p =>
                                            (HSpace.hmul (p.1.1, p.2.1), HSpace.hmul (p.1.2, p.2.2)))
                                          (prodMk (ContinuousMap.id (G × G')) (const (G × G') (HSpace.e, HSpace.e))))
                                        x),
                              map_one_left :=
                                (_ :
                                  ∀ (x : G × G'),
                                    ContinuousMap.toFun
                                        (ContinuousMap.mk fun p =>
                                          (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2)))
                                        (1, x) =
                                      (ContinuousMap.id (G × G')) x) }.toContinuousMap
                          (t, x))
                      x =
                    (comp (ContinuousMap.mk fun p => (HSpace.hmul (p.1.1, p.2.1), HSpace.hmul (p.1.2, p.2.2)))
                        (prodMk (ContinuousMap.id (G × G')) (const (G × G') (HSpace.e, HSpace.e))))
                      x) } }

Next tactic:
rfl