gh-40077: using _an_element_ in algebras
    
instead of `an_element`

plus pep8 cleanup of the 3 modified files

### 📝 Checklist

- [ ] The title is concise and informative.
- [ ] The description explains in detail what this PR is about.
    
URL: #40077
Reported by: Frédéric Chapoton
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/algebras/askey_wilson.py

@@ -234,13 +234,13 @@ def __classcall_private__(cls, R, q=None):
             q = R(q)
         if q == 0:
             raise ValueError("q cannot be 0")
-        if 1/q not in R:
+        if 1 / q not in R:
             raise ValueError("q={} is not invertible in {}".format(q, R))
         if R not in Rings().Commutative():
             raise ValueError("{} is not a commutative ring".format(R))
         return super().__classcall__(cls, R, q)
 
-    def __init__(self, R, q):
+    def __init__(self, R, q) -> None:
         r"""
         Initialize ``self``.
 
@@ -258,7 +258,7 @@ def __init__(self, R, q):
                                          category=cat)
         self._assign_names('A,B,C,a,b,g')
 
-    def _repr_term(self, t):
+    def _repr_term(self, t) -> str:
         r"""
         Return a string representation of the basis element indexed by ``t``.
 
@@ -278,14 +278,14 @@ def exp(l, e):
             if e == 1:
                 return '*' + l
             return '*' + l + '^{}'.format(e)
-        ret = ''.join(exp(l, e) for l, e in zip(['A','B','C','a','b','g'], t))
+        ret = ''.join(exp(l, e) for l, e in zip('ABCabg', t))
         if not ret:
             return '1'
         if ret[0] == '*':
             ret = ret[1:]
         return ret
 
-    def _latex_term(self, t):
+    def _latex_term(self, t) -> str:
         r"""
         Return a latex representation of the basis element indexed by ``t``.
 
@@ -389,7 +389,7 @@ def q(self):
         return self._q
 
     @cached_method
-    def an_element(self):
+    def _an_element_(self):
         r"""
         Return an element of ``self``.
 
