awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (goal)
Goal:
ι : Type v
α : ι → TopCat
i : ι
x : (↑(α i) : Type (max u v))
rw :
  Eq (α := (↑(∐ α) : Type (max v u)))
    ((ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max v u)), (↑Y : Type (max v u)))) (CC := carrier)
            (sigmaIsoSigma.{v, u} α).inv :
          (a : (↑(of ((i : ι) × (↑(α i) : Type (max u v)))) : Type (max v u))) → (↑(∐ α) : Type (max v u)))
        ((ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max v u)), (↑Y : Type (max v u)))) (CC :=
              carrier) (sigmaIsoSigma.{v, u} α).hom :
            (a : (↑(∐ α) : Type (max v u))) → (↑(of ((i : ι) × (↑(α i) : Type (max u v)))) : Type (max v u)))
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (Y := ∐ α) (Sigma.ι α i) :
              (a : (↑(α i) : Type (max u v))) → (↑(∐ α) : Type (max u v)))
            x)) :
      (↑(∐ α) : Type (max v u)))
    ((ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
            (Y := ∐ α) (Sigma.ι α i) :
          (a : (↑(α i) : Type (max u v))) → (↑(∐ α) : Type (max u v)))
        x :
      (↑(∐ α) : Type (max u v)))
⊢ Eq (α := (↑(∐ α) : Type (max v u)))
    ((ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max v u)), (↑Y : Type (max v u)))) (CC := carrier)
            (sigmaIsoSigma.{v, u} α).inv :
          (a : (↑(of ((i : ι) × (↑(α i) : Type (max u v)))) : Type (max v u))) → (↑(∐ α) : Type (max v u)))
        (Sigma.mk (β := fun (i : ι) ↦ (↑(α i) : Type (max u v))) i x) :
      (↑(∐ α) : Type (max v u)))
    ((ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
            (Y := ∐ α) (Sigma.ι α i) :
          (a : (↑(α i) : Type (max u v))) → (↑(∐ α) : Type (max u v)))
        x :
      (↑(∐ α) : Type (max u v)))
have rw₁ : Eq (α := (↑(∐ α) : Type (max v u)))
  ((@ConcreteCategory.hom _ instCategory (fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) carrier
          (fun (X Y : TopCat) ↦
            (ContinuousMap.instFunLike :
              FunLike C((↑X : Type (max u v)), (↑Y : Type (max u v))) (↑X : Type (max u v)) (↑Y : Type (max u v))))
          _ _ _ ((sigmaIsoSigma.{v, u} α).hom ≫ (sigmaIsoSigma.{v, u} α).inv) :
        (a : (↑(∐ α) : Type (max u v))) → (↑(∐ α) : Type (max u v)))
      ((ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
            carrier) (Y := ∐ α) (Sigma.ι α i) :
          (a : (↑(α i) : Type (max u v))) → (↑(∐ α) : Type (max u v)))
        x) :
    (↑(∐ α) : Type (max u v)))
  ((ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
          (Y := ∐ α) (Sigma.ι α i) :
        (a : (↑(α i) : Type (max u v))) → (↑(∐ α) : Type (max u v)))
      x :
    (↑(∐ α) : Type (max u v)))
Tactic: rw [← sigmaIsoSigma_hom_ι_apply, ← comp_app, ← comp_app, Iso.hom_inv_id,
    Category.comp_id]
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (goal)
Goal:
J : Type v
inst : Category.{w, v} J
X Y : TopCat
S : Cone (pair X Y)
⊢ Eq (α := S.pt ⟶ Functor.obj (pair X Y) { as := WalkingPair.left : Discrete WalkingPair })
    (ofHom
        {
          toFun := fun (s : (↑S.1 : Type u)) ↦
            ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.fst S) :
                  (a : (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.left }) : Type u)) →
                    (↑((pair X Y).obj { as := WalkingPair.left }) : Type u))
                s,
              (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.snd S) :
                  (a :
                      (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.right }) : Type u)) →
                    (↑((pair X Y).obj { as := WalkingPair.right }) : Type u))
                s),
          continuous_toFun := ⋯ : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
      (X.prodBinaryFan Y).π.app { as := WalkingPair.left })
    (S.π.app { as := WalkingPair.left })
