Merge PR sagemath#41038: Fix Jordan algebra algebra_generators

Author: cxzhong

src/sage/algebras/jordan_algebra.py

@@ -9,12 +9,12 @@
   Jordan algebra
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #  Copyright (C) 2014, 2023 Travis Scrimshaw <tscrim at ucdavis.edu>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #                  https://www.gnu.org/licenses/
-#*****************************************************************************
+# ***************************************************************************
 
 from sage.structure.parent import Parent
 from sage.structure.unique_representation import UniqueRepresentation
@@ -209,7 +209,7 @@ def __classcall_private__(self, arg0, arg1=None, names=None):
         if not arg1.is_symmetric():
             raise ValueError("the bilinear form is not symmetric")
 
-        arg1 = arg1.change_ring(arg0) # This makes a copy
+        arg1 = arg1.change_ring(arg0)  # This makes a copy
         arg1.set_immutable()
         return JordanAlgebraSymmetricBilinear(arg0, arg1, names=names)
 
@@ -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,19 +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")
 
-    def algebra_generators(self):
-        B = self._A.basis()
-        K = B.keys()
-        try:
-            len(K)
-        except NotImplementedError:
-            raise NotImplementedError("infinite set")
-        return Family(K, 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``.
 
@@ -345,22 +339,14 @@ 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)}
         """
-        G = self.algebra_generators()
-        # If G is infinite, len(G) will raise NotImplementedError('infinite set')
-        try:
-            len(G)
-        except NotImplementedError:
-            raise
-        return tuple(G)
+        return self.algebra_generators()
 
     @cached_method
     def zero(self):
@@ -754,7 +740,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``.
 
@@ -776,7 +762,7 @@ def basis(self):
 
     algebra_generators = basis
 
-    def gens(self) -> tuple:
+    def gens(self) -> Family:
         """
         Return the generators of ``self``.
 
@@ -785,9 +771,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):
@@ -987,7 +973,7 @@ def _mul_(self, other):
             P = self.parent()
             return self.__class__(P,
                                   self._s * other._s
-                                   + (self._v * P._form * other._v.column())[0],
+                                  + (self._v * P._form * other._v.column())[0],
                                   other._s * self._v + self._s * other._v)
 
         def _lmul_(self, other):
@@ -1036,8 +1022,8 @@ def monomial_coefficients(self, copy=True):
                 {0: 1, 1: 2, 2: -1}
             """
             d = {0: self._s}
-            for i,c in enumerate(self._v):
-                d[i+1] = c
+            for i, c in enumerate(self._v):
+                d[i + 1] = c
             return d
 
         def trace(self):
@@ -1271,8 +1257,8 @@ def _test_multiplication_self_adjoint(self, **options):
                  [SD[3].conjugate(), SD[1], SD[5]],
                  [SD[4].conjugate(), SD[5].conjugate(), SD[2]]]
             Y = [[OD[0], OD[3], OD[4]],
-                  [OD[3].conjugate(), OD[1], OD[5]],
-                  [OD[4].conjugate(), OD[5].conjugate(), OD[2]]]
+                 [OD[3].conjugate(), OD[1], OD[5]],
+                 [OD[4].conjugate(), OD[5].conjugate(), OD[2]]]
             for r, c in data_pairs:
                 if r != c:
                     val = sum(X[r][i] * Y[i][c] + Y[r][i] * X[i][c] for i in range(3)) * self._half
@@ -1283,7 +1269,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``.
 
@@ -1328,7 +1314,7 @@ def basis(self):
 
     algebra_generators = basis
 
-    def gens(self) -> tuple:
+    def gens(self) -> Family:
         """
         Return the generators of ``self``.
 
@@ -1350,7 +1336,7 @@ def gens(self) -> tuple:
             [ 0  0  k]
             [ 0 -k  0]
         """
-        return tuple(self.algebra_generators())
+        return self.basis()
 
     @cached_method
     def zero(self):
@@ -1697,8 +1683,8 @@ def _mul_(self, other):
                  [SD[3].conjugate(), SD[1], SD[5]],
                  [SD[4].conjugate(), SD[5].conjugate(), SD[2]]]
             Y = [[OD[0], OD[3], OD[4]],
-                  [OD[3].conjugate(), OD[1], OD[5]],
-                  [OD[4].conjugate(), OD[5].conjugate(), OD[2]]]
+                 [OD[3].conjugate(), OD[1], OD[5]],
+                 [OD[4].conjugate(), OD[5].conjugate(), OD[2]]]
             # we do a simplified multiplication for the diagonal entries since
             # we have, e.g., \alpha * \alpha' + (x (x')^* + x' x^* + y (y')^* + y' y^*) / 2
             ret = [X[0][0] * Y[0][0] + (X[0][1] * Y[1][0]).real_part() + (X[0][2] * Y[2][0]).real_part(),

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