@@ -451,13 +451,13 @@ def casimir_element(self):
         """
         q = self._q
         I = self._indices
-        d = {I((1,1,1,0,0,0)): q,      # q ABC
-             I((2,0,0,0,0,0)): q**2,   # q^2 A^2
-             I((0,2,0,0,0,0)): q**-2,  # q^-2 B^2
-             I((0,0,2,0,0,0)): q**2,   # q^2 C^2
-             I((1,0,0,1,0,0)): -q,     # -q A\alpha
-             I((0,1,0,0,1,0)): -q**-1, # -q^-1 B\beta
-             I((0,0,1,0,0,1)): -q}     # -q C\gamma
+        d = {I((1, 1, 1, 0, 0, 0)): q,       # q ABC
+             I((2, 0, 0, 0, 0, 0)): q**2,    # q^2 A^2
+             I((0, 2, 0, 0, 0, 0)): q**-2,   # q^-2 B^2
+             I((0, 0, 2, 0, 0, 0)): q**2,    # q^2 C^2
+             I((1, 0, 0, 1, 0, 0)): -q,      # -q A\alpha
+             I((0, 1, 0, 0, 1, 0)): -q**-1,  # -q^-1 B\beta
+             I((0, 0, 1, 0, 0, 1)): -q}      # -q C\gamma
         return self.element_class(self, d)
 
     @cached_method
@@ -505,7 +505,7 @@ def product_on_basis(self, x, y):
         # Commute the central parts to the right
         lhs = list(x[:3])
         rhs = list(y)
-        for i in range(3,6):
+        for i in range(3, 6):
             rhs[i] += x[i]
 
         # No ABC variables on the RHS to move past
@@ -515,44 +515,44 @@ def product_on_basis(self, x, y):
         # We recurse using the PBW-type basis property:
         #   that YX = XY + lower order terms (see Theorem 4.1 in Terwilliger).
         q = self._q
-        if lhs[2] > 0: # lhs has a C
-            if rhs[0] > 0: # rhs has an A to commute with C
+        if lhs[2] > 0:  # lhs has a C
+            if rhs[0] > 0:  # rhs has an A to commute with C
                 lhs[2] -= 1
                 rhs[0] -= 1
-                rel = {I((1,0,1,0,0,0)): q**-2,         # q^2 AC
-                       I((0,1,0,0,0,0)): q**-3 - q**1,  # q^-1(q^-2-q^2) B
-                       I((0,0,0,0,1,0)): 1 - q**-2}     # -q^-1(q^-1-q) b
+                rel = {I((1, 0, 1, 0, 0, 0)): q**-2,         # q^2 AC
+                       I((0, 1, 0, 0, 0, 0)): q**-3 - q**1,  # q^-1(q^-2-q^2) B
+                       I((0, 0, 0, 0, 1, 0)): 1 - q**-2}     # -q^-1(q^-1-q) b
                 rel = self.element_class(self, rel)
                 return self.monomial(I(lhs+[0]*3)) * (rel * self.monomial(I(rhs)))
-            elif rhs[1] > 0: # rhs has a B to commute with C
+            elif rhs[1] > 0:  # rhs has a B to commute with C
                 lhs[2] -= 1
                 rhs[1] -= 1
-                rel = {I((0,1,1,0,0,0)): q**2,          # q^2 BC
-                       I((1,0,0,0,0,0)): q**3 - q**-1,  # q(q^2-q^-2) A
-                       I((0,0,0,1,0,0)): -q**2 + 1}     # -q(q-q^-1) a
+                rel = {I((0, 1, 1, 0, 0, 0)): q**2,           # q^2 BC
+                       I((1, 0, 0, 0, 0, 0)): q**3 - q**-1,  # q(q^2-q^-2) A
+                       I((0, 0, 0, 1, 0, 0)): -q**2 + 1}     # -q(q-q^-1) a
                 rel = self.element_class(self, rel)
                 return self.monomial(I(lhs+[0]*3)) * (rel * self.monomial(I(rhs)))
-            else: # nothing to commute as rhs has no A nor B
+            else:  # nothing to commute as rhs has no A nor B
                 rhs[2] += lhs[2]
                 rhs[1] = lhs[1]
                 rhs[0] = lhs[0]
                 return self.monomial(I(rhs))
 
-        elif lhs[1] > 0: # lhs has a B
-            if rhs[0] > 0: # rhs has an A to commute with B
+        elif lhs[1] > 0:  # lhs has a B
+            if rhs[0] > 0:  # rhs has an A to commute with B
                 lhs[1] -= 1
                 rhs[0] -= 1
-                rel = {I((1,1,0,0,0,0)): q**2,          # q^2 AB
-                       I((0,0,1,0,0,0)): q**3 - q**-1,  # q(q^2-q^-2) C
-                       I((0,0,0,0,0,1)): -q**2 + 1}     # -q(q-q^-1) g
+                rel = {I((1, 1, 0, 0, 0, 0)): q**2,          # q^2 AB
+                       I((0, 0, 1, 0, 0, 0)): q**3 - q**-1,  # q(q^2-q^-2) C
+                       I((0, 0, 0, 0, 0, 1)): -q**2 + 1}     # -q(q-q^-1) g
                 rel = self.element_class(self, rel)
                 return self.monomial(I(lhs+[0]*3)) * (rel * self.monomial(I(rhs)))
-            else: # nothing to commute as rhs has no A
+            else:  # nothing to commute as rhs has no A
                 rhs[1] += lhs[1]
                 rhs[0] = lhs[0]
                 return self.monomial(I(rhs))
 
-        elif lhs[0] > 0: # lhs has an A
+        elif lhs[0] > 0:  # lhs has an A
             rhs[0] += lhs[0]
             return self.monomial(I(rhs))
 
@@ -905,7 +905,7 @@ def _on_basis(self, c):
              + (3-3*q^2)*g^2 - q^2*C + q*g
         """
         return self.codomain().prod(self._on_generators[i]**exp
-                                    for i,exp in enumerate(c))
+                                    for i, exp in enumerate(c))
 
     def _composition_(self, right, homset):
         """

src/sage/algebras/rational_cherednik_algebra.py

@@ -117,7 +117,7 @@ def __classcall_private__(cls, ct, c=1, t=None, base_ring=None, prefix=('a', 's'
 
         return super().__classcall__(cls, ct, c, t, base_ring, tuple(prefix))
 
-    def __init__(self, ct, c, t, base_ring, prefix):
+    def __init__(self, ct, c, t, base_ring, prefix) -> None:
         r"""
         Initialize ``self``.
 
