minor details in the quivers folder

Author: fchapoton

src/sage/quivers/algebra.py

@@ -19,8 +19,9 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from sage.misc.cachefunc import cached_method
 from sage.combinat.free_module import CombinatorialFreeModule
+from sage.misc.cachefunc import cached_method
+
 from .algebra_elements import PathAlgebraElement
 
 

src/sage/quivers/algebra_elements.pyx

@@ -322,13 +322,13 @@ cdef class PathAlgebraElement(RingElement):
             sage: len(X^5)
             17
         """
-        cdef size_t l = 0
+        cdef size_t ell = 0
         cdef path_homog_poly_t *H = self.data
         while H != NULL:
             sig_check()
-            l += H.poly.nterms
+            ell += H.poly.nterms
             H = H.nxt
-        return l
+        return ell
 
     cpdef ssize_t degree(self) except -2:
         """

src/sage/quivers/ar_quiver.py

@@ -12,18 +12,18 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from sage.structure.unique_representation import UniqueRepresentation
-from sage.structure.parent import Parent
-from sage.structure.element import Element
-from sage.structure.richcmp import richcmp
-from sage.structure.global_options import GlobalOptions
 from sage.categories.sets_cat import Sets
-from sage.sets.family import Family
-from sage.combinat.root_system.cartan_type import CartanType
 from sage.combinat.free_module import CombinatorialFreeModule
-from sage.rings.integer_ring import ZZ
-from sage.misc.cachefunc import cached_method
+from sage.combinat.root_system.cartan_type import CartanType
 from sage.graphs.digraph import DiGraph
+from sage.misc.cachefunc import cached_method
+from sage.rings.integer_ring import ZZ
+from sage.sets.family import Family
+from sage.structure.element import Element
+from sage.structure.global_options import GlobalOptions
+from sage.structure.parent import Parent
+from sage.structure.richcmp import richcmp
+from sage.structure.unique_representation import UniqueRepresentation
 
 
 class AuslanderReitenQuiver(UniqueRepresentation, Parent):
@@ -600,7 +600,7 @@ def _dim_vecs_level(self, k):
         elif k > 1:
             if k > self._max_level:
                 return {}
-            prev = self._dim_vecs_level(k-1)
+            prev = self._dim_vecs_level(k - 1)
             if k > self._max_level:  # this might get set on the recursive call
                 return {}
             ret = {}
@@ -624,7 +624,7 @@ def _dim_vecs_level(self, k):
                    for v in Q.vertex_iterator()}
 
         elif k < -1:
-            prev = self._dim_vecs_level(k+1)
+            prev = self._dim_vecs_level(k + 1)
             ret = {}
             for v in self._top_sort:
                 if v not in prev:  # assumption: this vertex will never reappear

src/sage/quivers/homspace.py

@@ -18,9 +18,10 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 from __future__ import annotations
+
 from sage.categories.homset import Homset
-from sage.quivers.morphism import QuiverRepHom
 from sage.misc.cachefunc import cached_method
+from sage.quivers.morphism import QuiverRepHom
 
 
 class QuiverHomSpace(Homset):

src/sage/quivers/morphism.py

@@ -173,7 +173,10 @@ def __init__(self, domain, codomain, data={}):
         # this is the case it will be loaded directly into _vector and then
         # _assert_valid_hom is called.
 
-        from sage.quivers.representation import QuiverRepElement, QuiverRep_with_path_basis
+        from sage.quivers.representation import (
+            QuiverRep_with_path_basis,
+            QuiverRepElement,
+        )
 
         self._domain = domain
         self._codomain = codomain
@@ -210,25 +213,24 @@ def __init__(self, domain, codomain, data={}):
             # If data is not a list create one, then create a dict from it
             if isinstance(data, list):
                 im_list = data
-            else:
-                # If data is a QuiverRepHom, create a list from it
-                if isinstance(data, QuiverRepHom):
-                    f = data._domain.coerce_map_from(domain)
-                    g = self._codomain.coerce_map_from(data._codomain)
-                    im_list = [g(data(f(x))) for x in domain.gens()]
+            # If data is a QuiverRepHom, create a list from it
+            elif isinstance(data, QuiverRepHom):
+                f = data._domain.coerce_map_from(domain)
+                g = self._codomain.coerce_map_from(data._codomain)
+                im_list = [g(data(f(x))) for x in domain.gens()]
 
