passagemath-gap 10.5.43__tar.gz → 10.6.1rc2__tar.gz

{passagemath_gap-10.5.43/passagemath_gap.egg-info → passagemath_gap-10.6.1rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: passagemath-gap
-Version: 10.5.43
+Version: 10.6.1rc2
 Summary: passagemath: Computational Group Theory with GAP
 Author-email: The Sage Developers <sage-support@googlegroups.com>
 Maintainer: Matthias Köppe, passagemath contributors
@@ -19,20 +19,19 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: <3.14,>=3.9
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/x-rst
 Requires-Dist: cysignals!=1.12.0,>=1.11.2
 Requires-Dist: memory_allocator
-Requires-Dist: passagemath-conf~=10.5.43.0
-Requires-Dist: passagemath-environment~=10.5.43.0
-Requires-Dist: passagemath-categories~=10.5.43.0
+Requires-Dist: passagemath-conf==10.6.1rc2
+Requires-Dist: passagemath-environment==10.6.1rc2
+Requires-Dist: passagemath-categories==10.6.1rc2
 Provides-Extra: test
 Requires-Dist: passagemath-repl; extra == "test"
 
@@ -77,7 +76,7 @@ passagemath attempts to support all major Linux distributions and recent version
 macOS. Use on Windows currently requires the use of Windows Subsystem for Linux or
 virtualization.
 
-Complete sets of binary wheels are provided on PyPI for Python versions 3.9.x-3.12.x.
+Complete sets of binary wheels are provided on PyPI for Python versions 3.10.x-3.13.x.
 Python 3.13.x is also supported, but some third-party packages are still missing wheels,
 so compilation from source is triggered for those.
 

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/README.rst

@@ -39,7 +39,7 @@ passagemath attempts to support all major Linux distributions and recent version
 macOS. Use on Windows currently requires the use of Windows Subsystem for Linux or
 virtualization.
 
-Complete sets of binary wheels are provided on PyPI for Python versions 3.9.x-3.12.x.
+Complete sets of binary wheels are provided on PyPI for Python versions 3.10.x-3.13.x.
 Python 3.13.x is also supported, but some third-party packages are still missing wheels,
 so compilation from source is triggered for those.
 

passagemath_gap-10.6.1rc2/VERSION.txt

@@ -0,0 +1 @@
+10.6.1.rc2

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2/passagemath_gap.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: passagemath-gap
-Version: 10.5.43
+Version: 10.6.1rc2
 Summary: passagemath: Computational Group Theory with GAP
 Author-email: The Sage Developers <sage-support@googlegroups.com>
 Maintainer: Matthias Köppe, passagemath contributors
@@ -19,20 +19,19 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: <3.14,>=3.9
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/x-rst
 Requires-Dist: cysignals!=1.12.0,>=1.11.2
 Requires-Dist: memory_allocator
-Requires-Dist: passagemath-conf~=10.5.43.0
-Requires-Dist: passagemath-environment~=10.5.43.0
-Requires-Dist: passagemath-categories~=10.5.43.0
+Requires-Dist: passagemath-conf==10.6.1rc2
+Requires-Dist: passagemath-environment==10.6.1rc2
+Requires-Dist: passagemath-categories==10.6.1rc2
 Provides-Extra: test
 Requires-Dist: passagemath-repl; extra == "test"
 
@@ -77,7 +76,7 @@ passagemath attempts to support all major Linux distributions and recent version
 macOS. Use on Windows currently requires the use of Windows Subsystem for Linux or
 virtualization.
 
-Complete sets of binary wheels are provided on PyPI for Python versions 3.9.x-3.12.x.
+Complete sets of binary wheels are provided on PyPI for Python versions 3.10.x-3.13.x.
 Python 3.13.x is also supported, but some third-party packages are still missing wheels,
 so compilation from source is triggered for those.
 

passagemath_gap-10.6.1rc2/passagemath_gap.egg-info/requires.txt

@@ -0,0 +1,8 @@
+cysignals!=1.12.0,>=1.11.2
+memory_allocator
+passagemath-conf==10.6.1rc2
+passagemath-environment==10.6.1rc2
+passagemath-categories==10.6.1rc2
+
+[test]
+passagemath-repl

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/pyproject.toml

@@ -3,10 +3,10 @@
 # Minimum requirements for the build system to execute.
 requires = [
     'setuptools >= 77.0.0',
-    'passagemath-setup ~= 10.5.43.0',
-    'passagemath-environment ~= 10.5.43.0',
-    'passagemath-categories ~= 10.5.43.0',
-    'passagemath-modules ~= 10.5.43.0',
+    'passagemath-setup == 10.6.1rc2',
+    'passagemath-environment == 10.6.1rc2',
+    'passagemath-categories == 10.6.1rc2',
+    'passagemath-modules == 10.6.1rc2',
     'cython >=3.0, != 3.0.3, <4.0', 'cython >=3.0.8,<3.1.0',
     'gmpy2 ~=2.1.b999',
     'cysignals >=1.11.2, != 1.12.0',
@@ -21,9 +21,9 @@ description = "passagemath: Computational Group Theory with GAP"
 dependencies = [
     'cysignals >=1.11.2, != 1.12.0',
     'memory_allocator',
-    'passagemath-conf ~= 10.5.43.0',
-    'passagemath-environment ~= 10.5.43.0',
-    'passagemath-categories ~= 10.5.43.0',
+    'passagemath-conf == 10.6.1rc2',
+    'passagemath-environment == 10.6.1rc2',
+    'passagemath-categories == 10.6.1rc2',
 ]
 dynamic = ["version"]
 license = "GPL-2.0-or-later"
@@ -39,7 +39,6 @@ classifiers = [
     "Operating System :: POSIX",
     "Operating System :: MacOS :: MacOS X",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -47,7 +46,7 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: CPython",
     "Topic :: Scientific/Engineering :: Mathematics",
 ]
-requires-python = ">=3.9, <3.14"
+requires-python = ">=3.10, <3.14"
 
 [project.urls]
 "release notes" = "https://github.com/passagemath/passagemath/releases"

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/coding/codecan/autgroup_can_label.pyx

@@ -246,7 +246,7 @@ class LinearCodeAutGroupCanLabel:
         z.sort()
         z = [i for (p, i) in z]
 
-        normalization_factors = [ F.one() ] * mat.ncols()
+        normalization_factors = [F.one()] * mat.ncols()
         if algorithm_type == "permutational":
             for c in col_list:
                 c.set_immutable()
@@ -258,20 +258,20 @@ class LinearCodeAutGroupCanLabel:
 
         normalization = S(v=normalization_factors)
         normalization_inverse = normalization ** (-1)
-        col_set = list({col_list[y] for y in nz })
+        col_set = list({col_list[y] for y in nz})
         col2pos = []
         col2P = []
         for c in col_set:
-            X = [(pos2P[y], y) for y in range(mat.ncols()) if col_list[y] == c ]
+            X = [(pos2P[y], y) for y in range(mat.ncols()) if col_list[y] == c]
             X.sort()
-            col2pos.append([b for (a, b) in X ])
-            col2P.append([a for (a, b) in X ])
+            col2pos.append([b for _, b in X])
+            col2P.append([a for a, _ in X])
 
         zipped = sorted(zip(col2P, col_set, col2pos))
 
-        col2P = [qty for (qty, c, pos) in zipped]
-        col_set = [c for (qty, c, pos) in zipped]
-        col2pos = [pos for (qty, c, pos) in zipped]
+        col2P = [qty for qty, c, pos in zipped]
+        col_set = [c for qty, c, pos in zipped]
+        col2pos = [pos for qty, c, pos in zipped]
         P_refined = []
         p = [0]
         act_qty = col2P[0]
@@ -291,7 +291,9 @@ class LinearCodeAutGroupCanLabel:
             # the dimension of the dual code
             # in this case we work with the code itself.
             pr = PartitionRefinementLinearCode(len(col_set),
-                matrix(col_set).transpose(), P=P_refined, algorithm_type=algorithm_type)
+                                               matrix(col_set).transpose(),
+                                               P=P_refined,
+                                               algorithm_type=algorithm_type)
 
             # this command allows you some advanced debugging
             # it prints the backtrack tree -> must be activated when installing
@@ -299,8 +301,11 @@ class LinearCodeAutGroupCanLabel:
 
             can_transp = pr.get_transporter()
             can_col_set = pr.get_canonical_form().columns()
-            self._PGammaL_autom_gens = self._compute_PGammaL_automs(pr.get_autom_gens(),
-                normalization, normalization_inverse, col2pos)
+            self._PGammaL_autom_gens = self._compute_PGammaL_automs(
+                pr.get_autom_gens(),
+                normalization,
+                normalization_inverse, col2pos
+            )
             self._PGammaL_autom_size = pr.get_autom_order_permutation()
             self._PGammaL_autom_size *= pr.get_autom_order_inner_stabilizer()
             self._full_autom_order = self._PGammaL_autom_size
@@ -333,28 +338,27 @@ class LinearCodeAutGroupCanLabel:
                         A.append(S_short(perm=_cyclic_shift(n, p)))
                     self._full_autom_order *= factorial(len(p))
             self._PGammaL_autom_size = self._full_autom_order / (len(F) - 1)
-            self._PGammaL_autom_gens = self._compute_PGammaL_automs(A,
-                normalization, normalization_inverse, col2pos)
+            self._PGammaL_autom_gens = self._compute_PGammaL_automs(
+                A, normalization, normalization_inverse, col2pos)
         else:
             # use the dual code for the computations
             # this might have zero columns or multiple columns, hence
             # we call this algorithm again.
             short_dual_code = LinearCode(matrix(col_set).transpose()).dual_code()
             agcl = LinearCodeAutGroupCanLabel(short_dual_code,
-                P=P_refined, algorithm_type=algorithm_type)
+                                              P=P_refined,
+                                              algorithm_type=algorithm_type)
             can_transp = agcl.get_transporter()
             can_transp.invert_v()
             can_col_set = agcl.get_canonical_form().parity_check_matrix().columns()
             A = agcl.get_autom_gens()
             for a in A:
                 a.invert_v()
