passagemath-groups 10.6.45__cp314-cp314-macosx_13_0_arm64.whl

passagemath_groups/__init__.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-groups
+
+from sage.all__sagemath_groups import *

passagemath_groups-10.6.45.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: passagemath-groups
+Version: 10.6.45
+Summary: passagemath: Groups and Invariant Theory
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Requires-Dist: passagemath-categories~=10.6.45.0
+Requires-Dist: passagemath-gap~=10.6.45.0
+Requires-Dist: passagemath-modules~=10.6.45.0
+Provides-Extra: test
+Requires-Dist: passagemath-repl; extra == "test"
+Provides-Extra: coxeter3
+Requires-Dist: passagemath-coxeter3; extra == "coxeter3"
+Provides-Extra: gap
+Provides-Extra: additive
+Provides-Extra: affine
+Provides-Extra: lie
+Provides-Extra: matrix
+Provides-Extra: permutation
+Provides-Extra: presentation
+Provides-Extra: representations
+Requires-Dist: passagemath-combinat; extra == "representations"
+Provides-Extra: semigroups
+Requires-Dist: passagemath-combinat; extra == "semigroups"
+Provides-Extra: standard
+Requires-Dist: passagemath-groups[additive,matrix,representations,semigroups]; extra == "standard"
+
+=====================================================================
+ passagemath: Groups and Invariant Theory
+=====================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.14.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable package ``passagemath-groups`` a distribution of a part of the Sage Library.  It provides a small subset of the modules of the Sage library ("sagelib", ``passagemath-standard``) for computations with groups.
+
+
+What is included
+----------------
+
+* `Groups <https://passagemath.org/docs/latest/html/en/reference/groups/index.html>`_
+
+* see https://github.com/passagemath/passagemath/blob/main/pkgs/sagemath-groups/MANIFEST.in

passagemath_groups-10.6.45.dist-info/RECORD

