Theorem: TopCat.isTopologicalBasis_cofiltered_limit
File: Mathlib/Topology/Category/TopCat/Limits/Cofiltered.lean

tactic: let D := limitConeInfi F
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
⊢ IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V}

tactic: let E : C.pt ≅ D.pt := hC.conePointUniqueUpToIso (limitConeInfiIsLimit _)
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
⊢ IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V}

tactic: have hE : Inducing E.hom := (TopCat.homeoOfIso E).inducing
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
⊢ IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V}

tactic: convert isTopologicalBasis_iInf hT fun j (x : D.pt) => D.π.app j x using 1
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
⊢ IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: ext U0
state_before: case h.e'_3
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
⊢ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V} =
    {S |
      ∃ U F_1,
        (∀ (i : J), i ∈ F_1 → U i ∈ T i) ∧
          S = ⋂ (i : J) (_ : i ∈ F_1), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i}

tactic: constructor
state_before: case h.e'_3.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V} ↔
    U0 ∈
      {S |
        ∃ U F_1,
          (∀ (i : J), i ∈ F_1 → U i ∈ T i) ∧
            S = ⋂ (i : J) (_ : i ∈ F_1), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i}

tactic: convert this.inducing hE
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
this : IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}
⊢ IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V}

tactic: ext U0
state_before: case h.e'_3.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
this : IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}
e_1✝ : ↑C.pt = (forget TopCat).obj C.pt
⊢ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V} =
    Set.preimage ((forget TopCat).map E.hom) '' {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: constructor
state_before: case h.e'_3.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
this : IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}
e_1✝ : ↑C.pt = (forget TopCat).obj C.pt
U0 : Set ↑C.pt
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V} ↔
    U0 ∈ Set.preimage ((forget TopCat).map E.hom) '' {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: rintro ⟨j, V, hV, rfl⟩
state_before: case h.e'_3.h.h.mp
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
this : IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}
e_1✝ : ↑C.pt = (forget TopCat).obj C.pt
U0 : Set ↑C.pt
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V} →
    U0 ∈ Set.preimage ((forget TopCat).map E.hom) '' {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: refine' ⟨D.π.app j ⁻¹' V, ⟨j, V, hV, rfl⟩, rfl⟩
state_before: case h.e'_3.h.h.mp.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
this : IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}
e_1✝ : ↑C.pt = (forget TopCat).obj C.pt
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
⊢ (forget TopCat).map (C.π.app j) ⁻¹' V ∈
    Set.preimage ((forget TopCat).map E.hom) '' {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: rintro ⟨W, ⟨j, V, hV, rfl⟩, rfl⟩
state_before: case h.e'_3.h.h.mpr
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
this : IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}
e_1✝ : ↑C.pt = (forget TopCat).obj C.pt
U0 : Set ↑C.pt
⊢ U0 ∈ Set.preimage ((forget TopCat).map E.hom) '' {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V} →
    U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V}

tactic: refine' ⟨j, V, hV, rfl⟩
state_before: case h.e'_3.h.h.mpr.intro.intro.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
this : IsTopologicalBasis {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}
e_1✝ : ↑C.pt = (forget TopCat).obj C.pt
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
⊢ (forget TopCat).map E.hom ⁻¹' ((forget TopCat).map (D.π.app j) ⁻¹' V) ∈
    {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (C.π.app j) ⁻¹' V}

tactic: rintro ⟨j, V, hV, rfl⟩
state_before: case h.e'_3.h.mp
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V} →
    U0 ∈
      {S |
        ∃ U F_1,
          (∀ (i : J), i ∈ F_1 → U i ∈ T i) ∧
            S = ⋂ (i : J) (_ : i ∈ F_1), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i}

tactic: let U : ∀ i, Set (F.obj i) := fun i =>
  if h : i = j then by
    rw [h]
    exact V
  else Set.univ
