some care about algebra_generators

Author: fchapoton

src/sage/algebras/jordan_algebra.py

@@ -311,7 +311,7 @@ def _an_element_(self):
         return self.element_class(self, self._A.an_element())
 
     @cached_method
-    def basis(self):
+    def basis(self) -> Family:
         """
         Return the basis of ``self``.
 
@@ -323,12 +323,13 @@ def basis(self):
             Lazy family (Term map(i))_{i in Free monoid on 3 generators (x, y, z)}
         """
         B = self._A.basis()
-        return Family(B.keys(), lambda x: self.element_class(self, B[x]), name="Term map")
+        return Family(B.keys(),
+                      lambda x: self.element_class(self, B[x]), name="Term map")
 
     algebra_generators = basis
 
     # TODO: Keep this until we can better handle R.<...> shorthand
-    def gens(self) -> tuple:
+    def gens(self) -> Family:
         """
         Return the generators of ``self``.
 
@@ -338,16 +339,16 @@ def gens(self) -> tuple:
             sage: C = CombinatorialFreeModule(QQ, ['x','y','z'], category=cat)
             sage: J = JordanAlgebra(C)
             sage: J.gens()
-            (B['x'], B['y'], B['z'])
+            Finite family {'x': B['x'], 'y': B['y'], 'z': B['z']}
 
             sage: F.<x,y,z> = FreeAlgebra(QQ)
             sage: J = JordanAlgebra(F)
             sage: J.gens()
             Traceback (most recent call last):
             ...
-            NotImplementedError: infinite set
+            Lazy family (Term map(i))_{i in Free monoid on 3 generators (x, y, z)}
         """
-        return tuple(self.algebra_generators())
+        return self.algebra_generators()
 
     @cached_method
     def zero(self):
@@ -741,7 +742,7 @@ def _coerce_map_from_base_ring(self):
         return self._generic_coerce_map(self.base_ring())
 
     @cached_method
-    def basis(self):
+    def basis(self) -> Family:
         """
         Return a basis of ``self``.
 
@@ -763,7 +764,7 @@ def basis(self):
 
     algebra_generators = basis
 
-    def gens(self) -> tuple:
+    def gens(self) -> Family:
         """
         Return the generators of ``self``.
 
@@ -772,9 +773,9 @@ def gens(self) -> tuple:
             sage: m = matrix([[0,1],[1,1]])
             sage: J = JordanAlgebra(m)
             sage: J.gens()
-            (1 + (0, 0), 0 + (1, 0), 0 + (0, 1))
+            Family (1 + (0, 0), 0 + (1, 0), 0 + (0, 1))
         """
-        return tuple(self.algebra_generators())
+        return self.algebra_generators()
 
     @cached_method
     def zero(self):
@@ -1270,7 +1271,7 @@ def _test_multiplication_self_adjoint(self, **options):
                     tester.assertEqual(val.imag_part(), zerO)
 
     @cached_method
-    def basis(self):
+    def basis(self) -> Family:
         r"""
         Return a basis of ``self``.
 
@@ -1315,7 +1316,7 @@ def basis(self):
 
     algebra_generators = basis
 
-    def gens(self) -> tuple:
+    def gens(self) -> Family:
         """
         Return the generators of ``self``.
 
@@ -1337,7 +1338,7 @@ def gens(self) -> tuple:
             [ 0  0  k]
             [ 0 -k  0]
         """
-        return tuple(self.algebra_generators())
+        return self.basis()
 
     @cached_method
     def zero(self):

src/sage/combinat/free_dendriform_algebra.py

@@ -249,7 +249,7 @@ def gen(self, i):
         return G[G.keys().unrank(i)]
 
     @cached_method
-    def algebra_generators(self):
+    def algebra_generators(self) -> Family:
         r"""
         Return the generators of this algebra.
 
@@ -266,6 +266,12 @@ def algebra_generators(self):
             sage: A = algebras.FreeDendriform(QQ, ['x1','x2'])
             sage: list(A.algebra_generators())
             [B[x1[., .]], B[x2[., .]]]
+
+        TESTS::
+
+            sage: A = algebras.FreeDendriform(ZZ, 'fgh')
+            sage: A.gens()
+            Finite family {'f': B[f[., .]], 'g': B[g[., .]], 'h': B[h[., .]]}
         """
         Trees = self.basis().keys()
         return Family(self._alphabet, lambda a: self.monomial(Trees([], a)))
@@ -287,17 +293,7 @@ def change_ring(self, R):
         """
         return FreeDendriformAlgebra(R, names=self.variable_names())
 
-    def gens(self) -> tuple:
-        """
-        Return the generators of ``self`` (as an algebra).
-
-        EXAMPLES::
-
-            sage: A = algebras.FreeDendriform(ZZ, 'fgh')
-            sage: A.gens()
-            (B[f[., .]], B[g[., .]], B[h[., .]])
-        """
-        return tuple(self.algebra_generators())
+    gens = algebra_generators
 
     def degree_on_basis(self, t):
         """

