l3lab/ntp-mathlib huggingface dataset:
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
x : ↑S.pt
i✝ j✝ : J
f : i✝ ⟶ j✝
⊢ (F.map f) ((fun j => (S.π.app j) x) i✝) = (fun j => (S.π.app j) x) j✝

Next tactic:
dsimp
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
x : ↑S.pt
i✝ j✝ : J
f : i✝ ⟶ j✝
⊢ (F.map f) ((S.π.app i✝) x) = (S.π.app j✝) x

Next tactic:
erw [← S.w f]
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
x : ↑S.pt
i✝ j✝ : J
f : i✝ ⟶ j✝
⊢ (F.map f) ((S.π.app i✝) x) = (S.π.app i✝ ≫ F.map f) x

Next tactic:
rfl
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
x : ↑S.pt
i j : J
f : i ⟶ j
⊢ (F.map f) ((fun j => (S.π.app j) x) i) = (fun j => (S.π.app j) x) j

Next tactic:
dsimp
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
x : ↑S.pt
i j : J
f : i ⟶ j
⊢ (F.map f) ((S.π.app i) x) = (S.π.app j) x

Next tactic:
rw [← S.w f]
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          rw [← S.w f]
          

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
x : ↑S.pt
i j : J
f : i ⟶ j
⊢ (F.map f) ((S.π.app i) x) = (S.π.app i ≫ F.map f) x

Next tactic:
rfl
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          rw [← S.w f]
          rfl }
  uniq S m h := by
    

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
m : S.pt ⟶ (limitCone F).pt
h : ∀ (j : J), m ≫ (limitCone F).π.app j = S.π.app j
⊢ m =
    (fun S =>
        ContinuousMap.mk fun x =>
          { val := fun j => (S.π.app j) x,
            property :=
              (_ : ∀ {i j : J} (f : i ⟶ j), (F.map f) ((fun j => (S.π.app j) x) i) = (fun j => (S.π.app j) x) j) })
      S

Next tactic:
apply ContinuousMap.ext
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          rw [← S.w f]
          rfl }
  uniq S m h := by
    apply ContinuousMap.ext; 

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
m : S.pt ⟶ (limitCone F).pt
h : ∀ (j : J), m ≫ (limitCone F).π.app j = S.π.app j
⊢ ∀ (a : ↑S.pt),
    m a =
      ((fun S =>
            ContinuousMap.mk fun x =>
              { val := fun j => (S.π.app j) x,
                property :=
                  (_ : ∀ {i j : J} (f : i ⟶ j), (F.map f) ((fun j => (S.π.app j) x) i) = (fun j => (S.π.app j) x) j) })
          S)
        a

Next tactic:
intros a
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          rw [← S.w f]
          rfl }
  uniq S m h := by
    apply ContinuousMap.ext; intros a; 

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
m : S.pt ⟶ (limitCone F).pt
h : ∀ (j : J), m ≫ (limitCone F).π.app j = S.π.app j
a : ↑S.pt
⊢ m a =
    ((fun S =>
          ContinuousMap.mk fun x =>
            { val := fun j => (S.π.app j) x,
              property :=
                (_ : ∀ {i j : J} (f : i ⟶ j), (F.map f) ((fun j => (S.π.app j) x) i) = (fun j => (S.π.app j) x) j) })
        S)
      a

Next tactic:
apply Subtype.ext
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          rw [← S.w f]
          rfl }
  uniq S m h := by
    apply ContinuousMap.ext; intros a; apply Subtype.ext; 

Proof state:
case h.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
m : S.pt ⟶ (limitCone F).pt
h : ∀ (j : J), m ≫ (limitCone F).π.app j = S.π.app j
a : ↑S.pt
⊢ ↑(m a) =
    ↑(((fun S =>
            ContinuousMap.mk fun x =>
              { val := fun j => (S.π.app j) x,
                property :=
                  (_ : ∀ {i j : J} (f : i ⟶ j), (F.map f) ((fun j => (S.π.app j) x) i) = (fun j => (S.π.app j) x) j) })
          S)
        a)

Next tactic:
funext j
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          rw [← S.w f]
          rfl }
  uniq S m h := by
    apply ContinuousMap.ext; intros a; apply Subtype.ext; funext j
    

Proof state:
case h.a.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
m : S.pt ⟶ (limitCone F).pt
h : ∀ (j : J), m ≫ (limitCone F).π.app j = S.π.app j
a : ↑S.pt
j : J
⊢ ↑(m a) j =
    ↑(((fun S =>
              ContinuousMap.mk fun x =>
                { val := fun j => (S.π.app j) x,
                  property :=
                    (_ :
                      ∀ {i j : J} (f : i ⟶ j), (F.map f) ((fun j => (S.π.app j) x) i) = (fun j => (S.π.app j) x) j) })
            S)
          a)
      j