-            self._PGammaL_autom_gens = self._compute_PGammaL_automs(A,
-                normalization, normalization_inverse, col2pos)
+            self._PGammaL_autom_gens = self._compute_PGammaL_automs(
+                A, normalization, normalization_inverse, col2pos)
             self._PGammaL_autom_size = agcl.get_PGammaL_order()
             self._full_autom_order = agcl.get_autom_order()
 
-        count = 0
-        block_ptr = []
         canonical_form = matrix(F, mat.ncols(), mat.nrows())
 
         perm = [-1] * mat.ncols()
@@ -363,8 +367,8 @@ class LinearCodeAutGroupCanLabel:
         for i in range(len(can_col_set)):
             img = can_transp.get_perm()(i + 1)
             for j in col2pos[img - 1]:
-                pos = P[ pos2P[j] ].pop()
-                canonical_form[ pos ] = can_col_set[i]
+                pos = P[pos2P[j]].pop()
+                canonical_form[pos] = can_col_set[i]
                 mult[pos] = can_transp.get_v()[i]
                 perm[pos] = j + 1
 
@@ -376,14 +380,17 @@ class LinearCodeAutGroupCanLabel:
 
         self._canonical_form = LinearCode(canonical_form.transpose())
         self._transporter = S(perm=Permutation(perm), v=mult, autom=can_transp.get_autom()) * normalization