have left : Eq (α := S.pt ⟶ X)
  (ofHom
        {
          toFun := fun (s : (↑S.1 : Type u)) ↦
            ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.fst S) :
                  (a : (↑S.pt : Type u)) → (↑X : Type u))
                s,
              (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.snd S) :
                  (a : (↑S.pt : Type u)) → (↑Y : Type u))
                s),
          continuous_toFun := sorry : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
      (X.prodBinaryFan Y).π.app { as := WalkingPair.left } :
    S.pt ⟶ X)
  (S.π.app { as := WalkingPair.left } :
    Functor.obj (Functor.obj (Functor.const (Discrete WalkingPair)) S.pt)
        { as := WalkingPair.left : Discrete WalkingPair } ⟶
      Functor.obj (pair X Y) { as := WalkingPair.left : Discrete WalkingPair })
Tactic: dsimp
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (goal)
Goal:
J : Type v
inst : Category.{w, v} J
X Y : TopCat
S : Cone (pair X Y)
⊢ Eq (α := S.pt ⟶ X)
    (ofHom
          {
            toFun := fun (s : (↑S.1 : Type u)) ↦
              ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                      (BinaryFan.fst S) :
                    (a : (↑S.pt : Type u)) → (↑X : Type u))
                  s,
                (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                      (BinaryFan.snd S) :
                    (a : (↑S.pt : Type u)) → (↑Y : Type u))
                  s),
            continuous_toFun := ⋯ : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
        (X.prodBinaryFan Y).π.app { as := WalkingPair.left } :
      S.pt ⟶ X)
    (S.π.app { as := WalkingPair.left } :
      Functor.obj (Functor.obj (Functor.const (Discrete WalkingPair)) S.pt)
          { as := WalkingPair.left : Discrete WalkingPair } ⟶
        Functor.obj (pair X Y) { as := WalkingPair.left : Discrete WalkingPair })
have left : ∀ (x : (↑S.pt : Type u)),
  Eq (α := (↑X : Type u))
    (((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier) (Y := X)
              (ofHom
                    {
                      toFun := fun (s : (↑S.1 : Type u)) ↦
                        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC :=
                                carrier) (BinaryFan.fst S) :
                              (a : (↑S.pt : Type u)) → (↑X : Type u))
                            s,
                          (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC :=
                                carrier) (BinaryFan.snd S) :
                              (a : (↑S.pt : Type u)) → (↑Y : Type u))
                            s),
                      continuous_toFun := sorry : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
                  (X.prodBinaryFan Y).π.app { as := WalkingPair.left } :
                S.pt ⟶ X) :
            C((↑S.pt : Type u), (↑X : Type u))) :
          (a : (↑S.pt : Type u)) → (↑X : Type u))
        x :
      (↑X : Type u))
    (((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier) (X := S.pt)
              (Y := X)
              (S.π.app { as := WalkingPair.left } :
                Functor.obj (Functor.obj (Functor.const (Discrete WalkingPair)) S.pt)
                    { as := WalkingPair.left : Discrete WalkingPair } ⟶
                  Functor.obj (pair X Y) { as := WalkingPair.left : Discrete WalkingPair }) :
            C((↑S.pt : Type u), (↑X : Type u))) :
          (a : (↑S.pt : Type u)) → (↑X : Type u))
        x :
      (↑X : Type u))
