Documentation

TauCeti.RepresentationTheory.Quiver.Representation.Simple

The vertex simple representations of a quiver #

For a vertex i of a quiver Q, the vertex simple representation Sᵢ is the base field k at i and the zero module at every other vertex, every arrow acting by zero. This file constructs Sᵢ, proves that it is a simple object of the category of representations, and proves that over an acyclic quiver these are all the simple objects.

The construction is a CategoryTheory.Paths.lift of the prefunctor sending i to k, every other vertex to the zero module, and every arrow to the zero map; functoriality along path concatenation is then supplied by Mathlib. Simplicity is checked pointwise, and uses only that Sᵢ is supported at the single vertex i: a monomorphism into a representation that vanishes away from i is zero there, so it is determined by its component at i, where k is a simple k-module. Lifting the vertex spaces to a larger universe preserves both of those properties, so the lifted Sᵢ is simple as well.

The converse classification runs through the subrepresentations of TauCeti.RepresentationTheory.Quiver.Representation.Subrepresentation. A nonzero vector x of Mᵢ spans two of them: the subrepresentation it generates, and the one generated by the images of x along the paths of positive length. Over an acyclic quiver the second vanishes at i while the first contains x, so simplicity makes the second zero and the first everything; M is then the line through x at i and zero elsewhere, which is Sᵢ.

Main definitions #

Main results #

Implementation notes #

simpleRep branches on equality of vertices. It is noncomputable in any case, so that branch is decided classically and no DecidableEq Q instance appears in the interface; simpleRep_obj_self and simpleRep_obj_of_ne describe the two cases without mentioning the branch. Only dimVector_simpleRep assumes DecidableEq Q, because Pi.single needs one to be stated.

The objects of CategoryTheory.Paths Q are the vertices of Q, so the statements below use a vertex directly as an object of the path category. The classification is the exception: rw and simp build their motives at a transparency at which M.obj i for a vertex i : Q is not type-correct, so simpleRepHom and everything downstream of it spell the base vertex as (CategoryTheory.Paths.of Q).obj i, and pin the implicit vertex of the spanning subrepresentations to match.

The roadmap pins the simplicity result as simpleRep_simple, so the instance carries that name rather than the simple_simpleRep a Mathlib predicate prefix would give it.

References #

This implements the vertex simples of Layer 1 of TauCetiRoadmap/RepresentationTheory/QuiverRepresentations/README.md.

noncomputable def TauCeti.simpleRep (k : Type u) (Q : Type v) [Field k] [Quiver Q] (i : Q) :

The vertex simple representation Sᵢ of a quiver: the base field k at the vertex i, the zero module at every other vertex, and the zero map along every arrow.

