Add files using upload-large-folder tool

.gitattributes

@@ -870,3 +870,5 @@ evalkit_tf437/lib/python3.10/site-packages/triton/_C/libtriton.so filter=lfs dif
 infer_4_47_1/lib/python3.10/site-packages/sympy/physics/control/__pycache__/lti.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_47_1/lib/python3.10/site-packages/sympy/matrices/__pycache__/matrixbase.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_47_1/lib/python3.10/site-packages/sympy/matrices/tests/__pycache__/test_matrixbase.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_args.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

infer_4_47_1/lib/python3.10/site-packages/sympy/calculus/__init__.py

@@ -0,0 +1,25 @@
+"""Calculus-related methods."""
+
+from .euler import euler_equations
+from .singularities import (singularities, is_increasing,
+                            is_strictly_increasing, is_decreasing,
+                            is_strictly_decreasing, is_monotonic)
+from .finite_diff import finite_diff_weights, apply_finite_diff, differentiate_finite
+from .util import (periodicity, not_empty_in, is_convex,
+                   stationary_points, minimum, maximum)
+from .accumulationbounds import AccumBounds
+
+__all__ = [
+'euler_equations',
+
+'singularities', 'is_increasing',
+'is_strictly_increasing', 'is_decreasing',
+'is_strictly_decreasing', 'is_monotonic',
+
+'finite_diff_weights', 'apply_finite_diff', 'differentiate_finite',
+
+'periodicity', 'not_empty_in', 'is_convex', 'stationary_points',
+'minimum', 'maximum',
+
+'AccumBounds'
+]

infer_4_47_1/lib/python3.10/site-packages/sympy/calculus/euler.py

@@ -0,0 +1,108 @@
+"""
+This module implements a method to find
+Euler-Lagrange Equations for given Lagrangian.
+"""
+from itertools import combinations_with_replacement
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.utilities.iterables import iterable
+
+
+def euler_equations(L, funcs=(), vars=()):
+    r"""
+    Find the Euler-Lagrange equations [1]_ for a given Lagrangian.
+
+    Parameters
+    ==========
+
+    L : Expr
+        The Lagrangian that should be a function of the functions listed
+        in the second argument and their derivatives.
+
+        For example, in the case of two functions $f(x,y)$, $g(x,y)$ and
+        two independent variables $x$, $y$ the Lagrangian has the form:
+
+            .. math:: L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x},
+                      \frac{\partial f(x,y)}{\partial y},
+                      \frac{\partial g(x,y)}{\partial x},
+                      \frac{\partial g(x,y)}{\partial y},x,y\right)
+
+        In many cases it is not necessary to provide anything, except the
+        Lagrangian, it will be auto-detected (and an error raised if this
+        cannot be done).
+
+    funcs : Function or an iterable of Functions
+        The functions that the Lagrangian depends on. The Euler equations
+        are differential equations for each of these functions.
+
+    vars : Symbol or an iterable of Symbols
+        The Symbols that are the independent variables of the functions.
+
+    Returns
+    =======
+
+    eqns : list of Eq
+        The list of differential equations, one for each function.
+
+    Examples
+    ========
+
+    >>> from sympy import euler_equations, Symbol, Function
+    >>> x = Function('x')
+    >>> t = Symbol('t')
+    >>> L = (x(t).diff(t))**2/2 - x(t)**2/2
+    >>> euler_equations(L, x(t), t)
+    [Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
+    >>> u = Function('u')
+    >>> x = Symbol('x')
+    >>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
+    >>> euler_equations(L, u(t, x), [t, x])
+    [Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation
+
+    """
+
+    funcs = tuple(funcs) if iterable(funcs) else (funcs,)
+
+    if not funcs:
+        funcs = tuple(L.atoms(Function))
+    else:
+        for f in funcs:
+            if not isinstance(f, Function):
+                raise TypeError('Function expected, got: %s' % f)
+
+    vars = tuple(vars) if iterable(vars) else (vars,)
+
+    if not vars:
+        vars = funcs[0].args
+    else:
+        vars = tuple(sympify(var) for var in vars)
+
+    if not all(isinstance(v, Symbol) for v in vars):
+        raise TypeError('Variables are not symbols, got %s' % vars)
+
+    for f in funcs:
+        if not vars == f.args:
+            raise ValueError("Variables %s do not match args: %s" % (vars, f))
+
+    order = max([len(d.variables) for d in L.atoms(Derivative)
+                        if d.expr in funcs] + [0])
+
+    eqns = []
+    for f in funcs:
+        eq = diff(L, f)
+        for i in range(1, order + 1):
+            for p in combinations_with_replacement(vars, i):
+                eq = eq + S.NegativeOne**i*diff(L, diff(f, *p), *p)
+        new_eq = Eq(eq, 0)
+        if isinstance(new_eq, Eq):
+            eqns.append(new_eq)
+
+    return eqns

infer_4_47_1/lib/python3.10/site-packages/sympy/calculus/singularities.py