Tactic: ext
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (goal)
Goal:
J : Type v
inst : Category.{w, v} J
X Y : TopCat
S : Cone (pair X Y)
⊢ Eq (α := S.pt ⟶ Functor.obj (pair X Y) { as := WalkingPair.left : Discrete WalkingPair })
    (ofHom
        {
          toFun := fun (s : (↑S.1 : Type u)) ↦
            ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.fst S) :
                  (a : (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.left }) : Type u)) →
                    (↑((pair X Y).obj { as := WalkingPair.left }) : Type u))
                s,
              (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.snd S) :
                  (a :
                      (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.right }) : Type u)) →
                    (↑((pair X Y).obj { as := WalkingPair.right }) : Type u))
                s),
          continuous_toFun := ⋯ : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
      (X.prodBinaryFan Y).π.app { as := WalkingPair.left })
    (S.π.app { as := WalkingPair.left })
have left : Eq (α := S.pt ⟶ X)
  (ofHom
        {
          toFun := fun (s : (↑S.1 : Type u)) ↦
            ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.fst S) :
                  (a : (↑S.pt : Type u)) → (↑X : Type u))
                s,
              (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.snd S) :
                  (a : (↑S.pt : Type u)) → (↑Y : Type u))
                s),
          continuous_toFun := sorry : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
      (X.prodBinaryFan Y).π.app { as := WalkingPair.left } :
    S.pt ⟶ X)
  (S.π.app { as := WalkingPair.left } :
    Functor.obj (Functor.obj (Functor.const (Discrete WalkingPair)) S.pt)
        { as := WalkingPair.left : Discrete WalkingPair } ⟶
      Functor.obj (pair X Y) { as := WalkingPair.left : Discrete WalkingPair })
Tactic: {dsimp; ext; rfl}
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (goal)
Goal:
J : Type v
inst : Category.{w, v} J
X Y : TopCat
S : Cone (pair X Y)
⊢ Eq (α := S.pt ⟶ Functor.obj (pair X Y) { as := WalkingPair.right : Discrete WalkingPair })
    (ofHom
        {
          toFun := fun (s : (↑S.1 : Type u)) ↦
            ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.fst S) :
                  (a : (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.left }) : Type u)) →
                    (↑((pair X Y).obj { as := WalkingPair.left }) : Type u))
                s,
              (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.snd S) :
                  (a :
                      (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.right }) : Type u)) →
                    (↑((pair X Y).obj { as := WalkingPair.right }) : Type u))
                s),
          continuous_toFun := ⋯ : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
      (X.prodBinaryFan Y).π.app { as := WalkingPair.right })
    (S.π.app { as := WalkingPair.right })
have right : Eq (α := S.pt ⟶ Y)
  (ofHom
        {
          toFun := fun (s : (↑S.1 : Type u)) ↦
            ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.fst S) :
                  (a : (↑S.pt : Type u)) → (↑X : Type u))
                s,
              (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.snd S) :
                  (a : (↑S.pt : Type u)) → (↑Y : Type u))
                s),
          continuous_toFun := sorry : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
      (X.prodBinaryFan Y).π.app { as := WalkingPair.right } :
    S.pt ⟶ Y)
  (S.π.app { as := WalkingPair.right } :
    Functor.obj (Functor.obj (Functor.const (Discrete WalkingPair)) S.pt)
        { as := WalkingPair.right : Discrete WalkingPair } ⟶
      Functor.obj (pair X Y) { as := WalkingPair.right : Discrete WalkingPair })
Tactic: dsimp
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (goal)
Goal:
J : Type v
inst : Category.{w, v} J
X Y : TopCat
S : Cone (pair X Y)
⊢ Eq (α := S.pt ⟶ Y)
    (ofHom
          {
            toFun := fun (s : (↑S.1 : Type u)) ↦
              ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                      (BinaryFan.fst S) :
                    (a : (↑S.pt : Type u)) → (↑X : Type u))
                  s,
                (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                      (BinaryFan.snd S) :
                    (a : (↑S.pt : Type u)) → (↑Y : Type u))
                  s),
            continuous_toFun := ⋯ : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
        (X.prodBinaryFan Y).π.app { as := WalkingPair.right } :
      S.pt ⟶ Y)
    (S.π.app { as := WalkingPair.right } :
      Functor.obj (Functor.obj (Functor.const (Discrete WalkingPair)) S.pt)
          { as := WalkingPair.right : Discrete WalkingPair } ⟶
        Functor.obj (pair X Y) { as := WalkingPair.right : Discrete WalkingPair })
