passagemath-modules 10.5.32__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/combinat/root_system/extended_affine_weyl_group.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
-# sage.doctest: needs sage.libs.gap
+# sage.doctest: needs sage.graphs sage.libs.gap
 r"""
-Extended Affine Weyl Groups
+Extended affine Weyl groups
 
 AUTHORS:
 
@@ -1322,7 +1322,7 @@ class ExtendedAffineWeylGroup_Class(UniqueRepresentation, Parent):
         class ElementMethods:
 
             @abstract_method
-            def has_descent(self, i, side='right', positive=False):
+            def has_descent(self, i, side='right', positive=False) -> bool:
                 r"""
                 Return whether ``self`` * `s_i` < ``self`` where `s_i` is the `i`-th simple
                 reflection in the realized group.
@@ -1919,7 +1919,7 @@ class ExtendedAffineWeylGroup_Class(UniqueRepresentation, Parent):
         The element class for the "PW0" realization.
         """
 
-        def has_descent(self, i, side='right', positive=False):
+        def has_descent(self, i, side='right', positive=False) -> bool:
             r"""
             Return whether ``self`` has `i` as a descent.
 
@@ -2129,7 +2129,7 @@ class ExtendedAffineWeylGroup_Class(UniqueRepresentation, Parent):
         The element class for the W0P realization.
         """
 
-        def has_descent(self, i, side='right', positive=False):
+        def has_descent(self, i, side='right', positive=False) -> bool:
             r"""
             Return whether ``self`` has `i` as a descent.
 
@@ -2308,7 +2308,7 @@ class ExtendedAffineWeylGroup_Class(UniqueRepresentation, Parent):
         Element class for the "WF" realization.
         """
 
-        def has_descent(self, i, side='right', positive=False):
+        def has_descent(self, i, side='right', positive=False) -> bool:
             r"""
             Return whether ``self`` has `i` as a descent.
 
@@ -2482,7 +2482,7 @@ class ExtendedAffineWeylGroup_Class(UniqueRepresentation, Parent):
         The element class for the "FW" realization.
         """
 
-        def has_descent(self, i, side='right', positive=False):
+        def has_descent(self, i, side='right', positive=False) -> bool:
             r"""
             Return whether ``self`` has descent at `i`.
 
@@ -2642,7 +2642,7 @@ class ExtendedAffineWeylGroup_Class(UniqueRepresentation, Parent):
         The element class for the "PvW0" realization.
         """
 
-        def has_descent(self, i, side='right', positive=False):
+        def has_descent(self, i, side='right', positive=False) -> bool:
             r"""
             Return whether ``self`` has `i` as a descent.
 
@@ -2837,7 +2837,7 @@ class ExtendedAffineWeylGroup_Class(UniqueRepresentation, Parent):
             assert la in w.parent().domain()
             return w.action(self.cartesian_projection(1).value + la)
 
-        def has_descent(self, i, side='right', positive=False):
+        def has_descent(self, i, side='right', positive=False) -> bool:
             r"""
             Return whether ``self`` has `i` as a descent.
 

sage/combinat/root_system/fundamental_group.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
 # sage.doctest: needs sage.graphs sage.groups
 r"""
-Fundamental Group of an Extended Affine Weyl Group
+Fundamental group of an extended affine Weyl group
 
 AUTHORS:
 
