attachment:quiver_representations.sage of days40_projects

   1 """
   2 
   3 .. TODO::
   4 
   5    - Refactor Quiver to handle paths with names on the edges, toward
   6      multiple edges. Use a list of edge names instead of nodes for the
   7      repr of paths.
   8 
   9    - Refactor path algebras of quivers to handle those.
  10 
  11    - Merge Cluster's quivers with those from Jim Stark's patch #12630?
  12      which implements acyclic free path algebras, hom, homsets.
  13 
  14 Basic quiver manipulations
  15 ==========================
  16 
  17     sage: c = Quiver(["A",4])
  18     sage: c = Quiver([[... some digraph data ...]])
  19 
  20     sage: c.path_algebra(QQ)
  21 
  22     sage: c.shortest_paths()   # find a good name
  23     ... kind of describes the minimal cycles of the quiver ...
  24 
  25 
  26 Representation theory
  27 =====================
  28 
  29 In case we want to separate representations from quiver:
  30 
  31     sage: R = c.representations(QQ, side="right"); R
  32     The category of representations of c over Rational Field
  33     sage: R.<tab>
  34     sage: R.simple_modules()
  35 
  36 Otherwise:
  37 
  38     sage: R = c
  39 
  40 The projective modules, and variants::
  41 
  42     sage: P = R.projective_indecomposable_modules(QQ)
  43     A family of quiver representations
  44     sage: P.keys()
  45     ... the nodes of the quiver ...
  46 
  47     sage: R.simple_modules()
  48     ...
  49     sage: R.injective_indecomposable_modules()  (or just injective_modules)
  50     ...
  51 
  52 Manipulating modules
  53 --------------------
  54 
  55     sage: V = P[i];V    # i is some node of the quiver
  56     A quiver representation (typically represented internally by the
  57     representation matrix of each quiver edge on each module).
  58 
  59     sage: V.dimension_vector()
  60     [...] the dimensions of the vector spaces
  61 
  62     sage: V.dimension()
  63     the sum of the above
  64 
  65     sage: V.is_exceptional()
  66 
  67     sage: v = V.an_element()
  68     ... internal representation: a list of vector ...
  69 
  70     sage: W = V.submodule([v])
  71     Returns the submodule spanned by v
  72 
  73 Quotients / factors::
  74 
  75     sage: V.factor(W)      # Peter has a slight preference for this guy
  76     sage: V.quotient(W)    # synonym: V.quo(W)
  77     sage: V/W
  78 
  79 Arithmetic on representations::
  80 
  81     sage: tensor([V, W, V])
  82     A quiver representation
  83     sage: direct_sum([W, W, V, V])    # or cartesian_product
  84     ...
  85 
  86     sage: V.radical()
  87     sage: V.socle()
  88     sage: V.top()     V.semisimple_quotient()
  89 
  90 Decompose a module into direct sums::  # implemented by Peter for reps of categories
  91 
  92     sage: V.decomposition()    V.indecomposable_summands() ?
  93     ...
  94 
  95     sage: V.composition_factors()   # This is not so interesting in the case of a representation of a quiver!!!
  96     ... the dimension vector ...
  97 
  98     sage: W.images(V)
  99     ... returns the direct sum of all isomorphic copies ov V in W ...
 100 
 101 Characters (not that relevant in the context of representations of a quiver)::
 102 
 103     sage: V.character()
 104 
 105     sage: R.grothendieck_group()
 106 
 107 Homomorphisms:
 108 --------------
 109 
 110     sage: H = Hom(V,W)
 111     sage: h = H.an_element()
 112     sage: h.kernel()
 113     ... a quiver module ...
 114     sage: h.image_set()       / h.image()
 115     ... a quiver module ...
 116 
 117 Ext groups:
 118 -----------
 119 
 120     sage: Ext(V, W, degree)
 121     sage: Ext(V, W)
 122     The family of all Ext(V, W, k), k>=0
 123     sage: Ext(V, W, 0)
 124     Returns Hom(V, W)
 125 
 126 one can further specify a category:
 127 
 128     sage: Ext(V, W, category=...)
 129 
 130 internally this would call::
 131 
 132     sage: V._Ext_(W,degree)
 133 
 134     sage: V.global_dimension()
 135     sage: V.is_quasi_hereditary()
 136 
 137     sage: V.projective_resolution(minimal = False)
 138 
 139 Nakayama functor::
 140 
 141     sage: V.dual()
 142     a module for the dual quiver
 143 
 144     sage: Hom(V, A, category=R)
 145     returns a module for the dual quiver
 146 
 147     sage: V.nakayama()   -> returns something isomorphic to Hom(V, A, category=R).dual(), hopefuly with better algorithms
 148     returns a new module
 149 
 150 Auslander-Reiten quiver
 151 
 152     sage: R.auslander_reiten_quiver()
 153     In general: some very very lazy object on which we would compute some pieces
 154 
 155 """
 156 
 157 class Quiver:
 158     """
 159 
 160     Internal representation: a digraph
 161 
 162     """
 163 
 164 class QuiverRepresentation(Parent):  # discuss with John to see how this was done for chain complexes
 165     """
 166 
 167         sage: R = quiver.representations(QQ, side="left")
 168         sage: r = R.simple_modules()[1]    /  simple_representations() ???
 169         sage: r.category()   # ideally; for the moment can be just Modules(QQ)
 170         ... R ...
 171         sage:
 172     """
 173 
 174 class QuiverWithRelationsRepresentations(Category):
 175     """
 176     Main job: delegate work to QPA
 177     """
 178 
 179     class SubcategoryMethods:
 180         def simple_modules(self):
 181             """
 182             """
 183 
 184 class QuiverRepresentations(Category):
 185     """
 186     A subcategory of QuiverWithRelationsRepresentations
 187     """
 188 
 189 
 190 class AcyclicQuiverRepresentations(Category):
 191     """
 192     subcategory of QuiverRepresentations
 193     """