src/sage/combinat/free_prelie_algebra.py

@@ -310,7 +310,7 @@ def gen(self, i):
         return G[G.keys().unrank(i)]
 
     @cached_method
-    def algebra_generators(self):
+    def algebra_generators(self) -> Family:
         r"""
         Return the generators of this algebra.
 
@@ -327,6 +327,12 @@ def algebra_generators(self):
             sage: A = algebras.FreePreLie(QQ, ['x1','x2'])
             sage: list(A.algebra_generators())
             [B[x1[]], B[x2[]]]
+
+        TESTS::
+
+            sage: A = algebras.FreePreLie(ZZ, 'fgh')
+            sage: A.gens()
+            Finite family {'f': B[f[]], 'g': B[g[]], 'h': B[h[]]}
         """
         Trees = self.basis().keys()
         return Family(self._alphabet, lambda a: self.monomial(Trees([], a)))
@@ -348,17 +354,7 @@ def change_ring(self, R):
         """
         return FreePreLieAlgebra(R, names=self.variable_names())
 
-    def gens(self) -> tuple:
-        """
-        Return the generators of ``self`` (as an algebra).
-
-        EXAMPLES::
-
-            sage: A = algebras.FreePreLie(ZZ, 'fgh')
-            sage: A.gens()
-            (B[f[]], B[g[]], B[h[]])
-        """
-        return tuple(self.algebra_generators())
+    gens = algebra_generators
 
     def degree_on_basis(self, t):
         """

src/sage/combinat/ncsf_qsym/ncsf.py

@@ -39,9 +39,10 @@
         coeff_sp, coeff_ell, m_to_s_stat, number_of_fCT, number_of_SSRCT, compositions_order)
 from sage.combinat.partition import Partition
 from sage.combinat.permutation import Permutations
+from sage.combinat.sf.sf import SymmetricFunctions
 from sage.matrix.constructor import matrix
 from sage.matrix.matrix_space import MatrixSpace
-from sage.combinat.sf.sf import SymmetricFunctions
+from sage.sets.family import Family
 
 
 class NonCommutativeSymmetricFunctions(UniqueRepresentation, Parent):
@@ -2031,7 +2032,7 @@ def super_categories(self):
         class ParentMethods:
 
             @cached_method
-            def algebra_generators(self):
+            def algebra_generators(self) -> Family:
                 """
                 Return the algebra generators of a given multiplicative basis of
                 non-commutative symmetric functions.
@@ -2047,9 +2048,9 @@ def algebra_generators(self):
                     sage: f[1], f[2], f[3]
                     (Psi[1], Psi[2], Psi[3])
                 """
-                from sage.sets.family import Family
                 from sage.sets.positive_integers import PositiveIntegers
-                return Family(PositiveIntegers(), lambda i: self.monomial(self._indices([i])))
+                return Family(PositiveIntegers(),
+                              lambda i: self.monomial(self._indices([i])))
 
             def product_on_basis(self, composition1, composition2):
                 """

src/sage/combinat/symmetric_group_algebra.py

@@ -22,7 +22,8 @@
     Permutations,
     from_permutation_group_element,
 )
-from sage.combinat.permutation_cython import left_action_same_n, right_action_same_n
+from sage.combinat.permutation_cython import (left_action_same_n,
+                                              right_action_same_n)
 from sage.combinat.skew_tableau import SkewTableau
 from sage.combinat.tableau import (
     StandardTableaux,
@@ -38,6 +39,7 @@
 from sage.modules.free_module_element import vector
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 from sage.rings.rational_field import QQ
+from sage.sets.family import Family
 
 lazy_import('sage.groups.perm_gps.permgroup_element',
             'PermutationGroupElement')
@@ -244,7 +246,7 @@ def SymmetricGroupAlgebra(R, W, category=None):
 
 class SymmetricGroupAlgebra_n(GroupAlgebra_class):
 
-    def __init__(self, R, W, category):
+    def __init__(self, R, W, category) -> None:
         """
         TESTS::
 
@@ -1355,10 +1357,9 @@ def ladder_idempotent(self, la):
         return Elad * eprod
 
     @cached_method
-    def algebra_generators(self):
+    def algebra_generators(self) -> Family:
         r"""
-        Return generators of this group algebra (as algebra) as a
-        list of permutations.
+        Return generators of this group algebra (as algebra).
 
         The generators used for the group algebra of `S_n` are the
         transposition `(2, 1)` and the `n`-cycle `(1, 2, \ldots, n)`,
@@ -1386,7 +1387,6 @@ def algebra_generators(self):
             sage: M = C.module_morphism(lambda x: S3.zero(), codomain=S3)
             sage: M.register_as_coercion()
         """
-        from sage.sets.family import Family
         if self.n <= 1:
             return Family([])
         a = list(range(1, self.n + 1))
