passagemath-modules 10.5.32__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

{passagemath_modules-10.5.32.dist-info → passagemath_modules-10.6.20.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_14_0_arm64
 Generator: delocate 0.13.0

sage/algebras/clifford_algebra.py

@@ -788,7 +788,7 @@ class CliffordAlgebra(CombinatorialFreeModule):
         """
         return self._from_dict({FrozenBitset((i,)): self.base_ring().one()}, remove_zeros=False)
 
-    def algebra_generators(self):
+    def algebra_generators(self) -> Family:
         """
         Return the algebra generators of ``self``.
 
@@ -802,7 +802,7 @@ class CliffordAlgebra(CombinatorialFreeModule):
         d = {x: self.gen(i) for i, x in enumerate(self.variable_names())}
         return Family(self.variable_names(), lambda x: d[x])
 
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
         Return the generators of ``self`` (as an algebra).
 

sage/algebras/clifford_algebra_element.pyx

@@ -16,13 +16,15 @@ AUTHORS:
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # ****************************************************************************
+from copy import copy
+
 from sage.structure.parent cimport Parent
 from sage.data_structures.bitset cimport Bitset
 from sage.algebras.weyl_algebra import repr_from_monomials
 from sage.data_structures.blas_dict cimport scal
-from copy import copy
+
 
 cdef class CliffordAlgebraElement(IndexedFreeModuleElement):
     """

sage/algebras/exterior_algebra_groebner.pyx

@@ -439,6 +439,8 @@ cdef class GroebnerStrategy:
         """
         Convert the computed Gröbner basis to a reduced Gröbner basis.
 
+        EXAMPLES::
+
             sage: E.<x,y,z> = ExteriorAlgebra(QQ)
             sage: I = E.ideal([x+y*z])
             sage: I.groebner_basis(reduced=False)

sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra.py

@@ -10,7 +10,7 @@ Finite-Dimensional Algebras
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  as published by the Free Software Foundation; either version 2 of
 #  the License, or (at your option) any later version.
-#                  http:s//www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # ***************************************************************************
 
 from .finite_dimensional_algebra_element import FiniteDimensionalAlgebraElement
@@ -19,6 +19,7 @@ from .finite_dimensional_algebra_ideal import FiniteDimensionalAlgebraIdeal
 from sage.rings.integer_ring import ZZ
 
 from sage.categories.magmatic_algebras import MagmaticAlgebras
+from sage.categories.algebras import Algebras
 from sage.matrix.constructor import matrix
 from sage.structure.element import Matrix
 from sage.structure.category_object import normalize_names
@@ -33,6 +34,9 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
     r"""
     Create a finite-dimensional `k`-algebra from a multiplication table.
 
+    This is a magmatic `k`-algebra, i.e., not necessarily
+    associative or unital.
+
     INPUT:
 
     - ``k`` -- a field
@@ -46,6 +50,10 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
       ``True``, then the category is set to ``category.Associative()``
       and methods requiring associativity assume this
 
+    - ``assume_unital`` -- boolean (default: ``False``); if
+      ``True``, then the category is set to ``category.Unital()``
+      and methods requiring unitality assume this
+
     - ``category`` -- (default:
       ``MagmaticAlgebras(k).FiniteDimensional().WithBasis()``)
       the category to which this algebra belongs
@@ -68,6 +76,49 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
         ....:                                   Matrix([[0,0,0], [0,0,0], [0,0,1]])])
         sage: B
         Finite-dimensional algebra of degree 3 over Rational Field
+        sage: B.one()
+        e0 + e2
+        sage: B.is_associative()
+        True
+
+    A more complicated example (the descent algebra of `S_3` in
+    a slightly rescaled I-basis, see :class:`DescentAlgebra`)::
+
+        sage: Ma = Matrix([[6,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0]])
+        sage: Mb = Matrix([[0,0,0,0], [0,1,0,0], [0,1,0,0], [0,0,0,0]])
+        sage: Mc = Matrix([[0,0,0,0], [0,0,1,0], [0,0,1,0], [0,0,0,0]])
+        sage: Md = Matrix([[0,0,0,0], [0,1,-1,0], [0,-1,1,0], [0,0,0,2]])
+        sage: C = FiniteDimensionalAlgebra(QQ, [Ma, Mb, Mc, Md])
+        sage: C.one()
+        1/6*e0 + 1/2*e1 + 1/2*e2 + 1/2*e3
+        sage: C.is_associative()
+        True
+        sage: C.is_commutative()
+        False
+
+    If we set both ``is_associative`` and ``is_unital`` to
+    ``True``, then this is an associative unital algebra and
+    belongs to the category of
+    :class:`sage.categories.finite_dimensional_algebras_with_basis.FiniteDimensionalAlgebrasWithBasis`::
+
+        sage: C = FiniteDimensionalAlgebra(QQ, [Ma, Mb, Mc, Md],
+        ....:                              assume_associative=True,
+        ....:                              assume_unital=True)
+        sage: C.radical_basis()
+        (e1 - e2,)
+        sage: C.radical()
+        Radical of Finite-dimensional algebra of degree 4 over Rational Field
+        sage: C.center_basis()
+        (e0, e1 + e2 + e3)
+        sage: C.center()
+        Center of Finite-dimensional algebra of degree 4 over Rational Field
+        sage: C.center().is_commutative()
+        True
+        sage: e = C.basis()
+        sage: C.annihilator_basis([e[1]])
+        (e0, e1 - e2, e3)
+        sage: C.annihilator_basis([e[1]], side='left')
+        (e0, e1 - e2 - e3)
 
     TESTS::
 
@@ -83,7 +134,7 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
     """
     @staticmethod
     def __classcall_private__(cls, k, table, names='e', assume_associative=False,
-                              category=None):
+                              assume_unital=False, category=None):
         """
         Normalize input.
 
@@ -106,6 +157,26 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
             sage: A1 is A2
             True
 
+        Likewise for the ``assume_associative`` keyword::
+
+            sage: A3 = FiniteDimensionalAlgebra(GF(3), table,
+            ....:                               category=cat.Unital())
+            sage: A4 = FiniteDimensionalAlgebra(GF(3), table, assume_unital=True)
+            sage: A3 is A4
+            True
+
+        With both keywords on, the
+        :class:`sage.categories.algebras.Algebras` category
+        is used::
+
+            sage: cat_a = Algebras(GF(3)).FiniteDimensional().WithBasis()
+            sage: A5 = FiniteDimensionalAlgebra(GF(3), table,
+            ....:                               category=cat_a)
+            sage: A6 = FiniteDimensionalAlgebra(GF(3), table, assume_associative=True,
+            ....:                               assume_unital=True)
+            sage: A5 is A6
+            True
+
         Uniqueness depends on the category::
 
             sage: cat = Algebras(GF(3)).FiniteDimensional().WithBasis()
@@ -145,6 +216,12 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
         cat = cat.or_subcategory(category)
         if assume_associative:
             cat = cat.Associative()
+            if assume_unital:
+                # both unital and associative, so algebra in modern sense
+                cat = Algebras(k).FiniteDimensional().WithBasis()
+                cat = cat.or_subcategory(category)
+        elif assume_unital:
+            cat = cat.Unital()
 
         names = normalize_names(n, names)
 
@@ -611,10 +688,10 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
         v = matrix(k, 1, n**2, (n - 1) * ([kone] + n * [kzero]) + [kone])
         try:
             sol1 = B1.solve_left(v)
-            sol2 = B2.solve_left(v)
         except ValueError:
             return False
-        assert sol1 == sol2
+        if sol1 * B2 != v:
+            return False
         self._one = sol1
         return True
 
@@ -932,7 +1009,8 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
         """
         Return a list consisting of all maximal ideals of ``self``.
 
