l3lab/ntp-mathlib huggingface dataset:
/-- (Implementation) The bijection of homsets to establish the reflective adjunction of compact
Hausdorff spaces in topological spaces.
-/
noncomputable def stoneCechEquivalence (X : TopCat.{u}) (Y : CompHaus.{u}) :
    (stoneCechObj X ⟶ Y) ≃ (X ⟶ compHausToTop.obj Y) where
  toFun f :=
    { toFun := f ∘ stoneCechUnit
      continuous_toFun := f.2.comp (@continuous_stoneCechUnit X _) }
  invFun f :=
    { toFun := stoneCechExtend f.2
      continuous_toFun := continuous_stoneCechExtend f.2 }
  left_inv := by
    rintro ⟨f : StoneCech X ⟶ Y, hf : Continuous f⟩
    -- Porting note: `ext` fails.
    apply ContinuousMap.ext
    intro (x : StoneCech X)
    refine' congr_fun _ x
    apply Continuous.ext_on denseRange_stoneCechUnit (continuous_stoneCechExtend _) hf
    rintro _ ⟨y, rfl⟩
    apply congr_fun (stoneCechExtend_extends (hf.comp _)) y
    

Proof state:
X : TopCat
Y : CompHaus
f : StoneCech ↑X ⟶ ↑Y.toTop
hf : Continuous f
x : StoneCech ↑X
⊢ Continuous fun x => stoneCechUnit x

Next tactic:
apply continuous_stoneCechUnit
/-- (Implementation) The bijection of homsets to establish the reflective adjunction of compact
Hausdorff spaces in topological spaces.
-/
noncomputable def stoneCechEquivalence (X : TopCat.{u}) (Y : CompHaus.{u}) :
    (stoneCechObj X ⟶ Y) ≃ (X ⟶ compHausToTop.obj Y) where
  toFun f :=
    { toFun := f ∘ stoneCechUnit
      continuous_toFun := f.2.comp (@continuous_stoneCechUnit X _) }
  invFun f :=
    { toFun := stoneCechExtend f.2
      continuous_toFun := continuous_stoneCechExtend f.2 }
  left_inv := by
    rintro ⟨f : StoneCech X ⟶ Y, hf : Continuous f⟩
    -- Porting note: `ext` fails.
    apply ContinuousMap.ext
    intro (x : StoneCech X)
    refine' congr_fun _ x
    apply Continuous.ext_on denseRange_stoneCechUnit (continuous_stoneCechExtend _) hf
    rintro _ ⟨y, rfl⟩
    apply congr_fun (stoneCechExtend_extends (hf.comp _)) y
    apply continuous_stoneCechUnit
  right_inv := by
    

Proof state:
X : TopCat
Y : CompHaus
⊢ Function.RightInverse (fun f => ContinuousMap.mk (stoneCechExtend (_ : Continuous f.toFun))) fun f =>
    ContinuousMap.mk (⇑f ∘ stoneCechUnit)

Next tactic:
rintro ⟨f : (X : Type _) ⟶ Y, hf : Continuous f⟩
/-- (Implementation) The bijection of homsets to establish the reflective adjunction of compact
Hausdorff spaces in topological spaces.
-/
noncomputable def stoneCechEquivalence (X : TopCat.{u}) (Y : CompHaus.{u}) :
    (stoneCechObj X ⟶ Y) ≃ (X ⟶ compHausToTop.obj Y) where
  toFun f :=
    { toFun := f ∘ stoneCechUnit
      continuous_toFun := f.2.comp (@continuous_stoneCechUnit X _) }
  invFun f :=
    { toFun := stoneCechExtend f.2
      continuous_toFun := continuous_stoneCechExtend f.2 }
  left_inv := by
    rintro ⟨f : StoneCech X ⟶ Y, hf : Continuous f⟩
    -- Porting note: `ext` fails.
    apply ContinuousMap.ext
    intro (x : StoneCech X)
    refine' congr_fun _ x
    apply Continuous.ext_on denseRange_stoneCechUnit (continuous_stoneCechExtend _) hf
    rintro _ ⟨y, rfl⟩
    apply congr_fun (stoneCechExtend_extends (hf.comp _)) y
    apply continuous_stoneCechUnit
  right_inv := by
    rintro ⟨f : (X : Type _) ⟶ Y, hf : Continuous f⟩
    -- Porting note: `ext` fails.
    

