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

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"""

sage/algebras/lie_algebras/subalgebra.py

@@ -6,9 +6,12 @@ Subalgebras and ideals of Lie algebras
 AUTHORS:
 
 - Eero Hakavuori (2018-08-29): initial version
+- Travis Scrimshaw (2025-05-21): make all Lie subalgebras use elements
+  in the ambient Lie algebra
 """
 # ****************************************************************************
 #       Copyright (C) 2018 Eero Hakavuori <eero.hakavuori@gmail.com>
+#                     2025 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
@@ -26,7 +29,7 @@ from sage.misc.lazy_attribute import lazy_attribute
 from sage.sets.family import Family
 from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
 from sage.structure.parent import Parent
-from sage.structure.element import parent
+from sage.structure.element import parent, Element
 from sage.structure.unique_representation import UniqueRepresentation
 
 
@@ -59,10 +62,10 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
 
         sage: S = L.subalgebra(Y)
         sage: S.basis()
-        Family (q1,)
+        Finite family {'q1': q1}
         sage: I = L.ideal(Y)
         sage: I.basis()
-        Family (q1, z)
+        Finite family {'q1': q1, 'z': z}
 
     The zero dimensional subalgebra can be created by giving 0 as a generator
     or with an empty list of generators::
@@ -73,7 +76,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
         sage: S1 is S2
         True
         sage: S1.basis()
-        Family ()
+        Finite family {}
 
     Elements of the ambient Lie algebra can be reduced modulo an
     ideal or subalgebra::
@@ -94,7 +97,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
         sage: # needs sage.symbolic
         sage: I =  L.ideal(X + Y)
         sage: I.basis()
-        Family (X + Y, Z)
+        Finite family {'Y': X + Y, 'Z': Z}
         sage: el = var('x')*X + var('y')*Y + var('z')*Z; el
         x*X + y*Y + z*Z
         sage: I.reduce(el)
@@ -104,7 +107,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
 
         sage: I =  L.ideal(X + Y, order=lambda s: ['Z','Y','X'].index(s))               # needs sage.symbolic
         sage: I.basis()                                                                 # needs sage.symbolic
-        Family (Z, X + Y)
+        Finite family {'Z': Z, 'X': X + Y}
         sage: I.reduce(el)                                                              # needs sage.symbolic
         (-x+y)*Y
 
@@ -126,20 +129,22 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
         sage: J = I.ideal(Z); J
         Ideal (Z) of Ideal (Y) of Lie algebra on 4 generators (X, Y, Z, W) over Rational Field
         sage: J.basis()
-        Family (Z,)
+        Finite family {'Z': Z}
         sage: J.is_ideal(L)
         False
         sage: K = L.ideal(J.basis().list())
         sage: K.basis()
-        Family (Z, W)
+        Finite family {'Z': Z, 'W': W}
 
     TESTS:
 
     Test suites::
 
-        sage: S =  L.subalgebra(X + Y)
+        sage: sc = {('X','Y'): {'Z': 1}, ('X','Z'): {'W': 1}}
+        sage: L.<X,Y,Z,W> = LieAlgebra(QQ, sc)
+        sage: S = L.subalgebra(X + Y)
         sage: TestSuite(S).run()
-        sage: I =  L.ideal(X + Y)
+        sage: I = L.ideal(X + Y)
         sage: TestSuite(I).run()
 
     Verify that subalgebras and ideals of nilpotent Lie algebras are nilpotent::
@@ -167,7 +172,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
         W
     """
     @staticmethod
-    def __classcall_private__(cls, ambient, gens, ideal=False,
+    def __classcall_private__(cls, ambient, gens, ideal_of=None,
                               order=None, category=None):
         """
         Normalize input to ensure a unique representation.
@@ -216,15 +221,32 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             Subalgebra generated by (a, a, b, e) of Lie algebra on
              5 generators (a, b, c, d, e) over Rational Field
             sage: S.basis()
