gh-40104: fix some typos and other details
    
just fixing a few typos and then other details (pep8) in the 3 modified
files

### 📝 Checklist

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

Author: Release Manager

src/sage/combinat/SJT.py

@@ -34,27 +34,28 @@ class SJT(CombinatorialElement):
     A representation of a list permuted using the Steinhaus-Johnson-Trotter
     algorithm.
 
-    Each element of the list has a direction (initialized at -1) that changes at
-    each permutation and that is used to determine which elements to transpose.
-    The directions have three possible values:
+    Each element of the list has a direction (initialized at -1) that
+    changes at each permutation and that is used to determine which
+    elements to transpose.  The directions have three possible values:
 
-    - ``-1``: element tranposes to the left
+    - ``-1``: element transposes to the left
 
     - ``1``: element transposes to the right
 
     - ``0``: element does not move
 
-    Thus in addition to the permutation itself, the direction of each element is
-    also stored.
+    Thus in addition to the permutation itself, the direction of each
+    element is also stored.
 
     Note that the permutations are not generated in lexicographic order.
 
     .. WARNING::
 
-        An ``SJT`` object should always be created with identity permutation for
-        the algorithm to behave properly. If the identity permutation is not
-        provided, it expects a coherent list of directions according to the
-        provided input. This list is not checked.
+        An ``SJT`` object should always be created with identity
+        permutation for the algorithm to behave properly. If the
+        identity permutation is not provided, it expects a coherent
+        list of directions according to the provided input. This list
+        is not checked.
 
     .. TODO::
 
@@ -101,9 +102,9 @@ def __init__(self, l, directions=None) -> None:
 
         - ``l`` -- list; a list of ordered ``int``.
 
-        - ``directions`` -- list (default: ``None``); a list of directions for
-          each element in the permuted list. Used when constructing permutations
-          from a pre-defined internal state.
+        - ``directions`` -- list (default: ``None``); a list of
+          directions for each element in the permuted list. Used when
+          constructing permutations from a pre-defined internal state.
 
         EXAMPLES::
 
@@ -124,8 +125,9 @@ def __init__(self, l, directions=None) -> None:
             sage: s = SJT([1, 3, 2, 4])
             Traceback (most recent call last):
             ...
-            ValueError: no internal state directions were given for non-identity
-            starting permutation for Steinhaus-Johnson-Trotter algorithm
+            ValueError: no internal state directions were given
+            for non-identity starting permutation
+            for Steinhaus-Johnson-Trotter algorithm
             sage: s = SJT([]); s
             []
             sage: s = s.next(); s
@@ -142,8 +144,8 @@ def __init__(self, l, directions=None) -> None:
         if directions is None:
             if not all(l[i] <= l[i+1] for i in range(self._n - 1)):
                 raise ValueError("no internal state directions were given for "
-                "non-identity starting permutation for "
-                "Steinhaus-Johnson-Trotter algorithm")
+                                 "non-identity starting permutation for "
+                                 "Steinhaus-Johnson-Trotter algorithm")
             self._directions = [-1] * self._n
 
             # The first element has null direction.
@@ -197,8 +199,9 @@ def next(self):
         if self._n == 0:
             return False
 
-        # Copying lists of permutation and directions to avoid changing internal
-        # state of the algorithm if ``next()`` is called without reassigning.
+        # Copying lists of permutation and directions to avoid
+        # changing internal state of the algorithm if ``next()`` is
+        # called without reassigning.
         perm = self._list[:]
         directions = self._directions[:]
 
@@ -210,7 +213,8 @@ def next(self):
         # If this element has null direction, find the largest whose is
         # non-null.
         if direction == 0:
-            xi = self.__idx_largest_element_non_zero_direction(perm, directions)
+            xi = self.__idx_largest_element_non_zero_direction(perm,
+                                                               directions)
             if xi is None:
                 # We have created every permutation. Detected when all elements
                 # have null direction.
@@ -228,14 +232,15 @@ def next(self):
         # If the transposition results in the largest element being on one edge
         # or if the following element in its direction is greater than it, then
         # then set its direction to 0
-        if new_pos == 0 or new_pos == self._n - 1 or \
-            perm[new_pos + direction] > selected_elt:
+        if (new_pos == 0 or new_pos == self._n - 1 or
+                perm[new_pos + direction] > selected_elt):
             directions[new_pos] = 0
 
-        # After each permutation, update each element's direction. If one
-        # element is greater than selected element, change its direction towards
-        # the selected element. This loops has no reason to be if selected
-        # element is n and this will be the case most of the time.
+        # After each permutation, update each element's direction. If
+        # one element is greater than selected element, change its
+        # direction towards the selected element. This loops has no
+        # reason to be if selected element is n and this will be the
+        # case most of the time.
         if selected_elt != self._n:
             for i in range(self._n):
                 if perm[i] > selected_elt:

src/sage/graphs/generators/distance_regular.pyx

@@ -853,7 +853,7 @@ def HermitianFormsGraph(const int n, const int r):
         sage: G.is_distance_regular(True)
         ([5, 4, None], [None, 1, 2])
         sage: G = graphs.HermitianFormsGraph(3, 3)      # not tested (2 min)
-        sage: G.order()                         # not tested (bacuase of the above)
+        sage: G.order()                         # not tested (because of the above)
         19683
 
     REFERENCES:

src/sage/modules/diamond_cutting.py

@@ -16,13 +16,13 @@
 # ****************************************************************************
 
 from sage.geometry.polyhedron.constructor import Polyhedron
-from sage.matrix.constructor import matrix, identity_matrix
+from sage.matrix.constructor import matrix
 from sage.modules.free_module_element import vector
 
 from math import sqrt, floor, ceil
 
 