@@ -532,8 +532,7 @@ class FundamentalGroupOfExtendedAffineWeylGroup_Class(UniqueRepresentation,
         """
         return iter(self.group_generators())
 
-    @cached_method
-    def an_element(self):
+    def _an_element_(self):
         r"""
         Return an element of ``self``.
 
@@ -708,8 +707,7 @@ class FundamentalGroupGL(FundamentalGroupOfExtendedAffineWeylGroup_Class):
         """
         return LazyFamily(ZZ, lambda i: i)
 
-    @cached_method
-    def an_element(self):
+    def _an_element_(self):
         r"""
         An element of ``self``.
 

sage/combinat/root_system/hecke_algebra_representation.py

@@ -1,5 +1,5 @@
 # sage_setup: distribution = sagemath-modules
-# sage.doctest: needs sage.libs.gap sage.groups
+# sage.doctest: needs sage.graphs sage.libs.gap sage.groups
 r"""
 Hecke algebra representations
 """

sage/combinat/root_system/integrable_representations.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
 # sage.doctest: needs sage.graphs sage.modules
 """
-Integrable Representations of Affine Lie Algebras
+Integrable representations of affine Lie algebras
 """
 # ***************************************************************************
 #  Copyright (C) 2014, 2105 Daniel Bump <bump at match.stanford.edu>

sage/combinat/root_system/pieri_factors.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
-# sage.doctest: needs sage.libs.gap
+# sage.doctest: needs sage.graphs sage.libs.gap
 r"""
-Pieri Factors
+Pieri factors
 """
 # ****************************************************************************
 #  Copyright (C) 2009-2010 Steven Pon <spon at math.ucdavis.edu>
@@ -520,7 +520,7 @@ class PieriFactors_type_A_affine(PieriFactors_affine_type):
 
     @staticmethod
     def __classcall__(cls, W, min_length=0, max_length=infinity,
-                      min_support=frozenset([]), max_support=None):
+                      min_support=frozenset(), max_support=None):
         r"""
         TESTS::
 

sage/combinat/root_system/root_lattice_realization_algebras.py

@@ -65,7 +65,7 @@ class Algebras(AlgebrasCategory):
 
                 sage: A = RootSystem(["B",2]).weight_space().algebra(QQ)
                 sage: A.some_elements()
-                [B[2*Lambda[1] + 2*Lambda[2]], ... B[Lambda[1]], B[Lambda[2]]]
+                [B[2*Lambda[1] + 2*Lambda[2]], ...B[Lambda[1]], B[Lambda[2]]]
                 sage: A.some_elements()                                                 # needs sage.graphs
                 [B[2*Lambda[1] + 2*Lambda[2]],
                  B[2*Lambda[1] - 2*Lambda[2]],

sage/combinat/root_system/root_lattice_realizations.py

@@ -3645,7 +3645,7 @@ class RootLatticeRealizations(Category_over_base_ring):
         # Descents
         ##########################################################################
 
-        def has_descent(self, i, positive=False):
+        def has_descent(self, i, positive=False) -> bool:
             """
             Test if ``self`` has a descent at position `i`, that is, if ``self`` is
             on the strict negative side of the `i`-th simple reflection

sage/combinat/root_system/type_folded.py

@@ -293,9 +293,9 @@ class CartanTypeFolded(UniqueRepresentation, SageObject):
                 return root.leading_coefficient() / coroot.leading_coefficient()
             index_set = self._cartan_type.index_set()
             min_f = min(f(j) for j in index_set)
-            return Family(dict( (i, int(f(i) / min_f)) for i in index_set ))
+            return Family({i: int(f(i) / min_f) for i in index_set})
         elif self._cartan_type.is_affine():
             c = self._cartan_type.translation_factors()
             cmax = max(c)
-            return Family(dict( (i, int(cmax / c[i]))
-                                for i in self._cartan_type.index_set() ))
+            return Family({i: int(cmax / c[i])
+                           for i in self._cartan_type.index_set()})

sage/combinat/root_system/type_reducible.py