-            Family (a, b, e)
+            Finite family {'a': a, 'b': b, 'e': e}
+
+        Check that other container-like objects are handled properly
+        (:issue:`40137`)::
+
+            sage: L.<a,b,c,d> = LieAlgebra(QQ, {('a','b'): {'c': 1, 'd':1}})
+            sage: A = L.ideal([b, c, d])
+            sage: B = L.ideal([b, c+d])
+            sage: A.ideal(B)
+            Ideal (b, c + d) of Ideal (b, c, d) of Lie algebra on 4 generators
+             (a, b, c, d) over Rational Field
+            sage: A.ideal(B.basis())
+            Ideal (b, c + d) of Ideal (b, c, d) of Lie algebra on 4 generators
+             (a, b, c, d) over Rational Field
         """
+        if isinstance(ambient, LieSubalgebra_finite_dimensional_with_basis):
+            ambient = ambient._ambient
         if isinstance(gens, LieSubalgebra_finite_dimensional_with_basis):
-            if not ideal or gens._is_ideal:
+            if gens._ideal_of is ideal_of:
                 return gens
             gens = gens.lie_algebra_generators()
-        if not isinstance(gens, (list, tuple)):
+        if isinstance(gens, Element):
             gens = [gens]
         new_gens = []
+
+        # make sure all elements belong to the ambient Lie algebra
         for gen in gens:
             if isinstance(gen, LieSubalgebra_finite_dimensional_with_basis):
                 new_gens.extend(ambient(b) for b in gen.basis())
@@ -232,21 +254,15 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
                 new_gens.append(ambient(gen))
         gens = tuple(new_gens)
 
-        if not ideal and isinstance(ambient,
-                            LieSubalgebra_finite_dimensional_with_basis):
-            # a nested subalgebra is a subalgebra
-            gens = tuple(ambient.lift(gen) for gen in gens)
-            ambient = ambient.ambient()
-
         cat = LieAlgebras(ambient.base_ring()).FiniteDimensional().WithBasis()
         category = cat.Subobjects().or_subcategory(category)
         if ambient in LieAlgebras(ambient.base_ring()).Nilpotent():
             category = category.Nilpotent()
 
-        return super().__classcall__(cls, ambient, gens, ideal,
+        return super().__classcall__(cls, ambient, gens, ideal_of,
                                      order, category)
 
-    def __init__(self, ambient, gens, ideal, order=None, category=None):
+    def __init__(self, ambient, gens, ideal_of, order=None, category=None):
         r"""
         Initialize ``self``.
 
@@ -264,7 +280,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             True
         """
         self._ambient = ambient
-        self._is_ideal = ideal
+        self._ideal_of = ideal_of
 
         # initialize helper variables for ordering
         if order is None:
@@ -352,16 +368,10 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             sage: L.ideal([X, Y])
             Ideal (X, Y) of Abelian Lie algebra on 2 generators (X, Y) over Rational Field
         """
-        gens = self.gens()
-        if len(gens) == 1:
-            gens = gens[0]
-
-        if self._is_ideal:
-            basestr = "Ideal"
-        else:
-            basestr = "Subalgebra generated by"
+        if self._ideal_of is not None:
+            return "Ideal {} of {}".format(self._repr_short(), self._ideal_of)
 
-        return "%s %s of %s" % (basestr, self._repr_short(), self.ambient())
+        return "Subalgebra generated by {} of {}".format(self._repr_short(), self.ambient())
 
     def _repr_short(self):
         """
@@ -390,7 +400,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             sage: S._an_element_()
             X
         """
-        return self.lie_algebra_generators()[0]
+        return next(iter(self.lie_algebra_generators()))
 
     def _element_constructor_(self, x):
         """
@@ -538,7 +548,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             sage: L.<x,y,z> = LieAlgebra(QQ, abelian=True)
             sage: S = L.subalgebra([x, y])
             sage: S._indices
-            {0, 1}
+            {'x', 'y'}
             sage: [S.basis()[k] for k in S._indices]
             [x, y]
         """
@@ -551,11 +561,11 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
         EXAMPLES::
 
             sage: L.<x,y,z> = LieAlgebra(QQ, abelian=True)
-            sage: S = L.subalgebra([x, y])
+            sage: S = L.subalgebra([x+y, z])
             sage: S.indices()
-            {0, 1}
+            {'y', 'z'}
             sage: [S.basis()[k] for k in S.indices()]
-            [x, y]
+            [x + y, z]
         """
         return self._indices
 
@@ -643,12 +653,13 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             by (X_1, X_2) of Free Nilpotent Lie algebra on 6 generators
             (X_1, X_2, X_3, X_12, X_13, X_23) over Rational Field
         """
+        X = self._ambient(X)
         if X not in self:
             raise ValueError("the element %s is not in %s" % (X, self))
 
         return self.element_class(self, X)
 
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
         Return the generating set of ``self``.
 
@@ -678,9 +689,9 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
 
             sage: I = L.ideal(x)
             sage: I.lie_algebra_generators()