-        self._trivial_autom_gens, a = self._compute_trivial_automs(normalization,
-            normalization_inverse, z, [pos2P[x] for x in z], zero_column_case=True)
+        self._trivial_autom_gens, a = self._compute_trivial_automs(
+            normalization,
+            normalization_inverse, z, [pos2P[x] for x in z],
+            zero_column_case=True)
         self._full_autom_order *= a
 
         for i in range(len(col2P)):
             if len(col2P[i]) > 1:
                 A, a = self._compute_trivial_automs(normalization,
-                    normalization_inverse, col2pos[i], col2P[i])
+                                                    normalization_inverse,
+                                                    col2pos[i], col2P[i])
                 self._full_autom_order *= a
                 self._trivial_autom_gens += A
 
@@ -461,11 +468,13 @@ class LinearCodeAutGroupCanLabel:
                 aut_order *= factorial(j - beg)
                 # we append a transposition of the first two elements
                 A.append(normalization_inverse *
-                    S(perm=_cyclic_shift(n, col2pos[beg:beg + 2])) * normalization)
+                         S(perm=_cyclic_shift(n, col2pos[beg:beg + 2])) *
+                         normalization)
                 if j - beg > 2:
                     # we append a cycle on all elements
                     A.append(normalization_inverse *
-                        S(perm=_cyclic_shift(n, col2pos[beg:j])) * normalization)
+                             S(perm=_cyclic_shift(n, col2pos[beg:j])) *
+                             normalization)
             beg = j
         return A, aut_order
 

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/coding/codecan/codecan.pxd