@@ -117,11 +117,12 @@ class CartanType(SageObject, CartanType_abstract):
         """
         self._types = types
         self.affine = False
-        indices = (None,) + tuple( (i, j)
-                                   for i in range(len(types))
-                                   for j in types[i].index_set() )
+        indices = (None,) + tuple((i, j)
+                                  for i in range(len(types))
+                                  for j in types[i].index_set())
         self._indices = indices
-        self._index_relabelling = dict((indices[i], i) for i in range(1, len(indices)))
+        self._index_relabelling = {indices[i]: i
+                                   for i in range(1, len(indices))}
 
         self._spaces = [t.root_system().ambient_space() for t in types]
         if all(l is not None for l in self._spaces):
@@ -131,9 +132,9 @@ class CartanType(SageObject, CartanType_abstract):
         self.tools = root_system.type_reducible
         # a direct product of finite Cartan types is again finite;
         # idem for simply laced and crystallographic.
-        super_classes = tuple( cls
-                               for cls in (CartanType_finite, CartanType_simply_laced, CartanType_crystallographic)
-                               if all(isinstance(t, cls) for t in types) )
+        super_classes = tuple(cls
+                              for cls in (CartanType_finite, CartanType_simply_laced, CartanType_crystallographic)
+                              if all(isinstance(t, cls) for t in types))
         self._add_abstract_superclass(super_classes)
 
     def _repr_(self, compact=True):  # We should make a consistent choice here

sage/combinat/root_system/type_super_A.py

@@ -376,7 +376,7 @@ class AmbientSpace(ambient_space.AmbientSpace):
             I = P.index_set()
             return P.sum((-c/dep[0]) * h[I[i]] for i,c in dep[1:].items())
 
-        def has_descent(self, i, positive=False):
+        def has_descent(self, i, positive=False) -> bool:
             """
             Test if ``self`` has a descent at position `i`, that is
             if ``self`` is on the strict negative side of the `i`-th
@@ -415,7 +415,7 @@ class AmbientSpace(ambient_space.AmbientSpace):
             else:
                 return s < 0
 
-        def is_dominant_weight(self):
+        def is_dominant_weight(self) -> bool:
             """
             Test whether ``self`` is a dominant element of the weight lattice.
 

sage/combinat/root_system/weight_lattice_realizations.py

@@ -480,7 +480,7 @@ class WeightLatticeRealizations(Category_over_base_ring):
                 sage: R.reduced_word_of_alcove_morphism(omega3.translation)
                 [0, 1, 0, 2, 1, 0]
 
-                sage: # needs sage.libs.gap
+                sage: # needs sage.graphs sage.libs.gap
                 sage: W = WeylGroup(['C',3,1])
                 sage: s = W.simple_reflections()
                 sage: w = s[0]*s[1]*s[2]*s[3]*s[2]
@@ -597,10 +597,10 @@ class WeightLatticeRealizations(Category_over_base_ring):
             # Now, we have d = f w^-1
             winv = ~w
             assert all(alpha[i].level().is_zero() for i in self.index_set())
-            rank_simple_roots = dict( (alpha[i],i) for i in self.index_set())
+            rank_simple_roots = {alpha[i]: i for i in self.index_set()}
             permutation = dict()
             for i in self.index_set():
-                root = f(winv.action(alpha[i])) # This is d(alpha_i)
+                root = f(winv.action(alpha[i]))  # This is d(alpha_i)
                 assert root in rank_simple_roots
                 permutation[i] = rank_simple_roots[root]
                 assert set(permutation.values()), set(self.index_set())
@@ -695,7 +695,8 @@ class WeightLatticeRealizations(Category_over_base_ring):
             # preserving the alcoves.
             if elements is None:
                 c = self.cartan_type().c()
-                elements = [ c[i] * Lambda[i] for i in self.cartan_type().classical().index_set() ]
+                elements = [c[i] * Lambda[i]
+                            for i in self.cartan_type().classical().index_set()]
 
             # When the null root is zero in this root lattice realization,
             # the roots correspond to the classical roots. We use that to
@@ -704,7 +705,7 @@ class WeightLatticeRealizations(Category_over_base_ring):
             # set to be of the form 0..n
             test_automorphism = self.null_root().is_zero() and set(self.index_set()) == set(i for i in range(len(self.index_set())))
             # dictionary assigning a simple root to its index
-            rank_simple_roots = dict( (alpha[i],i) for i in self.index_set() )
+            rank_simple_roots = {alpha[i]: i for i in self.index_set()}
 
             try:
                 W = self.weyl_group()
@@ -779,15 +780,15 @@ class WeightLatticeRealizations(Category_over_base_ring):
             EXAMPLES::
 
                 sage: L = RootSystem(['C',2,1]).weight_lattice()
-                sage: L.signs_of_alcovewalk([1,2,0,1,2,1,2,0,1,2])                      # needs sage.libs.gap
+                sage: L.signs_of_alcovewalk([1,2,0,1,2,1,2,0,1,2])                      # needs sage.graphs sage.libs.gap
                 [-1, -1, 1, -1, 1, 1, 1, 1, 1, 1]
 
                 sage: L = RootSystem(['A',2,1]).weight_lattice()
-                sage: L.signs_of_alcovewalk([0,1,2,1,2,0,1,2,0,1,2,0])                  # needs sage.libs.gap
+                sage: L.signs_of_alcovewalk([0,1,2,1,2,0,1,2,0,1,2,0])                  # needs sage.graphs sage.libs.gap
                 [1, 1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1]
 
                 sage: L = RootSystem(['B',2,1]).coweight_lattice()
-                sage: L.signs_of_alcovewalk([0,1,2,0,1,2])                              # needs sage.libs.gap
+                sage: L.signs_of_alcovewalk([0,1,2,0,1,2])                              # needs sage.graphs sage.libs.gap
                 [1, -1, 1, -1, 1, 1]
 
             .. WARNING::

sage/combinat/root_system/weyl_characters.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
 # sage.doctest: needs sage.graphs sage.groups sage.modules
 """