-            Family (x, z)
+            Finite family {'x': x, 'z': z}
         """
-        if self._is_ideal:
+        if self._ideal_of is not None:
             return self.basis()
         return self._gens
 
@@ -696,14 +707,14 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             sage: sc = {('a','b'): {'c': 1}, ('a','c'): {'d': 1}}
             sage: L.<a,b,c,d> = LieAlgebra(QQ, sc)
             sage: L.subalgebra([a + b, c + d]).basis()
-            Family (a + b, c, d)
+            Finite family {'b': a + b, 'c': c, 'd': d}
 
         A basis of an ideal::
 
             sage: sc = {('x','y'): {'z': 1}, ('x','z'): {'w': 1}}
             sage: L.<x,y,z,w> = LieAlgebra(QQ, sc)
             sage: L.ideal([x + y + z + w]).basis()
-            Family (x + y, z, w)
+            Finite family {'y': x + y, 'z': z, 'w': w}
 
         This also works for Lie algebras whose natural basis elements
         are not comparable (but have a well-defined basis ordering)::
@@ -718,27 +729,36 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             sage: sl3.subalgebra(e).dimension()
             3
         """
-        L = self.ambient()
-        B = [self._to_m(X) for X in L.basis()]
+        ambient = self._ambient
+        if self._ideal_of is not None:
+            L = self._ideal_of
+            B = [self._to_m(ambient(X)) for X in L.basis()]
+        else:
+            L = ambient
+            B = [self._to_m(X) for X in ambient.basis()]
 
-        m = L.module()
+        m = ambient.module()
         sm = m.submodule([self._to_m(X.value) for X in self.gens()])
         d = 0
 
         while sm.dimension() > d:
             d = sm.dimension()
             SB = sm.basis()
-            if not self._is_ideal:
+            if self._ideal_of is None:
                 B = SB
 