have right : ∀ (x : (↑S.pt : Type u)),
  Eq (α := (↑Y : Type u))
    (((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier) (Y := Y)
              (ofHom
                    {
                      toFun := fun (s : (↑S.1 : Type u)) ↦
                        ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC :=
                                carrier) (BinaryFan.fst S) :
                              (a : (↑S.pt : Type u)) → (↑X : Type u))
                            s,
                          (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC :=
                                carrier) (BinaryFan.snd S) :
                              (a : (↑S.pt : Type u)) → (↑Y : Type u))
                            s),
                      continuous_toFun := sorry : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
                  (X.prodBinaryFan Y).π.app { as := WalkingPair.right } :
                S.pt ⟶ Y) :
            C((↑S.pt : Type u), (↑Y : Type u))) :
          (a : (↑S.pt : Type u)) → (↑Y : Type u))
        x :
      (↑Y : Type u))
    (((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier) (X := S.pt)
              (Y := Y)
              (S.π.app { as := WalkingPair.right } :
                Functor.obj (Functor.obj (Functor.const (Discrete WalkingPair)) S.pt)
                    { as := WalkingPair.right : Discrete WalkingPair } ⟶
                  Functor.obj (pair X Y) { as := WalkingPair.right : Discrete WalkingPair }) :
            C((↑S.pt : Type u), (↑Y : Type u))) :
          (a : (↑S.pt : Type u)) → (↑Y : Type u))
        x :
      (↑Y : Type u))
Tactic: ext
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (goal)
Goal:
J : Type v
inst : Category.{w, v} J
X Y : TopCat
S : Cone (pair X Y)
⊢ Eq (α := S.pt ⟶ Functor.obj (pair X Y) { as := WalkingPair.right : Discrete WalkingPair })
    (ofHom
        {
          toFun := fun (s : (↑S.1 : Type u)) ↦
            ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.fst S) :
                  (a : (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.left }) : Type u)) →
                    (↑((pair X Y).obj { as := WalkingPair.left }) : Type u))
                s,
              (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.snd S) :
                  (a :
                      (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.right }) : Type u)) →
                    (↑((pair X Y).obj { as := WalkingPair.right }) : Type u))
                s),
          continuous_toFun := ⋯ : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
      (X.prodBinaryFan Y).π.app { as := WalkingPair.right })
    (S.π.app { as := WalkingPair.right })
have right : Eq (α := S.pt ⟶ Y)
  (ofHom
        {
          toFun := fun (s : (↑S.1 : Type u)) ↦
            ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.fst S) :
                  (a : (↑S.pt : Type u)) → (↑X : Type u))
                s,
              (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                    (BinaryFan.snd S) :
                  (a : (↑S.pt : Type u)) → (↑Y : Type u))
                s),
          continuous_toFun := sorry : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) } ≫
      (X.prodBinaryFan Y).π.app { as := WalkingPair.right } :
    S.pt ⟶ Y)
  (S.π.app { as := WalkingPair.right } :
    Functor.obj (Functor.obj (Functor.const (Discrete WalkingPair)) S.pt)
        { as := WalkingPair.right : Discrete WalkingPair } ⟶
      Functor.obj (pair X Y) { as := WalkingPair.right : Discrete WalkingPair })
