Theorem: TopCat.range_pullback_map
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: ext
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Set.range ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)) =
    (forget TopCat).map pullback.fst ⁻¹' Set.range ((forget TopCat).map i₁) ∩
      (forget TopCat).map pullback.snd ⁻¹' Set.range ((forget TopCat).map i₂)

tactic: constructor
state_before: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
⊢ x✝ ∈ Set.range ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)) ↔
    x✝ ∈
      (forget TopCat).map pullback.fst ⁻¹' Set.range ((forget TopCat).map i₁) ∩
        (forget TopCat).map pullback.snd ⁻¹' Set.range ((forget TopCat).map i₂)

tactic: rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩⟩
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
⊢ x✝ ∈
      (forget TopCat).map pullback.fst ⁻¹' Set.range ((forget TopCat).map i₁) ∩
        (forget TopCat).map pullback.snd ⁻¹' Set.range ((forget TopCat).map i₂) →
    x✝ ∈ Set.range ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂))

tactic: have : f₁ x₁ = f₂ x₂ := by
  apply (TopCat.mono_iff_injective _).mp H₃
  simp only [← comp_apply, eq₁, eq₂]
  simp only [comp_apply, hx₁, hx₂]
  simp only [← comp_apply, pullback.condition]
state_before: case h.mpr.intro.intro.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
⊢ x✝ ∈ Set.range ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂))

tactic: use (pullbackIsoProdSubtype f₁ f₂).inv ⟨⟨x₁, x₂⟩, this⟩
state_before: case h.mpr.intro.intro.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ x✝ ∈ Set.range ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂))

tactic: apply Concrete.limit_ext
state_before: case h.mpr.intro.intro.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ (forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)
      ((forget TopCat).map (pullbackIsoProdSubtype f₁ f₂).inv { val := (x₁, x₂), property := this }) =
    x✝

tactic: rintro (_ | _ | _)
state_before: case h.mpr.intro.intro.intro.a
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ ∀ (j : WalkingCospan),
    (forget TopCat).map (limit.π (cospan g₁ g₂) j)
        ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)
          ((forget TopCat).map (pullbackIsoProdSubtype f₁ f₂).inv { val := (x₁, x₂), property := this })) =
      (forget TopCat).map (limit.π (cospan g₁ g₂) j) x✝

tactic: rintro ⟨y, rfl⟩
state_before: case h.mp
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
⊢ x✝ ∈ Set.range ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)) →
    x✝ ∈
      (forget TopCat).map pullback.fst ⁻¹' Set.range ((forget TopCat).map i₁) ∩
        (forget TopCat).map pullback.snd ⁻¹' Set.range ((forget TopCat).map i₂)

tactic: simp
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
y : (forget TopCat).obj (pullback f₁ f₂)
⊢ (forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂) y ∈
    (forget TopCat).map pullback.fst ⁻¹' Set.range ((forget TopCat).map i₁) ∩
      (forget TopCat).map pullback.snd ⁻¹' Set.range ((forget TopCat).map i₂)

tactic: apply (TopCat.mono_iff_injective _).mp H₃
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
⊢ (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂

tactic: simp only [← comp_apply, eq₁, eq₂]
state_before: case a
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
⊢ (forget TopCat).map i₃ ((forget TopCat).map f₁ x₁) = (forget TopCat).map i₃ ((forget TopCat).map f₂ x₂)

tactic: simp only [comp_apply, hx₁, hx₂]
state_before: case a
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
⊢ (forget TopCat).map (i₁ ≫ g₁) x₁ = (forget TopCat).map (i₂ ≫ g₂) x₂

tactic: simp only [← comp_apply, pullback.condition]
state_before: case a
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
⊢ (forget TopCat).map g₁ ((forget TopCat).map pullback.fst x✝) =
    (forget TopCat).map g₂ ((forget TopCat).map pullback.snd x✝)

tactic: simp only [TopCat.comp_app, limit.lift_π_apply, Category.assoc, PullbackCone.mk_π_app_one, hx₁,
  pullbackIsoProdSubtype_inv_fst_apply, Subtype.coe_mk]
state_before: case h.mpr.intro.intro.intro.a.none
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ (forget TopCat).map (limit.π (cospan g₁ g₂) none)
      ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)
        ((forget TopCat).map (pullbackIsoProdSubtype f₁ f₂).inv { val := (x₁, x₂), property := this })) =
    (forget TopCat).map (limit.π (cospan g₁ g₂) none) x✝

tactic: simp only [← comp_apply]
state_before: case h.mpr.intro.intro.intro.a.none
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ (forget TopCat).map g₁ ((forget TopCat).map pullback.fst x✝) = (forget TopCat).map (limit.π (cospan g₁ g₂) none) x✝

tactic: have : pullback.fst ≫ g₁ = limit.π (cospan g₁ g₂) none := by
  apply limit.w _ WalkingCospan.Hom.inl
state_before: case h.mpr.intro.intro.intro.a.none
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ (forget TopCat).map (pullback.fst ≫ g₁) x✝ = (forget TopCat).map (limit.π (cospan g₁ g₂) none) x✝

tactic: rw [this]
state_before: case h.mpr.intro.intro.intro.a.none
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this✝ : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
this : pullback.fst ≫ g₁ = limit.π (cospan g₁ g₂) none
⊢ (forget TopCat).map (pullback.fst ≫ g₁) x✝ = (forget TopCat).map (limit.π (cospan g₁ g₂) none) x✝

tactic: apply limit.w _ WalkingCospan.Hom.inl
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ pullback.fst ≫ g₁ = limit.π (cospan g₁ g₂) none

tactic: simp [hx₁]
state_before: case h.mpr.intro.intro.intro.a.some.left
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ (forget TopCat).map (limit.π (cospan g₁ g₂) (some WalkingPair.left))
      ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)
        ((forget TopCat).map (pullbackIsoProdSubtype f₁ f₂).inv { val := (x₁, x₂), property := this })) =
    (forget TopCat).map (limit.π (cospan g₁ g₂) (some WalkingPair.left)) x✝

tactic: simp [hx₂]
state_before: case h.mpr.intro.intro.intro.a.some.right
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
i₃ : S ⟶ T
H₃ : Mono i₃
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
x✝ : (forget TopCat).obj (pullback g₁ g₂)
x₁ : (forget TopCat).obj W
hx₁ : (forget TopCat).map i₁ x₁ = (forget TopCat).map pullback.fst x✝
x₂ : (forget TopCat).obj X
hx₂ : (forget TopCat).map i₂ x₂ = (forget TopCat).map pullback.snd x✝
this : (forget TopCat).map f₁ x₁ = (forget TopCat).map f₂ x₂
⊢ (forget TopCat).map (limit.π (cospan g₁ g₂) (some WalkingPair.right))
      ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)
        ((forget TopCat).map (pullbackIsoProdSubtype f₁ f₂).inv { val := (x₁, x₂), property := this })) =
    (forget TopCat).map (limit.π (cospan g₁ g₂) (some WalkingPair.right)) x✝