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/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}

sage/algebras/steenrod/steenrod_algebra.py

@@ -453,12 +453,13 @@ examples.
 #  Distributed under the terms of the GNU General Public License (GPL)
 # ****************************************************************************
 
-from sage.combinat.free_module import CombinatorialFreeModule
-from sage.misc.lazy_attribute import lazy_attribute
-from sage.misc.cachefunc import cached_method
+from sage.categories.homset import Hom
 from sage.categories.modules_with_basis import ModulesWithBasis
 from sage.categories.tensor import tensor
-from sage.categories.homset import Hom
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_attribute import lazy_attribute
+from sage.sets.family import Family
 
 ######################################################
 # the main class
@@ -2109,7 +2110,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             sage: A1._element_constructor_(Sq(4)) # Sq(4) not in A1
             Traceback (most recent call last):
             ...
-            ValueError: Element does not lie in this Steenrod algebra
+            ValueError: element does not lie in this Steenrod algebra
             sage: A1({(2,): 1, (1,): 13})
             Sq(1) + Sq(2)
         """
@@ -2131,7 +2132,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
                 if self.basis_name() == 'milnor':
                     return a
                 return a.change_basis(self.basis_name())
-        raise ValueError("Element does not lie in this Steenrod algebra")
+        raise ValueError("element does not lie in this Steenrod algebra")
 
     def __contains__(self, x):
         r"""
@@ -2343,7 +2344,8 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         """
         from sage.rings.integer import Integer
         if self.basis_name() != 'milnor':
-            return self(SteenrodAlgebra(p=self.prime(),generic=self._generic).P(*nums))
+            return self(SteenrodAlgebra(p=self.prime(),
+                                        generic=self._generic).P(*nums))
         while nums and nums[-1] == 0:
             nums = nums[:-1]
         if len(nums) == 0 or (len(nums) == 1 and nums[0] == 0):
@@ -2359,10 +2361,11 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         else:
             t = ((), nums)
         if self._check_profile_on_basis(t):
-            A = SteenrodAlgebra_generic(p=self.prime(),generic=self._generic)
+            A = SteenrodAlgebra_generic(p=self.prime(),
+                                        generic=self._generic)
             a = A.monomial(t)
             return self(a)
-        raise ValueError("Element not in this algebra")
+        raise ValueError("element not in this algebra")
 
     def Q_exp(self, *nums):
         r"""
@@ -2399,7 +2402,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             Q_0 Q_2
         """
         if not all(x in (0, 1) for x in nums):
-            raise ValueError("The tuple %s should consist " % (nums,) +
+            raise ValueError("the tuple %s should consist " % (nums,) +
                              "only of 0s and 1s")
         else:
             if self.basis_name() != 'milnor':
@@ -2452,13 +2455,14 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             sage: H.Q(4)
             Traceback (most recent call last):
             ...
-            ValueError: Element not in this algebra
+            ValueError: element not in this algebra
         """
         if len(nums) != len(set(nums)):
             return self(0)
         else:
             if self.basis_name() != 'milnor':
-                return self(SteenrodAlgebra(p=self.prime(),generic=self._generic).Q(*nums))
+                return self(SteenrodAlgebra(p=self.prime(),
+                                            generic=self._generic).Q(*nums))
             if not self._generic:
                 if len(nums) == 0:
                     return self.one()
@@ -2474,9 +2478,9 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
                 t = answer.leading_support()
                 if self._check_profile_on_basis(t):
                     return answer
-                raise ValueError("Element not in this algebra")
+                raise ValueError("element not in this algebra")
 
-    def an_element(self):
+    def _an_element_(self):
         """
         An element of this Steenrod algebra.
 
@@ -2509,29 +2513,32 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
                 return self.one()
 
         if basis == 'milnor' and not self._generic:
-            return self.monomial((2,1))
+            return self.monomial((2, 1))
         if basis == 'milnor' and self._generic:
-            return self.term(((1,3), (2,1)), GF(p)(p-1))
+            return self.term(((1, 3), (2, 1)), GF(p)(p - 1))
         if basis == 'serre-cartan' and not self._generic:
-            return self.monomial((4,2,1))
+            return self.monomial((4, 2, 1))
         if basis == 'serre-cartan' and self._generic:
-            return self.term((1,p,0,1,0), GF(p)(p-1))
+            return self.term((1, p, 0, 1, 0), GF(p)(p - 1))
         if basis == 'woody' or basis == 'woodz':
-            return self._from_dict({((3,0),): 1, ((1, 1), (1, 0)): 1}, coerce=True)
+            return self._from_dict({((3, 0),): 1,
+                                    ((1, 1), (1, 0)): 1}, coerce=True)
         if basis.find('wall') >= 0:
-            return self._from_dict({((1,1), (1,0)): 1, ((2, 2), (0, 0)): 1}, coerce=True)
+            return self._from_dict({((1, 1), (1, 0)): 1,
+                                    ((2, 2), (0, 0)): 1}, coerce=True)
         if basis.find('arnona') >= 0:
-            return self._from_dict({((3,3),): 1, ((1, 1), (2, 1)): 1}, coerce=True)
+            return self._from_dict({((3, 3),): 1,
+                                    ((1, 1), (2, 1)): 1}, coerce=True)
         if basis == 'arnonc':
             return self._from_dict({(8,): 1, (4, 4): 1}, coerce=True)
         if basis.find('pst') >= 0:
             if not self._generic:
                 return self.monomial(((3, 1),))
-            return self.term(((1,), (((1,1), 2),)), GF(p)(p-1))
+            return self.term(((1,), (((1, 1), 2),)), GF(p)(p - 1))
         if basis.find('comm') >= 0:
             if not self._generic:
                 return self.monomial(((1, 2),))
-            return self.term(((), (((1,2), 1),)), GF(p)(p-1))
+            return self.term(((), (((1, 2), 1),)), GF(p)(p - 1))
 
     def pst(self, s, t):
         r"""