-Weyl Character Rings
+Weyl character rings
 """
 # ****************************************************************************
 #  Copyright (C) 2011 Daniel Bump <bump at match.stanford.edu>
@@ -91,7 +91,7 @@ class WeylCharacterRing(CombinatorialFreeModule):
     For more information, see the thematic tutorial *Lie Methods and
     Related Combinatorics in Sage*, available at:
 
-    https://doc.sagemath.org/html/en/thematic_tutorials/lie.html
+    https://passagemath.org/docs/latest/html/en/thematic_tutorials/lie.html
     """
     @staticmethod
     def __classcall__(cls, ct, base_ring=ZZ, prefix=None, style='lattice', k=None, conjugate=False, cyclotomic_order=None, fusion_labels=None, inject_variables=False):

sage/crypto/__init__.py

@@ -1,3 +1,4 @@
 # sage_setup: distribution = sagemath-modules
+# delvewheel: patch
 from sage.misc.lazy_import import lazy_import
 lazy_import('sage.crypto.lattice', 'gen_lattice')

sage/crypto/block_cipher/des.py

@@ -1042,7 +1042,7 @@ def convert_to_vector(I, L):
 
     - ``I`` -- integer or bit list-like
 
-    - ``L`` -- integer; the desired bit length of the ouput
+    - ``L`` -- integer; the desired bit length of the output
 
     OUTPUT: the ``L``-bit vector representation of ``I``
 

sage/crypto/block_cipher/miniaes.py

@@ -12,7 +12,7 @@ AUTHORS:
 - Minh Van Nguyen (2009-05): initial version
 """
 
-###########################################################################
+# #########################################################################
 # Copyright (c) 2009 Minh Van Nguyen <nguyenminh2@gmail.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -25,8 +25,8 @@ AUTHORS:
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
-# http://www.gnu.org/licenses/
-###########################################################################
+# https://www.gnu.org/licenses/
+# #########################################################################
 
 from sage.matrix.matrix_dense import Matrix_dense
 from sage.matrix.matrix_space import MatrixSpace

sage/crypto/block_cipher/present.py

@@ -554,7 +554,7 @@ class PRESENT(SageObject):
             :mod:`sage.crypto.sbox` uses big endian by default whereas most of
             Sage uses little endian. So to use the big endian PRESENT Sbox from
             :mod:`sage.crypto.sboxes` :func:`sbox_layer` has to do some endian
-            conversion (i.e. reverse input and ouput of the Sbox). Keep this in
+            conversion (i.e. reverse input and output of the Sbox). Keep this in
             mind if you change the Sbox or :func:`sbox_layer`.
         """
         sbox = self.sbox if not inverse else self.sbox.inverse()