state_before: case h.e'_3.h.mp.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
⊢ (forget TopCat).map (D.π.app j) ⁻¹' V ∈
    {S |
      ∃ U F_1,
        (∀ (i : J), i ∈ F_1 → U i ∈ T i) ∧
          S = ⋂ (i : J) (_ : i ∈ F_1), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i}

tactic: refine' ⟨U, {j}, _, _⟩
state_before: case h.e'_3.h.mp.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
U : (i : J) → Set ↑(F.obj i) := fun i => if h : i = j then Eq.mpr (_ : Set ↑(F.obj i) = Set ↑(F.obj j)) V else Set.univ
⊢ (forget TopCat).map (D.π.app j) ⁻¹' V ∈
    {S |
      ∃ U F_1,
        (∀ (i : J), i ∈ F_1 → U i ∈ T i) ∧
          S = ⋂ (i : J) (_ : i ∈ F_1), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i}

tactic: rw [h]
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
i : J
h : i = j
⊢ Set ↑(F.obj i)

tactic: exact V
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
i : J
h : i = j
⊢ Set ↑(F.obj j)

tactic: rintro i h
state_before: case h.e'_3.h.mp.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
U : (i : J) → Set ↑(F.obj i) := fun i => if h : i = j then Eq.mpr (_ : Set ↑(F.obj i) = Set ↑(F.obj j)) V else Set.univ
⊢ ∀ (i : J), i ∈ {j} → U i ∈ T i

tactic: rw [Finset.mem_singleton] at h
state_before: case h.e'_3.h.mp.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
U : (i : J) → Set ↑(F.obj i) := fun i => if h : i = j then Eq.mpr (_ : Set ↑(F.obj i) = Set ↑(F.obj j)) V else Set.univ
i : J
h : i ∈ {j}
⊢ U i ∈ T i

tactic: dsimp
state_before: case h.e'_3.h.mp.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
U : (i : J) → Set ↑(F.obj i) := fun i => if h : i = j then Eq.mpr (_ : Set ↑(F.obj i) = Set ↑(F.obj j)) V else Set.univ
i : J
h : i = j
⊢ U i ∈ T i

tactic: rw [dif_pos h]
state_before: case h.e'_3.h.mp.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
U : (i : J) → Set ↑(F.obj i) := fun i => if h : i = j then Eq.mpr (_ : Set ↑(F.obj i) = Set ↑(F.obj j)) V else Set.univ
i : J
h : i = j
⊢ (if h : i = j then cast (_ : Set ↑(F.obj j) = Set ↑(F.obj i)) V else Set.univ) ∈ T i

tactic: subst h
state_before: case h.e'_3.h.mp.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
U : (i : J) → Set ↑(F.obj i) := fun i => if h : i = j then Eq.mpr (_ : Set ↑(F.obj i) = Set ↑(F.obj j)) V else Set.univ
i : J
h : i = j
⊢ cast (_ : Set ↑(F.obj j) = Set ↑(F.obj i)) V ∈ T i

tactic: exact hV
state_before: case h.e'_3.h.mp.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
i : J
V : Set ↑(F.obj i)
hV : V ∈ T i
U : (i : J) → Set ↑(F.obj i) :=
  fun i_1 => if h : i_1 = i then Eq.mpr (_ : Set ↑(F.obj i_1) = Set ↑(F.obj i)) V else Set.univ
⊢ cast (_ : Set ↑(F.obj i) = Set ↑(F.obj i)) V ∈ T i

tactic: dsimp
state_before: case h.e'_3.h.mp.intro.intro.intro.refine'_2
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
U : (i : J) → Set ↑(F.obj i) := fun i => if h : i = j then Eq.mpr (_ : Set ↑(F.obj i) = Set ↑(F.obj j)) V else Set.univ
⊢ (forget TopCat).map (D.π.app j) ⁻¹' V = ⋂ (i : J) (_ : i ∈ {j}), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i

