File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Product.lean

full_name: FundamentalGroupoidFunctor.proj
code: /-- The projection map Π i, X i → X i induces a map π(Π i, X i) ⟶ π(X i).
-/
def proj (i : I) : πₓ (TopCat.of (∀ i, X i)) ⥤ πₓ (X i) 
goal: ↑(π.obj (TopCat.of ((i : I) → ↑(X i)))) ⥤ ↑(π.obj (X i))

full_name: FundamentalGroupoidFunctor.proj_map
code: /-- The projection map is precisely `Path.Homotopic.proj` interpreted as a functor -/
@[simp]
theorem proj_map (i : I) (x₀ x₁ : πₓ (TopCat.of (∀ i, X i))) (p : x₀ ⟶ x₁) :
    (proj X i).map p = @Path.Homotopic.proj _ _ _ _ _ i p 
goal: (FundamentalGroupoidFunctor.proj X i).map p = Path.Homotopic.proj i p

full_name: FundamentalGroupoidFunctor.piToPiTop_obj_as
code: /-- The map taking the pi product of a family of fundamental groupoids to the fundamental
groupoid of the pi product. This is actually an isomorphism (see `piIso`)
-/
@[simps]
def piToPiTop : (∀ i, πₓ (X i)) ⥤ πₓ (TopCat.of (∀ i, X i)) 
goal: ((FundamentalGroupoidFunctor.piToPiTop X).obj g).as i = (g i).as

full_name: FundamentalGroupoidFunctor.piToPiTop_map
code: /-- The map taking the pi product of a family of fundamental groupoids to the fundamental
groupoid of the pi product. This is actually an isomorphism (see `piIso`)
-/
@[simps]
def piToPiTop : (∀ i, πₓ (X i)) ⥤ πₓ (TopCat.of (∀ i, X i)) 
goal: ∀ {X_1 Y : (i : I) → ↑(π.obj (X i))} (p : X_1 ⟶ Y), (FundamentalGroupoidFunctor.piToPiTop X).map p = Path.Homotopic.pi p

full_name: FundamentalGroupoidFunctor.piToPiTop
code: /-- The map taking the pi product of a family of fundamental groupoids to the fundamental
groupoid of the pi product. This is actually an isomorphism (see `piIso`)
-/
@[simps]
def piToPiTop : (∀ i, πₓ (X i)) ⥤ πₓ (TopCat.of (∀ i, X i)) 
goal: ((i : I) → ↑(π.obj (X i))) ⥤ ↑(π.obj (TopCat.of ((i : I) → ↑(X i))))

full_name: FundamentalGroupoidFunctor.piIso_hom
code: /-- Shows `piToPiTop` is an isomorphism, whose inverse is precisely the pi product
of the induced projections. This shows that `fundamentalGroupoidFunctor` preserves products.
-/
@[simps]
def piIso : CategoryTheory.Grpd.of (∀ i : I, πₓ (X i)) ≅ πₓ (TopCat.of (∀ i, X i)) 
goal: (FundamentalGroupoidFunctor.piIso X).hom = FundamentalGroupoidFunctor.piToPiTop X

full_name: FundamentalGroupoidFunctor.piIso
code: /-- Shows `piToPiTop` is an isomorphism, whose inverse is precisely the pi product
of the induced projections. This shows that `fundamentalGroupoidFunctor` preserves products.
-/
@[simps]
def piIso : CategoryTheory.Grpd.of (∀ i : I, πₓ (X i)) ≅ πₓ (TopCat.of (∀ i, X i)) 
goal: CategoryTheory.Grpd.of ((i : I) → ↑(π.obj (X i))) ≅ π.obj (TopCat.of ((i : I) → ↑(X i)))

full_name: FundamentalGroupoidFunctor.piIso_inv
code: /-- Shows `piToPiTop` is an isomorphism, whose inverse is precisely the pi product
of the induced projections. This shows that `fundamentalGroupoidFunctor` preserves products.
-/
@[simps]
def piIso : CategoryTheory.Grpd.of (∀ i : I, πₓ (X i)) ≅ πₓ (TopCat.of (∀ i, X i)) 
goal: (FundamentalGroupoidFunctor.piIso X).inv = CategoryTheory.Functor.pi' (FundamentalGroupoidFunctor.proj X)

full_name: FundamentalGroupoidFunctor.coneDiscreteComp
code: /-- Equivalence between the categories of cones over the objects `π Xᵢ` written in two ways -/
def coneDiscreteComp :
    Limits.Cone (Discrete.functor X ⋙ π) ≌ Limits.Cone (Discrete.functor fun i => πₓ (X i)) 
goal: CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor X ⋙ π) ≌
  CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor fun i => π.obj (X i))

full_name: FundamentalGroupoidFunctor.coneDiscreteComp_obj_mapCone
code: theorem coneDiscreteComp_obj_mapCone :
    -- Porting note: check universe parameters here
    (coneDiscreteComp X).functor.obj (Functor.mapCone π (TopCat.piFan.{u,u} X)) =
      Limits.Fan.mk (πₓ (TopCat.of (∀ i, X i))) (proj X) 
goal: (FundamentalGroupoidFunctor.coneDiscreteComp X).functor.obj (π.mapCone (TopCat.piFan X)) =
  CategoryTheory.Limits.Fan.mk (π.obj (TopCat.of ((i : I) → ↑(X i)))) (FundamentalGroupoidFunctor.proj X)