Proof state:
case mk
X : TopCat
Y : CompHaus
f : ↑X ⟶ ↑Y.toTop
hf : Continuous f
⊢ (fun f => ContinuousMap.mk (⇑f ∘ stoneCechUnit))
      ((fun f => ContinuousMap.mk (stoneCechExtend (_ : Continuous f.toFun))) (ContinuousMap.mk f)) =
    ContinuousMap.mk f

Next tactic:
apply ContinuousMap.ext
/-- (Implementation) The bijection of homsets to establish the reflective adjunction of compact
Hausdorff spaces in topological spaces.
-/
noncomputable def stoneCechEquivalence (X : TopCat.{u}) (Y : CompHaus.{u}) :
    (stoneCechObj X ⟶ Y) ≃ (X ⟶ compHausToTop.obj Y) where
  toFun f :=
    { toFun := f ∘ stoneCechUnit
      continuous_toFun := f.2.comp (@continuous_stoneCechUnit X _) }
  invFun f :=
    { toFun := stoneCechExtend f.2
      continuous_toFun := continuous_stoneCechExtend f.2 }
  left_inv := by
    rintro ⟨f : StoneCech X ⟶ Y, hf : Continuous f⟩
    -- Porting note: `ext` fails.
    apply ContinuousMap.ext
    intro (x : StoneCech X)
    refine' congr_fun _ x
    apply Continuous.ext_on denseRange_stoneCechUnit (continuous_stoneCechExtend _) hf
    rintro _ ⟨y, rfl⟩
    apply congr_fun (stoneCechExtend_extends (hf.comp _)) y
    apply continuous_stoneCechUnit
  right_inv := by
    rintro ⟨f : (X : Type _) ⟶ Y, hf : Continuous f⟩
    -- Porting note: `ext` fails.
    apply ContinuousMap.ext
    

Proof state:
case mk.h
X : TopCat
Y : CompHaus
f : ↑X ⟶ ↑Y.toTop
hf : Continuous f
⊢ ∀ (a : ↑X),
    ((fun f => ContinuousMap.mk (⇑f ∘ stoneCechUnit))
          ((fun f => ContinuousMap.mk (stoneCechExtend (_ : Continuous f.toFun))) (ContinuousMap.mk f)))
        a =
      (ContinuousMap.mk f) a

Next tactic:
intro
/-- (Implementation) The bijection of homsets to establish the reflective adjunction of compact
Hausdorff spaces in topological spaces.
-/
noncomputable def stoneCechEquivalence (X : TopCat.{u}) (Y : CompHaus.{u}) :
    (stoneCechObj X ⟶ Y) ≃ (X ⟶ compHausToTop.obj Y) where
  toFun f :=
    { toFun := f ∘ stoneCechUnit
      continuous_toFun := f.2.comp (@continuous_stoneCechUnit X _) }
  invFun f :=
    { toFun := stoneCechExtend f.2
      continuous_toFun := continuous_stoneCechExtend f.2 }
  left_inv := by
    rintro ⟨f : StoneCech X ⟶ Y, hf : Continuous f⟩
    -- Porting note: `ext` fails.
    apply ContinuousMap.ext
    intro (x : StoneCech X)
    refine' congr_fun _ x
    apply Continuous.ext_on denseRange_stoneCechUnit (continuous_stoneCechExtend _) hf
    rintro _ ⟨y, rfl⟩
    apply congr_fun (stoneCechExtend_extends (hf.comp _)) y
    apply continuous_stoneCechUnit
  right_inv := by
    rintro ⟨f : (X : Type _) ⟶ Y, hf : Continuous f⟩
    -- Porting note: `ext` fails.
    apply ContinuousMap.ext
    intro
    

Proof state:
case mk.h
X : TopCat
Y : CompHaus
f : ↑X ⟶ ↑Y.toTop
hf : Continuous f
a✝ : ↑X
⊢ ((fun f => ContinuousMap.mk (⇑f ∘ stoneCechUnit))
        ((fun f => ContinuousMap.mk (stoneCechExtend (_ : Continuous f.toFun))) (ContinuousMap.mk f)))
      a✝ =
    (ContinuousMap.mk f) a✝

