File: Mathlib/CategoryTheory/Limits/Connected.lean

full_name: CategoryTheory.widePullbackShape_connected
code: instance widePullbackShape_connected (J : Type v₁) : IsConnected (WidePullbackShape J) 
goal: CategoryTheory.IsConnected (CategoryTheory.Limits.WidePullbackShape J)

full_name: CategoryTheory.widePushoutShape_connected
code: instance widePushoutShape_connected (J : Type v₁) : IsConnected (WidePushoutShape J) 
goal: CategoryTheory.IsConnected (CategoryTheory.Limits.WidePushoutShape J)

full_name: CategoryTheory.parallelPairInhabited
code: instance parallelPairInhabited : Inhabited WalkingParallelPair 
goal: Inhabited CategoryTheory.Limits.WalkingParallelPair

full_name: CategoryTheory.parallel_pair_connected
code: instance parallel_pair_connected : IsConnected WalkingParallelPair 
goal: CategoryTheory.IsConnected CategoryTheory.Limits.WalkingParallelPair

full_name: CategoryTheory.ProdPreservesConnectedLimits.γ₂
code: /-- (Impl). The obvious natural transformation from (X × K -) to K. -/
@[simps]
def γ₂ {K : J ⥤ C} (X : C) : K ⋙ prod.functor.obj X ⟶ K 
goal: K ⋙ CategoryTheory.Limits.prod.functor.obj X ⟶ K

full_name: CategoryTheory.ProdPreservesConnectedLimits.γ₂_app
code: /-- (Impl). The obvious natural transformation from (X × K -) to K. -/
@[simps]
def γ₂ {K : J ⥤ C} (X : C) : K ⋙ prod.functor.obj X ⟶ K 
goal: (CategoryTheory.ProdPreservesConnectedLimits.γ₂ X).app Y = CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.ProdPreservesConnectedLimits.γ₁_app
code: /-- (Impl). The obvious natural transformation from (X × K -) to X -/
@[simps]
def γ₁ {K : J ⥤ C} (X : C) : K ⋙ prod.functor.obj X ⟶ (Functor.const J).obj X 
goal: (CategoryTheory.ProdPreservesConnectedLimits.γ₁ X).app Y = CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.ProdPreservesConnectedLimits.γ₁
code: /-- (Impl). The obvious natural transformation from (X × K -) to X -/
@[simps]
def γ₁ {K : J ⥤ C} (X : C) : K ⋙ prod.functor.obj X ⟶ (Functor.const J).obj X 
goal: K ⋙ CategoryTheory.Limits.prod.functor.obj X ⟶ (CategoryTheory.Functor.const J).obj X

full_name: CategoryTheory.ProdPreservesConnectedLimits.forgetCone_pt
code: /-- (Impl).
Given a cone for (X × K -), produce a cone for K using the natural transformation `γ₂` -/
@[simps]
def forgetCone {X : C} {K : J ⥤ C} (s : Cone (K ⋙ prod.functor.obj X)) : Cone K 
goal: (CategoryTheory.ProdPreservesConnectedLimits.forgetCone s).pt = s.pt

full_name: CategoryTheory.ProdPreservesConnectedLimits.forgetCone
code: /-- (Impl).
Given a cone for (X × K -), produce a cone for K using the natural transformation `γ₂` -/
@[simps]
def forgetCone {X : C} {K : J ⥤ C} (s : Cone (K ⋙ prod.functor.obj X)) : Cone K 
goal: CategoryTheory.Limits.Cone K

full_name: CategoryTheory.ProdPreservesConnectedLimits.forgetCone_π
code: /-- (Impl).
Given a cone for (X × K -), produce a cone for K using the natural transformation `γ₂` -/
@[simps]
def forgetCone {X : C} {K : J ⥤ C} (s : Cone (K ⋙ prod.functor.obj X)) : Cone K 
goal: (CategoryTheory.ProdPreservesConnectedLimits.forgetCone s).π = s.π ≫ CategoryTheory.ProdPreservesConnectedLimits.γ₂ X

full_name: CategoryTheory.prodPreservesConnectedLimits
code: /-- The functor `(X × -)` preserves any connected limit.
Note that this functor does not preserve the two most obvious disconnected limits - that is,
`(X × -)` does not preserve products or terminal object, eg `(X ⨯ A) ⨯ (X ⨯ B)` is not isomorphic to
`X ⨯ (A ⨯ B)` and `X ⨯ 1` is not isomorphic to `1`.
-/
noncomputable def prodPreservesConnectedLimits [IsConnected J] (X : C) :
    PreservesLimitsOfShape J (prod.functor.obj X) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.Limits.prod.functor.obj X)