File: Mathlib/CategoryTheory/ConnectedComponents.lean

full_name: CategoryTheory.ConnectedComponents
code: /-- This type indexes the connected components of the category `J`. -/
def ConnectedComponents (J : Type u₁) [Category.{v₁} J] : Type u₁ 
goal: Type u₁

full_name: CategoryTheory.instInhabitedConnectedComponents
code: instance [Inhabited J] : Inhabited (ConnectedComponents J) 
goal: Inhabited (CategoryTheory.ConnectedComponents J)

full_name: CategoryTheory.Component
code: /-- Given an index for a connected component, produce the actual component as a full subcategory. -/
def Component (j : ConnectedComponents J) : Type u₁ 
goal: Type u₁

full_name: CategoryTheory.instCategoryComponent
code: instance {j : ConnectedComponents J} : Category (Component j) 
goal: CategoryTheory.Category.{v₁, u₁} (CategoryTheory.Component j)

full_name: CategoryTheory.Component.ι_map
code: /-- The inclusion functor from a connected component to the whole category. -/
@[simps!]
def Component.ι (j : ConnectedComponents J) : Component j ⥤ J 
goal: ∀ {X Y : CategoryTheory.InducedCategory J CategoryTheory.FullSubcategory.obj} (f : X ⟶ Y),
  (CategoryTheory.Component.ι j).map f = f

full_name: CategoryTheory.Component.ι
code: /-- The inclusion functor from a connected component to the whole category. -/
@[simps!]
def Component.ι (j : ConnectedComponents J) : Component j ⥤ J 
goal: CategoryTheory.Functor (CategoryTheory.Component j) J

full_name: CategoryTheory.Component.ι_obj
code: /-- The inclusion functor from a connected component to the whole category. -/
@[simps!]
def Component.ι (j : ConnectedComponents J) : Component j ⥤ J 
goal: (CategoryTheory.Component.ι j).obj self = self.obj

full_name: CategoryTheory.instFullComponentι
code: instance {j : ConnectedComponents J} : Functor.Full (Component.ι j) 
goal: (CategoryTheory.Component.ι j).Full

full_name: CategoryTheory.instFaithfulComponentι
code: instance {j : ConnectedComponents J} : Functor.Faithful (Component.ι j) 
goal: (CategoryTheory.Component.ι j).Faithful

full_name: CategoryTheory.instNonemptyComponent
code: /-- Each connected component of the category is nonempty. -/
instance (j : ConnectedComponents J) : Nonempty (Component j) 
goal: Nonempty (CategoryTheory.Component j)

full_name: CategoryTheory.instInhabitedComponent
code: instance (j : ConnectedComponents J) : Inhabited (Component j) 
goal: Inhabited (CategoryTheory.Component j)

full_name: CategoryTheory.instIsConnectedComponent
code: /-- Each connected component of the category is connected. -/
instance (j : ConnectedComponents J) : IsConnected (Component j) 
goal: CategoryTheory.IsConnected (CategoryTheory.Component j)

full_name: CategoryTheory.Decomposed
code: /-- The disjoint union of `J`s connected components, written explicitly as a sigma-type with the
category structure.
This category is equivalent to `J`.
-/
abbrev Decomposed (J : Type u₁) [Category.{v₁} J] 
goal: Type u₁

full_name: CategoryTheory.inclusion
code: /--
The inclusion of each component into the decomposed category. This is just `sigma.incl` but having
this abbreviation helps guide typeclass search to get the right category instance on `decomposed J`.
-/
abbrev inclusion (j : ConnectedComponents J) : Component j ⥤ Decomposed J 
goal: CategoryTheory.Functor (CategoryTheory.Component j) (CategoryTheory.Decomposed J)

full_name: CategoryTheory.decomposedTo_map
code: /-- The forward direction of the equivalence between the decomposed category and the original. -/
@[simps!]
def decomposedTo (J : Type u₁) [Category.{v₁} J] : Decomposed J ⥤ J 
goal: ∀ {X Y : (i : CategoryTheory.ConnectedComponents J) × CategoryTheory.Component i} (g : X ⟶ Y),
  (CategoryTheory.decomposedTo J).map g = CategoryTheory.Sigma.descMap CategoryTheory.Component.ι X Y g

full_name: CategoryTheory.decomposedTo
code: /-- The forward direction of the equivalence between the decomposed category and the original. -/
@[simps!]
def decomposedTo (J : Type u₁) [Category.{v₁} J] : Decomposed J ⥤ J 
goal: CategoryTheory.Functor (CategoryTheory.Decomposed J) J

full_name: CategoryTheory.decomposedTo_obj
code: /-- The forward direction of the equivalence between the decomposed category and the original. -/
@[simps!]
def decomposedTo (J : Type u₁) [Category.{v₁} J] : Decomposed J ⥤ J 
goal: (CategoryTheory.decomposedTo J).obj X = X.snd.obj

full_name: CategoryTheory.inclusion_comp_decomposedTo
code: @[simp]
theorem inclusion_comp_decomposedTo (j : ConnectedComponents J) :
    inclusion j ⋙ decomposedTo J = Component.ι j 
goal: (CategoryTheory.inclusion j).comp (CategoryTheory.decomposedTo J) = CategoryTheory.Component.ι j

full_name: CategoryTheory.instFullDecomposedDecomposedTo
code: instance : (decomposedTo J).Full 
goal: (CategoryTheory.decomposedTo J).Full

full_name: CategoryTheory.instFaithfulDecomposedDecomposedTo
code: instance : (decomposedTo J).Faithful 
goal: (CategoryTheory.decomposedTo J).Faithful

full_name: CategoryTheory.instEssSurjDecomposedDecomposedTo
code: instance : (decomposedTo J).EssSurj 
goal: (CategoryTheory.decomposedTo J).EssSurj

full_name: CategoryTheory.instIsEquivalenceDecomposedDecomposedTo
code: instance : (decomposedTo J).IsEquivalence 
goal: (CategoryTheory.decomposedTo J).IsEquivalence

full_name: CategoryTheory.decomposedEquiv_functor
code: /-- This gives that any category is equivalent to a disjoint union of connected categories. -/
@[simps! functor]
def decomposedEquiv : Decomposed J ≌ J 
goal: CategoryTheory.decomposedEquiv.functor = CategoryTheory.decomposedTo J

full_name: CategoryTheory.decomposedEquiv
code: /-- This gives that any category is equivalent to a disjoint union of connected categories. -/
@[simps! functor]
def decomposedEquiv : Decomposed J ≌ J 
goal: CategoryTheory.Decomposed J ≌ J