Next tactic:
exact congr_fun (stoneCechExtend_extends hf) _
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
⊢ CompactSpace ↑(TopCat.limitCone FF).pt

Next tactic:
show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
⊢ CompactSpace ↑{u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j}

Next tactic:
rw [← isCompact_iff_compactSpace]
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
⊢ IsCompact {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j}

Next tactic:
apply IsClosed.isCompact
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
⊢ IsClosed {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j}

Next tactic:
have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
⊢ {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}

Next tactic:
ext1
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
x✝ : (j : J) → ↑(F.obj j).toTop
⊢ x✝ ∈ {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} ↔ x✝ ∈ ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}

Next tactic:
simp only [Set.mem_iInter, Set.mem_setOf_eq]
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
⊢ IsClosed {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j}

Next tactic:
rw [this]
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
⊢ IsClosed (⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j})

Next tactic:
apply isClosed_iInter
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        apply isClosed_iInter
        

Proof state:
case h.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
⊢ ∀ (i : J), IsClosed (⋂ j, ⋂ f, {u | (F.map f) (u i) = u j})

Next tactic:
intro i
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        apply isClosed_iInter
        intro i
        

Proof state:
case h.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
i : J
⊢ IsClosed (⋂ j, ⋂ f, {u | (F.map f) (u i) = u j})

Next tactic:
apply isClosed_iInter
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        apply isClosed_iInter
        intro i
        apply isClosed_iInter
        

Proof state:
case h.h.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
i : J
⊢ ∀ (i_1 : J), IsClosed (⋂ f, {u | (F.map f) (u i) = u i_1})

Next tactic:
intro j
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        apply isClosed_iInter
        intro i
        apply isClosed_iInter
        intro j
        

Proof state:
case h.h.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
i j : J
⊢ IsClosed (⋂ f, {u | (F.map f) (u i) = u j})

Next tactic:
apply isClosed_iInter
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        apply isClosed_iInter
        intro i
        apply isClosed_iInter
        intro j
        apply isClosed_iInter
        

Proof state:
case h.h.h.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
i j : J
⊢ ∀ (i_1 : i ⟶ j), IsClosed {u | (F.map i_1) (u i) = u j}

Next tactic:
intro f
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        apply isClosed_iInter
        intro i
        apply isClosed_iInter
        intro j
        apply isClosed_iInter
        intro f
        

Proof state:
case h.h.h.h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
i j : J
f : i ⟶ j
⊢ IsClosed {u | (F.map f) (u i) = u j}

Next tactic:
apply isClosed_eq
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        apply isClosed_iInter
        intro i
        apply isClosed_iInter
        intro j
        apply isClosed_iInter
        intro f
        apply isClosed_eq
        · 

Proof state:
case h.h.h.h.hf
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
i j : J
f : i ⟶ j
⊢ Continuous fun y => (F.map f) (y i)

Next tactic:
exact (ContinuousMap.continuous (F.map f)).comp (continuous_apply i)
/-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. -/
def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F :=
  -- Porting note: Exploit the `TopCatMax` trick.
  letI FF : J ⥤ TopCatMax.{v,u} := F ⋙ compHausToTop
  { pt := {
      toTop := (TopCat.limitCone FF).pt
      is_compact := by
        show CompactSpace { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
        rw [← isCompact_iff_compactSpace]
        apply IsClosed.isCompact
        have :
          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
          ext1
          simp only [Set.mem_iInter, Set.mem_setOf_eq]
        rw [this]
        apply isClosed_iInter
        intro i
        apply isClosed_iInter
        intro j
        apply isClosed_iInter
        intro f
        apply isClosed_eq
        · exact (ContinuousMap.continuous (F.map f)).comp (continuous_apply i)
        · 

Proof state:
case h.h.h.h.hg
J : Type v
inst✝ : SmallCategory J
F : J ⥤ CompHaus
FF : J ⥤ TopCatMax := F ⋙ compHausToTop
this : {u | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} = ⋂ i, ⋂ j, ⋂ f, {u | (F.map f) (u i) = u j}
i j : J
f : i ⟶ j
⊢ Continuous fun y => y j

Next tactic:
exact continuous_apply j