passagemath-combinat 10.6.1__cp312-cp312-musllinux_1_2_aarch64.whl → 10.8.1a1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/algebras/jordan_algebra.py

@@ -10,12 +10,12 @@ AUTHORS:
   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
@@ -166,7 +166,12 @@ class JordanAlgebra(UniqueRepresentation, Parent):
 
             sage: cat = Algebras(QQ).WithBasis().FiniteDimensional()
             sage: C = CombinatorialFreeModule(QQ, ['x','y','z'], category=cat)
-            sage: J1 = JordanAlgebra(C, names=['a','b','c'])
+            sage: J1 = JordanAlgebra(C, names=['a','b','c']); J1
+            Jordan algebra of Free module generated by {'x', 'y', 'z'}
+            over Rational Field
+
+        In this case, the following syntactic sugar works::
+
             sage: J2.<a,b,c> = JordanAlgebra(C)
             sage: J1 is J2
             True
@@ -210,7 +215,7 @@ class JordanAlgebra(UniqueRepresentation, Parent):
         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)
 
@@ -241,7 +246,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
     r"""
     A (special) Jordan algebra `A^+` from an associative algebra `A`.
     """
-    def __init__(self, A, names=None):
+    def __init__(self, A, names=None) -> None:
         """
         Initialize ``self``.
 
@@ -251,7 +256,8 @@ class SpecialJordanAlgebra(JordanAlgebra):
             sage: J = JordanAlgebra(F)
             sage: TestSuite(J).run()
             sage: J.category()
-            Category of commutative unital algebras with basis over Rational Field
+            Category of commutative unital algebras with basis
+            over Rational Field
         """
         R = A.base_ring()
         C = MagmaticAlgebras(R)
@@ -269,7 +275,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
 
         Parent.__init__(self, base=R, names=names, category=cat)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -277,9 +283,10 @@ class SpecialJordanAlgebra(JordanAlgebra):
 
             sage: F.<x,y,z> = FreeAlgebra(QQ)
             sage: JordanAlgebra(F)
-            Jordan algebra of Free Algebra on 3 generators (x, y, z) over Rational Field
+            Jordan algebra of Free Algebra on 3 generators (x, y, z)
+            over Rational Field
         """
-        return "Jordan algebra of {}".format(self._A)
+        return f"Jordan algebra of {self._A}"
 
     def _element_constructor_(self, x):
         """
@@ -312,7 +319,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
         return self.element_class(self, self._A.an_element())
 
     @cached_method
-    def basis(self):
+    def basis(self) -> Family:
         """
         Return the basis of ``self``.
 
@@ -324,21 +331,25 @@ class SpecialJordanAlgebra(JordanAlgebra):
             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:
         """
-        Return the generators of ``self``.
+        Return the generators of ``self`` as a tuple.
+
+        This fails with :exc:`NotImplementedError`
+        when there are infinitely many.
 
         EXAMPLES::
 
             sage: cat = Algebras(QQ).WithBasis().FiniteDimensional()
             sage: C = CombinatorialFreeModule(QQ, ['x','y','z'], category=cat)
             sage: J = JordanAlgebra(C)
-            sage: J.gens()
+            sage: tuple(map(J, C.gens()))
             (B['x'], B['y'], B['z'])
 
             sage: F.<x,y,z> = FreeAlgebra(QQ)
@@ -348,7 +359,10 @@ class SpecialJordanAlgebra(JordanAlgebra):
             ...
             NotImplementedError: infinite set
         """
-        return tuple(self.algebra_generators())
+        F = self.algebra_generators()
+        if F.is_finite():
+            return tuple(F)
+        raise NotImplementedError('infinite set')
 
     @cached_method
     def zero(self):
@@ -382,7 +396,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
         """
         An element of a special Jordan algebra.
         """
-        def __init__(self, parent, x):
+        def __init__(self, parent, x) -> None:
             """
             Initialize ``self``.
 
@@ -396,7 +410,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
             self._x = x
             AlgebraElement.__init__(self, parent)
 
-        def _repr_(self):
+        def _repr_(self) -> str:
             """
             Return a string representation of ``self``.
 
@@ -410,7 +424,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
             """
             return repr(self._x)
 