@@ -2564,7 +2571,8 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         """
         from sage.rings.integer import Integer
         if self.basis_name() != 'milnor':
-            return self(SteenrodAlgebra(p=self.prime(),generic=self._generic).pst(s,t))
+            return self(SteenrodAlgebra(p=self.prime(),
+                                        generic=self._generic).pst(s, t))
         if not isinstance(s, (Integer, int)) and s >= 0:
             raise ValueError("%s is not a nonnegative integer" % s)
         if not isinstance(t, (Integer, int)) and t > 0:
@@ -2620,7 +2628,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             return sum(self._profile)
         return sum(self._profile[0]) + len([a for a in self._profile[1] if a == 2])
 
-    def gens(self):
+    def gens(self) -> Family:
         r"""
         Family of generators for this algebra.
 
@@ -2677,7 +2685,6 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             sage: SteenrodAlgebra(p=5, profile=[[2,1], [2,2,2]]).algebra_generators()
             Family (Q_0, P(1), P(5))
         """
-        from sage.sets.family import Family
         from sage.sets.non_negative_integers import NonNegativeIntegers
         from sage.rings.infinity import Infinity
         n = self.ngens()
@@ -2739,7 +2746,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
             sage: SteenrodAlgebra(profile=[1,2,1]).gen(5)
             Traceback (most recent call last):
             ...
-            ValueError: This algebra only has 4 generators, so call gen(i) with 0 <= i < 4
+            ValueError: this algebra only has 4 generators, so call gen(i) with 0 <= i < 4
 
             sage: D = SteenrodAlgebra(profile=lambda n: n)
             sage: [D.gen(n) for n in range(5)]
@@ -2761,11 +2768,11 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         num = self.ngens()
         if num < Infinity:
             if i >= num:
-                raise ValueError("This algebra only has %s generators, so call gen(i) with 0 <= i < %s" % (num, num))
+                raise ValueError("this algebra only has %s generators, so call gen(i) with 0 <= i < %s" % (num, num))
             # check to see if equal to A(n) for some n.
             n = self.profile(1)
             if not self._generic and self._profile == AA(n-1, p=p)._profile:
-                return self.pst(i,1)
+                return self.pst(i, 1)
             if self._generic and self._profile == AA(n, p=p)._profile:
                 if i == 0:
                     return self.Q(0)
@@ -3053,7 +3060,7 @@ class SteenrodAlgebra_generic(CombinatorialFreeModule):
         """
         return self.is_field()
 
-    def is_noetherian(self):
+    def is_noetherian(self) -> bool:
         """
         This algebra is Noetherian if and only if it is finite.
 

sage/algebras/steenrod/steenrod_algebra_bases.py

@@ -355,7 +355,7 @@ def steenrod_algebra_basis(n, basis='milnor', p=2, **kwds):
     profile = kwds.get("profile", None)
     if (profile is not None and profile != () and profile != ((), ())
             and basis != 'milnor' and basis.find('pst') == -1):
-        raise ValueError("Profile functions may only be used with the Milnor or pst bases")
+        raise ValueError("profile functions may only be used with the Milnor or pst bases")
 
     # Milnor basis
     if basis_name == 'milnor':
@@ -377,7 +377,7 @@ def steenrod_algebra_basis(n, basis='milnor', p=2, **kwds):
     elif not generic and basis == 'arnonc':
         return arnonC_basis(n)
     else:
-        raise ValueError("Unknown basis: %s at the prime %s" % (basis, p))
+        raise ValueError("unknown basis: %s at the prime %s" % (basis, p))
 
 
 # helper functions for producing bases