-                # The only case left is that data is a QuiverRepElement
-                else:
-                    if not isinstance(data, QuiverRepElement):
-                        raise TypeError("input data must be dictionary, list, "
-                                        "QuiverRepElement or vector")
-                    if not isinstance(domain, QuiverRep_with_path_basis):
-                        raise TypeError("if data is a QuiverRepElement then domain "
-                                        "must be a QuiverRep_with_path_basis.")
-                    if data not in codomain:
-                        raise ValueError("if data is a QuiverRepElement then it must "
-                                         "be an element of codomain")
-                    im_list = [codomain.right_edge_action(data, p) for v in domain._quiver for p in domain._bases[v]]
+            # The only case left is that data is a QuiverRepElement
+            else:
+                if not isinstance(data, QuiverRepElement):
+                    raise TypeError("input data must be dictionary, list, "
+                                    "QuiverRepElement or vector")
+                if not isinstance(domain, QuiverRep_with_path_basis):
+                    raise TypeError("if data is a QuiverRepElement then domain "
+                                    "must be a QuiverRep_with_path_basis.")
+                if data not in codomain:
+                    raise ValueError("if data is a QuiverRepElement then it must "
+                                     "be an element of codomain")
+                im_list = [codomain.right_edge_action(data, p) for v in domain._quiver for p in domain._bases[v]]
 
             # WARNING: This code assumes that the function QuiverRep.gens() returns
             # the generators ordered first by vertex and then by the order of the
@@ -337,7 +339,7 @@ def _call_(self, x):
         if not isinstance(x, QuiverRepElement):
             raise ValueError("QuiverRepHom can only be called on QuiverRepElement")
 
-        elements = dict((v, self.get_map(v)(x._elems[v])) for v in self._quiver)
+        elements = {v: self.get_map(v)(x._elems[v]) for v in self._quiver}
         return self._codomain(elements)
 
     def __add__(left, right):
@@ -952,7 +954,7 @@ def kernel(self):
             sage: g.kernel().dimension_vector()
             (0, 1, 0)
         """
-        spaces = dict((v, self.get_map(v).kernel()) for v in self._quiver)
+        spaces = {v: self.get_map(v).kernel() for v in self._quiver}
         return self._domain._submodule(spaces)
 
     def image(self):
@@ -979,7 +981,7 @@ def image(self):
             sage: g.image().dimension_vector()
             (0, 1, 1)
         """
-        spaces = dict((v, self.get_map(v).image()) for v in self._quiver)
+        spaces = {v: self.get_map(v).image() for v in self._quiver}
         return self._codomain._submodule(spaces)
 
     def cokernel(self):
@@ -1051,7 +1053,7 @@ def linear_dual(self):
         """
         # The effect of the functor D is that it just transposes the matrix of
         # a hom
-        maps = dict((v, self.get_matrix(v).transpose()) for v in self._quiver)
+        maps = {v: self.get_matrix(v).transpose() for v in self._quiver}
         return self._codomain.linear_dual().hom(maps, self._domain.linear_dual())
 
     def algebraic_dual(self):
@@ -1232,7 +1234,7 @@ def lift(self, x):
             ValueError: element is not in the image
         """
         # Lift at each vertex
-        elems = dict((v, self.get_map(v).lift(x._elems[v])) for v in self._quiver)
+        elems = {v: self.get_map(v).lift(x._elems[v]) for v in self._quiver}
         return self._domain(elems)
 
     ###########################################################################

src/sage/quivers/path_semigroup.py

@@ -18,16 +18,17 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
+from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
+from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
+from sage.categories.monoids import Monoids
+from sage.categories.semigroups import Semigroups
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_attribute import lazy_attribute
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
 from sage.structure.parent import Parent
 from sage.structure.unique_representation import UniqueRepresentation
-from sage.categories.semigroups import Semigroups
-from sage.categories.monoids import Monoids
-from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
-from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
-from sage.misc.cachefunc import cached_method
-from sage.misc.lazy_attribute import lazy_attribute
+
 from .paths import QuiverPath
 from .representation import QuiverRep
 
@@ -1131,14 +1132,16 @@ def _v_to_e(path):
             if len(path) == 1:
                 return [self.element_class(self, path[0], path[0], [])]
             paths = []
-            l = Q.edge_label(path[0], path[1])
-            if isinstance(l, str):
+            ell = Q.edge_label(path[0], path[1])
+            if isinstance(ell, str):
                 for b in _v_to_e(path[1:]):
-                    paths.append(self([(path[0], path[1], l)] + list(b), check=False))
+                    paths.append(self([(path[0], path[1], ell)]
+                                      + list(b), check=False))
             else:
-                for a in l:
+                for a in ell:
                     for b in _v_to_e(path[1:]):
