passagemath-flint 10.5.43__cp310-cp310-macosx_14_0_arm64.whl → 10.6.1rc1__cp310-cp310-macosx_14_0_arm64.whl

sage/quivers/algebra_elements.pyx

@@ -325,13 +325,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:
         """
@@ -372,9 +372,9 @@ cdef class PathAlgebraElement(RingElement):
             return -1
         return deg
 
-    def is_homogeneous(self):
+    def is_homogeneous(self) -> bool:
         """
-        Tells whether this element is homogeneous.
+        Tell whether this element is homogeneous.
 
         EXAMPLES::
 

sage/quivers/ar_quiver.py

@@ -14,18 +14,18 @@ Auslander-Reiten Quivers
 #                  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):
@@ -194,7 +194,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
         cat = Sets().Enumerated().Finite() if self._is_finite else Sets().Infinite()
         super().__init__(self, category=cat)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -363,7 +363,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
 
     def digraph_preprojectives(self, max_depth, with_translations=False):
         r"""
-        Return the diagraph of preprojectives of ``self`` up to ``max_depth``.
+        Return the digraph of preprojectives of ``self`` up to ``max_depth``.
 
         EXAMPLES::
 
@@ -402,7 +402,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
 
     def digraph_postinjectives(self, max_depth, with_translations=False):
         """
-        Return the diagraph of postinjectives of ``self`` up to ``max_depth``.
+        Return the digraph of postinjectives of ``self`` up to ``max_depth``.
 
         EXAMPLES::
 
@@ -442,12 +442,12 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
     @cached_method
     def digraph(self, with_translations=False):
         r"""
-        Return the diagraph of ``self``.
+        Return the digraph of ``self``.
 
         INPUT:
 
-        - ``with_translations`` -- boolean (default: ``False``); if ``True``, then
-          include the arrows corresponding to the translations
+        - ``with_translations`` -- boolean (default: ``False``); if ``True``,
+          then include the arrows corresponding to the translations
 
         EXAMPLES::
 
@@ -602,7 +602,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
         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 = {}
@@ -626,7 +626,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
                    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
@@ -699,7 +699,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
             self._level = ZZ(level)
             Element.__init__(self, parent)
 
-        def _repr_(self):
+        def _repr_(self) -> str:
             r"""
             Return a string representation of ``self``.
 
@@ -712,7 +712,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
             """
             return f"<{self._vertex}, {self._level}>"
 
-        def _latex_(self):
+        def _latex_(self) -> str:
             r"""
             Return a latex representation of ``self``.
 
@@ -741,7 +741,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
                 return dim_vec
             return r"\begin{{gathered}} {} \\ {} \end{{gathered}}".format(node, dim_vec)
 
-        def _richcmp_(self, other, op):
+        def _richcmp_(self, other, op) -> bool:
             r"""
             Rich comparison of ``self`` to ``other`` by ``op``.
 
@@ -754,7 +754,7 @@ class AuslanderReitenQuiver(UniqueRepresentation, Parent):
             """
             return richcmp((self._level, self._vertex), (other._level, other._vertex), op)
 
-        def __hash__(self):
+        def __hash__(self) -> int:
             r"""
             Return the hash of ``self``.
 

sage/quivers/homspace.py

@@ -20,9 +20,10 @@ Quiver Homspace
 #                  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):

sage/quivers/morphism.py

@@ -175,7 +175,10 @@ class QuiverRepHom(CallMorphism):
         # 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
@@ -212,25 +215,24 @@ class QuiverRepHom(CallMorphism):
             # 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
@@ -339,7 +341,7 @@ class QuiverRepHom(CallMorphism):
         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):
@@ -792,7 +794,7 @@ class QuiverRepHom(CallMorphism):
     #                                                                         #
     ###########################################################################
 
-    def is_injective(self):
+    def is_injective(self) -> bool:
         """
         Test whether the homomorphism is injective.
 
@@ -814,7 +816,7 @@ class QuiverRepHom(CallMorphism):
         # vertex
         return not any(self.get_matrix(v).nullity() for v in self._quiver)
 
-    def is_surjective(self):
+    def is_surjective(self) -> bool:
         """
         Test whether the homomorphism is surjective.
 
@@ -841,7 +843,7 @@ class QuiverRepHom(CallMorphism):
 
         return True
 
-    def is_isomorphism(self):
+    def is_isomorphism(self) -> bool:
         """
         Test whether the homomorphism is an isomorphism.
 