@@ -37,8 +37,8 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
     cdef int _k, _q
     cdef long *_hyp_refine_vals_scratch
     cdef object _inner_group_stabilizer_order
-    cdef bitset_t *_hyp2points # hyperplanes to points
-    cdef bitset_t *_points2hyp # points to hyperplanes, transpose of _hyp2points
+    cdef bitset_t *_hyp2points  # hyperplanes to points
+    cdef bitset_t *_points2hyp  # points to hyperplanes, transpose of _hyp2points
     cdef PartitionStack *_hyp_part
     cdef object _matrix, _root_matrix
     cdef InnerGroup _inner_group

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/coding/codecan/codecan.pyx

@@ -85,14 +85,14 @@ is returned by generators::
     True
 """
 
-#*******************************************************************************
+# *****************************************************************************
 #       Copyright (C) 2012 Thomas Feulner <thomas.feulner@uni-bayreuth.de>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  as published by the Free Software Foundation; either version 2 of
 #  the License, or (at your option) any later version.
 #                  https://www.gnu.org/licenses/
-#*******************************************************************************
+# *****************************************************************************
 from itertools import repeat
 from copy import copy
 from cysignals.memory cimport check_allocarray, sig_free
@@ -378,8 +378,9 @@ cdef class InnerGroup:
             6 -> 6 7 -> 7 8 -> 8 9 -> 9
         """
         return r"Subgroup of (GL(k,q) times \GF{q}^n ) rtimes Aut(\GF{q}) " + \
-            "with rank = %s, frobenius power = %s and partition =%s" % (self.rank,
-            self.frob_pow, OP_string(self.row_partition))
+            "with rank = %s, frobenius power = %s and partition =%s" % (
+                self.rank,
+                self.frob_pow, OP_string(self.row_partition))
 
     cdef void minimize_by_frobenius(self, object v, int *applied_frob, int *stab_pow) noexcept:
         r"""
@@ -637,7 +638,8 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
         else:
             P = remaining_inner_group.column_blocks(self._best_candidate)
             for p in P:
-                x = S(v=[ F.primitive_element() if i in p else F.one()  for i in range(self._n) ])
+                x = S(v=[F.primitive_element() if i in p else F.one()
+                         for i in range(self._n)])
                 self._autom_group_generators.append(transp_inv * x * self._transporter)
             self._inner_group_stabilizer_order = (len(F) - 1) ** len(P)
 
@@ -756,10 +758,9 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
         This graph will be later used in the refinement procedures.
         """
         cdef FFSS_projPoint iter = FFSS_projPoint(self._matrix)
-        cdef mp_bitcnt_t i,j
+        cdef mp_bitcnt_t i, j
 
         ambient_space = (self._matrix.base_ring()) ** (self._n)
