Theorem: TopCat.range_prod_map
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: ext x
state_before: J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
⊢ Set.range ⇑(prod.map f g) = ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g
state_after: case h
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ Set.range ⇑(prod.map f g) ↔ x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g

tactic: constructor
state_before: case h
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ Set.range ⇑(prod.map f g) ↔ x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g
state_after: case h.mp
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ Set.range ⇑(prod.map f g) → x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g

case h.mpr
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g → x ∈ Set.range ⇑(prod.map f g)

tactic: rintro ⟨y, rfl⟩
state_before: case h.mp
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ Set.range ⇑(prod.map f g) → x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g
state_after: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
y : ↑(W ⨯ X)
⊢ (prod.map f g) y ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g

tactic: simp_rw [Set.mem_inter_iff, Set.mem_preimage, Set.mem_range]
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
y : ↑(W ⨯ X)
⊢ (prod.map f g) y ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g
state_after: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
y : ↑(W ⨯ X)
⊢ (∃ y_1, f y_1 = prod.fst ((prod.map f g) y)) ∧ ∃ y_1, g y_1 = prod.snd ((prod.map f g) y)

tactic: erw  [← comp_apply, ← comp_apply]
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
y : ↑(W ⨯ X)
⊢ (∃ y_1, f y_1 = prod.fst ((prod.map f g) y)) ∧ ∃ y_1, g y_1 = prod.snd ((prod.map f g) y)
state_after: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
y : ↑(W ⨯ X)
⊢ (∃ y_1, f y_1 = (prod.map f g ≫ prod.fst) y) ∧ ∃ y_1, g y_1 = (prod.map f g ≫ prod.snd) y

tactic: simp_rw [Limits.prod.map_fst,
  Limits.prod.map_snd, comp_apply]
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
y : ↑(W ⨯ X)
⊢ (∃ y_1, f y_1 = (prod.map f g ≫ prod.fst) y) ∧ ∃ y_1, g y_1 = (prod.map f g ≫ prod.snd) y
state_after: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
y : ↑(W ⨯ X)
⊢ (∃ y_1, f y_1 = f (prod.fst y)) ∧ ∃ y_1, g y_1 = g (prod.snd y)

tactic: exact ⟨exists_apply_eq_apply _ _, exists_apply_eq_apply _ _⟩
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
y : ↑(W ⨯ X)
⊢ (∃ y_1, f y_1 = f (prod.fst y)) ∧ ∃ y_1, g y_1 = g (prod.snd y)
state_after: no goals

tactic: rintro ⟨⟨x₁, hx₁⟩, ⟨x₂, hx₂⟩⟩
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g → x ∈ Set.range ⇑(prod.map f g)
state_after: case h.mpr.intro.intro.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ x ∈ Set.range ⇑(prod.map f g)

tactic: use (prodIsoProd W X).inv (x₁, x₂)
state_before: case h.mpr.intro.intro.intro
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ x ∈ Set.range ⇑(prod.map f g)
state_after: case h
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂)) = x

tactic: change (forget TopCat).map _ _ = _
state_before: case h
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂)) = x
state_after: case h
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (forget TopCat).map (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂)) = x