@@ -3574,7 +3574,7 @@ def _element_constructor_(self, x):
 
 class HeckeAlgebraSymmetricGroup_t(HeckeAlgebraSymmetricGroup_generic):
 
-    def __init__(self, R, n, q=None):
+    def __init__(self, R, n, q=None) -> None:
         """
         TESTS::
 
@@ -3686,16 +3686,16 @@ def t(self, i):
                                list(range(i + 2, self.n + 1))))
         # The permutation here is simply the transposition (i, i+1).
 
-    def algebra_generators(self):
+    def algebra_generators(self) -> tuple:
         """
         Return the generators of the algebra.
 
         EXAMPLES::
 
             sage: HeckeAlgebraSymmetricGroupT(QQ,3).algebra_generators()
-            [T[2, 1, 3], T[1, 3, 2]]
+            (T[2, 1, 3], T[1, 3, 2])
         """
-        return [self.t(i) for i in range(1, self.n)]
+        return tuple(self.t(i) for i in range(1, self.n))
 
     def jucys_murphy(self, k):
         r"""

src/sage/groups/raag.py

@@ -22,22 +22,22 @@
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
+from sage.algebras.clifford_algebra_element import CohomologyRAAGElement
+from sage.categories.algebras_with_basis import AlgebrasWithBasis
+from sage.categories.fields import Fields
+from sage.categories.groups import Groups
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.combinat.root_system.coxeter_group import CoxeterGroup
+from sage.combinat.root_system.coxeter_matrix import CoxeterMatrix
+from sage.graphs.graph import Graph
+from sage.groups.artin import ArtinGroup, ArtinGroupElement
+from sage.groups.finitely_presented import (FinitelyPresentedGroup,
+                                            FinitelyPresentedGroupElement)
+from sage.groups.free_group import FreeGroup
 from sage.libs.gap.element import GapElement
-
 from sage.misc.cachefunc import cached_method
+from sage.sets.family import Family
 from sage.structure.richcmp import richcmp
-from sage.groups.finitely_presented import FinitelyPresentedGroup, FinitelyPresentedGroupElement
-from sage.groups.free_group import FreeGroup
-from sage.groups.artin import ArtinGroup, ArtinGroupElement
-from sage.graphs.graph import Graph
-from sage.combinat.root_system.coxeter_matrix import CoxeterMatrix
-from sage.combinat.root_system.coxeter_group import CoxeterGroup
-
-from sage.combinat.free_module import CombinatorialFreeModule
-from sage.categories.fields import Fields
-from sage.categories.groups import Groups
-from sage.categories.algebras_with_basis import AlgebrasWithBasis
-from sage.algebras.clifford_algebra_element import CohomologyRAAGElement
 from sage.typeset.ascii_art import ascii_art
 from sage.typeset.unicode_art import unicode_art
 
@@ -303,7 +303,7 @@ def _element_constructor_(self, x):
             1
         """
         if isinstance(x, RightAngledArtinGroup.Element):
-            raise ValueError("there is no coercion from {} into {}".format(x.parent(), self))
+            raise ValueError(f"there is no coercion from {x.parent()} into {self}")
         if x == 1:
             return self.one()
         verts = self._graph.vertices(sort=True)
@@ -782,10 +782,11 @@ def gen(self, i):
             sage: H.gen(1)
             e1
         """
-        return self._from_dict({(i,): self.base_ring().one()}, remove_zeros=False)
+        return self._from_dict({(i,): self.base_ring().one()},
+                               remove_zeros=False)
 
     @cached_method
-    def one_basis(self):
+    def one_basis(self) -> tuple:
         """
         Return the basis element indexing `1` of ``self``.
 
@@ -800,7 +801,7 @@ def one_basis(self):
         return ()
 
     @cached_method
-    def algebra_generators(self):
+    def algebra_generators(self) -> Family:
         """
         Return the algebra generators of ``self``.
 
@@ -811,25 +812,17 @@ def algebra_generators(self):
             sage: H = A.cohomology()
             sage: H.algebra_generators()
             Finite family {0: e0, 1: e1, 2: e2, 3: e3}
+
+        TESTS::
+
+            sage: H.gens()
+            Finite family {0: e0, 1: e1, 2: e2, 3: e3}
         """
         V = self._group._graph.vertices(True)
         d = {x: self.gen(i) for i, x in enumerate(V)}
-        from sage.sets.family import Family
         return Family(V, lambda x: d[x])
 
-    def gens(self) -> tuple:
-        r"""
-        Return the generators of ``self`` (as an algebra).
-
-        EXAMPLES::
-
-            sage: C4 = graphs.CycleGraph(4)
-            sage: A = groups.misc.RightAngledArtin(C4)
-            sage: H = A.cohomology()
-            sage: H.gens()
-            (e0, e1, e2, e3)
-        """
-        return tuple(self.algebra_generators())
+    gens = algebra_generators
 
     def ngens(self):
         """