@@ -0,0 +1,40 @@
+passagemath_groups/__init__.py,sha256=5UZ7CmaoJ-o6uzVDPDwTWpJ_EciPneedoip6lmUDqGw,86
+passagemath_groups/.dylibs/libreadline.8.2.dylib,sha256=oLjNdTQR_N5PDS6c2WerKvqEIlN0hKMKR2-5mzbhBbw,298136
+passagemath_groups/.dylibs/libz.1.3.1.dylib,sha256=htZ7pcm2d0F-f27a2iBxdfsizce4BO1n9c1CCN--bIM,119008
+passagemath_groups/.dylibs/libgap.10.dylib,sha256=vHOrEqH2jIkB51MjHgsjSf58pa-KrhPv94HapFToVgg,2474368
+passagemath_groups/.dylibs/libgmp.10.dylib,sha256=pnapXfr84Tlt7j4SDSGfqzzuIEGe5xLWUaKFZNxqkJA,446592
+passagemath_groups-10.6.45.dist-info/RECORD,,
+passagemath_groups-10.6.45.dist-info/WHEEL,sha256=3XbQBqanlgszXxeTyPSvYjuhSUOgjmWM5CtfEUkpneA,153
+passagemath_groups-10.6.45.dist-info/top_level.txt,sha256=ys0qYvxqpJEW3rVwKsO59n9kNFe6uNUAiVduBEf6o7Y,25
+passagemath_groups-10.6.45.dist-info/METADATA,sha256=Vp74oTeAsZnd1KU_lnTOQQ3XBOUO4AATJafSFxVXAfU,5177
+sage/all__sagemath_groups.py,sha256=JOSY5oJmS67eaWpSs14SBcD7be6NMKH05esJQj8sNOI,525
+sage/groups/finitely_presented.py,sha256=hLccjNjrj880fFeiLu9W7Z7Xz1HewuyJTVKNWrUsVMI,70042
+sage/groups/fqf_orthogonal.py,sha256=8cx71JJorwsFoSPzVLBg1rI_dA9dfGeWDqA6GAuqRh8,20181
+sage/groups/free_group.py,sha256=iMxfq5y8gA91i7XdpCmlL2N-5s2h_oYYohITmhMpVXo,29468
+sage/groups/all__sagemath_groups.py,sha256=g4HxEDA-YDJcTYHqA5pGLBIy7gpzg-BEVb2Jn7mTJD8,1147
+sage/groups/artin.py,sha256=CQHII1jKlBJZ_3GEyH-D22lS06prmIYcagTE7eg_RKc,41353
+sage/groups/finitely_presented_named.py,sha256=dKB2M78fw5W7RTHCGy-VB_X9co9UbFcQQYSdBr945Rc,20597
+sage/groups/all.py,sha256=ia6P1nJW_QxBEPMNKdT6ZE8v7J0z8qlMbX2uD3lBJU8,229
+sage/groups/raag.py,sha256=WbkPRhwCopLc2PtJ_Zcy_QASzsHcsp84_fM1x_dUcWw,28842
+sage/groups/cubic_braid.py,sha256=LEStrE9YiJAb5acsybhoQhth5fh-wbtn7uLjYyLoO1o,86974
+sage/groups/group_semidirect_product.py,sha256=7XqgwRR8i-KAWQdRXE8uoNbYDG-mDTqFw2uyqhDGCwY,17910
+sage/groups/cactus_group.py,sha256=O0FTBvGw8y3nRSR1aGPn5FdEv3jILG7QK_g_lZYdLPc,32895
+sage/groups/braid.py,sha256=6LyEbj9KCOyR7v1HhHWYyd62XqGSHcIOQVQF_TuWCXk,140495
+sage/groups/finitely_presented_catalog.py,sha256=Ylc_cx0Sv6eKH9J-n4xotqWK0Hc4pNrwZ3iRPe-gh1s,1251
+sage/groups/group_exp.py,sha256=KjhnaTnqnNKvBmYZJEbUge2-RydGSkued1JFXSLzeoo,11190
+sage/groups/kernel_subgroup.py,sha256=hZVsh5UYfq6MPxekXwlRuQyPuHq0Fk6SlNnN-5Yja6A,7706
+sage/groups/lie_gps/catalog.py,sha256=O5ub0bmV3z8tvJEFjxhgjIz4Zff8rJksOe5VQp0py0o,363
+sage/groups/lie_gps/all.py,sha256=-vXQHOTG46Zum7Q6k0kcJO43yJo09AIX-El8fzXA7eI,45
+sage/groups/lie_gps/nilpotent_lie_group.py,sha256=6VEgyU0U4ERif179dC1JWBdxO1PM6ZJ4d7Rc7dLkZmY,32506
+sage/groups/misc_gps/misc_groups.py,sha256=W2eH0XFqltL2-g7suj4vS8-klTYW4bTFmoWJ6ciR0-s,346
+sage/groups/misc_gps/all.py,sha256=-vXQHOTG46Zum7Q6k0kcJO43yJo09AIX-El8fzXA7eI,45
+sage/groups/misc_gps/misc_groups_catalog.py,sha256=TbpMPXGhwFpeOMlXdwdIGItBLV0XSvfN4oQRbKbMK9o,1627
+sage/groups/abelian_gps/all.py,sha256=yQQEiBWy_vtucLyFb_q1OIqgiC_DIE9KUzNWpdGTa4A,906
+sage/groups/semimonomial_transformations/semimonomial_transformation.pyx,sha256=9j9eS_uZYdCUQrTJDs4VhpO_7SeSzXdnzh0cACFNtkk,11298
+sage/groups/semimonomial_transformations/all.py,sha256=-vXQHOTG46Zum7Q6k0kcJO43yJo09AIX-El8fzXA7eI,45
+sage/groups/semimonomial_transformations/semimonomial_transformation_group.py,sha256=QflEYRK_oDUf8axx4kwcUR4aMOQNmE_faY1lzOdrAvQ,18312
+sage/groups/semimonomial_transformations/semimonomial_transformation.pxd,sha256=wivg7LyXn_ZMrADRUmabPEYNitTRZCvs2htLN3E0v9g,297
+sage/groups/semimonomial_transformations/semimonomial_transformation.cpython-314-darwin.so,sha256=FO_oCcCc0t7HkVlpnuvncX8SDKK4RbANOrni8XZIoWU,151280
+sage/geometry/all__sagemath_groups.py,sha256=-vXQHOTG46Zum7Q6k0kcJO43yJo09AIX-El8fzXA7eI,45
+sage/geometry/palp_normal_form.pyx,sha256=HfDpZHxffoxG2pxTrXO0ucRlEDZcrtzHBoZ0CoHm5lI,17498
+sage/geometry/palp_normal_form.cpython-314-darwin.so,sha256=TtWcy0Hb_OjQ5WJi3cmKx6Myz5zWlcbGrweCOGLcKo4,201256