-            brackets = [self._to_m(L.bracket(self._from_m(v), self._from_m(w)))
+            brackets = [self._to_m(ambient.bracket(self._from_m(v), self._from_m(w)))
                         for v in B for w in SB]
             sm = m.submodule(sm.basis() + brackets)
 
         basis = [self.element_class(self, self._from_m(v))
                  for v in sm.echelonized_basis()]
-        sortkey = lambda X: self._order(self.lift(X).leading_support(key=self._order))
-        return Family(sorted(basis, key=sortkey))
+
+        indices = [self.lift(X).leading_support(key=self._order) for X in basis]
+        basis = dict(zip(indices, basis))
+        indices.sort(key=self._order)
+
+        return Family(indices, basis.__getitem__)
 
     @cached_method
     def leading_monomials(self):
@@ -753,7 +773,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             sage: L.<a,b,c,d> = LieAlgebra(ZZ, sc)
             sage: I = L.ideal(a + b)
             sage: I.basis()
-            Family (a + b, 2*c, 4*d)
+            Finite family {'b': a + b, 'c': 2*c, 'd': 4*d}
             sage: I.leading_monomials()
             Family (b, c, d)
 
@@ -762,7 +782,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             sage: key = lambda s: ['d','c','b','a'].index(s)
             sage: I = L.ideal(a + b, order=key)
             sage: I.basis()
-            Family (4*d, 2*c, a + b)
+            Finite family {'d': 4*d, 'c': 2*c, 'a': a + b}
             sage: I.leading_monomials()
             Family (d, c, a)
         """
@@ -885,7 +905,7 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
             sage: L.is_ideal(I)
             False
         """
-        if A == self._ambient and self._is_ideal:
+        if A is self._ideal_of:
             return True
         return super().is_ideal(A)
 
@@ -900,7 +920,10 @@ class LieSubalgebra_finite_dimensional_with_basis(Parent, UniqueRepresentation):
                 sage: m = MS([[0, -1], [1, 0]])
                 sage: L = LieAlgebra(associative=MS)
                 sage: S = L.subalgebra([m])
-                sage: x = S.basis()[0]
+                sage: S.basis()
+                Finite family {(1, 0): [ 0 -1]
+                                       [ 1  0]}
+                sage: x = S.basis()[1,0]
                 sage: x.parent() is S
                 True
                 sage: x.adjoint_matrix()

sage/algebras/lie_algebras/verma_module.py

@@ -30,11 +30,9 @@ from sage.categories.morphism import Morphism
 from sage.categories.homset import Hom, Homset
 from sage.monoids.indexed_free_monoid import IndexedFreeAbelianMonoid
 from sage.combinat.free_module import CombinatorialFreeModule
-from sage.modules.free_module_element import vector
 from sage.sets.family import Family
 from sage.structure.richcmp import richcmp
 from sage.rings.integer_ring import ZZ
-from sage.rings.rational_field import QQ
 
 
 class ModulePrinting:
@@ -358,7 +356,7 @@ class VermaModule(ModulePrinting, CombinatorialFreeModule):
         return self._from_dict({self._indices.one(): one},
                                remove_zeros=False, coerce=False)
 
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
         Return the generators of ``self`` as a `U(\mathfrak{g})`-module.
 

sage/algebras/octonion_algebra.pyx

@@ -956,7 +956,7 @@ class OctonionAlgebra(UniqueRepresentation, Parent):
         return 0
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
         Return the generators of ``self``.
 

sage/algebras/orlik_solomon.py

@@ -193,7 +193,7 @@ class OrlikSolomonAlgebra(CombinatorialFreeModule):
 
             sage: M = matroids.Wheel(3)
             sage: OS = M.orlik_solomon_algebra(QQ)
-            sage: OS.one_basis() == frozenset([])
+            sage: OS.one_basis() == frozenset()
             True
         """
         return frozenset({})
@@ -348,7 +348,7 @@ class OrlikSolomonAlgebra(CombinatorialFreeModule):
             [[(1, 2), (1, 4), (2, 3), (3, 4)],
              [(3, 5), (3, 6), (5, 6)]]
             sage: OSMG = MG.orlik_solomon_algebra(QQ, ordering=s)
-            sage: OSMG.subset_image(frozenset([]))
+            sage: OSMG.subset_image(frozenset())
             OS{}
             sage: OSMG.subset_image(frozenset([(1,2),(3,4),(1,4),(2,3)]))
             0
@@ -376,7 +376,7 @@ class OrlikSolomonAlgebra(CombinatorialFreeModule):
              [0, 3, 5], [1, 2, 4], [1, 2, 5], [1, 3, 4],
              [1, 3, 5], [2, 3], [4, 5]]
             sage: OSMG = MG.orlik_solomon_algebra(QQ)
-            sage: OSMG.subset_image(frozenset([]))
+            sage: OSMG.subset_image(frozenset())
             OS{}
             sage: OSMG.subset_image(frozenset([1, 2, 3]))
             0
@@ -395,7 +395,7 @@ class OrlikSolomonAlgebra(CombinatorialFreeModule):
             sage: sorted([sorted(c) for c in MG.circuits()])
             [[0, 1], [2, 3, 4]]
             sage: OSMG = MG.orlik_solomon_algebra(QQ)
-            sage: OSMG.subset_image(frozenset([]))
+            sage: OSMG.subset_image(frozenset())
             OS{}
             sage: OSMG.subset_image(frozenset([1, 3, 4]))
             -OS{0, 2, 3} + OS{0, 2, 4}

sage/algebras/orlik_terao.py

@@ -243,7 +243,7 @@ class OrlikTeraoAlgebra(CombinatorialFreeModule):
 
             sage: M = matroids.Wheel(3)
             sage: OT = M.orlik_terao_algebra(QQ)
-            sage: OT.one_basis() == frozenset([])
+            sage: OT.one_basis() == frozenset()
             True
         """
         return frozenset({})
@@ -392,7 +392,7 @@ class OrlikTeraoAlgebra(CombinatorialFreeModule):
             [[(1, 2), (1, 4), (2, 3), (3, 4)],
              [(3, 5), (3, 6), (5, 6)]]
             sage: OT = M.orlik_terao_algebra(QQ, ordering=s)
-            sage: OT.subset_image(frozenset([]))
+            sage: OT.subset_image(frozenset())
             OT{}
             sage: OT.subset_image(frozenset([(1,2),(3,4),(1,4),(2,3)]))
             0
@@ -420,7 +420,7 @@ class OrlikTeraoAlgebra(CombinatorialFreeModule):
              [0, 3, 5], [1, 2, 4], [1, 2, 5], [1, 3, 4],
              [1, 3, 5], [2, 3], [4, 5]]
             sage: OT = M.orlik_terao_algebra()
-            sage: OT.subset_image(frozenset([]))
+            sage: OT.subset_image(frozenset())
             OT{}
             sage: OT.subset_image(frozenset([1, 2, 3]))
             0
@@ -439,7 +439,7 @@ class OrlikTeraoAlgebra(CombinatorialFreeModule):
             sage: sorted([sorted(c) for c in M.circuits()])
             [[0, 1], [2, 3, 4]]
             sage: OT = M.orlik_terao_algebra(QQ)
-            sage: OT.subset_image(frozenset([]))
+            sage: OT.subset_image(frozenset())
             OT{}
             sage: OT.subset_image(frozenset([1, 3, 4]))
             -OT{0, 2, 3} + OT{0, 2, 4}