-        def _latex_(self):
+        def _latex_(self) -> str:
             """
             Return a latex representation of ``self``.
 
@@ -439,7 +453,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
             """
             return bool(self._x)
 
-        def __eq__(self, other):
+        def __eq__(self, other) -> bool:
             """
             Check equality.
 
@@ -462,7 +476,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
                 return False
             return self._x == other._x
 
-        def __ne__(self, other):
+        def __ne__(self, other) -> bool:
             """
             Check inequality.
 
@@ -576,7 +590,7 @@ class SpecialJordanAlgebra(JordanAlgebra):
             """
             return self.__class__(self.parent(), other * self._x)
 
-        def monomial_coefficients(self, copy=True):
+        def monomial_coefficients(self, copy=True) -> dict:
             """
             Return a dictionary whose keys are indices of basis elements in
             the support of ``self`` and whose values are the corresponding
@@ -604,8 +618,15 @@ class SpecialJordanAlgebra(JordanAlgebra):
 class JordanAlgebraSymmetricBilinear(JordanAlgebra):
     r"""
     A Jordan algebra given by a symmetric bilinear form `m`.
+
+    TESTS::
+
+        sage: m = matrix([[0,1],[1,1]])
+        sage: J = JordanAlgebra(m)
+        sage: J.gens()
+        (1 + (0, 0), 0 + (1, 0), 0 + (0, 1))
     """
-    def __init__(self, R, form, names=None):
+    def __init__(self, R, form, names=None) -> None:
         """
         Initialize ``self``.
 
@@ -620,7 +641,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
         cat = MagmaticAlgebras(R).Commutative().Unital().FiniteDimensional().WithBasis()
         Parent.__init__(self, base=R, names=names, category=cat)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -708,7 +729,8 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
 
             return self.element_class(self, R(s), self._M.zero())
 
-        if len(args) == 2 and (isinstance(args[1], (list, tuple)) or args[1] in self._M):
+        if len(args) == 2 and (isinstance(args[1], (list, tuple))
+                               or args[1] in self._M):
             return self.element_class(self, R(args[0]), self._M(args[1]))
 
         if len(args) == self._form.ncols() + 1:
@@ -742,7 +764,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
         return self._generic_coerce_map(self.base_ring())
 
     @cached_method
-    def basis(self):
+    def basis(self) -> Family:
         """
         Return a basis of ``self``.
 
@@ -764,19 +786,6 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
 
     algebra_generators = basis
 
-    def gens(self) -> tuple:
-        """
-        Return the generators of ``self``.
-
-        EXAMPLES::
-
-            sage: m = matrix([[0,1],[1,1]])
-            sage: J = JordanAlgebra(m)
-            sage: J.gens()
-            (1 + (0, 0), 0 + (1, 0), 0 + (0, 1))
-        """
-        return tuple(self.algebra_generators())
-
     @cached_method
     def zero(self):
         """
@@ -809,7 +818,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
         """
         An element of a Jordan algebra defined by a symmetric bilinear form.
         """
-        def __init__(self, parent, s, v):
+        def __init__(self, parent, s, v) -> None:
             """
             Initialize ``self``.
 
@@ -823,7 +832,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
             self._v = v
             AlgebraElement.__init__(self, parent)
 
-        def _repr_(self):
+        def _repr_(self) -> str:
             """
             Return a string representation of ``self``.
 
@@ -836,7 +845,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
             """
             return "{} + {}".format(self._s, self._v)
 
-        def _latex_(self):
+        def _latex_(self) -> str:
             r"""
             Return a latex representation of ``self``.
 
@@ -867,7 +876,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
             """
             return bool(self._s) or bool(self._v)
 
-        def __eq__(self, other):
+        def __eq__(self, other) -> bool:
             """
             Check equality.
 
@@ -892,7 +901,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
                 return False
             return self._s == other._s and self._v == other._v
 
-        def __ne__(self, other):
+        def __ne__(self, other) -> bool:
             """
             Check inequality.
 
@@ -975,7 +984,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
             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):
@@ -1005,7 +1014,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
             """
             return self.__class__(self.parent(), other * self._s, other * self._v)
 
-        def monomial_coefficients(self, copy=True):
+        def monomial_coefficients(self, copy=True) -> dict:
             """
             Return a dictionary whose keys are indices of basis elements in
             the support of ``self`` and whose values are the corresponding