-                        paths.append(self([(path[0], path[1], a)] + list(b), check=False))
+                        paths.append(self([(path[0], path[1], a)]
+                                          + list(b), check=False))
             return paths
 
         # For each vertex path we append the resulting edge paths

src/sage/quivers/paths.pyx

@@ -760,10 +760,10 @@ cdef class QuiverPath(MonoidElement):
         out._end = self._start
         sig_check()
         biseq_init(out._path, self._path.length, self._path.itembitsize)
-        cdef mp_size_t l = self._path.length - 1
+        cdef mp_size_t ell = self._path.length - 1
         for i in range(self._path.length):
             sig_check()
-            biseq_inititem(out._path, i, biseq_getitem(self._path, l-i))
+            biseq_inititem(out._path, i, biseq_getitem(self._path, ell - i))
         return out
 
 

src/sage/quivers/representation.py

@@ -448,11 +448,12 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 from __future__ import annotations
-from sage.structure.factory import UniqueFactory
-from sage.modules.module import Module
-from sage.structure.element import ModuleElement
+
 from sage.misc.cachefunc import cached_method
 from sage.misc.fast_methods import WithEqualityById
+from sage.modules.module import Module
+from sage.structure.element import ModuleElement
+from sage.structure.factory import UniqueFactory
 
 
 class QuiverRepFactory(UniqueFactory):
@@ -706,8 +707,8 @@ def create_key(self, k, P, *args, **kwds):
             #
             # Note that the first space is assigned to key[3] and the first
             # vertex is 1 so the space assigned to vertex v is key[2 + v]
-            from sage.matrix.constructor import Matrix
             from sage.categories.morphism import Morphism
+            from sage.matrix.constructor import Matrix
             for x in P._sorted_edges:
                 if x in maps:
                     e = maps[x]
@@ -2469,10 +2470,11 @@ def direct_sum(self, modules, return_maps=False):
                 raise ValueError("cannot direct sum modules with different base rings")
 
         # Get the dimensions of all spaces at each vertex
-        dims = dict((v, [x._spaces[v].dimension() for x in mods]) for v in self._quiver)
+        dims = {v: [x._spaces[v].dimension() for x in mods]
+                for v in self._quiver}
 
         # Create spaces of the correct dimensions
-        spaces = dict((v, self.base_ring()**sum(dims[v])) for v in self._quiver)
+        spaces = {v: self.base_ring()**sum(dims[v]) for v in self._quiver}
 
         # Take block sums of matrices to form the maps
         from sage.matrix.constructor import block_diagonal_matrix
@@ -2486,7 +2488,7 @@ def direct_sum(self, modules, return_maps=False):
             return result
 
         # Create the inclusions and projections
-        from sage.matrix.constructor import block_matrix, Matrix
+        from sage.matrix.constructor import Matrix, block_matrix
         from sage.rings.integer import Integer
         iota = []
         pi = []
@@ -2754,7 +2756,7 @@ def __init__(self, k, P, basis):
                 maps[e][i, j] = k.one()
 
         # Create the spaces and then the representation
-        spaces = dict((v, len(self._bases[v])) for v in Q)
+        spaces = {v: len(self._bases[v]) for v in Q}
         super().__init__(k, P, spaces, maps)
 
         # Try and create the matrices for the left edge action of edges.  If it
@@ -2765,10 +2767,10 @@ def __init__(self, k, P, basis):
             action_mats[e] = {}
             for v in self._quiver:
                 # Start with the zero matrix and fill in
-                l = len(self._bases[v])
-                action_mats[e][v] = Matrix(k, l, l)
+                ell = len(self._bases[v])
+                action_mats[e][v] = Matrix(k, ell, ell)
 
-                for j in range(l):
+                for j in range(ell):
                     if e[1] == self._bases[v][j].initial_vertex():
                         try:
                             action_mats[e][v][self._bases[v].index(P([e], check=False) * self._bases[v][j]), j] = k.one()
@@ -2783,12 +2785,12 @@ def __init__(self, k, P, basis):
             action_mats[e] = {}
             for v in self._quiver:
                 # Start with the zero matrix and fill in
-                l = len(self._bases[v])
-                action_mats[e][v] = Matrix(k, l, l)
+                ell = len(self._bases[v])
+                action_mats[e][v] = Matrix(k, ell, ell)
 
                 # Paths not beginning at vert are sent to zero, paths beginning
                 # at vert are fixed
-                for i in range(l):
+                for i in range(ell):
                     if self._bases[v][i].initial_vertex() == vert:
                         action_mats[e][v][i, i] = k.one()