@@ -704,7 +704,7 @@ class PRESENT_KS(SageObject):
         :mod:`sage.crypto.sbox` uses big endian by default whereas most of Sage
         uses little endian. So to use the big endian PRESENT Sbox from
         :mod:`sage.crypto.sboxes` :class:`PRESENT_KS` has to do some endian
-        conversion (i.e. reverse input and ouput of the Sbox). Keep this in
+        conversion (i.e. reverse input and output of the Sbox). Keep this in
         mind if you change the Sbox or :func:`__call__`.
 
     .. automethod:: __init__
@@ -886,7 +886,7 @@ def convert_to_vector(I, L):
 
     - ``I`` -- integer or bit list-like
 
-    - ``L`` -- integer; the desired bit length of the ouput
+    - ``L`` -- integer; the desired bit length of the output
 
     OUTPUT: the ``L``-bit vector representation of ``I``
 

sage/crypto/block_cipher/sdes.py

@@ -13,7 +13,7 @@ AUTHORS:
 - Minh Van Nguyen (2009-06): initial version
 """
 
-###########################################################################
+# #########################################################################
 # Copyright (c) 2009 Minh Van Nguyen <nguyenminh2@gmail.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -26,8 +26,8 @@ AUTHORS:
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
-# http://www.gnu.org/licenses/
-###########################################################################
+# https://www.gnu.org/licenses/
+# #########################################################################
 
 from sage.monoids.string_monoid import BinaryStrings
 from sage.structure.sage_object import SageObject

sage/crypto/boolean_function.pyx

@@ -101,7 +101,7 @@ cdef long yellow_code(unsigned long a) noexcept:
     cdef unsigned long s = (8*sizeof(unsigned long)) >> 1
     cdef unsigned long m = (~0UL) >> s
     cdef unsigned long r = a
-    while(s):
+    while s:
         sig_check()
         r ^= (r&m) << s
         s >>= 1
@@ -289,11 +289,11 @@ cdef class BooleanFunction(SageObject):
         if isinstance(x, str):
             L = ZZ(len(x))
             if L.is_power_of(2):
-                x = ZZ("0x"+x).digits(base=2,padto=4*L)
+                x = ZZ("0x" + x).digits(base=2, padto=4*L)
             else:
                 raise ValueError("the length of the truth table must be a power of 2")
         from types import GeneratorType
-        if isinstance(x, (list,tuple,GeneratorType)):
+        if isinstance(x, (list, tuple, GeneratorType)):
             # initialisation from a truth table
 
             # first, check the length
@@ -337,14 +337,15 @@ cdef class BooleanFunction(SageObject):
                     FiniteField_givaro = ()
                 if isinstance(K, FiniteField_givaro):  # the ordering is not the same in this case
                     for u in K:
-                        bitset_set_to(self._truth_table, ZZ(u._vector_().list(),2), (x(u)).trace())
+                        bitset_set_to(self._truth_table,
+                                      ZZ(u._vector_().list(), 2), (x(u)).trace())
                 else:
-                    for i,u in enumerate(K):
+                    for i, u in enumerate(K):
                         bitset_set_to(self._truth_table, i, (x(u)).trace())
         elif isinstance(x, BooleanFunction):
             self._nvariables = x.nvariables()
             bitset_init(self._truth_table, <mp_bitcnt_t> (1<<self._nvariables))
-            bitset_copy(self._truth_table,(<BooleanFunction>x)._truth_table)
+            bitset_copy(self._truth_table, (<BooleanFunction>x)._truth_table)
         else:
             raise TypeError("unable to init the Boolean function")
 
@@ -508,7 +509,7 @@ cdef class BooleanFunction(SageObject):
         bitset_copy(anf, self._truth_table)
         reed_muller(anf.bits, ZZ(anf.limbs).exact_log(2))
         from sage.rings.polynomial.pbori.pbori import BooleanPolynomialRing
-        R = BooleanPolynomialRing(self._nvariables,"x")
+        R = BooleanPolynomialRing(self._nvariables, "x")
         G = R.gens()
         P = R(0)
 
@@ -518,7 +519,7 @@ cdef class BooleanFunction(SageObject):
                 inf = i*sizeof(long)*8
                 sup = min((i+1)*sizeof(long)*8, (1<<self._nvariables))
                 for j in range(inf, sup):
-                    if bitset_in(anf,j):
+                    if bitset_in(anf, j):
                         m = R(1)
                         for k in range(self._nvariables):
                             if (j>>k)&1:
@@ -593,9 +594,9 @@ cdef class BooleanFunction(SageObject):
         if format == 'bin':
             return tuple(self)
         if format == 'int':
-            return tuple(map(int,self))
+            return tuple(map(int, self))
         if format == 'hex':
-            S = ZZ(self.truth_table(),2).str(16)
+            S = ZZ(self.truth_table(), 2).str(16)
             S = "0"*((1<<(self._nvariables-2)) - len(S)) + S
             return S
         raise ValueError("unknown output format")
@@ -714,7 +715,7 @@ cdef class BooleanFunction(SageObject):
             (0, -4, 0, 4, 0, 4, 0, 4)
         """
         cdef long *temp