-def plane_inequality(v):
+def plane_inequality(v) -> list:
     """
     Return the inequality for points on the same side as the origin
     with respect to the plane through ``v`` normal to ``v``.
@@ -124,7 +124,7 @@ def jacobi(M):
     return matrix(q)
 
 
-def diamond_cut(V, GM, C, verbose=False):
+def diamond_cut(V, GM, C, verbose=False) -> Polyhedron:
     r"""
     Perform diamond cutting on polyhedron ``V`` with basis matrix ``GM``
     and squared radius ``C``.
@@ -137,7 +137,8 @@ def diamond_cut(V, GM, C, verbose=False):
 
     - ``C`` -- square of the radius to use in cutting algorithm
 
-    - ``verbose`` -- boolean (default: ``False``); whether to print debug information
+    - ``verbose`` -- boolean (default: ``False``); whether to print
+      debug information
 
     OUTPUT: a :class:`Polyhedron` instance
 
@@ -199,7 +200,7 @@ def diamond_cut(V, GM, C, verbose=False):
     inequalities = []
     while True:
         if verbose:
-            print("Dimension: {}".format(i))
+            print(f"Dimension: {i}")
         if new_dimension:
             Z = sqrt(T[i] / q[i][i])
             if verbose:
@@ -212,7 +213,7 @@ def diamond_cut(V, GM, C, verbose=False):
 
         x[i] += 1
         if verbose:
-            print("x: {}".format(x))
+            print(f"x: {x}")
         if x[i] > L[i]:
             i += 1
         elif i > 0:
@@ -249,7 +250,7 @@ def diamond_cut(V, GM, C, verbose=False):
     return V
 
 
-def calculate_voronoi_cell(basis, radius=None, verbose=False):
+def calculate_voronoi_cell(basis, radius=None, verbose=False) -> Polyhedron:
     """
     Calculate the Voronoi cell of the lattice defined by basis.
 
@@ -289,7 +290,8 @@ def calculate_voronoi_cell(basis, radius=None, verbose=False):
         sage: L = IntegerLattice([v])
         sage: C = L.voronoi_cell()
         sage: C.Hrepresentation()
-        (An inequality (-2, -2, 2) x + 3 >= 0, An inequality (2, 2, -2) x + 3 >= 0)
+        (An inequality (-2, -2, 2) x + 3 >= 0,
+         An inequality (2, 2, -2) x + 3 >= 0)
         sage: C.Vrepresentation()
         (A line in the direction (0, 1, 1),
          A line in the direction (1, 0, 1),
@@ -299,7 +301,8 @@ def calculate_voronoi_cell(basis, radius=None, verbose=False):
     Verify that :issue:`37086` is fixed::
 
         sage: from sage.modules.free_module_integer import IntegerLattice
-        sage: l  = [7, 0, -1, -2, -1, -2, 7, -2, 0, 0, -2, 0, 7, -2, 0, -1, -2, -1, 7, 0 , -1, -1, 0, -2, 7]
+        sage: l  = [7, 0, -1, -2, -1, -2, 7, -2, 0, 0, -2,
+        ....:       0, 7, -2, 0, -1, -2, -1, 7, 0 , -1, -1, 0, -2, 7]
         sage: M = matrix(5, 5, l)
         sage: C = IntegerLattice(M).voronoi_cell()
         sage: C
@@ -313,15 +316,15 @@ def calculate_voronoi_cell(basis, radius=None, verbose=False):
         # Convert the basis matrix to use RDF numbers for efficiency when we
         # calculate the triangular matrix of the QR decomposition.
         from sage.rings.real_double import RDF
-        tranposed_RDF_matrix = (basis.transpose()).change_ring(RDF)
-        R = tranposed_RDF_matrix.QR()[1]
+        transposed_RDF_matrix = (basis.transpose()).change_ring(RDF)
+        R = transposed_RDF_matrix.QR()[1]
         # The length of the vector formed by the diagonal entries of R is an
         # upper bound for twice the covering radius, so it is an upper bound
         # on the length of the lattice vectors that need to be considered for
         # diamond cutting. However, the value of the `radius` keyword is
         # actually a squared length, so there is no square root in the
         # following formula.
-        radius = sum(R[i,i]**2 for i in range(dim[0]))
+        radius = sum(R[i, i]**2 for i in range(dim[0]))
         # We then divide by 4 as we will divide the basis by 2 later on.
         radius = ceil(radius / 4)
     artificial_length = None
@@ -336,13 +339,14 @@ def calculate_voronoi_cell(basis, radius=None, verbose=False):
         from sage.rings.real_double import RDF
         # Convert the basis matrix to use RDF numbers for efficiency when we
         # perform the QR decomposition.
-        tranposed_RDF_matrix = (additional_vectors.transpose()).change_ring(RDF)
-        R = tranposed_RDF_matrix.QR()[1]
+        transposed_RDF_matrix = additional_vectors.transpose().change_ring(RDF)
+        R = transposed_RDF_matrix.QR()[1]
         # Since R is triangular, its smallest diagonal entry provides a
         # lower bound on the length of the shortest nonzero vector in the
         # lattice spanned by the artificial points. We square it because
         # value of `radius` is a squared length.
-        shortest_vector_lower_bound = min(R[i,i]**2 for i in range(dim[1] - dim[0]))
+        shortest_vector_lower_bound = min(R[i, i]**2
+                                          for i in range(dim[1] - dim[0]))
         # We will multiply our artificial points by the following scalar in
         # order to make sure the squared length of the shortest
         # nonzero vector is greater than radius, even after the vectors