Next tactic:
dsimp
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          rw [← S.w f]
          rfl }
  uniq S m h := by
    apply ContinuousMap.ext; intros a; apply Subtype.ext; funext j
    dsimp
    

Proof state:
case h.a.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
m : S.pt ⟶ (limitCone F).pt
h : ∀ (j : J), m ≫ (limitCone F).π.app j = S.π.app j
a : ↑S.pt
j : J
⊢ ↑(m a) j = (S.π.app j) a

Next tactic:
rw [← h]
/-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitCone.{v,u} F) where
  lift S :=
    { toFun := fun x =>
        ⟨fun j => S.π.app _ x, fun f => by
          dsimp
          erw [← S.w f]
          rfl⟩
      continuous_toFun :=
        Continuous.subtype_mk (continuous_pi <| fun j => (S.π.app j).2) fun x i j f => by
          dsimp
          rw [← S.w f]
          rfl }
  uniq S m h := by
    apply ContinuousMap.ext; intros a; apply Subtype.ext; funext j
    dsimp
    rw [← h]
    

Proof state:
case h.a.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
S : Cone F
m : S.pt ⟶ (limitCone F).pt
h : ∀ (j : J), m ≫ (limitCone F).π.app j = S.π.app j
a : ↑S.pt
j : J
⊢ ↑(m a) j = (m ≫ (limitCone F).π.app j) a

Next tactic:
rfl
/-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitConeInfi.{v,u} F) := by
  

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
⊢ IsLimit (limitConeInfi F)

Next tactic:
refine IsLimit.ofFaithful forget (Types.limitConeIsLimit.{v,u} (F ⋙ forget))
    -- Porting note: previously could infer all ?_ except continuity
    (fun s => ⟨fun v => ⟨ fun j => (Functor.mapCone forget s).π.app j v, ?_⟩, ?_⟩) fun s => ?_
/-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitConeInfi.{v,u} F) := by
  refine IsLimit.ofFaithful forget (Types.limitConeIsLimit.{v,u} (F ⋙ forget))
    -- Porting note: previously could infer all ?_ except continuity
    (fun s => ⟨fun v => ⟨ fun j => (Functor.mapCone forget s).π.app j v, ?_⟩, ?_⟩) fun s => ?_
  · 

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cone F
v : ↑s.pt
⊢ (fun j => (forget.mapCone s).π.app j v) ∈ Functor.sections (F ⋙ forget)