-        The algebra ``self`` has to be in the category of associative algebras.
+        The algebra ``self`` has to be in the category of
+        commutative, associative algebras.
 
         EXAMPLES::
 

sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra_element.pxd

@@ -7,4 +7,6 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
     cdef Matrix __matrix
     cdef FiniteDimensionalAlgebraElement __inverse
 
+    cpdef dict monomial_coefficients(self, bint copy=*)
+
 cpdef FiniteDimensionalAlgebraElement unpickle_FiniteDimensionalAlgebraElement(A, vec, mat)

sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra_element.pyx

@@ -132,6 +132,7 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
             else:
                 raise TypeError("elt should be a vector, a matrix, " +
                                 "or an element of the base field")
+        self._vector.set_immutable()
 
     def __reduce__(self):
         """
@@ -205,6 +206,7 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
             table = <tuple> A.table()
             ret = sum(self._vector[0, i] * table[i] for i in range(A.degree()))
             self.__matrix = MatrixSpace(A.base_ring(), A.degree())(ret)
+        self.__matrix.set_immutable()
         return self.__matrix
 
     def vector(self):
@@ -240,7 +242,7 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
         """
         return self._matrix
 
-    def monomial_coefficients(self, copy=True):
+    cpdef dict monomial_coefficients(self, bint copy=True):
         """
         Return a dictionary whose keys are indices of basis elements in
         the support of ``self`` and whose values are the corresponding
@@ -257,9 +259,10 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
             sage: elt = B(Matrix([[1,1], [-1,1]]))
             sage: elt.monomial_coefficients()
             {0: 1, 1: 1}
+            sage: B.one().monomial_coefficients()
+            {0: 1}
         """
