Connected components of a category

Defines a type ConnectedComponents J indexing the connected components of a category, and the full subcategories giving each connected component: Component j : Type u₁. We show that each Component j is in fact connected.

We show every category can be expressed as a disjoint union of its connected components, in particular Decomposed J is the category (definitionally) given by the sigma-type of the connected components of J, and it is shown that this is equivalent to J.

def CategoryTheory.ConnectedComponents (J : Type u₁) [Category.{v₁, u₁} J] : Type u₁

This type indexes the connected components of the category J.

Equations

• CategoryTheory.ConnectedComponents J = Quotient (CategoryTheory.Zigzag.setoid J)

def CategoryTheory.Functor.mapConnectedComponents {J : Type u₁} [Category.{v₁, u₁} J] {K : Type u₂} [Category.{v₂, u₂} K] (F : Functor J K) (x : ConnectedComponents J) : ConnectedComponents K

The map ConnectedComponents J → ConnectedComponents K induced by a functor J ⥤ K.

Equations

• F.mapConnectedComponents x = Quotient.lift (Quotient.mk (CategoryTheory.Zigzag.setoid K) ∘ F.obj) ⋯ x

@[simp]

theorem CategoryTheory.Functor.mapConnectedComponents_mk {J : Type u₁} [Category.{v₁, u₁} J] {K : Type u₂} [Category.{v₂, u₂} K] (F : Functor J K) (j : J) : F.mapConnectedComponents ⟦j⟧ = ⟦F.obj j⟧

instance CategoryTheory.instInhabitedConnectedComponents {J : Type u₁} [Category.{v₁, u₁} J] [Inhabited J] : Inhabited (ConnectedComponents J)

Equations

• CategoryTheory.instInhabitedConnectedComponents = { default := Quotient.mk'' default }

def CategoryTheory.ConnectedComponents.functorToDiscrete {J : Type u₁} [Category.{v₁, u₁} J] (X : Type u_1) (f : ConnectedComponents J → X) : Functor J (Discrete X)

Every function from connected components of a category gives a functor to discrete category

Equations

• One or more equations did not get rendered due to their size.

def CategoryTheory.ConnectedComponents.liftFunctor (J : Type u_2) [Category.{u_3, u_2} J] {X : Type u_1} (F : Functor J (Discrete X)) : ConnectedComponents J → X

Every functor to a discrete category gives a function from connected components

Equations

• CategoryTheory.ConnectedComponents.liftFunctor J F = Quotient.lift (fun (c : J) => (F.obj c).as) ⋯

def CategoryTheory.ConnectedComponents.typeToCatHomEquiv (J : Type u_2) [Category.{u_3, u_2} J] (X : Type u_1) : (ConnectedComponents J → X) ≃ Functor J (Discrete X)

Functions from connected components and functors to discrete category are in bijection

Equations

• One or more equations did not get rendered due to their size.

def CategoryTheory.Component {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) : Type u₁

Given an index for a connected component, produce the actual component as a full subcategory.

Equations

• CategoryTheory.Component j = CategoryTheory.FullSubcategory fun (k : J) => Quotient.mk'' k = j

instance CategoryTheory.instCategoryComponent {J : Type u₁} [Category.{v₁, u₁} J] {j : ConnectedComponents J} : Category.{v₁, u₁} (Component j)

Equations

• CategoryTheory.instCategoryComponent = CategoryTheory.FullSubcategory.category fun (k : J) => Quotient.mk'' k = j

def CategoryTheory.Component.ι {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) : Functor (Component j) J

The inclusion functor from a connected component to the whole category.

Equations

• CategoryTheory.Component.ι j = CategoryTheory.fullSubcategoryInclusion fun (k : J) => Quotient.mk'' k = j

@[simp]

theorem CategoryTheory.Component.ι_map {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) {X✝ Y✝ : InducedCategory J FullSubcategory.obj} (f : X✝ ⟶ Y✝) : (ι j).map f = f