@@ -1024,7 +1033,7 @@ class JordanAlgebraSymmetricBilinear(JordanAlgebra):
                 {0: 1, 1: 2, 2: -1}
             """
             d = {0: self._s}
-            for i,c in enumerate(self._v):
+            for i, c in enumerate(self._v):
                 d[i+1] = c
             return d
 
@@ -1151,7 +1160,7 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
     - :wikipedia:`Hurwitz's_theorem_(composition_algebras)#Applications_to_Jordan_algebras`
     - `<https://math.ucr.edu/home/baez/octonions/octonions.pdf>`_
     """
-    def __init__(self, O):
+    def __init__(self, Octo) -> None:
         r"""
         Initialize ``self``.
 
@@ -1175,23 +1184,41 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
             Traceback (most recent call last):
             ...
             ValueError: 2 must be invertible
+
+        TESTS::
+
+            sage: O = OctonionAlgebra(QQ)
+            sage: J = JordanAlgebra(O)
+            sage: G = J.gens()
+            sage: G[0]
+            [1 0 0]
+            [0 0 0]
+            [0 0 0]
+            sage: G[5]
+            [ 0  j  0]
+            [-j  0  0]
+            [ 0  0  0]
+            sage: G[22]
+            [ 0  0  0]
+            [ 0  0  k]
+            [ 0 -k  0]
         """
-        self._O = O
-        R = O.base_ring()
+        self._O = Octo
+        R = Octo.base_ring()
 
         if not R(2).is_unit():
             raise ValueError("2 must be invertible")
         self._half = R(2).inverse_of_unit()
 
         from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
