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

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.

sage/algebras/lie_algebras/lie_algebra_element.pyx

@@ -23,7 +23,6 @@ from cpython.object cimport Py_EQ, Py_NE, Py_GT, Py_GE
 from sage.misc.repr import repr_lincomb
 from sage.structure.element cimport have_same_parent, parent
 from sage.structure.coerce cimport coercion_model
-from sage.cpython.wrapperdescr cimport wrapperdescr_fastcall
 from sage.structure.element_wrapper cimport ElementWrapper
 from sage.structure.richcmp cimport richcmp, richcmp_not_equal
 from sage.data_structures.blas_dict cimport axpy, add, negate, scal
@@ -67,11 +66,28 @@ cdef class LieAlgebraElement(IndexedFreeModuleElement):
         """
         try:
             # Try the normal coercion first
-            return wrapperdescr_fastcall(IndexedFreeModuleElement.__mul__,
-                                         left, (right,), <object>NULL)
+            return IndexedFreeModuleElement.__mul__(left, right)
         except TypeError:
             pass
 
+        try:
+            # Handle the case of right multiplication by scalar
+            if isinstance(left, IndexedFreeModuleElement):
+                R = (<IndexedFreeModuleElement>left)._parent._base
+                x = R.coerce(right)
+                return IndexedFreeModuleElement.__mul__(left, x)
+        except (TypeError, KeyError):
+            pass
+
+        try:
+            # Handle the case of left multiplication by scalar
+            if isinstance(right, IndexedFreeModuleElement):
+                R = (<IndexedFreeModuleElement>right)._parent._base
+                x = R.coerce(left)
+                return IndexedFreeModuleElement.__mul__(x, right)
+        except (TypeError, KeyError):
+            pass
+
         # Lift up to the UEA and try multiplication there
         # We will eventually want to lift stuff up anyways,
         #   so just do it here.
@@ -117,7 +133,7 @@ cdef class LieAlgebraElement(IndexedFreeModuleElement):
         s = codomain.zero()
         if not self:  # If we are 0
             return s
-        names = self.parent().variable_names()
+        names = self._parent.variable_names()
         if base_map is None:
             def base_map(x):
                 return x
@@ -353,11 +369,28 @@ cdef class LieAlgebraElementWrapper(ElementWrapper):
         """
         try:
             # Try the normal coercion first
-            return wrapperdescr_fastcall(ElementWrapper.__mul__,
-                                         left, (right,), <object>NULL)
+            return ElementWrapper.__mul__(left, right)
         except TypeError:
             pass
 
+        try:
+            # Handle the case of right multiplication by scalar
+            if isinstance(left, LieAlgebraElementWrapper):
+                R = (<LieAlgebraElementWrapper>left)._parent._base
+                x = R.coerce(right)
+                return ElementWrapper.__mul__(left, x)
+        except (TypeError, KeyError):
+            pass
+
+        try:
+            # Handle the case of left multiplication by scalar
+            if isinstance(right, LieAlgebraElementWrapper):
+                R = (<LieAlgebraElementWrapper>right)._parent._base
+                x = R.coerce(left)
+                return ElementWrapper.__mul__(x, right)
+        except (TypeError, KeyError):
+            pass
+
         # Lift up to the UEA and try multiplication there
         # We will eventually want to lift stuff up anyways,
         #   so just do it here.
@@ -517,10 +550,12 @@ cdef class LieSubalgebraElementWrapper(LieAlgebraElementWrapper):
 
             sage: L.<X,Y,Z> = LieAlgebra(QQ, {('X','Y'): {'Z': 1}})
             sage: S = L.subalgebra([X, Y])
+            sage: S.indices()
+            {'X', 'Y', 'Z'}
             sage: el = S(2*Y + 9*Z)
-            sage: el[1]
+            sage: el['Y']
             2
-            sage: el[2]
+            sage: el['Z']
             9
         """
         if self._monomial_coefficients is None:
@@ -529,7 +564,7 @@ cdef class LieSubalgebraElementWrapper(LieAlgebraElementWrapper):
         try:
             return self._monomial_coefficients[i]
         except KeyError:
-            return self.parent().base_ring().zero()
+            return self._parent.base_ring().zero()
 
     def _bracket_(self, x):
         """
@@ -561,12 +596,12 @@ cdef class LieSubalgebraElementWrapper(LieAlgebraElementWrapper):
             sage: L.<X,Y,Z> = LieAlgebra(ZZ, {('X','Y'): {'Z': 3}})
             sage: S = L.subalgebra([X, Y])
             sage: S.basis()
