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

tactic: ext x
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
⊢ Set.range ((forget TopCat).map (prod.lift pullback.fst pullback.snd)) =
    {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}

tactic: constructor
state_before: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
⊢ x ∈ Set.range ((forget TopCat).map (prod.lift pullback.fst pullback.snd)) ↔
    x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}

tactic: rintro ⟨y, rfl⟩
state_before: case h.mp
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
⊢ x ∈ Set.range ((forget TopCat).map (prod.lift pullback.fst pullback.snd)) →
    x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}

tactic: simp only [← comp_apply, Set.mem_setOf_eq]
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
y : (forget TopCat).obj (pullback f g)
⊢ (forget TopCat).map (prod.lift pullback.fst pullback.snd) y ∈
    {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}

tactic: congr 1
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
y : (forget TopCat).obj (pullback f g)
⊢ (forget TopCat).map (prod.lift pullback.fst pullback.snd ≫ prod.fst ≫ f) y =
    (forget TopCat).map (prod.lift pullback.fst pullback.snd ≫ prod.snd ≫ g) y

tactic: simp [pullback.condition]
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
y : (forget TopCat).obj (pullback f g)
⊢ (forget TopCat).map (prod.lift pullback.fst pullback.snd ≫ prod.fst ≫ f) y =
    (forget TopCat).map (prod.lift pullback.fst pullback.snd ≫ prod.snd ≫ g) y

tactic: intro h
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
⊢ x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x} →
    x ∈ Set.range ((forget TopCat).map (prod.lift pullback.fst pullback.snd))

tactic: use (pullbackIsoProdSubtype f g).inv ⟨⟨_, _⟩, h⟩
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
h : x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}
⊢ x ∈ Set.range ((forget TopCat).map (prod.lift pullback.fst pullback.snd))

tactic: apply Concrete.limit_ext
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
h : x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}
⊢ (forget TopCat).map (prod.lift pullback.fst pullback.snd)
      ((forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (↑prod.fst x, ↑prod.snd x), property := h }) =
    x

tactic: rintro ⟨⟨⟩⟩
state_before: case h.mpr.a
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
h : x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}
⊢ ∀ (j : Discrete WalkingPair),
    (forget TopCat).map (limit.π (pair X Y) j)
        ((forget TopCat).map (prod.lift pullback.fst pullback.snd)
          ((forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (↑prod.fst x, ↑prod.snd x), property := h })) =
      (forget TopCat).map (limit.π (pair X Y) j) x

tactic: conv_rhs => rw [hom_apply]
state_before: case h.mpr.a.mk.left
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
h : x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}
⊢ (forget TopCat).map (limit.π (pair X Y) { as := WalkingPair.left })
      ((forget TopCat).map (prod.lift pullback.fst pullback.snd)
        ((forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (↑prod.fst x, ↑prod.snd x), property := h })) =
    (forget TopCat).map (limit.π (pair X Y) { as := WalkingPair.left }) x

tactic: simp
state_before: case h.mpr.a.mk.left
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
h : x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}
⊢ (forget TopCat).map (limit.π (pair X Y) { as := WalkingPair.left })
      ((forget TopCat).map (prod.lift pullback.fst pullback.snd)
        ((forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (↑prod.fst x, ↑prod.snd x), property := h })) =
    ContinuousMap.toFun (limit.π (pair X Y) { as := WalkingPair.left }) x

tactic: conv_rhs => rw [hom_apply]
state_before: case h.mpr.a.mk.right
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
h : x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}
⊢ (forget TopCat).map (limit.π (pair X Y) { as := WalkingPair.right })
      ((forget TopCat).map (prod.lift pullback.fst pullback.snd)
        ((forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (↑prod.fst x, ↑prod.snd x), property := h })) =
    (forget TopCat).map (limit.π (pair X Y) { as := WalkingPair.right }) x

tactic: simp
state_before: case h.mpr.a.mk.right
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ : TopCat
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
x : (forget TopCat).obj (X ⨯ Y)
h : x ∈ {x | (forget TopCat).map (prod.fst ≫ f) x = (forget TopCat).map (prod.snd ≫ g) x}
⊢ (forget TopCat).map (limit.π (pair X Y) { as := WalkingPair.right })
      ((forget TopCat).map (prod.lift pullback.fst pullback.snd)
        ((forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (↑prod.fst x, ↑prod.snd x), property := h })) =
    ContinuousMap.toFun (limit.π (pair X Y) { as := WalkingPair.right }) x