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

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
@@ -192,10 +208,10 @@ cdef class LieAlgebraElementWrapper(ElementWrapper):
     The next doctests show similar behavior, although on elements of
     other classes::
 
+        sage: # needs sage.graphs
         sage: L = lie_algebras.three_dimensional_by_rank(QQ, 3)
         sage: L.bracket(L.gen(0), L.gen(1)) == -L.bracket(L.gen(1), L.gen(0))
         True
-
         sage: L = lie_algebras.three_dimensional_by_rank(QQ, 1)
         sage: L.bracket(L.gen(0), L.gen(1)) == -L.bracket(L.gen(1), L.gen(0))
         True
@@ -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
@@ -972,6 +1008,7 @@ cdef class UntwistedAffineLieAlgebraElement(Element):
 
         EXAMPLES::
 
+            sage: # needs sage.graphs
             sage: L = lie_algebras.Affine(QQ, ['B', 3, 1])
             sage: elt = L.an_element()
             sage: elt._repr_generic(str, str, lambda t: "T^{}".format(t), '.', '(x)')

sage/algebras/lie_algebras/quotient.py

@@ -23,6 +23,7 @@ from sage.algebras.lie_algebras.subalgebra import LieSubalgebra_finite_dimension
 from sage.categories.homset import Hom
 from sage.categories.lie_algebras import LieAlgebras
 from sage.categories.morphism import SetMorphism
+from sage.structure.element import Element
 from sage.structure.indexed_generators import standardize_names_index_set
 
 