-        weights2size = [0] * (self.len() + 1)
         W = [[] for _ in repeat(None, self.len() + 1)]
         span = [ambient_space.zero_subspace()] * (self.len() + 1)
         min_weight = self.len()
@@ -814,8 +815,9 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
     cdef bint _minimization_allowed_on_col(self, int pos) noexcept:
         r"""
         Decide if we are allowed to perform the inner minimization on position
-        ``pos`` which is supposed to be a singleton. For linear codes over finite
-        fields, we can always return ``True``.
+        ``pos`` which is supposed to be a singleton.
+
+        For linear codes over finite fields, we can always return ``True``.
         """
         return True
 
@@ -834,8 +836,9 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
         - ``True`` if and only if the actual node compares less or equal
           to the candidate for the canonical form.
         """
-        self._matrix = self._inner_group.minimize_matrix_col(self._matrix, pos,
-                            self._fixed_minimized, inner_group_changed)
+        self._matrix = self._inner_group.minimize_matrix_col(
+            self._matrix, pos,
+            self._fixed_minimized, inner_group_changed)
 
         # finally compare the new column with the best candidate
         if self._is_candidate_initialized:
@@ -912,7 +915,7 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
         - ``False`` only if the image under this homomorphism of group actions
           compares larger than the image of the candidate for the canonical form.
         """
-        cdef int i, j, res, stab_pow, apply_pow
+        cdef int i, res, stab_pow, apply_pow
 
         if self._inner_group.rank < 2:
             return True
@@ -990,7 +993,9 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
         cdef long * best_vals = self._point_refine_vals.get_row(self._nr_of_point_refine_calls)
         self._nr_of_point_refine_calls += 1
         cdef bint ret_val = self._one_refinement(best_vals, 0, self._n,
-            inner_stab_changed, changed_partition, "point_refine")
+                                                 inner_stab_changed,
+                                                 changed_partition,
+                                                 "point_refine")
 
         if not changed_partition[0]:
             self._part.depth -= 1
@@ -1033,8 +1038,10 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
         self._nr_of_hyp_refine_calls += 1
 
         cdef tuple ret_val = PS_refinement(self._hyp_part,
-            self._hyp_refine_vals_scratch, best_vals, 0, self._hyp_part.degree,
-            &self._is_candidate_initialized, changed_partition)
+                                           self._hyp_refine_vals_scratch,
+                                           best_vals, 0, self._hyp_part.degree,
+                                           &self._is_candidate_initialized,
+                                           changed_partition)
 
         if not changed_partition[0]:
             self._hyp_part.depth -= 1
@@ -1095,11 +1102,11 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
             else:
                 self._latex_debug_string += " & "
 
-        permuted_matrix = self._matrix.matrix_from_columns([self._part.entries[i] for i in range(self._n) ])
+        permuted_matrix = self._matrix.matrix_from_columns([self._part.entries[i] for i in range(self._n)])
 
         # Now we will finally print the matrix.
-        for i from 0 <= i < self._k:
-            for j from 0 <= j < (self._n - 1):
+        for i in range(self._k):
+            for j in range(self._n - 1):
                 self._latex_debug_string += "$" + permuted_matrix[i, j]._latex_() + "$ & "
             self._latex_debug_string += "$" + permuted_matrix[i, self._n - 1]._latex_() + "$ \\\\\n"
 

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/combinat/enumeration_mod_permgroup.pyx

@@ -3,14 +3,14 @@
 r"""
 Tools for enumeration modulo the action of a permutation group
 """
-#*****************************************************************************
+# ***************************************************************************
 #    Copyright (C) 2010-12 Nicolas Borie <nicolas.borie at math dot u-psud.fr>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #
 #              The full text of the GPL is available at:
-#                    http://www.gnu.org/licenses/
-#*****************************************************************************
+#                    https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.groups.perm_gps.permgroup_element cimport PermutationGroupElement
 

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/combinat/root_system/reflection_group_complex.py