-        cdef Py_ssize_t i
-        return {i: self._vector[0, i] for i in range(self._vector.ncols())}
+        return {k[1]: c for k, c in self._vector._dict().items()}
 
     def left_matrix(self):
         """
@@ -335,6 +338,23 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
         from sage.misc.latex import latex
         return latex(self.matrix())
 
+    def __hash__(self):
+        """
+        Return the hash value for ``self``.
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebra(GF(3), [Matrix([[1,0], [0,1]]),
+            ....:                                      Matrix([[0,1], [0,0]])])
+            sage: a = A([1,2])
+            sage: b = A([2,3])
+            sage: hash(a) == hash(A([1,2]))
+            True
+            sage: hash(a) == hash(b)
+            False
+        """
+        return hash(self._vector)
+
     def __getitem__(self, m):
         """
         Return the `m`-th coefficient of ``self``.
@@ -351,6 +371,9 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
 
     def __len__(self):
         """
+        Return the number of coefficients of ``self``,
+        including the zero coefficients.
+
         EXAMPLES::
 
             sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([[1,0,0], [0,1,0], [0,0,0]]),
@@ -358,6 +381,8 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
             ....:                                   Matrix([[0,0,0], [0,0,0], [0,0,1]])])
             sage: len(A([2,1/4,3]))
             3
+            sage: len(A([2,0,3/4]))
+            3
         """
         return self._vector.ncols()
 

sage/algebras/finite_gca.py

@@ -161,7 +161,7 @@ class FiniteGCAlgebra(CombinatorialFreeModule):
             raise TypeError("max_degree must be specified")
         if names is None:
             if degrees is None:
-                raise ValueError("You must specify names or degrees")
+                raise ValueError("you must specify names or degrees")
             else:
                 n = len(degrees)
             names = tuple(f'x{i}' for i in range(n))

sage/algebras/lie_algebras/bgg_dual_module.py

@@ -18,20 +18,25 @@ AUTHORS:
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 
-from sage.misc.lazy_attribute import lazy_attribute
-from sage.misc.cachefunc import cached_method
+try:
+    from typing import Self  # type: ignore (Python >= 3.11)
+except ImportError:
+    from typing_extensions import Self  # type: ignore (Python 3.10)
+
+from sage.algebras.lie_algebras.verma_module import ModulePrinting
 from sage.categories.enumerated_sets import EnumeratedSets
 from sage.categories.monoids import Monoids
-from sage.structure.parent import Parent
-from sage.structure.indexed_generators import IndexedGenerators
-from sage.monoids.indexed_free_monoid import IndexedFreeAbelianMonoid, IndexedMonoid
 from sage.combinat.free_module import CombinatorialFreeModule
-from sage.sets.family import Family
-from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
+from sage.data_structures.blas_dict import iaxpy
 from sage.matrix.constructor import matrix
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_attribute import lazy_attribute
+from sage.monoids.indexed_free_monoid import IndexedFreeAbelianMonoid, IndexedMonoid
 from sage.rings.integer_ring import ZZ
-from sage.data_structures.blas_dict import iaxpy
-from sage.algebras.lie_algebras.verma_module import ModulePrinting
+from sage.sets.family import Family
+from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
+from sage.structure.indexed_generators import IndexedGenerators
+from sage.structure.parent import Parent
 
 
 class BGGDualModule(CombinatorialFreeModule):
