awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
S : Set (Set (↑(F.obj j) : Type (max u v)))
a : J
E : Finset J
_ha : a ∉ E
hh1 :
  ∀ (P : J → Set (↑(F.obj j) : Type (max u v))) (_univ : Set.univ ∈ S)
    (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
hh2 : J → Set (↑(F.obj j) : Type (max u v))
hh3 : Set.univ ∈ S
hh4 : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S
hh5 : ∀ (e : J) (_he : e ∈ Insert.insert a E), hh2 e ∈ S
insert : ∀ (e : J) (_he : e ∈ E), hh2 e ∈ S
⊢ hh2 a ∩ ⋂ x ∈ E, hh2 x ∈ S

Tactic:
refine hh4 _ _ (hh5 _ (Finset.mem_insert_self _ _)) (hh1 _ hh3 hh4 ?_)

Premises used: Finset.mem_insert_self
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
S : Set (Set (↑(F.obj j) : Type (max u v)))
a : J
E : Finset J
_ha : a ∉ E
hh1 :
  ∀ (P : J → Set (↑(F.obj j) : Type (max u v))) (_univ : Set.univ ∈ S)
    (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
hh2 : J → Set (↑(F.obj j) : Type (max u v))
hh3 : Set.univ ∈ S
hh4 : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S
hh5 : ∀ (e : J) (_he : e ∈ insert a E), hh2 e ∈ S
e : J
he : e ∈ E
⊢ hh2 e ∈ S

Tactic:
hh5 e (Finset.mem_insert_of_mem he)

Premises used: Finset.mem_insert_of_mem
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
S : Set (Set (↑(F.obj j) : Type (max u v)))
a : J
E : Finset J
_ha : a ∉ E
hh1 :
  ∀ (P : J → Set (↑(F.obj j) : Type (max u v))) (_univ : Set.univ ∈ S)
    (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
hh2 : J → Set (↑(F.obj j) : Type (max u v))
hh3 : Set.univ ∈ S
hh4 : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S
hh5 : ∀ (e : J) (_he : e ∈ insert a E), hh2 e ∈ S
e : J
he : e ∈ E
⊢ hh2 e ∈ S

Tactic:
exact hh5 e (Finset.mem_insert_of_mem he)

Premises used: Finset.mem_insert_of_mem
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
⊢ ∀ (S : Set (Set (↑(F.obj j) : Type (max u v)))) (E : Finset J) (P : J → Set (↑(F.obj j) : Type (max u v)))
    (_univ : Set.univ ∈ S) (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S

Tactic:
have :
        ∀ (S : Set (Set (F.obj j))) (E : Finset J) (P : J → Set (F.obj j)) (_univ : Set.univ ∈ S)
          (_inter : ∀ A B : Set (F.obj j), A ∈ S → B ∈ S → A ∩ B ∈ S)
          (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), (⋂ (e) (_he : e ∈ E), P e) ∈ S := by
        intro S E
        induction E using Finset.induction_on with
        | empty =>
          intro P he _hh
          simpa
        | insert a E _ha hh1 =>
          intro hh2 hh3 hh4 hh5
          rw [Finset.set_biInter_insert]
          refine hh4 _ _ (hh5 _ (Finset.mem_insert_self _ _)) (hh1 _ hh3 hh4 ?_)
          intro e he
          exact hh5 e (Finset.mem_insert_of_mem he)
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
this :
  ∀ (S : Set (Set (↑(F.obj j) : Type (max u v)))) (E : Finset J) (P : J → Set (↑(F.obj j) : Type (max u v)))
    (_univ : Set.univ ∈ S) (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
⊢ V ∈ T j

Tactic:
this _ _ _ (univ _) (inter _) ?_

Premises used: Set.Mem
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
this :
  ∀ (S : Set (Set (↑(F.obj j) : Type (max u v)))) (E : Finset J) (P : J → Set (↑(F.obj j) : Type (max u v)))
    (_univ : Set.univ ∈ S) (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
h : ∀ (e : J) (_he : e ∈ G), Vs e ∈ T j
⊢ V ∈ T j

Tactic:
refine this _ _ _ (univ _) (inter _) ?_
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
this :
  ∀ (S : Set (Set (↑(F.obj j) : Type (max u v)))) (E : Finset J) (P : J → Set (↑(F.obj j) : Type (max u v)))
    (_univ : Set.univ ∈ S) (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
e : J
he : e ∈ G
h :
  (if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ) ∈
    T j
⊢ Vs e ∈ T j

Tactic:
dsimp [Vs]
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
this :
  ∀ (S : Set (Set (↑(F.obj j) : Type (max u v)))) (E : Finset J) (P : J → Set (↑(F.obj j) : Type (max u v)))
    (_univ : Set.univ ∈ S) (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
e : J
he : e ∈ G
h :
  (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
            (F.map (g e he))) :
        (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
      U e ∈
    T j
⊢ (if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ) ∈
    T j

Tactic:
rw [dif_pos he]

Premises used: dif_pos
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
this :
  ∀ (S : Set (Set (↑(F.obj j) : Type (max u v)))) (E : Finset J) (P : J → Set (↑(F.obj j) : Type (max u v)))
    (_univ : Set.univ ∈ S) (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
e : J
he : e ∈ G
⊢ (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
            (F.map (g e he))) :
        (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
      U e ∈
    T j

Tactic:
compat j e (g e he) (U e) (h1 e he)

Premises used: Set.Mem
-- Module: Mathlib.Topology.Category.TopCat.Limits.Cofiltered
Goal:
J : Type v
inst : Category.{w, v} J
inst_1 : IsCofiltered.{w, v} J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set (↑(F.obj j) : Type (max u v)))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set (↑(F.obj i) : Type (max u v))), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat :
  ∀ (i j : J) (f : i ⟶ j) (V : Set (↑(F.obj j) : Type (max u v))) (_hV : V ∈ T j),
    (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
              (F.map f)) :
          (a : (↑(F.obj i) : Type (max u v))) → (↑(F.obj j) : Type (max u v))) ⁻¹'
        V ∈
      T i
U0 : Set (↑C.pt : Type (max u v))
U : (i : J) → Set (↑(F.obj i) : Type (max u v))
G : Finset J
h1 : ∀ i ∈ G, U i ∈ T i
h2 :
  U0 =
    ⋂ i ∈ G,
      (fun (x : (↑C.pt : Type (max u v))) ↦
          (ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
                carrier) (C.π.app i) :
              (a : (↑(((Functor.const J).obj C.pt).obj i) : Type (max u v))) → (↑(F.obj i) : Type (max u v)))
            x) ⁻¹'
        U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty.{w + 1} (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun (x : J) (he : x ∈ G) ↦ ⋯.some
Vs : J → Set (↑(F.obj j) : Type (max u v)) :=
  fun (e : J) ↦
    if h : e ∈ G then
      (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC :=
              carrier) (F.map (g e h))) :
          (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
        U e
    else Set.univ
V : Set (↑(F.obj j) : Type (max u v)) := ⋂ e ∈ G, Vs e
this :
  ∀ (S : Set (Set (↑(F.obj j) : Type (max u v)))) (E : Finset J) (P : J → Set (↑(F.obj j) : Type (max u v)))
    (_univ : Set.univ ∈ S) (_inter : ∀ (A B : Set (↑(F.obj j) : Type (max u v))), A ∈ S → B ∈ S → A ∩ B ∈ S)
    (_cond : ∀ (e : J) (_he : e ∈ E), P e ∈ S), ⋂ e ∈ E, P e ∈ S
e : J
he : e ∈ G
⊢ (⇑(ConcreteCategory.hom (FC := fun (X Y : TopCat) ↦ C((↑X : Type (max u v)), (↑Y : Type (max u v)))) (CC := carrier)
            (F.map (g e he))) :
        (a : (↑(F.obj j) : Type (max u v))) → (↑(F.obj e) : Type (max u v))) ⁻¹'
      U e ∈
    T j

Tactic:
exact compat j e (g e he) (U e) (h1 e he)