Quivers

This module defines quivers. A quiver on a type V of vertices assigns to every pair a b : V of vertices a type a ⟶ b of arrows from a to b. This is a very permissive notion of directed graph.

Implementation notes

Currently Quiver is defined with Hom : V → V → Sort v. This is different from the category theory setup, where we insist that morphisms live in some Type. There's some balance here: it's nice to allow Prop to ensure there are no multiple arrows, but it is also results in error-prone universe signatures when constraints require a Type.

class Quiver (V : Type u) : Type (max u v)

A quiver G on a type V of vertices assigns to every pair a b : V of vertices a type a ⟶ b of arrows from a to b.

For graphs with no repeated edges, one can use Quiver.{0} V, which ensures a ⟶ b : Prop. For multigraphs, one can use Quiver.{v+1} V, which ensures a ⟶ b : Type v.

Because Category will later extend this class, we call the field Hom. Except when constructing instances, you should rarely see this, and use the ⟶ notation instead.

• Hom : V → V → Sort v

  The type of edges/arrows/morphisms between a given source and target.

def «term_⟶_» : Lean.TrailingParserDescr

Notation for the type of edges/arrows/morphisms between a given source and target in a quiver or category.

Equations

• «term_⟶_» = Lean.ParserDescr.trailingNode `«term_⟶_» 10 11 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ⟶ ") (Lean.ParserDescr.cat `term 10))

structure Prefunctor (V : Type u₁) [Quiver V] (W : Type u₂) [Quiver W] : Sort (max (max (max (u₁ + 1) (u₂ + 1)) v₁) v₂)

A morphism of quivers. As we will later have categorical functors extend this structure, we call it a Prefunctor.

• obj : V → W

  The action of a (pre)functor on vertices/objects.

• map : {X Y : V} → (X ⟶ Y) → (self.obj X ⟶ self.obj Y)

  The action of a (pre)functor on edges/arrows/morphisms.

theorem Prefunctor.mk_obj {V : Type u_1} {W : Type u_2} [Quiver V] [Quiver W] {obj : V → W} {map : {X Y : V} → (X ⟶ Y) → (obj X ⟶ obj Y)} {X : V} : { obj := obj, map := map }.obj X = obj X

theorem Prefunctor.mk_map {V : Type u_1} {W : Type u_2} [Quiver V] [Quiver W] {obj : V → W} {map : {X Y : V} → (X ⟶ Y) → (obj X ⟶ obj Y)} {X Y : V} {f : X ⟶ Y} : { obj := obj, map := map }.map f = map f

theorem Prefunctor.ext {V : Type u} [Quiver V] {W : Type u₂} [Quiver W] {F G : V ⥤q W} (h_obj : ∀ (X : V), F.obj X = G.obj X) (h_map : ∀ (X Y : V) (f : X ⟶ Y), F.map f = Eq.recOn ⋯ (Eq.recOn ⋯ (G.map f))) : F = G

def Prefunctor.id (V : Type u_1) [Quiver V] : V ⥤q V

The identity morphism between quivers.

Equations

• 𝟭q V = { obj := fun (X : V) => X, map := fun {X Y : V} (f : X ⟶ Y) => f }

@[simp]

theorem Prefunctor.id_map (V : Type u_1) [Quiver V] {X✝ Y✝ : V} (f : X✝ ⟶ Y✝) : (𝟭q V).map f = f

@[simp]

theorem Prefunctor.id_obj (V : Type u_1) [Quiver V] (X : V) : (𝟭q V).obj X = X

instance Prefunctor.instInhabited (V : Type u_1) [Quiver V] : Inhabited (V ⥤q V)

Equations

• Prefunctor.instInhabited V = { default := 𝟭q V }

def Prefunctor.comp {U : Type u_1} [Quiver U] {V : Type u_2} [Quiver V] {W : Type u_3} [Quiver W] (F : U ⥤q V) (G : V ⥤q W) : U ⥤q W

Composition of morphisms between quivers.

Equations

• F ⋙q G = { obj := fun (X : U) => G.obj (F.obj X), map := fun {X Y : U} (f : X ⟶ Y) => G.map (F.map f) }

@[simp]

theorem Prefunctor.comp_obj {U : Type u_1} [Quiver U] {V : Type u_2} [Quiver V] {W : Type u_3} [Quiver W] (F : U ⥤q V) (G : V ⥤q W) (X : U) : (F ⋙q G).obj X = G.obj (F.obj X)

@[simp]

theorem Prefunctor.comp_map {U : Type u_1} [Quiver U] {V : Type u_2} [Quiver V] {W : Type u_3} [Quiver W] (F : U ⥤q V) (G : V ⥤q W) {X✝ Y✝ : U} (f : X✝ ⟶ Y✝) : (F ⋙q G).map f = G.map (F.map f)