Equations
Instances For
    @[simp]
    theorem TauCeti.simpleRep_obj_self {k : Type u} {Q : Type v} [Field k] [Quiver Q] (i : Q) :
    (simpleRep k Q i).obj i = ↧k

    At i, the vertex simple Sᵢ is the base field k.

    @[simp]
    theorem TauCeti.simpleRep_obj_of_ne {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i a : Q} (h : a ≠ i) :
    (simpleRep k Q i).obj a = 0

    Away from i, the vertex simple Sᵢ is the zero module.

    theorem TauCeti.isZero_simpleRep_obj {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i a : Q} (h : a ≠ i) :

    Away from i, the vertex simple Sᵢ vanishes.

    instance TauCeti.simple_simpleRep_obj_self {k : Type u} {Q : Type v} [Field k] [Quiver Q] (i : Q) :

    At i, the vertex simple Sᵢ is the simple k-module k.

    instance TauCeti.finiteDimensional_simpleRep_obj {k : Type u} {Q : Type v} [Field k] [Quiver Q] (i a : Q) :

    The vertex simple is a line at its vertex #

    noncomputable def TauCeti.simpleRepSelfEquiv (k : Type u) {Q : Type v} [Field k] [Quiver Q] (i : Q) :

    The vector space that the vertex simple Sᵢ puts at i is the base field.

    Equations
    Instances For
      noncomputable def TauCeti.simpleRepGenerator (k : Type u) {Q : Type v} [Field k] [Quiver Q] (i : Q) :

      The canonical generator of the line (Sᵢ)ᵢ: the element corresponding to 1 : k.

      Equations
      Instances For
        @[simp]

        The generator of (Sᵢ)ᵢ corresponds to 1 : k.

        theorem TauCeti.exists_eq_smul_simpleRepGenerator (k : Type u) {Q : Type v} [Field k] [Quiver Q] {i : Q} (x : ↑((simpleRep k Q i).obj ((CategoryTheory.Paths.of Q).obj i))) :
        ∃ (c : k), x = c • simpleRepGenerator k i

        The vertex simple is a line at its vertex: every element of (Sᵢ)ᵢ is a multiple of the generator.

        theorem TauCeti.simpleRepGenerator_ne_zero (k : Type u) {Q : Type v} [Field k] [Quiver Q] (i : Q) :

        The generator of (Sᵢ)ᵢ is nonzero.

        @[simp]
        theorem TauCeti.simpleRep_map_toPath {k : Type u} {Q : Type v} [Field k] [Quiver Q] (i : Q) {a b : Q} (e : a ⟶ b) :
        (simpleRep k Q i).map e.toPath = 0

        Every arrow of the quiver acts by zero on the vertex simple Sᵢ.

        @[simp]
        theorem TauCeti.simpleRep_map_cons {k : Type u} {Q : Type v} [Field k] [Quiver Q] (i : Q) {a b c : Q} (p : Quiver.Path a b) (e : b ⟶ c) :
        (simpleRep k Q i).map (p.cons e) = 0

        More generally, every path of positive length acts by zero on the vertex simple Sᵢ.

        theorem TauCeti.simpleRep_map_eq_zero_of_length_ne_zero {k : Type u} {Q : Type v} [Field k] [Quiver Q] (i : Q) {a b : Q} (p : Quiver.Path a b) (hp : p.length ≠ 0) :
        (simpleRep k Q i).map p = 0

        A path of positive length acts by zero on the vertex simple Sᵢ; only the trivial paths, which act by the identity, survive.

        @[simp]
        theorem TauCeti.hom_simpleRep_eq_zero_iff {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i : Q} {M : QuiverRep k Q} (f : M ⟶ simpleRep k Q i) :
        f = 0 ↔ f.app i = 0

        A morphism into the vertex simple Sᵢ vanishes as soon as its component at i does: all its other components land in a zero module.

        @[simp]
        theorem TauCeti.simpleRep_hom_eq_zero_iff {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i : Q} {M : QuiverRep k Q} (f : simpleRep k Q i ⟶ M) :
        f = 0 ↔ f.app i = 0

        Dually, a morphism out of the vertex simple Sᵢ vanishes as soon as its component at i does: all its other components start from a zero module.

        theorem TauCeti.simple_of_simple_obj_of_isZero_obj {k : Type u} {Q : Type v} [Field k] [Quiver Q] {M : QuiverRep k Q} {j : Q} (hj : CategoryTheory.Simple (M.obj j)) (hzero : ∀ (a : Q), a ≠ j → CategoryTheory.Limits.IsZero (M.obj a)) :

        A representation supported at a single vertex is simple as soon as its vertex space there is: if M vanishes at every vertex other than j and the module Mⱼ is simple, then M is a simple object of TauCeti.QuiverRep k Q. A monomorphism into such an M is zero away from j because the target vanishes there, so it is determined by its component at j, where simplicity of Mⱼ makes a nonzero monomorphism invertible.

        instance TauCeti.simpleRep_simple {k : Type u} {Q : Type v} [Field k] [Quiver Q] (i : Q) :

        The vertex simples are simple. The vertex representation Sᵢ = simpleRep k Q i is a simple object of TauCeti.QuiverRep k Q.

        Universe-lifting the vertex spaces of a vertex simple representation preserves its simplicity.

        @[simp]
        theorem TauCeti.dimVector_simpleRep {k : Type u} {Q : Type v} [Field k] [Quiver Q] [DecidableEq Q] (i : Q) :

        The dimension vector of the vertex simple Sᵢ is the standard basis vector at i.

        The vertex simples are the only simples over an acyclic quiver #

        noncomputable def TauCeti.simpleRepHom {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i : Q} {M : QuiverRep k Q} (x : ↑(M.obj ((CategoryTheory.Paths.of Q).obj i))) (hx : ∀ {a : Q} (p : Quiver.Path i a), p.length ≠ 0 → (CategoryTheory.ConcreteCategory.hom (M.map p)) x = 0) :
        simpleRep k Q i ⟶ M

        The morphism Sᵢ ⟶ M determined by a vector at i, for a vector x that every path out of i of positive length annihilates. It carries the generator of the line (Sᵢ)ᵢ to x, and is the zero map at every other vertex. The hypothesis hx is exactly what naturality asks for: a path of positive length acts by zero on Sᵢ, so it must kill x as well.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          @[simp]
          theorem TauCeti.simpleRepHom_app_of_ne {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i : Q} {M : QuiverRep k Q} (x : ↑(M.obj ((CategoryTheory.Paths.of Q).obj i))) (hx : ∀ {a : Q} (p : Quiver.Path i a), p.length ≠ 0 → (CategoryTheory.ConcreteCategory.hom (M.map p)) x = 0) {a : Q} (ha : a ≠ i) :
          (simpleRepHom x ⋯).app a = 0

          Away from i, the morphism Sᵢ ⟶ M attached to x : Mᵢ vanishes.

          @[simp]
          theorem TauCeti.simpleRepHom_app_generator {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i : Q} {M : QuiverRep k Q} (x : ↑(M.obj ((CategoryTheory.Paths.of Q).obj i))) (hx : ∀ {a : Q} (p : Quiver.Path i a), p.length ≠ 0 → (CategoryTheory.ConcreteCategory.hom (M.map p)) x = 0) :

          The morphism Sᵢ ⟶ M attached to x : Mᵢ carries the generator of (Sᵢ)ᵢ to x.

          theorem TauCeti.isIso_simpleRepHom {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i : Q} {M : QuiverRep k Q} (x : ↑(M.obj ((CategoryTheory.Paths.of Q).obj i))) (hx : ∀ {a : Q} (p : Quiver.Path i a), p.length ≠ 0 → (CategoryTheory.ConcreteCategory.hom (M.map p)) x = 0) (hx0 : x ≠ 0) (hspan : k ∙ x = ⊤) (hM : ∀ (a : Q), a ≠ i → CategoryTheory.Limits.IsZero (M.obj a)) :

          A representation carried by a single vector at i is Sᵢ: the morphism Sᵢ ⟶ M attached to a nonzero vector x spanning Mᵢ is an isomorphism, as soon as M vanishes at every other vertex.

          theorem TauCeti.exists_iso_simpleRep_of_simple {k : Type u} {Q : Type v} [Field k] [Quiver Q] (hQ : Quiver.IsAcyclic Q) (M : QuiverRep k Q) [CategoryTheory.Simple M] :
          ∃ (i : Q), Nonempty (M ≅ simpleRep k Q i)

          The vertex simples exhaust the simples. Over an acyclic quiver every simple representation is isomorphic to a vertex simple Sᵢ.

          The proof compares two subrepresentations attached to a nonzero vector x of Mᵢ: the one it generates, and the one generated by its images under the paths of positive length. Simplicity forces each to be everything or nothing; over an acyclic quiver the second vanishes at i while the first contains x, so the second is nothing and the first everything. Away from i the two agree, so M vanishes there, and at i it is the line through x.

          theorem TauCeti.exists_mono_simpleRep_of_not_isZero {k : Type u} {Q : Type v} [Field k] [Quiver Q] [Finite Q] (hQ : Quiver.IsAcyclic Q) {M : QuiverRep k Q} (hM : ¬CategoryTheory.Limits.IsZero M) :
          ∃ (i : Q) (f : simpleRep k Q i ⟶ M), CategoryTheory.Mono f

          Every nonzero representation of a finite-vertex acyclic quiver contains a vertex simple as a subrepresentation. No finite-dimensionality of the vertex spaces is needed.

          theorem TauCeti.not_nonempty_simpleRep_iso {k : Type u} {Q : Type v} [Field k] [Quiver Q] {i j : Q} (h : i ≠ j) :

          Vertex simples at distinct vertices are not isomorphic: their dimension vectors differ.