@[simp]

theorem CategoryTheory.Component.ι_obj {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) (self : FullSubcategory fun (k : J) => Quotient.mk'' k = j) : (ι j).obj self = self.obj

instance CategoryTheory.instFullComponentι {J : Type u₁} [Category.{v₁, u₁} J] {j : ConnectedComponents J} : (Component.ι j).Full

instance CategoryTheory.instFaithfulComponentι {J : Type u₁} [Category.{v₁, u₁} J] {j : ConnectedComponents J} : (Component.ι j).Faithful

instance CategoryTheory.instNonemptyComponent {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) : Nonempty (Component j)

Each connected component of the category is nonempty.

instance CategoryTheory.instInhabitedComponent {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) : Inhabited (Component j)

Equations

• CategoryTheory.instInhabitedComponent j = Classical.inhabited_of_nonempty'

instance CategoryTheory.instIsConnectedComponent {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) : IsConnected (Component j)

Each connected component of the category is connected.

@[reducible, inline]

abbrev CategoryTheory.Decomposed (J : Type u₁) [Category.{v₁, u₁} J] : Type u₁

The disjoint union of Js connected components, written explicitly as a sigma-type with the category structure. This category is equivalent to J.

Equations

• CategoryTheory.Decomposed J = ((j : CategoryTheory.ConnectedComponents J) × CategoryTheory.Component j)

@[reducible, inline]

abbrev CategoryTheory.inclusion {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) : Functor (Component j) (Decomposed J)

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.

Equations

• CategoryTheory.inclusion j = CategoryTheory.Sigma.incl j

def CategoryTheory.decomposedTo (J : Type u₁) [Category.{v₁, u₁} J] : Functor (Decomposed J) J

The forward direction of the equivalence between the decomposed category and the original.

Equations

• CategoryTheory.decomposedTo J = CategoryTheory.Sigma.desc CategoryTheory.Component.ι

@[simp]

theorem CategoryTheory.decomposedTo_map (J : Type u₁) [Category.{v₁, u₁} J] {X✝ Y✝ : (i : ConnectedComponents J) × Component i} (g : X✝ ⟶ Y✝) : (decomposedTo J).map g = Sigma.descMap Component.ι X✝ Y✝ g

@[simp]

theorem CategoryTheory.decomposedTo_obj (J : Type u₁) [Category.{v₁, u₁} J] (X : (i : ConnectedComponents J) × Component i) : (decomposedTo J).obj X = X.snd.obj

@[simp]

theorem CategoryTheory.inclusion_comp_decomposedTo {J : Type u₁} [Category.{v₁, u₁} J] (j : ConnectedComponents J) : (inclusion j).comp (decomposedTo J) = Component.ι j

instance CategoryTheory.instFullDecomposedDecomposedTo {J : Type u₁} [Category.{v₁, u₁} J] : (decomposedTo J).Full

instance CategoryTheory.instFaithfulDecomposedDecomposedTo {J : Type u₁} [Category.{v₁, u₁} J] : (decomposedTo J).Faithful

instance CategoryTheory.instEssSurjDecomposedDecomposedTo {J : Type u₁} [Category.{v₁, u₁} J] : (decomposedTo J).EssSurj

instance CategoryTheory.instIsEquivalenceDecomposedDecomposedTo {J : Type u₁} [Category.{v₁, u₁} J] : (decomposedTo J).IsEquivalence

def CategoryTheory.decomposedEquiv {J : Type u₁} [Category.{v₁, u₁} J] : Decomposed J ≌ J

This gives that any category is equivalent to a disjoint union of connected categories.

Equations

• CategoryTheory.decomposedEquiv = (CategoryTheory.decomposedTo J).asEquivalence

@[simp]

theorem CategoryTheory.decomposedEquiv_functor {J : Type u₁} [Category.{v₁, u₁} J] : decomposedEquiv.functor = decomposedTo J