-        cdef mp_bitcnt_t i,n
+        cdef mp_bitcnt_t i, n
 
         if self._walsh_hadamard_transform is None:
             n = self._truth_table.size
@@ -1011,7 +1012,7 @@ cdef class BooleanFunction(SageObject):
         """
         # NOTE: this is a toy implementation
         from sage.rings.polynomial.polynomial_ring_constructor import BooleanPolynomialRing_constructor
-        R = BooleanPolynomialRing_constructor(self._nvariables,'x')
+        R = BooleanPolynomialRing_constructor(self._nvariables, 'x')
         G = R.gens()
         r = [R(1)]
 
@@ -1023,7 +1024,8 @@ cdef class BooleanFunction(SageObject):
 
         from sage.matrix.constructor import Matrix
         from sage.arith.misc import binomial
-        M = Matrix(GF(2), sum(binomial(self._nvariables,i) for i in range(d+1)), len(s))
+        M = Matrix(GF(2), sum(binomial(self._nvariables, i)
+                              for i in range(d+1)), len(s))
 
         cdef long i
         for i in range(1, d+1):
@@ -1037,23 +1039,20 @@ cdef class BooleanFunction(SageObject):
         cdef long j
         cdef mp_bitcnt_t v
 
-        for i,m in enumerate(r):
+        for i, m in enumerate(r):
             t = BooleanFunction(m)
-            for j,v in enumerate(s):
+            for j, v in enumerate(s):
                 sig_check()
-                M[i,j] = bitset_in(t._truth_table,v)
+                M[i, j] = bitset_in(t._truth_table, v)
 
         kg = M.kernel().gens()
 
         if kg:
-            res = sum([kg[0][i]*ri for i,ri in enumerate(r)])
+            res = sum([kg[0][i]*ri for i, ri in enumerate(r)])
         else:
             res = None
 
-        if dim:
-            return res, len(kg)
-        else:
-            return res
+        return (res, len(kg)) if dim else res
 
     def algebraic_immunity(self, annihilator=False):
         """
