passagemath-schemes 10.8.1a4__cp314-cp314t-macosx_13_0_arm64.whl

sage/modular/arithgroup/congroup.pyx

@@ -0,0 +1,334 @@
+# sage_setup: distribution = sagemath-schemes
+r"""
+Helper functions for congruence subgroups
+
+This file contains optimized Cython implementations of a few functions related
+to the standard congruence subgroups `\Gamma_0, \Gamma_1, \Gamma_H`.  These
+functions are for internal use by routines elsewhere in the Sage library.
+"""
+
+# ****************************************************************************
+# 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 cysignals.memory cimport check_allocarray, sig_free
+
+from sage.matrix.matrix_dense cimport Matrix_dense
+
+try:
+    from sage.matrix.matrix_integer_dense import Matrix_integer_dense as MatrixClass
+except ImportError:
+    from sage.matrix.matrix_generic_dense import Matrix_generic_dense as MatrixClass
+
+import random
+from .congroup_gamma1 import Gamma1_constructor as Gamma1
+from .congroup_gamma0 import Gamma0_constructor as Gamma0
+
+cimport sage.rings.fast_arith
+import sage.rings.fast_arith
+cdef sage.rings.fast_arith.arith_int arith_int
+arith_int = sage.rings.fast_arith.arith_int()
+from sage.modular.modsym.p1list import lift_to_sl2z
+from sage.matrix.matrix_space import MatrixSpace
+from sage.rings.integer_ring import ZZ
+Mat2Z = MatrixSpace(ZZ, 2)
+
+cdef Matrix_dense genS, genT, genI
+
+genS = MatrixClass(Mat2Z, [0, -1, 1, 0], True, True)
+genT = MatrixClass(Mat2Z, [1, 1, 0, 1], True, True)
+genI = MatrixClass(Mat2Z, [1, 0, 0, 1], True, True)
+
+
+# This is the C version of a function formerly implemented in python in
+# sage.modular.congroup.  It is orders of magnitude faster (e.g., 30
+# times).  The key speedup is in replacing looping through the
+# elements of the Python list R with looping through the elements of a
+# C-array.
+
+def degeneracy_coset_representatives_gamma0(int N, int M, int t):
+    r"""
+    Let `N` be a positive integer and `M` a divisor of `N`.  Let `t` be a
+    divisor of `N/M`, and let `T` be the `2 \times 2` matrix `(1, 0; 0, t)`.
+    This function returns representatives for the orbit set `\Gamma_0(N)
+    \backslash T \Gamma_0(M)`, where `\Gamma_0(N)` acts on the left on `T
+    \Gamma_0(M)`.
+
+    INPUT:
+
+    - ``N`` -- integer
+    - ``M`` -- integer (divisor of `N`)
+    - ``t`` -- integer (divisor of `N/M`)
+
+    OUTPUT:
+
+    list -- list of lists ``[a,b,c,d]``, where ``[a,b,c,d]`` should be viewed
+    as a 2x2 matrix.
+
+    This function is used for computation of degeneracy maps between
+    spaces of modular symbols, hence its name.
+
+    We use that `T^{-1} \cdot (a,b;c,d) \cdot T = (a,bt; c/t,d)`, that the
+    group `T^{-1} \Gamma_0(N) T` is contained in `\Gamma_0(M)`, and that
+    `\Gamma_0(N) T` is contained in `T \Gamma_0(M)`.
+
+    ALGORITHM:
+
+    1. Compute representatives for `\Gamma_0(N/t,t)` inside of `\Gamma_0(M)`:
+
+      + COSET EQUIVALENCE: Two right cosets represented by `[a,b;c,d]` and
+        `[a',b';c',d']` of `\Gamma_0(N/t,t)` in `\SL_2(\ZZ)` are equivalent if
+        and only if `(a,b)=(a',b')` as points of `\mathbf{P}^1(\ZZ/t\ZZ)`,
+        i.e., `ab' \cong ba' \pmod{t}`, and `(c,d) = (c',d')` as points of
+        `\mathbf{P}^1(\ZZ/(N/t)\ZZ)`.
+
+      + ALGORITHM to list all cosets:
+
+        a) Compute the number of cosets.
+        b) Compute a random element `x` of `\Gamma_0(M)`.
+        c) Check if x is equivalent to anything generated so far; if not, add x
+           to the list.
+        d) Continue until the list is as long as the bound
+           computed in step (a).
+
+    2. There is a bijection between `\Gamma_0(N)\backslash T \Gamma_0(M)` and
+       `\Gamma_0(N/t,t) \backslash \Gamma_0(M)` given by `T r \leftrightarrow
+       r`. Consequently we obtain coset representatives for
+       `\Gamma_0(N)\backslash T \Gamma_0(M)` by left multiplying by `T` each
+       coset representative of `\Gamma_0(N/t,t) \backslash \Gamma_0(M)` found
+       in step 1.
+
+    EXAMPLES::
+
+        sage: from sage.modular.arithgroup.all import degeneracy_coset_representatives_gamma0
+        sage: len(degeneracy_coset_representatives_gamma0(13, 1, 1))
+        14
+        sage: len(degeneracy_coset_representatives_gamma0(13, 13, 1))
+        1
+        sage: len(degeneracy_coset_representatives_gamma0(13, 1, 13))
+        14
+    """
+    if N % M != 0:
+        raise ArithmeticError(f"M (={M}) must be a divisor of N (={N})")
+
+    if (N // M) % t != 0:
+        raise ArithmeticError(f"t (={t}) must be a divisor of N/M (={N//M})")
+
+    cdef int n, i, j, k, aa, bb, cc, dd, g, Ndivt, halfmax, is_new
+    cdef int* R
+
+    # total number of coset representatives that we'll find
+    n = Gamma0(N).index() / Gamma0(M).index()
+    k = 0   # number found so far
+    Ndivt = N // t
+    R = <int*>check_allocarray(4 * n, sizeof(int))
+    halfmax = 2*(n+10)
+    while k < n:
+        # try to find another coset representative.
+        cc = M*random.randrange(-halfmax, halfmax+1)
+        dd = random.randrange(-halfmax, halfmax+1)
+        g = arith_int.c_xgcd_int(-cc, dd, &bb, &aa)
+        if g == 0:
+            continue
+        cc = cc // g
+        if cc % M != 0:
+            continue
+        dd = dd // g
+        # Test if we've found a new coset representative.
+        is_new = 1
+        for i in range(k):
+            j = 4*i
+            if (R[j+1]*aa - R[j]*bb) % t == 0 and \
+               (R[j+3]*cc - R[j+2]*dd) % Ndivt == 0:
+                is_new = 0
+                break
+        # If our matrix is new add it to the list.
+        if is_new:
+            R[4*k] = aa
+            R[4*k+1] = bb
+            R[4*k+2] = cc
+            R[4*k+3] = dd
+            k = k + 1
+
+    # Return the list left multiplied by T.
+    S = []
+    for i in range(k):
+        j = 4*i
+        S.append([R[j], R[j+1], R[j+2]*t, R[j+3]*t])
+    sig_free(R)
+    return S
+
+
+def degeneracy_coset_representatives_gamma1(int N, int M, int t):
+    r"""
+    Let `N` be a positive integer and `M` a divisor of `N`.  Let `t` be a
+    divisor of `N/M`, and let `T` be the `2 \times 2` matrix `(1,0; 0,t)`.
+    This function returns representatives for the orbit set `\Gamma_1(N)
+    \backslash T \Gamma_1(M)`, where `\Gamma_1(N)` acts on the left on `T
+    \Gamma_1(M)`.
+
+    INPUT:
+
+    - ``N`` -- integer
+    - ``M`` -- integer (divisor of `N`)
+    - ``t`` -- integer (divisor of `N/M`)
+
+    OUTPUT:
+
+    list -- list of lists ``[a,b,c,d]``, where ``[a,b,c,d]`` should be viewed
+    as a 2x2 matrix.
+
+    This function is used for computation of degeneracy maps between
+    spaces of modular symbols, hence its name.
+
+    ALGORITHM:
+
+    Everything is the same as for
+    :func:`~degeneracy_coset_representatives_gamma0`, except for coset
+    equivalence.   Here `\Gamma_1(N/t,t)` consists of matrices that are of the
+    form `(1,*; 0,1) \bmod N/t` and `(1,0; *,1) \bmod t`.
+
+    COSET EQUIVALENCE: Two right cosets represented by `[a,b;c,d]` and
+    `[a',b';c',d']` of `\Gamma_1(N/t,t)` in `\SL_2(\ZZ)` are equivalent if
+    and only if
+
+    .. MATH::
+
+        a \cong a' \pmod{t},
+        b \cong b' \pmod{t},
+        c \cong c' \pmod{N/t},
+        d \cong d' \pmod{N/t}.
+
+    EXAMPLES::
+
+        sage: from sage.modular.arithgroup.all import degeneracy_coset_representatives_gamma1
+        sage: len(degeneracy_coset_representatives_gamma1(13, 1, 1))
+        168
+        sage: len(degeneracy_coset_representatives_gamma1(13, 13, 1))
+        1
+        sage: len(degeneracy_coset_representatives_gamma1(13, 1, 13))
+        168
+    """
+    if N % M != 0:
+        raise ArithmeticError(f"M (={M}) must be a divisor of N (={N})")
+
+    if (N // M) % t != 0:
+        raise ArithmeticError(f"t (={t}) must be a divisor of N/M (={N//M})")
+
+    cdef int d, g, i, j, k, n, aa, bb, cc, dd, Ndivt, halfmax, is_new
+    cdef int* R
+
+    # total number of coset representatives that we'll find
+    n = Gamma1(N).index() / Gamma1(M).index()
+    d = arith_int.c_gcd_int(t, N // t)
+    n = n // d
+    k = 0   # number found so far
+    Ndivt = N // t
+    R = <int*>check_allocarray(4 * n, sizeof(int))
+    halfmax = 2*(n+10)
+    while k < n:
+        # try to find another coset representative.
+        cc = M * random.randrange(-halfmax, halfmax + 1)
+        dd = 1 + M * random.randrange(-halfmax, halfmax + 1)
+        g = arith_int.c_xgcd_int(-cc, dd, &bb, &aa)
+        if g == 0:
+            continue
+        cc = cc // g
+        if cc % M != 0:
+            continue
+        dd = dd // g
+        if M != 1 and dd % M != 1:
+            continue
+        # Test if we've found a new coset representative.
+        is_new = 1
+        for i in range(k):
+            j = 4*i
+            if (R[j] - aa) % t == 0 and \
+               (R[j+1] - bb) % t == 0 and \
+               (R[j+2] - cc) % Ndivt == 0 and \
+               (R[j+3] - dd) % Ndivt == 0:
+                is_new = 0
+                break
+        # If our matrix is new add it to the list.
+        if is_new:
+            if k > n:
+                sig_free(R)
+                raise RuntimeError("bug!!")
+            R[4*k] = aa
+            R[4*k+1] = bb
+            R[4*k+2] = cc
+            R[4*k+3] = dd
+            k = k + 1
+
+    # Return the list left multiplied by T.
+    S = []
+    for i in range(k):
+        j = 4*i
+        S.append([R[j], R[j+1], R[j+2]*t, R[j+3]*t])
+    sig_free(R)
+    return S
+
+
+def generators_helper(coset_reps, level):
+    r"""
+    Helper function for generators of Gamma0, Gamma1 and GammaH.
+
+    These are computed using coset representatives, via an "inverse
+    Todd-Coxeter" algorithm, and generators for `\SL_2(\ZZ)`.
+
+    ALGORITHM: Given coset representatives for a finite index subgroup `G` of
+    `\SL_2(\ZZ)` we compute generators for `G` as follows.  Let `R` be a set of
+    coset representatives for `G`.  Let `S, T \in \SL_2(\ZZ)` be defined by
+    `(0,-1; 1,0)` and `(1,1,0,1)`, respectively.
+    Define maps `s, t: R \to G` as follows. If `r \in R`, then there exists a
+    unique `r' \in R` such that `GrS = Gr'`. Let `s(r) = rSr'^{-1}`. Likewise,
+    there is a unique `r'` such that `GrT = Gr'` and we let `t(r) = rTr'^{-1}`.
+    Note that `s(r)` and `t(r)` are in `G` for all `r`.  Then `G` is generated
+    by `s(R)\cup t(R)`.
+
+    There are more sophisticated algorithms using group actions on trees (and
+    Farey symbols) that give smaller generating sets -- this code is now
+    deprecated in favour of the newer implementation based on Farey symbols.
+
+    EXAMPLES::
+
+        sage: Gamma0(7).generators(algorithm='todd-coxeter') # indirect doctest
+        [
+        [1 1]  [-1  0]  [ 1 -1]  [1 0]  [1 1]  [-3 -1]  [-2 -1]  [-5 -1]
+        [0 1], [ 0 -1], [ 0  1], [7 1], [0 1], [ 7  2], [ 7  3], [21  4],
+        <BLANKLINE>
+        [-4 -1]  [-1  0]  [ 1  0]
+        [21  5], [ 7 -1], [-7  1]
+        ]
+    """
+    cdef Matrix_dense x, y, z, v, vSmod, vTmod
+
+    crs = coset_reps.list()
+    try:
+        reps = [MatrixClass(Mat2Z, lift_to_sl2z(c, d, level),
+                            False, True) for c, d in crs]
+    except Exception:
+        raise ArithmeticError("Error lifting to SL2Z: level=%s crs=%s" % (level, crs))
+    ans = []
+    cdef Py_ssize_t i
+    for i in range(len(crs)):
+        x = reps[i]
+        v = MatrixClass(Mat2Z, [crs[i][0], crs[i][1], 0, 0],
+                        False, True)
+        vSmod = (v*genS)
+        vTmod = (v*genT)
+        y_index = coset_reps.normalize(vSmod[0, 0], vSmod[0, 1])
+        z_index = coset_reps.normalize(vTmod[0, 0], vTmod[0, 1])
+        y_index = crs.index(y_index)
+        z_index = crs.index(z_index)
+        y = reps[y_index]
+        z = reps[z_index]
+        y = y.inverse_of_unit()
+        z = z.inverse_of_unit()
+        ans.append(x*genS*y)
+        ans.append(x*genT*z)
+    return [x for x in ans if x != genI]

sage/modular/arithgroup/congroup_gamma.py

@@ -0,0 +1,361 @@
+# sage_setup: distribution = sagemath-schemes
+r"""
+Congruence subgroup `\Gamma(N)`
+"""
+
+# ****************************************************************************
+# 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.arith.misc import gcd
+from sage.groups.matrix_gps.finitely_generated import MatrixGroup
+from sage.matrix.constructor import matrix
+from sage.misc.misc_c import prod
+from sage.modular.arithgroup.congroup_generic import CongruenceSubgroup
+from sage.modular.arithgroup.congroup_sl2z import SL2Z
+from sage.modular.cusps import Cusp
+from sage.rings.finite_rings.integer_mod_ring import Zmod
+from sage.rings.integer import GCD_list
+from sage.rings.integer_ring import ZZ
+from sage.rings.rational_field import QQ
+from sage.structure.richcmp import richcmp, richcmp_method
+
+_gamma_cache = {}
+
+
+def Gamma_constructor(N):
+    r"""
+    Return the congruence subgroup `\Gamma(N)`.
+
+    EXAMPLES::
+
+        sage: Gamma(5) # indirect doctest
+        Congruence Subgroup Gamma(5)
+        sage: G = Gamma(23)
+        sage: G is Gamma(23)
+        True
+        sage: TestSuite(G).run()
+
+    Test global uniqueness::
+
+        sage: G = Gamma(17)
+        sage: G is loads(dumps(G))
+        True
+        sage: G2 = sage.modular.arithgroup.congroup_gamma.Gamma_class(17)
+        sage: G == G2
+        True
+        sage: G is G2
+        False
+    """
+    if N == 1:
+        return SL2Z
+    try:
+        return _gamma_cache[N]
+    except KeyError:
+        _gamma_cache[N] = Gamma_class(N)
+        return _gamma_cache[N]
+
+
+@richcmp_method
+class Gamma_class(CongruenceSubgroup):
+    r"""
+    The principal congruence subgroup `\Gamma(N)`.
+    """
+    def _repr_(self):
+        """
+        Return the string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: Gamma(133)._repr_()
+            'Congruence Subgroup Gamma(133)'
+        """
+        return "Congruence Subgroup Gamma(%s)" % self.level()
+
+    def _latex_(self):
+        r"""
+        Return the \LaTeX representation of ``self``.
+
+        EXAMPLES::
+
+            sage: Gamma(20)._latex_()
+            '\\Gamma(20)'
+            sage: latex(Gamma(20))
+            \Gamma(20)
+        """
+        return "\\Gamma(%s)" % self.level()
+
+    def __reduce__(self):
+        """
+        Used for pickling ``self``.
+
+        EXAMPLES::
+
+            sage: Gamma(5).__reduce__()
+            (<function Gamma_constructor at ...>, (5,))
+        """
+        return Gamma_constructor, (self.level(),)
+
+    def __richcmp__(self, other, op):
+        r"""
+        Compare ``self`` to ``other``.
+
+        EXAMPLES::
+
+            sage: Gamma(3) == SymmetricGroup(8)                                         # needs sage.groups
+            False
+            sage: Gamma(3) == Gamma1(3)
+            False
+            sage: Gamma(5) < Gamma(6)
+            True
+            sage: Gamma(5) == Gamma(5)
+            True
+            sage: Gamma(3) == Gamma(3).as_permutation_group()                           # needs sage.groups
+            True
+        """
+        if isinstance(other, Gamma_class):
+            return richcmp(self.level(), other.level(), op)
+        else:
+            return NotImplemented
+
+    def index(self):
+        r"""
+        Return the index of ``self`` in the full modular group. This is given by
+
+        .. MATH::
+
+          \prod_{\substack{p \mid N \\ \text{$p$ prime}}}\left(p^{3e}-p^{3e-2}\right).
+
+        EXAMPLES::
+
+            sage: [Gamma(n).index() for n in [1..19]]
+            [1, 6, 24, 48, 120, 144, 336, 384, 648, 720, 1320, 1152, 2184, 2016, 2880, 3072, 4896, 3888, 6840]
+            sage: Gamma(32041).index()
+            32893086819240
+        """
+        return prod([p**(3*e-2)*(p*p-1) for (p,e) in self.level().factor()])
+
+    def _contains_sl2(self, a, b, c, d):
+        r"""
+        EXAMPLES::
+
+            sage: G = Gamma(5)
+            sage: [1, 0, -10, 1] in G
+            True
+            sage: 1 in G
+            True
+            sage: SL2Z([26, 5, 5, 1]) in G
+            True
+            sage: SL2Z([1, 1, 6, 7]) in G
+            False
+        """
+        N = self.level()
+        # don't need to check d == 1 as this is automatic from det
+        return ((a % N == 1) and (b % N == 0) and (c % N == 0))
+
+    def ncusps(self):
+        r"""
+        Return the number of cusps of this subgroup `\Gamma(N)`.
+
+        EXAMPLES::
+
+            sage: [Gamma(n).ncusps() for n in [1..19]]
+            [1, 3, 4, 6, 12, 12, 24, 24, 36, 36, 60, 48, 84, 72, 96, 96, 144, 108, 180]
+            sage: Gamma(30030).ncusps()
+            278691840
+            sage: Gamma(2^30).ncusps()
+            432345564227567616
+        """
+        n = self.level()
+        if n == 1:
+            return ZZ(1)
+        if n == 2:
+            return ZZ(3)
+        return prod([p**(2*e) - p**(2*e-2) for (p,e) in n.factor()])//2
+
+    def nirregcusps(self):
+        r"""
+        Return the number of irregular cusps of ``self``. For principal
+        congruence subgroups this is always 0.
+
+        EXAMPLES::
+
+            sage: Gamma(17).nirregcusps()
+            0
+        """
+        return 0
+
+    def _find_cusps(self):
+        r"""
+        Calculate the reduced representatives of the equivalence classes of
+        cusps for this group. Adapted from code by Ron Evans.
+
+        EXAMPLES::
+
+            sage: Gamma(8).cusps() # indirect doctest
+            [0, 1/4, 1/3, 3/8, 1/2, 2/3, 3/4, 1, 4/3, 3/2, 5/3, 2, 7/3, 5/2, 8/3, 3, 7/2, 11/3, 4, 14/3, 5, 6, 7, Infinity]
+        """
+        n = self.level()
+        C = [QQ(x) for x in range(n)]
+
+        n0 = n//2
+        n1 = (n+1)//2
+
+        for r in range(1, n1):
+            if r > 1 and gcd(r,n) == 1:
+                C.append(ZZ(r)/ZZ(n))
+            if n0 == n/2 and gcd(r,n0) == 1:
+                C.append(ZZ(r)/ZZ(n0))
+
+        for s in range(2,n1):
+            for r in range(1, 1+n):
+                if GCD_list([s,r,n]) == 1:
+                    # GCD_list is ~40x faster than gcd, since gcd wastes loads
+                    # of time initialising a Sequence type.
+                    u,v = _lift_pair(r,s,n)
+                    C.append(ZZ(u)/ZZ(v))
+
+        return [Cusp(x) for x in sorted(C)] + [Cusp(1,0)]
+
+    def reduce_cusp(self, c):
+        r"""
+        Calculate the unique reduced representative of the equivalence of the
+        cusp `c` modulo this group. The reduced representative of an
+        equivalence class is the unique cusp in the class of the form `u/v`
+        with `u, v \ge 0` coprime, `v` minimal, and `u` minimal for that `v`.
+
+        EXAMPLES::
+
+            sage: Gamma(5).reduce_cusp(1/5)
+            Infinity
+            sage: Gamma(5).reduce_cusp(7/8)
+            3/2
+            sage: Gamma(6).reduce_cusp(4/3)
+            2/3
+
+        TESTS::
+
+            sage: G = Gamma(50)
+            sage: all(c == G.reduce_cusp(c) for c in G.cusps())
+            True
+
+        We test that :issue:`36163` is fixed::
+
+            sage: Gamma(7).reduce_cusp(Cusp(6,7))
+            Infinity
+        """
+        N = self.level()
+        c = Cusp(c)
+        u,v = c.numerator() % N, c.denominator() % N
+        if (v > N//2) or (2*v == N and u > N//2):
+            u,v = -u,-v
+        u,v = _lift_pair(u,v,N)
+        return Cusp(u,v)
+
+    def are_equivalent(self, x, y, trans=False):
+        r"""
+        Check if the cusps `x` and `y` are equivalent under the action of this group.
+
+        ALGORITHM: The cusps `u_1 / v_1` and `u_2 / v_2` are equivalent modulo
+        `\Gamma(N)` if and only if `(u_1, v_1) = \pm (u_2, v_2) \bmod N`.
+
+        EXAMPLES::
+
+            sage: Gamma(7).are_equivalent(Cusp(2/3), Cusp(5/4))
+            True
+        """
+        if trans:
+            return CongruenceSubgroup.are_equivalent(self, x,y,trans=trans)
+        N = self.level()
+        u1,v1 = (x.numerator() % N, x.denominator() % N)
+        u2,v2 = (y.numerator(), y.denominator())
+
+        return ((u1,v1) == (u2 % N, v2 % N)) or ((u1,v1) == (-u2 % N, -v2 % N))
+
+    def nu3(self):
+        r"""
+        Return the number of elliptic points of order 3 for this arithmetic
+        subgroup. Since this subgroup is `\Gamma(N)` for `N \ge 2`, there are
+        no such points, so we return 0.
+
+        EXAMPLES::
+
+            sage: Gamma(89).nu3()
+            0
+        """
+        return 0
+
+    # We don't need to override nu2, since the default nu2 implementation knows
+    # that nu2 = 0 for odd subgroups.
+
+    def image_mod_n(self):
+        r"""
+        Return the image of this group modulo `N`, as a subgroup of `SL(2, \ZZ
+        / N\ZZ)`. This is just the trivial subgroup.
+
+        EXAMPLES::
+
+            sage: Gamma(3).image_mod_n()
+            Matrix group over Ring of integers modulo 3 with 1 generators (
+            [1 0]
+            [0 1]
+            )
+        """
+        return MatrixGroup([matrix(Zmod(self.level()), 2, 2, 1)])
+
+
+def is_Gamma(x):
+    r"""
+    Return ``True`` if x is a congruence subgroup of type Gamma.
+
+    EXAMPLES::
+
+        sage: from sage.modular.arithgroup.congroup_gamma import Gamma_class
+        sage: isinstance(Gamma0(13), Gamma_class)
+        False
+        sage: isinstance(Gamma(4), Gamma_class)
+        True
+    """
+    from sage.misc.superseded import deprecation
+    deprecation(38035, "The function is_Gamma is deprecated; use 'isinstance(..., Gamma_class)' instead.")
+    return isinstance(x, Gamma_class)
+
+
+def _lift_pair(U, V, N):
+    r"""
+    Utility function. Given integers ``U, V, N``, with `N \ge 1` and `{\rm
+    gcd}(U, V, N) = 1`, return a pair `(u, v)` congruent to `(U, V) \bmod N`,
+    such that `{\rm gcd}(u,v) = 1`, `u, v \ge 0`, `v` is as small as possible,
+    and `u` is as small as possible for that `v`.
+
+    *Warning*: As this function is for internal use, it does not do a
+    preliminary sanity check on its input, for efficiency. It will recover
+    reasonably gracefully if ``(U, V, N)`` are not coprime, but only after
+    wasting quite a lot of cycles!
+
+    EXAMPLES::
+
+        sage: from sage.modular.arithgroup.congroup_gamma import _lift_pair
+        sage: _lift_pair(2,4,7)
+        (9, 4)
+        sage: _lift_pair(2,4,8) # don't do this
+        Traceback (most recent call last):
+        ...
+        ValueError: (U, V, N) must be coprime
+    """
+    u = U % N
+    v = V % N
+    if v == 0:
+        if u == 1 or u == N-1:
+            return (1,0)
+        else:
+            v = N
+    while gcd(u, v) > 1:
+        u = u+N
+        if u > N*v:
+            raise ValueError("(U, V, N) must be coprime")
+    return (u, v)