-        Onames = list(O.variable_names())
+        Onames = list(Octo.variable_names())
         Onames.extend(Onames[3] + Onames[i] for i in range(3))
         self._repr_poly_ring = PolynomialRing(R, Onames)
 
         cat = MagmaticAlgebras(R).Unital().FiniteDimensional().WithBasis()
         Parent.__init__(self, base=R, category=cat)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -1259,8 +1286,8 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
                  [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
@@ -1271,7 +1298,7 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
                     tester.assertEqual(val.imag_part(), zerO)
 
     @cached_method
-    def basis(self):
+    def basis(self) -> Family:
         r"""
         Return a basis of ``self``.
 
@@ -1316,30 +1343,6 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
 
     algebra_generators = basis
 
-    def gens(self) -> tuple:
-        """
-        Return the generators of ``self``.
-
-        EXAMPLES::
-
-            sage: O = OctonionAlgebra(QQ)
-            sage: J = JordanAlgebra(O)
-            sage: G = J.gens()
-            sage: G[0]
-            [1 0 0]
-            [0 0 0]
-            [0 0 0]
-            sage: G[5]
-            [ 0  j  0]
-            [-j  0  0]
-            [ 0  0  0]
-            sage: G[22]
-            [ 0  0  0]
-            [ 0  0  k]
-            [ 0 -k  0]
-        """
-        return tuple(self.algebra_generators())
-
     @cached_method
     def zero(self):
         r"""
@@ -1378,7 +1381,7 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
         zero = self._O.zero()
         return self.element_class(self, (one, one, one, zero, zero, zero))
 
-    def some_elements(self):
+    def some_elements(self) -> list:
         r"""
         Return some elements of ``self``.
 
@@ -1457,14 +1460,15 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
              B[1], B[5], B[17], B[1] + self._half*B[25],
              self.one() + B[13] + 2*B[16]]
         S.append(sum(B[::5]))
-        S.append(sum(self._half * ind * b for ind, b in enumerate(B[::7], start=2)))
+        S.append(sum(self._half * ind * b
+                     for ind, b in enumerate(B[::7], start=2)))
         return S
 
     class Element(AlgebraElement):
         r"""
         An element of an exceptional Jordan algebra.
         """
-        def __init__(self, parent, data):
+        def __init__(self, parent, data) -> None:
             """
             Initialize ``self``.
 
@@ -1495,16 +1499,20 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
             PR = self.parent()._repr_poly_ring
             gens = [PR.one()] + list(PR.gens())
             data = [PR(self._data[i]) for i in range(3)]
-            data.extend(PR.sum(c * g for c, g in zip(self._data[3+i].vector(), gens))
+            data.extend(PR.sum(c * g
+                               for c, g in zip(self._data[3+i].vector(), gens))
                         for i in range(3))
             # add the conjugates
             for i in range(1, 8):
                 gens[i] = -gens[i]
-            data.extend(PR.sum(c * g for c, g in zip(self._data[3+i].vector(), gens))
+            data.extend(PR.sum(c * g
+                               for c, g in zip(self._data[3+i].vector(), gens))
                         for i in range(3))
-            return matrix(PR, [[data[0], data[3], data[4]], [data[6], data[1], data[5]], [data[7], data[8], data[2]]])
+            return matrix(PR, [[data[0], data[3], data[4]],
+                               [data[6], data[1], data[5]],
+                               [data[7], data[8], data[2]]])
 
-        def _repr_(self):
+        def _repr_(self) -> str:
             r"""
             Return a string representation of ``self``.
 
@@ -1519,7 +1527,7 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
             """
             return repr(self._to_print_matrix())
 
-        def _latex_(self):
+        def _latex_(self) -> str:
             r"""
             Return a latex representation of ``self``.
 
@@ -1584,7 +1592,7 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
             """
             return any(d for d in self._data)
 
-        def _richcmp_(self, other, op):
+        def _richcmp_(self, other, op) -> bool:
             r"""
             Rich comparison of ``self`` with ``other`` by ``op``.
 
@@ -1685,8 +1693,8 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
                  [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(),
@@ -1735,7 +1743,7 @@ class ExceptionalJordanAlgebra(JordanAlgebra):
             """
             return self.__class__(self.parent(), [other * c for c in self._data])
 
-        def monomial_coefficients(self, copy=True):
+        def monomial_coefficients(self, copy=True) -> dict:
             r"""
             Return a dictionary whose keys are indices of basis elements in
             the support of ``self`` and whose values are the corresponding

sage/algebras/lie_conformal_algebras/abelian_lie_conformal_algebra.py

@@ -12,15 +12,15 @@ AUTHORS:
 - Reimundo Heluani (2020-06-15): Initial implementation.
 """
 
-#******************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2019 Reimundo Heluani <heluani@potuz.net>
 #
 # 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
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from .graded_lie_conformal_algebra import GradedLieConformalAlgebra
 from sage.structure.indexed_generators import standardize_names_index_set
@@ -77,7 +77,7 @@ class AbelianLieConformalAlgebra(GradedLieConformalAlgebra):
         case.
     """
     def __init__(self, R, ngens=1, weights=None,
-                 parity=None, names=None, index_set=None):
+                 parity=None, names=None, index_set=None) -> None:
         """
         Initialize ``self``.
 
@@ -86,7 +86,7 @@ class AbelianLieConformalAlgebra(GradedLieConformalAlgebra):
             sage: V = lie_conformal_algebras.Abelian(QQ)
             sage: TestSuite(V).run()
         """
-        if (names is None) and (index_set is None):
+        if names is None and index_set is None:
             names = 'a'
             self._latex_names = tuple(r'a_{%d}' % i for i in range(ngens))
 
@@ -110,4 +110,4 @@ class AbelianLieConformalAlgebra(GradedLieConformalAlgebra):
             The Abelian Lie conformal algebra with generators (a,) over Rational Field
         """
         return "The Abelian Lie conformal algebra with generators {} over {}"\
-                .format(self.gens(), self.base_ring())
+            .format(self.gens(), self.base_ring())

sage/algebras/lie_conformal_algebras/affine_lie_conformal_algebra.py

@@ -22,15 +22,15 @@ AUTHORS:
 - Reimundo Heluani (2019-08-09): Initial implementation.
 """
 
-#******************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2019 Reimundo Heluani <heluani@potuz.net>
 #
 # 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
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.rings.integer import Integer
 from sage.algebras.lie_algebras.lie_algebra import LieAlgebra
@@ -82,7 +82,7 @@ class AffineLieConformalAlgebra(GradedLieConformalAlgebra):
     The Affine Lie conformal algebra associated with the finite
     dimensional simple Lie algebra of Cartan type ``ct``.
     """
-    def __init__(self, R, ct, names=None, prefix=None, bracket=None):
+    def __init__(self, R, ct, names=None, prefix=None, bracket=None) -> None:
         """
         Initialize ``self``.
 
@@ -91,7 +91,7 @@ class AffineLieConformalAlgebra(GradedLieConformalAlgebra):
             sage: V = lie_conformal_algebras.Affine(QQ,'A1')
             sage: TestSuite(V).run()
         """
-        if type(ct) is str:
+        if isinstance(ct, str):
             from sage.combinat.root_system.cartan_type import CartanType
             try:
                 ct = CartanType(ct)
@@ -99,7 +99,7 @@ class AffineLieConformalAlgebra(GradedLieConformalAlgebra):
                 raise ValueError("ct must be a valid Cartan Type")
         if not (ct.is_finite() and ct.is_irreducible):
             raise ValueError("only affine algebras of simple finite dimensional"
-                "Lie algebras are implemented")
+                             "Lie algebras are implemented")
         hv = Integer(ct.dual_coxeter_number())
         g = LieAlgebra(R, cartan_type=ct)
         B = g.basis()
@@ -109,8 +109,8 @@ class AffineLieConformalAlgebra(GradedLieConformalAlgebra):
             for k2 in S:
                 if S.rank(k2) <= S.rank(k1):
                     myb = B[k1].bracket(B[k2]).monomial_coefficients()
-                    myf = R(2).inverse_of_unit()*R(hv).inverse_of_unit()\
-                          * g.killing_form(B[k1], B[k2])
+                    myf = R(2).inverse_of_unit() * R(hv).inverse_of_unit()\
+                        * g.killing_form(B[k1], B[k2])
                     if myb or myf:
                         gdict[(k1, k2)] = {}
                         if myb:
@@ -125,9 +125,11 @@ class AffineLieConformalAlgebra(GradedLieConformalAlgebra):
             prefix = 'B'
 
         GradedLieConformalAlgebra.__init__(self,
-            R, gdict, index_set=S,
-            central_elements=('K',), weights=weights,
-            names=names, prefix=prefix, bracket=bracket)
+                                           R, gdict, index_set=S,
+                                           central_elements=('K',),
+                                           weights=weights,
+                                           names=names, prefix=prefix,
+                                           bracket=bracket)
 
     def cartan_type(self):
         """
@@ -153,4 +155,4 @@ class AffineLieConformalAlgebra(GradedLieConformalAlgebra):
             The affine Lie conformal algebra of type ['A', 1] over Rational Field
         """
         return "The affine Lie conformal algebra of type {} over {}".format(
-                                                    self._ct, self.base_ring())
+            self._ct, self.base_ring())