@@ -1211,7 +1210,7 @@ cdef class BooleanFunction(SageObject):
         except TypeError:
             raise TypeError("cannot compute is_linear_structure() using parameter %s" % (val,))
 
-    def has_linear_structure(self):
+    def has_linear_structure(self) -> bool:
         r"""
         Return ``True`` if this function has a linear structure.
 
@@ -1484,5 +1483,5 @@ def random_boolean_function(n):
     T[0] = B._truth_table[0]
     for i in range(T.limbs):
         sig_check()
-        T.bits[i] = r.randrange(0,Integer(1)<<(sizeof(unsigned long)*8))
+        T.bits[i] = r.randrange(0, Integer(1)<<(sizeof(unsigned long)*8))
     return B

sage/crypto/key_exchange/diffie_hellman.py

@@ -18,22 +18,17 @@ AUTHORS:
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
-
-from sage.misc.superseded import experimental
+from typing import Union
 
 from sage.crypto.key_exchange.key_exchange_scheme import KeyExchangeScheme
-
-from sage.arith.misc import is_prime
 from sage.misc.prandom import randint
-from sage.rings.integer import Integer
+from sage.misc.superseded import experimental
 from sage.rings.finite_rings.finite_field_constructor import GF
-from sage.rings.finite_rings.finite_field_prime_modn import \
-    FiniteField_prime_modn
+from sage.rings.finite_rings.finite_field_prime_modn import FiniteField_prime_modn
 from sage.rings.finite_rings.integer_mod import IntegerMod_abstract
+from sage.rings.integer import Integer
 from sage.structure.proof.proof import WithProof
 
-from typing import Union
-
 
 class DiffieHellman(KeyExchangeScheme):
 

sage/crypto/mq/sr.py

@@ -463,7 +463,7 @@ class SR_generic(MPolynomialSystemGenerator):
         self._reverse_variables = bool(kwargs.get("reverse_variables", True))
 
         with AllowZeroInversionsContext(self):
-            sub_byte_lookup = dict([(v, self.sub_byte(v)) for v in self._base])
+            sub_byte_lookup = {v: self.sub_byte(v) for v in self._base}
         self._sub_byte_lookup = sub_byte_lookup
 
         if self._gf2:

sage/crypto/public_key/blum_goldwasser.py

@@ -18,7 +18,7 @@ AUTHORS:
   the description contained in [MvOV1996]_.
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (c) 2009, 2010 Mike Hogan
 #       Copyright (c) 2009, 2010 David Joyner <wdjoyner@gmail.com>
 #       Copyright (c) 2009, 2010 Minh Van Nguyen <nguyenminh2@gmail.com>
@@ -27,8 +27,8 @@ AUTHORS:
 # 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 operator import xor
 

sage/crypto/sbox.pyx

@@ -1647,7 +1647,7 @@ cdef class SBox(SageObject):
                     ret.append((j, i, c))
         return ret
 
-    def has_linear_structure(self):
+    def has_linear_structure(self) -> bool:
         """
         Return ``True`` if there exists a nonzero component function of this
         S-Box that has a linear structure.

sage/crypto/sboxes.py

@@ -400,6 +400,28 @@ def monomial_function(n, e):
     return SBox(X**e)
 
 
+def inversion(n):
+    r"""
+    Return the S-Box constructed from the inversion mapping over `\GF{2^n}`
+    extending `0 \mapsto 0`.
+
+    INPUT:
+
+    - ``n`` -- size of the S-Box
+
+    EXAMPLES::
+
+        sage: from sage.crypto.sboxes import inversion
+        sage: S4 = inversion(4)
+        sage: S4.differential_uniformity()
+        4
+        sage: S5 = inversion(5)
+        sage: S5.differential_uniformity()
+        2
+    """
+    return monomial_function(n, 2**n - 2)
+
+
 def chi(n):
     r"""
     Return the `\chi` function defined over `\GF{2^n}` used in the nonlinear