@@ -161,7 +162,7 @@ class LieQuotient_finite_dimensional_with_basis(LieAlgebraWithStructureCoefficie
         sage: L.<c,b,a> = LieAlgebra(QQ, abelian=True)
         sage: I2 = L.ideal([a+b, a+c], order=sorted)
         sage: I2.basis()
-        Family (b + a, c + a)
+        Finite family {'b': b + a, 'c': c + a}
         sage: Q = L.quotient(I2)
         sage: Q.basis()
         Finite family {'a': a}
@@ -174,40 +175,44 @@ class LieQuotient_finite_dimensional_with_basis(LieAlgebraWithStructureCoefficie
         2
         sage: TestSuite(K).run()
     """
-
     @staticmethod
-    def __classcall_private__(cls, I, ambient=None, names=None,
-                              index_set=None, category=None):
+    def __classcall_private__(cls, ambient, I, names=None, index_set=None,
+                              index_set_mapping=None, category=None):
         r"""
         Normalize input to ensure a unique representation.
 
-        EXAMPLES:
-
-        Specifying the ambient Lie algebra is not necessary::
+        EXAMPLES::
 
             sage: from sage.algebras.lie_algebras.quotient import LieQuotient_finite_dimensional_with_basis
             sage: L.<X,Y> = LieAlgebra(QQ, {('X','Y'): {'X': 1}})
-            sage: Q1 = LieQuotient_finite_dimensional_with_basis(X, ambient=L)
-            sage: Q2 = LieQuotient_finite_dimensional_with_basis(X)
-            sage: Q1 is Q2
-            True
+            sage: Q1 = LieQuotient_finite_dimensional_with_basis(L, X)
 
         Variable names are extracted from the ambient Lie algebra by default::
 
+            sage: Q2 = LieQuotient_finite_dimensional_with_basis(L, X, index_set=['Y'])
+            sage: Q1 is Q2
+            True
             sage: Q3 = L.quotient(X, names=['Y'])
             sage: Q1 is Q3
             True
+
+        Check that quotients are properly constructed for ideals of
+        subalgebras (:issue:`40137`)::
+
+            sage: L.<a,b,c,d> = LieAlgebra(QQ, {('a','b'): {'c': 1, 'd':1}, ('a','c'): {'b':1}})
+            sage: A = L.ideal([b,c,d])
+            sage: B = L.ideal([c+d])
+            sage: Q = A.quotient(B); Q
+            Lie algebra quotient L/I of dimension 1 over Rational Field where
+            L: Ideal (b, c, d) of Lie algebra on 4 generators (a, b, c, d) over Rational Field
+            I: Ideal (b, c + d)
+            sage: Q.dimension() == A.dimension() - B.dimension()
+            True
         """
         if not isinstance(I, LieSubalgebra_finite_dimensional_with_basis):
-            # assume I is an element or list of elements of some lie algebra
-            if ambient is None:
-                if not isinstance(I, (list, tuple)):
-                    ambient = I.parent()
-                else:
-                    ambient = I[0].parent()
             I = ambient.ideal(I)
-        if ambient is None:
-            ambient = I.ambient()
+        if I.is_ideal(ambient):
+            I = ambient.ideal(I)
 
         if not ambient.base_ring().is_field():
             raise NotImplementedError("quotients over non-fields "
@@ -216,12 +221,16 @@ class LieQuotient_finite_dimensional_with_basis(LieAlgebraWithStructureCoefficie
         # extract an index set from a complementary basis to the ideal
         I_supp = [X.leading_support() for X in I.leading_monomials()]
         inv = ambient.basis().inverse_family()
-        sorted_indices = [inv[X] for X in ambient.basis()]
-        index_set = [i for i in sorted_indices if i not in I_supp]
+        IA = I.ambient()
+        B = ambient.basis()
+        if index_set_mapping is None:
+            index_set_mapping = [(IA(B[k]).leading_support(key=I._order), k) for k in B.keys()]
+        if index_set is None:
+            index_set = [i[0] for i in index_set_mapping if i[0] not in I_supp]
 
         if names is None:
             try:
-                amb_names = dict(zip(sorted_indices, ambient.variable_names()))
+                amb_names = dict(zip([i[1] for i in index_set_mapping], ambient.variable_names()))
                 names = [amb_names[i] for i in index_set]
             except (ValueError, KeyError):
                 # ambient has not assigned variable names
@@ -234,16 +243,16 @@ class LieQuotient_finite_dimensional_with_basis(LieAlgebraWithStructureCoefficie
                 names = ['%s_%d' % (names, k + 1)
                          for k in range(len(index_set))]
         names, index_set = standardize_names_index_set(names, index_set)
+        index_set_mapping = tuple([i for i in index_set_mapping if i[0] not in I_supp])
 
         cat = LieAlgebras(ambient.base_ring()).FiniteDimensional().WithBasis()
         if ambient in LieAlgebras(ambient.base_ring()).Nilpotent():
             cat = cat.Nilpotent()
         category = cat.Subquotients().or_subcategory(category)
+        return super().__classcall__(cls, ambient, I, names, index_set,
+                                     index_set_mapping, category=category)
 
-        return super().__classcall__(cls, I, ambient, names, index_set,
-                                     category=category)
-
-    def __init__(self, I, L, names, index_set, category=None):
+    def __init__(self, L, I, names, index_set, index_set_mapping, category=None):
         r"""
         Initialize ``self``.
 
@@ -257,8 +266,10 @@ class LieQuotient_finite_dimensional_with_basis(LieAlgebraWithStructureCoefficie
             sage: TestSuite(K).run()
         """
         B = L.basis()
-        sm = L.module().submodule_with_basis([I.reduce(B[i]).to_vector()
-                                              for i in index_set])
+        IA = I.ambient()
+        self._index_set_mapping = dict(index_set_mapping)
+        sm = L.module().submodule_with_basis([I.reduce(B[k]).to_vector()
+                                              for k in self._index_set_mapping.values()])
         SB = [L.from_vector(b) for b in sm.basis()]
 
         # compute and normalize structural coefficients for the quotient
@@ -370,7 +381,7 @@ class LieQuotient_finite_dimensional_with_basis(LieAlgebraWithStructureCoefficie
         """
         L = self.ambient()
         B = L.basis()
-        return L.sum(ck * B[ik] for ik, ck in X)
+        return L.sum(ck * B[self._index_set_mapping[ik]] for ik, ck in X)
 
     def retract(self, X):
         r"""