@@ -781,7 +786,9 @@ class SimpleModuleIndices(IndexedFreeAbelianMonoid):
             P = Phi.weight_lattice()
             coroots = Phi.root_lattice().simple_coroots()
             la = P._from_dict({i: weight.scalar(ac) for i, ac in coroots.items()})
-            from sage.combinat.crystals.monomial_crystals import CrystalOfNakajimaMonomials
+            from sage.combinat.crystals.monomial_crystals import (
+                CrystalOfNakajimaMonomials,
+            )
             return CrystalOfNakajimaMonomials(la).cardinality()
         from sage.rings.infinity import infinity
         return infinity
@@ -981,7 +988,7 @@ class SimpleModule(ModulePrinting, CombinatorialFreeModule):
             raise ValueError(f"{m} does not index a basis element")
         return self._indices._basis[m]
 
-    def dual(self):
+    def dual(self) -> Self:
         r"""
         Return the dual module of ``self``, which is ``self`` since simple
         modules are self-dual.

sage/algebras/lie_algebras/classical_lie_algebra.py

@@ -1713,7 +1713,7 @@ class LieAlgebraChevalleyBasis(LieAlgebraWithStructureCoefficients):
 
             sage: sl3 = LieAlgebra(GF(3), cartan_type=['A',2])
             sage: sl3.center().basis()
-            Family (2*h1 + h2,)
+            Finite family {alphacheck[2]: 2*h1 + h2}
             sage: sl4 = lie_algebras.sl(GF(3), 4)
             sage: sl4.center().dimension()
             0
@@ -1735,7 +1735,7 @@ class LieAlgebraChevalleyBasis(LieAlgebraWithStructureCoefficients):
 
             sage: sl4 = LieAlgebra(GF(2), cartan_type=['A',3])
             sage: sl4.center().basis()
-            Family (h1 + h3,)
+            Finite family {alphacheck[3]: h1 + h3}
             sage: sp6 = LieAlgebra(GF(2), cartan_type=['C',3])
             sage: sp6.killing_form_matrix().det()
             0
@@ -2172,7 +2172,7 @@ class LieAlgebraChevalleyBasis(LieAlgebraWithStructureCoefficients):
         return Family(I, d.__getitem__)
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
         Return the generators of ``self`` in the order of `e_i`, `f_i`,
         and `h_i`.

sage/algebras/lie_algebras/examples.py

@@ -169,7 +169,7 @@ def three_dimensional_by_rank(R, n, a=None, names=['X', 'Y', 'Z']):
 
     if n == 2:
         if a is None:
-            raise ValueError("The parameter 'a' must be specified")
+            raise ValueError("the parameter 'a' must be specified")
         X = names[0]
         Y = names[1]
         Z = names[2]
@@ -197,7 +197,7 @@ def three_dimensional_by_rank(R, n, a=None, names=['X', 'Y', 'Z']):
         L.rename("sl2 over {}".format(R))
         return L
 
-    raise ValueError("Invalid rank")
+    raise ValueError("invalid rank")
 
 
 def affine_transformations_line(R, names=['X', 'Y'], representation='bracket'):

sage/algebras/lie_algebras/free_lie_algebra.py

@@ -421,7 +421,7 @@ class FreeLieAlgebra(Parent, UniqueRepresentation):
         """
         return self.Lyndon().lie_algebra_generators()
 
-    def gens(self):
+    def gens(self) -> tuple:
         """
         Return the generators of ``self`` in the Lyndon basis.
 

sage/algebras/lie_algebras/heisenberg.py

@@ -8,15 +8,15 @@ AUTHORS:
 - Travis Scrimshaw (2013-08-13): Initial version
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2013-2017 Travis Scrimshaw <tcscrims at gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.misc.cachefunc import cached_method
 from sage.structure.indexed_generators import IndexedGenerators
@@ -236,7 +236,7 @@ class HeisenbergAlgebra_fd:
         return self._n
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         """
         Return the Lie algebra generators of ``self``.
 

sage/algebras/lie_algebras/lie_algebra.py

@@ -825,7 +825,7 @@ class LieAlgebraWithGenerators(LieAlgebra):
         return Family(self._indices, self.monomial, name="monomial map")
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         """
         Return a tuple whose entries are the generators for this
         object, in some order.