sage/algebras/lie_conformal_algebras/bosonic_ghosts_lie_conformal_algebra.py

@@ -20,15 +20,15 @@ AUTHORS:
 - Reimundo Heluani (2020-06-15): Initial implementation.
 """
 
-#******************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2019 Reimundo Heluani <heluani@potuz.net>
 #
 # 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
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.matrix.special import identity_matrix
 from sage.structure.indexed_generators import standardize_names_index_set
@@ -80,7 +80,7 @@ class BosonicGhostsLieConformalAlgebra(GradedLieConformalAlgebra):
         Category of H-graded finitely generated Lie conformal algebras with basis over Algebraic Real Field
     """
 
-    def __init__(self, R, ngens=2, names=None, index_set=None):
+    def __init__(self, R, ngens=2, names=None, index_set=None) -> None:
         """
         Initialize ``self``.
 
@@ -105,8 +105,8 @@ class BosonicGhostsLieConformalAlgebra(GradedLieConformalAlgebra):
                                 laxnames(half, r'\gamma')) + ('K',)
 
         names, index_set = standardize_names_index_set(names=names,
-                                                      index_set=index_set,
-                                                      ngens=ngens)
+                                                       index_set=index_set,
+                                                       ngens=ngens)
         A = identity_matrix(R, half)
         from sage.matrix.special import block_matrix
         gram_matrix = block_matrix([[R.zero(), A], [-A, R.zero()]])