@[simp]

theorem Prefunctor.comp_id {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] (F : U ⥤q V) : F ⋙q 𝟭q V = F

@[simp]

theorem Prefunctor.id_comp {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] (F : U ⥤q V) : 𝟭q U ⋙q F = F

@[simp]

theorem Prefunctor.comp_assoc {U : Type u_1} {V : Type u_2} {W : Type u_3} {Z : Type u_4} [Quiver U] [Quiver V] [Quiver W] [Quiver Z] (F : U ⥤q V) (G : V ⥤q W) (H : W ⥤q Z) : F ⋙q G ⋙q H = F ⋙q (G ⋙q H)

def Prefunctor.«term_⥤q_» : Lean.TrailingParserDescr

Notation for a prefunctor between quivers.

Equations

• Prefunctor.«term_⥤q_» = Lean.ParserDescr.trailingNode `Prefunctor.«term_⥤q_» 50 50 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ⥤q ") (Lean.ParserDescr.cat `term 51))

def Prefunctor.«term_⋙q_» : Lean.TrailingParserDescr

Notation for composition of prefunctors.

Equations

• Prefunctor.«term_⋙q_» = Lean.ParserDescr.trailingNode `Prefunctor.«term_⋙q_» 60 60 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ⋙q ") (Lean.ParserDescr.cat `term 61))

def Prefunctor.«term𝟭q» : Lean.ParserDescr

Notation for the identity prefunctor on a quiver.

Equations

• Prefunctor.«term𝟭q» = Lean.ParserDescr.node `Prefunctor.«term𝟭q» 1024 (Lean.ParserDescr.symbol "𝟭q")

theorem Prefunctor.congr_map {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] (F : U ⥤q V) {X Y : U} {f g : X ⟶ Y} (h : f = g) : F.map f = F.map g

instance Quiver.opposite {V : Type u_1} [Quiver V] : Quiver Vᵒᵖ

Vᵒᵖ reverses the direction of all arrows of V.

Equations

• Quiver.opposite = { Hom := fun (a b : Vᵒᵖ) => (Opposite.unop b ⟶ Opposite.unop a)ᵒᵖ }

def Quiver.Hom.op {V : Type u_1} [Quiver V] {X Y : V} (f : X ⟶ Y) : Opposite.op Y ⟶ Opposite.op X

The opposite of an arrow in V.

Equations

• f.op = Opposite.op f

def Quiver.Hom.unop {V : Type u_1} [Quiver V] {X Y : Vᵒᵖ} (f : X ⟶ Y) : Opposite.unop Y ⟶ Opposite.unop X

Given an arrow in Vᵒᵖ, we can take the "unopposite" back in V.

Equations

• f.unop = Opposite.unop f

def Quiver.Hom.opEquiv {V : Type u_1} [Quiver V] {X Y : V} : (X ⟶ Y) ≃ (Opposite.op Y ⟶ Opposite.op X)

The bijection (X ⟶ Y) ≃ (op Y ⟶ op X).

Equations

• Quiver.Hom.opEquiv = { toFun := Opposite.op, invFun := Opposite.unop, left_inv := ⋯, right_inv := ⋯ }

@[simp]

theorem Quiver.Hom.opEquiv_symm_apply {V : Type u_1} [Quiver V] {X Y : V} (self : (Opposite.unop (Opposite.op X) ⟶ Opposite.unop (Opposite.op Y))ᵒᵖ) : Quiver.Hom.opEquiv.symm self = Opposite.unop self

@[simp]

theorem Quiver.Hom.opEquiv_apply {V : Type u_1} [Quiver V] {X Y : V} (unop : X ⟶ Y) : Quiver.Hom.opEquiv unop = Opposite.op unop

def Quiver.Empty (V : Type u) : Type u

A type synonym for a quiver with no arrows.

Equations

• Quiver.Empty V = V

instance Quiver.emptyQuiver (V : Type u) : Quiver (Quiver.Empty V)

Equations

• Quiver.emptyQuiver V = { Hom := fun (x x : Quiver.Empty V) => PEmpty.{?u.13} }

@[simp]

theorem Quiver.empty_arrow {V : Type u} (a b : Quiver.Empty V) : (a ⟶ b) = PEmpty.{u}

@[reducible, inline]

abbrev Quiver.IsThin (V : Type u) [Quiver V] : Prop

A quiver is thin if it has no parallel arrows.

Equations

• Quiver.IsThin V = ∀ (a b : V), Subsingleton (a ⟶ b)