tactic: apply Concrete.limit_ext
state_before: case h
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (forget TopCat).map (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂)) = x
state_after: case h.a
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ ∀ (j : Discrete WalkingPair),
    (limit.π (pair Y Z) j) ((forget TopCat).map (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
      (limit.π (pair Y Z) j) x

tactic: rintro ⟨⟨⟩⟩
state_before: case h.a
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ ∀ (j : Discrete WalkingPair),
    (limit.π (pair Y Z) j) ((forget TopCat).map (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
      (limit.π (pair Y Z) j) x
state_after: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (limit.π (pair Y Z) { as := WalkingPair.left })
      ((forget TopCat).map (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
    (limit.π (pair Y Z) { as := WalkingPair.left }) x

case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (limit.π (pair Y Z) { as := WalkingPair.right })
      ((forget TopCat).map (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
    (limit.π (pair Y Z) { as := WalkingPair.right }) x

tactic: change limit.π (pair Y Z) _ ((prod.map f g) _) = _
state_before: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (limit.π (pair Y Z) { as := WalkingPair.left })
      ((forget TopCat).map (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
    (limit.π (pair Y Z) { as := WalkingPair.left }) x
state_after: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (limit.π (pair Y Z) { as := WalkingPair.left }) ((prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
    (limit.π (pair Y Z) { as := WalkingPair.left }) x

tactic: erw [← comp_apply, Limits.prod.map_fst]
state_before: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (limit.π (pair Y Z) { as := WalkingPair.left }) ((prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
    (limit.π (pair Y Z) { as := WalkingPair.left }) x
state_after: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (prod.fst ≫ f) ((W.prodIsoProd X).inv (x₁, x₂)) = (limit.π (pair Y Z) { as := WalkingPair.left }) x

tactic: change (_ ≫ _ ≫ f) _ = _
state_before: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (prod.fst ≫ f) ((W.prodIsoProd X).inv (x₁, x₂)) = (limit.π (pair Y Z) { as := WalkingPair.left }) x
state_after: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ ((W.prodIsoProd X).inv ≫ prod.fst ≫ f) (x₁, x₂) = (limit.π (pair Y Z) { as := WalkingPair.left }) x

tactic: erw [TopCat.prodIsoProd_inv_fst_assoc,TopCat.comp_app]
state_before: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ ((W.prodIsoProd X).inv ≫ prod.fst ≫ f) (x₁, x₂) = (limit.π (pair Y Z) { as := WalkingPair.left }) x
state_after: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ f (prodFst (x₁, x₂)) = (limit.π (pair Y Z) { as := WalkingPair.left }) x

tactic: exact hx₁
state_before: case h.a.mk.left
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ f (prodFst (x₁, x₂)) = (limit.π (pair Y Z) { as := WalkingPair.left }) x
state_after: no goals

tactic: change limit.π (pair Y Z) _ ((prod.map f g) _) = _
state_before: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (limit.π (pair Y Z) { as := WalkingPair.right })
      ((forget TopCat).map (prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
    (limit.π (pair Y Z) { as := WalkingPair.right }) x
state_after: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (limit.π (pair Y Z) { as := WalkingPair.right }) ((prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
    (limit.π (pair Y Z) { as := WalkingPair.right }) x

tactic: erw [← comp_apply, Limits.prod.map_snd]
state_before: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (limit.π (pair Y Z) { as := WalkingPair.right }) ((prod.map f g) ((W.prodIsoProd X).inv (x₁, x₂))) =
    (limit.π (pair Y Z) { as := WalkingPair.right }) x
state_after: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (prod.snd ≫ g) ((W.prodIsoProd X).inv (x₁, x₂)) = (limit.π (pair Y Z) { as := WalkingPair.right }) x

tactic: change (_ ≫ _ ≫ g) _ = _
state_before: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ (prod.snd ≫ g) ((W.prodIsoProd X).inv (x₁, x₂)) = (limit.π (pair Y Z) { as := WalkingPair.right }) x
state_after: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ ((W.prodIsoProd X).inv ≫ prod.snd ≫ g) (x₁, x₂) = (limit.π (pair Y Z) { as := WalkingPair.right }) x

tactic: erw [TopCat.prodIsoProd_inv_snd_assoc,TopCat.comp_app]
state_before: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ ((W.prodIsoProd X).inv ≫ prod.snd ≫ g) (x₁, x₂) = (limit.π (pair Y Z) { as := WalkingPair.right }) x
state_after: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ g (prodSnd (x₁, x₂)) = (limit.π (pair Y Z) { as := WalkingPair.right }) x

tactic: exact hx₂
state_before: case h.a.mk.right
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
x₁ : ↑W
hx₁ : f x₁ = prod.fst x
x₂ : ↑X
hx₂ : g x₂ = prod.snd x
⊢ g (prodSnd (x₁, x₂)) = (limit.π (pair Y Z) { as := WalkingPair.right }) x
state_after: no goals