gh-40757: various pep8 fixes in groups/
    
some fixes about pep8 E2** in groups

### 📝 Checklist

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

Author: Release Manager

src/sage/groups/abelian_gps/values.py

@@ -142,9 +142,9 @@ def AbelianGroupWithValues(values, n, gens_orders=None, names='f', check=False,
     if values_group is None:
         from sage.structure.sequence import Sequence
         values_group = Sequence(values).universe()
-    values = tuple( values_group(val) for val in values )
-    M = AbelianGroupWithValues_class(gens_orders, names, values, values_group)
-    return M
+    values = tuple(values_group(val) for val in values)
+    return AbelianGroupWithValues_class(gens_orders, names,
+                                        values, values_group)
 
 
 class AbelianGroupWithValuesEmbedding(Morphism):
@@ -264,7 +264,7 @@ def value(self):
         """
         if self._value is None:
             values = self.parent().gens_values()
-            self._value = prod( v**e for v,e in zip(values, self.exponents()) )
+            self._value = prod(v**e for v, e in zip(values, self.exponents()))
         return self._value
 
     def _div_(left, right):

src/sage/groups/conjugacy_classes.py

@@ -47,12 +47,12 @@
     sage: TestSuite(C).run()
 """
 
-#****************************************************************************
+# **************************************************************************
 #       Copyright (C) 2011 Javier López Peña <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#****************************************************************************
+#                  https://www.gnu.org/licenses/
+# **************************************************************************
 
 from sage.structure.parent import Parent
 from sage.misc.cachefunc import cached_method

src/sage/groups/cubic_braid.py

@@ -802,7 +802,7 @@ def __init__(self, names, cbg_type=None):
         self._centralizing_matrix = None   # for Assion groups: element in classical base group commuting with self
         self._centralizing_element = None   # image under nat. map of the former one in the proj. classical group
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation.
 
@@ -815,8 +815,8 @@ def _repr_(self):
         """
         if self._cbg_type == CubicBraidGroup.type.Coxeter:
             return "Cubic Braid group on %s strands" % (self.strands())
-        else:
-            return "Assion group on %s strands of type %s" % (self.strands() ,self._cbg_type.value)
+        return "Assion group on %s strands of type %s" % (self.strands(),
+                                                          self._cbg_type.value)
 
     def index_set(self):
         r"""

src/sage/groups/finitely_presented_named.py

@@ -71,7 +71,7 @@
 from sage.rings.integer_ring import ZZ
 
 
-def CyclicPresentation(n):
+def CyclicPresentation(n) -> FinitelyPresentedGroup:
     r"""
     Build cyclic group of order `n` as a finitely presented group.
 
@@ -195,15 +195,18 @@ def FinitelyGeneratedAbelianPresentation(int_list):
     invariants = FGP_Module(ZZ**(len(int_list)), col_sp).invariants()
     name_gen = _lexi_gen()
     F = FreeGroup([next(name_gen) for i in invariants])
-    ret_rls = [F([i+1])**invariants[i] for i in range(len(invariants)) if invariants[i] != 0]
+    ret_rls = [F([i + 1])**invariants[i] for i in range(len(invariants))
+               if invariants[i] != 0]
 
     # Build commutator relations
-    gen_pairs = [[F.gen(i),F.gen(j)] for i in range(F.ngens()-1) for j in range(i+1,F.ngens())]
-    ret_rls = ret_rls + [x[0]**(-1)*x[1]**(-1)*x[0]*x[1] for x in gen_pairs]
+    gen_pairs = [[F.gen(i), F.gen(j)] for i in range(F.ngens() - 1)
+                 for j in range(i + 1, F.ngens())]
+    ret_rls = ret_rls + [x[0]**(-1) * x[1]**(-1) * x[0] * x[1]
+                         for x in gen_pairs]
     return FinitelyPresentedGroup(F, tuple(ret_rls))
 
 
-def FinitelyGeneratedHeisenbergPresentation(n=1, p=0):
+def FinitelyGeneratedHeisenbergPresentation(n=1, p=0) -> FinitelyPresentedGroup:
     r"""
     Return a finite presentation of the Heisenberg group.
 
@@ -265,14 +268,14 @@ def FinitelyGeneratedHeisenbergPresentation(n=1, p=0):
         raise ValueError('n must be a positive integer')
 
     # generators' names are x1, .., xn, y1, .., yn, z
-    vx = ['x' + str(i) for i in range(1,n+1)]
-    vy = ['y' + str(i) for i in range(1,n+1)]
+    vx = ['x' + str(i) for i in range(1, n + 1)]
+    vy = ['y' + str(i) for i in range(1, n + 1)]
     str_generators = ', '.join(vx + vy + ['z'])
 
     F = FreeGroup(str_generators)
-    x = F.gens()[0:n] # list of generators x1, x2, ..., xn
-    y = F.gens()[n:2*n] # list of generators x1, x2, ..., xn
-    z = F.gen(n*2)
+    x = F.gens()[0:n]  # list of generators x1, x2, ..., xn
+    y = F.gens()[n:2 * n]  # list of generators x1, x2, ..., xn
+    z = F.gen(n * 2)
 
     def commutator(a, b):
         return a * b * a**-1 * b**-1
@@ -294,7 +297,7 @@ def commutator(a, b):
     return FinitelyPresentedGroup(F, tuple(rls))
 
 
-def DihedralPresentation(n):
+def DihedralPresentation(n) -> FinitelyPresentedGroup:
     r"""
     Build the Dihedral group of order `2n` as a finitely presented group.
 
@@ -322,15 +325,15 @@ def DihedralPresentation(n):
         ...
         ValueError: finitely presented group order must be positive
     """
-    n = Integer( n )
+    n = Integer(n)
     if n < 1:
         raise ValueError('finitely presented group order must be positive')
-    F = FreeGroup([ 'a', 'b' ])
-    rls = F([1])**n, F([2])**2, (F([1])*F([2]))**2
-    return FinitelyPresentedGroup( F, rls )
+    F = FreeGroup(['a', 'b'])
+    rls = F([1])**n, F([2])**2, (F([1]) * F([2]))**2
+    return FinitelyPresentedGroup(F, rls)
 
 
-def DiCyclicPresentation(n):
+def DiCyclicPresentation(n) -> FinitelyPresentedGroup:
     r"""
     Build the dicyclic group of order `4n`, for `n \geq 2`, as a finitely
     presented group.
@@ -376,12 +379,12 @@ def DiCyclicPresentation(n):
     if n < 2:
         raise ValueError('input integer must be greater than 1')
 
-    F = FreeGroup(['a','b'])
-    rls = F([1])**(2*n), F([2,2])*F([-1])**n, F([-2,1,2,1])
+    F = FreeGroup(['a', 'b'])
+    rls = F([1])**(2 * n), F([2, 2]) * F([-1])**n, F([-2, 1, 2, 1])
     return FinitelyPresentedGroup(F, rls)
 
 
-def SymmetricPresentation(n):
+def SymmetricPresentation(n) -> FinitelyPresentedGroup:
     r"""
     Build the Symmetric group of order `n!` as a finitely presented group.
 
@@ -432,7 +435,7 @@ def SymmetricPresentation(n):
     return FinitelyPresentedGroup(F, ret_rls)
 
 
-def QuaternionPresentation():
+def QuaternionPresentation() -> FinitelyPresentedGroup:
     r"""
     Build the Quaternion group of order 8 as a finitely presented group.
 
@@ -453,12 +456,12 @@ def QuaternionPresentation():
         sage: Q.is_isomorphic(groups.presentation.DiCyclic(2))
         True
     """
-    F = FreeGroup(['a','b'])
-    rls = F([1])**4, F([2,2,-1,-1]), F([1,2,1,-2])
+    F = FreeGroup(['a', 'b'])
+    rls = F([1])**4, F([2, 2, -1, -1]), F([1, 2, 1, -2])
     return FinitelyPresentedGroup(F, rls)
 
 
-def AlternatingPresentation(n):
+def AlternatingPresentation(n) -> FinitelyPresentedGroup:
     r"""
     Build the Alternating group of order `n!/2` as a finitely presented group.
 
@@ -509,7 +512,7 @@ def AlternatingPresentation(n):
     return FinitelyPresentedGroup(F, ret_rls)
 
 
-def KleinFourPresentation():
+def KleinFourPresentation() -> FinitelyPresentedGroup:
     r"""
     Build the Klein group of order `4` as a finitely presented group.
 
@@ -520,12 +523,12 @@ def KleinFourPresentation():
         sage: K = groups.presentation.KleinFour(); K
         Finitely presented group < a, b | a^2, b^2, a^-1*b^-1*a*b >
     """
-    F = FreeGroup(['a','b'])
-    rls = F([1])**2, F([2])**2, F([-1])*F([-2])*F([1])*F([2])
+    F = FreeGroup(['a', 'b'])
+    rls = F([1])**2, F([2])**2, F([-1]) * F([-2]) * F([1]) * F([2])
     return FinitelyPresentedGroup(F, rls)
 
 
-def BinaryDihedralPresentation(n):
+def BinaryDihedralPresentation(n) -> FinitelyPresentedGroup:
     r"""
     Build a binary dihedral group of order `4n` as a finitely presented group.
 
@@ -555,12 +558,12 @@ def BinaryDihedralPresentation(n):
         ....:     assert P.is_isomorphic(M)
     """
     F = FreeGroup('x,y,z')
-    x,y,z = F.gens()
-    rls = (x**-2 * y**2, x**-2 * z**n, x**-2 * x*y*z)
+    x, y, z = F.gens()
+    rls = (x**-2 * y**2, x**-2 * z**n, x**-2 * x * y * z)
     return FinitelyPresentedGroup(F, rls)
 
 
-def CactusPresentation(n):
+def CactusPresentation(n) -> FinitelyPresentedGroup:
     r"""
     Build the `n`-fruit cactus group as a finitely presented group.
 
@@ -579,11 +582,11 @@ def CactusPresentation(n):
     rls = [g**2 for g in gens]
     Gg = G.group_generators()
     K = Gg.keys()
-    for i,key in enumerate(K):
-        for j,key2 in enumerate(K):
+    for i, key in enumerate(K):
+        for j, key2 in enumerate(K):
             if i == j:
                 continue
-            x,y = (Gg[key] * Gg[key2])._data
+            x, y = (Gg[key] * Gg[key2])._data
             if key == x and key2 == y:
                 continue
             elt = gens[i] * gens[j] * ~gens[K.index(y)] * ~gens[K.index(x)]

src/sage/groups/indexed_free_group.py

@@ -280,7 +280,7 @@ def __invert__(self):
             return self.__class__(self.parent(),
                    tuple((x[0], -x[1]) for x in reversed(self._monomial)))
 
-        def to_word_list(self):
+        def to_word_list(self) -> list[tuple]:
             """
             Return ``self`` as a word represented as a list whose entries
             are the pairs ``(i, s)`` where ``i`` is the index and ``s`` is
@@ -294,9 +294,8 @@ def to_word_list(self):
                 sage: x.to_word_list()
                 [(0, 1), (1, 1), (1, 1), (4, 1), (0, -1)]
             """
-            sign = lambda x: 1 if x > 0 else -1 # It is never 0
-            return [ (k, sign(e)) for k,e in self._sorted_items()
-                     for dummy in range(abs(e))]
+            return [(k, 1 if e > 0 else -1) for k, e in self._sorted_items()
+                    for dummy in range(abs(e))]
 
 
 class IndexedFreeAbelianGroup(IndexedGroup, AbelianGroup):

src/sage/groups/libgap_morphism.py

@@ -515,7 +515,7 @@ def lift(self, h):
         phi = self.gap()
         if h.gap() not in phi.Image():
             raise ValueError("{} is not an element of the image of {}".format(h, self))
-        return self.domain()( phi.PreImagesRepresentative(h.gap()) )
+        return self.domain()(phi.PreImagesRepresentative(h.gap()))
 
     def preimage(self, S):
         r"""

src/sage/groups/matrix_gps/heisenberg.py

@@ -7,15 +7,15 @@
 - Hilder Vitor Lima Pereira (2017-08): initial version
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #    Copyright (C) 2017 Hilder Vitor Lima Pereira <hilder.vitor 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
 # 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.groups.matrix_gps.finitely_generated_gap import FinitelyGeneratedMatrixGroup_gap
 from sage.structure.unique_representation import UniqueRepresentation