@@ -862,7 +864,7 @@ class QuiverRepHom(CallMorphism):
         # It's an iso if and only if it's an iso at every vertex
         return all(self.get_matrix(v).is_invertible() for v in self._quiver)
 
-    def is_zero(self):
+    def is_zero(self) -> bool:
         """
         Test whether the homomorphism is the zero homomorphism.
 
@@ -883,7 +885,7 @@ class QuiverRepHom(CallMorphism):
         # The homomorphism is zero if and only if it is zero at every vertex
         return all(self.get_matrix(v).is_zero() for v in self._quiver)
 
-    def is_endomorphism(self):
+    def is_endomorphism(self) -> bool:
         """
         Test whether the homomorphism is an endomorphism.
 
@@ -954,7 +956,7 @@ class QuiverRepHom(CallMorphism):
             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):
@@ -981,7 +983,7 @@ class QuiverRepHom(CallMorphism):
             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):
@@ -1053,7 +1055,7 @@ class QuiverRepHom(CallMorphism):
         """
         # 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):
@@ -1234,7 +1236,7 @@ class QuiverRepHom(CallMorphism):
             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)
 
     ###########################################################################

sage/quivers/path_semigroup.py

@@ -20,16 +20,17 @@ Path Semigroups
 #                  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
 
@@ -1133,14 +1134,16 @@ class PathSemigroup(UniqueRepresentation, Parent):
             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

sage/quivers/paths.pyx

@@ -762,10 +762,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
 
 

sage/quivers/representation.py

@@ -450,11 +450,12 @@ the ``*`` operator::
 #                  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):
@@ -708,8 +709,8 @@ class QuiverRepFactory(UniqueFactory):
             #
             # 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]
@@ -1199,7 +1200,7 @@ class QuiverRepElement(ModuleElement):
     #                                                                         #
     ###########################################################################
 
-    def is_zero(self):
+    def is_zero(self) -> bool:
         """
         Test whether ``self`` is zero.
 
@@ -1777,7 +1778,7 @@ class QuiverRep_generic(WithEqualityById, Module):
         """
         return tuple(self._spaces[x].dimension() for x in self._quiver)
 
-    def is_zero(self):
+    def is_zero(self) -> bool:
         """
         Test whether the representation is zero.
 
@@ -1799,7 +1800,7 @@ class QuiverRep_generic(WithEqualityById, Module):
         """
         return self.dimension() == 0
 
-    def is_simple(self):
+    def is_simple(self) -> bool:
         """
         Test whether the representation is simple.
 
@@ -1817,7 +1818,7 @@ class QuiverRep_generic(WithEqualityById, Module):
         # dimension 1.
         return self.dimension() == 1
 
-    def is_semisimple(self):
+    def is_semisimple(self) -> bool:
         """
         Test whether the representation is semisimple.
 
@@ -2014,11 +2015,7 @@ class QuiverRep_generic(WithEqualityById, Module):
         gens = self.gens()
         if len(gens) != len(coordinates):
             raise ValueError("the coordinates do not match the dimension of the module")
-
-        result = self()  # this must not be self.zero(), which is cached
-        for ci, gi in zip(coordinates, gens):
-            result += ci * gi
-        return result
+        return self.sum(ci * gi for ci, gi in zip(coordinates, gens))
 
     ###########################################################################
     #                                                                         #
@@ -2471,10 +2468,11 @@ class QuiverRep_generic(WithEqualityById, Module):
                 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
@@ -2488,7 +2486,7 @@ class QuiverRep_generic(WithEqualityById, Module):
             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 = []
@@ -2756,7 +2754,7 @@ class QuiverRep_with_path_basis(QuiverRep_generic):
                 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
@@ -2767,10 +2765,10 @@ class QuiverRep_with_path_basis(QuiverRep_generic):
             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()
@@ -2785,12 +2783,12 @@ class QuiverRep_with_path_basis(QuiverRep_generic):
             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()
 
@@ -2859,7 +2857,7 @@ class QuiverRep_with_path_basis(QuiverRep_generic):
                  for v in self._quiver}
         return self(elems)
 
-    def is_left_module(self):
+    def is_left_module(self) -> bool:
         """
         Test whether the basis is closed under left multiplication.