full_name: FundamentalGroupoidFunctor.piTopToPiCone
code: /-- This is `piIso.inv` as a cone morphism (in fact, isomorphism) -/
def piTopToPiCone :
    Limits.Fan.mk (πₓ (TopCat.of (∀ i, X i))) (proj X) ⟶ Grpd.piLimitFan fun i : I => πₓ (X i) 
goal: CategoryTheory.Limits.Fan.mk (π.obj (TopCat.of ((i : I) → ↑(X i)))) (FundamentalGroupoidFunctor.proj X) ⟶
  CategoryTheory.Grpd.piLimitFan fun i => π.obj (X i)

full_name: FundamentalGroupoidFunctor.instIsIsoFanGrpdObjTopCatFundamentalGroupoidFunctorPiTopToPiCone
code: instance : IsIso (piTopToPiCone X) 
goal: CategoryTheory.IsIso (FundamentalGroupoidFunctor.piTopToPiCone X)

full_name: FundamentalGroupoidFunctor.preservesProduct
code: /-- The fundamental groupoid functor preserves products -/
def preservesProduct : Limits.PreservesLimit (Discrete.functor X) π 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Discrete.functor X) π

full_name: FundamentalGroupoidFunctor.projLeft
code: /-- The induced map of the left projection map X × Y → X -/
def projLeft : πₓ (TopCat.of (A × B)) ⥤ πₓ A 
goal: ↑(π.obj (TopCat.of (↑A × ↑B))) ⥤ ↑(π.obj A)

full_name: FundamentalGroupoidFunctor.projRight
code: /-- The induced map of the right projection map X × Y → Y -/
def projRight : πₓ (TopCat.of (A × B)) ⥤ πₓ B 
goal: ↑(π.obj (TopCat.of (↑A × ↑B))) ⥤ ↑(π.obj B)

full_name: FundamentalGroupoidFunctor.projLeft_map
code: @[simp]
theorem projLeft_map (x₀ x₁ : πₓ (TopCat.of (A × B))) (p : x₀ ⟶ x₁) :
    (projLeft A B).map p = Path.Homotopic.projLeft p 
goal: (FundamentalGroupoidFunctor.projLeft A B).map p = Path.Homotopic.projLeft p

full_name: FundamentalGroupoidFunctor.projRight_map
code: @[simp]
theorem projRight_map (x₀ x₁ : πₓ (TopCat.of (A × B))) (p : x₀ ⟶ x₁) :
    (projRight A B).map p = Path.Homotopic.projRight p 
goal: (FundamentalGroupoidFunctor.projRight A B).map p = Path.Homotopic.projRight p

full_name: FundamentalGroupoidFunctor.prodToProdTop_obj
code: /--
The map taking the product of two fundamental groupoids to the fundamental groupoid of the product
of the two topological spaces. This is in fact an isomorphism (see `prodIso`).
-/
@[simps obj]
def prodToProdTop : πₓ A × πₓ B ⥤ πₓ (TopCat.of (A × B)) 
goal: (FundamentalGroupoidFunctor.prodToProdTop A B).obj g = { as := (g.1.as, g.2.as) }

full_name: FundamentalGroupoidFunctor.prodToProdTop
code: /--
The map taking the product of two fundamental groupoids to the fundamental groupoid of the product
of the two topological spaces. This is in fact an isomorphism (see `prodIso`).
-/
@[simps obj]
def prodToProdTop : πₓ A × πₓ B ⥤ πₓ (TopCat.of (A × B)) 
goal: ↑(π.obj A) × ↑(π.obj B) ⥤ ↑(π.obj (TopCat.of (↑A × ↑B)))

full_name: FundamentalGroupoidFunctor.prodToProdTop_map
code: theorem prodToProdTop_map {x₀ x₁ : πₓ A} {y₀ y₁ : πₓ B} (p₀ : x₀ ⟶ x₁) (p₁ : y₀ ⟶ y₁) :
    (prodToProdTop A B).map (X := (x₀, y₀)) (Y := (x₁, y₁)) (p₀, p₁) =
      Path.Homotopic.prod p₀ p₁ 
goal: (FundamentalGroupoidFunctor.prodToProdTop A B).map (p₀, p₁) = Path.Homotopic.prod p₀ p₁

full_name: FundamentalGroupoidFunctor.prodIso
code: /-- Shows `prodToProdTop` is an isomorphism, whose inverse is precisely the product
of the induced left and right projections.
-/
@[simps]
def prodIso : CategoryTheory.Grpd.of (πₓ A × πₓ B) ≅ πₓ (TopCat.of (A × B)) 
goal: CategoryTheory.Grpd.of (↑(π.obj A) × ↑(π.obj B)) ≅ π.obj (TopCat.of (↑A × ↑B))

full_name: FundamentalGroupoidFunctor.prodIso_inv
code: /-- Shows `prodToProdTop` is an isomorphism, whose inverse is precisely the product
of the induced left and right projections.
-/
@[simps]
def prodIso : CategoryTheory.Grpd.of (πₓ A × πₓ B) ≅ πₓ (TopCat.of (A × B)) 
goal: (FundamentalGroupoidFunctor.prodIso A B).inv =
  (FundamentalGroupoidFunctor.projLeft A B).prod' (FundamentalGroupoidFunctor.projRight A B)

full_name: FundamentalGroupoidFunctor.prodIso_hom
code: /-- Shows `prodToProdTop` is an isomorphism, whose inverse is precisely the product
of the induced left and right projections.
-/
@[simps]
def prodIso : CategoryTheory.Grpd.of (πₓ A × πₓ B) ≅ πₓ (TopCat.of (A × B)) 
goal: (FundamentalGroupoidFunctor.prodIso A B).hom = FundamentalGroupoidFunctor.prodToProdTop A B