@@ -197,26 +197,25 @@ AUTHORS:
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from sage.misc.cachefunc import cached_method, cached_function
-from sage.misc.misc_c import prod
 from sage.categories.category import Category
-from sage.categories.permutation_groups import PermutationGroups
 from sage.categories.complex_reflection_groups import ComplexReflectionGroups
 from sage.categories.coxeter_groups import CoxeterGroups
+from sage.categories.permutation_groups import PermutationGroups
+from sage.combinat.root_system.cartan_matrix import CartanMatrix
 from sage.combinat.root_system.reflection_group_element import ComplexReflectionGroupElement, _gap_return
-from sage.sets.family import Family
-from sage.structure.unique_representation import UniqueRepresentation
 from sage.groups.perm_gps.permgroup import PermutationGroup_generic
-from sage.combinat.permutation import Permutation
-from sage.rings.integer_ring import ZZ
-from sage.rings.rational_field import QQ
+from sage.interfaces.gap3 import gap3
 from sage.matrix.constructor import matrix
 from sage.matrix.special import identity_matrix
-from sage.structure.element import Matrix
-from sage.interfaces.gap3 import gap3
-from sage.modules.free_module_element import vector
-from sage.combinat.root_system.cartan_matrix import CartanMatrix
+from sage.misc.cachefunc import cached_method, cached_function
+from sage.misc.misc_c import prod
 from sage.misc.sage_eval import sage_eval
+from sage.modules.free_module_element import vector
+from sage.rings.integer_ring import ZZ
+from sage.rings.rational_field import QQ
+from sage.sets.family import Family
+from sage.structure.element import Matrix
+from sage.structure.unique_representation import UniqueRepresentation
 
 
 class ComplexReflectionGroup(UniqueRepresentation, PermutationGroup_generic):

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/combinat/root_system/weyl_group.py

@@ -927,7 +927,7 @@ class WeylGroupElement(MatrixGroupElement_gap):
 
         return s is positive
 
-    def has_left_descent(self, i):
+    def has_left_descent(self, i) -> bool:
         """
         Test if ``self`` has a left descent at position ``i``.
 
@@ -948,7 +948,7 @@ class WeylGroupElement(MatrixGroupElement_gap):
         """
         return self.has_descent(i, side='left')
 
-    def has_right_descent(self, i):
+    def has_right_descent(self, i) -> bool:
         """
         Test if ``self`` has a right descent at position ``i``.
 

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/groups/class_function.py

@@ -68,7 +68,6 @@ def ClassFunction(group, values):
         sage: chi = ClassFunction(G, values); chi
         Character of Cyclic group of order 4 as a permutation group
     """
-    from sage.misc.superseded import deprecation
     try:
         return group.class_function(values)
     except AttributeError:

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/groups/libgap_wrapper.pyx

@@ -364,7 +364,7 @@ class ParentLibGAP(SageObject):
                 for gap_subgroup in self._libgap.MaximalNormalSubgroups()]
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         """
         Return the generators of the group.
 

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/groups/matrix_gps/binary_dihedral.py

@@ -83,7 +83,7 @@ class BinaryDihedralGroup(UniqueRepresentation, FinitelyGeneratedMatrixGroup_gap
 
         MS = MatrixSpace(R, 2)
         zero = R.zero()
-        gens = [ MS([zeta, zero, zero, ~zeta]), MS([zero, i, i, zero]) ]
+        gens = [MS([zeta, zero, zero, ~zeta]), MS([zero, i, i, zero])]
 
         from sage.libs.gap.libgap import libgap
         gap_gens = [libgap(matrix_gen) for matrix_gen in gens]

{passagemath_gap-10.5.43 → passagemath_gap-10.6.1rc2}/sage/groups/perm_gps/permgroup.py

@@ -383,13 +383,12 @@ def PermutationGroup(gens=None, *args, **kwds):
         ...
         TypeError: gens must be a tuple, list, or GapElement
 
-    This will raise an error after the deprecation period::
+    This now raises an error (:issue:`31510`)::
 
         sage: G = PermutationGroup([(1,2,3,4)], [(1,7,3,5)])
-        doctest:warning
+        Traceback (most recent call last):
         ...
-        DeprecationWarning: gap_group, domain, canonicalize, category will become keyword only
-        See https://github.com/sagemath/sage/issues/31510 for details.
+        ValueError: please use keywords gap_group=, domain=, canonicalize=, category= in the input
     """
     if not isinstance(gens, ExpectElement) and hasattr(gens, '_permgroup_'):
         return gens._permgroup_()