@@ -0,0 +1,406 @@
+"""
+Singularities
+=============
+
+This module implements algorithms for finding singularities for a function
+and identifying types of functions.
+
+The differential calculus methods in this module include methods to identify
+the following function types in the given ``Interval``:
+- Increasing
+- Strictly Increasing
+- Decreasing
+- Strictly Decreasing
+- Monotonic
+
+"""
+
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.trigonometric import sec, csc, cot, tan, cos
+from sympy.functions.elementary.hyperbolic import (
+    sech, csch, coth, tanh, cosh, asech, acsch, atanh, acoth)
+from sympy.utilities.misc import filldedent
+
+
+def singularities(expression, symbol, domain=None):
+    """
+    Find singularities of a given function.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function in which singularities need to be found.
+    symbol : Symbol
+        The symbol over the values of which the singularity in
+        expression in being searched for.
+
+    Returns
+    =======
+
+    Set
+        A set of values for ``symbol`` for which ``expression`` has a
+        singularity. An ``EmptySet`` is returned if ``expression`` has no
+        singularities for any given value of ``Symbol``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        Methods for determining the singularities of this function have
+        not been developed.
+
+    Notes
+    =====
+
+    This function does not find non-isolated singularities
+    nor does it find branch points of the expression.
+
+    Currently supported functions are:
+        - univariate continuous (real or complex) functions
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathematical_singularity
+
+    Examples
+    ========
+
+    >>> from sympy import singularities, Symbol, log
+    >>> x = Symbol('x', real=True)
+    >>> y = Symbol('y', real=False)
+    >>> singularities(x**2 + x + 1, x)
+    EmptySet
+    >>> singularities(1/(x + 1), x)
+    {-1}
+    >>> singularities(1/(y**2 + 1), y)
+    {-I, I}
+    >>> singularities(1/(y**3 + 1), y)
+    {-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2}
+    >>> singularities(log(x), x)
+    {0}
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    if domain is None:
+        domain = S.Reals if symbol.is_real else S.Complexes
+    try:
+        sings = S.EmptySet
+        e = expression.rewrite([sec, csc, cot, tan], cos)
+        e = e.rewrite([sech, csch, coth, tanh], cosh)
+        for i in e.atoms(Pow):
+            if i.exp.is_infinite:
+                raise NotImplementedError
+            if i.exp.is_negative:
+                # XXX: exponent of varying sign not handled
+                sings += solveset(i.base, symbol, domain)
+        for i in expression.atoms(log, asech, acsch):
+            sings += solveset(i.args[0], symbol, domain)
+        for i in expression.atoms(atanh, acoth):
+            sings += solveset(i.args[0] - 1, symbol, domain)
+            sings += solveset(i.args[0] + 1, symbol, domain)
+        return sings
+    except NotImplementedError:
+        raise NotImplementedError(filldedent('''
+            Methods for determining the singularities
+            of this function have not been developed.'''))
+
+
+###########################################################################
+#                      DIFFERENTIAL CALCULUS METHODS                      #
+###########################################################################
+
+
+def monotonicity_helper(expression, predicate, interval=S.Reals, symbol=None):
+    """
+    Helper function for functions checking function monotonicity.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked
+    predicate : function
+        The property being tested for. The function takes in an integer
+        and returns a boolean. The integer input is the derivative and
+        the boolean result should be true if the property is being held,
+        and false otherwise.
+    interval : Set, optional
+        The range of values in which we are testing, defaults to all reals.
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    It returns a boolean indicating whether the interval in which
+    the function's derivative satisfies given predicate is a superset
+    of the given interval.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``predicate`` is true for all the derivatives when ``symbol``
+        is varied in ``range``, False otherwise.
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    expression = sympify(expression)
+    free = expression.free_symbols
+
+    if symbol is None:
+        if len(free) > 1:
+            raise NotImplementedError(
+                'The function has not yet been implemented'
+                ' for all multivariate expressions.'
+            )
+
+    variable = symbol or (free.pop() if free else Symbol('x'))
+    derivative = expression.diff(variable)
+    predicate_interval = solveset(predicate(derivative), variable, S.Reals)
+    return interval.is_subset(predicate_interval)
+
+
+def is_increasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is increasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is increasing (either strictly increasing or
+        constant) in the given ``interval``, False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_increasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
+    True
+    >>> is_increasing(-x**2, Interval(-oo, 0))
+    True
+    >>> is_increasing(-x**2, Interval(0, oo))
+    False
+    >>> is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
+    False
+    >>> is_increasing(x**2 + y, Interval(1, 2), x)
+    True
+
+    """
+    return monotonicity_helper(expression, lambda x: x >= 0, interval, symbol)
+
+
+def is_strictly_increasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is strictly increasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is strictly increasing in the given ``interval``,
+        False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_strictly_increasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import Interval, oo
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
+    True
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
+    True
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
+    False
+    >>> is_strictly_increasing(-x**2, Interval(0, oo))
+    False
+    >>> is_strictly_increasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x > 0, interval, symbol)
+
+
+def is_decreasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is decreasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is decreasing (either strictly decreasing or
+        constant) in the given ``interval``, False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_decreasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
+    False
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
+    False
+    >>> is_decreasing(-x**2, Interval(-oo, 0))
+    False
+    >>> is_decreasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x <= 0, interval, symbol)
+
+
+def is_strictly_decreasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is strictly decreasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is strictly decreasing in the given ``interval``,
+        False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_strictly_decreasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
+    False
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
+    False
+    >>> is_strictly_decreasing(-x**2, Interval(-oo, 0))
+    False
+    >>> is_strictly_decreasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x < 0, interval, symbol)
+
+
+def is_monotonic(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is monotonic in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is monotonic in the given ``interval``,
+        False otherwise.
+
+    Raises
+    ======
+
+    NotImplementedError
+        Monotonicity check has not been implemented for the queried function.
+
+    Examples
+    ========
+
+    >>> from sympy import is_monotonic
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
+    True
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    True
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
+    True
+    >>> is_monotonic(-x**2, S.Reals)
+    False
+    >>> is_monotonic(x**2 + y + 1, Interval(1, 2), x)
+    True
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    expression = sympify(expression)
+
+    free = expression.free_symbols
+    if symbol is None and len(free) > 1:
+        raise NotImplementedError(
+            'is_monotonic has not yet been implemented'
+            ' for all multivariate expressions.'
+        )
+
+    variable = symbol or (free.pop() if free else Symbol('x'))
+    turning_points = solveset(expression.diff(variable), variable, interval)
+    return interval.intersection(turning_points) is S.EmptySet

infer_4_47_1/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d0c6b62b8a2eb4e4f9a149dc8a11cdec992f999a9dfed64ae1396f45fa3635f
+size 152911

infer_4_47_1/lib/python3.10/site-packages/sympy/core/tests/__pycache__/test_args.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2da74a66b5c7d641937b412b1ebd45cda788c95985bca103f6fe094093123a5f
+size 220806

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/digits.py

@@ -0,0 +1,150 @@
+from collections import defaultdict
+
+from sympy.utilities.iterables import multiset, is_palindromic as _palindromic
+from sympy.utilities.misc import as_int
+
+
+def digits(n, b=10, digits=None):
+    """
+    Return a list of the digits of ``n`` in base ``b``. The first
+    element in the list is ``b`` (or ``-b`` if ``n`` is negative).
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.digits import digits
+    >>> digits(35)
+    [10, 3, 5]
+
+    If the number is negative, the negative sign will be placed on the
+    base (which is the first element in the returned list):
+
+    >>> digits(-35)
+    [-10, 3, 5]
+
+    Bases other than 10 (and greater than 1) can be selected with ``b``:
+
+    >>> digits(27, b=2)
+    [2, 1, 1, 0, 1, 1]
+
+    Use the ``digits`` keyword if a certain number of digits is desired:
+
+    >>> digits(35, digits=4)
+    [10, 0, 0, 3, 5]
+
+    Parameters
+    ==========
+
+    n: integer
+        The number whose digits are returned.
+
+    b: integer
+        The base in which digits are computed.
+
+    digits: integer (or None for all digits)
+        The number of digits to be returned (padded with zeros, if
+        necessary).
+
+    See Also
+    ========
+    sympy.core.intfunc.num_digits, count_digits
+    """
+
+    b = as_int(b)
+    n = as_int(n)
+    if b < 2:
+        raise ValueError("b must be greater than 1")
+    else:
+        x, y = abs(n), []
+        while x >= b:
+            x, r = divmod(x, b)
+            y.append(r)
+        y.append(x)
+        y.append(-b if n < 0 else b)
+        y.reverse()
+        ndig = len(y) - 1
+        if digits is not None:
+            if ndig > digits:
+                raise ValueError(
+                    "For %s, at least %s digits are needed." % (n, ndig))
+            elif ndig < digits:
+                y[1:1] = [0]*(digits - ndig)
+        return y
+
+
+def count_digits(n, b=10):
+    """
+    Return a dictionary whose keys are the digits of ``n`` in the
+    given base, ``b``, with keys indicating the digits appearing in the
+    number and values indicating how many times that digit appeared.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import count_digits
+
+    >>> count_digits(1111339)
+    {1: 4, 3: 2, 9: 1}
+
+    The digits returned are always represented in base-10
+    but the number itself can be entered in any format that is
+    understood by Python; the base of the number can also be
+    given if it is different than 10:
+
+    >>> n = 0xFA; n
+    250
+    >>> count_digits(_)
+    {0: 1, 2: 1, 5: 1}
+    >>> count_digits(n, 16)
+    {10: 1, 15: 1}
+
+    The default dictionary will return a 0 for any digit that did
+    not appear in the number. For example, which digits appear 7
+    times in ``77!``:
+
+    >>> from sympy import factorial
+    >>> c77 = count_digits(factorial(77))
+    >>> [i for i in range(10) if c77[i] == 7]
+    [1, 3, 7, 9]
+
+    See Also
+    ========
+    sympy.core.intfunc.num_digits, digits
+    """
+    rv = defaultdict(int, multiset(digits(n, b)).items())
+    rv.pop(b) if b in rv else rv.pop(-b)  # b or -b is there
+    return rv
+
+
+def is_palindromic(n, b=10):
+    """return True if ``n`` is the same when read from left to right
+    or right to left in the given base, ``b``.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import is_palindromic
+
+    >>> all(is_palindromic(i) for i in (-11, 1, 22, 121))
+    True
+
+    The second argument allows you to test numbers in other
+    bases. For example, 88 is palindromic in base-10 but not
+    in base-8:
+
+    >>> is_palindromic(88, 8)
+    False
+
+    On the other hand, a number can be palindromic in base-8 but
+    not in base-10:
+
+    >>> 0o121, is_palindromic(0o121)
+    (81, False)
+
+    Or it might be palindromic in both bases:
+
+    >>> oct(121), is_palindromic(121, 8) and is_palindromic(121)
+    ('0o171', True)
+
+    """
+    return _palindromic(digits(n, b), 1)

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/ecm.py

@@ -0,0 +1,345 @@
+from math import log
+
+from sympy.core.random import _randint
+from sympy.external.gmpy import gcd, invert, sqrt
+from sympy.utilities.misc import as_int
+from .generate import sieve, primerange
+from .primetest import isprime
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                   Lenstra's Elliptic Curve Factorization                   #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class Point:
+    """Montgomery form of Points in an elliptic curve.
+    In this form, the addition and doubling of points
+    does not need any y-coordinate information thus
+    decreasing the number of operations.
+    Using Montgomery form we try to perform point addition
+    and doubling in least amount of multiplications.
+
+    The elliptic curve used here is of the form
+    (E : b*y**2*z = x**3 + a*x**2*z + x*z**2).
+    The a_24 parameter is equal to (a + 2)/4.
+
+    References
+    ==========
+
+    .. [1] Kris Gaj, Soonhak Kwon, Patrick Baier, Paul Kohlbrenner, Hoang Le, Mohammed Khaleeluddin, Ramakrishna Bachimanchi,
+           Implementing the Elliptic Curve Method of Factoring in Reconfigurable Hardware,
+           Cryptographic Hardware and Embedded Systems - CHES 2006 (2006), pp. 119-133,
+           https://doi.org/10.1007/11894063_10
+           https://www.hyperelliptic.org/tanja/SHARCS/talks06/Gaj.pdf
+
+    """
+
+    def __init__(self, x_cord, z_cord, a_24, mod):
+        """
+        Initial parameters for the Point class.
+
+        Parameters
+        ==========
+
+        x_cord : X coordinate of the Point
+        z_cord : Z coordinate of the Point
+        a_24 : Parameter of the elliptic curve in Montgomery form
+        mod : modulus
+        """
+        self.x_cord = x_cord
+        self.z_cord = z_cord
+        self.a_24 = a_24
+        self.mod = mod
+
+    def __eq__(self, other):
+        """Two points are equal if X/Z of both points are equal
+        """
+        if self.a_24 != other.a_24 or self.mod != other.mod:
+            return False
+        return self.x_cord * other.z_cord % self.mod ==\
+            other.x_cord * self.z_cord % self.mod
+
+    def add(self, Q, diff):
+        """
+        Add two points self and Q where diff = self - Q. Moreover the assumption
+        is self.x_cord*Q.x_cord*(self.x_cord - Q.x_cord) != 0. This algorithm
+        requires 6 multiplications. Here the difference between the points
+        is already known and using this algorithm speeds up the addition
+        by reducing the number of multiplication required. Also in the
+        mont_ladder algorithm is constructed in a way so that the difference
+        between intermediate points is always equal to the initial point.
+        So, we always know what the difference between the point is.
+
+
+        Parameters
+        ==========
+
+        Q : point on the curve in Montgomery form
+        diff : self - Q
+
+        Examples
+        ========
+
+        >>> from sympy.ntheory.ecm import Point
+        >>> p1 = Point(11, 16, 7, 29)
+        >>> p2 = Point(13, 10, 7, 29)
+        >>> p3 = p2.add(p1, p1)
+        >>> p3.x_cord
+        23
+        >>> p3.z_cord
+        17
+        """
+        u = (self.x_cord - self.z_cord)*(Q.x_cord + Q.z_cord)
+        v = (self.x_cord + self.z_cord)*(Q.x_cord - Q.z_cord)
+        add, subt = u + v, u - v
+        x_cord = diff.z_cord * add * add % self.mod
+        z_cord = diff.x_cord * subt * subt % self.mod
+        return Point(x_cord, z_cord, self.a_24, self.mod)
+
+    def double(self):
+        """
+        Doubles a point in an elliptic curve in Montgomery form.
+        This algorithm requires 5 multiplications.
+
+        Examples
+        ========
+
+        >>> from sympy.ntheory.ecm import Point
+        >>> p1 = Point(11, 16, 7, 29)
+        >>> p2 = p1.double()
+        >>> p2.x_cord
+        13
+        >>> p2.z_cord
+        10
+        """
+        u = pow(self.x_cord + self.z_cord, 2, self.mod)
+        v = pow(self.x_cord - self.z_cord, 2, self.mod)
+        diff = u - v
+        x_cord = u*v % self.mod
+        z_cord = diff*(v + self.a_24*diff) % self.mod
+        return Point(x_cord, z_cord, self.a_24, self.mod)
+
+    def mont_ladder(self, k):
+        """
+        Scalar multiplication of a point in Montgomery form
+        using Montgomery Ladder Algorithm.
+        A total of 11 multiplications are required in each step of this
+        algorithm.
+
+        Parameters
+        ==========
+
+        k : The positive integer multiplier
+
+        Examples
+        ========
+
+        >>> from sympy.ntheory.ecm import Point
+        >>> p1 = Point(11, 16, 7, 29)
+        >>> p3 = p1.mont_ladder(3)
+        >>> p3.x_cord
+        23
+        >>> p3.z_cord
+        17
+        """
+        Q = self
+        R = self.double()
+        for i in bin(k)[3:]:
+            if  i  == '1':
+                Q = R.add(Q, self)
+                R = R.double()
+            else:
+                R = Q.add(R, self)
+                Q = Q.double()
+        return Q
+
+
+def _ecm_one_factor(n, B1=10000, B2=100000, max_curve=200, seed=None):
+    """Returns one factor of n using
+    Lenstra's 2 Stage Elliptic curve Factorization
+    with Suyama's Parameterization. Here Montgomery
+    arithmetic is used for fast computation of addition
+    and doubling of points in elliptic curve.
+
+    Explanation
+    ===========
+
+    This ECM method considers elliptic curves in Montgomery
+    form (E : b*y**2*z = x**3 + a*x**2*z + x*z**2) and involves
+    elliptic curve operations (mod N), where the elements in
+    Z are reduced (mod N). Since N is not a prime, E over FF(N)
+    is not really an elliptic curve but we can still do point additions
+    and doubling as if FF(N) was a field.
+
+    Stage 1 : The basic algorithm involves taking a random point (P) on an
+    elliptic curve in FF(N). The compute k*P using Montgomery ladder algorithm.
+    Let q be an unknown factor of N. Then the order of the curve E, |E(FF(q))|,
+    might be a smooth number that divides k. Then we have k = l * |E(FF(q))|
+    for some l. For any point belonging to the curve E, |E(FF(q))|*P = O,
+    hence k*P = l*|E(FF(q))|*P. Thus kP.z_cord = 0 (mod q), and the unknownn
+    factor of N (q) can be recovered by taking gcd(kP.z_cord, N).
+
+    Stage 2 : This is a continuation of Stage 1 if k*P != O. The idea utilize
+    the fact that even if kP != 0, the value of k might miss just one large
+    prime divisor of |E(FF(q))|. In this case we only need to compute the
+    scalar multiplication by p to get p*k*P = O. Here a second bound B2
+    restrict the size of possible values of p.
+
+    Parameters
+    ==========
+
+    n : Number to be Factored
+    B1 : Stage 1 Bound. Must be an even number.
+    B2 : Stage 2 Bound. Must be an even number.
+    max_curve : Maximum number of curves generated
+
+    Returns
+    =======
+
+    integer | None : ``n`` (if it is prime) else a non-trivial divisor of ``n``. ``None`` if not found
+
+    References
+    ==========
+
+    .. [1] Carl Pomerance, Richard Crandall, Prime Numbers: A Computational Perspective,
+           2nd Edition (2005), page 344, ISBN:978-0387252827
+    """
+    randint = _randint(seed)
+    if isprime(n):
+        return n
+
+    # When calculating T, if (B1 - 2*D) is negative, it cannot be calculated.
+    D = min(sqrt(B2), B1 // 2 - 1)
+    sieve.extend(D)
+    beta = [0] * D
+    S = [0] * D
+    k = 1
+    for p in primerange(2, B1 + 1):
+        k *= pow(p, int(log(B1, p)))
+
+    # Pre-calculate the prime numbers to be used in stage 2.
+    # Using the fact that the x-coordinates of point P and its
+    # inverse -P coincide, the number of primes to be checked
+    # in stage 2 can be reduced.
+    deltas_list = []
+    for r in range(B1 + 2*D, B2 + 2*D, 4*D):
+        deltas = set()
+        deltas.update((abs(q - r) - 1) // 2 for q in primerange(r - 2*D, r + 2*D))
+        # d in deltas iff r+(2d+1) and/or r-(2d+1) is prime
+        deltas_list.append(list(deltas))
+
+    for _ in range(max_curve):
+        #Suyama's Parametrization
+        sigma = randint(6, n - 1)
+        u = (sigma**2 - 5) % n
+        v = (4*sigma) % n
+        u_3 = pow(u, 3, n)
+
+        try:
+            # We use the elliptic curve y**2 = x**3 + a*x**2 + x
+            # where a = pow(v - u, 3, n)*(3*u + v)*invert(4*u_3*v, n) - 2
+            # However, we do not declare a because it is more convenient
+            # to use a24 = (a + 2)*invert(4, n) in the calculation.
+            a24 = pow(v - u, 3, n)*(3*u + v)*invert(16*u_3*v, n) % n
+        except ZeroDivisionError:
+            #If the invert(16*u_3*v, n) doesn't exist (i.e., g != 1)
+            g = gcd(2*u_3*v, n)
+            #If g = n, try another curve
+            if g == n:
+                continue
+            return g
+
+        Q = Point(u_3, pow(v, 3, n), a24, n)
+        Q = Q.mont_ladder(k)
+        g = gcd(Q.z_cord, n)
+
+        #Stage 1 factor
+        if g != 1 and g != n:
+            return g
+        #Stage 1 failure. Q.z = 0, Try another curve
+        elif g == n:
+            continue
+
+        #Stage 2 - Improved Standard Continuation
+        S[0] = Q
+        Q2 = Q.double()
+        S[1] = Q2.add(Q, Q)
+        beta[0] = (S[0].x_cord*S[0].z_cord) % n
+        beta[1] = (S[1].x_cord*S[1].z_cord) % n
+        for d in range(2, D):
+            S[d] = S[d - 1].add(Q2, S[d - 2])
+            beta[d] = (S[d].x_cord*S[d].z_cord) % n
+        # i.e., S[i] = Q.mont_ladder(2*i + 1)
+
+        g = 1
+        W = Q.mont_ladder(4*D)
+        T = Q.mont_ladder(B1 - 2*D)
+        R = Q.mont_ladder(B1 + 2*D)
+        for deltas in deltas_list:
+            # R = Q.mont_ladder(r) where r in range(B1 + 2*D, B2 + 2*D, 4*D)
+            alpha = (R.x_cord*R.z_cord) % n
+            for delta in deltas:
+                # We want to calculate
+                # f = R.x_cord * S[delta].z_cord - S[delta].x_cord * R.z_cord
+                f = (R.x_cord - S[delta].x_cord)*\
+                    (R.z_cord + S[delta].z_cord) - alpha + beta[delta]
+                g = (g*f) % n
+            T, R = R, R.add(W, T)
+        g = gcd(n, g)
+
+        #Stage 2 Factor found
+        if g != 1 and g != n:
+            return g
+
+
+def ecm(n, B1=10000, B2=100000, max_curve=200, seed=1234):
+    """Performs factorization using Lenstra's Elliptic curve method.
+
+    This function repeatedly calls ``_ecm_one_factor`` to compute the factors
+    of n. First all the small factors are taken out using trial division.
+    Then ``_ecm_one_factor`` is used to compute one factor at a time.
+
+    Parameters
+    ==========
+
+    n : Number to be Factored
+    B1 : Stage 1 Bound. Must be an even number.
+    B2 : Stage 2 Bound. Must be an even number.
+    max_curve : Maximum number of curves generated
+    seed : Initialize pseudorandom generator
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import ecm
+    >>> ecm(25645121643901801)
+    {5394769, 4753701529}
+    >>> ecm(9804659461513846513)
+    {4641991, 2112166839943}
+    """
+    n = as_int(n)
+    if B1 % 2 != 0 or B2 % 2 != 0:
+        raise ValueError("both bounds must be even")
+    _factors = set()
+    for prime in sieve.primerange(1, 100000):
+        if n % prime == 0:
+            _factors.add(prime)
+            while(n % prime == 0):
+                n //= prime
+    while(n > 1):
+        factor = _ecm_one_factor(n, B1, B2, max_curve, seed)
+        if factor is None:
+            raise ValueError("Increase the bounds")
+        _factors.add(factor)
+        n //= factor
+
+    factors = set()
+    for factor in _factors:
+        if isprime(factor):
+            factors.add(factor)
+            continue
+        factors |= ecm(factor)
+    return factors

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/generate.py

@@ -0,0 +1,1147 @@
+"""
+Generating and counting primes.
+
+"""
+
+from bisect import bisect, bisect_left
+from itertools import count
+# Using arrays for sieving instead of lists greatly reduces
+# memory consumption
+from array import array as _array
+
+from sympy.core.random import randint
+from sympy.external.gmpy import sqrt
+from .primetest import isprime
+from sympy.utilities.decorator import deprecated
+from sympy.utilities.misc import as_int
+
+
+def _as_int_ceiling(a):
+    """ Wrapping ceiling in as_int will raise an error if there was a problem
+        determining whether the expression was exactly an integer or not."""
+    from sympy.functions.elementary.integers import ceiling
+    return as_int(ceiling(a))
+
+
+class Sieve:
+    """A list of prime numbers, implemented as a dynamically
+    growing sieve of Eratosthenes. When a lookup is requested involving
+    an odd number that has not been sieved, the sieve is automatically
+    extended up to that number. Implementation details limit the number of
+    primes to ``2^32-1``.
+
+    Examples
+    ========
+
+    >>> from sympy import sieve
+    >>> sieve._reset() # this line for doctest only
+    >>> 25 in sieve
+    False
+    >>> sieve._list
+    array('L', [2, 3, 5, 7, 11, 13, 17, 19, 23])
+    """
+
+    # data shared (and updated) by all Sieve instances
+    def __init__(self, sieve_interval=1_000_000):
+        """ Initial parameters for the Sieve class.
+
+        Parameters
+        ==========
+
+        sieve_interval (int): Amount of memory to be used
+
+        Raises
+        ======
+
+        ValueError
+            If ``sieve_interval`` is not positive.
+
+        """
+        self._n = 6
+        self._list = _array('L', [2, 3, 5, 7, 11, 13]) # primes
+        self._tlist = _array('L', [0, 1, 1, 2, 2, 4]) # totient
+        self._mlist = _array('i', [0, 1, -1, -1, 0, -1]) # mobius
+        if sieve_interval <= 0:
+            raise ValueError("sieve_interval should be a positive integer")
+        self.sieve_interval = sieve_interval
+        assert all(len(i) == self._n for i in (self._list, self._tlist, self._mlist))
+
+    def __repr__(self):
+        return ("<%s sieve (%i): %i, %i, %i, ... %i, %i\n"
+             "%s sieve (%i): %i, %i, %i, ... %i, %i\n"
+             "%s sieve (%i): %i, %i, %i, ... %i, %i>") % (
+             'prime', len(self._list),
+                 self._list[0], self._list[1], self._list[2],
+                 self._list[-2], self._list[-1],
+             'totient', len(self._tlist),
+                 self._tlist[0], self._tlist[1],
+                 self._tlist[2], self._tlist[-2], self._tlist[-1],
+             'mobius', len(self._mlist),
+                 self._mlist[0], self._mlist[1],
+                 self._mlist[2], self._mlist[-2], self._mlist[-1])
+
+    def _reset(self, prime=None, totient=None, mobius=None):
+        """Reset all caches (default). To reset one or more set the
+            desired keyword to True."""
+        if all(i is None for i in (prime, totient, mobius)):
+            prime = totient = mobius = True
+        if prime:
+            self._list = self._list[:self._n]
+        if totient:
+            self._tlist = self._tlist[:self._n]
+        if mobius:
+            self._mlist = self._mlist[:self._n]
+
+    def extend(self, n):
+        """Grow the sieve to cover all primes <= n.
+
+        Examples
+        ========
+
+        >>> from sympy import sieve
+        >>> sieve._reset() # this line for doctest only
+        >>> sieve.extend(30)
+        >>> sieve[10] == 29
+        True
+        """
+        n = int(n)
+        # `num` is even at any point in the function.
+        # This satisfies the condition required by `self._primerange`.
+        num = self._list[-1] + 1
+        if n < num:
+            return
+        num2 = num**2
+        while num2 <= n:
+            self._list += _array('L', self._primerange(num, num2))
+            num, num2 = num2, num2**2
+        # Merge the sieves
+        self._list += _array('L', self._primerange(num, n + 1))
+
+    def _primerange(self, a, b):
+        """ Generate all prime numbers in the range (a, b).
+
+        Parameters
+        ==========
+
+        a, b : positive integers assuming the following conditions
+                * a is an even number
+                * 2 < self._list[-1] < a < b < nextprime(self._list[-1])**2
+
+        Yields
+        ======
+
+        p (int): prime numbers such that ``a < p < b``
+
+        Examples
+        ========
+
+        >>> from sympy.ntheory.generate import Sieve
+        >>> s = Sieve()
+        >>> s._list[-1]
+        13
+        >>> list(s._primerange(18, 31))
+        [19, 23, 29]
+
+        """
+        if b % 2:
+            b -= 1
+        while a < b:
+            block_size = min(self.sieve_interval, (b - a) // 2)
+            # Create the list such that block[x] iff (a + 2x + 1) is prime.
+            # Note that even numbers are not considered here.
+            block = [True] * block_size
+            for p in self._list[1:bisect(self._list, sqrt(a + 2 * block_size + 1))]:
+                for t in range((-(a + 1 + p) // 2) % p, block_size, p):
+                    block[t] = False
+            for idx, p in enumerate(block):
+                if p:
+                    yield a + 2 * idx + 1
+            a += 2 * block_size
+
+    def extend_to_no(self, i):
+        """Extend to include the ith prime number.
+
+        Parameters
+        ==========
+
+        i : integer
+
+        Examples
+        ========
+
+        >>> from sympy import sieve
+        >>> sieve._reset() # this line for doctest only
+        >>> sieve.extend_to_no(9)
+        >>> sieve._list
+        array('L', [2, 3, 5, 7, 11, 13, 17, 19, 23])
+
+        Notes
+        =====
+
+        The list is extended by 50% if it is too short, so it is
+        likely that it will be longer than requested.
+        """
+        i = as_int(i)
+        while len(self._list) < i:
+            self.extend(int(self._list[-1] * 1.5))
+
+    def primerange(self, a, b=None):
+        """Generate all prime numbers in the range [2, a) or [a, b).
+
+        Examples
+        ========
+
+        >>> from sympy import sieve, prime
+
+        All primes less than 19:
+
+        >>> print([i for i in sieve.primerange(19)])
+        [2, 3, 5, 7, 11, 13, 17]
+
+        All primes greater than or equal to 7 and less than 19:
+
+        >>> print([i for i in sieve.primerange(7, 19)])
+        [7, 11, 13, 17]
+
+        All primes through the 10th prime
+
+        >>> list(sieve.primerange(prime(10) + 1))
+        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+
+        """
+        if b is None:
+            b = _as_int_ceiling(a)
+            a = 2
+        else:
+            a = max(2, _as_int_ceiling(a))
+            b = _as_int_ceiling(b)
+        if a >= b:
+            return
+        self.extend(b)
+        yield from self._list[bisect_left(self._list, a):
+                              bisect_left(self._list, b)]
+
+    def totientrange(self, a, b):
+        """Generate all totient numbers for the range [a, b).
+
+        Examples
+        ========
+
+        >>> from sympy import sieve
+        >>> print([i for i in sieve.totientrange(7, 18)])
+        [6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16]
+        """
+        a = max(1, _as_int_ceiling(a))
+        b = _as_int_ceiling(b)
+        n = len(self._tlist)
+        if a >= b:
+            return
+        elif b <= n:
+            for i in range(a, b):
+                yield self._tlist[i]
+        else:
+            self._tlist += _array('L', range(n, b))
+            for i in range(1, n):
+                ti = self._tlist[i]
+                if ti == i - 1:
+                    startindex = (n + i - 1) // i * i
+                    for j in range(startindex, b, i):
+                        self._tlist[j] -= self._tlist[j] // i
+                if i >= a:
+                    yield ti
+
+            for i in range(n, b):
+                ti = self._tlist[i]
+                if ti == i:
+                    for j in range(i, b, i):
+                        self._tlist[j] -= self._tlist[j] // i
+                if i >= a:
+                    yield self._tlist[i]
+
+    def mobiusrange(self, a, b):
+        """Generate all mobius numbers for the range [a, b).
+
+        Parameters
+        ==========
+
+        a : integer
+            First number in range
+
+        b : integer
+            First number outside of range
+
+        Examples
+        ========
+
+        >>> from sympy import sieve
+        >>> print([i for i in sieve.mobiusrange(7, 18)])
+        [-1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1]
+        """
+        a = max(1, _as_int_ceiling(a))
+        b = _as_int_ceiling(b)
+        n = len(self._mlist)
+        if a >= b:
+            return
+        elif b <= n:
+            for i in range(a, b):
+                yield self._mlist[i]
+        else:
+            self._mlist += _array('i', [0]*(b - n))
+            for i in range(1, n):
+                mi = self._mlist[i]
+                startindex = (n + i - 1) // i * i
+                for j in range(startindex, b, i):
+                    self._mlist[j] -= mi
+                if i >= a:
+                    yield mi
+
+            for i in range(n, b):
+                mi = self._mlist[i]
+                for j in range(2 * i, b, i):
+                    self._mlist[j] -= mi
+                if i >= a:
+                    yield mi
+
+    def search(self, n):
+        """Return the indices i, j of the primes that bound n.
+
+        If n is prime then i == j.
+
+        Although n can be an expression, if ceiling cannot convert
+        it to an integer then an n error will be raised.
+
+        Examples
+        ========
+
+        >>> from sympy import sieve
+        >>> sieve.search(25)
+        (9, 10)
+        >>> sieve.search(23)
+        (9, 9)
+        """
+        test = _as_int_ceiling(n)
+        n = as_int(n)
+        if n < 2:
+            raise ValueError("n should be >= 2 but got: %s" % n)
+        if n > self._list[-1]:
+            self.extend(n)
+        b = bisect(self._list, n)
+        if self._list[b - 1] == test:
+            return b, b
+        else:
+            return b, b + 1
+
+    def __contains__(self, n):
+        try:
+            n = as_int(n)
+            assert n >= 2
+        except (ValueError, AssertionError):
+            return False
+        if n % 2 == 0:
+            return n == 2
+        a, b = self.search(n)
+        return a == b
+
+    def __iter__(self):
+        for n in count(1):
+            yield self[n]
+
+    def __getitem__(self, n):
+        """Return the nth prime number"""
+        if isinstance(n, slice):
+            self.extend_to_no(n.stop)
+            # Python 2.7 slices have 0 instead of None for start, so
+            # we can't default to 1.
+            start = n.start if n.start is not None else 0
+            if start < 1:
+                # sieve[:5] would be empty (starting at -1), let's
+                # just be explicit and raise.
+                raise IndexError("Sieve indices start at 1.")
+            return self._list[start - 1:n.stop - 1:n.step]
+        else:
+            if n < 1:
+                # offset is one, so forbid explicit access to sieve[0]
+                # (would surprisingly return the last one).
+                raise IndexError("Sieve indices start at 1.")
+            n = as_int(n)
+            self.extend_to_no(n)
+            return self._list[n - 1]
+
+# Generate a global object for repeated use in trial division etc
+sieve = Sieve()
+
+
+def prime(nth):
+    r""" Return the nth prime, with the primes indexed as prime(1) = 2,
+        prime(2) = 3, etc.... The nth prime is approximately $n\log(n)$.
+
+        Logarithmic integral of $x$ is a pretty nice approximation for number of
+        primes $\le x$, i.e.
+        li(x) ~ pi(x)
+        In fact, for the numbers we are concerned about( x<1e11 ),
+        li(x) - pi(x) < 50000
+
+        Also,
+        li(x) > pi(x) can be safely assumed for the numbers which
+        can be evaluated by this function.
+
+        Here, we find the least integer m such that li(m) > n using binary search.
+        Now pi(m-1) < li(m-1) <= n,
+
+        We find pi(m - 1) using primepi function.
+
+        Starting from m, we have to find n - pi(m-1) more primes.
+
+        For the inputs this implementation can handle, we will have to test
+        primality for at max about 10**5 numbers, to get our answer.
+
+        Examples
+        ========
+
+        >>> from sympy import prime
+        >>> prime(10)
+        29
+        >>> prime(1)
+        2
+        >>> prime(100000)
+        1299709
+
+        See Also
+        ========
+
+        sympy.ntheory.primetest.isprime : Test if n is prime
+        primerange : Generate all primes in a given range
+        primepi : Return the number of primes less than or equal to n
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Prime_number_theorem#Table_of_.CF.80.28x.29.2C_x_.2F_log_x.2C_and_li.28x.29
+        .. [2] https://en.wikipedia.org/wiki/Prime_number_theorem#Approximations_for_the_nth_prime_number
+        .. [3] https://en.wikipedia.org/wiki/Skewes%27_number
+    """
+    n = as_int(nth)
+    if n < 1:
+        raise ValueError("nth must be a positive integer; prime(1) == 2")
+    if n <= len(sieve._list):
+        return sieve[n]
+
+    from sympy.functions.elementary.exponential import log
+    from sympy.functions.special.error_functions import li
+    a = 2 # Lower bound for binary search
+    # leave n inside int since int(i*r) != i*int(r) is not a valid property
+    # e.g. int(2*.5) != 2*int(.5)
+    b = int(n*(log(n) + log(log(n)))) # Upper bound for the search.
+
+    while a < b:
+        mid = (a + b) >> 1
+        if li(mid) > n:
+            b = mid
+        else:
+            a = mid + 1
+    n_primes = _primepi(a - 1)
+    while n_primes < n:
+        if isprime(a):
+            n_primes += 1
+        a += 1
+    return a - 1
+
+@deprecated("""\
+The `sympy.ntheory.generate.primepi` has been moved to `sympy.functions.combinatorial.numbers.primepi`.""",
+deprecated_since_version="1.13",
+active_deprecations_target='deprecated-ntheory-symbolic-functions')
+def primepi(n):
+    r""" Represents the prime counting function pi(n) = the number
+        of prime numbers less than or equal to n.
+
+        .. deprecated:: 1.13
+
+            The ``primepi`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.primepi`
+            instead. See its documentation for more information. See
+            :ref:`deprecated-ntheory-symbolic-functions` for details.
+
+        Algorithm Description:
+
+        In sieve method, we remove all multiples of prime p
+        except p itself.
+
+        Let phi(i,j) be the number of integers 2 <= k <= i
+        which remain after sieving from primes less than
+        or equal to j.
+        Clearly, pi(n) = phi(n, sqrt(n))
+
+        If j is not a prime,
+        phi(i,j) = phi(i, j - 1)
+
+        if j is a prime,
+        We remove all numbers(except j) whose
+        smallest prime factor is j.
+
+        Let $x= j \times a$ be such a number, where $2 \le a \le i / j$
+        Now, after sieving from primes $\le j - 1$,
+        a must remain
+        (because x, and hence a has no prime factor $\le j - 1$)
+        Clearly, there are phi(i / j, j - 1) such a
+        which remain on sieving from primes $\le j - 1$
+
+        Now, if a is a prime less than equal to j - 1,
+        $x= j \times a$ has smallest prime factor = a, and
+        has already been removed(by sieving from a).
+        So, we do not need to remove it again.
+        (Note: there will be pi(j - 1) such x)
+
+        Thus, number of x, that will be removed are:
+        phi(i / j, j - 1) - phi(j - 1, j - 1)
+        (Note that pi(j - 1) = phi(j - 1, j - 1))
+
+        $\Rightarrow$ phi(i,j) = phi(i, j - 1) - phi(i / j, j - 1) + phi(j - 1, j - 1)
+
+        So,following recursion is used and implemented as dp:
+
+        phi(a, b) = phi(a, b - 1), if b is not a prime
+        phi(a, b) = phi(a, b-1)-phi(a / b, b-1) + phi(b-1, b-1), if b is prime
+
+        Clearly a is always of the form floor(n / k),
+        which can take at most $2\sqrt{n}$ values.
+        Two arrays arr1,arr2 are maintained
+        arr1[i] = phi(i, j),
+        arr2[i] = phi(n // i, j)
+
+        Finally the answer is arr2[1]
+
+        Examples
+        ========
+
+        >>> from sympy import primepi, prime, prevprime, isprime
+        >>> primepi(25)
+        9
+
+        So there are 9 primes less than or equal to 25. Is 25 prime?
+
+        >>> isprime(25)
+        False
+
+        It is not. So the first prime less than 25 must be the
+        9th prime:
+
+        >>> prevprime(25) == prime(9)
+        True
+
+        See Also
+        ========
+
+        sympy.ntheory.primetest.isprime : Test if n is prime
+        primerange : Generate all primes in a given range
+        prime : Return the nth prime
+    """
+    from sympy.functions.combinatorial.numbers import primepi as func_primepi
+    return func_primepi(n)
+
+
+def _primepi(n:int) -> int:
+    r""" Represents the prime counting function pi(n) = the number
+    of prime numbers less than or equal to n.
+
+    Explanation
+    ===========
+
+    In sieve method, we remove all multiples of prime p
+    except p itself.
+
+    Let phi(i,j) be the number of integers 2 <= k <= i
+    which remain after sieving from primes less than
+    or equal to j.
+    Clearly, pi(n) = phi(n, sqrt(n))
+
+    If j is not a prime,
+    phi(i,j) = phi(i, j - 1)
+
+    if j is a prime,
+    We remove all numbers(except j) whose
+    smallest prime factor is j.
+
+    Let $x= j \times a$ be such a number, where $2 \le a \le i / j$
+    Now, after sieving from primes $\le j - 1$,
+    a must remain
+    (because x, and hence a has no prime factor $\le j - 1$)
+    Clearly, there are phi(i / j, j - 1) such a
+    which remain on sieving from primes $\le j - 1$
+
+    Now, if a is a prime less than equal to j - 1,
+    $x= j \times a$ has smallest prime factor = a, and
+    has already been removed(by sieving from a).
+    So, we do not need to remove it again.
+    (Note: there will be pi(j - 1) such x)
+
+    Thus, number of x, that will be removed are:
+    phi(i / j, j - 1) - phi(j - 1, j - 1)
+    (Note that pi(j - 1) = phi(j - 1, j - 1))
+
+    $\Rightarrow$ phi(i,j) = phi(i, j - 1) - phi(i / j, j - 1) + phi(j - 1, j - 1)
+
+    So,following recursion is used and implemented as dp:
+
+    phi(a, b) = phi(a, b - 1), if b is not a prime
+    phi(a, b) = phi(a, b-1)-phi(a / b, b-1) + phi(b-1, b-1), if b is prime
+
+    Clearly a is always of the form floor(n / k),
+    which can take at most $2\sqrt{n}$ values.
+    Two arrays arr1,arr2 are maintained
+    arr1[i] = phi(i, j),
+    arr2[i] = phi(n // i, j)
+
+    Finally the answer is arr2[1]
+
+    Parameters
+    ==========
+
+    n : int
+
+    """
+    if n < 2:
+        return 0
+    if n <= sieve._list[-1]:
+        return sieve.search(n)[0]
+    lim = sqrt(n)
+    arr1 = [0] * (lim + 1)
+    arr2 = [0] * (lim + 1)
+    for i in range(1, lim + 1):
+        arr1[i] = i - 1
+        arr2[i] = n // i - 1
+    for i in range(2, lim + 1):
+        # Presently, arr1[k]=phi(k,i - 1),
+        # arr2[k] = phi(n // k,i - 1)
+        if arr1[i] == arr1[i - 1]:
+            continue
+        p = arr1[i - 1]
+        for j in range(1, min(n // (i * i), lim) + 1):
+            st = i * j
+            if st <= lim:
+                arr2[j] -= arr2[st] - p
+            else:
+                arr2[j] -= arr1[n // st] - p
+        lim2 = min(lim, i * i - 1)
+        for j in range(lim, lim2, -1):
+            arr1[j] -= arr1[j // i] - p
+    return arr2[1]
+
+
+def nextprime(n, ith=1):
+    """ Return the ith prime greater than n.
+
+        Parameters
+        ==========
+
+        n : integer
+        ith : positive integer
+
+        Returns
+        =======
+
+        int : Return the ith prime greater than n
+
+        Raises
+        ======
+
+        ValueError
+            If ``ith <= 0``.
+            If ``n`` or ``ith`` is not an integer.
+
+        Notes
+        =====
+
+        Potential primes are located at 6*j +/- 1. This
+        property is used during searching.
+
+        >>> from sympy import nextprime
+        >>> [(i, nextprime(i)) for i in range(10, 15)]
+        [(10, 11), (11, 13), (12, 13), (13, 17), (14, 17)]
+        >>> nextprime(2, ith=2) # the 2nd prime after 2
+        5
+
+        See Also
+        ========
+
+        prevprime : Return the largest prime smaller than n
+        primerange : Generate all primes in a given range
+
+    """
+    n = int(n)
+    i = as_int(ith)
+    if i <= 0:
+        raise ValueError("ith should be positive")
+    if n < 2:
+        n = 2
+        i -= 1
+    if n <= sieve._list[-2]:
+        l, _ = sieve.search(n)
+        if l + i - 1 < len(sieve._list):
+            return sieve._list[l + i - 1]
+        return nextprime(sieve._list[-1], l + i - len(sieve._list))
+    if 1 < i:
+        for _ in range(i):
+            n = nextprime(n)
+        return n
+    nn = 6*(n//6)
+    if nn == n:
+        n += 1
+        if isprime(n):
+            return n
+        n += 4
+    elif n - nn == 5:
+        n += 2
+        if isprime(n):
+            return n
+        n += 4
+    else:
+        n = nn + 5
+    while 1:
+        if isprime(n):
+            return n
+        n += 2
+        if isprime(n):
+            return n
+        n += 4
+
+
+def prevprime(n):
+    """ Return the largest prime smaller than n.
+
+        Notes
+        =====
+
+        Potential primes are located at 6*j +/- 1. This
+        property is used during searching.
+
+        >>> from sympy import prevprime
+        >>> [(i, prevprime(i)) for i in range(10, 15)]
+        [(10, 7), (11, 7), (12, 11), (13, 11), (14, 13)]
+
+        See Also
+        ========
+
+        nextprime : Return the ith prime greater than n
+        primerange : Generates all primes in a given range
+    """
+    n = _as_int_ceiling(n)
+    if n < 3:
+        raise ValueError("no preceding primes")
+    if n < 8:
+        return {3: 2, 4: 3, 5: 3, 6: 5, 7: 5}[n]
+    if n <= sieve._list[-1]:
+        l, u = sieve.search(n)
+        if l == u:
+            return sieve[l-1]
+        else:
+            return sieve[l]
+    nn = 6*(n//6)
+    if n - nn <= 1:
+        n = nn - 1
+        if isprime(n):
+            return n
+        n -= 4
+    else:
+        n = nn + 1
+    while 1:
+        if isprime(n):
+            return n
+        n -= 2
+        if isprime(n):
+            return n
+        n -= 4
+
+
+def primerange(a, b=None):
+    """ Generate a list of all prime numbers in the range [2, a),
+        or [a, b).
+
+        If the range exists in the default sieve, the values will
+        be returned from there; otherwise values will be returned
+        but will not modify the sieve.
+
+        Examples
+        ========
+
+        >>> from sympy import primerange, prime
+
+        All primes less than 19:
+
+        >>> list(primerange(19))
+        [2, 3, 5, 7, 11, 13, 17]
+
+        All primes greater than or equal to 7 and less than 19:
+
+        >>> list(primerange(7, 19))
+        [7, 11, 13, 17]
+
+        All primes through the 10th prime
+
+        >>> list(primerange(prime(10) + 1))
+        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+
+        The Sieve method, primerange, is generally faster but it will
+        occupy more memory as the sieve stores values. The default
+        instance of Sieve, named sieve, can be used:
+
+        >>> from sympy import sieve
+        >>> list(sieve.primerange(1, 30))
+        [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+
+        Notes
+        =====
+
+        Some famous conjectures about the occurrence of primes in a given
+        range are [1]:
+
+        - Twin primes: though often not, the following will give 2 primes
+                    an infinite number of times:
+                        primerange(6*n - 1, 6*n + 2)
+        - Legendre's: the following always yields at least one prime
+                        primerange(n**2, (n+1)**2+1)
+        - Bertrand's (proven): there is always a prime in the range
+                        primerange(n, 2*n)
+        - Brocard's: there are at least four primes in the range
+                        primerange(prime(n)**2, prime(n+1)**2)
+
+        The average gap between primes is log(n) [2]; the gap between
+        primes can be arbitrarily large since sequences of composite
+        numbers are arbitrarily large, e.g. the numbers in the sequence
+        n! + 2, n! + 3 ... n! + n are all composite.
+
+        See Also
+        ========
+
+        prime : Return the nth prime
+        nextprime : Return the ith prime greater than n
+        prevprime : Return the largest prime smaller than n
+        randprime : Returns a random prime in a given range
+        primorial : Returns the product of primes based on condition
+        Sieve.primerange : return range from already computed primes
+                           or extend the sieve to contain the requested
+                           range.
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Prime_number
+        .. [2] https://primes.utm.edu/notes/gaps.html
+    """
+    if b is None:
+        a, b = 2, a
+    if a >= b:
+        return
+    # If we already have the range, return it.
+    largest_known_prime = sieve._list[-1]
+    if b <= largest_known_prime:
+        yield from sieve.primerange(a, b)
+        return
+    # If we know some of it, return it.
+    if a <= largest_known_prime:
+        yield from sieve._list[bisect_left(sieve._list, a):]
+        a = largest_known_prime + 1
+    elif a % 2:
+        a -= 1
+    tail = min(b, (largest_known_prime)**2)
+    if a < tail:
+        yield from sieve._primerange(a, tail)
+        a = tail
+    if b <= a:
+        return
+    # otherwise compute, without storing, the desired range.
+    while 1:
+        a = nextprime(a)
+        if a < b:
+            yield a
+        else:
+            return
+
+
+def randprime(a, b):
+    """ Return a random prime number in the range [a, b).
+
+        Bertrand's postulate assures that
+        randprime(a, 2*a) will always succeed for a > 1.
+
+        Note that due to implementation difficulties,
+        the prime numbers chosen are not uniformly random.
+        For example, there are two primes in the range [112, 128),
+        ``113`` and ``127``, but ``randprime(112, 128)`` returns ``127``
+        with a probability of 15/17.
+
+        Examples
+        ========
+
+        >>> from sympy import randprime, isprime
+        >>> randprime(1, 30) #doctest: +SKIP
+        13
+        >>> isprime(randprime(1, 30))
+        True
+
+        See Also
+        ========
+
+        primerange : Generate all primes in a given range
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Bertrand's_postulate
+
+    """
+    if a >= b:
+        return
+    a, b = map(int, (a, b))
+    n = randint(a - 1, b)
+    p = nextprime(n)
+    if p >= b:
+        p = prevprime(b)
+    if p < a:
+        raise ValueError("no primes exist in the specified range")
+    return p
+
+
+def primorial(n, nth=True):
+    """
+    Returns the product of the first n primes (default) or
+    the primes less than or equal to n (when ``nth=False``).
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.generate import primorial, primerange
+    >>> from sympy import factorint, Mul, primefactors, sqrt
+    >>> primorial(4) # the first 4 primes are 2, 3, 5, 7
+    210
+    >>> primorial(4, nth=False) # primes <= 4 are 2 and 3
+    6
+    >>> primorial(1)
+    2
+    >>> primorial(1, nth=False)
+    1
+    >>> primorial(sqrt(101), nth=False)
+    210
+
+    One can argue that the primes are infinite since if you take
+    a set of primes and multiply them together (e.g. the primorial) and
+    then add or subtract 1, the result cannot be divided by any of the
+    original factors, hence either 1 or more new primes must divide this
+    product of primes.
+
+    In this case, the number itself is a new prime:
+
+    >>> factorint(primorial(4) + 1)
+    {211: 1}
+
+    In this case two new primes are the factors:
+
+    >>> factorint(primorial(4) - 1)
+    {11: 1, 19: 1}
+
+    Here, some primes smaller and larger than the primes multiplied together
+    are obtained:
+
+    >>> p = list(primerange(10, 20))
+    >>> sorted(set(primefactors(Mul(*p) + 1)).difference(set(p)))
+    [2, 5, 31, 149]
+
+    See Also
+    ========
+
+    primerange : Generate all primes in a given range
+
+    """
+    if nth:
+        n = as_int(n)
+    else:
+        n = int(n)
+    if n < 1:
+        raise ValueError("primorial argument must be >= 1")
+    p = 1
+    if nth:
+        for i in range(1, n + 1):
+            p *= prime(i)
+    else:
+        for i in primerange(2, n + 1):
+            p *= i
+    return p
+
+
+def cycle_length(f, x0, nmax=None, values=False):
+    """For a given iterated sequence, return a generator that gives
+    the length of the iterated cycle (lambda) and the length of terms
+    before the cycle begins (mu); if ``values`` is True then the
+    terms of the sequence will be returned instead. The sequence is
+    started with value ``x0``.
+
+    Note: more than the first lambda + mu terms may be returned and this
+    is the cost of cycle detection with Brent's method; there are, however,
+    generally less terms calculated than would have been calculated if the
+    proper ending point were determined, e.g. by using Floyd's method.
+
+    >>> from sympy.ntheory.generate import cycle_length
+
+    This will yield successive values of i <-- func(i):
+
+        >>> def gen(func, i):
+        ...     while 1:
+        ...         yield i
+        ...         i = func(i)
+        ...
+
+    A function is defined:
+
+        >>> func = lambda i: (i**2 + 1) % 51
+
+    and given a seed of 4 and the mu and lambda terms calculated:
+
+        >>> next(cycle_length(func, 4))
+        (6, 3)
+
+    We can see what is meant by looking at the output:
+
+        >>> iter = cycle_length(func, 4, values=True)
+        >>> list(iter)
+        [4, 17, 35, 2, 5, 26, 14, 44, 50, 2, 5, 26, 14]
+
+    There are 6 repeating values after the first 3.
+
+    If a sequence is suspected of being longer than you might wish, ``nmax``
+    can be used to exit early (and mu will be returned as None):
+
+        >>> next(cycle_length(func, 4, nmax = 4))
+        (4, None)
+        >>> list(cycle_length(func, 4, nmax = 4, values=True))
+        [4, 17, 35, 2]
+
+    Code modified from:
+        https://en.wikipedia.org/wiki/Cycle_detection.
+    """
+
+    nmax = int(nmax or 0)
+
+    # main phase: search successive powers of two
+    power = lam = 1
+    tortoise, hare = x0, f(x0)  # f(x0) is the element/node next to x0.
+    i = 1
+    if values:
+        yield tortoise
+    while tortoise != hare and (not nmax or i < nmax):
+        i += 1
+        if power == lam:   # time to start a new power of two?
+            tortoise = hare
+            power *= 2
+            lam = 0
+        if values:
+            yield hare
+        hare = f(hare)
+        lam += 1
+    if nmax and i == nmax:
+        if values:
+            return
+        else:
+            yield nmax, None
+            return
+    if not values:
+        # Find the position of the first repetition of length lambda
+        mu = 0
+        tortoise = hare = x0
+        for i in range(lam):
+            hare = f(hare)
+        while tortoise != hare:
+            tortoise = f(tortoise)
+            hare = f(hare)
+            mu += 1
+        yield lam, mu
+
+
+def composite(nth):
+    """ Return the nth composite number, with the composite numbers indexed as
+        composite(1) = 4, composite(2) = 6, etc....
+
+        Examples
+        ========
+
+        >>> from sympy import composite
+        >>> composite(36)
+        52
+        >>> composite(1)
+        4
+        >>> composite(17737)
+        20000
+
+        See Also
+        ========
+
+        sympy.ntheory.primetest.isprime : Test if n is prime
+        primerange : Generate all primes in a given range
+        primepi : Return the number of primes less than or equal to n
+        prime : Return the nth prime
+        compositepi : Return the number of positive composite numbers less than or equal to n
+    """
+    n = as_int(nth)
+    if n < 1:
+        raise ValueError("nth must be a positive integer; composite(1) == 4")
+    composite_arr = [4, 6, 8, 9, 10, 12, 14, 15, 16, 18]
+    if n <= 10:
+        return composite_arr[n - 1]
+
+    a, b = 4, sieve._list[-1]
+    if n <= b - _primepi(b) - 1:
+        while a < b - 1:
+            mid = (a + b) >> 1
+            if mid - _primepi(mid) - 1 > n:
+                b = mid
+            else:
+                a = mid
+        if isprime(a):
+            a -= 1
+        return a
+
+    from sympy.functions.elementary.exponential import log
+    from sympy.functions.special.error_functions import li
+    a = 4 # Lower bound for binary search
+    b = int(n*(log(n) + log(log(n)))) # Upper bound for the search.
+
+    while a < b:
+        mid = (a + b) >> 1
+        if mid - li(mid) - 1 > n:
+            b = mid
+        else:
+            a = mid + 1
+
+    n_composites = a - _primepi(a) - 1
+    while n_composites > n:
+        if not isprime(a):
+            n_composites -= 1
+        a -= 1
+    if isprime(a):
+        a -= 1
+    return a
+
+
+def compositepi(n):
+    """ Return the number of positive composite numbers less than or equal to n.
+        The first positive composite is 4, i.e. compositepi(4) = 1.
+
+        Examples
+        ========
+
+        >>> from sympy import compositepi
+        >>> compositepi(25)
+        15
+        >>> compositepi(1000)
+        831
+
+        See Also
+        ========
+
+        sympy.ntheory.primetest.isprime : Test if n is prime
+        primerange : Generate all primes in a given range
+        prime : Return the nth prime
+        primepi : Return the number of primes less than or equal to n
+        composite : Return the nth composite number
+    """
+    n = int(n)
+    if n < 4:
+        return 0
+    return n - _primepi(n) - 1

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/primetest.py

@@ -0,0 +1,793 @@
+"""
+Primality testing
+
+"""
+
+from itertools import count
+
+from sympy.core.sympify import sympify
+from sympy.external.gmpy import (gmpy as _gmpy, gcd, jacobi,
+                                 is_square as gmpy_is_square,
+                                 bit_scan1, is_fermat_prp, is_euler_prp,
+                                 is_selfridge_prp, is_strong_selfridge_prp,
+                                 is_strong_bpsw_prp)
+from sympy.external.ntheory import _lucas_sequence
+from sympy.utilities.misc import as_int, filldedent
+
+# Note: This list should be updated whenever new Mersenne primes are found.
+# Refer: https://www.mersenne.org/
+MERSENNE_PRIME_EXPONENTS = (2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, 2203,
+ 2281, 3217, 4253, 4423, 9689, 9941, 11213, 19937, 21701, 23209, 44497, 86243, 110503, 132049,
+ 216091, 756839, 859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, 20996011, 24036583,
+ 25964951, 30402457, 32582657, 37156667, 42643801, 43112609, 57885161, 74207281, 77232917, 82589933)
+
+
+def is_fermat_pseudoprime(n, a):
+    r"""Returns True if ``n`` is prime or is an odd composite integer that
+    is coprime to ``a`` and satisfy the modular arithmetic congruence relation:
+
+    .. math ::
+        a^{n-1} \equiv 1 \pmod{n}
+
+    (where mod refers to the modulo operation).
+
+    Parameters
+    ==========
+
+    n : Integer
+        ``n`` is a positive integer.
+    a : Integer
+        ``a`` is a positive integer.
+        ``a`` and ``n`` should be relatively prime.
+
+    Returns
+    =======
+
+    bool : If ``n`` is prime, it always returns ``True``.
+           The composite number that returns ``True`` is called an Fermat pseudoprime.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import is_fermat_pseudoprime
+    >>> from sympy.ntheory.factor_ import isprime
+    >>> for n in range(1, 1000):
+    ...     if is_fermat_pseudoprime(n, 2) and not isprime(n):
+    ...         print(n)
+    341
+    561
+    645
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fermat_pseudoprime
+    """
+    n, a = as_int(n), as_int(a)
+    if a == 1:
+        return n == 2 or bool(n % 2)
+    return is_fermat_prp(n, a)
+
+
+def is_euler_pseudoprime(n, a):
+    r"""Returns True if ``n`` is prime or is an odd composite integer that
+    is coprime to ``a`` and satisfy the modular arithmetic congruence relation:
+
+    .. math ::
+        a^{(n-1)/2} \equiv \pm 1 \pmod{n}
+
+    (where mod refers to the modulo operation).
+
+    Parameters
+    ==========
+
+    n : Integer
+        ``n`` is a positive integer.
+    a : Integer
+        ``a`` is a positive integer.
+        ``a`` and ``n`` should be relatively prime.
+
+    Returns
+    =======
+
+    bool : If ``n`` is prime, it always returns ``True``.
+           The composite number that returns ``True`` is called an Euler pseudoprime.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import is_euler_pseudoprime
+    >>> from sympy.ntheory.factor_ import isprime
+    >>> for n in range(1, 1000):
+    ...     if is_euler_pseudoprime(n, 2) and not isprime(n):
+    ...         print(n)
+    341
+    561
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler_pseudoprime
+    """
+    n, a = as_int(n), as_int(a)
+    if a < 1:
+        raise ValueError("a should be an integer greater than 0")
+    if n < 1:
+        raise ValueError("n should be an integer greater than 0")
+    if n == 1:
+        return False
+    if a == 1:
+        return n == 2 or bool(n % 2)  # (prime or odd composite)
+    if n % 2 == 0:
+        return n == 2
+    if gcd(n, a) != 1:
+        raise ValueError("The two numbers should be relatively prime")
+    return pow(a, (n - 1) // 2, n) in [1, n - 1]
+
+
+def is_euler_jacobi_pseudoprime(n, a):
+    r"""Returns True if ``n`` is prime or is an odd composite integer that
+    is coprime to ``a`` and satisfy the modular arithmetic congruence relation:
+
+    .. math ::
+        a^{(n-1)/2} \equiv \left(\frac{a}{n}\right) \pmod{n}
+
+    (where mod refers to the modulo operation).
+
+    Parameters
+    ==========
+
+    n : Integer
+        ``n`` is a positive integer.
+    a : Integer
+        ``a`` is a positive integer.
+        ``a`` and ``n`` should be relatively prime.
+
+    Returns
+    =======
+
+    bool : If ``n`` is prime, it always returns ``True``.
+           The composite number that returns ``True`` is called an Euler-Jacobi pseudoprime.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import is_euler_jacobi_pseudoprime
+    >>> from sympy.ntheory.factor_ import isprime
+    >>> for n in range(1, 1000):
+    ...     if is_euler_jacobi_pseudoprime(n, 2) and not isprime(n):
+    ...         print(n)
+    561
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Jacobi_pseudoprime
+    """
+    n, a = as_int(n), as_int(a)
+    if a == 1:
+        return n == 2 or bool(n % 2)
+    return is_euler_prp(n, a)
+
+
+def is_square(n, prep=True):
+    """Return True if n == a * a for some integer a, else False.
+    If n is suspected of *not* being a square then this is a
+    quick method of confirming that it is not.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import is_square
+    >>> is_square(25)
+    True
+    >>> is_square(2)
+    False
+
+    References
+    ==========
+
+    .. [1]  https://mersenneforum.org/showpost.php?p=110896
+
+    See Also
+    ========
+    sympy.core.intfunc.isqrt
+    """
+    if prep:
+        n = as_int(n)
+        if n < 0:
+            return False
+        if n in (0, 1):
+            return True
+    return gmpy_is_square(n)
+
+
+def _test(n, base, s, t):
+    """Miller-Rabin strong pseudoprime test for one base.
+    Return False if n is definitely composite, True if n is
+    probably prime, with a probability greater than 3/4.
+
+    """
+    # do the Fermat test
+    b = pow(base, t, n)
+    if b == 1 or b == n - 1:
+        return True
+    for _ in range(s - 1):
+        b = pow(b, 2, n)
+        if b == n - 1:
+            return True
+        # see I. Niven et al. "An Introduction to Theory of Numbers", page 78
+        if b == 1:
+            return False
+    return False
+
+
+def mr(n, bases):
+    """Perform a Miller-Rabin strong pseudoprime test on n using a
+    given list of bases/witnesses.
+
+    References
+    ==========
+
+    .. [1] Richard Crandall & Carl Pomerance (2005), "Prime Numbers:
+           A Computational Perspective", Springer, 2nd edition, 135-138
+
+    A list of thresholds and the bases they require are here:
+    https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test#Deterministic_variants
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import mr
+    >>> mr(1373651, [2, 3])
+    False
+    >>> mr(479001599, [31, 73])
+    True
+
+    """
+    from sympy.polys.domains import ZZ
+
+    n = as_int(n)
+    if n < 2:
+        return False
+    # remove powers of 2 from n-1 (= t * 2**s)
+    s = bit_scan1(n - 1)
+    t = n >> s
+    for base in bases:
+        # Bases >= n are wrapped, bases < 2 are invalid
+        if base >= n:
+            base %= n
+        if base >= 2:
+            base = ZZ(base)
+            if not _test(n, base, s, t):
+                return False
+    return True
+
+
+def _lucas_extrastrong_params(n):
+    """Calculates the "extra strong" parameters (D, P, Q) for n.
+
+    Parameters
+    ==========
+
+    n : int
+        positive odd integer
+
+    Returns
+    =======
+
+    D, P, Q: "extra strong" parameters.
+             ``(0, 0, 0)`` if we find a nontrivial divisor of ``n``.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import _lucas_extrastrong_params
+    >>> _lucas_extrastrong_params(101)
+    (12, 4, 1)
+    >>> _lucas_extrastrong_params(15)
+    (0, 0, 0)
+
+    References
+    ==========
+    .. [1] OEIS A217719: Extra Strong Lucas Pseudoprimes
+           https://oeis.org/A217719
+    .. [2] https://en.wikipedia.org/wiki/Lucas_pseudoprime
+
+    """
+    for P in count(3):
+        D = P**2 - 4
+        j = jacobi(D, n)
+        if j == -1:
+            return (D, P, 1)
+        elif j == 0 and D % n:
+            return (0, 0, 0)
+
+
+def is_lucas_prp(n):
+    """Standard Lucas compositeness test with Selfridge parameters.  Returns
+    False if n is definitely composite, and True if n is a Lucas probable
+    prime.
+
+    This is typically used in combination with the Miller-Rabin test.
+
+    References
+    ==========
+    .. [1] Robert Baillie, Samuel S. Wagstaff, Lucas Pseudoprimes,
+           Math. Comp. Vol 35, Number 152 (1980), pp. 1391-1417,
+           https://doi.org/10.1090%2FS0025-5718-1980-0583518-6
+           http://mpqs.free.fr/LucasPseudoprimes.pdf
+    .. [2] OEIS A217120: Lucas Pseudoprimes
+           https://oeis.org/A217120
+    .. [3] https://en.wikipedia.org/wiki/Lucas_pseudoprime
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import isprime, is_lucas_prp
+    >>> for i in range(10000):
+    ...     if is_lucas_prp(i) and not isprime(i):
+    ...         print(i)
+    323
+    377
+    1159
+    1829
+    3827
+    5459
+    5777
+    9071
+    9179
+    """
+    n = as_int(n)
+    if n < 2:
+        return False
+    return is_selfridge_prp(n)
+
+
+def is_strong_lucas_prp(n):
+    """Strong Lucas compositeness test with Selfridge parameters.  Returns
+    False if n is definitely composite, and True if n is a strong Lucas
+    probable prime.
+
+    This is often used in combination with the Miller-Rabin test, and
+    in particular, when combined with M-R base 2 creates the strong BPSW test.
+
+    References
+    ==========
+    .. [1] Robert Baillie, Samuel S. Wagstaff, Lucas Pseudoprimes,
+           Math. Comp. Vol 35, Number 152 (1980), pp. 1391-1417,
+           https://doi.org/10.1090%2FS0025-5718-1980-0583518-6
+           http://mpqs.free.fr/LucasPseudoprimes.pdf
+    .. [2] OEIS A217255: Strong Lucas Pseudoprimes
+           https://oeis.org/A217255
+    .. [3] https://en.wikipedia.org/wiki/Lucas_pseudoprime
+    .. [4] https://en.wikipedia.org/wiki/Baillie-PSW_primality_test
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import isprime, is_strong_lucas_prp
+    >>> for i in range(20000):
+    ...     if is_strong_lucas_prp(i) and not isprime(i):
+    ...        print(i)
+    5459
+    5777
+    10877
+    16109
+    18971
+    """
+    n = as_int(n)
+    if n < 2:
+        return False
+    return is_strong_selfridge_prp(n)
+
+
+def is_extra_strong_lucas_prp(n):
+    """Extra Strong Lucas compositeness test.  Returns False if n is
+    definitely composite, and True if n is an "extra strong" Lucas probable
+    prime.
+
+    The parameters are selected using P = 3, Q = 1, then incrementing P until
+    (D|n) == -1.  The test itself is as defined in [1]_, from the
+    Mo and Jones preprint.  The parameter selection and test are the same as
+    used in OEIS A217719, Perl's Math::Prime::Util, and the Lucas pseudoprime
+    page on Wikipedia.
+
+    It is 20-50% faster than the strong test.
+
+    Because of the different parameters selected, there is no relationship
+    between the strong Lucas pseudoprimes and extra strong Lucas pseudoprimes.
+    In particular, one is not a subset of the other.
+
+    References
+    ==========
+    .. [1] Jon Grantham, Frobenius Pseudoprimes,
+           Math. Comp. Vol 70, Number 234 (2001), pp. 873-891,
+           https://doi.org/10.1090%2FS0025-5718-00-01197-2
+    .. [2] OEIS A217719: Extra Strong Lucas Pseudoprimes
+           https://oeis.org/A217719
+    .. [3] https://en.wikipedia.org/wiki/Lucas_pseudoprime
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import isprime, is_extra_strong_lucas_prp
+    >>> for i in range(20000):
+    ...     if is_extra_strong_lucas_prp(i) and not isprime(i):
+    ...        print(i)
+    989
+    3239
+    5777
+    10877
+    """
+    # Implementation notes:
+    #   1) the parameters differ from Thomas R. Nicely's.  His parameter
+    #      selection leads to pseudoprimes that overlap M-R tests, and
+    #      contradict Baillie and Wagstaff's suggestion of (D|n) = -1.
+    #   2) The MathWorld page as of June 2013 specifies Q=-1.  The Lucas
+    #      sequence must have Q=1.  See Grantham theorem 2.3, any of the
+    #      references on the MathWorld page, or run it and see Q=-1 is wrong.
+    n = as_int(n)
+    if n == 2:
+        return True
+    if n < 2 or (n % 2) == 0:
+        return False
+    if gmpy_is_square(n):
+        return False
+
+    D, P, Q = _lucas_extrastrong_params(n)
+    if D == 0:
+        return False
+
+    # remove powers of 2 from n+1 (= k * 2**s)
+    s = bit_scan1(n + 1)
+    k = (n + 1) >> s
+
+    U, V, _ = _lucas_sequence(n, P, Q, k)
+
+    if U == 0 and (V == 2 or V == n - 2):
+        return True
+    for _ in range(1, s):
+        if V == 0:
+            return True
+        V = (V*V - 2) % n
+    return False
+
+
+def proth_test(n):
+    r""" Test if the Proth number `n = k2^m + 1` is prime. where k is a positive odd number and `2^m > k`.
+
+    Parameters
+    ==========
+
+    n : Integer
+        ``n`` is Proth number
+
+    Returns
+    =======
+
+    bool : If ``True``, then ``n`` is the Proth prime
+
+    Raises
+    ======
+
+    ValueError
+        If ``n`` is not Proth number.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import proth_test
+    >>> proth_test(41)
+    True
+    >>> proth_test(57)
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Proth_prime
+
+    """
+    n = as_int(n)
+    if n < 3:
+        raise ValueError("n is not Proth number")
+    m = bit_scan1(n - 1)
+    k = n >> m
+    if m < k.bit_length():
+        raise ValueError("n is not Proth number")
+    if n % 3 == 0:
+        return n == 3
+    if k % 3: # n % 12 == 5
+        return pow(3, n >> 1, n) == n - 1
+    # If `n` is a square number, then `jacobi(a, n) = 1` for any `a`
+    if gmpy_is_square(n):
+        return False
+    # `a` may be chosen at random.
+    # In any case, we want to find `a` such that `jacobi(a, n) = -1`.
+    for a in range(5, n):
+        j = jacobi(a, n)
+        if j == -1:
+            return pow(a, n >> 1, n) == n - 1
+        if j == 0:
+            return False
+
+
+def _lucas_lehmer_primality_test(p):
+    r""" Test if the Mersenne number `M_p = 2^p-1` is prime.
+
+    Parameters
+    ==========
+
+    p : int
+        ``p`` is an odd prime number
+
+    Returns
+    =======
+
+    bool : If ``True``, then `M_p` is the Mersenne prime
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.primetest import _lucas_lehmer_primality_test
+    >>> _lucas_lehmer_primality_test(5) # 2**5 - 1 = 31 is prime
+    True
+    >>> _lucas_lehmer_primality_test(11) # 2**11 - 1 = 2047 is not prime
+    False
+
+    See Also
+    ========
+
+    is_mersenne_prime
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lucas%E2%80%93Lehmer_primality_test
+
+    """
+    v = 4
+    m = 2**p - 1
+    for _ in range(p - 2):
+        v = pow(v, 2, m) - 2
+    return v == 0
+
+
+def is_mersenne_prime(n):
+    """Returns True if  ``n`` is a Mersenne prime, else False.
+
+    A Mersenne prime is a prime number having the form `2^i - 1`.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.factor_ import is_mersenne_prime
+    >>> is_mersenne_prime(6)
+    False
+    >>> is_mersenne_prime(127)
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/MersennePrime.html
+
+    """
+    n = as_int(n)
+    if n < 1:
+        return False
+    if n & (n + 1):
+        # n is not Mersenne number
+        return False
+    p = n.bit_length()
+    if p in MERSENNE_PRIME_EXPONENTS:
+        return True
+    if p < 65_000_000 or not isprime(p):
+        # According to GIMPS, verification was completed on September 19, 2023 for p less than 65 million.
+        # https://www.mersenne.org/report_milestones/
+        # If p is composite number, then n=2**p-1 is composite number.
+        return False
+    result = _lucas_lehmer_primality_test(p)
+    if result:
+        raise ValueError(filldedent('''
+            This Mersenne Prime, 2^%s - 1, should
+            be added to SymPy's known values.''' % p))
+    return result
+
+
+def isprime(n):
+    """
+    Test if n is a prime number (True) or not (False). For n < 2^64 the
+    answer is definitive; larger n values have a small probability of actually
+    being pseudoprimes.
+
+    Negative numbers (e.g. -2) are not considered prime.
+
+    The first step is looking for trivial factors, which if found enables
+    a quick return.  Next, if the sieve is large enough, use bisection search
+    on the sieve.  For small numbers, a set of deterministic Miller-Rabin
+    tests are performed with bases that are known to have no counterexamples
+    in their range.  Finally if the number is larger than 2^64, a strong
+    BPSW test is performed.  While this is a probable prime test and we
+    believe counterexamples exist, there are no known counterexamples.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import isprime
+    >>> isprime(13)
+    True
+    >>> isprime(15)
+    False
+
+    Notes
+    =====
+
+    This routine is intended only for integer input, not numerical
+    expressions which may represent numbers. Floats are also
+    rejected as input because they represent numbers of limited
+    precision. While it is tempting to permit 7.0 to represent an
+    integer there are errors that may "pass silently" if this is
+    allowed:
+
+    >>> from sympy import Float, S
+    >>> int(1e3) == 1e3 == 10**3
+    True
+    >>> int(1e23) == 1e23
+    True
+    >>> int(1e23) == 10**23
+    False
+
+    >>> near_int = 1 + S(1)/10**19
+    >>> near_int == int(near_int)
+    False
+    >>> n = Float(near_int, 10)  # truncated by precision
+    >>> n % 1 == 0
+    True
+    >>> n = Float(near_int, 20)
+    >>> n % 1 == 0
+    False
+
+    See Also
+    ========
+
+    sympy.ntheory.generate.primerange : Generates all primes in a given range
+    sympy.functions.combinatorial.numbers.primepi : Return the number of primes less than or equal to n
+    sympy.ntheory.generate.prime : Return the nth prime
+
+    References
+    ==========
+    .. [1] https://en.wikipedia.org/wiki/Strong_pseudoprime
+    .. [2] Robert Baillie, Samuel S. Wagstaff, Lucas Pseudoprimes,
+           Math. Comp. Vol 35, Number 152 (1980), pp. 1391-1417,
+           https://doi.org/10.1090%2FS0025-5718-1980-0583518-6
+           http://mpqs.free.fr/LucasPseudoprimes.pdf
+    .. [3] https://en.wikipedia.org/wiki/Baillie-PSW_primality_test
+    """
+    n = as_int(n)
+
+    # Step 1, do quick composite testing via trial division.  The individual
+    # modulo tests benchmark faster than one or two primorial igcds for me.
+    # The point here is just to speedily handle small numbers and many
+    # composites.  Step 2 only requires that n <= 2 get handled here.
+    if n in [2, 3, 5]:
+        return True
+    if n < 2 or (n % 2) == 0 or (n % 3) == 0 or (n % 5) == 0:
+        return False
+    if n < 49:
+        return True
+    if (n %  7) == 0 or (n % 11) == 0 or (n % 13) == 0 or (n % 17) == 0 or \
+       (n % 19) == 0 or (n % 23) == 0 or (n % 29) == 0 or (n % 31) == 0 or \
+       (n % 37) == 0 or (n % 41) == 0 or (n % 43) == 0 or (n % 47) == 0:
+        return False
+    if n < 2809:
+        return True
+    if n < 65077:
+        # There are only five Euler pseudoprimes with a least prime factor greater than 47
+        return pow(2, n >> 1, n) in [1, n - 1] and n not in [8321, 31621, 42799, 49141, 49981]
+
+    # bisection search on the sieve if the sieve is large enough
+    from sympy.ntheory.generate import sieve as s
+    if n <= s._list[-1]:
+        l, u = s.search(n)
+        return l == u
+
+    # If we have GMPY2, skip straight to step 3 and do a strong BPSW test.
+    # This should be a bit faster than our step 2, and for large values will
+    # be a lot faster than our step 3 (C+GMP vs. Python).
+    if _gmpy is not None:
+        return is_strong_bpsw_prp(n)
+
+
+    # Step 2: deterministic Miller-Rabin testing for numbers < 2^64.  See:
+    #    https://miller-rabin.appspot.com/
+    # for lists.  We have made sure the M-R routine will successfully handle
+    # bases larger than n, so we can use the minimal set.
+    # In September 2015 deterministic numbers were extended to over 2^81.
+    #    https://arxiv.org/pdf/1509.00864.pdf
+    #    https://oeis.org/A014233
+    if n < 341531:
+        return mr(n, [9345883071009581737])
+    if n < 885594169:
+        return mr(n, [725270293939359937, 3569819667048198375])
+    if n < 350269456337:
+        return mr(n, [4230279247111683200, 14694767155120705706, 16641139526367750375])
+    if n < 55245642489451:
+        return mr(n, [2, 141889084524735, 1199124725622454117, 11096072698276303650])
+    if n < 7999252175582851:
+        return mr(n, [2, 4130806001517, 149795463772692060, 186635894390467037, 3967304179347715805])
+    if n < 585226005592931977:
+        return mr(n, [2, 123635709730000, 9233062284813009, 43835965440333360, 761179012939631437, 1263739024124850375])
+    if n < 18446744073709551616:
+        return mr(n, [2, 325, 9375, 28178, 450775, 9780504, 1795265022])
+    if n < 318665857834031151167461:
+        return mr(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37])
+    if n < 3317044064679887385961981:
+        return mr(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41])
+
+    # We could do this instead at any point:
+    #if n < 18446744073709551616:
+    #   return mr(n, [2]) and is_extra_strong_lucas_prp(n)
+
+    # Here are tests that are safe for MR routines that don't understand
+    # large bases.
+    #if n < 9080191:
+    #    return mr(n, [31, 73])
+    #if n < 19471033:
+    #    return mr(n, [2, 299417])
+    #if n < 38010307:
+    #    return mr(n, [2, 9332593])
+    #if n < 316349281:
+    #    return mr(n, [11000544, 31481107])
+    #if n < 4759123141:
+    #    return mr(n, [2, 7, 61])
+    #if n < 105936894253:
+    #    return mr(n, [2, 1005905886, 1340600841])
+    #if n < 31858317218647:
+    #    return mr(n, [2, 642735, 553174392, 3046413974])
+    #if n < 3071837692357849:
+    #    return mr(n, [2, 75088, 642735, 203659041, 3613982119])
+    #if n < 18446744073709551616:
+    #    return mr(n, [2, 325, 9375, 28178, 450775, 9780504, 1795265022])
+
+    # Step 3: BPSW.
+    #
+    #  Time for isprime(10**2000 + 4561), no gmpy or gmpy2 installed
+    #     44.0s   old isprime using 46 bases
+    #      5.3s   strong BPSW + one random base
+    #      4.3s   extra strong BPSW + one random base
+    #      4.1s   strong BPSW
+    #      3.2s   extra strong BPSW
+
+    # Classic BPSW from page 1401 of the paper.  See alternate ideas below.
+    return is_strong_bpsw_prp(n)
+
+    # Using extra strong test, which is somewhat faster
+    #return mr(n, [2]) and is_extra_strong_lucas_prp(n)
+
+    # Add a random M-R base
+    #import random
+    #return mr(n, [2, random.randint(3, n-1)]) and is_strong_lucas_prp(n)
+
+
+def is_gaussian_prime(num):
+    r"""Test if num is a Gaussian prime number.
+
+    References
+    ==========
+
+    .. [1] https://oeis.org/wiki/Gaussian_primes
+    """
+
+    num = sympify(num)
+    a, b = num.as_real_imag()
+    a = as_int(a, strict=False)
+    b = as_int(b, strict=False)
+    if a == 0:
+        b = abs(b)
+        return isprime(b) and b % 4 == 3
+    elif b == 0:
+        a = abs(a)
+        return isprime(a) and a % 4 == 3
+    return isprime(a**2 + b**2)

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/qs.py

@@ -0,0 +1,511 @@
+from sympy.core.random import _randint
+from sympy.external.gmpy import gcd, invert, sqrt as isqrt
+from sympy.ntheory.residue_ntheory import _sqrt_mod_prime_power
+from sympy.ntheory import isprime
+from math import log, sqrt
+
+
+class SievePolynomial:
+    def __init__(self, modified_coeff=(), a=None, b=None):
+        """This class denotes the seive polynomial.
+        If ``g(x) = (a*x + b)**2 - N``. `g(x)` can be expanded
+        to ``a*x**2 + 2*a*b*x + b**2 - N``, so the coefficient
+        is stored in the form `[a**2, 2*a*b, b**2 - N]`. This
+        ensures faster `eval` method because we dont have to
+        perform `a**2, 2*a*b, b**2` every time we call the
+        `eval` method. As multiplication is more expensive
+        than addition, by using modified_coefficient we get
+        a faster seiving process.
+
+        Parameters
+        ==========
+
+        modified_coeff : modified_coefficient of sieve polynomial
+        a : parameter of the sieve polynomial
+        b : parameter of the sieve polynomial
+        """
+        self.modified_coeff = modified_coeff
+        self.a = a
+        self.b = b
+
+    def eval(self, x):
+        """
+        Compute the value of the sieve polynomial at point x.
+
+        Parameters
+        ==========
+
+        x : Integer parameter for sieve polynomial
+        """
+        ans = 0
+        for coeff in self.modified_coeff:
+            ans *= x
+            ans += coeff
+        return ans
+
+
+class FactorBaseElem:
+    """This class stores an element of the `factor_base`.
+    """
+    def __init__(self, prime, tmem_p, log_p):
+        """
+        Initialization of factor_base_elem.
+
+        Parameters
+        ==========
+
+        prime : prime number of the factor_base
+        tmem_p : Integer square root of x**2 = n mod prime
+        log_p : Compute Natural Logarithm of the prime
+        """
+        self.prime = prime
+        self.tmem_p = tmem_p
+        self.log_p = log_p
+        self.soln1 = None
+        self.soln2 = None
+        self.a_inv = None
+        self.b_ainv = None
+
+
+def _generate_factor_base(prime_bound, n):
+    """Generate `factor_base` for Quadratic Sieve. The `factor_base`
+    consists of all the points whose ``legendre_symbol(n, p) == 1``
+    and ``p < num_primes``. Along with the prime `factor_base` also stores
+    natural logarithm of prime and the residue n modulo p.
+    It also returns the of primes numbers in the `factor_base` which are
+    close to 1000 and 5000.
+
+    Parameters
+    ==========
+
+    prime_bound : upper prime bound of the factor_base
+    n : integer to be factored
+    """
+    from sympy.ntheory.generate import sieve
+    factor_base = []
+    idx_1000, idx_5000 = None, None
+    for prime in sieve.primerange(1, prime_bound):
+        if pow(n, (prime - 1) // 2, prime) == 1:
+            if prime > 1000 and idx_1000 is None:
+                idx_1000 = len(factor_base) - 1
+            if prime > 5000 and idx_5000 is None:
+                idx_5000 = len(factor_base) - 1
+            residue = _sqrt_mod_prime_power(n, prime, 1)[0]
+            log_p = round(log(prime)*2**10)
+            factor_base.append(FactorBaseElem(prime, residue, log_p))
+    return idx_1000, idx_5000, factor_base
+
+
+def _initialize_first_polynomial(N, M, factor_base, idx_1000, idx_5000, seed=None):
+    """This step is the initialization of the 1st sieve polynomial.
+    Here `a` is selected as a product of several primes of the factor_base
+    such that `a` is about to ``sqrt(2*N) / M``. Other initial values of
+    factor_base elem are also initialized which includes a_inv, b_ainv, soln1,
+    soln2 which are used when the sieve polynomial is changed. The b_ainv
+    is required for fast polynomial change as we do not have to calculate
+    `2*b*invert(a, prime)` every time.
+    We also ensure that the `factor_base` primes which make `a` are between
+    1000 and 5000.
+
+    Parameters
+    ==========
+
+    N : Number to be factored
+    M : sieve interval
+    factor_base : factor_base primes
+    idx_1000 : index of prime number in the factor_base near 1000
+    idx_5000 : index of prime number in the factor_base near to 5000
+    seed : Generate pseudoprime numbers
+    """
+    randint = _randint(seed)
+    approx_val = sqrt(2*N) / M
+    # `a` is a parameter of the sieve polynomial and `q` is the prime factors of `a`
+    # randomly search for a combination of primes whose multiplication is close to approx_val
+    # This multiplication of primes will be `a` and the primes will be `q`
+    # `best_a` denotes that `a` is close to approx_val in the random search of combination
+    best_a, best_q, best_ratio = None, None, None
+    start = 0 if idx_1000 is None else idx_1000
+    end = len(factor_base) - 1 if idx_5000 is None else idx_5000
+    for _ in range(50):
+        a = 1
+        q = []
+        while(a < approx_val):
+            rand_p = 0
+            while(rand_p == 0 or rand_p in q):
+                rand_p = randint(start, end)
+            p = factor_base[rand_p].prime
+            a *= p
+            q.append(rand_p)
+        ratio = a / approx_val
+        if best_ratio is None or abs(ratio - 1) < abs(best_ratio - 1):
+            best_q = q
+            best_a = a
+            best_ratio = ratio
+
+    a = best_a
+    q = best_q
+
+    B = []
+    for val in q:
+        q_l = factor_base[val].prime
+        gamma = factor_base[val].tmem_p * invert(a // q_l, q_l) % q_l
+        if gamma > q_l / 2:
+            gamma = q_l - gamma
+        B.append(a//q_l*gamma)
+
+    b = sum(B)
+    g = SievePolynomial([a*a, 2*a*b, b*b - N], a, b)
+
+    for fb in factor_base:
+        if a % fb.prime == 0:
+            continue
+        fb.a_inv = invert(a, fb.prime)
+        fb.b_ainv = [2*b_elem*fb.a_inv % fb.prime for b_elem in B]
+        fb.soln1 = (fb.a_inv*(fb.tmem_p - b)) % fb.prime
+        fb.soln2 = (fb.a_inv*(-fb.tmem_p - b)) % fb.prime
+    return g, B
+
+
+def _initialize_ith_poly(N, factor_base, i, g, B):
+    """Initialization stage of ith poly. After we finish sieving 1`st polynomial
+    here we quickly change to the next polynomial from which we will again
+    start sieving. Suppose we generated ith sieve polynomial and now we
+    want to generate (i + 1)th polynomial, where ``1 <= i <= 2**(j - 1) - 1``
+    where `j` is the number of prime factors of the coefficient `a`
+    then this function can be used to go to the next polynomial. If
+    ``i = 2**(j - 1) - 1`` then go to _initialize_first_polynomial stage.
+
+    Parameters
+    ==========
+
+    N : number to be factored
+    factor_base : factor_base primes
+    i : integer denoting ith polynomial
+    g : (i - 1)th polynomial
+    B : array that stores a//q_l*gamma
+    """
+    from sympy.functions.elementary.integers import ceiling
+    v = 1
+    j = i
+    while(j % 2 == 0):
+        v += 1
+        j //= 2
+    if ceiling(i / (2**v)) % 2 == 1:
+        neg_pow = -1
+    else:
+        neg_pow = 1
+    b = g.b + 2*neg_pow*B[v - 1]
+    a = g.a
+    g = SievePolynomial([a*a, 2*a*b, b*b - N], a, b)
+    for fb in factor_base:
+        if a % fb.prime == 0:
+            continue
+        fb.soln1 = (fb.soln1 - neg_pow*fb.b_ainv[v - 1]) % fb.prime
+        fb.soln2 = (fb.soln2 - neg_pow*fb.b_ainv[v - 1]) % fb.prime
+
+    return g
+
+
+def _gen_sieve_array(M, factor_base):
+    """Sieve Stage of the Quadratic Sieve. For every prime in the factor_base
+    that does not divide the coefficient `a` we add log_p over the sieve_array
+    such that ``-M <= soln1 + i*p <=  M`` and ``-M <= soln2 + i*p <=  M`` where `i`
+    is an integer. When p = 2 then log_p is only added using
+    ``-M <= soln1 + i*p <=  M``.
+
+    Parameters
+    ==========
+
+    M : sieve interval
+    factor_base : factor_base primes
+    """
+    sieve_array = [0]*(2*M + 1)
+    for factor in factor_base:
+        if factor.soln1 is None: #The prime does not divides a
+            continue
+        for idx in range((M + factor.soln1) % factor.prime, 2*M, factor.prime):
+            sieve_array[idx] += factor.log_p
+        if factor.prime == 2:
+            continue
+        #if prime is 2 then sieve only with soln_1_p
+        for idx in range((M + factor.soln2) % factor.prime, 2*M, factor.prime):
+            sieve_array[idx] += factor.log_p
+    return sieve_array
+
+
+def _check_smoothness(num, factor_base):
+    """Here we check that if `num` is a smooth number or not. If `a` is a smooth
+    number then it returns a vector of prime exponents modulo 2. For example
+    if a = 2 * 5**2 * 7**3 and the factor base contains {2, 3, 5, 7} then
+    `a` is a smooth number and this function returns ([1, 0, 0, 1], True). If
+    `a` is a partial relation which means that `a` a has one prime factor
+    greater than the `factor_base` then it returns `(a, False)` which denotes `a`
+    is a partial relation.
+
+    Parameters
+    ==========
+
+    a : integer whose smootheness is to be checked
+    factor_base : factor_base primes
+    """
+    vec = []
+    if num < 0:
+        vec.append(1)
+        num *= -1
+    else:
+        vec.append(0)
+     #-1 is not included in factor_base add -1 in vector
+    for factor in factor_base:
+        if num % factor.prime != 0:
+            vec.append(0)
+            continue
+        factor_exp = 0
+        while num % factor.prime == 0:
+            factor_exp += 1
+            num //= factor.prime
+        vec.append(factor_exp % 2)
+    if num == 1:
+        return vec, True
+    if isprime(num):
+        return num, False
+    return None, None
+
+
+def _trial_division_stage(N, M, factor_base, sieve_array, sieve_poly, partial_relations, ERROR_TERM):
+    """Trial division stage. Here we trial divide the values generetated
+    by sieve_poly in the sieve interval and if it is a smooth number then
+    it is stored in `smooth_relations`. Moreover, if we find two partial relations
+    with same large prime then they are combined to form a smooth relation.
+    First we iterate over sieve array and look for values which are greater
+    than accumulated_val, as these values have a high chance of being smooth
+    number. Then using these values we find smooth relations.
+    In general, let ``t**2 = u*p modN`` and ``r**2 = v*p modN`` be two partial relations
+    with the same large prime p. Then they can be combined ``(t*r/p)**2 = u*v modN``
+    to form a smooth relation.
+
+    Parameters
+    ==========
+
+    N : Number to be factored
+    M : sieve interval
+    factor_base : factor_base primes
+    sieve_array : stores log_p values
+    sieve_poly : polynomial from which we find smooth relations
+    partial_relations : stores partial relations with one large prime
+    ERROR_TERM : error term for accumulated_val
+    """
+    sqrt_n = isqrt(N)
+    accumulated_val = log(M * sqrt_n)*2**10 - ERROR_TERM
+    smooth_relations = []
+    proper_factor = set()
+    partial_relation_upper_bound = 128*factor_base[-1].prime
+    for idx, val in enumerate(sieve_array):
+        if val < accumulated_val:
+            continue
+        x = idx - M
+        v = sieve_poly.eval(x)
+        vec, is_smooth = _check_smoothness(v, factor_base)
+        if is_smooth is None:#Neither smooth nor partial
+            continue
+        u = sieve_poly.a*x + sieve_poly.b
+        # Update the partial relation
+        # If 2 partial relation with same large prime is found then generate smooth relation
+        if is_smooth is False:#partial relation found
+            large_prime = vec
+            #Consider the large_primes under 128*F
+            if large_prime > partial_relation_upper_bound:
+                continue
+            if large_prime not in partial_relations:
+                partial_relations[large_prime] = (u, v)
+                continue
+            else:
+                u_prev, v_prev = partial_relations[large_prime]
+                partial_relations.pop(large_prime)
+                try:
+                    large_prime_inv = invert(large_prime, N)
+                except ZeroDivisionError:#if large_prime divides N
+                    proper_factor.add(large_prime)
+                    continue
+                u = u*u_prev*large_prime_inv
+                v = v*v_prev // (large_prime*large_prime)
+                vec, is_smooth = _check_smoothness(v, factor_base)
+        #assert u*u % N == v % N
+        smooth_relations.append((u, v, vec))
+    return smooth_relations, proper_factor
+
+
+#LINEAR ALGEBRA STAGE
+def _build_matrix(smooth_relations):
+    """Build a 2D matrix from smooth relations.
+
+    Parameters
+    ==========
+
+    smooth_relations : Stores smooth relations
+    """
+    matrix = []
+    for s_relation in smooth_relations:
+        matrix.append(s_relation[2])
+    return matrix
+
+
+def _gauss_mod_2(A):
+    """Fast gaussian reduction for modulo 2 matrix.
+
+    Parameters
+    ==========
+
+    A : Matrix
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.qs import _gauss_mod_2
+    >>> _gauss_mod_2([[0, 1, 1], [1, 0, 1], [0, 1, 0], [1, 1, 1]])
+    ([[[1, 0, 1], 3]],
+     [True, True, True, False],
+     [[0, 1, 0], [1, 0, 0], [0, 0, 1], [1, 0, 1]])
+
+    Reference
+    ==========
+
+    .. [1] A fast algorithm for gaussian elimination over GF(2) and
+    its implementation on the GAPP. Cetin K.Koc, Sarath N.Arachchige"""
+    import copy
+    matrix = copy.deepcopy(A)
+    row = len(matrix)
+    col = len(matrix[0])
+    mark = [False]*row
+    for c in range(col):
+        for r in range(row):
+            if matrix[r][c] == 1:
+                break
+        mark[r] = True
+        for c1 in range(col):
+            if c1 == c:
+                continue
+            if matrix[r][c1] == 1:
+                for r2 in range(row):
+                    matrix[r2][c1] = (matrix[r2][c1] + matrix[r2][c]) % 2
+    dependent_row = []
+    for idx, val in enumerate(mark):
+        if val == False:
+            dependent_row.append([matrix[idx], idx])
+    return dependent_row, mark, matrix
+
+
+def _find_factor(dependent_rows, mark, gauss_matrix, index, smooth_relations, N):
+    """Finds proper factor of N. Here, transform the dependent rows as a
+    combination of independent rows of the gauss_matrix to form the desired
+    relation of the form ``X**2 = Y**2 modN``. After obtaining the desired relation
+    we obtain a proper factor of N by `gcd(X - Y, N)`.
+
+    Parameters
+    ==========
+
+    dependent_rows : denoted dependent rows in the reduced matrix form
+    mark : boolean array to denoted dependent and independent rows
+    gauss_matrix : Reduced form of the smooth relations matrix
+    index : denoted the index of the dependent_rows
+    smooth_relations : Smooth relations vectors matrix
+    N : Number to be factored
+    """
+    idx_in_smooth = dependent_rows[index][1]
+    independent_u = [smooth_relations[idx_in_smooth][0]]
+    independent_v = [smooth_relations[idx_in_smooth][1]]
+    dept_row = dependent_rows[index][0]
+
+    for idx, val in enumerate(dept_row):
+        if val == 1:
+            for row in range(len(gauss_matrix)):
+                if gauss_matrix[row][idx] == 1 and mark[row] == True:
+                    independent_u.append(smooth_relations[row][0])
+                    independent_v.append(smooth_relations[row][1])
+                    break
+
+    u = 1
+    v = 1
+    for i in independent_u:
+        u *= i
+    for i in independent_v:
+        v *= i
+    #assert u**2 % N == v % N
+    v = isqrt(v)
+    return gcd(u - v, N)
+
+
+def qs(N, prime_bound, M, ERROR_TERM=25, seed=1234):
+    """Performs factorization using Self-Initializing Quadratic Sieve.
+    In SIQS, let N be a number to be factored, and this N should not be a
+    perfect power. If we find two integers such that ``X**2 = Y**2 modN`` and
+    ``X != +-Y modN``, then `gcd(X + Y, N)` will reveal a proper factor of N.
+    In order to find these integers X and Y we try to find relations of form
+    t**2 = u modN where u is a product of small primes. If we have enough of
+    these relations then we can form ``(t1*t2...ti)**2 = u1*u2...ui modN`` such that
+    the right hand side is a square, thus we found a relation of ``X**2 = Y**2 modN``.
+
+    Here, several optimizations are done like using multiple polynomials for
+    sieving, fast changing between polynomials and using partial relations.
+    The use of partial relations can speeds up the factoring by 2 times.
+
+    Parameters
+    ==========
+
+    N : Number to be Factored
+    prime_bound : upper bound for primes in the factor base
+    M : Sieve Interval
+    ERROR_TERM : Error term for checking smoothness
+    threshold : Extra smooth relations for factorization
+    seed : generate pseudo prime numbers
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import qs
+    >>> qs(25645121643901801, 2000, 10000)
+    {5394769, 4753701529}
+    >>> qs(9804659461513846513, 2000, 10000)
+    {4641991, 2112166839943}
+
+    References
+    ==========
+
+    .. [1] https://pdfs.semanticscholar.org/5c52/8a975c1405bd35c65993abf5a4edb667c1db.pdf
+    .. [2] https://www.rieselprime.de/ziki/Self-initializing_quadratic_sieve
+    """
+    ERROR_TERM*=2**10
+    idx_1000, idx_5000, factor_base = _generate_factor_base(prime_bound, N)
+    smooth_relations = []
+    ith_poly = 0
+    partial_relations = {}
+    proper_factor = set()
+    threshold = 5*len(factor_base) // 100
+    while True:
+        if ith_poly == 0:
+            ith_sieve_poly, B_array = _initialize_first_polynomial(N, M, factor_base, idx_1000, idx_5000)
+        else:
+            ith_sieve_poly = _initialize_ith_poly(N, factor_base, ith_poly, ith_sieve_poly, B_array)
+        ith_poly += 1
+        if ith_poly >= 2**(len(B_array) - 1): # time to start with a new sieve polynomial
+            ith_poly = 0
+        sieve_array = _gen_sieve_array(M, factor_base)
+        s_rel, p_f = _trial_division_stage(N, M, factor_base, sieve_array, ith_sieve_poly, partial_relations, ERROR_TERM)
+        smooth_relations += s_rel
+        proper_factor |= p_f
+        if len(smooth_relations) >= len(factor_base) + threshold:
+            break
+    matrix = _build_matrix(smooth_relations)
+    dependent_row, mark, gauss_matrix = _gauss_mod_2(matrix)
+    N_copy = N
+    for index in range(len(dependent_row)):
+        factor = _find_factor(dependent_row, mark, gauss_matrix, index, smooth_relations, N)
+        if factor > 1 and factor < N:
+            proper_factor.add(factor)
+            while(N_copy % factor == 0):
+                N_copy //= factor
+            if isprime(N_copy):
+                proper_factor.add(N_copy)
+                break
+            if(N_copy == 1):
+                break
+    return proper_factor

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/residue_ntheory.py

@@ -0,0 +1,1954 @@
+from __future__ import annotations
+
+from sympy.external.gmpy import (gcd, lcm, invert, sqrt, jacobi,
+                                 bit_scan1, remove)
+from sympy.polys import Poly
+from sympy.polys.domains import ZZ
+from sympy.polys.galoistools import gf_crt1, gf_crt2, linear_congruence, gf_csolve
+from .primetest import isprime
+from .generate import primerange
+from .factor_ import factorint, _perfect_power
+from .modular import crt
+from sympy.utilities.decorator import deprecated
+from sympy.utilities.memoization import recurrence_memo
+from sympy.utilities.misc import as_int
+from sympy.utilities.iterables import iproduct
+from sympy.core.random import _randint, randint
+
+from itertools import product
+
+
+def n_order(a, n):
+    r""" Returns the order of ``a`` modulo ``n``.
+
+    Explanation
+    ===========
+
+    The order of ``a`` modulo ``n`` is the smallest integer
+    ``k`` such that `a^k` leaves a remainder of 1 with ``n``.
+
+    Parameters
+    ==========
+
+    a : integer
+    n : integer, n > 1. a and n should be relatively prime
+
+    Returns
+    =======
+
+    int : the order of ``a`` modulo ``n``
+
+    Raises
+    ======
+
+    ValueError
+        If `n \le 1` or `\gcd(a, n) \neq 1`.
+        If ``a`` or ``n`` is not an integer.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import n_order
+    >>> n_order(3, 7)
+    6
+    >>> n_order(4, 7)
+    3
+
+    See Also
+    ========
+
+    is_primitive_root
+        We say that ``a`` is a primitive root of ``n``
+        when the order of ``a`` modulo ``n`` equals ``totient(n)``
+
+    """
+    a, n = as_int(a), as_int(n)
+    if n <= 1:
+        raise ValueError("n should be an integer greater than 1")
+    a = a % n
+    # Trivial
+    if a == 1:
+        return 1
+    if gcd(a, n) != 1:
+        raise ValueError("The two numbers should be relatively prime")
+    a_order = 1
+    for p, e in factorint(n).items():
+        pe = p**e
+        pe_order = (p - 1) * p**(e - 1)
+        factors = factorint(p - 1)
+        if e > 1:
+            factors[p] = e - 1
+        order = 1
+        for px, ex in factors.items():
+            x = pow(a, pe_order // px**ex, pe)
+            while x != 1:
+                x = pow(x, px, pe)
+                order *= px
+        a_order = lcm(a_order, order)
+    return int(a_order)
+
+
+def _primitive_root_prime_iter(p):
+    r""" Generates the primitive roots for a prime ``p``.
+
+    Explanation
+    ===========
+
+    The primitive roots generated are not necessarily sorted.
+    However, the first one is the smallest primitive root.
+
+    Find the element whose order is ``p-1`` from the smaller one.
+    If we can find the first primitive root ``g``, we can use the following theorem.
+
+    .. math ::
+        \operatorname{ord}(g^k) = \frac{\operatorname{ord}(g)}{\gcd(\operatorname{ord}(g), k)}
+
+    From the assumption that `\operatorname{ord}(g)=p-1`,
+    it is a necessary and sufficient condition for
+    `\operatorname{ord}(g^k)=p-1` that `\gcd(p-1, k)=1`.
+
+    Parameters
+    ==========
+
+    p : odd prime
+
+    Yields
+    ======
+
+    int
+        the primitive roots of ``p``
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _primitive_root_prime_iter
+    >>> sorted(_primitive_root_prime_iter(19))
+    [2, 3, 10, 13, 14, 15]
+
+    References
+    ==========
+
+    .. [1] W. Stein "Elementary Number Theory" (2011), page 44
+
+    """
+    if p == 3:
+        yield 2
+        return
+    # Let p = +-1 (mod 4a). Legendre symbol (a/p) = 1, so `a` is not the primitive root.
+    # Corollary : If p = +-1 (mod 8), then 2 is not the primitive root of p.
+    g_min = 3 if p % 8 in [1, 7] else 2
+    if p < 41:
+        # small case
+        g = 5 if p == 23 else g_min
+    else:
+        v = [(p - 1) // i for i in factorint(p - 1).keys()]
+        for g in range(g_min, p):
+            if all(pow(g, pw, p) != 1 for pw in v):
+                break
+    yield g
+    # g**k is the primitive root of p iff gcd(p - 1, k) = 1
+    for k in range(3, p, 2):
+        if gcd(p - 1, k) == 1:
+            yield pow(g, k, p)
+
+
+def _primitive_root_prime_power_iter(p, e):
+    r""" Generates the primitive roots of `p^e`.
+
+    Explanation
+    ===========
+
+    Let ``g`` be the primitive root of ``p``.
+    If `g^{p-1} \not\equiv 1 \pmod{p^2}`, then ``g`` is primitive root of `p^e`.
+    Thus, if we find a primitive root ``g`` of ``p``,
+    then `g, g+p, g+2p, \ldots, g+(p-1)p` are primitive roots of `p^2` except one.
+    That one satisfies `\hat{g}^{p-1} \equiv 1 \pmod{p^2}`.
+    If ``h`` is the primitive root of `p^2`,
+    then `h, h+p^2, h+2p^2, \ldots, h+(p^{e-2}-1)p^e` are primitive roots of `p^e`.
+
+    Parameters
+    ==========
+
+    p : odd prime
+    e : positive integer
+
+    Yields
+    ======
+
+    int
+        the primitive roots of `p^e`
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _primitive_root_prime_power_iter
+    >>> sorted(_primitive_root_prime_power_iter(5, 2))
+    [2, 3, 8, 12, 13, 17, 22, 23]
+
+    """
+    if e == 1:
+        yield from _primitive_root_prime_iter(p)
+    else:
+        p2 = p**2
+        for g in _primitive_root_prime_iter(p):
+            t = (g - pow(g, 2 - p, p2)) % p2
+            for k in range(0, p2, p):
+                if k != t:
+                    yield from (g + k + m for m in range(0, p**e, p2))
+
+
+def _primitive_root_prime_power2_iter(p, e):
+    r""" Generates the primitive roots of `2p^e`.
+
+    Explanation
+    ===========
+
+    If ``g`` is the primitive root of ``p**e``,
+    then the odd one of ``g`` and ``g+p**e`` is the primitive root of ``2*p**e``.
+
+    Parameters
+    ==========
+
+    p : odd prime
+    e : positive integer
+
+    Yields
+    ======
+
+    int
+        the primitive roots of `2p^e`
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _primitive_root_prime_power2_iter
+    >>> sorted(_primitive_root_prime_power2_iter(5, 2))
+    [3, 13, 17, 23, 27, 33, 37, 47]
+
+    """
+    for g in _primitive_root_prime_power_iter(p, e):
+        if g % 2 == 1:
+            yield g
+        else:
+            yield g + p**e
+
+
+def primitive_root(p, smallest=True):
+    r""" Returns a primitive root of ``p`` or None.
+
+    Explanation
+    ===========
+
+    For the definition of primitive root,
+    see the explanation of ``is_primitive_root``.
+
+    The primitive root of ``p`` exist only for
+    `p = 2, 4, q^e, 2q^e` (``q`` is an odd prime).
+    Now, if we know the primitive root of ``q``,
+    we can calculate the primitive root of `q^e`,
+    and if we know the primitive root of `q^e`,
+    we can calculate the primitive root of `2q^e`.
+    When there is no need to find the smallest primitive root,
+    this property can be used to obtain a fast primitive root.
+    On the other hand, when we want the smallest primitive root,
+    we naively determine whether it is a primitive root or not.
+
+    Parameters
+    ==========
+
+    p : integer, p > 1
+    smallest : if True the smallest primitive root is returned or None
+
+    Returns
+    =======
+
+    int | None :
+        If the primitive root exists, return the primitive root of ``p``.
+        If not, return None.
+
+    Raises
+    ======
+
+    ValueError
+        If `p \le 1` or ``p`` is not an integer.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import primitive_root
+    >>> primitive_root(19)
+    2
+    >>> primitive_root(21) is None
+    True
+    >>> primitive_root(50, smallest=False)
+    27
+
+    See Also
+    ========
+
+    is_primitive_root
+
+    References
+    ==========
+
+    .. [1] W. Stein "Elementary Number Theory" (2011), page 44
+    .. [2] P. Hackman "Elementary Number Theory" (2009), Chapter C
+
+    """
+    p = as_int(p)
+    if p <= 1:
+        raise ValueError("p should be an integer greater than 1")
+    if p <= 4:
+        return p - 1
+    p_even = p % 2 == 0
+    if not p_even:
+        q = p  # p is odd
+    elif p % 4:
+        q = p//2  # p had 1 factor of 2
+    else:
+        return None  # p had more than one factor of 2
+    if isprime(q):
+        e = 1
+    else:
+        m = _perfect_power(q, 3)
+        if not m:
+            return None
+        q, e = m
+        if not isprime(q):
+            return None
+    if not smallest:
+        if p_even:
+            return next(_primitive_root_prime_power2_iter(q, e))
+        return next(_primitive_root_prime_power_iter(q, e))
+    if p_even:
+        for i in range(3, p, 2):
+            if i % q and is_primitive_root(i, p):
+                return i
+    g = next(_primitive_root_prime_iter(q))
+    if e == 1 or pow(g, q - 1, q**2) != 1:
+        return g
+    for i in range(g + 1, p):
+        if i % q and is_primitive_root(i, p):
+            return i
+
+
+def is_primitive_root(a, p):
+    r""" Returns True if ``a`` is a primitive root of ``p``.
+
+    Explanation
+    ===========
+
+    ``a`` is said to be the primitive root of ``p`` if `\gcd(a, p) = 1` and
+    `\phi(p)` is the smallest positive number s.t.
+
+        `a^{\phi(p)} \equiv 1 \pmod{p}`.
+
+    where `\phi(p)` is Euler's totient function.
+
+    The primitive root of ``p`` exist only for
+    `p = 2, 4, q^e, 2q^e` (``q`` is an odd prime).
+    Hence, if it is not such a ``p``, it returns False.
+    To determine the primitive root, we need to know
+    the prime factorization of ``q-1``.
+    The hardness of the determination depends on this complexity.
+
+    Parameters
+    ==========
+
+    a : integer
+    p : integer, ``p`` > 1. ``a`` and ``p`` should be relatively prime
+
+    Returns
+    =======
+
+    bool : If True, ``a`` is the primitive root of ``p``.
+
+    Raises
+    ======
+
+    ValueError
+        If `p \le 1` or `\gcd(a, p) \neq 1`.
+        If ``a`` or ``p`` is not an integer.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import totient
+    >>> from sympy.ntheory import is_primitive_root, n_order
+    >>> is_primitive_root(3, 10)
+    True
+    >>> is_primitive_root(9, 10)
+    False
+    >>> n_order(3, 10) == totient(10)
+    True
+    >>> n_order(9, 10) == totient(10)
+    False
+
+    See Also
+    ========
+
+    primitive_root
+
+    """
+    a, p = as_int(a), as_int(p)
+    if p <= 1:
+        raise ValueError("p should be an integer greater than 1")
+    a = a % p
+    if gcd(a, p) != 1:
+        raise ValueError("The two numbers should be relatively prime")
+    # Primitive root of p exist only for
+    # p = 2, 4, q**e, 2*q**e (q is odd prime)
+    if p <= 4:
+        # The primitive root is only p-1.
+        return a == p - 1
+    if p % 2:
+        q = p  # p is odd
+    elif p % 4:
+        q = p//2  # p had 1 factor of 2
+    else:
+        return False  # p had more than one factor of 2
+    if isprime(q):
+        group_order = q - 1
+        factors = factorint(q - 1).keys()
+    else:
+        m = _perfect_power(q, 3)
+        if not m:
+            return False
+        q, e = m
+        if not isprime(q):
+            return False
+        group_order = q**(e - 1)*(q - 1)
+        factors = set(factorint(q - 1).keys())
+        factors.add(q)
+    return all(pow(a, group_order // prime, p) != 1 for prime in factors)
+
+
+def _sqrt_mod_tonelli_shanks(a, p):
+    """
+    Returns the square root in the case of ``p`` prime with ``p == 1 (mod 8)``
+
+    Assume that the root exists.
+
+    Parameters
+    ==========
+
+    a : int
+    p : int
+        prime number. should be ``p % 8 == 1``
+
+    Returns
+    =======
+
+    int : Generally, there are two roots, but only one is returned.
+          Which one is returned is random.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _sqrt_mod_tonelli_shanks
+    >>> _sqrt_mod_tonelli_shanks(2, 17) in [6, 11]
+    True
+
+    References
+    ==========
+
+    .. [1] Carl Pomerance, Richard Crandall, Prime Numbers: A Computational Perspective,
+           2nd Edition (2005), page 101, ISBN:978-0387252827
+
+    """
+    s = bit_scan1(p - 1)
+    t = p >> s
+    # find a non-quadratic residue
+    if p % 12 == 5:
+        # Legendre symbol (3/p) == -1 if p % 12 in [5, 7]
+        d = 3
+    elif p % 5 in [2, 3]:
+        # Legendre symbol (5/p) == -1 if p % 5 in [2, 3]
+        d = 5
+    else:
+        while 1:
+            d = randint(6, p - 1)
+            if jacobi(d, p) == -1:
+                break
+    #assert legendre_symbol(d, p) == -1
+    A = pow(a, t, p)
+    D = pow(d, t, p)
+    m = 0
+    for i in range(s):
+        adm = A*pow(D, m, p) % p
+        adm = pow(adm, 2**(s - 1 - i), p)
+        if adm % p == p - 1:
+            m += 2**i
+    #assert A*pow(D, m, p) % p == 1
+    x = pow(a, (t + 1)//2, p)*pow(D, m//2, p) % p
+    return x
+
+
+def sqrt_mod(a, p, all_roots=False):
+    """
+    Find a root of ``x**2 = a mod p``.
+
+    Parameters
+    ==========
+
+    a : integer
+    p : positive integer
+    all_roots : if True the list of roots is returned or None
+
+    Notes
+    =====
+
+    If there is no root it is returned None; else the returned root
+    is less or equal to ``p // 2``; in general is not the smallest one.
+    It is returned ``p // 2`` only if it is the only root.
+
+    Use ``all_roots`` only when it is expected that all the roots fit
+    in memory; otherwise use ``sqrt_mod_iter``.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import sqrt_mod
+    >>> sqrt_mod(11, 43)
+    21
+    >>> sqrt_mod(17, 32, True)
+    [7, 9, 23, 25]
+    """
+    if all_roots:
+        return sorted(sqrt_mod_iter(a, p))
+    p = abs(as_int(p))
+    halfp = p // 2
+    x = None
+    for r in sqrt_mod_iter(a, p):
+        if r < halfp:
+            return r
+        elif r > halfp:
+            return p - r
+        else:
+            x = r
+    return x
+
+
+def sqrt_mod_iter(a, p, domain=int):
+    """
+    Iterate over solutions to ``x**2 = a mod p``.
+
+    Parameters
+    ==========
+
+    a : integer
+    p : positive integer
+    domain : integer domain, ``int``, ``ZZ`` or ``Integer``
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import sqrt_mod_iter
+    >>> list(sqrt_mod_iter(11, 43))
+    [21, 22]
+
+    See Also
+    ========
+
+    sqrt_mod : Same functionality, but you want a sorted list or only one solution.
+
+    """
+    a, p = as_int(a), abs(as_int(p))
+    v = []
+    pv = []
+    _product = product
+    for px, ex in factorint(p).items():
+        if a % px:
+            # `len(rx)` is at most 4
+            rx = _sqrt_mod_prime_power(a, px, ex)
+        else:
+            # `len(list(rx))` can be assumed to be large.
+            # The `itertools.product` is disadvantageous in terms of memory usage.
+            # It is also inferior to iproduct in speed if not all Cartesian products are needed.
+            rx = _sqrt_mod1(a, px, ex)
+            _product = iproduct
+        if not rx:
+            return
+        v.append(rx)
+        pv.append(px**ex)
+    if len(v) == 1:
+        yield from map(domain, v[0])
+    else:
+        mm, e, s = gf_crt1(pv, ZZ)
+        for vx in _product(*v):
+            yield domain(gf_crt2(vx, pv, mm, e, s, ZZ))
+
+
+def _sqrt_mod_prime_power(a, p, k):
+    """
+    Find the solutions to ``x**2 = a mod p**k`` when ``a % p != 0``.
+    If no solution exists, return ``None``.
+    Solutions are returned in an ascending list.
+
+    Parameters
+    ==========
+
+    a : integer
+    p : prime number
+    k : positive integer
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _sqrt_mod_prime_power
+    >>> _sqrt_mod_prime_power(11, 43, 1)
+    [21, 22]
+
+    References
+    ==========
+
+    .. [1] P. Hackman "Elementary Number Theory" (2009), page 160
+    .. [2] http://www.numbertheory.org/php/squareroot.html
+    .. [3] [Gathen99]_
+    """
+    pk = p**k
+    a = a % pk
+
+    if p == 2:
+        # see Ref.[2]
+        if a % 8 != 1:
+            return None
+        # Trivial
+        if k <= 3:
+            return list(range(1, pk, 2))
+        r = 1
+        # r is one of the solutions to x**2 - a = 0 (mod 2**3).
+        # Hensel lift them to solutions of x**2 - a = 0 (mod 2**k)
+        # if r**2 - a = 0 mod 2**nx but not mod 2**(nx+1)
+        # then r + 2**(nx - 1) is a root mod 2**(nx+1)
+        for nx in range(3, k):
+            if ((r**2 - a) >> nx) % 2:
+                r += 1 << (nx - 1)
+        # r is a solution of x**2 - a = 0 (mod 2**k), and
+        # there exist other solutions -r, r+h, -(r+h), and these are all solutions.
+        h = 1 << (k - 1)
+        return sorted([r, pk - r, (r + h) % pk, -(r + h) % pk])
+
+    # If the Legendre symbol (a/p) is not 1, no solution exists.
+    if jacobi(a, p) != 1:
+        return None
+    if p % 4 == 3:
+        res = pow(a, (p + 1) // 4, p)
+    elif p % 8 == 5:
+        res = pow(a, (p + 3) // 8, p)
+        if pow(res, 2, p) != a % p:
+            res = res * pow(2, (p - 1) // 4, p) % p
+    else:
+        res = _sqrt_mod_tonelli_shanks(a, p)
+    if k > 1:
+        # Hensel lifting with Newton iteration, see Ref.[3] chapter 9
+        # with f(x) = x**2 - a; one has f'(a) != 0 (mod p) for p != 2
+        px = p
+        for _ in range(k.bit_length() - 1):
+            px = px**2
+            frinv = invert(2*res, px)
+            res = (res - (res**2 - a)*frinv) % px
+        if k & (k - 1): # If k is not a power of 2
+            frinv = invert(2*res, pk)
+            res = (res - (res**2 - a)*frinv) % pk
+    return sorted([res, pk - res])
+
+
+def _sqrt_mod1(a, p, n):
+    """
+    Find solution to ``x**2 == a mod p**n`` when ``a % p == 0``.
+    If no solution exists, return ``None``.
+
+    Parameters
+    ==========
+
+    a : integer
+    p : prime number, p must divide a
+    n : positive integer
+
+    References
+    ==========
+
+    .. [1] http://www.numbertheory.org/php/squareroot.html
+    """
+    pn = p**n
+    a = a % pn
+    if a == 0:
+        # case gcd(a, p**k) = p**n
+        return range(0, pn, p**((n + 1) // 2))
+    # case gcd(a, p**k) = p**r, r < n
+    a, r = remove(a, p)
+    if r % 2 == 1:
+        return None
+    res = _sqrt_mod_prime_power(a, p, n - r)
+    if res is None:
+        return None
+    m = r // 2
+    return (x for rx in res for x in range(rx*p**m, pn, p**(n - m)))
+
+
+def is_quad_residue(a, p):
+    """
+    Returns True if ``a`` (mod ``p``) is in the set of squares mod ``p``,
+    i.e a % p in set([i**2 % p for i in range(p)]).
+
+    Parameters
+    ==========
+
+    a : integer
+    p : positive integer
+
+    Returns
+    =======
+
+    bool : If True, ``x**2 == a (mod p)`` has solution.
+
+    Raises
+    ======
+
+    ValueError
+        If ``a``, ``p`` is not integer.
+        If ``p`` is not positive.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import is_quad_residue
+    >>> is_quad_residue(21, 100)
+    True
+
+    Indeed, ``pow(39, 2, 100)`` would be 21.
+
+    >>> is_quad_residue(21, 120)
+    False
+
+    That is, for any integer ``x``, ``pow(x, 2, 120)`` is not 21.
+
+    If ``p`` is an odd
+    prime, an iterative method is used to make the determination:
+
+    >>> from sympy.ntheory import is_quad_residue
+    >>> sorted(set([i**2 % 7 for i in range(7)]))
+    [0, 1, 2, 4]
+    >>> [j for j in range(7) if is_quad_residue(j, 7)]
+    [0, 1, 2, 4]
+
+    See Also
+    ========
+
+    legendre_symbol, jacobi_symbol, sqrt_mod
+    """
+    a, p = as_int(a), as_int(p)
+    if p < 1:
+        raise ValueError('p must be > 0')
+    a %= p
+    if a < 2 or p < 3:
+        return True
+    # Since we want to compute the Jacobi symbol,
+    # we separate p into the odd part and the rest.
+    t = bit_scan1(p)
+    if t:
+        # The existence of a solution to a power of 2 is determined
+        # using the logic of `p==2` in `_sqrt_mod_prime_power` and `_sqrt_mod1`.
+        a_ = a % (1 << t)
+        if a_:
+            r = bit_scan1(a_)
+            if r % 2 or (a_ >> r) & 6:
+                return False
+        p >>= t
+        a %= p
+        if a < 2 or p < 3:
+            return True
+    # If Jacobi symbol is -1 or p is prime, can be determined by Jacobi symbol only
+    j = jacobi(a, p)
+    if j == -1 or isprime(p):
+        return j == 1
+    # Checks if `x**2 = a (mod p)` has a solution
+    for px, ex in factorint(p).items():
+        if a % px:
+            if jacobi(a, px) != 1:
+                return False
+        else:
+            a_ = a % px**ex
+            if a_ == 0:
+                continue
+            a_, r = remove(a_, px)
+            if r % 2 or jacobi(a_, px) != 1:
+                return False
+    return True
+
+
+def is_nthpow_residue(a, n, m):
+    """
+    Returns True if ``x**n == a (mod m)`` has solutions.
+
+    References
+    ==========
+
+    .. [1] P. Hackman "Elementary Number Theory" (2009), page 76
+
+    """
+    a = a % m
+    a, n, m = as_int(a), as_int(n), as_int(m)
+    if m <= 0:
+        raise ValueError('m must be > 0')
+    if n < 0:
+        raise ValueError('n must be >= 0')
+    if n == 0:
+        if m == 1:
+            return False
+        return a == 1
+    if a == 0:
+        return True
+    if n == 1:
+        return True
+    if n == 2:
+        return is_quad_residue(a, m)
+    return all(_is_nthpow_residue_bign_prime_power(a, n, p, e)
+               for p, e in factorint(m).items())
+
+
+def _is_nthpow_residue_bign_prime_power(a, n, p, k):
+    r"""
+    Returns True if `x^n = a \pmod{p^k}` has solutions for `n > 2`.
+
+    Parameters
+    ==========
+
+    a : positive integer
+    n : integer, n > 2
+    p : prime number
+    k : positive integer
+
+    """
+    while a % p == 0:
+        a %= pow(p, k)
+        if not a:
+            return True
+        a, mu = remove(a, p)
+        if mu % n:
+            return False
+        k -= mu
+    if p != 2:
+        f = p**(k - 1)*(p - 1) # f = totient(p**k)
+        return pow(a, f // gcd(f, n), pow(p, k)) == 1
+    if n & 1:
+        return True
+    c = min(bit_scan1(n) + 2, k)
+    return a % pow(2, c) == 1
+
+
+def _nthroot_mod1(s, q, p, all_roots):
+    """
+    Root of ``x**q = s mod p``, ``p`` prime and ``q`` divides ``p - 1``.
+    Assume that the root exists.
+
+    Parameters
+    ==========
+
+    s : integer
+    q : integer, n > 2. ``q`` divides ``p - 1``.
+    p : prime number
+    all_roots : if False returns the smallest root, else the list of roots
+
+    Returns
+    =======
+
+    list[int] | int :
+        Root of ``x**q = s mod p``. If ``all_roots == True``,
+        returned ascending list. otherwise, returned an int.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _nthroot_mod1
+    >>> _nthroot_mod1(5, 3, 13, False)
+    7
+    >>> _nthroot_mod1(13, 4, 17, True)
+    [3, 5, 12, 14]
+
+    References
+    ==========
+
+    .. [1] A. M. Johnston, A Generalized qth Root Algorithm,
+           ACM-SIAM Symposium on Discrete Algorithms (1999), pp. 929-930
+
+    """
+    g = next(_primitive_root_prime_iter(p))
+    r = s
+    for qx, ex in factorint(q).items():
+        f = (p - 1) // qx**ex
+        while f % qx == 0:
+            f //= qx
+        z = f*invert(-f, qx)
+        x = (1 + z) // qx
+        t = discrete_log(p, pow(r, f, p), pow(g, f*qx, p))
+        for _ in range(ex):
+            # assert t == discrete_log(p, pow(r, f, p), pow(g, f*qx, p))
+            r = pow(r, x, p)*pow(g, -z*t % (p - 1), p) % p
+            t //= qx
+    res = [r]
+    h = pow(g, (p - 1) // q, p)
+    #assert pow(h, q, p) == 1
+    hx = r
+    for _ in range(q - 1):
+        hx = (hx*h) % p
+        res.append(hx)
+    if all_roots:
+        res.sort()
+        return res
+    return min(res)
+
+
+def _nthroot_mod_prime_power(a, n, p, k):
+    """ Root of ``x**n = a mod p**k``.
+
+    Parameters
+    ==========
+
+    a : integer
+    n : integer, n > 2
+    p : prime number
+    k : positive integer
+
+    Returns
+    =======
+
+    list[int] :
+        Ascending list of roots of ``x**n = a mod p**k``.
+        If no solution exists, return ``[]``.
+
+    """
+    if not _is_nthpow_residue_bign_prime_power(a, n, p, k):
+        return []
+    a_mod_p = a % p
+    if a_mod_p == 0:
+        base_roots = [0]
+    elif (p - 1) % n == 0:
+        base_roots = _nthroot_mod1(a_mod_p, n, p, all_roots=True)
+    else:
+        # The roots of ``x**n - a = 0 (mod p)`` are roots of
+        # ``gcd(x**n - a, x**(p - 1) - 1) = 0 (mod p)``
+        pa = n
+        pb = p - 1
+        b = 1
+        if pa < pb:
+            a_mod_p, pa, b, pb = b, pb, a_mod_p, pa
+        # gcd(x**pa - a, x**pb - b) = gcd(x**pb - b, x**pc - c)
+        # where pc = pa % pb; c = b**-q * a mod p
+        while pb:
+            q, pc = divmod(pa, pb)
+            c = pow(b, -q, p) * a_mod_p % p
+            pa, pb = pb, pc
+            a_mod_p, b = b, c
+        if pa == 1:
+            base_roots = [a_mod_p]
+        elif pa == 2:
+            base_roots = sqrt_mod(a_mod_p, p, all_roots=True)
+        else:
+            base_roots = _nthroot_mod1(a_mod_p, pa, p, all_roots=True)
+    if k == 1:
+        return base_roots
+    a %= p**k
+    tot_roots = set()
+    for root in base_roots:
+        diff = pow(root, n - 1, p)*n % p
+        new_base = p
+        if diff != 0:
+            m_inv = invert(diff, p)
+            for _ in range(k - 1):
+                new_base *= p
+                tmp = pow(root, n, new_base) - a
+                tmp *= m_inv
+                root = (root - tmp) % new_base
+            tot_roots.add(root)
+        else:
+            roots_in_base = {root}
+            for _ in range(k - 1):
+                new_base *= p
+                new_roots = set()
+                for k_ in roots_in_base:
+                    if pow(k_, n, new_base) != a % new_base:
+                        continue
+                    while k_ not in new_roots:
+                        new_roots.add(k_)
+                        k_ = (k_ + (new_base // p)) % new_base
+                roots_in_base = new_roots
+            tot_roots = tot_roots | roots_in_base
+    return sorted(tot_roots)
+
+
+def nthroot_mod(a, n, p, all_roots=False):
+    """
+    Find the solutions to ``x**n = a mod p``.
+
+    Parameters
+    ==========
+
+    a : integer
+    n : positive integer
+    p : positive integer
+    all_roots : if False returns the smallest root, else the list of roots
+
+    Returns
+    =======
+
+        list[int] | int | None :
+            solutions to ``x**n = a mod p``.
+            The table of the output type is:
+
+            ========== ========== ==========
+            all_roots  has roots  Returns
+            ========== ========== ==========
+            True       Yes        list[int]
+            True       No         []
+            False      Yes        int
+            False      No         None
+            ========== ========== ==========
+
+    Raises
+    ======
+
+        ValueError
+            If ``a``, ``n`` or ``p`` is not integer.
+            If ``n`` or ``p`` is not positive.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import nthroot_mod
+    >>> nthroot_mod(11, 4, 19)
+    8
+    >>> nthroot_mod(11, 4, 19, True)
+    [8, 11]
+    >>> nthroot_mod(68, 3, 109)
+    23
+
+    References
+    ==========
+
+    .. [1] P. Hackman "Elementary Number Theory" (2009), page 76
+
+    """
+    a = a % p
+    a, n, p = as_int(a), as_int(n), as_int(p)
+
+    if n < 1:
+        raise ValueError("n should be positive")
+    if p < 1:
+        raise ValueError("p should be positive")
+    if n == 1:
+        return [a] if all_roots else a
+    if n == 2:
+        return sqrt_mod(a, p, all_roots)
+    base = []
+    prime_power = []
+    for q, e in factorint(p).items():
+        tot_roots = _nthroot_mod_prime_power(a, n, q, e)
+        if not tot_roots:
+            return [] if all_roots else None
+        prime_power.append(q**e)
+        base.append(sorted(tot_roots))
+    P, E, S = gf_crt1(prime_power, ZZ)
+    ret = sorted(map(int, {gf_crt2(c, prime_power, P, E, S, ZZ)
+                           for c in product(*base)}))
+    if all_roots:
+        return ret
+    if ret:
+        return ret[0]
+
+
+def quadratic_residues(p) -> list[int]:
+    """
+    Returns the list of quadratic residues.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import quadratic_residues
+    >>> quadratic_residues(7)
+    [0, 1, 2, 4]
+    """
+    p = as_int(p)
+    r = {pow(i, 2, p) for i in range(p // 2 + 1)}
+    return sorted(r)
+
+
+@deprecated("""\
+The `sympy.ntheory.residue_ntheory.legendre_symbol` has been moved to `sympy.functions.combinatorial.numbers.legendre_symbol`.""",
+deprecated_since_version="1.13",
+active_deprecations_target='deprecated-ntheory-symbolic-functions')
+def legendre_symbol(a, p):
+    r"""
+    Returns the Legendre symbol `(a / p)`.
+
+    .. deprecated:: 1.13
+
+        The ``legendre_symbol`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.legendre_symbol`
+        instead. See its documentation for more information. See
+        :ref:`deprecated-ntheory-symbolic-functions` for details.
+
+    For an integer ``a`` and an odd prime ``p``, the Legendre symbol is
+    defined as
+
+    .. math ::
+        \genfrac(){}{}{a}{p} = \begin{cases}
+             0 & \text{if } p \text{ divides } a\\
+             1 & \text{if } a \text{ is a quadratic residue modulo } p\\
+            -1 & \text{if } a \text{ is a quadratic nonresidue modulo } p
+        \end{cases}
+
+    Parameters
+    ==========
+
+    a : integer
+    p : odd prime
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import legendre_symbol
+    >>> [legendre_symbol(i, 7) for i in range(7)]
+    [0, 1, 1, -1, 1, -1, -1]
+    >>> sorted(set([i**2 % 7 for i in range(7)]))
+    [0, 1, 2, 4]
+
+    See Also
+    ========
+
+    is_quad_residue, jacobi_symbol
+
+    """
+    from sympy.functions.combinatorial.numbers import legendre_symbol as _legendre_symbol
+    return _legendre_symbol(a, p)
+
+
+@deprecated("""\
+The `sympy.ntheory.residue_ntheory.jacobi_symbol` has been moved to `sympy.functions.combinatorial.numbers.jacobi_symbol`.""",
+deprecated_since_version="1.13",
+active_deprecations_target='deprecated-ntheory-symbolic-functions')
+def jacobi_symbol(m, n):
+    r"""
+    Returns the Jacobi symbol `(m / n)`.
+
+    .. deprecated:: 1.13
+
+        The ``jacobi_symbol`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.jacobi_symbol`
+        instead. See its documentation for more information. See
+        :ref:`deprecated-ntheory-symbolic-functions` for details.
+
+    For any integer ``m`` and any positive odd integer ``n`` the Jacobi symbol
+    is defined as the product of the Legendre symbols corresponding to the
+    prime factors of ``n``:
+
+    .. math ::
+        \genfrac(){}{}{m}{n} =
+            \genfrac(){}{}{m}{p^{1}}^{\alpha_1}
+            \genfrac(){}{}{m}{p^{2}}^{\alpha_2}
+            ...
+            \genfrac(){}{}{m}{p^{k}}^{\alpha_k}
+            \text{ where } n =
+                p_1^{\alpha_1}
+                p_2^{\alpha_2}
+                ...
+                p_k^{\alpha_k}
+
+    Like the Legendre symbol, if the Jacobi symbol `\genfrac(){}{}{m}{n} = -1`
+    then ``m`` is a quadratic nonresidue modulo ``n``.
+
+    But, unlike the Legendre symbol, if the Jacobi symbol
+    `\genfrac(){}{}{m}{n} = 1` then ``m`` may or may not be a quadratic residue
+    modulo ``n``.
+
+    Parameters
+    ==========
+
+    m : integer
+    n : odd positive integer
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import jacobi_symbol, legendre_symbol
+    >>> from sympy import S
+    >>> jacobi_symbol(45, 77)
+    -1
+    >>> jacobi_symbol(60, 121)
+    1
+
+    The relationship between the ``jacobi_symbol`` and ``legendre_symbol`` can
+    be demonstrated as follows:
+
+    >>> L = legendre_symbol
+    >>> S(45).factors()
+    {3: 2, 5: 1}
+    >>> jacobi_symbol(7, 45) == L(7, 3)**2 * L(7, 5)**1
+    True
+
+    See Also
+    ========
+
+    is_quad_residue, legendre_symbol
+    """
+    from sympy.functions.combinatorial.numbers import jacobi_symbol as _jacobi_symbol
+    return _jacobi_symbol(m, n)
+
+
+@deprecated("""\
+The `sympy.ntheory.residue_ntheory.mobius` has been moved to `sympy.functions.combinatorial.numbers.mobius`.""",
+deprecated_since_version="1.13",
+active_deprecations_target='deprecated-ntheory-symbolic-functions')
+def mobius(n):
+    """
+    Mobius function maps natural number to {-1, 0, 1}
+
+    .. deprecated:: 1.13
+
+        The ``mobius`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.mobius`
+        instead. See its documentation for more information. See
+        :ref:`deprecated-ntheory-symbolic-functions` for details.
+
+    It is defined as follows:
+        1) `1` if `n = 1`.
+        2) `0` if `n` has a squared prime factor.
+        3) `(-1)^k` if `n` is a square-free positive integer with `k`
+           number of prime factors.
+
+    It is an important multiplicative function in number theory
+    and combinatorics.  It has applications in mathematical series,
+    algebraic number theory and also physics (Fermion operator has very
+    concrete realization with Mobius Function model).
+
+    Parameters
+    ==========
+
+    n : positive integer
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import mobius
+    >>> mobius(13*7)
+    1
+    >>> mobius(1)
+    1
+    >>> mobius(13*7*5)
+    -1
+    >>> mobius(13**2)
+    0
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/M%C3%B6bius_function
+    .. [2] Thomas Koshy "Elementary Number Theory with Applications"
+
+    """
+    from sympy.functions.combinatorial.numbers import mobius as _mobius
+    return _mobius(n)
+
+
+def _discrete_log_trial_mul(n, a, b, order=None):
+    """
+    Trial multiplication algorithm for computing the discrete logarithm of
+    ``a`` to the base ``b`` modulo ``n``.
+
+    The algorithm finds the discrete logarithm using exhaustive search. This
+    naive method is used as fallback algorithm of ``discrete_log`` when the
+    group order is very small.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _discrete_log_trial_mul
+    >>> _discrete_log_trial_mul(41, 15, 7)
+    3
+
+    See Also
+    ========
+
+    discrete_log
+
+    References
+    ==========
+
+    .. [1] "Handbook of applied cryptography", Menezes, A. J., Van, O. P. C., &
+        Vanstone, S. A. (1997).
+    """
+    a %= n
+    b %= n
+    if order is None:
+        order = n
+    x = 1
+    for i in range(order):
+        if x == a:
+            return i
+        x = x * b % n
+    raise ValueError("Log does not exist")
+
+
+def _discrete_log_shanks_steps(n, a, b, order=None):
+    """
+    Baby-step giant-step algorithm for computing the discrete logarithm of
+    ``a`` to the base ``b`` modulo ``n``.
+
+    The algorithm is a time-memory trade-off of the method of exhaustive
+    search. It uses `O(sqrt(m))` memory, where `m` is the group order.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _discrete_log_shanks_steps
+    >>> _discrete_log_shanks_steps(41, 15, 7)
+    3
+
+    See Also
+    ========
+
+    discrete_log
+
+    References
+    ==========
+
+    .. [1] "Handbook of applied cryptography", Menezes, A. J., Van, O. P. C., &
+        Vanstone, S. A. (1997).
+    """
+    a %= n
+    b %= n
+    if order is None:
+        order = n_order(b, n)
+    m = sqrt(order) + 1
+    T = {}
+    x = 1
+    for i in range(m):
+        T[x] = i
+        x = x * b % n
+    z = pow(b, -m, n)
+    x = a
+    for i in range(m):
+        if x in T:
+            return i * m + T[x]
+        x = x * z % n
+    raise ValueError("Log does not exist")
+
+
+def _discrete_log_pollard_rho(n, a, b, order=None, retries=10, rseed=None):
+    """
+    Pollard's Rho algorithm for computing the discrete logarithm of ``a`` to
+    the base ``b`` modulo ``n``.
+
+    It is a randomized algorithm with the same expected running time as
+    ``_discrete_log_shanks_steps``, but requires a negligible amount of memory.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _discrete_log_pollard_rho
+    >>> _discrete_log_pollard_rho(227, 3**7, 3)
+    7
+
+    See Also
+    ========
+
+    discrete_log
+
+    References
+    ==========
+
+    .. [1] "Handbook of applied cryptography", Menezes, A. J., Van, O. P. C., &
+        Vanstone, S. A. (1997).
+    """
+    a %= n
+    b %= n
+
+    if order is None:
+        order = n_order(b, n)
+    randint = _randint(rseed)
+
+    for i in range(retries):
+        aa = randint(1, order - 1)
+        ba = randint(1, order - 1)
+        xa = pow(b, aa, n) * pow(a, ba, n) % n
+
+        c = xa % 3
+        if c == 0:
+            xb = a * xa % n
+            ab = aa
+            bb = (ba + 1) % order
+        elif c == 1:
+            xb = xa * xa % n
+            ab = (aa + aa) % order
+            bb = (ba + ba) % order
+        else:
+            xb = b * xa % n
+            ab = (aa + 1) % order
+            bb = ba
+
+        for j in range(order):
+            c = xa % 3
+            if c == 0:
+                xa = a * xa % n
+                ba = (ba + 1) % order
+            elif c == 1:
+                xa = xa * xa % n
+                aa = (aa + aa) % order
+                ba = (ba + ba) % order
+            else:
+                xa = b * xa % n
+                aa = (aa + 1) % order
+
+            c = xb % 3
+            if c == 0:
+                xb = a * xb % n
+                bb = (bb + 1) % order
+            elif c == 1:
+                xb = xb * xb % n
+                ab = (ab + ab) % order
+                bb = (bb + bb) % order
+            else:
+                xb = b * xb % n
+                ab = (ab + 1) % order
+
+            c = xb % 3
+            if c == 0:
+                xb = a * xb % n
+                bb = (bb + 1) % order
+            elif c == 1:
+                xb = xb * xb % n
+                ab = (ab + ab) % order
+                bb = (bb + bb) % order
+            else:
+                xb = b * xb % n
+                ab = (ab + 1) % order
+
+            if xa == xb:
+                r = (ba - bb) % order
+                try:
+                    e = invert(r, order) * (ab - aa) % order
+                    if (pow(b, e, n) - a) % n == 0:
+                        return e
+                except ZeroDivisionError:
+                    pass
+                break
+    raise ValueError("Pollard's Rho failed to find logarithm")
+
+
+def _discrete_log_is_smooth(n: int, factorbase: list):
+    """Try to factor n with respect to a given factorbase.
+    Upon success a list of exponents with repect to the factorbase is returned.
+    Otherwise None."""
+    factors = [0]*len(factorbase)
+    for i, p in enumerate(factorbase):
+        while n % p == 0: # divide by p as many times as possible
+            factors[i] += 1
+            n = n // p
+    if n != 1:
+        return None # the number factors if at the end nothing is left
+    return factors
+
+
+def _discrete_log_index_calculus(n, a, b, order, rseed=None):
+    """
+    Index Calculus algorithm for computing the discrete logarithm of ``a`` to
+    the base ``b`` modulo ``n``.
+
+    The group order must be given and prime. It is not suitable for small orders
+    and the algorithm might fail to find a solution in such situations.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _discrete_log_index_calculus
+    >>> _discrete_log_index_calculus(24570203447, 23859756228, 2, 12285101723)
+    4519867240
+
+    See Also
+    ========
+
+    discrete_log
+
+    References
+    ==========
+
+    .. [1] "Handbook of applied cryptography", Menezes, A. J., Van, O. P. C., &
+        Vanstone, S. A. (1997).
+    """
+    randint = _randint(rseed)
+    from math import sqrt, exp, log
+    a %= n
+    b %= n
+    # assert isprime(order), "The order of the base must be prime."
+    # First choose a heuristic the bound B for the factorbase.
+    # We have added an extra term to the asymptotic value which
+    # is closer to the theoretical optimum for n up to 2^70.
+    B = int(exp(0.5 * sqrt( log(n) * log(log(n)) )*( 1 + 1/log(log(n)) )))
+    max = 5 * B * B  # expected number of trys to find a relation
+    factorbase = list(primerange(B)) # compute the factorbase
+    lf = len(factorbase) # length of the factorbase
+    ordermo = order-1
+    abx = a
+    for x in range(order):
+        if abx == 1:
+            return (order - x) % order
+        relationa = _discrete_log_is_smooth(abx, factorbase)
+        if relationa:
+            relationa = [r % order for r in relationa] + [x]
+            break
+        abx = abx * b % n # abx = a*pow(b, x, n) % n
+
+    else:
+        raise ValueError("Index Calculus failed")
+
+    relations = [None] * lf
+    k = 1  # number of relations found
+    kk = 0
+    while k < 3 * lf and kk < max:  # find relations for all primes in our factor base
+        x = randint(1,ordermo)
+        relation = _discrete_log_is_smooth(pow(b,x,n), factorbase)
+        if relation is None:
+            kk += 1
+            continue
+        k += 1
+        kk = 0
+        relation += [ x ]
+        index = lf  # determine the index of the first nonzero entry
+        for i in range(lf):
+            ri = relation[i] % order
+            if ri> 0 and relations[i] is not None:  # make this entry zero if we can
+                for j in range(lf+1):
+                    relation[j] = (relation[j] - ri*relations[i][j]) % order
+            else:
+                relation[i] = ri
+            if relation[i] > 0 and index == lf:  # is this the index of the first nonzero entry?
+                index = i
+        if index == lf or relations[index] is not None:  # the relation contains no new information
+            continue
+        # the relation contains new information
+        rinv = pow(relation[index],-1,order)  # normalize the first nonzero entry
+        for j in range(index,lf+1):
+            relation[j] = rinv * relation[j] % order
+        relations[index] = relation
+        for i in range(lf):  # subtract the new relation from the one for a
+            if relationa[i] > 0 and relations[i] is not None:
+                rbi = relationa[i]
+                for j in range(lf+1):
+                    relationa[j] = (relationa[j] - rbi*relations[i][j]) % order
+            if relationa[i] > 0:  # the index of the first nonzero entry
+                break  # we do not need to reduce further at this point
+        else:  # all unkowns are gone
+            #print(f"Success after {k} relations out of {lf}")
+            x = (order -relationa[lf]) % order
+            if pow(b,x,n) == a:
+                return x
+            raise ValueError("Index Calculus failed")
+    raise ValueError("Index Calculus failed")
+
+
+def _discrete_log_pohlig_hellman(n, a, b, order=None, order_factors=None):
+    """
+    Pohlig-Hellman algorithm for computing the discrete logarithm of ``a`` to
+    the base ``b`` modulo ``n``.
+
+    In order to compute the discrete logarithm, the algorithm takes advantage
+    of the factorization of the group order. It is more efficient when the
+    group order factors into many small primes.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _discrete_log_pohlig_hellman
+    >>> _discrete_log_pohlig_hellman(251, 210, 71)
+    197
+
+    See Also
+    ========
+
+    discrete_log
+
+    References
+    ==========
+
+    .. [1] "Handbook of applied cryptography", Menezes, A. J., Van, O. P. C., &
+        Vanstone, S. A. (1997).
+    """
+    from .modular import crt
+    a %= n
+    b %= n
+
+    if order is None:
+        order = n_order(b, n)
+    if order_factors is None:
+        order_factors = factorint(order)
+    l = [0] * len(order_factors)
+
+    for i, (pi, ri) in enumerate(order_factors.items()):
+        for j in range(ri):
+            aj = pow(a * pow(b, -l[i], n), order // pi**(j + 1), n)
+            bj = pow(b, order // pi, n)
+            cj = discrete_log(n, aj, bj, pi, True)
+            l[i] += cj * pi**j
+
+    d, _ = crt([pi**ri for pi, ri in order_factors.items()], l)
+    return d
+
+
+def discrete_log(n, a, b, order=None, prime_order=None):
+    """
+    Compute the discrete logarithm of ``a`` to the base ``b`` modulo ``n``.
+
+    This is a recursive function to reduce the discrete logarithm problem in
+    cyclic groups of composite order to the problem in cyclic groups of prime
+    order.
+
+    It employs different algorithms depending on the problem (subgroup order
+    size, prime order or not):
+
+        * Trial multiplication
+        * Baby-step giant-step
+        * Pollard's Rho
+        * Index Calculus
+        * Pohlig-Hellman
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import discrete_log
+    >>> discrete_log(41, 15, 7)
+    3
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/DiscreteLogarithm.html
+    .. [2] "Handbook of applied cryptography", Menezes, A. J., Van, O. P. C., &
+        Vanstone, S. A. (1997).
+
+    """
+    from math import sqrt, log
+    n, a, b = as_int(n), as_int(a), as_int(b)
+    if order is None:
+        # Compute the order and its factoring in one pass
+        # order = totient(n), factors = factorint(order)
+        factors = {}
+        for px, kx in factorint(n).items():
+            if kx > 1:
+                if px in factors:
+                    factors[px] += kx - 1
+                else:
+                    factors[px] = kx - 1
+            for py, ky in factorint(px - 1).items():
+                if py in factors:
+                    factors[py] += ky
+                else:
+                    factors[py] = ky
+        order = 1
+        for px, kx in factors.items():
+            order *= px**kx
+        # Now the `order` is the order of the group and factors = factorint(order)
+        # The order of `b` divides the order of the group.
+        order_factors = {}
+        for p, e in factors.items():
+            i = 0
+            for _ in range(e):
+                if pow(b, order // p, n) == 1:
+                   order //= p
+                   i += 1
+                else:
+                    break
+            if i < e:
+                order_factors[p] = e - i
+
+    if prime_order is None:
+        prime_order = isprime(order)
+
+    if order < 1000:
+        return _discrete_log_trial_mul(n, a, b, order)
+    elif prime_order:
+        # Shanks and Pollard rho are O(sqrt(order)) while index calculus is O(exp(2*sqrt(log(n)log(log(n)))))
+        # we compare the expected running times to determine the algorithmus which is expected to be faster
+        if 4*sqrt(log(n)*log(log(n))) < log(order) - 10:  # the number 10 was determined experimental
+            return _discrete_log_index_calculus(n, a, b, order)
+        elif order < 1000000000000:
+            # Shanks seems typically faster, but uses O(sqrt(order)) memory
+            return _discrete_log_shanks_steps(n, a, b, order)
+        return _discrete_log_pollard_rho(n, a, b, order)
+
+    return _discrete_log_pohlig_hellman(n, a, b, order, order_factors)
+
+
+
+def quadratic_congruence(a, b, c, n):
+    r"""
+    Find the solutions to `a x^2 + b x + c \equiv 0 \pmod{n}`.
+
+    Parameters
+    ==========
+
+    a : int
+    b : int
+    c : int
+    n : int
+        A positive integer.
+
+    Returns
+    =======
+
+    list[int] :
+        A sorted list of solutions. If no solution exists, ``[]``.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import quadratic_congruence
+    >>> quadratic_congruence(2, 5, 3, 7) # 2x^2 + 5x + 3 = 0 (mod 7)
+    [2, 6]
+    >>> quadratic_congruence(8, 6, 4, 15) # No solution
+    []
+
+    See Also
+    ========
+
+    polynomial_congruence : Solve the polynomial congruence
+
+    """
+    a = as_int(a)
+    b = as_int(b)
+    c = as_int(c)
+    n = as_int(n)
+    if n <= 1:
+        raise ValueError("n should be an integer greater than 1")
+    a %= n
+    b %= n
+    c %= n
+
+    if a == 0:
+        return linear_congruence(b, -c, n)
+    if n == 2:
+        # assert a == 1
+        roots = []
+        if c == 0:
+            roots.append(0)
+        if (b + c) % 2:
+            roots.append(1)
+        return roots
+    if gcd(2*a, n) == 1:
+        inv_a = invert(a, n)
+        b *= inv_a
+        c *= inv_a
+        if b % 2:
+            b += n
+        b >>= 1
+        return sorted((i - b) % n for i in sqrt_mod_iter(b**2 - c, n))
+    res = set()
+    for i in sqrt_mod_iter(b**2 - 4*a*c, 4*a*n):
+        res.update(j % n for j in linear_congruence(2*a, i - b, 4*a*n))
+    return sorted(res)
+
+
+def _valid_expr(expr):
+    """
+    return coefficients of expr if it is a univariate polynomial
+    with integer coefficients else raise a ValueError.
+    """
+
+    if not expr.is_polynomial():
+        raise ValueError("The expression should be a polynomial")
+    polynomial = Poly(expr)
+    if not polynomial.is_univariate:
+        raise ValueError("The expression should be univariate")
+    if not polynomial.domain == ZZ:
+        raise ValueError("The expression should should have integer coefficients")
+    return polynomial.all_coeffs()
+
+
+def polynomial_congruence(expr, m):
+    """
+    Find the solutions to a polynomial congruence equation modulo m.
+
+    Parameters
+    ==========
+
+    expr : integer coefficient polynomial
+    m : positive integer
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory import polynomial_congruence
+    >>> from sympy.abc import x
+    >>> expr = x**6 - 2*x**5 -35
+    >>> polynomial_congruence(expr, 6125)
+    [3257]
+
+    See Also
+    ========
+
+    sympy.polys.galoistools.gf_csolve : low level solving routine used by this routine
+
+    """
+    coefficients = _valid_expr(expr)
+    coefficients = [num % m for num in coefficients]
+    rank = len(coefficients)
+    if rank == 3:
+        return quadratic_congruence(*coefficients, m)
+    if rank == 2:
+        return quadratic_congruence(0, *coefficients, m)
+    if coefficients[0] == 1 and 1 + coefficients[-1] == sum(coefficients):
+        return nthroot_mod(-coefficients[-1], rank - 1, m, True)
+    return gf_csolve(coefficients, m)
+
+
+def binomial_mod(n, m, k):
+    """Compute ``binomial(n, m) % k``.
+
+    Explanation
+    ===========
+
+    Returns ``binomial(n, m) % k`` using a generalization of Lucas'
+    Theorem for prime powers given by Granville [1]_, in conjunction with
+    the Chinese Remainder Theorem.  The residue for each prime power
+    is calculated in time O(log^2(n) + q^4*log(n)log(p) + q^4*p*log^3(p)).
+
+    Parameters
+    ==========
+
+    n : an integer
+    m : an integer
+    k : a positive integer
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import binomial_mod
+    >>> binomial_mod(10, 2, 6)  # binomial(10, 2) = 45
+    3
+    >>> binomial_mod(17, 9, 10)  # binomial(17, 9) = 24310
+    0
+
+    References
+    ==========
+
+    .. [1] Binomial coefficients modulo prime powers, Andrew Granville,
+        Available: https://web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf
+    """
+    if k < 1: raise ValueError('k is required to be positive')
+    # We decompose q into a product of prime powers and apply
+    # the generalization of Lucas' Theorem given by Granville
+    # to obtain binomial(n, k) mod p^e, and then use the Chinese
+    # Remainder Theorem to obtain the result mod q
+    if n < 0 or m < 0 or m > n: return 0
+    factorisation = factorint(k)
+    residues = [_binomial_mod_prime_power(n, m, p, e) for p, e in factorisation.items()]
+    return crt([p**pw for p, pw in factorisation.items()], residues, check=False)[0]
+
+
+def _binomial_mod_prime_power(n, m, p, q):
+    """Compute ``binomial(n, m) % p**q`` for a prime ``p``.
+
+    Parameters
+    ==========
+
+    n : positive integer
+    m : a nonnegative integer
+    p : a prime
+    q : a positive integer (the prime exponent)
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.residue_ntheory import _binomial_mod_prime_power
+    >>> _binomial_mod_prime_power(10, 2, 3, 2)  # binomial(10, 2) = 45
+    0
+    >>> _binomial_mod_prime_power(17, 9, 2, 4)  # binomial(17, 9) = 24310
+    6
+
+    References
+    ==========
+
+    .. [1] Binomial coefficients modulo prime powers, Andrew Granville,
+        Available: https://web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf
+    """
+    # Function/variable naming within this function follows Ref.[1]
+    # n!_p will be used to denote the product of integers <= n not divisible by
+    # p, with binomial(n, m)_p the same as binomial(n, m), but defined using
+    # n!_p in place of n!
+    modulo = pow(p, q)
+
+    def up_factorial(u):
+        """Compute (u*p)!_p modulo p^q."""
+        r = q // 2
+        fac = prod = 1
+        if r == 1 and p == 2 or 2*r + 1 in (p, p*p):
+            if q % 2 == 1: r += 1
+            modulo, div = pow(p, 2*r), pow(p, 2*r - q)
+        else:
+            modulo, div = pow(p, 2*r + 1), pow(p, (2*r + 1) - q)
+        for j in range(1, r + 1):
+            for mul in range((j - 1)*p + 1, j*p):  # ignore jp itself
+                fac *= mul
+                fac %= modulo
+            bj_ = bj(u, j, r)
+            prod *= pow(fac, bj_, modulo)
+            prod %= modulo
+        if p == 2:
+            sm = u // 2
+            for j in range(1, r + 1): sm += j//2 * bj(u, j, r)
+            if sm % 2 == 1: prod *= -1
+        prod %= modulo//div
+        return prod % modulo
+
+    def bj(u, j, r):
+        """Compute the exponent of (j*p)!_p in the calculation of (u*p)!_p."""
+        prod = u
+        for i in range(1, r + 1):
+            if i != j: prod *= u*u - i*i
+        for i in range(1, r + 1):
+            if i != j: prod //= j*j - i*i
+        return prod // j
+
+    def up_plus_v_binom(u, v):
+        """Compute binomial(u*p + v, v)_p modulo p^q."""
+        prod = 1
+        div = invert(factorial(v), modulo)
+        for j in range(1, q):
+            b = div
+            for v_ in range(j*p + 1, j*p + v + 1):
+                b *= v_
+                b %= modulo
+            aj = u
+            for i in range(1, q):
+                if i != j: aj *= u - i
+            for i in range(1, q):
+                if i != j: aj //= j - i
+            aj //= j
+            prod *= pow(b, aj, modulo)
+            prod %= modulo
+        return prod
+
+    @recurrence_memo([1])
+    def factorial(v, prev):
+        """Compute v! modulo p^q."""
+        return v*prev[-1] % modulo
+
+    def factorial_p(n):
+        """Compute n!_p modulo p^q."""
+        u, v = divmod(n, p)
+        return (factorial(v) * up_factorial(u) * up_plus_v_binom(u, v)) % modulo
+
+    prod = 1
+    Nj, Mj, Rj = n, m, n - m
+    # e0 will be the p-adic valuation of binomial(n, m) at p
+    e0 = carry = eq_1 = j = 0
+    while Nj:
+        numerator = factorial_p(Nj % modulo)
+        denominator = factorial_p(Mj % modulo) * factorial_p(Rj % modulo) % modulo
+        Nj, (Mj, mj), (Rj, rj) = Nj//p, divmod(Mj, p), divmod(Rj, p)
+        carry = (mj + rj + carry) // p
+        e0 += carry
+        if j >= q - 1: eq_1 += carry
+        prod *= numerator * invert(denominator, modulo)
+        prod %= modulo
+        j += 1
+
+    mul = pow(1 if p == 2 and q >= 3 else -1, eq_1, modulo)
+    return (pow(p, e0, modulo) * mul * prod) % modulo

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/tests/test_bbp_pi.py

@@ -0,0 +1,134 @@
+from sympy.core.random import randint
+
+from sympy.ntheory.bbp_pi import pi_hex_digits
+from sympy.testing.pytest import raises
+
+
+# http://www.herongyang.com/Cryptography/Blowfish-First-8366-Hex-Digits-of-PI.html
+# There are actually 8336 listed there; with the prepended 3 there are 8337
+# below
+dig=''.join('''
+3243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89452821e638d013
+77be5466cf34e90c6cc0ac29b7c97c50dd3f84d5b5b54709179216d5d98979fb1bd1310ba698dfb5
+ac2ffd72dbd01adfb7b8e1afed6a267e96ba7c9045f12c7f9924a19947b3916cf70801f2e2858efc
+16636920d871574e69a458fea3f4933d7e0d95748f728eb658718bcd5882154aee7b54a41dc25a59
+b59c30d5392af26013c5d1b023286085f0ca417918b8db38ef8e79dcb0603a180e6c9e0e8bb01e8a
+3ed71577c1bd314b2778af2fda55605c60e65525f3aa55ab945748986263e8144055ca396a2aab10
+b6b4cc5c341141e8cea15486af7c72e993b3ee1411636fbc2a2ba9c55d741831f6ce5c3e169b8793
+1eafd6ba336c24cf5c7a325381289586773b8f48986b4bb9afc4bfe81b6628219361d809ccfb21a9
+91487cac605dec8032ef845d5de98575b1dc262302eb651b8823893e81d396acc50f6d6ff383f442
+392e0b4482a484200469c8f04a9e1f9b5e21c66842f6e96c9a670c9c61abd388f06a51a0d2d8542f
+68960fa728ab5133a36eef0b6c137a3be4ba3bf0507efb2a98a1f1651d39af017666ca593e82430e
+888cee8619456f9fb47d84a5c33b8b5ebee06f75d885c12073401a449f56c16aa64ed3aa62363f77
+061bfedf72429b023d37d0d724d00a1248db0fead349f1c09b075372c980991b7b25d479d8f6e8de
+f7e3fe501ab6794c3b976ce0bd04c006bac1a94fb6409f60c45e5c9ec2196a246368fb6faf3e6c53
+b51339b2eb3b52ec6f6dfc511f9b30952ccc814544af5ebd09bee3d004de334afd660f2807192e4b
+b3c0cba85745c8740fd20b5f39b9d3fbdb5579c0bd1a60320ad6a100c6402c7279679f25fefb1fa3
+cc8ea5e9f8db3222f83c7516dffd616b152f501ec8ad0552ab323db5fafd23876053317b483e00df
+829e5c57bbca6f8ca01a87562edf1769dbd542a8f6287effc3ac6732c68c4f5573695b27b0bbca58
+c8e1ffa35db8f011a010fa3d98fd2183b84afcb56c2dd1d35b9a53e479b6f84565d28e49bc4bfb97
+90e1ddf2daa4cb7e3362fb1341cee4c6e8ef20cada36774c01d07e9efe2bf11fb495dbda4dae9091
+98eaad8e716b93d5a0d08ed1d0afc725e08e3c5b2f8e7594b78ff6e2fbf2122b648888b812900df0
+1c4fad5ea0688fc31cd1cff191b3a8c1ad2f2f2218be0e1777ea752dfe8b021fa1e5a0cc0fb56f74
+e818acf3d6ce89e299b4a84fe0fd13e0b77cc43b81d2ada8d9165fa2668095770593cc7314211a14
+77e6ad206577b5fa86c75442f5fb9d35cfebcdaf0c7b3e89a0d6411bd3ae1e7e4900250e2d2071b3
+5e226800bb57b8e0af2464369bf009b91e5563911d59dfa6aa78c14389d95a537f207d5ba202e5b9
+c5832603766295cfa911c819684e734a41b3472dca7b14a94a1b5100529a532915d60f573fbc9bc6
+e42b60a47681e6740008ba6fb5571be91ff296ec6b2a0dd915b6636521e7b9f9b6ff34052ec58556
+6453b02d5da99f8fa108ba47996e85076a4b7a70e9b5b32944db75092ec4192623ad6ea6b049a7df
+7d9cee60b88fedb266ecaa8c71699a17ff5664526cc2b19ee1193602a575094c29a0591340e4183a
+3e3f54989a5b429d656b8fe4d699f73fd6a1d29c07efe830f54d2d38e6f0255dc14cdd20868470eb
+266382e9c6021ecc5e09686b3f3ebaefc93c9718146b6a70a1687f358452a0e286b79c5305aa5007
+373e07841c7fdeae5c8e7d44ec5716f2b8b03ada37f0500c0df01c1f040200b3ffae0cf51a3cb574
+b225837a58dc0921bdd19113f97ca92ff69432477322f547013ae5e58137c2dadcc8b576349af3dd
+a7a94461460fd0030eecc8c73ea4751e41e238cd993bea0e2f3280bba1183eb3314e548b384f6db9
+086f420d03f60a04bf2cb8129024977c795679b072bcaf89afde9a771fd9930810b38bae12dccf3f
+2e5512721f2e6b7124501adde69f84cd877a5847187408da17bc9f9abce94b7d8cec7aec3adb851d
+fa63094366c464c3d2ef1c18473215d908dd433b3724c2ba1612a14d432a65c45150940002133ae4
+dd71dff89e10314e5581ac77d65f11199b043556f1d7a3c76b3c11183b5924a509f28fe6ed97f1fb
+fa9ebabf2c1e153c6e86e34570eae96fb1860e5e0a5a3e2ab3771fe71c4e3d06fa2965dcb999e71d
+0f803e89d65266c8252e4cc9789c10b36ac6150eba94e2ea78a5fc3c531e0a2df4f2f74ea7361d2b
+3d1939260f19c279605223a708f71312b6ebadfe6eeac31f66e3bc4595a67bc883b17f37d1018cff
+28c332ddefbe6c5aa56558218568ab9802eecea50fdb2f953b2aef7dad5b6e2f841521b628290761
+70ecdd4775619f151013cca830eb61bd960334fe1eaa0363cfb5735c904c70a239d59e9e0bcbaade
+14eecc86bc60622ca79cab5cabb2f3846e648b1eaf19bdf0caa02369b9655abb5040685a323c2ab4
+b3319ee9d5c021b8f79b540b19875fa09995f7997e623d7da8f837889a97e32d7711ed935f166812
+810e358829c7e61fd696dedfa17858ba9957f584a51b2272639b83c3ff1ac24696cdb30aeb532e30
+548fd948e46dbc312858ebf2ef34c6ffeafe28ed61ee7c3c735d4a14d9e864b7e342105d14203e13
+e045eee2b6a3aaabeadb6c4f15facb4fd0c742f442ef6abbb5654f3b1d41cd2105d81e799e86854d
+c7e44b476a3d816250cf62a1f25b8d2646fc8883a0c1c7b6a37f1524c369cb749247848a0b5692b2
+85095bbf00ad19489d1462b17423820e0058428d2a0c55f5ea1dadf43e233f70613372f0928d937e
+41d65fecf16c223bdb7cde3759cbee74604085f2a7ce77326ea607808419f8509ee8efd85561d997
+35a969a7aac50c06c25a04abfc800bcadc9e447a2ec3453484fdd567050e1e9ec9db73dbd3105588
+cd675fda79e3674340c5c43465713e38d83d28f89ef16dff20153e21e78fb03d4ae6e39f2bdb83ad
+f7e93d5a68948140f7f64c261c94692934411520f77602d4f7bcf46b2ed4a20068d40824713320f4
+6a43b7d4b7500061af1e39f62e9724454614214f74bf8b88404d95fc1d96b591af70f4ddd366a02f
+45bfbc09ec03bd97857fac6dd031cb850496eb27b355fd3941da2547e6abca0a9a28507825530429
+f40a2c86dae9b66dfb68dc1462d7486900680ec0a427a18dee4f3ffea2e887ad8cb58ce0067af4d6
+b6aace1e7cd3375fecce78a399406b2a4220fe9e35d9f385b9ee39d7ab3b124e8b1dc9faf74b6d18
+5626a36631eae397b23a6efa74dd5b43326841e7f7ca7820fbfb0af54ed8feb397454056acba4895
+2755533a3a20838d87fe6ba9b7d096954b55a867bca1159a58cca9296399e1db33a62a4a563f3125
+f95ef47e1c9029317cfdf8e80204272f7080bb155c05282ce395c11548e4c66d2248c1133fc70f86
+dc07f9c9ee41041f0f404779a45d886e17325f51ebd59bc0d1f2bcc18f41113564257b7834602a9c
+60dff8e8a31f636c1b0e12b4c202e1329eaf664fd1cad181156b2395e0333e92e13b240b62eebeb9
+2285b2a20ee6ba0d99de720c8c2da2f728d012784595b794fd647d0862e7ccf5f05449a36f877d48
+fac39dfd27f33e8d1e0a476341992eff743a6f6eabf4f8fd37a812dc60a1ebddf8991be14cdb6e6b
+0dc67b55106d672c372765d43bdcd0e804f1290dc7cc00ffa3b5390f92690fed0b667b9ffbcedb7d
+9ca091cf0bd9155ea3bb132f88515bad247b9479bf763bd6eb37392eb3cc1159798026e297f42e31
+2d6842ada7c66a2b3b12754ccc782ef11c6a124237b79251e706a1bbe64bfb63501a6b101811caed
+fa3d25bdd8e2e1c3c9444216590a121386d90cec6ed5abea2a64af674eda86a85fbebfe98864e4c3
+fe9dbc8057f0f7c08660787bf86003604dd1fd8346f6381fb07745ae04d736fccc83426b33f01eab
+71b08041873c005e5f77a057bebde8ae2455464299bf582e614e58f48ff2ddfda2f474ef388789bd
+c25366f9c3c8b38e74b475f25546fcd9b97aeb26618b1ddf84846a0e79915f95e2466e598e20b457
+708cd55591c902de4cb90bace1bb8205d011a862487574a99eb77f19b6e0a9dc09662d09a1c43246
+33e85a1f0209f0be8c4a99a0251d6efe101ab93d1d0ba5a4dfa186f20f2868f169dcb7da83573906
+fea1e2ce9b4fcd7f5250115e01a70683faa002b5c40de6d0279af88c27773f8641c3604c0661a806
+b5f0177a28c0f586e0006058aa30dc7d6211e69ed72338ea6353c2dd94c2c21634bbcbee5690bcb6
+deebfc7da1ce591d766f05e4094b7c018839720a3d7c927c2486e3725f724d9db91ac15bb4d39eb8
+fced54557808fca5b5d83d7cd34dad0fc41e50ef5eb161e6f8a28514d96c51133c6fd5c7e756e14e
+c4362abfceddc6c837d79a323492638212670efa8e406000e03a39ce37d3faf5cfabc277375ac52d
+1b5cb0679e4fa33742d382274099bc9bbed5118e9dbf0f7315d62d1c7ec700c47bb78c1b6b21a190
+45b26eb1be6a366eb45748ab2fbc946e79c6a376d26549c2c8530ff8ee468dde7dd5730a1d4cd04d
+c62939bbdba9ba4650ac9526e8be5ee304a1fad5f06a2d519a63ef8ce29a86ee22c089c2b843242e
+f6a51e03aa9cf2d0a483c061ba9be96a4d8fe51550ba645bd62826a2f9a73a3ae14ba99586ef5562
+e9c72fefd3f752f7da3f046f6977fa0a5980e4a91587b086019b09e6ad3b3ee593e990fd5a9e34d7
+972cf0b7d9022b8b5196d5ac3a017da67dd1cf3ed67c7d2d281f9f25cfadf2b89b5ad6b4725a88f5
+4ce029ac71e019a5e647b0acfded93fa9be8d3c48d283b57ccf8d5662979132e28785f0191ed7560
+55f7960e44e3d35e8c15056dd488f46dba03a161250564f0bdc3eb9e153c9057a297271aeca93a07
+2a1b3f6d9b1e6321f5f59c66fb26dcf3197533d928b155fdf5035634828aba3cbb28517711c20ad9
+f8abcc5167ccad925f4de817513830dc8e379d58629320f991ea7a90c2fb3e7bce5121ce64774fbe
+32a8b6e37ec3293d4648de53696413e680a2ae0810dd6db22469852dfd09072166b39a460a6445c0
+dd586cdecf1c20c8ae5bbef7dd1b588d40ccd2017f6bb4e3bbdda26a7e3a59ff453e350a44bcb4cd
+d572eacea8fa6484bb8d6612aebf3c6f47d29be463542f5d9eaec2771bf64e6370740e0d8de75b13
+57f8721671af537d5d4040cb084eb4e2cc34d2466a0115af84e1b0042895983a1d06b89fb4ce6ea0
+486f3f3b823520ab82011a1d4b277227f8611560b1e7933fdcbb3a792b344525bda08839e151ce79
+4b2f32c9b7a01fbac9e01cc87ebcc7d1f6cf0111c3a1e8aac71a908749d44fbd9ad0dadecbd50ada
+380339c32ac69136678df9317ce0b12b4ff79e59b743f5bb3af2d519ff27d9459cbf97222c15e6fc
+2a0f91fc719b941525fae59361ceb69cebc2a8645912baa8d1b6c1075ee3056a0c10d25065cb03a4
+42e0ec6e0e1698db3b4c98a0be3278e9649f1f9532e0d392dfd3a0342b8971f21e1b0a74414ba334
+8cc5be7120c37632d8df359f8d9b992f2ee60b6f470fe3f11de54cda541edad891ce6279cfcd3e7e
+6f1618b166fd2c1d05848fd2c5f6fb2299f523f357a632762393a8353156cccd02acf081625a75eb
+b56e16369788d273ccde96629281b949d04c50901b71c65614e6c6c7bd327a140a45e1d006c3f27b
+9ac9aa53fd62a80f00bb25bfe235bdd2f671126905b2040222b6cbcf7ccd769c2b53113ec01640e3
+d338abbd602547adf0ba38209cf746ce7677afa1c52075606085cbfe4e8ae88dd87aaaf9b04cf9aa
+7e1948c25c02fb8a8c01c36ae4d6ebe1f990d4f869a65cdea03f09252dc208e69fb74e6132ce77e2
+5b578fdfe33ac372e6'''.split())
+
+
+def test_hex_pi_nth_digits():
+    assert pi_hex_digits(0) == '3243f6a8885a30'
+    assert pi_hex_digits(1) ==  '243f6a8885a308'
+    assert pi_hex_digits(10000) == '68ac8fcfb8016c'
+    assert pi_hex_digits(13) == '08d313198a2e03'
+    assert pi_hex_digits(0, 3) == '324'
+    assert pi_hex_digits(0, 0) == ''
+    raises(ValueError, lambda: pi_hex_digits(-1))
+    raises(ValueError, lambda: pi_hex_digits(0, -1))
+    raises(ValueError, lambda: pi_hex_digits(3.14))
+
+    # this will pick a random segment to compute every time
+    # it is run. If it ever fails, there is an error in the
+    # computation.
+    n = randint(0, len(dig))
+    prec = randint(0, len(dig) - n)
+    assert pi_hex_digits(n, prec) == dig[n: n + prec]

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/tests/test_digits.py

@@ -0,0 +1,55 @@
+from sympy.ntheory import count_digits, digits, is_palindromic
+from sympy.core.intfunc import num_digits
+
+from sympy.testing.pytest import raises
+
+
+def test_num_digits():
+    # depending on whether one rounds up or down or uses log or log10,
+    # one or more of these will fail if you don't check for the off-by
+    # one condition
+    assert num_digits(2, 2) == 2
+    assert num_digits(2**48 - 1, 2) == 48
+    assert num_digits(1000, 10) == 4
+    assert num_digits(125, 5) == 4
+    assert num_digits(100, 16) == 2
+    assert num_digits(-1000, 10) == 4
+    # if changes are made to the function, this structured test over
+    # this range will expose problems
+    for base in range(2, 100):
+        for e in range(1, 100):
+            n = base**e
+            assert num_digits(n, base) == e + 1
+            assert num_digits(n + 1, base) == e + 1
+            assert num_digits(n - 1, base) == e
+
+
+def test_digits():
+    assert all(digits(n, 2)[1:] == [int(d) for d in format(n, 'b')]
+                for n in range(20))
+    assert all(digits(n, 8)[1:] == [int(d) for d in format(n, 'o')]
+                for n in range(20))
+    assert all(digits(n, 16)[1:] == [int(d, 16) for d in format(n, 'x')]
+                for n in range(20))
+    assert digits(2345, 34) == [34, 2, 0, 33]
+    assert digits(384753, 71) == [71, 1, 5, 23, 4]
+    assert digits(93409, 10) == [10, 9, 3, 4, 0, 9]
+    assert digits(-92838, 11) == [-11, 6, 3, 8, 2, 9]
+    assert digits(35, 10) == [10, 3, 5]
+    assert digits(35, 10, 3) == [10, 0, 3, 5]
+    assert digits(-35, 10, 4) == [-10, 0, 0, 3, 5]
+    raises(ValueError, lambda: digits(2, 2, 1))
+
+
+def test_count_digits():
+    assert count_digits(55, 2) == {1: 5, 0: 1}
+    assert count_digits(55, 10) == {5: 2}
+    n = count_digits(123)
+    assert n[4] == 0 and type(n[4]) is int
+
+
+def test_is_palindromic():
+    assert is_palindromic(-11)
+    assert is_palindromic(11)
+    assert is_palindromic(0o121, 8)
+    assert not is_palindromic(123)

infer_4_47_1/lib/python3.10/site-packages/sympy/ntheory/tests/test_hypothesis.py

@@ -0,0 +1,24 @@
+from hypothesis import given
+from hypothesis import strategies as st
+from sympy import divisors
+from sympy.functions.combinatorial.numbers import divisor_sigma, totient
+from sympy.ntheory.primetest import is_square
+
+
+@given(n=st.integers(1, 10**10))
+def test_tau_hypothesis(n):
+    div = divisors(n)
+    tau_n = len(div)
+    assert is_square(n) == (tau_n % 2 == 1)
+    sigmas = [divisor_sigma(i) for i in div]
+    totients = [totient(n // i) for i in div]
+    mul = [a * b for a, b in zip(sigmas, totients)]
+    assert n * tau_n == sum(mul)
+
+
+@given(n=st.integers(1, 10**10))
+def test_totient_hypothesis(n):
+    assert totient(n) <= n
+    div = divisors(n)
+    totients = [totient(i) for i in div]
+    assert n == sum(totients)