passagemath_groups-10.6.45.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314-macosx_13_0_arm64
+Generator: delocate 0.13.1.dev42+ga0af70b54
+

passagemath_groups-10.6.45.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+
+passagemath_groups
+sage

sage/all__sagemath_groups.py

@@ -0,0 +1,21 @@
+# sage_setup: distribution = sagemath-groups
+# delvewheel: patch
+r"""
+Top level of the distribution package sagemath-groups
+
+This distribution makes the following feature available::
+
+    sage: from sage.features.sagemath import *
+    sage: sage__groups().is_present()
+    FeatureTestResult('sage.groups', True)
+"""
+
+from .all__sagemath_gap import *
+from .all__sagemath_modules import *
+
+try:  # extra
+    from sage.all__sagemath_combinat import *
+except ImportError:
+    pass
+
+from sage.groups.all__sagemath_groups import *

sage/geometry/all__sagemath_groups.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-groups

sage/geometry/palp_normal_form.pyx

@@ -0,0 +1,401 @@
+# sage_setup: distribution = sagemath-groups
+# sage.doctest: needs sage.geometry.polyhedron sage.groups
+r"""
+PALP normal form of vertices of a lattice polytope
+"""
+# ****************************************************************************
+#       Copyright (C) 2013      Jan Keitel
+#                     2014      Volker Braun
+#                     2018      Christian Stump
+#                     2019      Vincent Delecroix
+#                     2019      Jonathan Kliem
+#                     2021      Michael Orlitzky
+#                     2018-2022 Frédéric Chapoton
+#                     2023      Luze Xu
+#                     2023      Matthias Koeppe
+#
+# 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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.groups.perm_gps.permgroup_element cimport PermutationGroupElement
+from sage.groups.perm_gps.permgroup_named import SymmetricGroup
+from sage.matrix.matrix_integer_dense cimport Matrix_integer_dense
+from sage.matrix.special import column_matrix
+from sage.structure.element import Matrix
+
+
+def _palp_PM_max(Matrix_integer_dense PM, check=False):
+    r"""
+    Compute the permutation normal form of the vertex facet pairing matrix.
+
+    The permutation normal form of a matrix is defined as the lexicographic
+    maximum under all permutations of its rows and columns. For more
+    more detail, see also
+    :meth:`~sage.matrix.matrix2.Matrix.permutation_normal_form`.
+
+    Instead of using the generic method for computing the permutation
+    normal form, this method uses the PALP algorithm to compute
+    the permutation normal form and its automorphisms concurrently.
+
+    INPUT:
+
+    - ``check`` -- boolean (default: ``False``); whether to return
+      the permutations leaving the maximal vertex-facet pairing
+      matrix invariant
+
+    OUTPUT:
+
+    A matrix or a tuple of a matrix and a dict whose values are the
+    permutation group elements corresponding to the permutations
+    that permute :meth:`vertices` such that the vertex-facet pairing
+    matrix is maximal.
+
+    EXAMPLES::
+
+        sage: o = lattice_polytope.cross_polytope(2)
+        sage: PM = o.vertex_facet_pairing_matrix()
+        sage: PM_max = PM.permutation_normal_form()
+        sage: PM_max == o._palp_PM_max()
+        True
+
+        sage: # needs polytopes_db
+        sage: P2 = ReflexivePolytope(2, 0)
+        sage: PM_max, permutations = P2._palp_PM_max(check=True)
+        sage: PM_max
+        [3 0 0]
+        [0 3 0]
+        [0 0 3]
+        sage: list(permutations.values())
+        [[(1,2,3), (1,2,3)],
+         [(1,3,2), (1,3,2)],
+         [(1,3), (1,3)],
+         [(1,2), (1,2)],
+         [(), ()],
+         [(2,3), (2,3)]]
+        sage: PM_max.automorphisms_of_rows_and_columns()
+        [((), ()),
+         ((1,2,3), (1,2,3)),
+         ((1,3,2), (1,3,2)),
+         ((2,3), (2,3)),
+         ((1,2), (1,2)),
+         ((1,3), (1,3))]
+        sage: PMs = (i._palp_PM_max(check=True)
+        ....:        for i in ReflexivePolytopes(2))
+        sage: results = (len(i) == len(j.automorphisms_of_rows_and_columns())
+        ....:            for j, i in PMs)
+        sage: all(results)  # long time
+        True
+
+    TESTS:
+
+    Check that a bug introduced in :issue:`35997` is fixed::
+
+        sage: from sage.geometry.palp_normal_form import _palp_PM_max, _palp_canonical_order
+        sage: P = Polyhedron([(-4,-6),(-4,-5),(0,0),(1,0),(5,6)])
+        sage: PM = P.slack_matrix().transpose()
+        sage: _palp_PM_max(PM)
+        [9 5 4 0 0]
+        [6 0 6 5 0]
+        [1 5 0 0 4]
+        [0 6 0 1 6]
+        [0 0 3 5 3]
+        sage: PM_max, permutations = _palp_PM_max(PM, check=True)
+        sage: _palp_canonical_order(P.vertices(), PM_max, permutations)
+        ([(1, 0), (0, 0), (2, 4), (1, 5), (-1, 1)], (1,2,3))
+    """
+    cdef int n_v = PM.ncols()
+    cdef int n_f = PM.nrows()
+    S_v = SymmetricGroup(n_v)
+    S_f = SymmetricGroup(n_f)
+
+    cdef int n_s = 1
+    cdef dict permutations = {0: [S_f.one(), S_v.one()]}
+    cdef int j, k, m, d
+    cdef int element, max_element
+
+    for j in range(n_v):
+        max_element = PM.get_unsafe_int(0, (<PermutationGroupElement> permutations[0][1])(j + 1) - 1)
+        m = 0
+        for i in range(j + 1, n_v):
+            element = PM.get_unsafe_int(0, (<PermutationGroupElement> permutations[0][1])(i + 1) - 1)
+            if element > max_element:
+                max_element = element
+                m = i - j
+        if m > 0:
+            permutations[0][1] = (<PermutationGroupElement> permutations[0][1])._transpose_left(j + 1, m + j + 1)
+
+    cdef first_row_index = 0
+
+    # Arrange other rows one by one and compare with first row
+    for k in range(1, n_f):
+        # Error for k == 1 already!
+        permutations[n_s] = [S_f.one(), S_v.one()]
+        max_element = PM.get_unsafe_int(k, (<PermutationGroupElement> permutations[n_s][1])(1) - 1)
+        m = 0
+        for j in range(1, n_v):
+            element = PM.get_unsafe_int(k, (<PermutationGroupElement> permutations[n_s][1])(j + 1) - 1)
+            if element > max_element:
+                max_element = element
+                m = j
+        if m > 0:
+            permutations[n_s][1] = (<PermutationGroupElement> permutations[n_s][1])._transpose_left(1, m + 1)
+        d = (PM.get_unsafe_int(k, (<PermutationGroupElement> permutations[n_s][1])(1) - 1)
+             - PM.get_unsafe_int(first_row_index, (<PermutationGroupElement> permutations[0][1])(1) - 1))
+        if d < 0:
+            # The largest elt of this row is smaller than largest elt
+            # in 1st row, so nothing to do
+            continue
+        # otherwise:
+        for i in range(1, n_v):
+            max_element = PM.get_unsafe_int(k, (<PermutationGroupElement> permutations[n_s][1])(i + 1) - 1)
+            m = i
+            for j in range(i + 1, n_v):
+                element = PM.get_unsafe_int(k, (<PermutationGroupElement> permutations[n_s][1])(j + 1) - 1)
+                if element > max_element:
+                    max_element = element
+                    m = j
+            if m > i:
+                permutations[n_s][1] = (<PermutationGroupElement> permutations[n_s][1])._transpose_left(i + 1, m + 1)
+            if d == 0:
+                d = (PM.get_unsafe_int(k, (<PermutationGroupElement> permutations[n_s][1])(i+1) - 1)
+                     - PM.get_unsafe_int(first_row_index, (<PermutationGroupElement> permutations[0][1])(i + 1) - 1))
+                if d < 0:
+                    break
+        if d < 0:
+            # This row is smaller than 1st row, so nothing to do
+            del permutations[n_s]
+            continue
+        permutations[n_s][0] = (<PermutationGroupElement> permutations[n_s][0])._transpose_left(1, k + 1)
+        if d == 0:
+            # This row is the same, so we have a symmetry!
+            n_s += 1
+        else:
+            # This row is larger, so it becomes the first row and
+            # the symmetries reset.
+            first_row_index = k
+            permutations = {0: permutations[n_s]}
+            n_s = 1
+    permutations = {k: permutations[k] for k in permutations if k < n_s}
+
+    cdef tuple b = tuple(PM.get_unsafe_int((<PermutationGroupElement> permutations[0][0])(1) - 1,
+                                           (<PermutationGroupElement> permutations[0][1])(j+1) - 1)
+                         for j in range(n_v))
+    # Work out the restrictions the current permutations
+    # place on other permutations as a automorphisms
+    # of the first row
+    # The array is such that:
+    # S = [i, 1, ..., 1 (ith), j, i+1, ..., i+1 (jth), k ... ]
+    # describes the "symmetry blocks"
+    cdef list S = list(range(1, n_v + 1))
+    for i in range(1, n_v):
+        if b[i-1] == b[i]:
+            S[i] = S[i-1]
+            S[S[i]-1] += 1
+        else:
+            S[i] = i + 1
+
+    cdef int l, cf, ccf, n_s_bar, d1, v0, vc, vj
+    cdef list l_r
+
+    # We determine the other rows of PM_max in turn by use of perms and
+    # aut on previous rows.
+    for l in range(1, n_f - 1):
+        n_s = len(permutations)
+        n_s_bar = n_s
+        cf = 0
+        l_r = [0]*n_v
+        # Search for possible local permutations based off previous
+        # global permutations.
+        for k in range(n_s_bar - 1, -1, -1):
+            # number of local permutations associated with current global
+            n_p = 0
+            ccf = cf
+            permutations_bar = {0: list(permutations[k])}
+            # We look for the line with the maximal entry in the first
+            # subsymmetry block, i.e. we are allowed to swap elements
+            # between 0 and S(0)
+            for s in range(l, n_f):
+                for j in range(1, S[0]):
+                    v0 = PM.get_unsafe_int((<PermutationGroupElement> permutations_bar[n_p][0])(s+1) - 1,
+                                           (<PermutationGroupElement> permutations_bar[n_p][1])(1) - 1)
+                    vj = PM.get_unsafe_int((<PermutationGroupElement> permutations_bar[n_p][0])(s+1) - 1,
+                                           (<PermutationGroupElement> permutations_bar[n_p][1])(j+1) - 1)
+                    if v0 < vj:
+                        permutations_bar[n_p][1] = (<PermutationGroupElement> permutations_bar[n_p][1])._transpose_left(1, j + 1)
+                if ccf == 0:
+                    l_r[0] = PM.get_unsafe_int((<PermutationGroupElement> permutations_bar[n_p][0])(s+1) - 1,
+                                               (<PermutationGroupElement> permutations_bar[n_p][1])(1) - 1)
+                    if s != l:
+                        permutations_bar[n_p][0] = (<PermutationGroupElement> permutations_bar[n_p][0])._transpose_left(l + 1, s + 1)
+                    n_p += 1
+                    ccf = 1
+                    permutations_bar[n_p] = list(permutations[k])
+                else:
+                    d1 = PM.get_unsafe_int((<PermutationGroupElement> permutations_bar[n_p][0])(s+1) - 1,
+                                           (<PermutationGroupElement> permutations_bar[n_p][1])(1) - 1)
+                    d = d1 - l_r[0]
+                    if d < 0:
+                        # We move to the next line
+                        continue
+                    elif d==0:
+                        # Maximal values agree, so possible symmetry
+                        if s != l:
+                            permutations_bar[n_p][0] = (<PermutationGroupElement> permutations_bar[n_p][0])._transpose_left(l + 1, s + 1)
+                        n_p += 1
+                        permutations_bar[n_p] = list(permutations[k])
+                    else:
+                        # We found a greater maximal value for first entry.
+                        # It becomes our new reference:
+                        l_r[0] = d1
+                        if s != l:
+                            permutations_bar[n_p][0] = (<PermutationGroupElement> permutations_bar[n_p][0])._transpose_left(l + 1, s + 1)
+                        # Forget previous work done
+                        cf = 0
+                        permutations_bar = {0: list(permutations_bar[n_p])}
+                        n_p = 1
+                        permutations_bar[n_p] = list(permutations[k])
+                        n_s = k + 1
+            # Check if the permutations found just now work
+            # with other elements
+            for c in range(1, n_v):
+                h = S[c]
+                ccf = cf
+                # Now let us find out where the end of the
+                # next symmetry block is:
+                if h < c + 1:
+                    h = S[h - 1]
+                s = n_p
+                # Check through this block for each possible permutation
+                while s > 0:
+                    s -= 1
+                    # Find the largest value in this symmetry block
+                    for j in range(c + 1, h):
+                        vc = PM.get_unsafe_int((<PermutationGroupElement> permutations_bar[s][0])(l+1) - 1,
+                                               (<PermutationGroupElement> permutations_bar[s][1])(c+1) - 1)
+                        vj = PM.get_unsafe_int((<PermutationGroupElement> permutations_bar[s][0])(l+1) - 1,
+                                               (<PermutationGroupElement> permutations_bar[s][1])(j+1) - 1)
+                        if vc < vj:
+                            permutations_bar[s][1] = (<PermutationGroupElement> permutations_bar[s][1])._transpose_left(c + 1, j + 1)
+                    if ccf == 0:
+                        # Set reference and carry on to next permutation
+                        l_r[c] = PM.get_unsafe_int((<PermutationGroupElement> permutations_bar[s][0])(l+1) - 1,
+                                                   (<PermutationGroupElement> permutations_bar[s][1])(c+1) - 1)
+                        ccf = 1
+                    else:
+                        d1 = PM.get_unsafe_int((<PermutationGroupElement> permutations_bar[s][0])(l+1) - 1,
+                                               (<PermutationGroupElement> permutations_bar[s][1])(c+1) - 1)
+                        d = d1 - l_r[c]
+                        if d < 0:
+                            n_p -= 1
+                            if s < n_p:
+                                permutations_bar[s] = list(permutations_bar[n_p])
+                        elif d > 0:
+                            # The current case leads to a smaller matrix,
+                            # hence this case becomes our new reference
+                            l_r[c] = d1
+                            cf = 0
+                            n_p = s + 1
+                            n_s = k + 1
+            # Update permutations
+            if (n_s - 1) > k:
+                permutations[k] = list(permutations[n_s - 1])
+            n_s -= 1
+            for s in range(n_p):
+                permutations[n_s] = list(permutations_bar[s])
+                n_s += 1
+            cf = n_s
+        permutations = {k: permutations[k] for k in permutations if k < n_s}
+        # If the automorphisms are not already completely restricted,
+        # update them
+        if S != list(range(1, n_v + 1)):
+            # Take the old automorphisms and update by
+            # the restrictions the last worked out
+            # row imposes.
+            c = 0
+            M = tuple(PM.get_unsafe_int((<PermutationGroupElement> permutations[0][0])(l+1) - 1,
+                                        (<PermutationGroupElement> permutations[0][1])(j+1) - 1)
+                      for j in range(n_v))
+            while c < n_v:
+                s = S[c] + 1
+                S[c] = c + 1
+                c += 1
+                while c < (s - 1):
+                    if M[c] == M[c - 1]:
+                        S[c] = S[c - 1]
+                        S[S[c] - 1] += 1
+                    else:
+                        S[c] = c + 1
+                    c += 1
+    # Now we have the perms, we construct PM_max using one of them
+    PM_max = PM.with_permuted_rows_and_columns(*permutations[0])
+    if check:
+        return (PM_max, permutations)
+    else:
+        return PM_max
+
+
+def _palp_canonical_order(vertices, PM_max, permutations):
+    r"""
+    Compute the PALP normal form of vertices of a lattice polytope
+    using auxiliary data computed elsewhere.
+
+    This is a helper function for
+    :meth:`~sage.geometry.lattice_polytope.LatticePolytopeClass.normal_form`
+    and should not be called directly.
+
+    Given an iterable of vertices, the maximal vertex-facet pairing matrix
+    and the permutations realizing this matrix, apply the last part of the
+    PALP algorithm and return the normal form.
+
+    INPUT:
+
+    - ``vertices`` -- iterable of iterables; the vertices
+
+    - ``PM_max`` -- the maximal vertex-facet pairing matrix
+
+    - ``permutation`` -- the permutations of the vertices yielding ``PM_max``
+
+    OUTPUT: the PALP normal form as an iterable of integer vectors
+
+    TESTS::
+
+        sage: L = lattice_polytope.cross_polytope(2)
+        sage: V = L.vertices()
+        sage: PM_max, permutations = L._palp_PM_max(check=True)
+        sage: from sage.geometry.lattice_polytope import _palp_canonical_order
+        sage: _palp_canonical_order(V, PM_max, permutations)
+        (M( 1,  0),
+         M( 0,  1),
+         M( 0, -1),
+         M(-1,  0)
+         in 2-d lattice M, (1,3,2,4))
+    """
+    n_v = PM_max.ncols()
+    S_v = SymmetricGroup(n_v)
+    p_c = S_v.one()
+    M_max = [max(row[j] for row in PM_max.rows()) for j in range(n_v)]
+    S_max = sum(PM_max)
+    for i in range(n_v):
+        k = i
+        for j in range(i + 1, n_v):
+            if M_max[j] < M_max[k] or \
+               (M_max[j] == M_max[k] and S_max[j] < S_max[k]):
+                k = j
+        if not k == i:
+            M_max[i], M_max[k] = M_max[k], M_max[i]
+            S_max[i], S_max[k] = S_max[k], S_max[i]
+            p_c = p_c._transpose_left(1 + i, 1 + k)
+    # Create array of possible NFs.
+    permutations = [p_c * l[1] for l in permutations.values()]
+    if isinstance(vertices, Matrix):
+        Vmatrix = vertices
+    else:
+        Vmatrix = column_matrix(vertices)
+    Vs = [(Vmatrix.with_permuted_columns(sig).hermite_form(), sig)
+          for sig in permutations]
+    Vmin = min(Vs, key=lambda x: x[0])
+    return Vmin[0].columns(), Vmin[1]

sage/groups/abelian_gps/all.py

@@ -0,0 +1,25 @@
+# sage_setup: distribution = sagemath-groups
+"""
+all.py -- export of abelian groups to Sage
+"""
+
+# *****************************************************************************
+#
+#   Sage: Open Source Mathematical Software
+#
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.groups.abelian_gps.all__sagemath_modules import *
+from sage.groups.abelian_gps.all__sagemath_gap import *

sage/groups/all.py

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-groups
+from sage.groups.all__sagemath_modules import *
+from sage.groups.all__sagemath_gap import *
+from sage.groups.all__sagemath_pari import *
+from sage.groups.all__sagemath_groups import *