@@ -405,18 +404,7 @@ def PermutationGroup(gens=None, *args, **kwds):
             raise ValueError("you must specify the domain for an action")
         return PermutationGroup_action(gens, action, domain, gap_group=gap_group)
     if args:
-        from sage.misc.superseded import deprecation
-        deprecation(31510, "gap_group, domain, canonicalize, category will become keyword only")
-        if len(args) > 4:
-            raise ValueError("invalid input")
-        args = list(args)
-        gap_group = args.pop(0)
-        if args:
-            domain = args.pop(0)
-            if args:
-                canonicalize = args.pop(0)
-                if args:
-                    category = args.pop(0)
+        raise ValueError("please use keywords gap_group=, domain=, canonicalize=, category= in the input")
     return PermutationGroup_generic(gens=gens, gap_group=gap_group, domain=domain,
                                     canonicalize=canonicalize, category=category)
 
@@ -1073,7 +1061,7 @@ class PermutationGroup_generic(FiniteGroup):
         """
         return list(self)
 
-    def __contains__(self, item):
+    def __contains__(self, item) -> bool:
         """
         Return whether ``item`` is an element of this group.
 
@@ -1110,33 +1098,6 @@ class PermutationGroup_generic(FiniteGroup):
             return False
         return True
 
-    def has_element(self, item):
-        """
-        Return whether ``item`` is an element of this group -
-        however *ignores* parentage.
-
-        EXAMPLES::
-
-            sage: G = CyclicPermutationGroup(4)
-            sage: gens = G.gens()
-            sage: H = DihedralGroup(4)
-            sage: g = G([(1,2,3,4)]); g
-            (1,2,3,4)
-            sage: G.has_element(g)
-            doctest:warning
-            ...
-            DeprecationWarning: G.has_element(g) is deprecated; use :meth:`__contains__`, i.e., `g in G` instead
-            See https://github.com/sagemath/sage/issues/33831 for details.
-            True
-            sage: h = H([(1,2),(3,4)]); h
-            (1,2)(3,4)
-            sage: G.has_element(h)
-            False
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(33831, "G.has_element(g) is deprecated; use :meth:`__contains__`, i.e., `g in G` instead")
-        return item in self
-
     def __iter__(self):
         r"""
         Return an iterator going through all elements in ``self``.
@@ -1166,9 +1127,9 @@ class PermutationGroup_generic(FiniteGroup):
         """
         if len(self._gens) == 1:
             return self._iteration_monogen()
-        else:
-            # TODO: this is too slow for moderatly small permutation groups
-            return self.iteration(algorithm='SGS')
+
+        # TODO: this is too slow for moderately small permutation groups
+        return self.iteration(algorithm='SGS')
 
     def _iteration_monogen(self):
         r"""
@@ -3357,9 +3318,17 @@ class PermutationGroup_generic(FiniteGroup):
             Traceback (most recent call last):
             ...
             TypeError: junk is not a permutation group
+
+        TESTS:
+
+        Verify that :issue`39416` is fixed::
+
+            sage: G = PermutationGroup(gens=[(1,2), (2,4)], domain={1, 2, 4})
+            sage: G.commutator()
+            Permutation Group with generators [(1,2,4)]
         """
         if other is None:
-            return PermutationGroup(gap_group=libgap.DerivedSubgroup(self))
+            return PermutationGroup(gap_group=libgap.DerivedSubgroup(self), domain=self.domain())
         else:
             from sage.categories.finite_permutation_groups import FinitePermutationGroups
             if other not in FinitePermutationGroups():