-            Family (X, Y, 3*Z)
+            Finite family {'X': X, 'Y': Y, 'Z': 3*Z}
             sage: S(2*Y + 9*Z).to_vector()
             (0, 2, 9)
             sage: S2 = L.subalgebra([Y, Z])
             sage: S2.basis()
-            Family (Y, Z)
+            Finite family {'Y': Y, 'Z': Z}
             sage: S2(2*Y + 9*Z).to_vector()
             (0, 2, 9)
 
@@ -601,17 +636,18 @@ cdef class LieSubalgebraElementWrapper(LieAlgebraElementWrapper):
             sage: L.<X,Y,Z> = LieAlgebra(ZZ, {('X','Y'): {'Z': 3}})
             sage: S = L.subalgebra([X, Y])
             sage: S(2*Y + 9*Z).monomial_coefficients()
-            {1: 2, 2: 3}
+            {'Y': 2, 'Z': 3}
             sage: S2 = L.subalgebra([Y, Z])
             sage: S2(2*Y + 9*Z).monomial_coefficients()
-            {0: 2, 1: 9}
+            {'Y': 2, 'Z': 9}
         """
         cdef Py_ssize_t k
+        indices = self._parent._indices
         if self._monomial_coefficients is None:
-            sm = self.parent().module()
+            sm = self._parent.module()
             v = sm.coordinate_vector(self.to_vector())
-            self._monomial_coefficients = {k: v[k] for k in range(len(v))
-                                           if v[k]}
+            self._monomial_coefficients = {indices[k]: v[k]
+                                           for k in range(len(v)) if v[k]}
         if copy:
             return dict(self._monomial_coefficients)
         return self._monomial_coefficients
@@ -627,13 +663,13 @@ cdef class LieSubalgebraElementWrapper(LieAlgebraElementWrapper):
             sage: a = S(2*Y + 12*Z)
             sage: b = S(X + 2*Y)
             sage: (a + b).monomial_coefficients()
-            {0: 1, 1: 4, 2: 4}
+            {'X': 1, 'Y': 4, 'Z': 4}
             sage: a.monomial_coefficients()        # We set a._monomial_coefficients
-            {1: 2, 2: 4}
+            {'Y': 2, 'Z': 4}
             sage: b.monomial_coefficients()        # We set b._monomial_coefficients
-            {0: 1, 1: 2}
+            {'X': 1, 'Y': 2}
             sage: (a + b).monomial_coefficients()  # This is now computed from a and b
-            {0: 1, 1: 4, 2: 4}
+            {'X': 1, 'Y': 4, 'Z': 4}
         """
         cdef LieSubalgebraElementWrapper ret, other = <LieSubalgebraElementWrapper> right
         ret = type(self)(self._parent, self.value + other.value)
@@ -653,13 +689,13 @@ cdef class LieSubalgebraElementWrapper(LieAlgebraElementWrapper):
             sage: a = S(2*Y + 12*Z)
             sage: b = S(X + 2*Y)
             sage: (a - b).monomial_coefficients()
-            {0: -1, 2: 4}
+            {'X': -1, 'Z': 4}
             sage: a.monomial_coefficients()        # We set a._monomial_coefficients
-            {1: 2, 2: 4}
+            {'Y': 2, 'Z': 4}
             sage: b.monomial_coefficients()        # We set b._monomial_coefficients
-            {0: 1, 1: 2}
+            {'X': 1, 'Y': 2}
             sage: (a - b).monomial_coefficients()  # This is now computed from a and b
-            {0: -1, 2: 4}
+            {'X': -1, 'Z': 4}
         """
         cdef LieSubalgebraElementWrapper ret, other = <LieSubalgebraElementWrapper> right
         ret = type(self)(self._parent, self.value - other.value)
@@ -678,11 +714,11 @@ cdef class LieSubalgebraElementWrapper(LieAlgebraElementWrapper):
             sage: S = L.subalgebra([X, Y])
             sage: a = S(2*Y + 12*Z)
             sage: (2*a).monomial_coefficients()
-            {1: 4, 2: 8}
+            {'Y': 4, 'Z': 8}
             sage: a.monomial_coefficients()      # We set a._monomial_coefficients
-            {1: 2, 2: 4}
+            {'Y': 2, 'Z': 4}
             sage: (2*a).monomial_coefficients()  # This is now computed from a
-            {1: 4, 2: 8}
+            {'Y': 4, 'Z': 8}
         """
         # This was copied and IDK if it still applies (TCS):
         # With the current design, the coercion model does not have