@@ -161,7 +161,7 @@ def _genkey(self, t):
         return (self.degree_on_basis(t), t[1].length(), t[1], str(t[0]), str(t[2]))
 
     @lazy_attribute
-    def _reflections(self):
+    def _reflections(self) -> dict:
         """
         A dictionary of reflections to a pair of the associated root
         and coroot.
@@ -205,7 +205,7 @@ def _repr_(self) -> str:
             ret += "c_L={} and c_S={}".format(*self._c)
         return ret + " and t={} over {}".format(self._t, self.base_ring())
 
-    def _repr_term(self, t):
+    def _repr_term(self, t) -> str:
         """
         Return a string representation of the term indexed by ``t``.
 
@@ -238,26 +238,26 @@ def algebra_generators(self):
             sage: list(R.algebra_generators())
             [a1, a2, s1, s2, ac1, ac2]
         """
-        keys = ['a'+str(i) for i in self._cartan_type.index_set()]
-        keys += ['s'+str(i) for i in self._cartan_type.index_set()]
-        keys += ['ac'+str(i) for i in self._cartan_type.index_set()]
+        keys = ['a' + str(i) for i in self._cartan_type.index_set()]
+        keys += ['s' + str(i) for i in self._cartan_type.index_set()]
+        keys += ['ac' + str(i) for i in self._cartan_type.index_set()]
 
         def gen_map(k):
             if k[0] == 's':
                 i = int(k[1:])
                 return self.monomial((self._hd.one(),
-                                       self._weyl.group_generators()[i],
-                                       self._h.one()))
+                                      self._weyl.group_generators()[i],
+                                      self._h.one()))
             if k[1] == 'c':
                 i = int(k[2:])
                 return self.monomial((self._hd.one(),
-                                       self._weyl.one(),
-                                       self._h.monoid_generators()[i]))
+                                      self._weyl.one(),
+                                      self._h.monoid_generators()[i]))
 
             i = int(k[1:])
             return self.monomial((self._hd.monoid_generators()[i],
-                                   self._weyl.one(),
-                                   self._h.one()))
+                                  self._weyl.one(),
+                                  self._h.one()))
         return Family(keys, gen_map)
 
     @cached_method
@@ -320,12 +320,12 @@ def product_on_basis(self, left, right):
         I = self._cartan_type.index_set()
         P = PolynomialRing(R, 'x', len(I))
         G = P.gens()
-        gens_dict = {a:G[i] for i,a in enumerate(I)}
+        gens_dict = {a: G[i] for i, a in enumerate(I)}
         Q = RootSystem(self._cartan_type).root_lattice()
         alpha = Q.simple_roots()
         alphacheck = Q.simple_coroots()
 
-        def commute_w_hd(w, al): # al is given as a dictionary
+        def commute_w_hd(w, al):  # al is given as a dictionary
             ret = P.one()
             for k in al:
                 x = sum(c * gens_dict[i] for i, c in alpha[k].weyl_action(w))
@@ -351,15 +351,15 @@ def commute_w_hd(w, al): # al is given as a dictionary
                 del dr[ir]
 
             # We now commute right roots past the left reflections: s Ra = Ra' s
-            cur = self._from_dict({(hd, s*right[1], right[2]): c * cc
-                                    for s,c in terms
-                                    for hd, cc in commute_w_hd(s, dr)})
+            cur = self._from_dict({(hd, s * right[1], right[2]): c * cc
+                                   for s, c in terms
+                                   for hd, cc in commute_w_hd(s, dr)})
             cur = self.monomial((left[0], left[1], self._h(dl))) * cur
 
             # Add back in the commuted h and hd elements
             rem = self.monomial((left[0], left[1], self._h(dl)))
-            rem = rem * self.monomial((self._hd({ir:1}), self._weyl.one(),
-                                        self._h({il:1})))
+            rem = rem * self.monomial((self._hd({ir: 1}), self._weyl.one(),
+                                       self._h({il: 1})))
             rem = rem * self.monomial((self._hd(dr), right[1], right[2]))
 
             return cur + rem
@@ -385,9 +385,9 @@ def commute_w_hd(w, al): # al is given as a dictionary
 
         # Otherwise dr is non-trivial and we have La Ls Ra Rs Rac,
         #   so we must commute Ls Ra = Ra' Ls
-        w = left[1]*right[1]
+        w = left[1] * right[1]
         return self._from_dict({(left[0] * hd, w, right[2]): c
-                                 for hd, c in commute_w_hd(left[1], dr)})
+                                for hd, c in commute_w_hd(left[1], dr)})
 
     @cached_method
     def _product_coroot_root(self, i, j):
@@ -435,7 +435,7 @@ def _product_coroot_root(self, i, j):
             # p[0] is the root, p[1] is the coroot, p[2] the value c_s
             pr, pc, c = self._reflections[s]
             terms.append((s, c * R(ac.scalar(pr) * pc.scalar(al)
-                                    / pc.scalar(pr))))
+                                   / pc.scalar(pr))))
         return tuple(terms)
 
     def degree_on_basis(self, m):
@@ -468,8 +468,8 @@ def trivial_idempotent(self):
             1/6*I + 1/6*s1 + 1/6*s2 + 1/6*s2*s1 + 1/6*s1*s2 + 1/6*s1*s2*s1
         """
         coeff = self.base_ring()(~self._weyl.cardinality())