Next tactic:
dsimp [Functor.sections]
/-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitConeInfi.{v,u} F) := by
  refine IsLimit.ofFaithful forget (Types.limitConeIsLimit.{v,u} (F ⋙ forget))
    -- Porting note: previously could infer all ?_ except continuity
    (fun s => ⟨fun v => ⟨ fun j => (Functor.mapCone forget s).π.app j v, ?_⟩, ?_⟩) fun s => ?_
  · dsimp [Functor.sections]
    

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cone F
v : ↑s.pt
⊢ ∀ {j j' : J} (f : j ⟶ j'), forget.map (F.map f) (forget.map (s.π.app j) v) = forget.map (s.π.app j') v

Next tactic:
intro _ _ _
/-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitConeInfi.{v,u} F) := by
  refine IsLimit.ofFaithful forget (Types.limitConeIsLimit.{v,u} (F ⋙ forget))
    -- Porting note: previously could infer all ?_ except continuity
    (fun s => ⟨fun v => ⟨ fun j => (Functor.mapCone forget s).π.app j v, ?_⟩, ?_⟩) fun s => ?_
  · dsimp [Functor.sections]
    intro _ _ _
    

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cone F
v : ↑s.pt
j✝ j'✝ : J
f✝ : j✝ ⟶ j'✝
⊢ forget.map (F.map f✝) (forget.map (s.π.app j✝) v) = forget.map (s.π.app j'✝) v

Next tactic:
rw [← comp_apply', forget_map_eq_coe, ← s.π.naturality, forget_map_eq_coe]
/-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitConeInfi.{v,u} F) := by
  refine IsLimit.ofFaithful forget (Types.limitConeIsLimit.{v,u} (F ⋙ forget))
    -- Porting note: previously could infer all ?_ except continuity
    (fun s => ⟨fun v => ⟨ fun j => (Functor.mapCone forget s).π.app j v, ?_⟩, ?_⟩) fun s => ?_
  · dsimp [Functor.sections]
    intro _ _ _
    rw [← comp_apply', forget_map_eq_coe, ← s.π.naturality, forget_map_eq_coe]
    

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cone F
v : ↑s.pt
j✝ j'✝ : J
f✝ : j✝ ⟶ j'✝
⊢ (((Functor.const J).obj s.pt).map f✝ ≫ s.π.app j'✝) v = (s.π.app j'✝) v

Next tactic:
dsimp
/-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitConeInfi.{v,u} F) := by
  refine IsLimit.ofFaithful forget (Types.limitConeIsLimit.{v,u} (F ⋙ forget))
    -- Porting note: previously could infer all ?_ except continuity
    (fun s => ⟨fun v => ⟨ fun j => (Functor.mapCone forget s).π.app j v, ?_⟩, ?_⟩) fun s => ?_
  · dsimp [Functor.sections]
    intro _ _ _
    rw [← comp_apply', forget_map_eq_coe, ← s.π.naturality, forget_map_eq_coe]
    dsimp
    

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cone F
v : ↑s.pt
j✝ j'✝ : J
f✝ : j✝ ⟶ j'✝
⊢ (𝟙 s.pt ≫ s.π.app j'✝) v = (s.π.app j'✝) v

Next tactic:
rw [Category.id_comp]
/-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitConeInfi.{v,u} F) := by
  refine IsLimit.ofFaithful forget (Types.limitConeIsLimit.{v,u} (F ⋙ forget))
    -- Porting note: previously could infer all ?_ except continuity
    (fun s => ⟨fun v => ⟨ fun j => (Functor.mapCone forget s).π.app j v, ?_⟩, ?_⟩) fun s => ?_
  · dsimp [Functor.sections]
    intro _ _ _
    rw [← comp_apply', forget_map_eq_coe, ← s.π.naturality, forget_map_eq_coe]
    dsimp
    rw [Category.id_comp]
  · 

Proof state:
case refine_2
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cone F
⊢ Continuous fun v =>
    { val := fun j => (forget.mapCone s).π.app j v,
      property := (_ : (fun j => (forget.mapCone s).π.app j v) ∈ Functor.sections (F ⋙ forget)) }

Next tactic:
exact
    continuous_iff_coinduced_le.mpr
      (le_iInf fun j =>
        coinduced_le_iff_le_induced.mp <|
          (continuous_iff_coinduced_le.mp (s.π.app j).continuous : _))
/-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCatMax.{v, u}) : IsLimit (limitConeInfi.{v,u} F) := by
  refine IsLimit.ofFaithful forget (Types.limitConeIsLimit.{v,u} (F ⋙ forget))
    -- Porting note: previously could infer all ?_ except continuity
    (fun s => ⟨fun v => ⟨ fun j => (Functor.mapCone forget s).π.app j v, ?_⟩, ?_⟩) fun s => ?_
  · dsimp [Functor.sections]
    intro _ _ _
    rw [← comp_apply', forget_map_eq_coe, ← s.π.naturality, forget_map_eq_coe]
    dsimp
    rw [Category.id_comp]
  · exact
    continuous_iff_coinduced_le.mpr
      (le_iInf fun j =>
        coinduced_le_iff_le_induced.mp <|
          (continuous_iff_coinduced_le.mp (s.π.app j).continuous : _))
  · 

Proof state:
case refine_3
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cone F
⊢ forget.map
      ((fun s =>
          ContinuousMap.mk fun v =>
            { val := fun j => (forget.mapCone s).π.app j v,
              property := (_ : (fun j => (forget.mapCone s).π.app j v) ∈ Functor.sections (F ⋙ forget)) })
        s) =
    IsLimit.lift (Types.limitConeIsLimit (F ⋙ forget)) (forget.mapCone s)

Next tactic:
rfl
/-- The chosen cocone `TopCat.colimitCocone F` for a functor `F : J ⥤ TopCat` is a colimit cocone.
Generally you should just use `colimit.isColimit F`, unless you need the actual definition
(which is in terms of `Types.colimitCoconeIsColimit`).
-/
def colimitCoconeIsColimit (F : J ⥤ TopCatMax.{v, u}) : IsColimit (colimitCocone F) := by
  

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
⊢ IsColimit (colimitCocone F)

Next tactic:
refine
    IsColimit.ofFaithful forget (Types.colimitCoconeIsColimit _) (fun s =>
    -- Porting note: it appears notation for forget breaks dot notation (also above)
    -- Porting note: previously function was inferred
      ⟨Quot.lift (fun p => (Functor.mapCocone forget s).ι.app p.fst p.snd) ?_, ?_⟩) fun s => ?_
/-- The chosen cocone `TopCat.colimitCocone F` for a functor `F : J ⥤ TopCat` is a colimit cocone.
Generally you should just use `colimit.isColimit F`, unless you need the actual definition
(which is in terms of `Types.colimitCoconeIsColimit`).
-/
def colimitCoconeIsColimit (F : J ⥤ TopCatMax.{v, u}) : IsColimit (colimitCocone F) := by
  refine
    IsColimit.ofFaithful forget (Types.colimitCoconeIsColimit _) (fun s =>
    -- Porting note: it appears notation for forget breaks dot notation (also above)
    -- Porting note: previously function was inferred
      ⟨Quot.lift (fun p => (Functor.mapCocone forget s).ι.app p.fst p.snd) ?_, ?_⟩) fun s => ?_
  · 

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cocone F
⊢ ∀ (a b : (j : J) × (F ⋙ forget).obj j),
    Types.Quot.Rel (F ⋙ forget) a b →
      (fun p => (forget.mapCocone s).ι.app p.fst p.snd) a = (fun p => (forget.mapCocone s).ι.app p.fst p.snd) b

Next tactic:
intro _ _ ⟨_, h⟩
/-- The chosen cocone `TopCat.colimitCocone F` for a functor `F : J ⥤ TopCat` is a colimit cocone.
Generally you should just use `colimit.isColimit F`, unless you need the actual definition
(which is in terms of `Types.colimitCoconeIsColimit`).
-/
def colimitCoconeIsColimit (F : J ⥤ TopCatMax.{v, u}) : IsColimit (colimitCocone F) := by
  refine
    IsColimit.ofFaithful forget (Types.colimitCoconeIsColimit _) (fun s =>
    -- Porting note: it appears notation for forget breaks dot notation (also above)
    -- Porting note: previously function was inferred
      ⟨Quot.lift (fun p => (Functor.mapCocone forget s).ι.app p.fst p.snd) ?_, ?_⟩) fun s => ?_
  · intro _ _ ⟨_, h⟩
    

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cocone F
a✝ b✝ : (j : J) × (F ⋙ forget).obj j
w✝ : a✝.fst ⟶ b✝.fst
h : b✝.snd = (F ⋙ forget).map w✝ a✝.snd
⊢ (fun p => (forget.mapCocone s).ι.app p.fst p.snd) a✝ = (fun p => (forget.mapCocone s).ι.app p.fst p.snd) b✝

Next tactic:
dsimp
/-- The chosen cocone `TopCat.colimitCocone F` for a functor `F : J ⥤ TopCat` is a colimit cocone.
Generally you should just use `colimit.isColimit F`, unless you need the actual definition
(which is in terms of `Types.colimitCoconeIsColimit`).
-/
def colimitCoconeIsColimit (F : J ⥤ TopCatMax.{v, u}) : IsColimit (colimitCocone F) := by
  refine
    IsColimit.ofFaithful forget (Types.colimitCoconeIsColimit _) (fun s =>
    -- Porting note: it appears notation for forget breaks dot notation (also above)
    -- Porting note: previously function was inferred
      ⟨Quot.lift (fun p => (Functor.mapCocone forget s).ι.app p.fst p.snd) ?_, ?_⟩) fun s => ?_
  · intro _ _ ⟨_, h⟩
    dsimp
    

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cocone F
a✝ b✝ : (j : J) × (F ⋙ forget).obj j
w✝ : a✝.fst ⟶ b✝.fst
h : b✝.snd = (F ⋙ forget).map w✝ a✝.snd
⊢ forget.map (s.ι.app a✝.fst) a✝.snd = forget.map (s.ι.app b✝.fst) b✝.snd

Next tactic:
rw [h, Functor.comp_map, ← comp_apply', s.ι.naturality]
/-- The chosen cocone `TopCat.colimitCocone F` for a functor `F : J ⥤ TopCat` is a colimit cocone.
Generally you should just use `colimit.isColimit F`, unless you need the actual definition
(which is in terms of `Types.colimitCoconeIsColimit`).
-/
def colimitCoconeIsColimit (F : J ⥤ TopCatMax.{v, u}) : IsColimit (colimitCocone F) := by
  refine
    IsColimit.ofFaithful forget (Types.colimitCoconeIsColimit _) (fun s =>
    -- Porting note: it appears notation for forget breaks dot notation (also above)
    -- Porting note: previously function was inferred
      ⟨Quot.lift (fun p => (Functor.mapCocone forget s).ι.app p.fst p.snd) ?_, ?_⟩) fun s => ?_
  · intro _ _ ⟨_, h⟩
    dsimp
    rw [h, Functor.comp_map, ← comp_apply', s.ι.naturality]
    

Proof state:
case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
s : Cocone F
a✝ b✝ : (j : J) × (F ⋙ forget).obj j
w✝ : a✝.fst ⟶ b✝.fst
h : b✝.snd = (F ⋙ forget).map w✝ a✝.snd
⊢ forget.map (s.ι.app a✝.fst) a✝.snd = forget.map (s.ι.app a✝.fst ≫ ((Functor.const J).obj s.pt).map w✝) a✝.snd

Next tactic:
dsimp