tactic: simp
state_before: case h.e'_3.h.mp.intro.intro.intro.refine'_2
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
j : J
V : Set ↑(F.obj j)
hV : V ∈ T j
U : (i : J) → Set ↑(F.obj i) := fun i => if h : i = j then Eq.mpr (_ : Set ↑(F.obj i) = Set ↑(F.obj j)) V else Set.univ
⊢ (forget TopCat).map ((limitConeInfi F).π.app j) ⁻¹' V =
    ⋂ (i : J) (_ : i ∈ {j}),
      (fun x => (forget TopCat).map ((limitConeInfi F).π.app i) x) ⁻¹'
        if h : i = j then cast (_ : Set ↑(F.obj j) = Set ↑(F.obj i)) V else Set.univ

tactic: rintro ⟨U, G, h1, h2⟩
state_before: case h.e'_3.h.mpr
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
⊢ U0 ∈
      {S |
        ∃ U F_1,
          (∀ (i : J), i ∈ F_1 → U i ∈ T i) ∧
            S = ⋂ (i : J) (_ : i ∈ F_1), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i} →
    U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: obtain ⟨j, hj⟩ := IsCofiltered.inf_objs_exists G
state_before: case h.e'_3.h.mpr.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: let g : ∀ (e) (_he : e ∈ G), j ⟶ e := fun _ he => (hj he).some
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: let Vs : J → Set (F.obj j) := fun e => if h : e ∈ G then F.map (g e h) ⁻¹' U e else Set.univ
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: let V : Set (F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: refine' ⟨j, V, _, _⟩
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
⊢ U0 ∈ {U | ∃ j V, V ∈ T j ∧ U = (forget TopCat).map (D.π.app j) ⁻¹' V}

tactic: refine' this _ _ _ (univ _) (inter _) _
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
this :
  ∀ (S : Set (Set ↑(F.obj j))) (E : Finset J) (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
⊢ V ∈ T j

tactic: intro e he
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
this :
  ∀ (S : Set (Set ↑(F.obj j))) (E : Finset J) (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
⊢ ∀ (e : J), e ∈ G → Vs e ∈ T j

tactic: dsimp
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
this :
  ∀ (S : Set (Set ↑(F.obj j))) (E : Finset J) (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
e : J
he : e ∈ G
⊢ Vs e ∈ T j

tactic: rw [dif_pos he]
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
this :
  ∀ (S : Set (Set ↑(F.obj j))) (E : Finset J) (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
e : J
he : e ∈ G
⊢ (if h : e ∈ G then (forget TopCat).map (F.map (Nonempty.some (_ : Nonempty (j ⟶ e)))) ⁻¹' U e else Set.univ) ∈ T j

tactic: exact compat j e (g e he) (U e) (h1 e he)
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_1
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
this :
  ∀ (S : Set (Set ↑(F.obj j))) (E : Finset J) (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
e : J
he : e ∈ G
⊢ (forget TopCat).map (F.map (Nonempty.some (_ : Nonempty (j ⟶ e)))) ⁻¹' U e ∈ T j

tactic: intro S E
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
⊢ ∀ (S : Set (Set ↑(F.obj j))) (E : Finset J) (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S

tactic: induction' E using Finset.induction_on with a E _ hh1
state_before: J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E✝ : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E✝.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
S : Set (Set ↑(F.obj j))
E : Finset J
⊢ ∀ (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S

tactic: intro P he _
state_before: case empty
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
S : Set (Set ↑(F.obj j))
⊢ ∀ (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ ∅ → P e ∈ S) → (⋂ (e : J) (_ : e ∈ ∅), P e) ∈ S

tactic: simpa
state_before: case empty
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
S : Set (Set ↑(F.obj j))
P : J → Set ↑(F.obj j)
he : Set.univ ∈ S
x✝ : ∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S
⊢ (∀ (e : J), e ∈ ∅ → P e ∈ S) → (⋂ (e : J) (_ : e ∈ ∅), P e) ∈ S

tactic: intro hh2 hh3 hh4 hh5
state_before: case insert
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E✝ : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E✝.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
S : Set (Set ↑(F.obj j))
a : J
E : Finset J
a✝ : ¬a ∈ E
hh1 :
  ∀ (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
⊢ ∀ (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ insert a E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ insert a E), P e) ∈ S

tactic: rw [Finset.set_biInter_insert]
state_before: case insert
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E✝ : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E✝.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
S : Set (Set ↑(F.obj j))
a : J
E : Finset J
a✝ : ¬a ∈ E
hh1 :
  ∀ (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
hh2 : J → Set ↑(F.obj j)
hh3 : Set.univ ∈ S
hh4 : ∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S
hh5 : ∀ (e : J), e ∈ insert a E → hh2 e ∈ S
⊢ (⋂ (e : J) (_ : e ∈ insert a E), hh2 e) ∈ S

tactic: refine' hh4 _ _ (hh5 _ (Finset.mem_insert_self _ _)) (hh1 _ hh3 hh4 _)
state_before: case insert
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E✝ : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E✝.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
S : Set (Set ↑(F.obj j))
a : J
E : Finset J
a✝ : ¬a ∈ E
hh1 :
  ∀ (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
hh2 : J → Set ↑(F.obj j)
hh3 : Set.univ ∈ S
hh4 : ∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S
hh5 : ∀ (e : J), e ∈ insert a E → hh2 e ∈ S
⊢ (hh2 a ∩ ⋂ (x : J) (_ : x ∈ E), hh2 x) ∈ S

tactic: intro e he
state_before: case insert
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E✝ : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E✝.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
S : Set (Set ↑(F.obj j))
a : J
E : Finset J
a✝ : ¬a ∈ E
hh1 :
  ∀ (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
hh2 : J → Set ↑(F.obj j)
hh3 : Set.univ ∈ S
hh4 : ∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S
hh5 : ∀ (e : J), e ∈ insert a E → hh2 e ∈ S
⊢ ∀ (e : J), e ∈ E → hh2 e ∈ S

tactic: exact hh5 e (Finset.mem_insert_of_mem he)
state_before: case insert
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E✝ : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E✝.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
S : Set (Set ↑(F.obj j))
a : J
E : Finset J
a✝ : ¬a ∈ E
hh1 :
  ∀ (P : J → Set ↑(F.obj j)),
    Set.univ ∈ S →
      (∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S) →
        (∀ (e : J), e ∈ E → P e ∈ S) → (⋂ (e : J) (_ : e ∈ E), P e) ∈ S
hh2 : J → Set ↑(F.obj j)
hh3 : Set.univ ∈ S
hh4 : ∀ (A B : Set ↑(F.obj j)), A ∈ S → B ∈ S → A ∩ B ∈ S
hh5 : ∀ (e : J), e ∈ insert a E → hh2 e ∈ S
e : J
he : e ∈ E
⊢ hh2 e ∈ S

tactic: rw [h2]
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
⊢ U0 = (forget TopCat).map (D.π.app j) ⁻¹' V

tactic: change _ = (D.π.app j)⁻¹' ⋂ (e : J) (_ : e ∈ G), Vs e
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
⊢ (⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i) = (forget TopCat).map (D.π.app j) ⁻¹' V

tactic: rw [Set.preimage_iInter]
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
⊢ (⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i) =
    (forget TopCat).map (D.π.app j) ⁻¹' ⋂ (e : J) (_ : e ∈ G), Vs e

tactic: apply congrArg
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
⊢ (⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i) =
    ⋂ (i : J), (forget TopCat).map (D.π.app j) ⁻¹' ⋂ (_ : i ∈ G), Vs i

tactic: ext1 e
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
⊢ (fun i => ⋂ (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i) = fun i =>
    (forget TopCat).map (D.π.app j) ⁻¹' ⋂ (_ : i ∈ G), Vs i

tactic: erw [Set.preimage_iInter]
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
e : J
⊢ (⋂ (_ : e ∈ G), (fun x => (forget TopCat).map (D.π.app e) x) ⁻¹' U e) =
    (forget TopCat).map (D.π.app j) ⁻¹' ⋂ (_ : e ∈ G), Vs e

tactic: apply congrArg
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
e : J
⊢ (⋂ (_ : e ∈ G), (fun x => (forget TopCat).map (D.π.app e) x) ⁻¹' U e) =
    ⋂ (_ : e ∈ G), (forget TopCat).map (D.π.app j) ⁻¹' Vs e

tactic: ext1 he
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
e : J
⊢ (fun x => (fun x => (forget TopCat).map (D.π.app e) x) ⁻¹' U e) = fun i => (forget TopCat).map (D.π.app j) ⁻¹' Vs e

tactic: change (forget TopCat).map (D.π.app e)⁻¹' U e =
  (forget TopCat).map (D.π.app j) ⁻¹' if h : e ∈ G then F.map (g e h) ⁻¹' U e else Set.univ
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h.h.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
e : J
he : e ∈ G
⊢ (fun x => (forget TopCat).map (D.π.app e) x) ⁻¹' U e = (forget TopCat).map (D.π.app j) ⁻¹' Vs e

tactic: rw [dif_pos he, ← Set.preimage_comp]
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h.h.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
e : J
he : e ∈ G
⊢ (forget TopCat).map (D.π.app e) ⁻¹' U e =
    (forget TopCat).map (D.π.app j) ⁻¹' if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ

tactic: apply congrFun
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h.h.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
e : J
he : e ∈ G
⊢ (forget TopCat).map (D.π.app e) ⁻¹' U e =
    (forget TopCat).map (F.map (g e he)) ∘ (forget TopCat).map (D.π.app j) ⁻¹' U e

tactic: apply congrArg
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h.h.h.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
e : J
he : e ∈ G
⊢ Set.preimage ((forget TopCat).map (D.π.app e)) =
    Set.preimage ((forget TopCat).map (F.map (g e he)) ∘ (forget TopCat).map (D.π.app j))

tactic: rw [←coe_comp, D.w]
state_before: case h.e'_3.h.mpr.intro.intro.intro.intro.refine'_2.h.h.h.h.h.h
J : Type v
inst✝¹ : SmallCategory J
inst✝ : IsCofiltered J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
T : (j : J) → Set (Set ↑(F.obj j))
hT : ∀ (j : J), IsTopologicalBasis (T j)
univ : ∀ (i : J), Set.univ ∈ T i
inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i
compat : ∀ (i j : J) (f : i ⟶ j) (V : Set ↑(F.obj j)), V ∈ T j → (forget TopCat).map (F.map f) ⁻¹' V ∈ T i
D : Cone F := limitConeInfi F
E : C.pt ≅ D.pt := IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F)
hE : Inducing ((forget TopCat).map E.hom)
U0 : Set ↑D.pt
U : (i : J) → Set ↑(F.obj i)
G : Finset J
h1 : ∀ (i : J), i ∈ G → U i ∈ T i
h2 : U0 = ⋂ (i : J) (_ : i ∈ G), (fun x => (forget TopCat).map (D.π.app i) x) ⁻¹' U i
j : J
hj : ∀ {X : J}, X ∈ G → Nonempty (j ⟶ X)
g : (e : J) → e ∈ G → (j ⟶ e) := fun x he => Nonempty.some (_ : Nonempty (j ⟶ x))
Vs : J → Set ↑(F.obj j) := fun e => if h : e ∈ G then (forget TopCat).map (F.map (g e h)) ⁻¹' U e else Set.univ
V : Set ↑(F.obj j) := ⋂ (e : J) (_ : e ∈ G), Vs e
e : J
he : e ∈ G
⊢ (forget TopCat).map (D.π.app e) = (forget TopCat).map (F.map (g e he)) ∘ (forget TopCat).map (D.π.app j)