-        hd_one = self._hd.one() # root - a
-        h_one = self._h.one() # coroot - ac
+        hd_one = self._hd.one()  # root - a
+        h_one = self._h.one()  # coroot - ac
         return self._from_dict({(hd_one, w, h_one): coeff for w in self._weyl},
                                remove_zeros=False)
 
@@ -489,12 +489,13 @@ def deformed_euler(self):
         G = self.algebra_generators()
         cm = ~CartanMatrix(self._cartan_type)
         n = len(I)
-        ac = [G['ac'+str(i)] for i in I]
-        la = [sum(cm[i,j]*G['a'+str(I[i])] for i in range(n)) for j in range(n)]
-        return self.sum(ac[i]*la[i] for i in range(n))
+        ac = [G['ac' + str(i)] for i in I]
+        la = [sum(cm[i, j] * G['a' + str(I[i])]
+                  for i in range(n)) for j in range(n)]
+        return self.sum(ac[i] * la[i] for i in range(n))
 
     @cached_method
-    def an_element(self):
+    def _an_element_(self):
         """
         Return an element of ``self``.
 
@@ -506,7 +507,7 @@ def an_element(self):
         """
         G = self.algebra_generators()
         i = str(self._cartan_type.index_set()[0])
-        return G['a'+i] + 2*G['s'+i] + 3*G['ac'+i]
+        return G['a' + i] + 2 * G['s' + i] + 3 * G['ac' + i]
 
     def some_elements(self):
         """

src/sage/algebras/steenrod/steenrod_algebra.py

@@ -2343,7 +2343,8 @@ def P(self, *nums):
         """
         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,7 +2360,8 @@ def P(self, *nums):
         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")
@@ -2477,7 +2479,7 @@ def Q(self, *nums):
                     return answer
                 raise ValueError("element not in this algebra")
 
-    def an_element(self):
+    def _an_element_(self):
         """
         An element of this Steenrod algebra.
 
@@ -2510,29 +2512,32 @@ def an_element(self):
                 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"""
@@ -2565,7 +2570,8 @@ def pst(self, s, t):
         """
         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:
@@ -2765,7 +2771,7 @@ def gen(self, i=0):
             # 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)