Tactic: {dsimp; ext; rfl}
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (goal)
Goal:
J : Type v
inst : Category.{w, v} J
X Y : TopCat
S : Cone (pair X Y)
m : S.pt ⟶ (X.prodBinaryFan Y).pt
h : ∀ (j : Discrete WalkingPair), m ≫ (X.prodBinaryFan Y).π.app j = S.π.app j
⊢ m =
    ofHom
      {
        toFun := fun (s : (↑S.1 : Type u)) ↦
          ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                  (BinaryFan.fst S) :
                (a : (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.left }) : Type u)) →
                  (↑((pair X Y).obj { as := WalkingPair.left }) : Type u))
              s,
            (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
                  (BinaryFan.snd S) :
                (a : (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.right }) : Type u)) →
                  (↑((pair X Y).obj { as := WalkingPair.right }) : Type u))
              s),
        continuous_toFun := ⋯ }
have w : ∀ (x : (↑S.pt : Type u)),
  Eq (α := (↑(X.prodBinaryFan Y).pt : Type u))
    ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier) m :
          (a : (↑S.pt : Type u)) → (↑(X.prodBinaryFan Y).pt : Type u))
        x :
      (↑(X.prodBinaryFan Y).pt : Type u))
    ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
            (ofHom
              {
                toFun := fun (s : (↑S.1 : Type u)) ↦
                  ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC :=
                          carrier) (BinaryFan.fst S) :
                        (a :
                            (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.left }) :
                              Type u)) →
                          (↑((pair X Y).obj { as := WalkingPair.left }) : Type u))
                      s,
                    (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC :=
                          carrier) (BinaryFan.snd S) :
                        (a :
                            (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.right }) :
                              Type u)) →
                          (↑((pair X Y).obj { as := WalkingPair.right }) : Type u))
                      s),
                continuous_toFun := sorry : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) }) :
          (a : (↑S.pt : Type u)) → (↑(X.prodBinaryFan Y).pt : Type u))
        x :
      (↑(X.prodBinaryFan Y).pt : Type u))
Tactic: ext x
-- Lean 4 proof step from Mathlib.Topology.Category.TopCat.Limits.Products (hypothesis)
Goal:
J : Type v
inst : Category.{w, v} J
X Y : TopCat
S : Cone (pair X Y)
m : S.pt ⟶ (X.prodBinaryFan Y).pt
h : ∀ (j : Discrete WalkingPair), m ≫ (X.prodBinaryFan Y).π.app j = S.π.app j
x : (↑S.pt : Type u)
⊢ Eq.{u + 1} (α := (↑X : Type u))
    ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier) m :
          (a : (↑S.pt : Type u)) → (↑(X.prodBinaryFan Y).pt : Type u))
        x).1
    ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC := carrier)
            (ofHom
              {
                toFun := fun (s : (↑S.1 : Type u)) ↦
                  ((ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC :=
                          carrier) (BinaryFan.fst S) :
                        (a :
                            (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.left }) :
                              Type u)) →
                          (↑((pair X Y).obj { as := WalkingPair.left }) : Type u))
                      s,
                    (ConcreteCategory.hom (FC := fun (X Y : TopCat.{u}) ↦ C((↑X : Type u), (↑Y : Type u))) (CC :=
                          carrier) (BinaryFan.snd S) :
                        (a :
                            (↑(((Functor.const (Discrete WalkingPair)).obj S.pt).obj { as := WalkingPair.right }) :
                              Type u)) →
                          (↑((pair X Y).obj { as := WalkingPair.right }) : Type u))
                      s),
                continuous_toFun := ⋯ : C((↑S.1 : Type u), (↑X : Type u) × (↑Y : Type u)) }) :
          (a : (↑S.pt : Type u)) → (↑(X.prodBinaryFan Y).pt : Type u))
        x).1
have h₁ : Eq (α := S.pt ⟶ Functor.obj (pair X Y) { as := WalkingPair.left : Discrete WalkingPair })
  (m ≫ (X.prodBinaryFan Y).π.app { as := WalkingPair.left }) (S.π.app { as := WalkingPair.left })
Tactic: specialize h ⟨WalkingPair.left⟩
Cleared hypotheses: h