Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/sympy/benchmarks/bench_discrete_log.py

@@ -0,0 +1,83 @@
+import sys
+from time import time
+from sympy.ntheory.residue_ntheory import (discrete_log,
+        _discrete_log_trial_mul, _discrete_log_shanks_steps,
+        _discrete_log_pollard_rho, _discrete_log_pohlig_hellman)
+
+
+# Cyclic group (Z/pZ)* with p prime, order p - 1 and generator g
+data_set_1 = [
+        # p, p - 1, g
+        [191, 190, 19],
+        [46639, 46638, 6],
+        [14789363, 14789362, 2],
+        [4254225211, 4254225210, 2],
+        [432751500361, 432751500360, 7],
+        [158505390797053, 158505390797052, 2],
+        [6575202655312007, 6575202655312006, 5],
+        [8430573471995353769, 8430573471995353768, 3],
+        [3938471339744997827267, 3938471339744997827266, 2],
+        [875260951364705563393093, 875260951364705563393092, 5],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with prime order p and generator g
+# (n, p are primes and n = 2 * p + 1)
+data_set_2 = [
+        # n, p, g
+        [227, 113, 3],
+        [2447, 1223, 2],
+        [24527, 12263, 2],
+        [245639, 122819, 2],
+        [2456747, 1228373, 3],
+        [24567899, 12283949, 3],
+        [245679023, 122839511, 2],
+        [2456791307, 1228395653, 3],
+        [24567913439, 12283956719, 2],
+        [245679135407, 122839567703, 2],
+        [2456791354763, 1228395677381, 3],
+        [24567913550903, 12283956775451, 2],
+        [245679135509519, 122839567754759, 2],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with smooth order o and generator g
+data_set_3 = [
+        # n, o, g
+        [2**118, 2**116, 3],
+    ]
+
+
+def bench_discrete_log(data_set, algo=None):
+    if algo is None:
+        f = discrete_log
+    elif algo == 'trial':
+        f = _discrete_log_trial_mul
+    elif algo == 'shanks':
+        f = _discrete_log_shanks_steps
+    elif algo == 'rho':
+        f = _discrete_log_pollard_rho
+    elif algo == 'ph':
+        f = _discrete_log_pohlig_hellman
+    else:
+        raise ValueError("Argument 'algo' should be one"
+                " of ('trial', 'shanks', 'rho' or 'ph')")
+
+    for i, data in enumerate(data_set):
+        for j, (n, p, g) in enumerate(data):
+            t = time()
+            l = f(n, pow(g, p - 1, n), g, p)
+            t = time() - t
+            print('[%02d-%03d] %15.10f' % (i, j, t))
+            assert l == p - 1
+
+
+if __name__ == '__main__':
+    algo = sys.argv[1] \
+            if len(sys.argv) > 1 else None
+    data_set = [
+            data_set_1,
+            data_set_2,
+            data_set_3,
+        ]
+    bench_discrete_log(data_set, algo)

llmeval-env/lib/python3.10/site-packages/sympy/benchmarks/bench_meijerint.py

@@ -0,0 +1,261 @@
+# conceal the implicit import from the code quality tester
+from sympy.core.numbers import (oo, pi)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate
+from sympy.integrals.transforms import (mellin_transform,
+    inverse_fourier_transform, inverse_mellin_transform,
+    laplace_transform, inverse_laplace_transform, fourier_transform)
+
+LT = laplace_transform
+FT = fourier_transform
+MT = mellin_transform
+IFT = inverse_fourier_transform
+ILT = inverse_laplace_transform
+IMT = inverse_mellin_transform
+
+from sympy.abc import x, y
+nu, beta, rho = symbols('nu beta rho')
+
+apos, bpos, cpos, dpos, posk, p = symbols('a b c d k p', positive=True)
+k = Symbol('k', real=True)
+negk = Symbol('k', negative=True)
+
+mu1, mu2 = symbols('mu1 mu2', real=True, nonzero=True, finite=True)
+sigma1, sigma2 = symbols('sigma1 sigma2', real=True, nonzero=True,
+                         finite=True, positive=True)
+rate = Symbol('lambda', positive=True)
+
+
+def normal(x, mu, sigma):
+    return 1/sqrt(2*pi*sigma**2)*exp(-(x - mu)**2/2/sigma**2)
+
+
+def exponential(x, rate):
+    return rate*exp(-rate*x)
+alpha, beta = symbols('alpha beta', positive=True)
+betadist = x**(alpha - 1)*(1 + x)**(-alpha - beta)*gamma(alpha + beta) \
+    /gamma(alpha)/gamma(beta)
+kint = Symbol('k', integer=True, positive=True)
+chi = 2**(1 - kint/2)*x**(kint - 1)*exp(-x**2/2)/gamma(kint/2)
+chisquared = 2**(-k/2)/gamma(k/2)*x**(k/2 - 1)*exp(-x/2)
+dagum = apos*p/x*(x/bpos)**(apos*p)/(1 + x**apos/bpos**apos)**(p + 1)
+d1, d2 = symbols('d1 d2', positive=True)
+f = sqrt(((d1*x)**d1 * d2**d2)/(d1*x + d2)**(d1 + d2))/x \
+    /gamma(d1/2)/gamma(d2/2)*gamma((d1 + d2)/2)
+nupos, sigmapos = symbols('nu sigma', positive=True)
+rice = x/sigmapos**2*exp(-(x**2 + nupos**2)/2/sigmapos**2)*besseli(0, x*
+                         nupos/sigmapos**2)
+mu = Symbol('mu', real=True)
+laplace = exp(-abs(x - mu)/bpos)/2/bpos
+
+u = Symbol('u', polar=True)
+tpos = Symbol('t', positive=True)
+
+
+def E(expr):
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (x, 0, oo), (y, -oo, oo), meijerg=True)
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (y, -oo, oo), (x, 0, oo), meijerg=True)
+
+bench = [
+    'MT(x**nu*Heaviside(x - 1), x, s)',
+    'MT(x**nu*Heaviside(1 - x), x, s)',
+    'MT((1-x)**(beta - 1)*Heaviside(1-x), x, s)',
+    'MT((x-1)**(beta - 1)*Heaviside(x-1), x, s)',
+    'MT((1+x)**(-rho), x, s)',
+    'MT(abs(1-x)**(-rho), x, s)',
+    'MT((1-x)**(beta-1)*Heaviside(1-x) + a*(x-1)**(beta-1)*Heaviside(x-1), x, s)',
+    'MT((x**a-b**a)/(x-b), x, s)',
+    'MT((x**a-bpos**a)/(x-bpos), x, s)',
+    'MT(exp(-x), x, s)',
+    'MT(exp(-1/x), x, s)',
+    'MT(log(x)**4*Heaviside(1-x), x, s)',
+    'MT(log(x)**3*Heaviside(x-1), x, s)',
+    'MT(log(x + 1), x, s)',
+    'MT(log(1/x + 1), x, s)',
+    'MT(log(abs(1 - x)), x, s)',
+    'MT(log(abs(1 - 1/x)), x, s)',
+    'MT(log(x)/(x+1), x, s)',
+    'MT(log(x)**2/(x+1), x, s)',
+    'MT(log(x)/(x+1)**2, x, s)',
+    'MT(erf(sqrt(x)), x, s)',
+
+    'MT(besselj(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2, x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(-a, sqrt(x)), x, s)',
+    'MT(besselj(a - 1, sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(b, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2 + besselj(-a, sqrt(x))**2, x, s)',
+    'MT(bessely(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(b, sqrt(x)), x, s)',
+    'MT(bessely(a, sqrt(x))**2, x, s)',
+
+    'MT(besselk(a, 2*sqrt(x)), x, s)',
+    'MT(besselj(a, 2*sqrt(2*sqrt(x)))*besselk(a, 2*sqrt(2*sqrt(x))), x, s)',
+    'MT(besseli(a, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(besseli(b, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(exp(-x/2)*besselk(a, x/2), x, s)',
+
+    # later: ILT, IMT
+
+    'LT((t-apos)**bpos*exp(-cpos*(t-apos))*Heaviside(t-apos), t, s)',
+    'LT(t**apos, t, s)',
+    'LT(Heaviside(t), t, s)',
+    'LT(Heaviside(t - apos), t, s)',
+    'LT(1 - exp(-apos*t), t, s)',
+    'LT((exp(2*t)-1)*exp(-bpos - t)*Heaviside(t)/2, t, s, noconds=True)',
+    'LT(exp(t), t, s)',
+    'LT(exp(2*t), t, s)',
+    'LT(exp(apos*t), t, s)',
+    'LT(log(t/apos), t, s)',
+    'LT(erf(t), t, s)',
+    'LT(sin(apos*t), t, s)',
+    'LT(cos(apos*t), t, s)',
+    'LT(exp(-apos*t)*sin(bpos*t), t, s)',
+    'LT(exp(-apos*t)*cos(bpos*t), t, s)',
+    'LT(besselj(0, t), t, s, noconds=True)',
+    'LT(besselj(1, t), t, s, noconds=True)',
+
+    'FT(Heaviside(1 - abs(2*apos*x)), x, k)',
+    'FT(Heaviside(1-abs(apos*x))*(1-abs(apos*x)), x, k)',
+    'FT(exp(-apos*x)*Heaviside(x), x, k)',
+    'IFT(1/(apos + 2*pi*I*x), x, posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, -posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, negk)',
+    'FT(x*exp(-apos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x)*sin(bpos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x**2), x, k)',
+    'IFT(sqrt(pi/apos)*exp(-(pi*k)**2/apos), k, x)',
+    'FT(exp(-apos*abs(x)), x, k)',
+
+    'integrate(normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**3*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y+1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y-1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                   (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x**2*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'E(1)',
+    'E(x*y)',
+    'E(x*y**2)',
+    'E((x+y+1)**2)',
+    'E(x+y+1)',
+    'E((x+y-1)**2)',
+    'integrate(betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(chi, (x, 0, oo), meijerg=True)',
+    'integrate(x*chi, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chi, (x, 0, oo), meijerg=True)',
+    'integrate(chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(((x-k)/sqrt(2*k))**3*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(f, (x, 0, oo), meijerg=True)',
+    'integrate(x*f, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*f, (x, 0, oo), meijerg=True)',
+    'integrate(rice, (x, 0, oo), meijerg=True)',
+    'integrate(laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(log(x) * x**(k-1) * exp(-x) / gamma(k), (x, 0, oo))',
+
+    'integrate(sin(z*x)*(x**2-1)**(-(y+S(1)/2)), (x, 1, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*besselk(0,x), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(a,x)*besselj(b,x)/x, (x,0,oo), meijerg=True)',
+
+    'hyperexpand(meijerg((-s - a/2 + 1, -s + a/2 + 1), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), (a/2, -a/2), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), 1))',
+    "gammasimp(S('2**(2*s)*(-pi*gamma(-a + 1)*gamma(a + 1)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 3/2)*gamma(a + s + 1)/(a*(a + s)) - gamma(-a - 1/2)*gamma(-a + 1)*gamma(a + 1)*gamma(a + 3/2)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a + s + 1)*gamma(a - s + 1)/(a*(-a + s)))*gamma(-2*s + 1)*gamma(s + 1)/(pi*s*gamma(-a - 1/2)*gamma(a + 3/2)*gamma(-s + 1)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 1)*gamma(a - s + 3/2))'))",
+
+    'mellin_transform(E1(x), x, s)',
+    'inverse_mellin_transform(gamma(s)/s, s, x, (0, oo))',
+    'mellin_transform(expint(a, x), x, s)',
+    'mellin_transform(Si(x), x, s)',
+    'inverse_mellin_transform(-2**s*sqrt(pi)*gamma((s + 1)/2)/(2*s*gamma(-s/2 + 1)), s, x, (-1, 0))',
+    'mellin_transform(Ci(sqrt(x)), x, s)',
+    'inverse_mellin_transform(-4**s*sqrt(pi)*gamma(s)/(2*s*gamma(-s + S(1)/2)),s, u, (0, 1))',
+    'laplace_transform(Ci(x), x, s)',
+    'laplace_transform(expint(a, x), x, s)',
+    'laplace_transform(expint(1, x), x, s)',
+    'laplace_transform(expint(2, x), x, s)',
+    'inverse_laplace_transform(-log(1 + s**2)/2/s, s, u)',
+    'inverse_laplace_transform(log(s + 1)/s, s, x)',
+    'inverse_laplace_transform((s - log(s + 1))/s**2, s, x)',
+    'laplace_transform(Chi(x), x, s)',
+    'laplace_transform(Shi(x), x, s)',
+
+    'integrate(exp(-z*x)/x, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**2, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**3, (x, 1, oo), meijerg=True,conds="none")',
+    'integrate(-cos(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(-sin(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(sin(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(sinh(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(exp(-x)/x, x, meijerg=True)',
+    'integrate(exp(-x)/x**2, x, meijerg=True)',
+    'integrate(cos(u)/u, u, meijerg=True)',
+    'integrate(cosh(u)/u, u, meijerg=True)',
+    'integrate(expint(1, x), x, meijerg=True)',
+    'integrate(expint(2, x), x, meijerg=True)',
+    'integrate(Si(x), x, meijerg=True)',
+    'integrate(Ci(u), u, meijerg=True)',
+    'integrate(Shi(x), x, meijerg=True)',
+    'integrate(Chi(u), u, meijerg=True)',
+    'integrate(Si(x)*exp(-x), (x, 0, oo), meijerg=True)',
+    'integrate(expint(1, x)*sin(x), (x, 0, oo), meijerg=True)'
+]
+
+from time import time
+from sympy.core.cache import clear_cache
+import sys
+
+timings = []
+
+if __name__ == '__main__':
+    for n, string in enumerate(bench):
+        clear_cache()
+        _t = time()
+        exec(string)
+        _t = time() - _t
+        timings += [(_t, string)]
+        sys.stdout.write('.')
+        sys.stdout.flush()
+        if n % (len(bench) // 10) == 0:
+            sys.stdout.write('%s' % (10*n // len(bench)))
+    print()
+
+    timings.sort(key=lambda x: -x[0])
+
+    for ti, string in timings:
+        print('%.2fs %s' % (ti, string))

llmeval-env/lib/python3.10/site-packages/sympy/benchmarks/bench_symbench.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+from sympy.core.random import random
+from sympy.core.numbers import (I, Integer, pi)
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import factor
+from sympy.simplify.simplify import simplify
+from sympy.abc import x, y, z
+from timeit import default_timer as clock
+
+
+def bench_R1():
+    "real(f(f(f(f(f(f(f(f(f(f(i/2)))))))))))"
+    def f(z):
+        return sqrt(Integer(1)/3)*z**2 + I/3
+    f(f(f(f(f(f(f(f(f(f(I/2)))))))))).as_real_imag()[0]
+
+
+def bench_R2():
+    "Hermite polynomial hermite(15, y)"
+    def hermite(n, y):
+        if n == 1:
+            return 2*y
+        if n == 0:
+            return 1
+        return (2*y*hermite(n - 1, y) - 2*(n - 1)*hermite(n - 2, y)).expand()
+
+    hermite(15, y)
+
+
+def bench_R3():
+    "a = [bool(f==f) for _ in range(10)]"
+    f = x + y + z
+    [bool(f == f) for _ in range(10)]
+
+
+def bench_R4():
+    # we don't have Tuples
+    pass
+
+
+def bench_R5():
+    "blowup(L, 8); L=uniq(L)"
+    def blowup(L, n):
+        for i in range(n):
+            L.append( (L[i] + L[i + 1]) * L[i + 2] )
+
+    def uniq(x):
+        v = set(x)
+        return v
+    L = [x, y, z]
+    blowup(L, 8)
+    L = uniq(L)
+
+
+def bench_R6():
+    "sum(simplify((x+sin(i))/x+(x-sin(i))/x) for i in range(100))"
+    sum(simplify((x + sin(i))/x + (x - sin(i))/x) for i in range(100))
+
+
+def bench_R7():
+    "[f.subs(x, random()) for _ in range(10**4)]"
+    f = x**24 + 34*x**12 + 45*x**3 + 9*x**18 + 34*x**10 + 32*x**21
+    [f.subs(x, random()) for _ in range(10**4)]
+
+
+def bench_R8():
+    "right(x^2,0,5,10^4)"
+    def right(f, a, b, n):
+        a = sympify(a)
+        b = sympify(b)
+        n = sympify(n)
+        x = f.atoms(Symbol).pop()
+        Deltax = (b - a)/n
+        c = a
+        est = 0
+        for i in range(n):
+            c += Deltax
+            est += f.subs(x, c)
+        return est*Deltax
+
+    right(x**2, 0, 5, 10**4)
+
+
+def _bench_R9():
+    "factor(x^20 - pi^5*y^20)"
+    factor(x**20 - pi**5*y**20)
+
+
+def bench_R10():
+    "v = [-pi,-pi+1/10..,pi]"
+    def srange(min, max, step):
+        v = [min]
+        while (max - v[-1]).evalf() > 0:
+            v.append(v[-1] + step)
+        return v[:-1]
+    srange(-pi, pi, sympify(1)/10)
+
+
+def bench_R11():
+    "a = [random() + random()*I for w in [0..1000]]"
+    [random() + random()*I for w in range(1000)]
+
+
+def bench_S1():
+    "e=(x+y+z+1)**7;f=e*(e+1);f.expand()"
+    e = (x + y + z + 1)**7
+    f = e*(e + 1)
+    f.expand()
+
+
+if __name__ == '__main__':
+    benchmarks = [
+        bench_R1,
+        bench_R2,
+        bench_R3,
+        bench_R5,
+        bench_R6,
+        bench_R7,
+        bench_R8,
+        #_bench_R9,
+        bench_R10,
+        bench_R11,
+        #bench_S1,
+    ]
+
+    report = []
+    for b in benchmarks:
+        t = clock()
+        b()
+        t = clock() - t
+        print("%s%65s: %f" % (b.__name__, b.__doc__, t))

llmeval-env/lib/python3.10/site-packages/sympy/crypto/__init__.py

@@ -0,0 +1,35 @@
+from sympy.crypto.crypto import (cycle_list,
+        encipher_shift, encipher_affine, encipher_substitution,
+        check_and_join, encipher_vigenere, decipher_vigenere, bifid5_square,
+        bifid6_square, encipher_hill, decipher_hill,
+        encipher_bifid5, encipher_bifid6, decipher_bifid5,
+        decipher_bifid6, encipher_kid_rsa, decipher_kid_rsa,
+        kid_rsa_private_key, kid_rsa_public_key, decipher_rsa, rsa_private_key,
+        rsa_public_key, encipher_rsa, lfsr_connection_polynomial,
+        lfsr_autocorrelation, lfsr_sequence, encode_morse, decode_morse,
+        elgamal_private_key, elgamal_public_key, decipher_elgamal,
+        encipher_elgamal, dh_private_key, dh_public_key, dh_shared_key,
+        padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5,
+        bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key,
+        gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg,
+        encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash,
+        encipher_railfence, decipher_railfence)
+
+__all__ = [
+    'cycle_list', 'encipher_shift', 'encipher_affine',
+    'encipher_substitution', 'check_and_join', 'encipher_vigenere',
+    'decipher_vigenere', 'bifid5_square', 'bifid6_square', 'encipher_hill',
+    'decipher_hill', 'encipher_bifid5', 'encipher_bifid6', 'decipher_bifid5',
+    'decipher_bifid6', 'encipher_kid_rsa', 'decipher_kid_rsa',
+    'kid_rsa_private_key', 'kid_rsa_public_key', 'decipher_rsa',
+    'rsa_private_key', 'rsa_public_key', 'encipher_rsa',
+    'lfsr_connection_polynomial', 'lfsr_autocorrelation', 'lfsr_sequence',
+    'encode_morse', 'decode_morse', 'elgamal_private_key',
+    'elgamal_public_key', 'decipher_elgamal', 'encipher_elgamal',
+    'dh_private_key', 'dh_public_key', 'dh_shared_key', 'padded_key',
+    'encipher_bifid', 'decipher_bifid', 'bifid_square', 'bifid5', 'bifid6',
+    'bifid10', 'decipher_gm', 'encipher_gm', 'gm_public_key',
+    'gm_private_key', 'bg_private_key', 'bg_public_key', 'encipher_bg',
+    'decipher_bg', 'encipher_rot13', 'decipher_rot13', 'encipher_atbash',
+    'decipher_atbash', 'encipher_railfence', 'decipher_railfence',
+]

llmeval-env/lib/python3.10/site-packages/sympy/crypto/crypto.py

@@ -0,0 +1,3360 @@
+"""
+This file contains some classical ciphers and routines
+implementing a linear-feedback shift register (LFSR)
+and the Diffie-Hellman key exchange.
+
+.. warning::
+
+   This module is intended for educational purposes only. Do not use the
+   functions in this module for real cryptographic applications. If you wish
+   to encrypt real data, we recommend using something like the `cryptography
+   <https://cryptography.io/en/latest/>`_ module.
+
+"""
+
+from string import whitespace, ascii_uppercase as uppercase, printable
+from functools import reduce
+import warnings
+
+from itertools import cycle
+
+from sympy.core import Symbol
+from sympy.core.numbers import igcdex, mod_inverse, igcd, Rational
+from sympy.core.random import _randrange, _randint
+from sympy.matrices import Matrix
+from sympy.ntheory import isprime, primitive_root, factorint
+from sympy.ntheory import totient as _euler
+from sympy.ntheory import reduced_totient as _carmichael
+from sympy.ntheory.generate import nextprime
+from sympy.ntheory.modular import crt
+from sympy.polys.domains import FF
+from sympy.polys.polytools import gcd, Poly
+from sympy.utilities.misc import as_int, filldedent, translate
+from sympy.utilities.iterables import uniq, multiset
+
+
+class NonInvertibleCipherWarning(RuntimeWarning):
+    """A warning raised if the cipher is not invertible."""
+    def __init__(self, msg):
+        self.fullMessage = msg
+
+    def __str__(self):
+        return '\n\t' + self.fullMessage
+
+    def warn(self, stacklevel=3):
+        warnings.warn(self, stacklevel=stacklevel)
+
+
+def AZ(s=None):
+    """Return the letters of ``s`` in uppercase. In case more than
+    one string is passed, each of them will be processed and a list
+    of upper case strings will be returned.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import AZ
+    >>> AZ('Hello, world!')
+    'HELLOWORLD'
+    >>> AZ('Hello, world!'.split())
+    ['HELLO', 'WORLD']
+
+    See Also
+    ========
+
+    check_and_join
+
+    """
+    if not s:
+        return uppercase
+    t = isinstance(s, str)
+    if t:
+        s = [s]
+    rv = [check_and_join(i.upper().split(), uppercase, filter=True)
+        for i in s]
+    if t:
+        return rv[0]
+    return rv
+
+bifid5 = AZ().replace('J', '')
+bifid6 = AZ() + '0123456789'
+bifid10 = printable
+
+
+def padded_key(key, symbols):
+    """Return a string of the distinct characters of ``symbols`` with
+    those of ``key`` appearing first. A ValueError is raised if
+    a) there are duplicate characters in ``symbols`` or
+    b) there are characters in ``key`` that are  not in ``symbols``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import padded_key
+    >>> padded_key('PUPPY', 'OPQRSTUVWXY')
+    'PUYOQRSTVWX'
+    >>> padded_key('RSA', 'ARTIST')
+    Traceback (most recent call last):
+    ...
+    ValueError: duplicate characters in symbols: T
+
+    """
+    syms = list(uniq(symbols))
+    if len(syms) != len(symbols):
+        extra = ''.join(sorted({
+            i for i in symbols if symbols.count(i) > 1}))
+        raise ValueError('duplicate characters in symbols: %s' % extra)
+    extra = set(key) - set(syms)
+    if extra:
+        raise ValueError(
+            'characters in key but not symbols: %s' % ''.join(
+            sorted(extra)))
+    key0 = ''.join(list(uniq(key)))
+    # remove from syms characters in key0
+    return key0 + translate(''.join(syms), None, key0)
+
+
+def check_and_join(phrase, symbols=None, filter=None):
+    """
+    Joins characters of ``phrase`` and if ``symbols`` is given, raises
+    an error if any character in ``phrase`` is not in ``symbols``.
+
+    Parameters
+    ==========
+
+    phrase
+        String or list of strings to be returned as a string.
+
+    symbols
+        Iterable of characters allowed in ``phrase``.
+
+        If ``symbols`` is ``None``, no checking is performed.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import check_and_join
+    >>> check_and_join('a phrase')
+    'a phrase'
+    >>> check_and_join('a phrase'.upper().split())
+    'APHRASE'
+    >>> check_and_join('a phrase!'.upper().split(), 'ARE', filter=True)
+    'ARAE'
+    >>> check_and_join('a phrase!'.upper().split(), 'ARE')
+    Traceback (most recent call last):
+    ...
+    ValueError: characters in phrase but not symbols: "!HPS"
+
+    """
+    rv = ''.join(''.join(phrase))
+    if symbols is not None:
+        symbols = check_and_join(symbols)
+        missing = ''.join(sorted(set(rv) - set(symbols)))
+        if missing:
+            if not filter:
+                raise ValueError(
+                    'characters in phrase but not symbols: "%s"' % missing)
+            rv = translate(rv, None, missing)
+    return rv
+
+
+def _prep(msg, key, alp, default=None):
+    if not alp:
+        if not default:
+            alp = AZ()
+            msg = AZ(msg)
+            key = AZ(key)
+        else:
+            alp = default
+    else:
+        alp = ''.join(alp)
+    key = check_and_join(key, alp, filter=True)
+    msg = check_and_join(msg, alp, filter=True)
+    return msg, key, alp
+
+
+def cycle_list(k, n):
+    """
+    Returns the elements of the list ``range(n)`` shifted to the
+    left by ``k`` (so the list starts with ``k`` (mod ``n``)).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import cycle_list
+    >>> cycle_list(3, 10)
+    [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]
+
+    """
+    k = k % n
+    return list(range(k, n)) + list(range(k))
+
+
+######## shift cipher examples ############
+
+
+def encipher_shift(msg, key, symbols=None):
+    """
+    Performs shift cipher encryption on plaintext msg, and returns the
+    ciphertext.
+
+    Parameters
+    ==========
+
+    key : int
+        The secret key.
+
+    msg : str
+        Plaintext of upper-case letters.
+
+    Returns
+    =======
+
+    str
+        Ciphertext of upper-case letters.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_shift, decipher_shift
+    >>> msg = "GONAVYBEATARMY"
+    >>> ct = encipher_shift(msg, 1); ct
+    'HPOBWZCFBUBSNZ'
+
+    To decipher the shifted text, change the sign of the key:
+
+    >>> encipher_shift(ct, -1)
+    'GONAVYBEATARMY'
+
+    There is also a convenience function that does this with the
+    original key:
+
+    >>> decipher_shift(ct, 1)
+    'GONAVYBEATARMY'
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L1`` of
+               corresponding integers.
+            2. Compute from the list ``L1`` a new list ``L2``, given by
+               adding ``(k mod 26)`` to each element in ``L1``.
+            3. Compute from the list ``L2`` a string ``ct`` of
+               corresponding letters.
+
+    The shift cipher is also called the Caesar cipher, after
+    Julius Caesar, who, according to Suetonius, used it with a
+    shift of three to protect messages of military significance.
+    Caesar's nephew Augustus reportedly used a similar cipher, but
+    with a right shift of 1.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Caesar_cipher
+    .. [2] https://mathworld.wolfram.com/CaesarsMethod.html
+
+    See Also
+    ========
+
+    decipher_shift
+
+    """
+    msg, _, A = _prep(msg, '', symbols)
+    shift = len(A) - key % len(A)
+    key = A[shift:] + A[:shift]
+    return translate(msg, key, A)
+
+
+def decipher_shift(msg, key, symbols=None):
+    """
+    Return the text by shifting the characters of ``msg`` to the
+    left by the amount given by ``key``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_shift, decipher_shift
+    >>> msg = "GONAVYBEATARMY"
+    >>> ct = encipher_shift(msg, 1); ct
+    'HPOBWZCFBUBSNZ'
+
+    To decipher the shifted text, change the sign of the key:
+
+    >>> encipher_shift(ct, -1)
+    'GONAVYBEATARMY'
+
+    Or use this function with the original key:
+
+    >>> decipher_shift(ct, 1)
+    'GONAVYBEATARMY'
+
+    """
+    return encipher_shift(msg, -key, symbols)
+
+def encipher_rot13(msg, symbols=None):
+    """
+    Performs the ROT13 encryption on a given plaintext ``msg``.
+
+    Explanation
+    ===========
+
+    ROT13 is a substitution cipher which substitutes each letter
+    in the plaintext message for the letter furthest away from it
+    in the English alphabet.
+
+    Equivalently, it is just a Caeser (shift) cipher with a shift
+    key of 13 (midway point of the alphabet).
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/ROT13
+
+    See Also
+    ========
+
+    decipher_rot13
+    encipher_shift
+
+    """
+    return encipher_shift(msg, 13, symbols)
+
+def decipher_rot13(msg, symbols=None):
+    """
+    Performs the ROT13 decryption on a given plaintext ``msg``.
+
+    Explanation
+    ============
+
+    ``decipher_rot13`` is equivalent to ``encipher_rot13`` as both
+    ``decipher_shift`` with a key of 13 and ``encipher_shift`` key with a
+    key of 13 will return the same results. Nonetheless,
+    ``decipher_rot13`` has nonetheless been explicitly defined here for
+    consistency.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_rot13, decipher_rot13
+    >>> msg = 'GONAVYBEATARMY'
+    >>> ciphertext = encipher_rot13(msg);ciphertext
+    'TBANILORNGNEZL'
+    >>> decipher_rot13(ciphertext)
+    'GONAVYBEATARMY'
+    >>> encipher_rot13(msg) == decipher_rot13(msg)
+    True
+    >>> msg == decipher_rot13(ciphertext)
+    True
+
+    """
+    return decipher_shift(msg, 13, symbols)
+
+######## affine cipher examples ############
+
+
+def encipher_affine(msg, key, symbols=None, _inverse=False):
+    r"""
+    Performs the affine cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Explanation
+    ===========
+
+    Encryption is based on the map `x \rightarrow ax+b` (mod `N`)
+    where ``N`` is the number of characters in the alphabet.
+    Decryption is based on the map `x \rightarrow cx+d` (mod `N`),
+    where `c = a^{-1}` (mod `N`) and `d = -a^{-1}b` (mod `N`).
+    In particular, for the map to be invertible, we need
+    `\mathrm{gcd}(a, N) = 1` and an error will be raised if this is
+    not true.
+
+    Parameters
+    ==========
+
+    msg : str
+        Characters that appear in ``symbols``.
+
+    a, b : int, int
+        A pair integers, with ``gcd(a, N) = 1`` (the secret key).
+
+    symbols
+        String of characters (default = uppercase letters).
+
+        When no symbols are given, ``msg`` is converted to upper case
+        letters and all other characters are ignored.
+
+    Returns
+    =======
+
+    ct
+        String of characters (the ciphertext message)
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L1`` of
+               corresponding integers.
+            2. Compute from the list ``L1`` a new list ``L2``, given by
+               replacing ``x`` by ``a*x + b (mod N)``, for each element
+               ``x`` in ``L1``.
+            3. Compute from the list ``L2`` a string ``ct`` of
+               corresponding letters.
+
+    This is a straightforward generalization of the shift cipher with
+    the added complexity of requiring 2 characters to be deciphered in
+    order to recover the key.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Affine_cipher
+
+    See Also
+    ========
+
+    decipher_affine
+
+    """
+    msg, _, A = _prep(msg, '', symbols)
+    N = len(A)
+    a, b = key
+    assert gcd(a, N) == 1
+    if _inverse:
+        c = mod_inverse(a, N)
+        d = -b*c
+        a, b = c, d
+    B = ''.join([A[(a*i + b) % N] for i in range(N)])
+    return translate(msg, A, B)
+
+
+def decipher_affine(msg, key, symbols=None):
+    r"""
+    Return the deciphered text that was made from the mapping,
+    `x \rightarrow ax+b` (mod `N`), where ``N`` is the
+    number of characters in the alphabet. Deciphering is done by
+    reciphering with a new key: `x \rightarrow cx+d` (mod `N`),
+    where `c = a^{-1}` (mod `N`) and `d = -a^{-1}b` (mod `N`).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_affine, decipher_affine
+    >>> msg = "GO NAVY BEAT ARMY"
+    >>> key = (3, 1)
+    >>> encipher_affine(msg, key)
+    'TROBMVENBGBALV'
+    >>> decipher_affine(_, key)
+    'GONAVYBEATARMY'
+
+    See Also
+    ========
+
+    encipher_affine
+
+    """
+    return encipher_affine(msg, key, symbols, _inverse=True)
+
+
+def encipher_atbash(msg, symbols=None):
+    r"""
+    Enciphers a given ``msg`` into its Atbash ciphertext and returns it.
+
+    Explanation
+    ===========
+
+    Atbash is a substitution cipher originally used to encrypt the Hebrew
+    alphabet. Atbash works on the principle of mapping each alphabet to its
+    reverse / counterpart (i.e. a would map to z, b to y etc.)
+
+    Atbash is functionally equivalent to the affine cipher with ``a = 25``
+    and ``b = 25``
+
+    See Also
+    ========
+
+    decipher_atbash
+
+    """
+    return encipher_affine(msg, (25, 25), symbols)
+
+
+def decipher_atbash(msg, symbols=None):
+    r"""
+    Deciphers a given ``msg`` using Atbash cipher and returns it.
+
+    Explanation
+    ===========
+
+    ``decipher_atbash`` is functionally equivalent to ``encipher_atbash``.
+    However, it has still been added as a separate function to maintain
+    consistency.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_atbash, decipher_atbash
+    >>> msg = 'GONAVYBEATARMY'
+    >>> encipher_atbash(msg)
+    'TLMZEBYVZGZINB'
+    >>> decipher_atbash(msg)
+    'TLMZEBYVZGZINB'
+    >>> encipher_atbash(msg) == decipher_atbash(msg)
+    True
+    >>> msg == encipher_atbash(encipher_atbash(msg))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Atbash
+
+    See Also
+    ========
+
+    encipher_atbash
+
+    """
+    return decipher_affine(msg, (25, 25), symbols)
+
+#################### substitution cipher ###########################
+
+
+def encipher_substitution(msg, old, new=None):
+    r"""
+    Returns the ciphertext obtained by replacing each character that
+    appears in ``old`` with the corresponding character in ``new``.
+    If ``old`` is a mapping, then new is ignored and the replacements
+    defined by ``old`` are used.
+
+    Explanation
+    ===========
+
+    This is a more general than the affine cipher in that the key can
+    only be recovered by determining the mapping for each symbol.
+    Though in practice, once a few symbols are recognized the mappings
+    for other characters can be quickly guessed.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_substitution, AZ
+    >>> old = 'OEYAG'
+    >>> new = '034^6'
+    >>> msg = AZ("go navy! beat army!")
+    >>> ct = encipher_substitution(msg, old, new); ct
+    '60N^V4B3^T^RM4'
+
+    To decrypt a substitution, reverse the last two arguments:
+
+    >>> encipher_substitution(ct, new, old)
+    'GONAVYBEATARMY'
+
+    In the special case where ``old`` and ``new`` are a permutation of
+    order 2 (representing a transposition of characters) their order
+    is immaterial:
+
+    >>> old = 'NAVY'
+    >>> new = 'ANYV'
+    >>> encipher = lambda x: encipher_substitution(x, old, new)
+    >>> encipher('NAVY')
+    'ANYV'
+    >>> encipher(_)
+    'NAVY'
+
+    The substitution cipher, in general, is a method
+    whereby "units" (not necessarily single characters) of plaintext
+    are replaced with ciphertext according to a regular system.
+
+    >>> ords = dict(zip('abc', ['\\%i' % ord(i) for i in 'abc']))
+    >>> print(encipher_substitution('abc', ords))
+    \97\98\99
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Substitution_cipher
+
+    """
+    return translate(msg, old, new)
+
+
+######################################################################
+#################### Vigenere cipher examples ########################
+######################################################################
+
+def encipher_vigenere(msg, key, symbols=None):
+    """
+    Performs the Vigenere cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_vigenere, AZ
+    >>> key = "encrypt"
+    >>> msg = "meet me on monday"
+    >>> encipher_vigenere(msg, key)
+    'QRGKKTHRZQEBPR'
+
+    Section 1 of the Kryptos sculpture at the CIA headquarters
+    uses this cipher and also changes the order of the
+    alphabet [2]_. Here is the first line of that section of
+    the sculpture:
+
+    >>> from sympy.crypto.crypto import decipher_vigenere, padded_key
+    >>> alp = padded_key('KRYPTOS', AZ())
+    >>> key = 'PALIMPSEST'
+    >>> msg = 'EMUFPHZLRFAXYUSDJKZLDKRNSHGNFIVJ'
+    >>> decipher_vigenere(msg, key, alp)
+    'BETWEENSUBTLESHADINGANDTHEABSENC'
+
+    Explanation
+    ===========
+
+    The Vigenere cipher is named after Blaise de Vigenere, a sixteenth
+    century diplomat and cryptographer, by a historical accident.
+    Vigenere actually invented a different and more complicated cipher.
+    The so-called *Vigenere cipher* was actually invented
+    by Giovan Batista Belaso in 1553.
+
+    This cipher was used in the 1800's, for example, during the American
+    Civil War. The Confederacy used a brass cipher disk to implement the
+    Vigenere cipher (now on display in the NSA Museum in Fort
+    Meade) [1]_.
+
+    The Vigenere cipher is a generalization of the shift cipher.
+    Whereas the shift cipher shifts each letter by the same amount
+    (that amount being the key of the shift cipher) the Vigenere
+    cipher shifts a letter by an amount determined by the key (which is
+    a word or phrase known only to the sender and receiver).
+
+    For example, if the key was a single letter, such as "C", then the
+    so-called Vigenere cipher is actually a shift cipher with a
+    shift of `2` (since "C" is the 2nd letter of the alphabet, if
+    you start counting at `0`). If the key was a word with two
+    letters, such as "CA", then the so-called Vigenere cipher will
+    shift letters in even positions by `2` and letters in odd positions
+    are left alone (shifted by `0`, since "A" is the 0th letter, if
+    you start counting at `0`).
+
+
+    ALGORITHM:
+
+        INPUT:
+
+            ``msg``: string of characters that appear in ``symbols``
+            (the plaintext)
+
+            ``key``: a string of characters that appear in ``symbols``
+            (the secret key)
+
+            ``symbols``: a string of letters defining the alphabet
+
+
+        OUTPUT:
+
+            ``ct``: string of characters (the ciphertext message)
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``key`` a list ``L1`` of
+               corresponding integers. Let ``n1 = len(L1)``.
+            2. Compute from the string ``msg`` a list ``L2`` of
+               corresponding integers. Let ``n2 = len(L2)``.
+            3. Break ``L2`` up sequentially into sublists of size
+               ``n1``; the last sublist may be smaller than ``n1``
+            4. For each of these sublists ``L`` of ``L2``, compute a
+               new list ``C`` given by ``C[i] = L[i] + L1[i] (mod N)``
+               to the ``i``-th element in the sublist, for each ``i``.
+            5. Assemble these lists ``C`` by concatenation into a new
+               list of length ``n2``.
+            6. Compute from the new list a string ``ct`` of
+               corresponding letters.
+
+    Once it is known that the key is, say, `n` characters long,
+    frequency analysis can be applied to every `n`-th letter of
+    the ciphertext to determine the plaintext. This method is
+    called *Kasiski examination* (although it was first discovered
+    by Babbage). If they key is as long as the message and is
+    comprised of randomly selected characters -- a one-time pad -- the
+    message is theoretically unbreakable.
+
+    The cipher Vigenere actually discovered is an "auto-key" cipher
+    described as follows.
+
+    ALGORITHM:
+
+        INPUT:
+
+          ``key``: a string of letters (the secret key)
+
+          ``msg``: string of letters (the plaintext message)
+
+        OUTPUT:
+
+          ``ct``: string of upper-case letters (the ciphertext message)
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L2`` of
+               corresponding integers. Let ``n2 = len(L2)``.
+            2. Let ``n1`` be the length of the key. Append to the
+               string ``key`` the first ``n2 - n1`` characters of
+               the plaintext message. Compute from this string (also of
+               length ``n2``) a list ``L1`` of integers corresponding
+               to the letter numbers in the first step.
+            3. Compute a new list ``C`` given by
+               ``C[i] = L1[i] + L2[i] (mod N)``.
+            4. Compute from the new list a string ``ct`` of letters
+               corresponding to the new integers.
+
+    To decipher the auto-key ciphertext, the key is used to decipher
+    the first ``n1`` characters and then those characters become the
+    key to  decipher the next ``n1`` characters, etc...:
+
+    >>> m = AZ('go navy, beat army! yes you can'); m
+    'GONAVYBEATARMYYESYOUCAN'
+    >>> key = AZ('gold bug'); n1 = len(key); n2 = len(m)
+    >>> auto_key = key + m[:n2 - n1]; auto_key
+    'GOLDBUGGONAVYBEATARMYYE'
+    >>> ct = encipher_vigenere(m, auto_key); ct
+    'MCYDWSHKOGAMKZCELYFGAYR'
+    >>> n1 = len(key)
+    >>> pt = []
+    >>> while ct:
+    ...     part, ct = ct[:n1], ct[n1:]
+    ...     pt.append(decipher_vigenere(part, key))
+    ...     key = pt[-1]
+    ...
+    >>> ''.join(pt) == m
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Vigenere_cipher
+    .. [2] https://web.archive.org/web/20071116100808/https://filebox.vt.edu/users/batman/kryptos.html
+       (short URL: https://goo.gl/ijr22d)
+
+    """
+    msg, key, A = _prep(msg, key, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    key = [map[c] for c in key]
+    N = len(map)
+    k = len(key)
+    rv = []
+    for i, m in enumerate(msg):
+        rv.append(A[(map[m] + key[i % k]) % N])
+    rv = ''.join(rv)
+    return rv
+
+
+def decipher_vigenere(msg, key, symbols=None):
+    """
+    Decode using the Vigenere cipher.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_vigenere
+    >>> key = "encrypt"
+    >>> ct = "QRGK kt HRZQE BPR"
+    >>> decipher_vigenere(ct, key)
+    'MEETMEONMONDAY'
+
+    """
+    msg, key, A = _prep(msg, key, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    N = len(A)   # normally, 26
+    K = [map[c] for c in key]
+    n = len(K)
+    C = [map[c] for c in msg]
+    rv = ''.join([A[(-K[i % n] + c) % N] for i, c in enumerate(C)])
+    return rv
+
+
+#################### Hill cipher  ########################
+
+
+def encipher_hill(msg, key, symbols=None, pad="Q"):
+    r"""
+    Return the Hill cipher encryption of ``msg``.
+
+    Explanation
+    ===========
+
+    The Hill cipher [1]_, invented by Lester S. Hill in the 1920's [2]_,
+    was the first polygraphic cipher in which it was practical
+    (though barely) to operate on more than three symbols at once.
+    The following discussion assumes an elementary knowledge of
+    matrices.
+
+    First, each letter is first encoded as a number starting with 0.
+    Suppose your message `msg` consists of `n` capital letters, with no
+    spaces. This may be regarded an `n`-tuple M of elements of
+    `Z_{26}` (if the letters are those of the English alphabet). A key
+    in the Hill cipher is a `k x k` matrix `K`, all of whose entries
+    are in `Z_{26}`, such that the matrix `K` is invertible (i.e., the
+    linear transformation `K: Z_{N}^k \rightarrow Z_{N}^k`
+    is one-to-one).
+
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext message of `n` upper-case letters.
+
+    key
+        A `k \times k` invertible matrix `K`, all of whose entries are
+        in `Z_{26}` (or whatever number of symbols are being used).
+
+    pad
+        Character (default "Q") to use to make length of text be a
+        multiple of ``k``.
+
+    Returns
+    =======
+
+    ct
+        Ciphertext of upper-case letters.
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L`` of
+               corresponding integers. Let ``n = len(L)``.
+            2. Break the list ``L`` up into ``t = ceiling(n/k)``
+               sublists ``L_1``, ..., ``L_t`` of size ``k`` (with
+               the last list "padded" to ensure its size is
+               ``k``).
+            3. Compute new list ``C_1``, ..., ``C_t`` given by
+               ``C[i] = K*L_i`` (arithmetic is done mod N), for each
+               ``i``.
+            4. Concatenate these into a list ``C = C_1 + ... + C_t``.
+            5. Compute from ``C`` a string ``ct`` of corresponding
+               letters. This has length ``k*t``.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hill_cipher
+    .. [2] Lester S. Hill, Cryptography in an Algebraic Alphabet,
+       The American Mathematical Monthly Vol.36, June-July 1929,
+       pp.306-312.
+
+    See Also
+    ========
+
+    decipher_hill
+
+    """
+    assert key.is_square
+    assert len(pad) == 1
+    msg, pad, A = _prep(msg, pad, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    P = [map[c] for c in msg]
+    N = len(A)
+    k = key.cols
+    n = len(P)
+    m, r = divmod(n, k)
+    if r:
+        P = P + [map[pad]]*(k - r)
+        m += 1
+    rv = ''.join([A[c % N] for j in range(m) for c in
+        list(key*Matrix(k, 1, [P[i]
+        for i in range(k*j, k*(j + 1))]))])
+    return rv
+
+
+def decipher_hill(msg, key, symbols=None):
+    """
+    Deciphering is the same as enciphering but using the inverse of the
+    key matrix.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_hill, decipher_hill
+    >>> from sympy import Matrix
+
+    >>> key = Matrix([[1, 2], [3, 5]])
+    >>> encipher_hill("meet me on monday", key)
+    'UEQDUEODOCTCWQ'
+    >>> decipher_hill(_, key)
+    'MEETMEONMONDAY'
+
+    When the length of the plaintext (stripped of invalid characters)
+    is not a multiple of the key dimension, extra characters will
+    appear at the end of the enciphered and deciphered text. In order to
+    decipher the text, those characters must be included in the text to
+    be deciphered. In the following, the key has a dimension of 4 but
+    the text is 2 short of being a multiple of 4 so two characters will
+    be added.
+
+    >>> key = Matrix([[1, 1, 1, 2], [0, 1, 1, 0],
+    ...               [2, 2, 3, 4], [1, 1, 0, 1]])
+    >>> msg = "ST"
+    >>> encipher_hill(msg, key)
+    'HJEB'
+    >>> decipher_hill(_, key)
+    'STQQ'
+    >>> encipher_hill(msg, key, pad="Z")
+    'ISPK'
+    >>> decipher_hill(_, key)
+    'STZZ'
+
+    If the last two characters of the ciphertext were ignored in
+    either case, the wrong plaintext would be recovered:
+
+    >>> decipher_hill("HD", key)
+    'ORMV'
+    >>> decipher_hill("IS", key)
+    'UIKY'
+
+    See Also
+    ========
+
+    encipher_hill
+
+    """
+    assert key.is_square
+    msg, _, A = _prep(msg, '', symbols)
+    map = {c: i for i, c in enumerate(A)}
+    C = [map[c] for c in msg]
+    N = len(A)
+    k = key.cols
+    n = len(C)
+    m, r = divmod(n, k)
+    if r:
+        C = C + [0]*(k - r)
+        m += 1
+    key_inv = key.inv_mod(N)
+    rv = ''.join([A[p % N] for j in range(m) for p in
+        list(key_inv*Matrix(
+        k, 1, [C[i] for i in range(k*j, k*(j + 1))]))])
+    return rv
+
+
+#################### Bifid cipher  ########################
+
+
+def encipher_bifid(msg, key, symbols=None):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    This is the version of the Bifid cipher that uses an `n \times n`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext string.
+
+    key
+        Short string for key.
+
+        Duplicate characters are ignored and then it is padded with the
+        characters in ``symbols`` that were not in the short key.
+
+    symbols
+        `n \times n` characters defining the alphabet.
+
+        (default is string.printable)
+
+    Returns
+    =======
+
+    ciphertext
+        Ciphertext using Bifid5 cipher without spaces.
+
+    See Also
+    ========
+
+    decipher_bifid, encipher_bifid5, encipher_bifid6
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bifid_cipher
+
+    """
+    msg, key, A = _prep(msg, key, symbols, bifid10)
+    long_key = ''.join(uniq(key)) or A
+
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    N = int(n)
+    if len(long_key) < N**2:
+      long_key = list(long_key) + [x for x in A if x not in long_key]
+
+    # the fractionalization
+    row_col = {ch: divmod(i, N) for i, ch in enumerate(long_key)}
+    r, c = zip(*[row_col[x] for x in msg])
+    rc = r + c
+    ch = {i: ch for ch, i in row_col.items()}
+    rv = ''.join(ch[i] for i in zip(rc[::2], rc[1::2]))
+    return rv
+
+
+def decipher_bifid(msg, key, symbols=None):
+    r"""
+    Performs the Bifid cipher decryption on ciphertext ``msg``, and
+    returns the plaintext.
+
+    This is the version of the Bifid cipher that uses the `n \times n`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string.
+
+    key
+        Short string for key.
+
+        Duplicate characters are ignored and then it is padded with the
+        characters in symbols that were not in the short key.
+
+    symbols
+        `n \times n` characters defining the alphabet.
+
+        (default=string.printable, a `10 \times 10` matrix)
+
+    Returns
+    =======
+
+    deciphered
+        Deciphered text.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_bifid, decipher_bifid, AZ)
+
+    Do an encryption using the bifid5 alphabet:
+
+    >>> alp = AZ().replace('J', '')
+    >>> ct = AZ("meet me on monday!")
+    >>> key = AZ("gold bug")
+    >>> encipher_bifid(ct, key, alp)
+    'IEILHHFSTSFQYE'
+
+    When entering the text or ciphertext, spaces are ignored so it
+    can be formatted as desired. Re-entering the ciphertext from the
+    preceding, putting 4 characters per line and padding with an extra
+    J, does not cause problems for the deciphering:
+
+    >>> decipher_bifid('''
+    ... IEILH
+    ... HFSTS
+    ... FQYEJ''', key, alp)
+    'MEETMEONMONDAY'
+
+    When no alphabet is given, all 100 printable characters will be
+    used:
+
+    >>> key = ''
+    >>> encipher_bifid('hello world!', key)
+    'bmtwmg-bIo*w'
+    >>> decipher_bifid(_, key)
+    'hello world!'
+
+    If the key is changed, a different encryption is obtained:
+
+    >>> key = 'gold bug'
+    >>> encipher_bifid('hello world!', 'gold_bug')
+    'hg2sfuei7t}w'
+
+    And if the key used to decrypt the message is not exact, the
+    original text will not be perfectly obtained:
+
+    >>> decipher_bifid(_, 'gold pug')
+    'heldo~wor6d!'
+
+    """
+    msg, _, A = _prep(msg, '', symbols, bifid10)
+    long_key = ''.join(uniq(key)) or A
+
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    N = int(n)
+    if len(long_key) < N**2:
+        long_key = list(long_key) + [x for x in A if x not in long_key]
+
+    # the reverse fractionalization
+    row_col = {
+        ch: divmod(i, N) for i, ch in enumerate(long_key)}
+    rc = [i for c in msg for i in row_col[c]]
+    n = len(msg)
+    rc = zip(*(rc[:n], rc[n:]))
+    ch = {i: ch for ch, i in row_col.items()}
+    rv = ''.join(ch[i] for i in rc)
+    return rv
+
+
+def bifid_square(key):
+    """Return characters of ``key`` arranged in a square.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...    bifid_square, AZ, padded_key, bifid5)
+    >>> bifid_square(AZ().replace('J', ''))
+    Matrix([
+    [A, B, C, D, E],
+    [F, G, H, I, K],
+    [L, M, N, O, P],
+    [Q, R, S, T, U],
+    [V, W, X, Y, Z]])
+
+    >>> bifid_square(padded_key(AZ('gold bug!'), bifid5))
+    Matrix([
+    [G, O, L, D, B],
+    [U, A, C, E, F],
+    [H, I, K, M, N],
+    [P, Q, R, S, T],
+    [V, W, X, Y, Z]])
+
+    See Also
+    ========
+
+    padded_key
+
+    """
+    A = ''.join(uniq(''.join(key)))
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    n = int(n)
+    f = lambda i, j: Symbol(A[n*i + j])
+    rv = Matrix(n, n, f)
+    return rv
+
+
+def encipher_bifid5(msg, key):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Explanation
+    ===========
+
+    This is the version of the Bifid cipher that uses the `5 \times 5`
+    Polybius square. The letter "J" is ignored so it must be replaced
+    with something else (traditionally an "I") before encryption.
+
+    ALGORITHM: (5x5 case)
+
+        STEPS:
+            0. Create the `5 \times 5` Polybius square ``S`` associated
+               to ``key`` as follows:
+
+                a) moving from left-to-right, top-to-bottom,
+                   place the letters of the key into a `5 \times 5`
+                   matrix,
+                b) if the key has less than 25 letters, add the
+                   letters of the alphabet not in the key until the
+                   `5 \times 5` square is filled.
+
+            1. Create a list ``P`` of pairs of numbers which are the
+               coordinates in the Polybius square of the letters in
+               ``msg``.
+            2. Let ``L1`` be the list of all first coordinates of ``P``
+               (length of ``L1 = n``), let ``L2`` be the list of all
+               second coordinates of ``P`` (so the length of ``L2``
+               is also ``n``).
+            3. Let ``L`` be the concatenation of ``L1`` and ``L2``
+               (length ``L = 2*n``), except that consecutive numbers
+               are paired ``(L[2*i], L[2*i + 1])``. You can regard
+               ``L`` as a list of pairs of length ``n``.
+            4. Let ``C`` be the list of all letters which are of the
+               form ``S[i, j]``, for all ``(i, j)`` in ``L``. As a
+               string, this is the ciphertext of ``msg``.
+
+    Parameters
+    ==========
+
+    msg : str
+        Plaintext string.
+
+        Converted to upper case and filtered of anything but all letters
+        except J.
+
+    key
+        Short string for key; non-alphabetic letters, J and duplicated
+        characters are ignored and then, if the length is less than 25
+        characters, it is padded with other letters of the alphabet
+        (in alphabetical order).
+
+    Returns
+    =======
+
+    ct
+        Ciphertext (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_bifid5, decipher_bifid5)
+
+    "J" will be omitted unless it is replaced with something else:
+
+    >>> round_trip = lambda m, k: \
+    ...     decipher_bifid5(encipher_bifid5(m, k), k)
+    >>> key = 'a'
+    >>> msg = "JOSIE"
+    >>> round_trip(msg, key)
+    'OSIE'
+    >>> round_trip(msg.replace("J", "I"), key)
+    'IOSIE'
+    >>> j = "QIQ"
+    >>> round_trip(msg.replace("J", j), key).replace(j, "J")
+    'JOSIE'
+
+
+    Notes
+    =====
+
+    The Bifid cipher was invented around 1901 by Felix Delastelle.
+    It is a *fractional substitution* cipher, where letters are
+    replaced by pairs of symbols from a smaller alphabet. The
+    cipher uses a `5 \times 5` square filled with some ordering of the
+    alphabet, except that "J" is replaced with "I" (this is a so-called
+    Polybius square; there is a `6 \times 6` analog if you add back in
+    "J" and also append onto the usual 26 letter alphabet, the digits
+    0, 1, ..., 9).
+    According to Helen Gaines' book *Cryptanalysis*, this type of cipher
+    was used in the field by the German Army during World War I.
+
+    See Also
+    ========
+
+    decipher_bifid5, encipher_bifid
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid5)
+    key = padded_key(key, bifid5)
+    return encipher_bifid(msg, '', key)
+
+
+def decipher_bifid5(msg, key):
+    r"""
+    Return the Bifid cipher decryption of ``msg``.
+
+    Explanation
+    ===========
+
+    This is the version of the Bifid cipher that uses the `5 \times 5`
+    Polybius square; the letter "J" is ignored unless a ``key`` of
+    length 25 is used.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string.
+
+    key
+        Short string for key; duplicated characters are ignored and if
+        the length is less then 25 characters, it will be padded with
+        other letters from the alphabet omitting "J".
+        Non-alphabetic characters are ignored.
+
+    Returns
+    =======
+
+    plaintext
+        Plaintext from Bifid5 cipher (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_bifid5, decipher_bifid5
+    >>> key = "gold bug"
+    >>> encipher_bifid5('meet me on friday', key)
+    'IEILEHFSTSFXEE'
+    >>> encipher_bifid5('meet me on monday', key)
+    'IEILHHFSTSFQYE'
+    >>> decipher_bifid5(_, key)
+    'MEETMEONMONDAY'
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid5)
+    key = padded_key(key, bifid5)
+    return decipher_bifid(msg, '', key)
+
+
+def bifid5_square(key=None):
+    r"""
+    5x5 Polybius square.
+
+    Produce the Polybius square for the `5 \times 5` Bifid cipher.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import bifid5_square
+    >>> bifid5_square("gold bug")
+    Matrix([
+    [G, O, L, D, B],
+    [U, A, C, E, F],
+    [H, I, K, M, N],
+    [P, Q, R, S, T],
+    [V, W, X, Y, Z]])
+
+    """
+    if not key:
+        key = bifid5
+    else:
+        _, key, _ = _prep('', key.upper(), None, bifid5)
+        key = padded_key(key, bifid5)
+    return bifid_square(key)
+
+
+def encipher_bifid6(msg, key):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    This is the version of the Bifid cipher that uses the `6 \times 6`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext string (digits okay).
+
+    key
+        Short string for key (digits okay).
+
+        If ``key`` is less than 36 characters long, the square will be
+        filled with letters A through Z and digits 0 through 9.
+
+    Returns
+    =======
+
+    ciphertext
+        Ciphertext from Bifid cipher (all caps, no spaces).
+
+    See Also
+    ========
+
+    decipher_bifid6, encipher_bifid
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid6)
+    key = padded_key(key, bifid6)
+    return encipher_bifid(msg, '', key)
+
+
+def decipher_bifid6(msg, key):
+    r"""
+    Performs the Bifid cipher decryption on ciphertext ``msg``, and
+    returns the plaintext.
+
+    This is the version of the Bifid cipher that uses the `6 \times 6`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string (digits okay); converted to upper case
+
+    key
+        Short string for key (digits okay).
+
+        If ``key`` is less than 36 characters long, the square will be
+        filled with letters A through Z and digits 0 through 9.
+        All letters are converted to uppercase.
+
+    Returns
+    =======
+
+    plaintext
+        Plaintext from Bifid cipher (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_bifid6, decipher_bifid6
+    >>> key = "gold bug"
+    >>> encipher_bifid6('meet me on monday at 8am', key)
+    'KFKLJJHF5MMMKTFRGPL'
+    >>> decipher_bifid6(_, key)
+    'MEETMEONMONDAYAT8AM'
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid6)
+    key = padded_key(key, bifid6)
+    return decipher_bifid(msg, '', key)
+
+
+def bifid6_square(key=None):
+    r"""
+    6x6 Polybius square.
+
+    Produces the Polybius square for the `6 \times 6` Bifid cipher.
+    Assumes alphabet of symbols is "A", ..., "Z", "0", ..., "9".
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import bifid6_square
+    >>> key = "gold bug"
+    >>> bifid6_square(key)
+    Matrix([
+    [G, O, L, D, B, U],
+    [A, C, E, F, H, I],
+    [J, K, M, N, P, Q],
+    [R, S, T, V, W, X],
+    [Y, Z, 0, 1, 2, 3],
+    [4, 5, 6, 7, 8, 9]])
+
+    """
+    if not key:
+        key = bifid6
+    else:
+        _, key, _ = _prep('', key.upper(), None, bifid6)
+        key = padded_key(key, bifid6)
+    return bifid_square(key)
+
+
+#################### RSA  #############################
+
+def _decipher_rsa_crt(i, d, factors):
+    """Decipher RSA using chinese remainder theorem from the information
+    of the relatively-prime factors of the modulus.
+
+    Parameters
+    ==========
+
+    i : integer
+        Ciphertext
+
+    d : integer
+        The exponent component.
+
+    factors : list of relatively-prime integers
+        The integers given must be coprime and the product must equal
+        the modulus component of the original RSA key.
+
+    Examples
+    ========
+
+    How to decrypt RSA with CRT:
+
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+    >>> primes = [61, 53]
+    >>> e = 17
+    >>> args = primes + [e]
+    >>> puk = rsa_public_key(*args)
+    >>> prk = rsa_private_key(*args)
+
+    >>> from sympy.crypto.crypto import encipher_rsa, _decipher_rsa_crt
+    >>> msg = 65
+    >>> crt_primes = primes
+    >>> encrypted = encipher_rsa(msg, puk)
+    >>> decrypted = _decipher_rsa_crt(encrypted, prk[1], primes)
+    >>> decrypted
+    65
+    """
+    moduluses = [pow(i, d, p) for p in factors]
+
+    result = crt(factors, moduluses)
+    if not result:
+        raise ValueError("CRT failed")
+    return result[0]
+
+
+def _rsa_key(*args, public=True, private=True, totient='Euler', index=None, multipower=None):
+    r"""A private subroutine to generate RSA key
+
+    Parameters
+    ==========
+
+    public, private : bool, optional
+        Flag to generate either a public key, a private key.
+
+    totient : 'Euler' or 'Carmichael'
+        Different notation used for totient.
+
+    multipower : bool, optional
+        Flag to bypass warning for multipower RSA.
+    """
+
+    if len(args) < 2:
+        return False
+
+    if totient not in ('Euler', 'Carmichael'):
+        raise ValueError(
+            "The argument totient={} should either be " \
+            "'Euler', 'Carmichalel'." \
+            .format(totient))
+
+    if totient == 'Euler':
+        _totient = _euler
+    else:
+        _totient = _carmichael
+
+    if index is not None:
+        index = as_int(index)
+        if totient != 'Carmichael':
+            raise ValueError(
+                "Setting the 'index' keyword argument requires totient"
+                "notation to be specified as 'Carmichael'.")
+
+    primes, e = args[:-1], args[-1]
+
+    if not all(isprime(p) for p in primes):
+        new_primes = []
+        for i in primes:
+            new_primes.extend(factorint(i, multiple=True))
+        primes = new_primes
+
+    n = reduce(lambda i, j: i*j, primes)
+
+    tally = multiset(primes)
+    if all(v == 1 for v in tally.values()):
+        multiple = list(tally.keys())
+        phi = _totient._from_distinct_primes(*multiple)
+
+    else:
+        if not multipower:
+            NonInvertibleCipherWarning(
+                'Non-distinctive primes found in the factors {}. '
+                'The cipher may not be decryptable for some numbers '
+                'in the complete residue system Z[{}], but the cipher '
+                'can still be valid if you restrict the domain to be '
+                'the reduced residue system Z*[{}]. You can pass '
+                'the flag multipower=True if you want to suppress this '
+                'warning.'
+                .format(primes, n, n)
+                # stacklevel=4 because most users will call a function that
+                # calls this function
+                ).warn(stacklevel=4)
+        phi = _totient._from_factors(tally)
+
+    if igcd(e, phi) == 1:
+        if public and not private:
+            if isinstance(index, int):
+                e = e % phi
+                e += index * phi
+            return n, e
+
+        if private and not public:
+            d = mod_inverse(e, phi)
+            if isinstance(index, int):
+                d += index * phi
+            return n, d
+
+    return False
+
+
+def rsa_public_key(*args, **kwargs):
+    r"""Return the RSA *public key* pair, `(n, e)`
+
+    Parameters
+    ==========
+
+    args : naturals
+        If specified as `p, q, e` where `p` and `q` are distinct primes
+        and `e` is a desired public exponent of the RSA, `n = p q` and
+        `e` will be verified against the totient
+        `\phi(n)` (Euler totient) or `\lambda(n)` (Carmichael totient)
+        to be `\gcd(e, \phi(n)) = 1` or `\gcd(e, \lambda(n)) = 1`.
+
+        If specified as `p_1, p_2, \dots, p_n, e` where
+        `p_1, p_2, \dots, p_n` are specified as primes,
+        and `e` is specified as a desired public exponent of the RSA,
+        it will be able to form a multi-prime RSA, which is a more
+        generalized form of the popular 2-prime RSA.
+
+        It can also be possible to form a single-prime RSA by specifying
+        the argument as `p, e`, which can be considered a trivial case
+        of a multiprime RSA.
+
+        Furthermore, it can be possible to form a multi-power RSA by
+        specifying two or more pairs of the primes to be same.
+        However, unlike the two-distinct prime RSA or multi-prime
+        RSA, not every numbers in the complete residue system
+        (`\mathbb{Z}_n`) will be decryptable since the mapping
+        `\mathbb{Z}_{n} \rightarrow \mathbb{Z}_{n}`
+        will not be bijective.
+        (Only except for the trivial case when
+        `e = 1`
+        or more generally,
+
+        .. math::
+            e \in \left \{ 1 + k \lambda(n)
+            \mid k \in \mathbb{Z} \land k \geq 0 \right \}
+
+        when RSA reduces to the identity.)
+        However, the RSA can still be decryptable for the numbers in the
+        reduced residue system (`\mathbb{Z}_n^{\times}`), since the
+        mapping
+        `\mathbb{Z}_{n}^{\times} \rightarrow \mathbb{Z}_{n}^{\times}`
+        can still be bijective.
+
+        If you pass a non-prime integer to the arguments
+        `p_1, p_2, \dots, p_n`, the particular number will be
+        prime-factored and it will become either a multi-prime RSA or a
+        multi-power RSA in its canonical form, depending on whether the
+        product equals its radical or not.
+        `p_1 p_2 \dots p_n = \text{rad}(p_1 p_2 \dots p_n)`
+
+    totient : bool, optional
+        If ``'Euler'``, it uses Euler's totient `\phi(n)` which is
+        :meth:`sympy.ntheory.factor_.totient` in SymPy.
+
+        If ``'Carmichael'``, it uses Carmichael's totient `\lambda(n)`
+        which is :meth:`sympy.ntheory.factor_.reduced_totient` in SymPy.
+
+        Unlike private key generation, this is a trivial keyword for
+        public key generation because
+        `\gcd(e, \phi(n)) = 1 \iff \gcd(e, \lambda(n)) = 1`.
+
+    index : nonnegative integer, optional
+        Returns an arbitrary solution of a RSA public key at the index
+        specified at `0, 1, 2, \dots`. This parameter needs to be
+        specified along with ``totient='Carmichael'``.
+
+        Similarly to the non-uniquenss of a RSA private key as described
+        in the ``index`` parameter documentation in
+        :meth:`rsa_private_key`, RSA public key is also not unique and
+        there is an infinite number of RSA public exponents which
+        can behave in the same manner.
+
+        From any given RSA public exponent `e`, there are can be an
+        another RSA public exponent `e + k \lambda(n)` where `k` is an
+        integer, `\lambda` is a Carmichael's totient function.
+
+        However, considering only the positive cases, there can be
+        a principal solution of a RSA public exponent `e_0` in
+        `0 < e_0 < \lambda(n)`, and all the other solutions
+        can be canonicalzed in a form of `e_0 + k \lambda(n)`.
+
+        ``index`` specifies the `k` notation to yield any possible value
+        an RSA public key can have.
+
+        An example of computing any arbitrary RSA public key:
+
+        >>> from sympy.crypto.crypto import rsa_public_key
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=0)
+        (3233, 17)
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=1)
+        (3233, 797)
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=2)
+        (3233, 1577)
+
+    multipower : bool, optional
+        Any pair of non-distinct primes found in the RSA specification
+        will restrict the domain of the cryptosystem, as noted in the
+        explanation of the parameter ``args``.
+
+        SymPy RSA key generator may give a warning before dispatching it
+        as a multi-power RSA, however, you can disable the warning if
+        you pass ``True`` to this keyword.
+
+    Returns
+    =======
+
+    (n, e) : int, int
+        `n` is a product of any arbitrary number of primes given as
+        the argument.
+
+        `e` is relatively prime (coprime) to the Euler totient
+        `\phi(n)`.
+
+    False
+        Returned if less than two arguments are given, or `e` is
+        not relatively prime to the modulus.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import rsa_public_key
+
+    A public key of a two-prime RSA:
+
+    >>> p, q, e = 3, 5, 7
+    >>> rsa_public_key(p, q, e)
+    (15, 7)
+    >>> rsa_public_key(p, q, 30)
+    False
+
+    A public key of a multiprime RSA:
+
+    >>> primes = [2, 3, 5, 7, 11, 13]
+    >>> e = 7
+    >>> args = primes + [e]
+    >>> rsa_public_key(*args)
+    (30030, 7)
+
+    Notes
+    =====
+
+    Although the RSA can be generalized over any modulus `n`, using
+    two large primes had became the most popular specification because a
+    product of two large primes is usually the hardest to factor
+    relatively to the digits of `n` can have.
+
+    However, it may need further understanding of the time complexities
+    of each prime-factoring algorithms to verify the claim.
+
+    See Also
+    ========
+
+    rsa_private_key
+    encipher_rsa
+    decipher_rsa
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29
+
+    .. [2] https://cacr.uwaterloo.ca/techreports/2006/cacr2006-16.pdf
+
+    .. [3] https://link.springer.com/content/pdf/10.1007/BFb0055738.pdf
+
+    .. [4] https://www.itiis.org/digital-library/manuscript/1381
+    """
+    return _rsa_key(*args, public=True, private=False, **kwargs)
+
+
+def rsa_private_key(*args, **kwargs):
+    r"""Return the RSA *private key* pair, `(n, d)`
+
+    Parameters
+    ==========
+
+    args : naturals
+        The keyword is identical to the ``args`` in
+        :meth:`rsa_public_key`.
+
+    totient : bool, optional
+        If ``'Euler'``, it uses Euler's totient convention `\phi(n)`
+        which is :meth:`sympy.ntheory.factor_.totient` in SymPy.
+
+        If ``'Carmichael'``, it uses Carmichael's totient convention
+        `\lambda(n)` which is
+        :meth:`sympy.ntheory.factor_.reduced_totient` in SymPy.
+
+        There can be some output differences for private key generation
+        as examples below.
+
+        Example using Euler's totient:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Euler')
+        (3233, 2753)
+
+        Example using Carmichael's totient:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael')
+        (3233, 413)
+
+    index : nonnegative integer, optional
+        Returns an arbitrary solution of a RSA private key at the index
+        specified at `0, 1, 2, \dots`. This parameter needs to be
+        specified along with ``totient='Carmichael'``.
+
+        RSA private exponent is a non-unique solution of
+        `e d \mod \lambda(n) = 1` and it is possible in any form of
+        `d + k \lambda(n)`, where `d` is an another
+        already-computed private exponent, and `\lambda` is a
+        Carmichael's totient function, and `k` is any integer.
+
+        However, considering only the positive cases, there can be
+        a principal solution of a RSA private exponent `d_0` in
+        `0 < d_0 < \lambda(n)`, and all the other solutions
+        can be canonicalzed in a form of `d_0 + k \lambda(n)`.
+
+        ``index`` specifies the `k` notation to yield any possible value
+        an RSA private key can have.
+
+        An example of computing any arbitrary RSA private key:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=0)
+        (3233, 413)
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=1)
+        (3233, 1193)
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=2)
+        (3233, 1973)
+
+    multipower : bool, optional
+        The keyword is identical to the ``multipower`` in
+        :meth:`rsa_public_key`.
+
+    Returns
+    =======
+
+    (n, d) : int, int
+        `n` is a product of any arbitrary number of primes given as
+        the argument.
+
+        `d` is the inverse of `e` (mod `\phi(n)`) where `e` is the
+        exponent given, and `\phi` is a Euler totient.
+
+    False
+        Returned if less than two arguments are given, or `e` is
+        not relatively prime to the totient of the modulus.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import rsa_private_key
+
+    A private key of a two-prime RSA:
+
+    >>> p, q, e = 3, 5, 7
+    >>> rsa_private_key(p, q, e)
+    (15, 7)
+    >>> rsa_private_key(p, q, 30)
+    False
+
+    A private key of a multiprime RSA:
+
+    >>> primes = [2, 3, 5, 7, 11, 13]
+    >>> e = 7
+    >>> args = primes + [e]
+    >>> rsa_private_key(*args)
+    (30030, 823)
+
+    See Also
+    ========
+
+    rsa_public_key
+    encipher_rsa
+    decipher_rsa
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29
+
+    .. [2] https://cacr.uwaterloo.ca/techreports/2006/cacr2006-16.pdf
+
+    .. [3] https://link.springer.com/content/pdf/10.1007/BFb0055738.pdf
+
+    .. [4] https://www.itiis.org/digital-library/manuscript/1381
+    """
+    return _rsa_key(*args, public=False, private=True, **kwargs)
+
+
+def _encipher_decipher_rsa(i, key, factors=None):
+    n, d = key
+    if not factors:
+        return pow(i, d, n)
+
+    def _is_coprime_set(l):
+        is_coprime_set = True
+        for i in range(len(l)):
+            for j in range(i+1, len(l)):
+                if igcd(l[i], l[j]) != 1:
+                    is_coprime_set = False
+                    break
+        return is_coprime_set
+
+    prod = reduce(lambda i, j: i*j, factors)
+    if prod == n and _is_coprime_set(factors):
+        return _decipher_rsa_crt(i, d, factors)
+    return _encipher_decipher_rsa(i, key, factors=None)
+
+
+def encipher_rsa(i, key, factors=None):
+    r"""Encrypt the plaintext with RSA.
+
+    Parameters
+    ==========
+
+    i : integer
+        The plaintext to be encrypted for.
+
+    key : (n, e) where n, e are integers
+        `n` is the modulus of the key and `e` is the exponent of the
+        key. The encryption is computed by `i^e \bmod n`.
+
+        The key can either be a public key or a private key, however,
+        the message encrypted by a public key can only be decrypted by
+        a private key, and vice versa, as RSA is an asymmetric
+        cryptography system.
+
+    factors : list of coprime integers
+        This is identical to the keyword ``factors`` in
+        :meth:`decipher_rsa`.
+
+    Notes
+    =====
+
+    Some specifications may make the RSA not cryptographically
+    meaningful.
+
+    For example, `0`, `1` will remain always same after taking any
+    number of exponentiation, thus, should be avoided.
+
+    Furthermore, if `i^e < n`, `i` may easily be figured out by taking
+    `e` th root.
+
+    And also, specifying the exponent as `1` or in more generalized form
+    as `1 + k \lambda(n)` where `k` is an nonnegative integer,
+    `\lambda` is a carmichael totient, the RSA becomes an identity
+    mapping.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_rsa
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+
+    Public Key Encryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> encipher_rsa(msg, puk)
+    3
+
+    Private Key Encryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> msg = 12
+    >>> encipher_rsa(msg, prk)
+    3
+
+    Encryption using chinese remainder theorem:
+
+    >>> encipher_rsa(msg, prk, factors=[p, q])
+    3
+    """
+    return _encipher_decipher_rsa(i, key, factors=factors)
+
+
+def decipher_rsa(i, key, factors=None):
+    r"""Decrypt the ciphertext with RSA.
+
+    Parameters
+    ==========
+
+    i : integer
+        The ciphertext to be decrypted for.
+
+    key : (n, d) where n, d are integers
+        `n` is the modulus of the key and `d` is the exponent of the
+        key. The decryption is computed by `i^d \bmod n`.
+
+        The key can either be a public key or a private key, however,
+        the message encrypted by a public key can only be decrypted by
+        a private key, and vice versa, as RSA is an asymmetric
+        cryptography system.
+
+    factors : list of coprime integers
+        As the modulus `n` created from RSA key generation is composed
+        of arbitrary prime factors
+        `n = {p_1}^{k_1}{p_2}^{k_2}\dots{p_n}^{k_n}` where
+        `p_1, p_2, \dots, p_n` are distinct primes and
+        `k_1, k_2, \dots, k_n` are positive integers, chinese remainder
+        theorem can be used to compute `i^d \bmod n` from the
+        fragmented modulo operations like
+
+        .. math::
+            i^d \bmod {p_1}^{k_1}, i^d \bmod {p_2}^{k_2}, \dots,
+            i^d \bmod {p_n}^{k_n}
+
+        or like
+
+        .. math::
+            i^d \bmod {p_1}^{k_1}{p_2}^{k_2},
+            i^d \bmod {p_3}^{k_3}, \dots ,
+            i^d \bmod {p_n}^{k_n}
+
+        as long as every moduli does not share any common divisor each
+        other.
+
+        The raw primes used in generating the RSA key pair can be a good
+        option.
+
+        Note that the speed advantage of using this is only viable for
+        very large cases (Like 2048-bit RSA keys) since the
+        overhead of using pure Python implementation of
+        :meth:`sympy.ntheory.modular.crt` may overcompensate the
+        theoretical speed advantage.
+
+    Notes
+    =====
+
+    See the ``Notes`` section in the documentation of
+    :meth:`encipher_rsa`
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_rsa, encipher_rsa
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+
+    Public Key Encryption and Decryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> new_msg = encipher_rsa(msg, prk)
+    >>> new_msg
+    3
+    >>> decipher_rsa(new_msg, puk)
+    12
+
+    Private Key Encryption and Decryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> new_msg = encipher_rsa(msg, puk)
+    >>> new_msg
+    3
+    >>> decipher_rsa(new_msg, prk)
+    12
+
+    Decryption using chinese remainder theorem:
+
+    >>> decipher_rsa(new_msg, prk, factors=[p, q])
+    12
+
+    See Also
+    ========
+
+    encipher_rsa
+    """
+    return _encipher_decipher_rsa(i, key, factors=factors)
+
+
+#################### kid krypto (kid RSA) #############################
+
+
+def kid_rsa_public_key(a, b, A, B):
+    r"""
+    Kid RSA is a version of RSA useful to teach grade school children
+    since it does not involve exponentiation.
+
+    Explanation
+    ===========
+
+    Alice wants to talk to Bob. Bob generates keys as follows.
+    Key generation:
+
+    * Select positive integers `a, b, A, B` at random.
+    * Compute `M = a b - 1`, `e = A M + a`, `d = B M + b`,
+      `n = (e d - 1)//M`.
+    * The *public key* is `(n, e)`. Bob sends these to Alice.
+    * The *private key* is `(n, d)`, which Bob keeps secret.
+
+    Encryption: If `p` is the plaintext message then the
+    ciphertext is `c = p e \pmod n`.
+
+    Decryption: If `c` is the ciphertext message then the
+    plaintext is `p = c d \pmod n`.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import kid_rsa_public_key
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> kid_rsa_public_key(a, b, A, B)
+    (369, 58)
+
+    """
+    M = a*b - 1
+    e = A*M + a
+    d = B*M + b
+    n = (e*d - 1)//M
+    return n, e
+
+
+def kid_rsa_private_key(a, b, A, B):
+    """
+    Compute `M = a b - 1`, `e = A M + a`, `d = B M + b`,
+    `n = (e d - 1) / M`. The *private key* is `d`, which Bob
+    keeps secret.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import kid_rsa_private_key
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> kid_rsa_private_key(a, b, A, B)
+    (369, 70)
+
+    """
+    M = a*b - 1
+    e = A*M + a
+    d = B*M + b
+    n = (e*d - 1)//M
+    return n, d
+
+
+def encipher_kid_rsa(msg, key):
+    """
+    Here ``msg`` is the plaintext and ``key`` is the public key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_kid_rsa, kid_rsa_public_key)
+    >>> msg = 200
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> key = kid_rsa_public_key(a, b, A, B)
+    >>> encipher_kid_rsa(msg, key)
+    161
+
+    """
+    n, e = key
+    return (msg*e) % n
+
+
+def decipher_kid_rsa(msg, key):
+    """
+    Here ``msg`` is the plaintext and ``key`` is the private key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     kid_rsa_public_key, kid_rsa_private_key,
+    ...     decipher_kid_rsa, encipher_kid_rsa)
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> d = kid_rsa_private_key(a, b, A, B)
+    >>> msg = 200
+    >>> pub = kid_rsa_public_key(a, b, A, B)
+    >>> pri = kid_rsa_private_key(a, b, A, B)
+    >>> ct = encipher_kid_rsa(msg, pub)
+    >>> decipher_kid_rsa(ct, pri)
+    200
+
+    """
+    n, d = key
+    return (msg*d) % n
+
+
+#################### Morse Code ######################################
+
+morse_char = {
+    ".-": "A", "-...": "B",
+    "-.-.": "C", "-..": "D",
+    ".": "E", "..-.": "F",
+    "--.": "G", "....": "H",
+    "..": "I", ".---": "J",
+    "-.-": "K", ".-..": "L",
+    "--": "M", "-.": "N",
+    "---": "O", ".--.": "P",
+    "--.-": "Q", ".-.": "R",
+    "...": "S", "-": "T",
+    "..-": "U", "...-": "V",
+    ".--": "W", "-..-": "X",
+    "-.--": "Y", "--..": "Z",
+    "-----": "0", ".----": "1",
+    "..---": "2", "...--": "3",
+    "....-": "4", ".....": "5",
+    "-....": "6", "--...": "7",
+    "---..": "8", "----.": "9",
+    ".-.-.-": ".", "--..--": ",",
+    "---...": ":", "-.-.-.": ";",
+    "..--..": "?", "-....-": "-",
+    "..--.-": "_", "-.--.": "(",
+    "-.--.-": ")", ".----.": "'",
+    "-...-": "=", ".-.-.": "+",
+    "-..-.": "/", ".--.-.": "@",
+    "...-..-": "$", "-.-.--": "!"}
+char_morse = {v: k for k, v in morse_char.items()}
+
+
+def encode_morse(msg, sep='|', mapping=None):
+    """
+    Encodes a plaintext into popular Morse Code with letters
+    separated by ``sep`` and words by a double ``sep``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encode_morse
+    >>> msg = 'ATTACK RIGHT FLANK'
+    >>> encode_morse(msg)
+    '.-|-|-|.-|-.-.|-.-||.-.|..|--.|....|-||..-.|.-..|.-|-.|-.-'
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Morse_code
+
+    """
+
+    mapping = mapping or char_morse
+    assert sep not in mapping
+    word_sep = 2*sep
+    mapping[" "] = word_sep
+    suffix = msg and msg[-1] in whitespace
+
+    # normalize whitespace
+    msg = (' ' if word_sep else '').join(msg.split())
+    # omit unmapped chars
+    chars = set(''.join(msg.split()))
+    ok = set(mapping.keys())
+    msg = translate(msg, None, ''.join(chars - ok))
+
+    morsestring = []
+    words = msg.split()
+    for word in words:
+        morseword = []
+        for letter in word:
+            morseletter = mapping[letter]
+            morseword.append(morseletter)
+
+        word = sep.join(morseword)
+        morsestring.append(word)
+
+    return word_sep.join(morsestring) + (word_sep if suffix else '')
+
+
+def decode_morse(msg, sep='|', mapping=None):
+    """
+    Decodes a Morse Code with letters separated by ``sep``
+    (default is '|') and words by `word_sep` (default is '||)
+    into plaintext.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decode_morse
+    >>> mc = '--|---|...-|.||.|.-|...|-'
+    >>> decode_morse(mc)
+    'MOVE EAST'
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Morse_code
+
+    """
+
+    mapping = mapping or morse_char
+    word_sep = 2*sep
+    characterstring = []
+    words = msg.strip(word_sep).split(word_sep)
+    for word in words:
+        letters = word.split(sep)
+        chars = [mapping[c] for c in letters]
+        word = ''.join(chars)
+        characterstring.append(word)
+    rv = " ".join(characterstring)
+    return rv
+
+
+#################### LFSRs  ##########################################
+
+
+def lfsr_sequence(key, fill, n):
+    r"""
+    This function creates an LFSR sequence.
+
+    Parameters
+    ==========
+
+    key : list
+        A list of finite field elements, `[c_0, c_1, \ldots, c_k].`
+
+    fill : list
+        The list of the initial terms of the LFSR sequence,
+        `[x_0, x_1, \ldots, x_k].`
+
+    n
+        Number of terms of the sequence that the function returns.
+
+    Returns
+    =======
+
+    L
+        The LFSR sequence defined by
+        `x_{n+1} = c_k x_n + \ldots + c_0 x_{n-k}`, for
+        `n \leq k`.
+
+    Notes
+    =====
+
+    S. Golomb [G]_ gives a list of three statistical properties a
+    sequence of numbers `a = \{a_n\}_{n=1}^\infty`,
+    `a_n \in \{0,1\}`, should display to be considered
+    "random". Define the autocorrelation of `a` to be
+
+    .. math::
+
+        C(k) = C(k,a) = \lim_{N\rightarrow \infty} {1\over N}\sum_{n=1}^N (-1)^{a_n + a_{n+k}}.
+
+    In the case where `a` is periodic with period
+    `P` then this reduces to
+
+    .. math::
+
+        C(k) = {1\over P}\sum_{n=1}^P (-1)^{a_n + a_{n+k}}.
+
+    Assume `a` is periodic with period `P`.
+
+    - balance:
+
+      .. math::
+
+        \left|\sum_{n=1}^P(-1)^{a_n}\right| \leq 1.
+
+    - low autocorrelation:
+
+       .. math::
+
+         C(k) = \left\{ \begin{array}{cc} 1,& k = 0,\\ \epsilon, & k \ne 0. \end{array} \right.
+
+      (For sequences satisfying these first two properties, it is known
+      that `\epsilon = -1/P` must hold.)
+
+    - proportional runs property: In each period, half the runs have
+      length `1`, one-fourth have length `2`, etc.
+      Moreover, there are as many runs of `1`'s as there are of
+      `0`'s.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import lfsr_sequence
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> lfsr_sequence(key, fill, 10)
+    [1 mod 2, 1 mod 2, 0 mod 2, 1 mod 2, 0 mod 2,
+    1 mod 2, 1 mod 2, 0 mod 2, 0 mod 2, 1 mod 2]
+
+    References
+    ==========
+
+    .. [G] Solomon Golomb, Shift register sequences, Aegean Park Press,
+       Laguna Hills, Ca, 1967
+
+    """
+    if not isinstance(key, list):
+        raise TypeError("key must be a list")
+    if not isinstance(fill, list):
+        raise TypeError("fill must be a list")
+    p = key[0].mod
+    F = FF(p)
+    s = fill
+    k = len(fill)
+    L = []
+    for i in range(n):
+        s0 = s[:]
+        L.append(s[0])
+        s = s[1:k]
+        x = sum([int(key[i]*s0[i]) for i in range(k)])
+        s.append(F(x))
+    return L       # use [x.to_int() for x in L] for int version
+
+
+def lfsr_autocorrelation(L, P, k):
+    """
+    This function computes the LFSR autocorrelation function.
+
+    Parameters
+    ==========
+
+    L
+        A periodic sequence of elements of `GF(2)`.
+        L must have length larger than P.
+
+    P
+        The period of L.
+
+    k : int
+        An integer `k` (`0 < k < P`).
+
+    Returns
+    =======
+
+    autocorrelation
+        The k-th value of the autocorrelation of the LFSR L.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     lfsr_sequence, lfsr_autocorrelation)
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_autocorrelation(s, 15, 7)
+    -1/15
+    >>> lfsr_autocorrelation(s, 15, 0)
+    1
+
+    """
+    if not isinstance(L, list):
+        raise TypeError("L (=%s) must be a list" % L)
+    P = int(P)
+    k = int(k)
+    L0 = L[:P]     # slices makes a copy
+    L1 = L0 + L0[:k]
+    L2 = [(-1)**(L1[i].to_int() + L1[i + k].to_int()) for i in range(P)]
+    tot = sum(L2)
+    return Rational(tot, P)
+
+
+def lfsr_connection_polynomial(s):
+    """
+    This function computes the LFSR connection polynomial.
+
+    Parameters
+    ==========
+
+    s
+        A sequence of elements of even length, with entries in a finite
+        field.
+
+    Returns
+    =======
+
+    C(x)
+        The connection polynomial of a minimal LFSR yielding s.
+
+        This implements the algorithm in section 3 of J. L. Massey's
+        article [M]_.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     lfsr_sequence, lfsr_connection_polynomial)
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**4 + x + 1
+    >>> fill = [F(1), F(0), F(0), F(1)]
+    >>> key = [F(1), F(1), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + 1
+    >>> fill = [F(1), F(0), F(1)]
+    >>> key = [F(1), F(1), F(0)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + x**2 + 1
+    >>> fill = [F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + x + 1
+
+    References
+    ==========
+
+    .. [M] James L. Massey, "Shift-Register Synthesis and BCH Decoding."
+        IEEE Trans. on Information Theory, vol. 15(1), pp. 122-127,
+        Jan 1969.
+
+    """
+    # Initialization:
+    p = s[0].mod
+    x = Symbol("x")
+    C = 1*x**0
+    B = 1*x**0
+    m = 1
+    b = 1*x**0
+    L = 0
+    N = 0
+    while N < len(s):
+        if L > 0:
+            dC = Poly(C).degree()
+            r = min(L + 1, dC + 1)
+            coeffsC = [C.subs(x, 0)] + [C.coeff(x**i)
+                for i in range(1, dC + 1)]
+            d = (s[N].to_int() + sum([coeffsC[i]*s[N - i].to_int()
+                for i in range(1, r)])) % p
+        if L == 0:
+            d = s[N].to_int()*x**0
+        if d == 0:
+            m += 1
+            N += 1
+        if d > 0:
+            if 2*L > N:
+                C = (C - d*((b**(p - 2)) % p)*x**m*B).expand()
+                m += 1
+                N += 1
+            else:
+                T = C
+                C = (C - d*((b**(p - 2)) % p)*x**m*B).expand()
+                L = N + 1 - L
+                m = 1
+                b = d
+                B = T
+                N += 1
+    dC = Poly(C).degree()
+    coeffsC = [C.subs(x, 0)] + [C.coeff(x**i) for i in range(1, dC + 1)]
+    return sum([coeffsC[i] % p*x**i for i in range(dC + 1)
+        if coeffsC[i] is not None])
+
+
+#################### ElGamal  #############################
+
+
+def elgamal_private_key(digit=10, seed=None):
+    r"""
+    Return three number tuple as private key.
+
+    Explanation
+    ===========
+
+    Elgamal encryption is based on the mathematical problem
+    called the Discrete Logarithm Problem (DLP). For example,
+
+    `a^{b} \equiv c \pmod p`
+
+    In general, if ``a`` and ``b`` are known, ``ct`` is easily
+    calculated. If ``b`` is unknown, it is hard to use
+    ``a`` and ``ct`` to get ``b``.
+
+    Parameters
+    ==========
+
+    digit : int
+        Minimum number of binary digits for key.
+
+    Returns
+    =======
+
+    tuple : (p, r, d)
+        p = prime number.
+
+        r = primitive root.
+
+        d = random number.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import elgamal_private_key
+    >>> from sympy.ntheory import is_primitive_root, isprime
+    >>> a, b, _ = elgamal_private_key()
+    >>> isprime(a)
+    True
+    >>> is_primitive_root(b, a)
+    True
+
+    """
+    randrange = _randrange(seed)
+    p = nextprime(2**digit)
+    return p, primitive_root(p), randrange(2, p)
+
+
+def elgamal_public_key(key):
+    r"""
+    Return three number tuple as public key.
+
+    Parameters
+    ==========
+
+    key : (p, r, e)
+        Tuple generated by ``elgamal_private_key``.
+
+    Returns
+    =======
+
+    tuple : (p, r, e)
+        `e = r**d \bmod p`
+
+        `d` is a random number in private key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import elgamal_public_key
+    >>> elgamal_public_key((1031, 14, 636))
+    (1031, 14, 212)
+
+    """
+    p, r, e = key
+    return p, r, pow(r, e, p)
+
+
+def encipher_elgamal(i, key, seed=None):
+    r"""
+    Encrypt message with public key.
+
+    Explanation
+    ===========
+
+    ``i`` is a plaintext message expressed as an integer.
+    ``key`` is public key (p, r, e). In order to encrypt
+    a message, a random number ``a`` in ``range(2, p)``
+    is generated and the encryped message is returned as
+    `c_{1}` and `c_{2}` where:
+
+    `c_{1} \equiv r^{a} \pmod p`
+
+    `c_{2} \equiv m e^{a} \pmod p`
+
+    Parameters
+    ==========
+
+    msg
+        int of encoded message.
+
+    key
+        Public key.
+
+    Returns
+    =======
+
+    tuple : (c1, c2)
+        Encipher into two number.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_elgamal, elgamal_private_key, elgamal_public_key
+    >>> pri = elgamal_private_key(5, seed=[3]); pri
+    (37, 2, 3)
+    >>> pub = elgamal_public_key(pri); pub
+    (37, 2, 8)
+    >>> msg = 36
+    >>> encipher_elgamal(msg, pub, seed=[3])
+    (8, 6)
+
+    """
+    p, r, e = key
+    if i < 0 or i >= p:
+        raise ValueError(
+            'Message (%s) should be in range(%s)' % (i, p))
+    randrange = _randrange(seed)
+    a = randrange(2, p)
+    return pow(r, a, p), i*pow(e, a, p) % p
+
+
+def decipher_elgamal(msg, key):
+    r"""
+    Decrypt message with private key.
+
+    `msg = (c_{1}, c_{2})`
+
+    `key = (p, r, d)`
+
+    According to extended Eucliden theorem,
+    `u c_{1}^{d} + p n = 1`
+
+    `u \equiv 1/{{c_{1}}^d} \pmod p`
+
+    `u c_{2} \equiv \frac{1}{c_{1}^d} c_{2} \equiv \frac{1}{r^{ad}} c_{2} \pmod p`
+
+    `\frac{1}{r^{ad}} m e^a \equiv \frac{1}{r^{ad}} m {r^{d a}} \equiv m \pmod p`
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_elgamal
+    >>> from sympy.crypto.crypto import encipher_elgamal
+    >>> from sympy.crypto.crypto import elgamal_private_key
+    >>> from sympy.crypto.crypto import elgamal_public_key
+
+    >>> pri = elgamal_private_key(5, seed=[3])
+    >>> pub = elgamal_public_key(pri); pub
+    (37, 2, 8)
+    >>> msg = 17
+    >>> decipher_elgamal(encipher_elgamal(msg, pub), pri) == msg
+    True
+
+    """
+    p, _, d = key
+    c1, c2 = msg
+    u = igcdex(c1**d, p)[0]
+    return u * c2 % p
+
+
+################ Diffie-Hellman Key Exchange  #########################
+
+def dh_private_key(digit=10, seed=None):
+    r"""
+    Return three integer tuple as private key.
+
+    Explanation
+    ===========
+
+    Diffie-Hellman key exchange is based on the mathematical problem
+    called the Discrete Logarithm Problem (see ElGamal).
+
+    Diffie-Hellman key exchange is divided into the following steps:
+
+    *   Alice and Bob agree on a base that consist of a prime ``p``
+        and a primitive root of ``p`` called ``g``
+    *   Alice choses a number ``a`` and Bob choses a number ``b`` where
+        ``a`` and ``b`` are random numbers in range `[2, p)`. These are
+        their private keys.
+    *   Alice then publicly sends Bob `g^{a} \pmod p` while Bob sends
+        Alice `g^{b} \pmod p`
+    *   They both raise the received value to their secretly chosen
+        number (``a`` or ``b``) and now have both as their shared key
+        `g^{ab} \pmod p`
+
+    Parameters
+    ==========
+
+    digit
+        Minimum number of binary digits required in key.
+
+    Returns
+    =======
+
+    tuple : (p, g, a)
+        p = prime number.
+
+        g = primitive root of p.
+
+        a = random number from 2 through p - 1.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import dh_private_key
+    >>> from sympy.ntheory import isprime, is_primitive_root
+    >>> p, g, _ = dh_private_key()
+    >>> isprime(p)
+    True
+    >>> is_primitive_root(g, p)
+    True
+    >>> p, g, _ = dh_private_key(5)
+    >>> isprime(p)
+    True
+    >>> is_primitive_root(g, p)
+    True
+
+    """
+    p = nextprime(2**digit)
+    g = primitive_root(p)
+    randrange = _randrange(seed)
+    a = randrange(2, p)
+    return p, g, a
+
+
+def dh_public_key(key):
+    r"""
+    Return three number tuple as public key.
+
+    This is the tuple that Alice sends to Bob.
+
+    Parameters
+    ==========
+
+    key : (p, g, a)
+        A tuple generated by ``dh_private_key``.
+
+    Returns
+    =======
+
+    tuple : int, int, int
+        A tuple of `(p, g, g^a \mod p)` with `p`, `g` and `a` given as
+        parameters.s
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import dh_private_key, dh_public_key
+    >>> p, g, a = dh_private_key();
+    >>> _p, _g, x = dh_public_key((p, g, a))
+    >>> p == _p and g == _g
+    True
+    >>> x == pow(g, a, p)
+    True
+
+    """
+    p, g, a = key
+    return p, g, pow(g, a, p)
+
+
+def dh_shared_key(key, b):
+    """
+    Return an integer that is the shared key.
+
+    This is what Bob and Alice can both calculate using the public
+    keys they received from each other and their private keys.
+
+    Parameters
+    ==========
+
+    key : (p, g, x)
+        Tuple `(p, g, x)` generated by ``dh_public_key``.
+
+    b
+        Random number in the range of `2` to `p - 1`
+        (Chosen by second key exchange member (Bob)).
+
+    Returns
+    =======
+
+    int
+        A shared key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     dh_private_key, dh_public_key, dh_shared_key)
+    >>> prk = dh_private_key();
+    >>> p, g, x = dh_public_key(prk);
+    >>> sk = dh_shared_key((p, g, x), 1000)
+    >>> sk == pow(x, 1000, p)
+    True
+
+    """
+    p, _, x = key
+    if 1 >= b or b >= p:
+        raise ValueError(filldedent('''
+            Value of b should be greater 1 and less
+            than prime %s.''' % p))
+
+    return pow(x, b, p)
+
+
+################ Goldwasser-Micali Encryption  #########################
+
+
+def _legendre(a, p):
+    """
+    Returns the legendre symbol of a and p
+    assuming that p is a prime.
+
+    i.e. 1 if a is a quadratic residue mod p
+        -1 if a is not a quadratic residue mod p
+         0 if a is divisible by p
+
+    Parameters
+    ==========
+
+    a : int
+        The number to test.
+
+    p : prime
+        The prime to test ``a`` against.
+
+    Returns
+    =======
+
+    int
+        Legendre symbol (a / p).
+
+    """
+    sig = pow(a, (p - 1)//2, p)
+    if sig == 1:
+        return 1
+    elif sig == 0:
+        return 0
+    else:
+        return -1
+
+
+def _random_coprime_stream(n, seed=None):
+    randrange = _randrange(seed)
+    while True:
+        y = randrange(n)
+        if gcd(y, n) == 1:
+            yield y
+
+
+def gm_private_key(p, q, a=None):
+    r"""
+    Check if ``p`` and ``q`` can be used as private keys for
+    the Goldwasser-Micali encryption. The method works
+    roughly as follows.
+
+    Explanation
+    ===========
+
+    #. Pick two large primes $p$ and $q$.
+    #. Call their product $N$.
+    #. Given a message as an integer $i$, write $i$ in its bit representation $b_0, \dots, b_n$.
+    #. For each $k$,
+
+     if $b_k = 0$:
+        let $a_k$ be a random square
+        (quadratic residue) modulo $p q$
+        such that ``jacobi_symbol(a, p*q) = 1``
+     if $b_k = 1$:
+        let $a_k$ be a random non-square
+        (non-quadratic residue) modulo $p q$
+        such that ``jacobi_symbol(a, p*q) = 1``
+
+    returns $\left[a_1, a_2, \dots\right]$
+
+    $b_k$ can be recovered by checking whether or not
+    $a_k$ is a residue. And from the $b_k$'s, the message
+    can be reconstructed.
+
+    The idea is that, while ``jacobi_symbol(a, p*q)``
+    can be easily computed (and when it is equal to $-1$ will
+    tell you that $a$ is not a square mod $p q$), quadratic
+    residuosity modulo a composite number is hard to compute
+    without knowing its factorization.
+
+    Moreover, approximately half the numbers coprime to $p q$ have
+    :func:`~.jacobi_symbol` equal to $1$ . And among those, approximately half
+    are residues and approximately half are not. This maximizes the
+    entropy of the code.
+
+    Parameters
+    ==========
+
+    p, q, a
+        Initialization variables.
+
+    Returns
+    =======
+
+    tuple : (p, q)
+        The input value ``p`` and ``q``.
+
+    Raises
+    ======
+
+    ValueError
+        If ``p`` and ``q`` are not distinct odd primes.
+
+    """
+    if p == q:
+        raise ValueError("expected distinct primes, "
+                         "got two copies of %i" % p)
+    elif not isprime(p) or not isprime(q):
+        raise ValueError("first two arguments must be prime, "
+                         "got %i of %i" % (p, q))
+    elif p == 2 or q == 2:
+        raise ValueError("first two arguments must not be even, "
+                         "got %i of %i" % (p, q))
+    return p, q
+
+
+def gm_public_key(p, q, a=None, seed=None):
+    """
+    Compute public keys for ``p`` and ``q``.
+    Note that in Goldwasser-Micali Encryption,
+    public keys are randomly selected.
+
+    Parameters
+    ==========
+
+    p, q, a : int, int, int
+        Initialization variables.
+
+    Returns
+    =======
+
+    tuple : (a, N)
+        ``a`` is the input ``a`` if it is not ``None`` otherwise
+        some random integer coprime to ``p`` and ``q``.
+
+        ``N`` is the product of ``p`` and ``q``.
+
+    """
+
+    p, q = gm_private_key(p, q)
+    N = p * q
+
+    if a is None:
+        randrange = _randrange(seed)
+        while True:
+            a = randrange(N)
+            if _legendre(a, p) == _legendre(a, q) == -1:
+                break
+    else:
+        if _legendre(a, p) != -1 or _legendre(a, q) != -1:
+            return False
+    return (a, N)
+
+
+def encipher_gm(i, key, seed=None):
+    """
+    Encrypt integer 'i' using public_key 'key'
+    Note that gm uses random encryption.
+
+    Parameters
+    ==========
+
+    i : int
+        The message to encrypt.
+
+    key : (a, N)
+        The public key.
+
+    Returns
+    =======
+
+    list : list of int
+        The randomized encrypted message.
+
+    """
+    if i < 0:
+        raise ValueError(
+            "message must be a non-negative "
+            "integer: got %d instead" % i)
+    a, N = key
+    bits = []
+    while i > 0:
+        bits.append(i % 2)
+        i //= 2
+
+    gen = _random_coprime_stream(N, seed)
+    rev = reversed(bits)
+    encode = lambda b: next(gen)**2*pow(a, b) % N
+    return [ encode(b) for b in rev ]
+
+
+
+def decipher_gm(message, key):
+    """
+    Decrypt message 'message' using public_key 'key'.
+
+    Parameters
+    ==========
+
+    message : list of int
+        The randomized encrypted message.
+
+    key : (p, q)
+        The private key.
+
+    Returns
+    =======
+
+    int
+        The encrypted message.
+
+    """
+    p, q = key
+    res = lambda m, p: _legendre(m, p) > 0
+    bits = [res(m, p) * res(m, q) for m in message]
+    m = 0
+    for b in bits:
+        m <<= 1
+        m += not b
+    return m
+
+
+
+########### RailFence Cipher #############
+
+def encipher_railfence(message,rails):
+    """
+    Performs Railfence Encryption on plaintext and returns ciphertext
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_railfence
+    >>> message = "hello world"
+    >>> encipher_railfence(message,3)
+    'horel ollwd'
+
+    Parameters
+    ==========
+
+    message : string, the message to encrypt.
+    rails : int, the number of rails.
+
+    Returns
+    =======
+
+    The Encrypted string message.
+
+    References
+    ==========
+    .. [1] https://en.wikipedia.org/wiki/Rail_fence_cipher
+
+    """
+    r = list(range(rails))
+    p = cycle(r + r[-2:0:-1])
+    return ''.join(sorted(message, key=lambda i: next(p)))
+
+
+def decipher_railfence(ciphertext,rails):
+    """
+    Decrypt the message using the given rails
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_railfence
+    >>> decipher_railfence("horel ollwd",3)
+    'hello world'
+
+    Parameters
+    ==========
+
+    message : string, the message to encrypt.
+    rails : int, the number of rails.
+
+    Returns
+    =======
+
+    The Decrypted string message.
+
+    """
+    r = list(range(rails))
+    p = cycle(r + r[-2:0:-1])
+
+    idx = sorted(range(len(ciphertext)), key=lambda i: next(p))
+    res = [''] * len(ciphertext)
+    for i, c in zip(idx, ciphertext):
+        res[i] = c
+    return ''.join(res)
+
+
+################ Blum-Goldwasser cryptosystem  #########################
+
+def bg_private_key(p, q):
+    """
+    Check if p and q can be used as private keys for
+    the Blum-Goldwasser cryptosystem.
+
+    Explanation
+    ===========
+
+    The three necessary checks for p and q to pass
+    so that they can be used as private keys:
+
+        1. p and q must both be prime
+        2. p and q must be distinct
+        3. p and q must be congruent to 3 mod 4
+
+    Parameters
+    ==========
+
+    p, q
+        The keys to be checked.
+
+    Returns
+    =======
+
+    p, q
+        Input values.
+
+    Raises
+    ======
+
+    ValueError
+        If p and q do not pass the above conditions.
+
+    """
+
+    if not isprime(p) or not isprime(q):
+        raise ValueError("the two arguments must be prime, "
+                         "got %i and %i" %(p, q))
+    elif p == q:
+        raise ValueError("the two arguments must be distinct, "
+                         "got two copies of %i. " %p)
+    elif (p - 3) % 4 != 0 or (q - 3) % 4 != 0:
+        raise ValueError("the two arguments must be congruent to 3 mod 4, "
+                         "got %i and %i" %(p, q))
+    return p, q
+
+def bg_public_key(p, q):
+    """
+    Calculates public keys from private keys.
+
+    Explanation
+    ===========
+
+    The function first checks the validity of
+    private keys passed as arguments and
+    then returns their product.
+
+    Parameters
+    ==========
+
+    p, q
+        The private keys.
+
+    Returns
+    =======
+
+    N
+        The public key.
+
+    """
+    p, q = bg_private_key(p, q)
+    N = p * q
+    return N
+
+def encipher_bg(i, key, seed=None):
+    """
+    Encrypts the message using public key and seed.
+
+    Explanation
+    ===========
+
+    ALGORITHM:
+        1. Encodes i as a string of L bits, m.
+        2. Select a random element r, where 1 < r < key, and computes
+           x = r^2 mod key.
+        3. Use BBS pseudo-random number generator to generate L random bits, b,
+        using the initial seed as x.
+        4. Encrypted message, c_i = m_i XOR b_i, 1 <= i <= L.
+        5. x_L = x^(2^L) mod key.
+        6. Return (c, x_L)
+
+    Parameters
+    ==========
+
+    i
+        Message, a non-negative integer
+
+    key
+        The public key
+
+    Returns
+    =======
+
+    Tuple
+        (encrypted_message, x_L)
+
+    Raises
+    ======
+
+    ValueError
+        If i is negative.
+
+    """
+
+    if i < 0:
+        raise ValueError(
+            "message must be a non-negative "
+            "integer: got %d instead" % i)
+
+    enc_msg = []
+    while i > 0:
+        enc_msg.append(i % 2)
+        i //= 2
+    enc_msg.reverse()
+    L = len(enc_msg)
+
+    r = _randint(seed)(2, key - 1)
+    x = r**2 % key
+    x_L = pow(int(x), int(2**L), int(key))
+
+    rand_bits = []
+    for _ in range(L):
+        rand_bits.append(x % 2)
+        x = x**2 % key
+
+    encrypt_msg = [m ^ b for (m, b) in zip(enc_msg, rand_bits)]
+
+    return (encrypt_msg, x_L)
+
+def decipher_bg(message, key):
+    """
+    Decrypts the message using private keys.
+
+    Explanation
+    ===========
+
+    ALGORITHM:
+        1. Let, c be the encrypted message, y the second number received,
+        and p and q be the private keys.
+        2. Compute, r_p = y^((p+1)/4 ^ L) mod p and
+        r_q = y^((q+1)/4 ^ L) mod q.
+        3. Compute x_0 = (q(q^-1 mod p)r_p + p(p^-1 mod q)r_q) mod N.
+        4. From, recompute the bits using the BBS generator, as in the
+        encryption algorithm.
+        5. Compute original message by XORing c and b.
+
+    Parameters
+    ==========
+
+    message
+        Tuple of encrypted message and a non-negative integer.
+
+    key
+        Tuple of private keys.
+
+    Returns
+    =======
+
+    orig_msg
+        The original message
+
+    """
+
+    p, q = key
+    encrypt_msg, y = message
+    public_key = p * q
+    L = len(encrypt_msg)
+    p_t = ((p + 1)/4)**L
+    q_t = ((q + 1)/4)**L
+    r_p = pow(int(y), int(p_t), int(p))
+    r_q = pow(int(y), int(q_t), int(q))
+
+    x = (q * mod_inverse(q, p) * r_p + p * mod_inverse(p, q) * r_q) % public_key
+
+    orig_bits = []
+    for _ in range(L):
+        orig_bits.append(x % 2)
+        x = x**2 % public_key
+
+    orig_msg = 0
+    for (m, b) in zip(encrypt_msg, orig_bits):
+        orig_msg = orig_msg * 2
+        orig_msg += (m ^ b)
+
+    return orig_msg

llmeval-env/lib/python3.10/site-packages/sympy/crypto/tests/test_crypto.py

@@ -0,0 +1,562 @@
+from sympy.core import symbols
+from sympy.crypto.crypto import (cycle_list,
+      encipher_shift, encipher_affine, encipher_substitution,
+      check_and_join, encipher_vigenere, decipher_vigenere,
+      encipher_hill, decipher_hill, encipher_bifid5, encipher_bifid6,
+      bifid5_square, bifid6_square, bifid5, bifid6,
+      decipher_bifid5, decipher_bifid6, encipher_kid_rsa,
+      decipher_kid_rsa, kid_rsa_private_key, kid_rsa_public_key,
+      decipher_rsa, rsa_private_key, rsa_public_key, encipher_rsa,
+      lfsr_connection_polynomial, lfsr_autocorrelation, lfsr_sequence,
+      encode_morse, decode_morse, elgamal_private_key, elgamal_public_key,
+      encipher_elgamal, decipher_elgamal, dh_private_key, dh_public_key,
+      dh_shared_key, decipher_shift, decipher_affine, encipher_bifid,
+      decipher_bifid, bifid_square, padded_key, uniq, decipher_gm,
+      encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg,
+      bg_private_key, bg_public_key, encipher_rot13, decipher_rot13,
+      encipher_atbash, decipher_atbash, NonInvertibleCipherWarning,
+      encipher_railfence, decipher_railfence)
+from sympy.matrices import Matrix
+from sympy.ntheory import isprime, is_primitive_root
+from sympy.polys.domains import FF
+
+from sympy.testing.pytest import raises, warns
+
+from sympy.core.random import randrange
+
+def test_encipher_railfence():
+    assert encipher_railfence("hello world",2) == "hlowrdel ol"
+    assert encipher_railfence("hello world",3) == "horel ollwd"
+    assert encipher_railfence("hello world",4) == "hwe olordll"
+
+def test_decipher_railfence():
+    assert decipher_railfence("hlowrdel ol",2) == "hello world"
+    assert decipher_railfence("horel ollwd",3) == "hello world"
+    assert decipher_railfence("hwe olordll",4) == "hello world"
+
+
+def test_cycle_list():
+    assert cycle_list(3, 4) == [3, 0, 1, 2]
+    assert cycle_list(-1, 4) == [3, 0, 1, 2]
+    assert cycle_list(1, 4) == [1, 2, 3, 0]
+
+
+def test_encipher_shift():
+    assert encipher_shift("ABC", 0) == "ABC"
+    assert encipher_shift("ABC", 1) == "BCD"
+    assert encipher_shift("ABC", -1) == "ZAB"
+    assert decipher_shift("ZAB", -1) == "ABC"
+
+def test_encipher_rot13():
+    assert encipher_rot13("ABC") == "NOP"
+    assert encipher_rot13("NOP") == "ABC"
+    assert decipher_rot13("ABC") == "NOP"
+    assert decipher_rot13("NOP") == "ABC"
+
+
+def test_encipher_affine():
+    assert encipher_affine("ABC", (1, 0)) == "ABC"
+    assert encipher_affine("ABC", (1, 1)) == "BCD"
+    assert encipher_affine("ABC", (-1, 0)) == "AZY"
+    assert encipher_affine("ABC", (-1, 1), symbols="ABCD") == "BAD"
+    assert encipher_affine("123", (-1, 1), symbols="1234") == "214"
+    assert encipher_affine("ABC", (3, 16)) == "QTW"
+    assert decipher_affine("QTW", (3, 16)) == "ABC"
+
+def test_encipher_atbash():
+    assert encipher_atbash("ABC") == "ZYX"
+    assert encipher_atbash("ZYX") == "ABC"
+    assert decipher_atbash("ABC") == "ZYX"
+    assert decipher_atbash("ZYX") == "ABC"
+
+def test_encipher_substitution():
+    assert encipher_substitution("ABC", "BAC", "ABC") == "BAC"
+    assert encipher_substitution("123", "1243", "1234") == "124"
+
+
+def test_check_and_join():
+    assert check_and_join("abc") == "abc"
+    assert check_and_join(uniq("aaabc")) == "abc"
+    assert check_and_join("ab c".split()) == "abc"
+    assert check_and_join("abc", "a", filter=True) == "a"
+    raises(ValueError, lambda: check_and_join('ab', 'a'))
+
+
+def test_encipher_vigenere():
+    assert encipher_vigenere("ABC", "ABC") == "ACE"
+    assert encipher_vigenere("ABC", "ABC", symbols="ABCD") == "ACA"
+    assert encipher_vigenere("ABC", "AB", symbols="ABCD") == "ACC"
+    assert encipher_vigenere("AB", "ABC", symbols="ABCD") == "AC"
+    assert encipher_vigenere("A", "ABC", symbols="ABCD") == "A"
+
+
+def test_decipher_vigenere():
+    assert decipher_vigenere("ABC", "ABC") == "AAA"
+    assert decipher_vigenere("ABC", "ABC", symbols="ABCD") == "AAA"
+    assert decipher_vigenere("ABC", "AB", symbols="ABCD") == "AAC"
+    assert decipher_vigenere("AB", "ABC", symbols="ABCD") == "AA"
+    assert decipher_vigenere("A", "ABC", symbols="ABCD") == "A"
+
+
+def test_encipher_hill():
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert encipher_hill("ABCD", A) == "CFIV"
+    A = Matrix(2, 2, [1, 0, 0, 1])
+    assert encipher_hill("ABCD", A) == "ABCD"
+    assert encipher_hill("ABCD", A, symbols="ABCD") == "ABCD"
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert encipher_hill("ABCD", A, symbols="ABCD") == "CBAB"
+    assert encipher_hill("AB", A, symbols="ABCD") == "CB"
+    # message length, n, does not need to be a multiple of k;
+    # it is padded
+    assert encipher_hill("ABA", A) == "CFGC"
+    assert encipher_hill("ABA", A, pad="Z") == "CFYV"
+
+
+def test_decipher_hill():
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert decipher_hill("CFIV", A) == "ABCD"
+    A = Matrix(2, 2, [1, 0, 0, 1])
+    assert decipher_hill("ABCD", A) == "ABCD"
+    assert decipher_hill("ABCD", A, symbols="ABCD") == "ABCD"
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert decipher_hill("CBAB", A, symbols="ABCD") == "ABCD"
+    assert decipher_hill("CB", A, symbols="ABCD") == "AB"
+    # n does not need to be a multiple of k
+    assert decipher_hill("CFA", A) == "ABAA"
+
+
+def test_encipher_bifid5():
+    assert encipher_bifid5("AB", "AB") == "AB"
+    assert encipher_bifid5("AB", "CD") == "CO"
+    assert encipher_bifid5("ab", "c") == "CH"
+    assert encipher_bifid5("a bc", "b") == "BAC"
+
+
+def test_bifid5_square():
+    A = bifid5
+    f = lambda i, j: symbols(A[5*i + j])
+    M = Matrix(5, 5, f)
+    assert bifid5_square("") == M
+
+
+def test_decipher_bifid5():
+    assert decipher_bifid5("AB", "AB") == "AB"
+    assert decipher_bifid5("CO", "CD") == "AB"
+    assert decipher_bifid5("ch", "c") == "AB"
+    assert decipher_bifid5("b ac", "b") == "ABC"
+
+
+def test_encipher_bifid6():
+    assert encipher_bifid6("AB", "AB") == "AB"
+    assert encipher_bifid6("AB", "CD") == "CP"
+    assert encipher_bifid6("ab", "c") == "CI"
+    assert encipher_bifid6("a bc", "b") == "BAC"
+
+
+def test_decipher_bifid6():
+    assert decipher_bifid6("AB", "AB") == "AB"
+    assert decipher_bifid6("CP", "CD") == "AB"
+    assert decipher_bifid6("ci", "c") == "AB"
+    assert decipher_bifid6("b ac", "b") == "ABC"
+
+
+def test_bifid6_square():
+    A = bifid6
+    f = lambda i, j: symbols(A[6*i + j])
+    M = Matrix(6, 6, f)
+    assert bifid6_square("") == M
+
+
+def test_rsa_public_key():
+    assert rsa_public_key(2, 3, 1) == (6, 1)
+    assert rsa_public_key(5, 3, 3) == (15, 3)
+
+    with warns(NonInvertibleCipherWarning):
+        assert rsa_public_key(2, 2, 1) == (4, 1)
+        assert rsa_public_key(8, 8, 8) is False
+
+
+def test_rsa_private_key():
+    assert rsa_private_key(2, 3, 1) == (6, 1)
+    assert rsa_private_key(5, 3, 3) == (15, 3)
+    assert rsa_private_key(23,29,5) == (667,493)
+
+    with warns(NonInvertibleCipherWarning):
+        assert rsa_private_key(2, 2, 1) == (4, 1)
+        assert rsa_private_key(8, 8, 8) is False
+
+
+def test_rsa_large_key():
+    # Sample from
+    # http://www.herongyang.com/Cryptography/JCE-Public-Key-RSA-Private-Public-Key-Pair-Sample.html
+    p = int('101565610013301240713207239558950144682174355406589305284428666'\
+        '903702505233009')
+    q = int('894687191887545488935455605955948413812376003053143521429242133'\
+        '12069293984003')
+    e = int('65537')
+    d = int('893650581832704239530398858744759129594796235440844479456143566'\
+        '6999402846577625762582824202269399672579058991442587406384754958587'\
+        '400493169361356902030209')
+    assert rsa_public_key(p, q, e) == (p*q, e)
+    assert rsa_private_key(p, q, e) == (p*q, d)
+
+
+def test_encipher_rsa():
+    puk = rsa_public_key(2, 3, 1)
+    assert encipher_rsa(2, puk) == 2
+    puk = rsa_public_key(5, 3, 3)
+    assert encipher_rsa(2, puk) == 8
+
+    with warns(NonInvertibleCipherWarning):
+        puk = rsa_public_key(2, 2, 1)
+        assert encipher_rsa(2, puk) == 2
+
+
+def test_decipher_rsa():
+    prk = rsa_private_key(2, 3, 1)
+    assert decipher_rsa(2, prk) == 2
+    prk = rsa_private_key(5, 3, 3)
+    assert decipher_rsa(8, prk) == 2
+
+    with warns(NonInvertibleCipherWarning):
+        prk = rsa_private_key(2, 2, 1)
+        assert decipher_rsa(2, prk) == 2
+
+
+def test_mutltiprime_rsa_full_example():
+    # Test example from
+    # https://iopscience.iop.org/article/10.1088/1742-6596/995/1/012030
+    puk = rsa_public_key(2, 3, 5, 7, 11, 13, 7)
+    prk = rsa_private_key(2, 3, 5, 7, 11, 13, 7)
+    assert puk == (30030, 7)
+    assert prk == (30030, 823)
+
+    msg = 10
+    encrypted = encipher_rsa(2 * msg - 15, puk)
+    assert encrypted == 18065
+    decrypted = (decipher_rsa(encrypted, prk) + 15) / 2
+    assert decrypted == msg
+
+    # Test example from
+    # https://www.scirp.org/pdf/JCC_2018032215502008.pdf
+    puk1 = rsa_public_key(53, 41, 43, 47, 41)
+    prk1 = rsa_private_key(53, 41, 43, 47, 41)
+    puk2 = rsa_public_key(53, 41, 43, 47, 97)
+    prk2 = rsa_private_key(53, 41, 43, 47, 97)
+
+    assert puk1 == (4391633, 41)
+    assert prk1 == (4391633, 294041)
+    assert puk2 == (4391633, 97)
+    assert prk2 == (4391633, 455713)
+
+    msg = 12321
+    encrypted = encipher_rsa(encipher_rsa(msg, puk1), puk2)
+    assert encrypted == 1081588
+    decrypted = decipher_rsa(decipher_rsa(encrypted, prk2), prk1)
+    assert decrypted == msg
+
+
+def test_rsa_crt_extreme():
+    p = int(
+        '10177157607154245068023861503693082120906487143725062283406501' \
+        '54082258226204046999838297167140821364638180697194879500245557' \
+        '65445186962893346463841419427008800341257468600224049986260471' \
+        '92257248163014468841725476918639415726709736077813632961290911' \
+        '0256421232977833028677441206049309220354796014376698325101693')
+
+    q = int(
+        '28752342353095132872290181526607275886182793241660805077850801' \
+        '75689512797754286972952273553128181861830576836289738668745250' \
+        '34028199691128870676414118458442900035778874482624765513861643' \
+        '27966696316822188398336199002306588703902894100476186823849595' \
+        '103239410527279605442148285816149368667083114802852804976893')
+
+    r = int(
+        '17698229259868825776879500736350186838850961935956310134378261' \
+        '89771862186717463067541369694816245225291921138038800171125596' \
+        '07315449521981157084370187887650624061033066022458512942411841' \
+        '18747893789972315277160085086164119879536041875335384844820566' \
+        '0287479617671726408053319619892052000850883994343378882717849')
+
+    s = int(
+        '68925428438585431029269182233502611027091755064643742383515623' \
+        '64321310582896893395529367074942808353187138794422745718419645' \
+        '28291231865157212604266903677599180789896916456120289112752835' \
+        '98502265889669730331688206825220074713977607415178738015831030' \
+        '364290585369150502819743827343552098197095520550865360159439'
+    )
+
+    t = int(
+        '69035483433453632820551311892368908779778144568711455301541094' \
+        '31487047642322695357696860925747923189635033183069823820910521' \
+        '71172909106797748883261493224162414050106920442445896819806600' \
+        '15448444826108008217972129130625571421904893252804729877353352' \
+        '739420480574842850202181462656251626522910618936534699566291'
+    )
+
+    e = 65537
+    puk = rsa_public_key(p, q, r, s, t, e)
+    prk = rsa_private_key(p, q, r, s, t, e)
+
+    plaintext = 1000
+    ciphertext_1 = encipher_rsa(plaintext, puk)
+    ciphertext_2 = encipher_rsa(plaintext, puk, [p, q, r, s, t])
+    assert ciphertext_1 == ciphertext_2
+    assert decipher_rsa(ciphertext_1, prk) == \
+        decipher_rsa(ciphertext_1, prk, [p, q, r, s, t])
+
+
+def test_rsa_exhaustive():
+    p, q = 61, 53
+    e = 17
+    puk = rsa_public_key(p, q, e, totient='Carmichael')
+    prk = rsa_private_key(p, q, e, totient='Carmichael')
+
+    for msg in range(puk[0]):
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_rsa_multiprime_exhanstive():
+    primes = [3, 5, 7, 11]
+    e = 7
+    args = primes + [e]
+    puk = rsa_public_key(*args, totient='Carmichael')
+    prk = rsa_private_key(*args, totient='Carmichael')
+    n = puk[0]
+
+    for msg in range(n):
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_rsa_multipower_exhanstive():
+    from sympy.core.numbers import igcd
+    primes = [5, 5, 7]
+    e = 7
+    args = primes + [e]
+    puk = rsa_public_key(*args, multipower=True)
+    prk = rsa_private_key(*args, multipower=True)
+    n = puk[0]
+
+    for msg in range(n):
+        if igcd(msg, n) != 1:
+            continue
+
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_kid_rsa_public_key():
+    assert kid_rsa_public_key(1, 2, 1, 1) == (5, 2)
+    assert kid_rsa_public_key(1, 2, 2, 1) == (8, 3)
+    assert kid_rsa_public_key(1, 2, 1, 2) == (7, 2)
+
+
+def test_kid_rsa_private_key():
+    assert kid_rsa_private_key(1, 2, 1, 1) == (5, 3)
+    assert kid_rsa_private_key(1, 2, 2, 1) == (8, 3)
+    assert kid_rsa_private_key(1, 2, 1, 2) == (7, 4)
+
+
+def test_encipher_kid_rsa():
+    assert encipher_kid_rsa(1, (5, 2)) == 2
+    assert encipher_kid_rsa(1, (8, 3)) == 3
+    assert encipher_kid_rsa(1, (7, 2)) == 2
+
+
+def test_decipher_kid_rsa():
+    assert decipher_kid_rsa(2, (5, 3)) == 1
+    assert decipher_kid_rsa(3, (8, 3)) == 1
+    assert decipher_kid_rsa(2, (7, 4)) == 1
+
+
+def test_encode_morse():
+    assert encode_morse('ABC') == '.-|-...|-.-.'
+    assert encode_morse('SMS ') == '...|--|...||'
+    assert encode_morse('SMS\n') == '...|--|...||'
+    assert encode_morse('') == ''
+    assert encode_morse(' ') == '||'
+    assert encode_morse(' ', sep='`') == '``'
+    assert encode_morse(' ', sep='``') == '````'
+    assert encode_morse('!@#$%^&*()_+') == '-.-.--|.--.-.|...-..-|-.--.|-.--.-|..--.-|.-.-.'
+    assert encode_morse('12345') == '.----|..---|...--|....-|.....'
+    assert encode_morse('67890') == '-....|--...|---..|----.|-----'
+
+
+def test_decode_morse():
+    assert decode_morse('-.-|.|-.--') == 'KEY'
+    assert decode_morse('.-.|..-|-.||') == 'RUN'
+    raises(KeyError, lambda: decode_morse('.....----'))
+
+
+def test_lfsr_sequence():
+    raises(TypeError, lambda: lfsr_sequence(1, [1], 1))
+    raises(TypeError, lambda: lfsr_sequence([1], 1, 1))
+    F = FF(2)
+    assert lfsr_sequence([F(1)], [F(1)], 2) == [F(1), F(1)]
+    assert lfsr_sequence([F(0)], [F(1)], 2) == [F(1), F(0)]
+    F = FF(3)
+    assert lfsr_sequence([F(1)], [F(1)], 2) == [F(1), F(1)]
+    assert lfsr_sequence([F(0)], [F(2)], 2) == [F(2), F(0)]
+    assert lfsr_sequence([F(1)], [F(2)], 2) == [F(2), F(2)]
+
+
+def test_lfsr_autocorrelation():
+    raises(TypeError, lambda: lfsr_autocorrelation(1, 2, 3))
+    F = FF(2)
+    s = lfsr_sequence([F(1), F(0)], [F(0), F(1)], 5)
+    assert lfsr_autocorrelation(s, 2, 0) == 1
+    assert lfsr_autocorrelation(s, 2, 1) == -1
+
+
+def test_lfsr_connection_polynomial():
+    F = FF(2)
+    x = symbols("x")
+    s = lfsr_sequence([F(1), F(0)], [F(0), F(1)], 5)
+    assert lfsr_connection_polynomial(s) == x**2 + 1
+    s = lfsr_sequence([F(1), F(1)], [F(0), F(1)], 5)
+    assert lfsr_connection_polynomial(s) == x**2 + x + 1
+
+
+def test_elgamal_private_key():
+    a, b, _ = elgamal_private_key(digit=100)
+    assert isprime(a)
+    assert is_primitive_root(b, a)
+    assert len(bin(a)) >= 102
+
+
+def test_elgamal():
+    dk = elgamal_private_key(5)
+    ek = elgamal_public_key(dk)
+    P = ek[0]
+    assert P - 1 == decipher_elgamal(encipher_elgamal(P - 1, ek), dk)
+    raises(ValueError, lambda: encipher_elgamal(P, dk))
+    raises(ValueError, lambda: encipher_elgamal(-1, dk))
+
+
+def test_dh_private_key():
+    p, g, _ = dh_private_key(digit = 100)
+    assert isprime(p)
+    assert is_primitive_root(g, p)
+    assert len(bin(p)) >= 102
+
+
+def test_dh_public_key():
+    p1, g1, a = dh_private_key(digit = 100)
+    p2, g2, ga = dh_public_key((p1, g1, a))
+    assert p1 == p2
+    assert g1 == g2
+    assert ga == pow(g1, a, p1)
+
+
+def test_dh_shared_key():
+    prk = dh_private_key(digit = 100)
+    p, _, ga = dh_public_key(prk)
+    b = randrange(2, p)
+    sk = dh_shared_key((p, _, ga), b)
+    assert sk == pow(ga, b, p)
+    raises(ValueError, lambda: dh_shared_key((1031, 14, 565), 2000))
+
+
+def test_padded_key():
+    assert padded_key('b', 'ab') == 'ba'
+    raises(ValueError, lambda: padded_key('ab', 'ace'))
+    raises(ValueError, lambda: padded_key('ab', 'abba'))
+
+
+def test_bifid():
+    raises(ValueError, lambda: encipher_bifid('abc', 'b', 'abcde'))
+    assert encipher_bifid('abc', 'b', 'abcd') == 'bdb'
+    raises(ValueError, lambda: decipher_bifid('bdb', 'b', 'abcde'))
+    assert encipher_bifid('bdb', 'b', 'abcd') == 'abc'
+    raises(ValueError, lambda: bifid_square('abcde'))
+    assert bifid5_square("B") == \
+        bifid5_square('BACDEFGHIKLMNOPQRSTUVWXYZ')
+    assert bifid6_square('B0') == \
+        bifid6_square('B0ACDEFGHIJKLMNOPQRSTUVWXYZ123456789')
+
+
+def test_encipher_decipher_gm():
+    ps = [131, 137, 139, 149, 151, 157, 163, 167,
+          173, 179, 181, 191, 193, 197, 199]
+    qs = [89, 97, 101, 103, 107, 109, 113, 127,
+          131, 137, 139, 149, 151, 157, 47]
+    messages = [
+        0, 32855, 34303, 14805, 1280, 75859, 38368,
+        724, 60356, 51675, 76697, 61854, 18661,
+    ]
+    for p, q in zip(ps, qs):
+        pri = gm_private_key(p, q)
+        for msg in messages:
+            pub = gm_public_key(p, q)
+            enc = encipher_gm(msg, pub)
+            dec = decipher_gm(enc, pri)
+            assert dec == msg
+
+
+def test_gm_private_key():
+    raises(ValueError, lambda: gm_public_key(13, 15))
+    raises(ValueError, lambda: gm_public_key(0, 0))
+    raises(ValueError, lambda: gm_public_key(0, 5))
+    assert 17, 19 == gm_public_key(17, 19)
+
+
+def test_gm_public_key():
+    assert 323 == gm_public_key(17, 19)[1]
+    assert 15  == gm_public_key(3, 5)[1]
+    raises(ValueError, lambda: gm_public_key(15, 19))
+
+def test_encipher_decipher_bg():
+    ps = [67, 7, 71, 103, 11, 43, 107, 47,
+          79, 19, 83, 23, 59, 127, 31]
+    qs = qs = [7, 71, 103, 11, 43, 107, 47,
+               79, 19, 83, 23, 59, 127, 31, 67]
+    messages = [
+        0, 328, 343, 148, 1280, 758, 383,
+        724, 603, 516, 766, 618, 186,
+    ]
+
+    for p, q in zip(ps, qs):
+        pri = bg_private_key(p, q)
+        for msg in messages:
+            pub = bg_public_key(p, q)
+            enc = encipher_bg(msg, pub)
+            dec = decipher_bg(enc, pri)
+            assert dec == msg
+
+def test_bg_private_key():
+    raises(ValueError, lambda: bg_private_key(8, 16))
+    raises(ValueError, lambda: bg_private_key(8, 8))
+    raises(ValueError, lambda: bg_private_key(13, 17))
+    assert 23, 31 == bg_private_key(23, 31)
+
+def test_bg_public_key():
+    assert 5293 == bg_public_key(67, 79)
+    assert 713 == bg_public_key(23, 31)
+    raises(ValueError, lambda: bg_private_key(13, 17))

llmeval-env/lib/python3.10/site-packages/sympy/polys/__init__.py

@@ -0,0 +1,129 @@
+"""Polynomial manipulation algorithms and algebraic objects. """
+
+__all__ = [
+    'Poly', 'PurePoly', 'poly_from_expr', 'parallel_poly_from_expr', 'degree',
+    'total_degree', 'degree_list', 'LC', 'LM', 'LT', 'pdiv', 'prem', 'pquo',
+    'pexquo', 'div', 'rem', 'quo', 'exquo', 'half_gcdex', 'gcdex', 'invert',
+    'subresultants', 'resultant', 'discriminant', 'cofactors', 'gcd_list',
+    'gcd', 'lcm_list', 'lcm', 'terms_gcd', 'trunc', 'monic', 'content',
+    'primitive', 'compose', 'decompose', 'sturm', 'gff_list', 'gff',
+    'sqf_norm', 'sqf_part', 'sqf_list', 'sqf', 'factor_list', 'factor',
+    'intervals', 'refine_root', 'count_roots', 'real_roots', 'nroots',
+    'ground_roots', 'nth_power_roots_poly', 'cancel', 'reduced', 'groebner',
+    'is_zero_dimensional', 'GroebnerBasis', 'poly',
+
+    'symmetrize', 'horner', 'interpolate', 'rational_interpolate', 'viete',
+
+    'together',
+
+    'BasePolynomialError', 'ExactQuotientFailed', 'PolynomialDivisionFailed',
+    'OperationNotSupported', 'HeuristicGCDFailed', 'HomomorphismFailed',
+    'IsomorphismFailed', 'ExtraneousFactors', 'EvaluationFailed',
+    'RefinementFailed', 'CoercionFailed', 'NotInvertible', 'NotReversible',
+    'NotAlgebraic', 'DomainError', 'PolynomialError', 'UnificationFailed',
+    'GeneratorsError', 'GeneratorsNeeded', 'ComputationFailed',
+    'UnivariatePolynomialError', 'MultivariatePolynomialError',
+    'PolificationFailed', 'OptionError', 'FlagError',
+
+    'minpoly', 'minimal_polynomial', 'primitive_element', 'field_isomorphism',
+    'to_number_field', 'isolate', 'round_two', 'prime_decomp',
+    'prime_valuation', 'galois_group',
+
+    'itermonomials', 'Monomial',
+
+    'lex', 'grlex', 'grevlex', 'ilex', 'igrlex', 'igrevlex',
+
+    'CRootOf', 'rootof', 'RootOf', 'ComplexRootOf', 'RootSum',
+
+    'roots',
+
+    'Domain', 'FiniteField', 'IntegerRing', 'RationalField', 'RealField',
+    'ComplexField', 'PythonFiniteField', 'GMPYFiniteField',
+    'PythonIntegerRing', 'GMPYIntegerRing', 'PythonRational',
+    'GMPYRationalField', 'AlgebraicField', 'PolynomialRing', 'FractionField',
+    'ExpressionDomain', 'FF_python', 'FF_gmpy', 'ZZ_python', 'ZZ_gmpy',
+    'QQ_python', 'QQ_gmpy', 'GF', 'FF', 'ZZ', 'QQ', 'ZZ_I', 'QQ_I', 'RR',
+    'CC', 'EX', 'EXRAW',
+
+    'construct_domain',
+
+    'swinnerton_dyer_poly', 'cyclotomic_poly', 'symmetric_poly',
+    'random_poly', 'interpolating_poly',
+
+    'jacobi_poly', 'chebyshevt_poly', 'chebyshevu_poly', 'hermite_poly',
+    'hermite_prob_poly', 'legendre_poly', 'laguerre_poly',
+
+    'bernoulli_poly', 'bernoulli_c_poly', 'genocchi_poly', 'euler_poly',
+    'andre_poly',
+
+    'apart', 'apart_list', 'assemble_partfrac_list',
+
+    'Options',
+
+    'ring', 'xring', 'vring', 'sring',
+
+    'field', 'xfield', 'vfield', 'sfield'
+]
+
+from .polytools import (Poly, PurePoly, poly_from_expr,
+        parallel_poly_from_expr, degree, total_degree, degree_list, LC, LM,
+        LT, pdiv, prem, pquo, pexquo, div, rem, quo, exquo, half_gcdex, gcdex,
+        invert, subresultants, resultant, discriminant, cofactors, gcd_list,
+        gcd, lcm_list, lcm, terms_gcd, trunc, monic, content, primitive,
+        compose, decompose, sturm, gff_list, gff, sqf_norm, sqf_part,
+        sqf_list, sqf, factor_list, factor, intervals, refine_root,
+        count_roots, real_roots, nroots, ground_roots, nth_power_roots_poly,
+        cancel, reduced, groebner, is_zero_dimensional, GroebnerBasis, poly)
+
+from .polyfuncs import (symmetrize, horner, interpolate,
+        rational_interpolate, viete)
+
+from .rationaltools import together
+
+from .polyerrors import (BasePolynomialError, ExactQuotientFailed,
+        PolynomialDivisionFailed, OperationNotSupported, HeuristicGCDFailed,
+        HomomorphismFailed, IsomorphismFailed, ExtraneousFactors,
+        EvaluationFailed, RefinementFailed, CoercionFailed, NotInvertible,
+        NotReversible, NotAlgebraic, DomainError, PolynomialError,
+        UnificationFailed, GeneratorsError, GeneratorsNeeded,
+        ComputationFailed, UnivariatePolynomialError,
+        MultivariatePolynomialError, PolificationFailed, OptionError,
+        FlagError)
+
+from .numberfields import (minpoly, minimal_polynomial, primitive_element,
+        field_isomorphism, to_number_field, isolate, round_two, prime_decomp,
+        prime_valuation, galois_group)
+
+from .monomials import itermonomials, Monomial
+
+from .orderings import lex, grlex, grevlex, ilex, igrlex, igrevlex
+
+from .rootoftools import CRootOf, rootof, RootOf, ComplexRootOf, RootSum
+
+from .polyroots import roots
+
+from .domains import (Domain, FiniteField, IntegerRing, RationalField,
+        RealField, ComplexField, PythonFiniteField, GMPYFiniteField,
+        PythonIntegerRing, GMPYIntegerRing, PythonRational, GMPYRationalField,
+        AlgebraicField, PolynomialRing, FractionField, ExpressionDomain,
+        FF_python, FF_gmpy, ZZ_python, ZZ_gmpy, QQ_python, QQ_gmpy, GF, FF,
+        ZZ, QQ, ZZ_I, QQ_I, RR, CC, EX, EXRAW)
+
+from .constructor import construct_domain
+
+from .specialpolys import (swinnerton_dyer_poly, cyclotomic_poly,
+        symmetric_poly, random_poly, interpolating_poly)
+
+from .orthopolys import (jacobi_poly, chebyshevt_poly, chebyshevu_poly,
+        hermite_poly, hermite_prob_poly, legendre_poly, laguerre_poly)
+
+from .appellseqs import (bernoulli_poly, bernoulli_c_poly, genocchi_poly,
+        euler_poly, andre_poly)
+
+from .partfrac import apart, apart_list, assemble_partfrac_list
+
+from .polyoptions import Options
+
+from .rings import ring, xring, vring, sring
+
+from .fields import field, xfield, vfield, sfield

llmeval-env/lib/python3.10/site-packages/sympy/polys/appellseqs.py

@@ -0,0 +1,269 @@
+r"""
+Efficient functions for generating Appell sequences.
+
+An Appell sequence is a zero-indexed sequence of polynomials `p_i(x)`
+satisfying `p_{i+1}'(x)=(i+1)p_i(x)` for all `i`. This definition leads
+to the following iterative algorithm:
+
+.. math :: p_0(x) = c_0,\ p_i(x) = i \int_0^x p_{i-1}(t)\,dt + c_i
+
+The constant coefficients `c_i` are usually determined from the
+just-evaluated integral and `i`.
+
+Appell sequences satisfy the following identity from umbral calculus:
+
+.. math :: p_n(x+y) = \sum_{k=0}^n \binom{n}{k} p_k(x) y^{n-k}
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Appell_sequence
+.. [2] Peter Luschny, "An introduction to the Bernoulli function",
+       https://arxiv.org/abs/2009.06743
+"""
+from sympy.polys.densearith import dup_mul_ground, dup_sub_ground, dup_quo_ground
+from sympy.polys.densetools import dup_eval, dup_integrate
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.polytools import named_poly
+from sympy.utilities import public
+
+def dup_bernoulli(n, K):
+    """Low-level implementation of Bernoulli polynomials."""
+    if n < 1:
+        return [K.one]
+    p = [K.one, K(-1,2)]
+    for i in range(2, n+1):
+        p = dup_integrate(dup_mul_ground(p, K(i), K), 1, K)
+        if i % 2 == 0:
+            p = dup_sub_ground(p, dup_eval(p, K(1,2), K) * K(1<<(i-1), (1<<i)-1), K)
+    return p
+
+@public
+def bernoulli_poly(n, x=None, polys=False):
+    r"""Generates the Bernoulli polynomial `\operatorname{B}_n(x)`.
+
+    `\operatorname{B}_n(x)` is the unique polynomial satisfying
+
+    .. math :: \int_{x}^{x+1} \operatorname{B}_n(t) \,dt = x^n.
+
+    Based on this, we have for nonnegative integer `s` and integer
+    `a` and `b`
+
+    .. math :: \sum_{k=a}^{b} k^s = \frac{\operatorname{B}_{s+1}(b+1) -
+            \operatorname{B}_{s+1}(a)}{s+1}
+
+    which is related to Jakob Bernoulli's original motivation for introducing
+    the Bernoulli numbers, the values of these polynomials at `x = 1`.
+
+    Examples
+    ========
+
+    >>> from sympy import summation
+    >>> from sympy.abc import x
+    >>> from sympy.polys import bernoulli_poly
+    >>> bernoulli_poly(5, x)
+    x**5 - 5*x**4/2 + 5*x**3/3 - x/6
+
+    >>> def psum(p, a, b):
+    ...     return (bernoulli_poly(p+1,b+1) - bernoulli_poly(p+1,a)) / (p+1)
+    >>> psum(4, -6, 27)
+    3144337
+    >>> summation(x**4, (x, -6, 27))
+    3144337
+
+    >>> psum(1, 1, x).factor()
+    x*(x + 1)/2
+    >>> psum(2, 1, x).factor()
+    x*(x + 1)*(2*x + 1)/6
+    >>> psum(3, 1, x).factor()
+    x**2*(x + 1)**2/4
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of the polynomial.
+    x : optional
+    polys : bool, optional
+        If True, return a Poly, otherwise (default) return an expression.
+
+    See Also
+    ========
+
+    sympy.functions.combinatorial.numbers.bernoulli
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bernoulli_polynomials
+    """
+    return named_poly(n, dup_bernoulli, QQ, "Bernoulli polynomial", (x,), polys)
+
+def dup_bernoulli_c(n, K):
+    """Low-level implementation of central Bernoulli polynomials."""
+    p = [K.one]
+    for i in range(1, n+1):
+        p = dup_integrate(dup_mul_ground(p, K(i), K), 1, K)
+        if i % 2 == 0:
+            p = dup_sub_ground(p, dup_eval(p, K.one, K) * K((1<<(i-1))-1, (1<<i)-1), K)
+    return p
+
+@public
+def bernoulli_c_poly(n, x=None, polys=False):
+    r"""Generates the central Bernoulli polynomial `\operatorname{B}_n^c(x)`.
+
+    These are scaled and shifted versions of the plain Bernoulli polynomials,
+    done in such a way that `\operatorname{B}_n^c(x)` is an even or odd function
+    for even or odd `n` respectively:
+
+    .. math :: \operatorname{B}_n^c(x) = 2^n \operatorname{B}_n
+            \left(\frac{x+1}{2}\right)
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of the polynomial.
+    x : optional
+    polys : bool, optional
+        If True, return a Poly, otherwise (default) return an expression.
+    """
+    return named_poly(n, dup_bernoulli_c, QQ, "central Bernoulli polynomial", (x,), polys)
+
+def dup_genocchi(n, K):
+    """Low-level implementation of Genocchi polynomials."""
+    if n < 1:
+        return [K.zero]
+    p = [-K.one]
+    for i in range(2, n+1):
+        p = dup_integrate(dup_mul_ground(p, K(i), K), 1, K)
+        if i % 2 == 0:
+            p = dup_sub_ground(p, dup_eval(p, K.one, K) // K(2), K)
+    return p
+
+@public
+def genocchi_poly(n, x=None, polys=False):
+    r"""Generates the Genocchi polynomial `\operatorname{G}_n(x)`.
+
+    `\operatorname{G}_n(x)` is twice the difference between the plain and
+    central Bernoulli polynomials, so has degree `n-1`:
+
+    .. math :: \operatorname{G}_n(x) = 2 (\operatorname{B}_n(x) -
+            \operatorname{B}_n^c(x))
+
+    The factor of 2 in the definition endows `\operatorname{G}_n(x)` with
+    integer coefficients.
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of the polynomial plus one.
+    x : optional
+    polys : bool, optional
+        If True, return a Poly, otherwise (default) return an expression.
+
+    See Also
+    ========
+
+    sympy.functions.combinatorial.numbers.genocchi
+    """
+    return named_poly(n, dup_genocchi, ZZ, "Genocchi polynomial", (x,), polys)
+
+def dup_euler(n, K):
+    """Low-level implementation of Euler polynomials."""
+    return dup_quo_ground(dup_genocchi(n+1, ZZ), K(-n-1), K)
+
+@public
+def euler_poly(n, x=None, polys=False):
+    r"""Generates the Euler polynomial `\operatorname{E}_n(x)`.
+
+    These are scaled and reindexed versions of the Genocchi polynomials:
+
+    .. math :: \operatorname{E}_n(x) = -\frac{\operatorname{G}_{n+1}(x)}{n+1}
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of the polynomial.
+    x : optional
+    polys : bool, optional
+        If True, return a Poly, otherwise (default) return an expression.
+
+    See Also
+    ========
+
+    sympy.functions.combinatorial.numbers.euler
+    """
+    return named_poly(n, dup_euler, QQ, "Euler polynomial", (x,), polys)
+
+def dup_andre(n, K):
+    """Low-level implementation of Andre polynomials."""
+    p = [K.one]
+    for i in range(1, n+1):
+        p = dup_integrate(dup_mul_ground(p, K(i), K), 1, K)
+        if i % 2 == 0:
+            p = dup_sub_ground(p, dup_eval(p, K.one, K), K)
+    return p
+
+@public
+def andre_poly(n, x=None, polys=False):
+    r"""Generates the Andre polynomial `\mathcal{A}_n(x)`.
+
+    This is the Appell sequence where the constant coefficients form the sequence
+    of Euler numbers ``euler(n)``. As such they have integer coefficients
+    and parities matching the parity of `n`.
+
+    Luschny calls these the *Swiss-knife polynomials* because their values
+    at 0 and 1 can be simply transformed into both the Bernoulli and Euler
+    numbers. Here they are called the Andre polynomials because
+    `|\mathcal{A}_n(n\bmod 2)|` for `n \ge 0` generates what Luschny calls
+    the *Andre numbers*, A000111 in the OEIS.
+
+    Examples
+    ========
+
+    >>> from sympy import bernoulli, euler, genocchi
+    >>> from sympy.abc import x
+    >>> from sympy.polys import andre_poly
+    >>> andre_poly(9, x)
+    x**9 - 36*x**7 + 630*x**5 - 5124*x**3 + 12465*x
+
+    >>> [andre_poly(n, 0) for n in range(11)]
+    [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
+    >>> [euler(n) for n in range(11)]
+    [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
+    >>> [andre_poly(n-1, 1) * n / (4**n - 2**n) for n in range(1, 11)]
+    [1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66]
+    >>> [bernoulli(n) for n in range(1, 11)]
+    [1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66]
+    >>> [-andre_poly(n-1, -1) * n / (-2)**(n-1) for n in range(1, 11)]
+    [-1, -1, 0, 1, 0, -3, 0, 17, 0, -155]
+    >>> [genocchi(n) for n in range(1, 11)]
+    [-1, -1, 0, 1, 0, -3, 0, 17, 0, -155]
+
+    >>> [abs(andre_poly(n, n%2)) for n in range(11)]
+    [1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of the polynomial.
+    x : optional
+    polys : bool, optional
+        If True, return a Poly, otherwise (default) return an expression.
+
+    See Also
+    ========
+
+    sympy.functions.combinatorial.numbers.andre
+
+    References
+    ==========
+
+    .. [1] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+    """
+    return named_poly(n, dup_andre, ZZ, "Andre polynomial", (x,), polys)

llmeval-env/lib/python3.10/site-packages/sympy/polys/compatibility.py

@@ -0,0 +1,1134 @@
+"""Compatibility interface between dense and sparse polys. """
+
+
+from sympy.polys.densearith import dup_add_term
+from sympy.polys.densearith import dmp_add_term
+from sympy.polys.densearith import dup_sub_term
+from sympy.polys.densearith import dmp_sub_term
+from sympy.polys.densearith import dup_mul_term
+from sympy.polys.densearith import dmp_mul_term
+from sympy.polys.densearith import dup_add_ground
+from sympy.polys.densearith import dmp_add_ground
+from sympy.polys.densearith import dup_sub_ground
+from sympy.polys.densearith import dmp_sub_ground
+from sympy.polys.densearith import dup_mul_ground
+from sympy.polys.densearith import dmp_mul_ground
+from sympy.polys.densearith import dup_quo_ground
+from sympy.polys.densearith import dmp_quo_ground
+from sympy.polys.densearith import dup_exquo_ground
+from sympy.polys.densearith import dmp_exquo_ground
+from sympy.polys.densearith import dup_lshift
+from sympy.polys.densearith import dup_rshift
+from sympy.polys.densearith import dup_abs
+from sympy.polys.densearith import dmp_abs
+from sympy.polys.densearith import dup_neg
+from sympy.polys.densearith import dmp_neg
+from sympy.polys.densearith import dup_add
+from sympy.polys.densearith import dmp_add
+from sympy.polys.densearith import dup_sub
+from sympy.polys.densearith import dmp_sub
+from sympy.polys.densearith import dup_add_mul
+from sympy.polys.densearith import dmp_add_mul
+from sympy.polys.densearith import dup_sub_mul
+from sympy.polys.densearith import dmp_sub_mul
+from sympy.polys.densearith import dup_mul
+from sympy.polys.densearith import dmp_mul
+from sympy.polys.densearith import dup_sqr
+from sympy.polys.densearith import dmp_sqr
+from sympy.polys.densearith import dup_pow
+from sympy.polys.densearith import dmp_pow
+from sympy.polys.densearith import dup_pdiv
+from sympy.polys.densearith import dup_prem
+from sympy.polys.densearith import dup_pquo
+from sympy.polys.densearith import dup_pexquo
+from sympy.polys.densearith import dmp_pdiv
+from sympy.polys.densearith import dmp_prem
+from sympy.polys.densearith import dmp_pquo
+from sympy.polys.densearith import dmp_pexquo
+from sympy.polys.densearith import dup_rr_div
+from sympy.polys.densearith import dmp_rr_div
+from sympy.polys.densearith import dup_ff_div
+from sympy.polys.densearith import dmp_ff_div
+from sympy.polys.densearith import dup_div
+from sympy.polys.densearith import dup_rem
+from sympy.polys.densearith import dup_quo
+from sympy.polys.densearith import dup_exquo
+from sympy.polys.densearith import dmp_div
+from sympy.polys.densearith import dmp_rem
+from sympy.polys.densearith import dmp_quo
+from sympy.polys.densearith import dmp_exquo
+from sympy.polys.densearith import dup_max_norm
+from sympy.polys.densearith import dmp_max_norm
+from sympy.polys.densearith import dup_l1_norm
+from sympy.polys.densearith import dmp_l1_norm
+from sympy.polys.densearith import dup_l2_norm_squared
+from sympy.polys.densearith import dmp_l2_norm_squared
+from sympy.polys.densearith import dup_expand
+from sympy.polys.densearith import dmp_expand
+from sympy.polys.densebasic import dup_LC
+from sympy.polys.densebasic import dmp_LC
+from sympy.polys.densebasic import dup_TC
+from sympy.polys.densebasic import dmp_TC
+from sympy.polys.densebasic import dmp_ground_LC
+from sympy.polys.densebasic import dmp_ground_TC
+from sympy.polys.densebasic import dup_degree
+from sympy.polys.densebasic import dmp_degree
+from sympy.polys.densebasic import dmp_degree_in
+from sympy.polys.densebasic import dmp_to_dict
+from sympy.polys.densetools import dup_integrate
+from sympy.polys.densetools import dmp_integrate
+from sympy.polys.densetools import dmp_integrate_in
+from sympy.polys.densetools import dup_diff
+from sympy.polys.densetools import dmp_diff
+from sympy.polys.densetools import dmp_diff_in
+from sympy.polys.densetools import dup_eval
+from sympy.polys.densetools import dmp_eval
+from sympy.polys.densetools import dmp_eval_in
+from sympy.polys.densetools import dmp_eval_tail
+from sympy.polys.densetools import dmp_diff_eval_in
+from sympy.polys.densetools import dup_trunc
+from sympy.polys.densetools import dmp_trunc
+from sympy.polys.densetools import dmp_ground_trunc
+from sympy.polys.densetools import dup_monic
+from sympy.polys.densetools import dmp_ground_monic
+from sympy.polys.densetools import dup_content
+from sympy.polys.densetools import dmp_ground_content
+from sympy.polys.densetools import dup_primitive
+from sympy.polys.densetools import dmp_ground_primitive
+from sympy.polys.densetools import dup_extract
+from sympy.polys.densetools import dmp_ground_extract
+from sympy.polys.densetools import dup_real_imag
+from sympy.polys.densetools import dup_mirror
+from sympy.polys.densetools import dup_scale
+from sympy.polys.densetools import dup_shift
+from sympy.polys.densetools import dup_transform
+from sympy.polys.densetools import dup_compose
+from sympy.polys.densetools import dmp_compose
+from sympy.polys.densetools import dup_decompose
+from sympy.polys.densetools import dmp_lift
+from sympy.polys.densetools import dup_sign_variations
+from sympy.polys.densetools import dup_clear_denoms
+from sympy.polys.densetools import dmp_clear_denoms
+from sympy.polys.densetools import dup_revert
+from sympy.polys.euclidtools import dup_half_gcdex
+from sympy.polys.euclidtools import dmp_half_gcdex
+from sympy.polys.euclidtools import dup_gcdex
+from sympy.polys.euclidtools import dmp_gcdex
+from sympy.polys.euclidtools import dup_invert
+from sympy.polys.euclidtools import dmp_invert
+from sympy.polys.euclidtools import dup_euclidean_prs
+from sympy.polys.euclidtools import dmp_euclidean_prs
+from sympy.polys.euclidtools import dup_primitive_prs
+from sympy.polys.euclidtools import dmp_primitive_prs
+from sympy.polys.euclidtools import dup_inner_subresultants
+from sympy.polys.euclidtools import dup_subresultants
+from sympy.polys.euclidtools import dup_prs_resultant
+from sympy.polys.euclidtools import dup_resultant
+from sympy.polys.euclidtools import dmp_inner_subresultants
+from sympy.polys.euclidtools import dmp_subresultants
+from sympy.polys.euclidtools import dmp_prs_resultant
+from sympy.polys.euclidtools import dmp_zz_modular_resultant
+from sympy.polys.euclidtools import dmp_zz_collins_resultant
+from sympy.polys.euclidtools import dmp_qq_collins_resultant
+from sympy.polys.euclidtools import dmp_resultant
+from sympy.polys.euclidtools import dup_discriminant
+from sympy.polys.euclidtools import dmp_discriminant
+from sympy.polys.euclidtools import dup_rr_prs_gcd
+from sympy.polys.euclidtools import dup_ff_prs_gcd
+from sympy.polys.euclidtools import dmp_rr_prs_gcd
+from sympy.polys.euclidtools import dmp_ff_prs_gcd
+from sympy.polys.euclidtools import dup_zz_heu_gcd
+from sympy.polys.euclidtools import dmp_zz_heu_gcd
+from sympy.polys.euclidtools import dup_qq_heu_gcd
+from sympy.polys.euclidtools import dmp_qq_heu_gcd
+from sympy.polys.euclidtools import dup_inner_gcd
+from sympy.polys.euclidtools import dmp_inner_gcd
+from sympy.polys.euclidtools import dup_gcd
+from sympy.polys.euclidtools import dmp_gcd
+from sympy.polys.euclidtools import dup_rr_lcm
+from sympy.polys.euclidtools import dup_ff_lcm
+from sympy.polys.euclidtools import dup_lcm
+from sympy.polys.euclidtools import dmp_rr_lcm
+from sympy.polys.euclidtools import dmp_ff_lcm
+from sympy.polys.euclidtools import dmp_lcm
+from sympy.polys.euclidtools import dmp_content
+from sympy.polys.euclidtools import dmp_primitive
+from sympy.polys.euclidtools import dup_cancel
+from sympy.polys.euclidtools import dmp_cancel
+from sympy.polys.factortools import dup_trial_division
+from sympy.polys.factortools import dmp_trial_division
+from sympy.polys.factortools import dup_zz_mignotte_bound
+from sympy.polys.factortools import dmp_zz_mignotte_bound
+from sympy.polys.factortools import dup_zz_hensel_step
+from sympy.polys.factortools import dup_zz_hensel_lift
+from sympy.polys.factortools import dup_zz_zassenhaus
+from sympy.polys.factortools import dup_zz_irreducible_p
+from sympy.polys.factortools import dup_cyclotomic_p
+from sympy.polys.factortools import dup_zz_cyclotomic_poly
+from sympy.polys.factortools import dup_zz_cyclotomic_factor
+from sympy.polys.factortools import dup_zz_factor_sqf
+from sympy.polys.factortools import dup_zz_factor
+from sympy.polys.factortools import dmp_zz_wang_non_divisors
+from sympy.polys.factortools import dmp_zz_wang_lead_coeffs
+from sympy.polys.factortools import dup_zz_diophantine
+from sympy.polys.factortools import dmp_zz_diophantine
+from sympy.polys.factortools import dmp_zz_wang_hensel_lifting
+from sympy.polys.factortools import dmp_zz_wang
+from sympy.polys.factortools import dmp_zz_factor
+from sympy.polys.factortools import dup_qq_i_factor
+from sympy.polys.factortools import dup_zz_i_factor
+from sympy.polys.factortools import dmp_qq_i_factor
+from sympy.polys.factortools import dmp_zz_i_factor
+from sympy.polys.factortools import dup_ext_factor
+from sympy.polys.factortools import dmp_ext_factor
+from sympy.polys.factortools import dup_gf_factor
+from sympy.polys.factortools import dmp_gf_factor
+from sympy.polys.factortools import dup_factor_list
+from sympy.polys.factortools import dup_factor_list_include
+from sympy.polys.factortools import dmp_factor_list
+from sympy.polys.factortools import dmp_factor_list_include
+from sympy.polys.factortools import dup_irreducible_p
+from sympy.polys.factortools import dmp_irreducible_p
+from sympy.polys.rootisolation import dup_sturm
+from sympy.polys.rootisolation import dup_root_upper_bound
+from sympy.polys.rootisolation import dup_root_lower_bound
+from sympy.polys.rootisolation import dup_step_refine_real_root
+from sympy.polys.rootisolation import dup_inner_refine_real_root
+from sympy.polys.rootisolation import dup_outer_refine_real_root
+from sympy.polys.rootisolation import dup_refine_real_root
+from sympy.polys.rootisolation import dup_inner_isolate_real_roots
+from sympy.polys.rootisolation import dup_inner_isolate_positive_roots
+from sympy.polys.rootisolation import dup_inner_isolate_negative_roots
+from sympy.polys.rootisolation import dup_isolate_real_roots_sqf
+from sympy.polys.rootisolation import dup_isolate_real_roots
+from sympy.polys.rootisolation import dup_isolate_real_roots_list
+from sympy.polys.rootisolation import dup_count_real_roots
+from sympy.polys.rootisolation import dup_count_complex_roots
+from sympy.polys.rootisolation import dup_isolate_complex_roots_sqf
+from sympy.polys.rootisolation import dup_isolate_all_roots_sqf
+from sympy.polys.rootisolation import dup_isolate_all_roots
+
+from sympy.polys.sqfreetools import (
+    dup_sqf_p, dmp_sqf_p, dup_sqf_norm, dmp_sqf_norm, dup_gf_sqf_part, dmp_gf_sqf_part,
+    dup_sqf_part, dmp_sqf_part, dup_gf_sqf_list, dmp_gf_sqf_list, dup_sqf_list,
+    dup_sqf_list_include, dmp_sqf_list, dmp_sqf_list_include, dup_gff_list, dmp_gff_list)
+
+from sympy.polys.galoistools import (
+    gf_degree, gf_LC, gf_TC, gf_strip, gf_from_dict,
+    gf_to_dict, gf_from_int_poly, gf_to_int_poly, gf_neg, gf_add_ground, gf_sub_ground,
+    gf_mul_ground, gf_quo_ground, gf_add, gf_sub, gf_mul, gf_sqr, gf_add_mul, gf_sub_mul,
+    gf_expand, gf_div, gf_rem, gf_quo, gf_exquo, gf_lshift, gf_rshift, gf_pow, gf_pow_mod,
+    gf_gcd, gf_lcm, gf_cofactors, gf_gcdex, gf_monic, gf_diff, gf_eval, gf_multi_eval,
+    gf_compose, gf_compose_mod, gf_trace_map, gf_random, gf_irreducible, gf_irred_p_ben_or,
+    gf_irred_p_rabin, gf_irreducible_p, gf_sqf_p, gf_sqf_part, gf_Qmatrix,
+    gf_berlekamp, gf_ddf_zassenhaus, gf_edf_zassenhaus, gf_ddf_shoup, gf_edf_shoup,
+    gf_zassenhaus, gf_shoup, gf_factor_sqf, gf_factor)
+
+from sympy.utilities import public
+
+@public
+class IPolys:
+    symbols = None
+    ngens = None
+    domain = None
+    order = None
+    gens = None
+
+    def drop(self, gen):
+        pass
+
+    def clone(self, symbols=None, domain=None, order=None):
+        pass
+
+    def to_ground(self):
+        pass
+
+    def ground_new(self, element):
+        pass
+
+    def domain_new(self, element):
+        pass
+
+    def from_dict(self, d):
+        pass
+
+    def wrap(self, element):
+        from sympy.polys.rings import PolyElement
+        if isinstance(element, PolyElement):
+            if element.ring == self:
+                return element
+            else:
+                raise NotImplementedError("domain conversions")
+        else:
+            return self.ground_new(element)
+
+    def to_dense(self, element):
+        return self.wrap(element).to_dense()
+
+    def from_dense(self, element):
+        return self.from_dict(dmp_to_dict(element, self.ngens-1, self.domain))
+
+    def dup_add_term(self, f, c, i):
+        return self.from_dense(dup_add_term(self.to_dense(f), c, i, self.domain))
+    def dmp_add_term(self, f, c, i):
+        return self.from_dense(dmp_add_term(self.to_dense(f), self.wrap(c).drop(0).to_dense(), i, self.ngens-1, self.domain))
+    def dup_sub_term(self, f, c, i):
+        return self.from_dense(dup_sub_term(self.to_dense(f), c, i, self.domain))
+    def dmp_sub_term(self, f, c, i):
+        return self.from_dense(dmp_sub_term(self.to_dense(f), self.wrap(c).drop(0).to_dense(), i, self.ngens-1, self.domain))
+    def dup_mul_term(self, f, c, i):
+        return self.from_dense(dup_mul_term(self.to_dense(f), c, i, self.domain))
+    def dmp_mul_term(self, f, c, i):
+        return self.from_dense(dmp_mul_term(self.to_dense(f), self.wrap(c).drop(0).to_dense(), i, self.ngens-1, self.domain))
+
+    def dup_add_ground(self, f, c):
+        return self.from_dense(dup_add_ground(self.to_dense(f), c, self.domain))
+    def dmp_add_ground(self, f, c):
+        return self.from_dense(dmp_add_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+    def dup_sub_ground(self, f, c):
+        return self.from_dense(dup_sub_ground(self.to_dense(f), c, self.domain))
+    def dmp_sub_ground(self, f, c):
+        return self.from_dense(dmp_sub_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+    def dup_mul_ground(self, f, c):
+        return self.from_dense(dup_mul_ground(self.to_dense(f), c, self.domain))
+    def dmp_mul_ground(self, f, c):
+        return self.from_dense(dmp_mul_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+    def dup_quo_ground(self, f, c):
+        return self.from_dense(dup_quo_ground(self.to_dense(f), c, self.domain))
+    def dmp_quo_ground(self, f, c):
+        return self.from_dense(dmp_quo_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+    def dup_exquo_ground(self, f, c):
+        return self.from_dense(dup_exquo_ground(self.to_dense(f), c, self.domain))
+    def dmp_exquo_ground(self, f, c):
+        return self.from_dense(dmp_exquo_ground(self.to_dense(f), c, self.ngens-1, self.domain))
+
+    def dup_lshift(self, f, n):
+        return self.from_dense(dup_lshift(self.to_dense(f), n, self.domain))
+    def dup_rshift(self, f, n):
+        return self.from_dense(dup_rshift(self.to_dense(f), n, self.domain))
+
+    def dup_abs(self, f):
+        return self.from_dense(dup_abs(self.to_dense(f), self.domain))
+    def dmp_abs(self, f):
+        return self.from_dense(dmp_abs(self.to_dense(f), self.ngens-1, self.domain))
+
+    def dup_neg(self, f):
+        return self.from_dense(dup_neg(self.to_dense(f), self.domain))
+    def dmp_neg(self, f):
+        return self.from_dense(dmp_neg(self.to_dense(f), self.ngens-1, self.domain))
+
+    def dup_add(self, f, g):
+        return self.from_dense(dup_add(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_add(self, f, g):
+        return self.from_dense(dmp_add(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_sub(self, f, g):
+        return self.from_dense(dup_sub(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_sub(self, f, g):
+        return self.from_dense(dmp_sub(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_add_mul(self, f, g, h):
+        return self.from_dense(dup_add_mul(self.to_dense(f), self.to_dense(g), self.to_dense(h), self.domain))
+    def dmp_add_mul(self, f, g, h):
+        return self.from_dense(dmp_add_mul(self.to_dense(f), self.to_dense(g), self.to_dense(h), self.ngens-1, self.domain))
+    def dup_sub_mul(self, f, g, h):
+        return self.from_dense(dup_sub_mul(self.to_dense(f), self.to_dense(g), self.to_dense(h), self.domain))
+    def dmp_sub_mul(self, f, g, h):
+        return self.from_dense(dmp_sub_mul(self.to_dense(f), self.to_dense(g), self.to_dense(h), self.ngens-1, self.domain))
+
+    def dup_mul(self, f, g):
+        return self.from_dense(dup_mul(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_mul(self, f, g):
+        return self.from_dense(dmp_mul(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_sqr(self, f):
+        return self.from_dense(dup_sqr(self.to_dense(f), self.domain))
+    def dmp_sqr(self, f):
+        return self.from_dense(dmp_sqr(self.to_dense(f), self.ngens-1, self.domain))
+    def dup_pow(self, f, n):
+        return self.from_dense(dup_pow(self.to_dense(f), n, self.domain))
+    def dmp_pow(self, f, n):
+        return self.from_dense(dmp_pow(self.to_dense(f), n, self.ngens-1, self.domain))
+
+    def dup_pdiv(self, f, g):
+        q, r = dup_pdiv(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dup_prem(self, f, g):
+        return self.from_dense(dup_prem(self.to_dense(f), self.to_dense(g), self.domain))
+    def dup_pquo(self, f, g):
+        return self.from_dense(dup_pquo(self.to_dense(f), self.to_dense(g), self.domain))
+    def dup_pexquo(self, f, g):
+        return self.from_dense(dup_pexquo(self.to_dense(f), self.to_dense(g), self.domain))
+
+    def dmp_pdiv(self, f, g):
+        q, r = dmp_pdiv(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dmp_prem(self, f, g):
+        return self.from_dense(dmp_prem(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+    def dmp_pquo(self, f, g):
+        return self.from_dense(dmp_pquo(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+    def dmp_pexquo(self, f, g):
+        return self.from_dense(dmp_pexquo(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_rr_div(self, f, g):
+        q, r = dup_rr_div(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dmp_rr_div(self, f, g):
+        q, r = dmp_rr_div(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dup_ff_div(self, f, g):
+        q, r = dup_ff_div(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dmp_ff_div(self, f, g):
+        q, r = dmp_ff_div(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+
+    def dup_div(self, f, g):
+        q, r = dup_div(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dup_rem(self, f, g):
+        return self.from_dense(dup_rem(self.to_dense(f), self.to_dense(g), self.domain))
+    def dup_quo(self, f, g):
+        return self.from_dense(dup_quo(self.to_dense(f), self.to_dense(g), self.domain))
+    def dup_exquo(self, f, g):
+        return self.from_dense(dup_exquo(self.to_dense(f), self.to_dense(g), self.domain))
+
+    def dmp_div(self, f, g):
+        q, r = dmp_div(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(q), self.from_dense(r))
+    def dmp_rem(self, f, g):
+        return self.from_dense(dmp_rem(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+    def dmp_quo(self, f, g):
+        return self.from_dense(dmp_quo(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+    def dmp_exquo(self, f, g):
+        return self.from_dense(dmp_exquo(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_max_norm(self, f):
+        return dup_max_norm(self.to_dense(f), self.domain)
+    def dmp_max_norm(self, f):
+        return dmp_max_norm(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_l1_norm(self, f):
+        return dup_l1_norm(self.to_dense(f), self.domain)
+    def dmp_l1_norm(self, f):
+        return dmp_l1_norm(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_l2_norm_squared(self, f):
+        return dup_l2_norm_squared(self.to_dense(f), self.domain)
+    def dmp_l2_norm_squared(self, f):
+        return dmp_l2_norm_squared(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_expand(self, polys):
+        return self.from_dense(dup_expand(list(map(self.to_dense, polys)), self.domain))
+    def dmp_expand(self, polys):
+        return self.from_dense(dmp_expand(list(map(self.to_dense, polys)), self.ngens-1, self.domain))
+
+    def dup_LC(self, f):
+        return dup_LC(self.to_dense(f), self.domain)
+    def dmp_LC(self, f):
+        LC = dmp_LC(self.to_dense(f), self.domain)
+        if isinstance(LC, list):
+            return self[1:].from_dense(LC)
+        else:
+            return LC
+    def dup_TC(self, f):
+        return dup_TC(self.to_dense(f), self.domain)
+    def dmp_TC(self, f):
+        TC = dmp_TC(self.to_dense(f), self.domain)
+        if isinstance(TC, list):
+            return self[1:].from_dense(TC)
+        else:
+            return TC
+
+    def dmp_ground_LC(self, f):
+        return dmp_ground_LC(self.to_dense(f), self.ngens-1, self.domain)
+    def dmp_ground_TC(self, f):
+        return dmp_ground_TC(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_degree(self, f):
+        return dup_degree(self.to_dense(f))
+    def dmp_degree(self, f):
+        return dmp_degree(self.to_dense(f), self.ngens-1)
+    def dmp_degree_in(self, f, j):
+        return dmp_degree_in(self.to_dense(f), j, self.ngens-1)
+    def dup_integrate(self, f, m):
+        return self.from_dense(dup_integrate(self.to_dense(f), m, self.domain))
+    def dmp_integrate(self, f, m):
+        return self.from_dense(dmp_integrate(self.to_dense(f), m, self.ngens-1, self.domain))
+
+    def dup_diff(self, f, m):
+        return self.from_dense(dup_diff(self.to_dense(f), m, self.domain))
+    def dmp_diff(self, f, m):
+        return self.from_dense(dmp_diff(self.to_dense(f), m, self.ngens-1, self.domain))
+
+    def dmp_diff_in(self, f, m, j):
+        return self.from_dense(dmp_diff_in(self.to_dense(f), m, j, self.ngens-1, self.domain))
+    def dmp_integrate_in(self, f, m, j):
+        return self.from_dense(dmp_integrate_in(self.to_dense(f), m, j, self.ngens-1, self.domain))
+
+    def dup_eval(self, f, a):
+        return dup_eval(self.to_dense(f), a, self.domain)
+    def dmp_eval(self, f, a):
+        result = dmp_eval(self.to_dense(f), a, self.ngens-1, self.domain)
+        return self[1:].from_dense(result)
+
+    def dmp_eval_in(self, f, a, j):
+        result = dmp_eval_in(self.to_dense(f), a, j, self.ngens-1, self.domain)
+        return self.drop(j).from_dense(result)
+    def dmp_diff_eval_in(self, f, m, a, j):
+        result = dmp_diff_eval_in(self.to_dense(f), m, a, j, self.ngens-1, self.domain)
+        return self.drop(j).from_dense(result)
+
+    def dmp_eval_tail(self, f, A):
+        result = dmp_eval_tail(self.to_dense(f), A, self.ngens-1, self.domain)
+        if isinstance(result, list):
+            return self[:-len(A)].from_dense(result)
+        else:
+            return result
+
+    def dup_trunc(self, f, p):
+        return self.from_dense(dup_trunc(self.to_dense(f), p, self.domain))
+    def dmp_trunc(self, f, g):
+        return self.from_dense(dmp_trunc(self.to_dense(f), self[1:].to_dense(g), self.ngens-1, self.domain))
+    def dmp_ground_trunc(self, f, p):
+        return self.from_dense(dmp_ground_trunc(self.to_dense(f), p, self.ngens-1, self.domain))
+
+    def dup_monic(self, f):
+        return self.from_dense(dup_monic(self.to_dense(f), self.domain))
+    def dmp_ground_monic(self, f):
+        return self.from_dense(dmp_ground_monic(self.to_dense(f), self.ngens-1, self.domain))
+
+    def dup_extract(self, f, g):
+        c, F, G = dup_extract(self.to_dense(f), self.to_dense(g), self.domain)
+        return (c, self.from_dense(F), self.from_dense(G))
+    def dmp_ground_extract(self, f, g):
+        c, F, G = dmp_ground_extract(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (c, self.from_dense(F), self.from_dense(G))
+
+    def dup_real_imag(self, f):
+        p, q = dup_real_imag(self.wrap(f).drop(1).to_dense(), self.domain)
+        return (self.from_dense(p), self.from_dense(q))
+
+    def dup_mirror(self, f):
+        return self.from_dense(dup_mirror(self.to_dense(f), self.domain))
+    def dup_scale(self, f, a):
+        return self.from_dense(dup_scale(self.to_dense(f), a, self.domain))
+    def dup_shift(self, f, a):
+        return self.from_dense(dup_shift(self.to_dense(f), a, self.domain))
+    def dup_transform(self, f, p, q):
+        return self.from_dense(dup_transform(self.to_dense(f), self.to_dense(p), self.to_dense(q), self.domain))
+
+    def dup_compose(self, f, g):
+        return self.from_dense(dup_compose(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_compose(self, f, g):
+        return self.from_dense(dmp_compose(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_decompose(self, f):
+        components = dup_decompose(self.to_dense(f), self.domain)
+        return list(map(self.from_dense, components))
+
+    def dmp_lift(self, f):
+        result = dmp_lift(self.to_dense(f), self.ngens-1, self.domain)
+        return self.to_ground().from_dense(result)
+
+    def dup_sign_variations(self, f):
+        return dup_sign_variations(self.to_dense(f), self.domain)
+
+    def dup_clear_denoms(self, f, convert=False):
+        c, F = dup_clear_denoms(self.to_dense(f), self.domain, convert=convert)
+        if convert:
+            ring = self.clone(domain=self.domain.get_ring())
+        else:
+            ring = self
+        return (c, ring.from_dense(F))
+    def dmp_clear_denoms(self, f, convert=False):
+        c, F = dmp_clear_denoms(self.to_dense(f), self.ngens-1, self.domain, convert=convert)
+        if convert:
+            ring = self.clone(domain=self.domain.get_ring())
+        else:
+            ring = self
+        return (c, ring.from_dense(F))
+
+    def dup_revert(self, f, n):
+        return self.from_dense(dup_revert(self.to_dense(f), n, self.domain))
+
+    def dup_half_gcdex(self, f, g):
+        s, h = dup_half_gcdex(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(s), self.from_dense(h))
+    def dmp_half_gcdex(self, f, g):
+        s, h = dmp_half_gcdex(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(s), self.from_dense(h))
+    def dup_gcdex(self, f, g):
+        s, t, h = dup_gcdex(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(s), self.from_dense(t), self.from_dense(h))
+    def dmp_gcdex(self, f, g):
+        s, t, h = dmp_gcdex(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(s), self.from_dense(t), self.from_dense(h))
+
+    def dup_invert(self, f, g):
+        return self.from_dense(dup_invert(self.to_dense(f), self.to_dense(g), self.domain))
+    def dmp_invert(self, f, g):
+        return self.from_dense(dmp_invert(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain))
+
+    def dup_euclidean_prs(self, f, g):
+        prs = dup_euclidean_prs(self.to_dense(f), self.to_dense(g), self.domain)
+        return list(map(self.from_dense, prs))
+    def dmp_euclidean_prs(self, f, g):
+        prs = dmp_euclidean_prs(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return list(map(self.from_dense, prs))
+    def dup_primitive_prs(self, f, g):
+        prs = dup_primitive_prs(self.to_dense(f), self.to_dense(g), self.domain)
+        return list(map(self.from_dense, prs))
+    def dmp_primitive_prs(self, f, g):
+        prs = dmp_primitive_prs(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return list(map(self.from_dense, prs))
+
+    def dup_inner_subresultants(self, f, g):
+        prs, sres = dup_inner_subresultants(self.to_dense(f), self.to_dense(g), self.domain)
+        return (list(map(self.from_dense, prs)), sres)
+    def dmp_inner_subresultants(self, f, g):
+        prs, sres  = dmp_inner_subresultants(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (list(map(self.from_dense, prs)), sres)
+
+    def dup_subresultants(self, f, g):
+        prs = dup_subresultants(self.to_dense(f), self.to_dense(g), self.domain)
+        return list(map(self.from_dense, prs))
+    def dmp_subresultants(self, f, g):
+        prs = dmp_subresultants(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return list(map(self.from_dense, prs))
+
+    def dup_prs_resultant(self, f, g):
+        res, prs = dup_prs_resultant(self.to_dense(f), self.to_dense(g), self.domain)
+        return (res, list(map(self.from_dense, prs)))
+    def dmp_prs_resultant(self, f, g):
+        res, prs = dmp_prs_resultant(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self[1:].from_dense(res), list(map(self.from_dense, prs)))
+
+    def dmp_zz_modular_resultant(self, f, g, p):
+        res = dmp_zz_modular_resultant(self.to_dense(f), self.to_dense(g), self.domain_new(p), self.ngens-1, self.domain)
+        return self[1:].from_dense(res)
+    def dmp_zz_collins_resultant(self, f, g):
+        res = dmp_zz_collins_resultant(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self[1:].from_dense(res)
+    def dmp_qq_collins_resultant(self, f, g):
+        res = dmp_qq_collins_resultant(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self[1:].from_dense(res)
+
+    def dup_resultant(self, f, g): #, includePRS=False):
+        return dup_resultant(self.to_dense(f), self.to_dense(g), self.domain) #, includePRS=includePRS)
+    def dmp_resultant(self, f, g): #, includePRS=False):
+        res = dmp_resultant(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain) #, includePRS=includePRS)
+        if isinstance(res, list):
+            return self[1:].from_dense(res)
+        else:
+            return res
+
+    def dup_discriminant(self, f):
+        return dup_discriminant(self.to_dense(f), self.domain)
+    def dmp_discriminant(self, f):
+        disc = dmp_discriminant(self.to_dense(f), self.ngens-1, self.domain)
+        if isinstance(disc, list):
+            return self[1:].from_dense(disc)
+        else:
+            return disc
+
+    def dup_rr_prs_gcd(self, f, g):
+        H, F, G = dup_rr_prs_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_ff_prs_gcd(self, f, g):
+        H, F, G = dup_ff_prs_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_rr_prs_gcd(self, f, g):
+        H, F, G = dmp_rr_prs_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_ff_prs_gcd(self, f, g):
+        H, F, G = dmp_ff_prs_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_zz_heu_gcd(self, f, g):
+        H, F, G = dup_zz_heu_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_zz_heu_gcd(self, f, g):
+        H, F, G = dmp_zz_heu_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_qq_heu_gcd(self, f, g):
+        H, F, G = dup_qq_heu_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_qq_heu_gcd(self, f, g):
+        H, F, G = dmp_qq_heu_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_inner_gcd(self, f, g):
+        H, F, G = dup_inner_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dmp_inner_gcd(self, f, g):
+        H, F, G = dmp_inner_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return (self.from_dense(H), self.from_dense(F), self.from_dense(G))
+    def dup_gcd(self, f, g):
+        H = dup_gcd(self.to_dense(f), self.to_dense(g), self.domain)
+        return self.from_dense(H)
+    def dmp_gcd(self, f, g):
+        H = dmp_gcd(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self.from_dense(H)
+    def dup_rr_lcm(self, f, g):
+        H = dup_rr_lcm(self.to_dense(f), self.to_dense(g), self.domain)
+        return self.from_dense(H)
+    def dup_ff_lcm(self, f, g):
+        H = dup_ff_lcm(self.to_dense(f), self.to_dense(g), self.domain)
+        return self.from_dense(H)
+    def dup_lcm(self, f, g):
+        H = dup_lcm(self.to_dense(f), self.to_dense(g), self.domain)
+        return self.from_dense(H)
+    def dmp_rr_lcm(self, f, g):
+        H = dmp_rr_lcm(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self.from_dense(H)
+    def dmp_ff_lcm(self, f, g):
+        H = dmp_ff_lcm(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self.from_dense(H)
+    def dmp_lcm(self, f, g):
+        H = dmp_lcm(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain)
+        return self.from_dense(H)
+
+    def dup_content(self, f):
+        cont = dup_content(self.to_dense(f), self.domain)
+        return cont
+    def dup_primitive(self, f):
+        cont, prim = dup_primitive(self.to_dense(f), self.domain)
+        return cont, self.from_dense(prim)
+
+    def dmp_content(self, f):
+        cont = dmp_content(self.to_dense(f), self.ngens-1, self.domain)
+        if isinstance(cont, list):
+            return self[1:].from_dense(cont)
+        else:
+            return cont
+    def dmp_primitive(self, f):
+        cont, prim = dmp_primitive(self.to_dense(f), self.ngens-1, self.domain)
+        if isinstance(cont, list):
+            return (self[1:].from_dense(cont), self.from_dense(prim))
+        else:
+            return (cont, self.from_dense(prim))
+
+    def dmp_ground_content(self, f):
+        cont = dmp_ground_content(self.to_dense(f), self.ngens-1, self.domain)
+        return cont
+    def dmp_ground_primitive(self, f):
+        cont, prim = dmp_ground_primitive(self.to_dense(f), self.ngens-1, self.domain)
+        return (cont, self.from_dense(prim))
+
+    def dup_cancel(self, f, g, include=True):
+        result = dup_cancel(self.to_dense(f), self.to_dense(g), self.domain, include=include)
+        if not include:
+            cf, cg, F, G = result
+            return (cf, cg, self.from_dense(F), self.from_dense(G))
+        else:
+            F, G = result
+            return (self.from_dense(F), self.from_dense(G))
+    def dmp_cancel(self, f, g, include=True):
+        result = dmp_cancel(self.to_dense(f), self.to_dense(g), self.ngens-1, self.domain, include=include)
+        if not include:
+            cf, cg, F, G = result
+            return (cf, cg, self.from_dense(F), self.from_dense(G))
+        else:
+            F, G = result
+            return (self.from_dense(F), self.from_dense(G))
+
+    def dup_trial_division(self, f, factors):
+        factors = dup_trial_division(self.to_dense(f), list(map(self.to_dense, factors)), self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+    def dmp_trial_division(self, f, factors):
+        factors = dmp_trial_division(self.to_dense(f), list(map(self.to_dense, factors)), self.ngens-1, self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_zz_mignotte_bound(self, f):
+        return dup_zz_mignotte_bound(self.to_dense(f), self.domain)
+    def dmp_zz_mignotte_bound(self, f):
+        return dmp_zz_mignotte_bound(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_zz_hensel_step(self, m, f, g, h, s, t):
+        D = self.to_dense
+        G, H, S, T = dup_zz_hensel_step(m, D(f), D(g), D(h), D(s), D(t), self.domain)
+        return (self.from_dense(G), self.from_dense(H), self.from_dense(S), self.from_dense(T))
+    def dup_zz_hensel_lift(self, p, f, f_list, l):
+        D = self.to_dense
+        polys = dup_zz_hensel_lift(p, D(f), list(map(D, f_list)), l, self.domain)
+        return list(map(self.from_dense, polys))
+
+    def dup_zz_zassenhaus(self, f):
+        factors = dup_zz_zassenhaus(self.to_dense(f), self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_zz_irreducible_p(self, f):
+        return dup_zz_irreducible_p(self.to_dense(f), self.domain)
+    def dup_cyclotomic_p(self, f, irreducible=False):
+        return dup_cyclotomic_p(self.to_dense(f), self.domain, irreducible=irreducible)
+    def dup_zz_cyclotomic_poly(self, n):
+        F = dup_zz_cyclotomic_poly(n, self.domain)
+        return self.from_dense(F)
+    def dup_zz_cyclotomic_factor(self, f):
+        result = dup_zz_cyclotomic_factor(self.to_dense(f), self.domain)
+        if result is None:
+            return result
+        else:
+            return list(map(self.from_dense, result))
+
+    # E: List[ZZ], cs: ZZ, ct: ZZ
+    def dmp_zz_wang_non_divisors(self, E, cs, ct):
+        return dmp_zz_wang_non_divisors(E, cs, ct, self.domain)
+
+    # f: Poly, T: List[(Poly, int)], ct: ZZ, A: List[ZZ]
+    #def dmp_zz_wang_test_points(f, T, ct, A):
+    #   dmp_zz_wang_test_points(self.to_dense(f), T, ct, A, self.ngens-1, self.domain)
+
+    # f: Poly, T: List[(Poly, int)], cs: ZZ, E: List[ZZ], H: List[Poly], A: List[ZZ]
+    def dmp_zz_wang_lead_coeffs(self, f, T, cs, E, H, A):
+        mv = self[1:]
+        T = [ (mv.to_dense(t), k) for t, k in T ]
+        uv = self[:1]
+        H = list(map(uv.to_dense, H))
+        f, HH, CC = dmp_zz_wang_lead_coeffs(self.to_dense(f), T, cs, E, H, A, self.ngens-1, self.domain)
+        return self.from_dense(f), list(map(uv.from_dense, HH)), list(map(mv.from_dense, CC))
+
+    # f: List[Poly], m: int, p: ZZ
+    def dup_zz_diophantine(self, F, m, p):
+        result = dup_zz_diophantine(list(map(self.to_dense, F)), m, p, self.domain)
+        return list(map(self.from_dense, result))
+
+    # f: List[Poly], c: List[Poly], A: List[ZZ], d: int, p: ZZ
+    def dmp_zz_diophantine(self, F, c, A, d, p):
+        result = dmp_zz_diophantine(list(map(self.to_dense, F)), self.to_dense(c), A, d, p, self.ngens-1, self.domain)
+        return list(map(self.from_dense, result))
+
+    # f: Poly, H: List[Poly], LC: List[Poly], A: List[ZZ], p: ZZ
+    def dmp_zz_wang_hensel_lifting(self, f, H, LC, A, p):
+        uv = self[:1]
+        mv = self[1:]
+        H = list(map(uv.to_dense, H))
+        LC = list(map(mv.to_dense, LC))
+        result = dmp_zz_wang_hensel_lifting(self.to_dense(f), H, LC, A, p, self.ngens-1, self.domain)
+        return list(map(self.from_dense, result))
+
+    def dmp_zz_wang(self, f, mod=None, seed=None):
+        factors = dmp_zz_wang(self.to_dense(f), self.ngens-1, self.domain, mod=mod, seed=seed)
+        return [ self.from_dense(g) for g in factors ]
+
+    def dup_zz_factor_sqf(self, f):
+        coeff, factors = dup_zz_factor_sqf(self.to_dense(f), self.domain)
+        return (coeff, [ self.from_dense(g) for g in factors ])
+
+    def dup_zz_factor(self, f):
+        coeff, factors = dup_zz_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_zz_factor(self, f):
+        coeff, factors = dmp_zz_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_qq_i_factor(self, f):
+        coeff, factors = dup_qq_i_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_qq_i_factor(self, f):
+        coeff, factors = dmp_qq_i_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_zz_i_factor(self, f):
+        coeff, factors = dup_zz_i_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_zz_i_factor(self, f):
+        coeff, factors = dmp_zz_i_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_ext_factor(self, f):
+        coeff, factors = dup_ext_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_ext_factor(self, f):
+        coeff, factors = dmp_ext_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_gf_factor(self, f):
+        coeff, factors = dup_gf_factor(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_gf_factor(self, f):
+        coeff, factors = dmp_gf_factor(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_factor_list(self, f):
+        coeff, factors = dup_factor_list(self.to_dense(f), self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dup_factor_list_include(self, f):
+        factors = dup_factor_list_include(self.to_dense(f), self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dmp_factor_list(self, f):
+        coeff, factors = dmp_factor_list(self.to_dense(f), self.ngens-1, self.domain)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_factor_list_include(self, f):
+        factors = dmp_factor_list_include(self.to_dense(f), self.ngens-1, self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_irreducible_p(self, f):
+        return dup_irreducible_p(self.to_dense(f), self.domain)
+    def dmp_irreducible_p(self, f):
+        return dmp_irreducible_p(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_sturm(self, f):
+        seq = dup_sturm(self.to_dense(f), self.domain)
+        return list(map(self.from_dense, seq))
+
+    def dup_sqf_p(self, f):
+        return dup_sqf_p(self.to_dense(f), self.domain)
+    def dmp_sqf_p(self, f):
+        return dmp_sqf_p(self.to_dense(f), self.ngens-1, self.domain)
+
+    def dup_sqf_norm(self, f):
+        s, F, R = dup_sqf_norm(self.to_dense(f), self.domain)
+        return (s, self.from_dense(F), self.to_ground().from_dense(R))
+    def dmp_sqf_norm(self, f):
+        s, F, R = dmp_sqf_norm(self.to_dense(f), self.ngens-1, self.domain)
+        return (s, self.from_dense(F), self.to_ground().from_dense(R))
+
+    def dup_gf_sqf_part(self, f):
+        return self.from_dense(dup_gf_sqf_part(self.to_dense(f), self.domain))
+    def dmp_gf_sqf_part(self, f):
+        return self.from_dense(dmp_gf_sqf_part(self.to_dense(f), self.domain))
+    def dup_sqf_part(self, f):
+        return self.from_dense(dup_sqf_part(self.to_dense(f), self.domain))
+    def dmp_sqf_part(self, f):
+        return self.from_dense(dmp_sqf_part(self.to_dense(f), self.ngens-1, self.domain))
+
+    def dup_gf_sqf_list(self, f, all=False):
+        coeff, factors = dup_gf_sqf_list(self.to_dense(f), self.domain, all=all)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_gf_sqf_list(self, f, all=False):
+        coeff, factors = dmp_gf_sqf_list(self.to_dense(f), self.ngens-1, self.domain, all=all)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+
+    def dup_sqf_list(self, f, all=False):
+        coeff, factors = dup_sqf_list(self.to_dense(f), self.domain, all=all)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dup_sqf_list_include(self, f, all=False):
+        factors = dup_sqf_list_include(self.to_dense(f), self.domain, all=all)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+    def dmp_sqf_list(self, f, all=False):
+        coeff, factors = dmp_sqf_list(self.to_dense(f), self.ngens-1, self.domain, all=all)
+        return (coeff, [ (self.from_dense(g), k) for g, k in factors ])
+    def dmp_sqf_list_include(self, f, all=False):
+        factors = dmp_sqf_list_include(self.to_dense(f), self.ngens-1, self.domain, all=all)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_gff_list(self, f):
+        factors = dup_gff_list(self.to_dense(f), self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+    def dmp_gff_list(self, f):
+        factors = dmp_gff_list(self.to_dense(f), self.ngens-1, self.domain)
+        return [ (self.from_dense(g), k) for g, k in factors ]
+
+    def dup_root_upper_bound(self, f):
+        return dup_root_upper_bound(self.to_dense(f), self.domain)
+    def dup_root_lower_bound(self, f):
+        return dup_root_lower_bound(self.to_dense(f), self.domain)
+
+    def dup_step_refine_real_root(self, f, M, fast=False):
+        return dup_step_refine_real_root(self.to_dense(f), M, self.domain, fast=fast)
+    def dup_inner_refine_real_root(self, f, M, eps=None, steps=None, disjoint=None, fast=False, mobius=False):
+        return dup_inner_refine_real_root(self.to_dense(f), M, self.domain, eps=eps, steps=steps, disjoint=disjoint, fast=fast, mobius=mobius)
+    def dup_outer_refine_real_root(self, f, s, t, eps=None, steps=None, disjoint=None, fast=False):
+        return dup_outer_refine_real_root(self.to_dense(f), s, t, self.domain, eps=eps, steps=steps, disjoint=disjoint, fast=fast)
+    def dup_refine_real_root(self, f, s, t, eps=None, steps=None, disjoint=None, fast=False):
+        return dup_refine_real_root(self.to_dense(f), s, t, self.domain, eps=eps, steps=steps, disjoint=disjoint, fast=fast)
+    def dup_inner_isolate_real_roots(self, f, eps=None, fast=False):
+        return dup_inner_isolate_real_roots(self.to_dense(f), self.domain, eps=eps, fast=fast)
+    def dup_inner_isolate_positive_roots(self, f, eps=None, inf=None, sup=None, fast=False, mobius=False):
+        return dup_inner_isolate_positive_roots(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, fast=fast, mobius=mobius)
+    def dup_inner_isolate_negative_roots(self, f, inf=None, sup=None, eps=None, fast=False, mobius=False):
+        return dup_inner_isolate_negative_roots(self.to_dense(f), self.domain, inf=inf, sup=sup, eps=eps, fast=fast, mobius=mobius)
+    def dup_isolate_real_roots_sqf(self, f, eps=None, inf=None, sup=None, fast=False, blackbox=False):
+        return dup_isolate_real_roots_sqf(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, fast=fast, blackbox=blackbox)
+    def dup_isolate_real_roots(self, f, eps=None, inf=None, sup=None, basis=False, fast=False):
+        return dup_isolate_real_roots(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, basis=basis, fast=fast)
+    def dup_isolate_real_roots_list(self, polys, eps=None, inf=None, sup=None, strict=False, basis=False, fast=False):
+        return dup_isolate_real_roots_list(list(map(self.to_dense, polys)), self.domain, eps=eps, inf=inf, sup=sup, strict=strict, basis=basis, fast=fast)
+    def dup_count_real_roots(self, f, inf=None, sup=None):
+        return dup_count_real_roots(self.to_dense(f), self.domain, inf=inf, sup=sup)
+    def dup_count_complex_roots(self, f, inf=None, sup=None, exclude=None):
+        return dup_count_complex_roots(self.to_dense(f), self.domain, inf=inf, sup=sup, exclude=exclude)
+    def dup_isolate_complex_roots_sqf(self, f, eps=None, inf=None, sup=None, blackbox=False):
+        return dup_isolate_complex_roots_sqf(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, blackbox=blackbox)
+    def dup_isolate_all_roots_sqf(self, f, eps=None, inf=None, sup=None, fast=False, blackbox=False):
+        return dup_isolate_all_roots_sqf(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, fast=fast, blackbox=blackbox)
+    def dup_isolate_all_roots(self, f, eps=None, inf=None, sup=None, fast=False):
+        return dup_isolate_all_roots(self.to_dense(f), self.domain, eps=eps, inf=inf, sup=sup, fast=fast)
+
+    def fateman_poly_F_1(self):
+        from sympy.polys.specialpolys import dmp_fateman_poly_F_1
+        return tuple(map(self.from_dense, dmp_fateman_poly_F_1(self.ngens-1, self.domain)))
+    def fateman_poly_F_2(self):
+        from sympy.polys.specialpolys import dmp_fateman_poly_F_2
+        return tuple(map(self.from_dense, dmp_fateman_poly_F_2(self.ngens-1, self.domain)))
+    def fateman_poly_F_3(self):
+        from sympy.polys.specialpolys import dmp_fateman_poly_F_3
+        return tuple(map(self.from_dense, dmp_fateman_poly_F_3(self.ngens-1, self.domain)))
+
+    def to_gf_dense(self, element):
+        return gf_strip([ self.domain.dom.convert(c, self.domain) for c in self.wrap(element).to_dense() ])
+
+    def from_gf_dense(self, element):
+        return self.from_dict(dmp_to_dict(element, self.ngens-1, self.domain.dom))
+
+    def gf_degree(self, f):
+        return gf_degree(self.to_gf_dense(f))
+
+    def gf_LC(self, f):
+        return gf_LC(self.to_gf_dense(f), self.domain.dom)
+    def gf_TC(self, f):
+        return gf_TC(self.to_gf_dense(f), self.domain.dom)
+
+    def gf_strip(self, f):
+        return self.from_gf_dense(gf_strip(self.to_gf_dense(f)))
+    def gf_trunc(self, f):
+        return self.from_gf_dense(gf_strip(self.to_gf_dense(f), self.domain.mod))
+    def gf_normal(self, f):
+        return self.from_gf_dense(gf_strip(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_from_dict(self, f):
+        return self.from_gf_dense(gf_from_dict(f, self.domain.mod, self.domain.dom))
+    def gf_to_dict(self, f, symmetric=True):
+        return gf_to_dict(self.to_gf_dense(f), self.domain.mod, symmetric=symmetric)
+
+    def gf_from_int_poly(self, f):
+        return self.from_gf_dense(gf_from_int_poly(f, self.domain.mod))
+    def gf_to_int_poly(self, f, symmetric=True):
+        return gf_to_int_poly(self.to_gf_dense(f), self.domain.mod, symmetric=symmetric)
+
+    def gf_neg(self, f):
+        return self.from_gf_dense(gf_neg(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_add_ground(self, f, a):
+        return self.from_gf_dense(gf_add_ground(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom))
+    def gf_sub_ground(self, f, a):
+        return self.from_gf_dense(gf_sub_ground(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom))
+    def gf_mul_ground(self, f, a):
+        return self.from_gf_dense(gf_mul_ground(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom))
+    def gf_quo_ground(self, f, a):
+        return self.from_gf_dense(gf_quo_ground(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom))
+
+    def gf_add(self, f, g):
+        return self.from_gf_dense(gf_add(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_sub(self, f, g):
+        return self.from_gf_dense(gf_sub(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_mul(self, f, g):
+        return self.from_gf_dense(gf_mul(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_sqr(self, f):
+        return self.from_gf_dense(gf_sqr(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_add_mul(self, f, g, h):
+        return self.from_gf_dense(gf_add_mul(self.to_gf_dense(f), self.to_gf_dense(g), self.to_gf_dense(h), self.domain.mod, self.domain.dom))
+    def gf_sub_mul(self, f, g, h):
+        return self.from_gf_dense(gf_sub_mul(self.to_gf_dense(f), self.to_gf_dense(g), self.to_gf_dense(h), self.domain.mod, self.domain.dom))
+
+    def gf_expand(self, F):
+        return self.from_gf_dense(gf_expand(list(map(self.to_gf_dense, F)), self.domain.mod, self.domain.dom))
+
+    def gf_div(self, f, g):
+        q, r = gf_div(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom)
+        return self.from_gf_dense(q), self.from_gf_dense(r)
+    def gf_rem(self, f, g):
+        return self.from_gf_dense(gf_rem(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_quo(self, f, g):
+        return self.from_gf_dense(gf_quo(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_exquo(self, f, g):
+        return self.from_gf_dense(gf_exquo(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+
+    def gf_lshift(self, f, n):
+        return self.from_gf_dense(gf_lshift(self.to_gf_dense(f), n, self.domain.dom))
+    def gf_rshift(self, f, n):
+        return self.from_gf_dense(gf_rshift(self.to_gf_dense(f), n, self.domain.dom))
+
+    def gf_pow(self, f, n):
+        return self.from_gf_dense(gf_pow(self.to_gf_dense(f), n, self.domain.mod, self.domain.dom))
+    def gf_pow_mod(self, f, n, g):
+        return self.from_gf_dense(gf_pow_mod(self.to_gf_dense(f), n, self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+
+    def gf_cofactors(self, f, g):
+        h, cff, cfg = gf_cofactors(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom)
+        return self.from_gf_dense(h), self.from_gf_dense(cff), self.from_gf_dense(cfg)
+    def gf_gcd(self, f, g):
+        return self.from_gf_dense(gf_gcd(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_lcm(self, f, g):
+        return self.from_gf_dense(gf_lcm(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_gcdex(self, f, g):
+        return self.from_gf_dense(gf_gcdex(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+
+    def gf_monic(self, f):
+        return self.from_gf_dense(gf_monic(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+    def gf_diff(self, f):
+        return self.from_gf_dense(gf_diff(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_eval(self, f, a):
+        return gf_eval(self.to_gf_dense(f), a, self.domain.mod, self.domain.dom)
+    def gf_multi_eval(self, f, A):
+        return gf_multi_eval(self.to_gf_dense(f), A, self.domain.mod, self.domain.dom)
+
+    def gf_compose(self, f, g):
+        return self.from_gf_dense(gf_compose(self.to_gf_dense(f), self.to_gf_dense(g), self.domain.mod, self.domain.dom))
+    def gf_compose_mod(self, g, h, f):
+        return self.from_gf_dense(gf_compose_mod(self.to_gf_dense(g), self.to_gf_dense(h), self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+
+    def gf_trace_map(self, a, b, c, n, f):
+        a = self.to_gf_dense(a)
+        b = self.to_gf_dense(b)
+        c = self.to_gf_dense(c)
+        f = self.to_gf_dense(f)
+        U, V = gf_trace_map(a, b, c, n, f, self.domain.mod, self.domain.dom)
+        return self.from_gf_dense(U), self.from_gf_dense(V)
+
+    def gf_random(self, n):
+        return self.from_gf_dense(gf_random(n, self.domain.mod, self.domain.dom))
+    def gf_irreducible(self, n):
+        return self.from_gf_dense(gf_irreducible(n, self.domain.mod, self.domain.dom))
+
+    def gf_irred_p_ben_or(self, f):
+        return gf_irred_p_ben_or(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+    def gf_irred_p_rabin(self, f):
+        return gf_irred_p_rabin(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+    def gf_irreducible_p(self, f):
+        return gf_irreducible_p(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+    def gf_sqf_p(self, f):
+        return gf_sqf_p(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+
+    def gf_sqf_part(self, f):
+        return self.from_gf_dense(gf_sqf_part(self.to_gf_dense(f), self.domain.mod, self.domain.dom))
+    def gf_sqf_list(self, f, all=False):
+        coeff, factors = gf_sqf_part(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return coeff, [ (self.from_gf_dense(g), k) for g, k in factors ]
+
+    def gf_Qmatrix(self, f):
+        return gf_Qmatrix(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+    def gf_berlekamp(self, f):
+        factors = gf_berlekamp(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+
+    def gf_ddf_zassenhaus(self, f):
+        factors = gf_ddf_zassenhaus(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ (self.from_gf_dense(g), k) for g, k in factors ]
+    def gf_edf_zassenhaus(self, f, n):
+        factors = gf_edf_zassenhaus(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+
+    def gf_ddf_shoup(self, f):
+        factors = gf_ddf_shoup(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ (self.from_gf_dense(g), k) for g, k in factors ]
+    def gf_edf_shoup(self, f, n):
+        factors = gf_edf_shoup(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+
+    def gf_zassenhaus(self, f):
+        factors = gf_zassenhaus(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+    def gf_shoup(self, f):
+        factors = gf_shoup(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return [ self.from_gf_dense(g) for g in factors ]
+
+    def gf_factor_sqf(self, f, method=None):
+        coeff, factors = gf_factor_sqf(self.to_gf_dense(f), self.domain.mod, self.domain.dom, method=method)
+        return coeff, [ self.from_gf_dense(g) for g in factors ]
+    def gf_factor(self, f):
+        coeff, factors = gf_factor(self.to_gf_dense(f), self.domain.mod, self.domain.dom)
+        return coeff, [ (self.from_gf_dense(g), k) for g, k in factors ]

llmeval-env/lib/python3.10/site-packages/sympy/polys/constructor.py

@@ -0,0 +1,387 @@
+"""Tools for constructing domains for expressions. """
+from math import prod
+
+from sympy.core import sympify
+from sympy.core.evalf import pure_complex
+from sympy.core.sorting import ordered
+from sympy.polys.domains import ZZ, QQ, ZZ_I, QQ_I, EX
+from sympy.polys.domains.complexfield import ComplexField
+from sympy.polys.domains.realfield import RealField
+from sympy.polys.polyoptions import build_options
+from sympy.polys.polyutils import parallel_dict_from_basic
+from sympy.utilities import public
+
+
+def _construct_simple(coeffs, opt):
+    """Handle simple domains, e.g.: ZZ, QQ, RR and algebraic domains. """
+    rationals = floats = complexes = algebraics = False
+    float_numbers = []
+
+    if opt.extension is True:
+        is_algebraic = lambda coeff: coeff.is_number and coeff.is_algebraic
+    else:
+        is_algebraic = lambda coeff: False
+
+    for coeff in coeffs:
+        if coeff.is_Rational:
+            if not coeff.is_Integer:
+                rationals = True
+        elif coeff.is_Float:
+            if algebraics:
+                # there are both reals and algebraics -> EX
+                return False
+            else:
+                floats = True
+                float_numbers.append(coeff)
+        else:
+            is_complex = pure_complex(coeff)
+            if is_complex:
+                complexes = True
+                x, y = is_complex
+                if x.is_Rational and y.is_Rational:
+                    if not (x.is_Integer and y.is_Integer):
+                        rationals = True
+                    continue
+                else:
+                    floats = True
+                    if x.is_Float:
+                        float_numbers.append(x)
+                    if y.is_Float:
+                        float_numbers.append(y)
+            elif is_algebraic(coeff):
+                if floats:
+                    # there are both algebraics and reals -> EX
+                    return False
+                algebraics = True
+            else:
+                # this is a composite domain, e.g. ZZ[X], EX
+                return None
+
+    # Use the maximum precision of all coefficients for the RR or CC
+    # precision
+    max_prec = max(c._prec for c in float_numbers) if float_numbers else 53
+
+    if algebraics:
+        domain, result = _construct_algebraic(coeffs, opt)
+    else:
+        if floats and complexes:
+            domain = ComplexField(prec=max_prec)
+        elif floats:
+            domain = RealField(prec=max_prec)
+        elif rationals or opt.field:
+            domain = QQ_I if complexes else QQ
+        else:
+            domain = ZZ_I if complexes else ZZ
+
+        result = [domain.from_sympy(coeff) for coeff in coeffs]
+
+    return domain, result
+
+
+def _construct_algebraic(coeffs, opt):
+    """We know that coefficients are algebraic so construct the extension. """
+    from sympy.polys.numberfields import primitive_element
+
+    exts = set()
+
+    def build_trees(args):
+        trees = []
+        for a in args:
+            if a.is_Rational:
+                tree = ('Q', QQ.from_sympy(a))
+            elif a.is_Add:
+                tree = ('+', build_trees(a.args))
+            elif a.is_Mul:
+                tree = ('*', build_trees(a.args))
+            else:
+                tree = ('e', a)
+                exts.add(a)
+            trees.append(tree)
+        return trees
+
+    trees = build_trees(coeffs)
+    exts = list(ordered(exts))
+
+    g, span, H = primitive_element(exts, ex=True, polys=True)
+    root = sum([ s*ext for s, ext in zip(span, exts) ])
+
+    domain, g = QQ.algebraic_field((g, root)), g.rep.rep
+
+    exts_dom = [domain.dtype.from_list(h, g, QQ) for h in H]
+    exts_map = dict(zip(exts, exts_dom))
+
+    def convert_tree(tree):
+        op, args = tree
+        if op == 'Q':
+            return domain.dtype.from_list([args], g, QQ)
+        elif op == '+':
+            return sum((convert_tree(a) for a in args), domain.zero)
+        elif op == '*':
+            return prod(convert_tree(a) for a in args)
+        elif op == 'e':
+            return exts_map[args]
+        else:
+            raise RuntimeError
+
+    result = [convert_tree(tree) for tree in trees]
+
+    return domain, result
+
+
+def _construct_composite(coeffs, opt):
+    """Handle composite domains, e.g.: ZZ[X], QQ[X], ZZ(X), QQ(X). """
+    numers, denoms = [], []
+
+    for coeff in coeffs:
+        numer, denom = coeff.as_numer_denom()
+
+        numers.append(numer)
+        denoms.append(denom)
+
+    polys, gens = parallel_dict_from_basic(numers + denoms)  # XXX: sorting
+    if not gens:
+        return None
+
+    if opt.composite is None:
+        if any(gen.is_number and gen.is_algebraic for gen in gens):
+            return None # generators are number-like so lets better use EX
+
+        all_symbols = set()
+
+        for gen in gens:
+            symbols = gen.free_symbols
+
+            if all_symbols & symbols:
+                return None # there could be algebraic relations between generators
+            else:
+                all_symbols |= symbols
+
+    n = len(gens)
+    k = len(polys)//2
+
+    numers = polys[:k]
+    denoms = polys[k:]
+
+    if opt.field:
+        fractions = True
+    else:
+        fractions, zeros = False, (0,)*n
+
+        for denom in denoms:
+            if len(denom) > 1 or zeros not in denom:
+                fractions = True
+                break
+
+    coeffs = set()
+
+    if not fractions:
+        for numer, denom in zip(numers, denoms):
+            denom = denom[zeros]
+
+            for monom, coeff in numer.items():
+                coeff /= denom
+                coeffs.add(coeff)
+                numer[monom] = coeff
+    else:
+        for numer, denom in zip(numers, denoms):
+            coeffs.update(list(numer.values()))
+            coeffs.update(list(denom.values()))
+
+    rationals = floats = complexes = False
+    float_numbers = []
+
+    for coeff in coeffs:
+        if coeff.is_Rational:
+            if not coeff.is_Integer:
+                rationals = True
+        elif coeff.is_Float:
+            floats = True
+            float_numbers.append(coeff)
+        else:
+            is_complex = pure_complex(coeff)
+            if is_complex is not None:
+                complexes = True
+                x, y = is_complex
+                if x.is_Rational and y.is_Rational:
+                    if not (x.is_Integer and y.is_Integer):
+                        rationals = True
+                else:
+                    floats = True
+                    if x.is_Float:
+                        float_numbers.append(x)
+                    if y.is_Float:
+                        float_numbers.append(y)
+
+    max_prec = max(c._prec for c in float_numbers) if float_numbers else 53
+
+    if floats and complexes:
+        ground = ComplexField(prec=max_prec)
+    elif floats:
+        ground = RealField(prec=max_prec)
+    elif complexes:
+        if rationals:
+            ground = QQ_I
+        else:
+            ground = ZZ_I
+    elif rationals:
+        ground = QQ
+    else:
+        ground = ZZ
+
+    result = []
+
+    if not fractions:
+        domain = ground.poly_ring(*gens)
+
+        for numer in numers:
+            for monom, coeff in numer.items():
+                numer[monom] = ground.from_sympy(coeff)
+
+            result.append(domain(numer))
+    else:
+        domain = ground.frac_field(*gens)
+
+        for numer, denom in zip(numers, denoms):
+            for monom, coeff in numer.items():
+                numer[monom] = ground.from_sympy(coeff)
+
+            for monom, coeff in denom.items():
+                denom[monom] = ground.from_sympy(coeff)
+
+            result.append(domain((numer, denom)))
+
+    return domain, result
+
+
+def _construct_expression(coeffs, opt):
+    """The last resort case, i.e. use the expression domain. """
+    domain, result = EX, []
+
+    for coeff in coeffs:
+        result.append(domain.from_sympy(coeff))
+
+    return domain, result
+
+
+@public
+def construct_domain(obj, **args):
+    """Construct a minimal domain for a list of expressions.
+
+    Explanation
+    ===========
+
+    Given a list of normal SymPy expressions (of type :py:class:`~.Expr`)
+    ``construct_domain`` will find a minimal :py:class:`~.Domain` that can
+    represent those expressions. The expressions will be converted to elements
+    of the domain and both the domain and the domain elements are returned.
+
+    Parameters
+    ==========
+
+    obj: list or dict
+        The expressions to build a domain for.
+
+    **args: keyword arguments
+        Options that affect the choice of domain.
+
+    Returns
+    =======
+
+    (K, elements): Domain and list of domain elements
+        The domain K that can represent the expressions and the list or dict
+        of domain elements representing the same expressions as elements of K.
+
+    Examples
+    ========
+
+    Given a list of :py:class:`~.Integer` ``construct_domain`` will return the
+    domain :ref:`ZZ` and a list of integers as elements of :ref:`ZZ`.
+
+    >>> from sympy import construct_domain, S
+    >>> expressions = [S(2), S(3), S(4)]
+    >>> K, elements = construct_domain(expressions)
+    >>> K
+    ZZ
+    >>> elements
+    [2, 3, 4]
+    >>> type(elements[0])  # doctest: +SKIP
+    <class 'int'>
+    >>> type(expressions[0])
+    <class 'sympy.core.numbers.Integer'>
+
+    If there are any :py:class:`~.Rational` then :ref:`QQ` is returned
+    instead.
+
+    >>> construct_domain([S(1)/2, S(3)/4])
+    (QQ, [1/2, 3/4])
+
+    If there are symbols then a polynomial ring :ref:`K[x]` is returned.
+
+    >>> from sympy import symbols
+    >>> x, y = symbols('x, y')
+    >>> construct_domain([2*x + 1, S(3)/4])
+    (QQ[x], [2*x + 1, 3/4])
+    >>> construct_domain([2*x + 1, y])
+    (ZZ[x,y], [2*x + 1, y])
+
+    If any symbols appear with negative powers then a rational function field
+    :ref:`K(x)` will be returned.
+
+    >>> construct_domain([y/x, x/(1 - y)])
+    (ZZ(x,y), [y/x, -x/(y - 1)])
+
+    Irrational algebraic numbers will result in the :ref:`EX` domain by
+    default. The keyword argument ``extension=True`` leads to the construction
+    of an algebraic number field :ref:`QQ(a)`.
+
+    >>> from sympy import sqrt
+    >>> construct_domain([sqrt(2)])
+    (EX, [EX(sqrt(2))])
+    >>> construct_domain([sqrt(2)], extension=True)  # doctest: +SKIP
+    (QQ<sqrt(2)>, [ANP([1, 0], [1, 0, -2], QQ)])
+
+    See also
+    ========
+
+    Domain
+    Expr
+    """
+    opt = build_options(args)
+
+    if hasattr(obj, '__iter__'):
+        if isinstance(obj, dict):
+            if not obj:
+                monoms, coeffs = [], []
+            else:
+                monoms, coeffs = list(zip(*list(obj.items())))
+        else:
+            coeffs = obj
+    else:
+        coeffs = [obj]
+
+    coeffs = list(map(sympify, coeffs))
+    result = _construct_simple(coeffs, opt)
+
+    if result is not None:
+        if result is not False:
+            domain, coeffs = result
+        else:
+            domain, coeffs = _construct_expression(coeffs, opt)
+    else:
+        if opt.composite is False:
+            result = None
+        else:
+            result = _construct_composite(coeffs, opt)
+
+        if result is not None:
+            domain, coeffs = result
+        else:
+            domain, coeffs = _construct_expression(coeffs, opt)
+
+    if hasattr(obj, '__iter__'):
+        if isinstance(obj, dict):
+            return domain, dict(list(zip(monoms, coeffs)))
+        else:
+            return domain, coeffs
+    else:
+        return domain, coeffs[0]

llmeval-env/lib/python3.10/site-packages/sympy/polys/densearith.py

@@ -0,0 +1,1875 @@
+"""Arithmetics for dense recursive polynomials in ``K[x]`` or ``K[X]``. """
+
+
+from sympy.polys.densebasic import (
+    dup_slice,
+    dup_LC, dmp_LC,
+    dup_degree, dmp_degree,
+    dup_strip, dmp_strip,
+    dmp_zero_p, dmp_zero,
+    dmp_one_p, dmp_one,
+    dmp_ground, dmp_zeros)
+from sympy.polys.polyerrors import (ExactQuotientFailed, PolynomialDivisionFailed)
+
+def dup_add_term(f, c, i, K):
+    """
+    Add ``c*x**i`` to ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_add_term(x**2 - 1, ZZ(2), 4)
+    2*x**4 + x**2 - 1
+
+    """
+    if not c:
+        return f
+
+    n = len(f)
+    m = n - i - 1
+
+    if i == n - 1:
+        return dup_strip([f[0] + c] + f[1:])
+    else:
+        if i >= n:
+            return [c] + [K.zero]*(i - n) + f
+        else:
+            return f[:m] + [f[m] + c] + f[m + 1:]
+
+
+def dmp_add_term(f, c, i, u, K):
+    """
+    Add ``c(x_2..x_u)*x_0**i`` to ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_add_term(x*y + 1, 2, 2)
+    2*x**2 + x*y + 1
+
+    """
+    if not u:
+        return dup_add_term(f, c, i, K)
+
+    v = u - 1
+
+    if dmp_zero_p(c, v):
+        return f
+
+    n = len(f)
+    m = n - i - 1
+
+    if i == n - 1:
+        return dmp_strip([dmp_add(f[0], c, v, K)] + f[1:], u)
+    else:
+        if i >= n:
+            return [c] + dmp_zeros(i - n, v, K) + f
+        else:
+            return f[:m] + [dmp_add(f[m], c, v, K)] + f[m + 1:]
+
+
+def dup_sub_term(f, c, i, K):
+    """
+    Subtract ``c*x**i`` from ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_sub_term(2*x**4 + x**2 - 1, ZZ(2), 4)
+    x**2 - 1
+
+    """
+    if not c:
+        return f
+
+    n = len(f)
+    m = n - i - 1
+
+    if i == n - 1:
+        return dup_strip([f[0] - c] + f[1:])
+    else:
+        if i >= n:
+            return [-c] + [K.zero]*(i - n) + f
+        else:
+            return f[:m] + [f[m] - c] + f[m + 1:]
+
+
+def dmp_sub_term(f, c, i, u, K):
+    """
+    Subtract ``c(x_2..x_u)*x_0**i`` from ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_sub_term(2*x**2 + x*y + 1, 2, 2)
+    x*y + 1
+
+    """
+    if not u:
+        return dup_add_term(f, -c, i, K)
+
+    v = u - 1
+
+    if dmp_zero_p(c, v):
+        return f
+
+    n = len(f)
+    m = n - i - 1
+
+    if i == n - 1:
+        return dmp_strip([dmp_sub(f[0], c, v, K)] + f[1:], u)
+    else:
+        if i >= n:
+            return [dmp_neg(c, v, K)] + dmp_zeros(i - n, v, K) + f
+        else:
+            return f[:m] + [dmp_sub(f[m], c, v, K)] + f[m + 1:]
+
+
+def dup_mul_term(f, c, i, K):
+    """
+    Multiply ``f`` by ``c*x**i`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_mul_term(x**2 - 1, ZZ(3), 2)
+    3*x**4 - 3*x**2
+
+    """
+    if not c or not f:
+        return []
+    else:
+        return [ cf * c for cf in f ] + [K.zero]*i
+
+
+def dmp_mul_term(f, c, i, u, K):
+    """
+    Multiply ``f`` by ``c(x_2..x_u)*x_0**i`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_mul_term(x**2*y + x, 3*y, 2)
+    3*x**4*y**2 + 3*x**3*y
+
+    """
+    if not u:
+        return dup_mul_term(f, c, i, K)
+
+    v = u - 1
+
+    if dmp_zero_p(f, u):
+        return f
+    if dmp_zero_p(c, v):
+        return dmp_zero(u)
+    else:
+        return [ dmp_mul(cf, c, v, K) for cf in f ] + dmp_zeros(i, v, K)
+
+
+def dup_add_ground(f, c, K):
+    """
+    Add an element of the ground domain to ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_add_ground(x**3 + 2*x**2 + 3*x + 4, ZZ(4))
+    x**3 + 2*x**2 + 3*x + 8
+
+    """
+    return dup_add_term(f, c, 0, K)
+
+
+def dmp_add_ground(f, c, u, K):
+    """
+    Add an element of the ground domain to ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_add_ground(x**3 + 2*x**2 + 3*x + 4, ZZ(4))
+    x**3 + 2*x**2 + 3*x + 8
+
+    """
+    return dmp_add_term(f, dmp_ground(c, u - 1), 0, u, K)
+
+
+def dup_sub_ground(f, c, K):
+    """
+    Subtract an element of the ground domain from ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_sub_ground(x**3 + 2*x**2 + 3*x + 4, ZZ(4))
+    x**3 + 2*x**2 + 3*x
+
+    """
+    return dup_sub_term(f, c, 0, K)
+
+
+def dmp_sub_ground(f, c, u, K):
+    """
+    Subtract an element of the ground domain from ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_sub_ground(x**3 + 2*x**2 + 3*x + 4, ZZ(4))
+    x**3 + 2*x**2 + 3*x
+
+    """
+    return dmp_sub_term(f, dmp_ground(c, u - 1), 0, u, K)
+
+
+def dup_mul_ground(f, c, K):
+    """
+    Multiply ``f`` by a constant value in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_mul_ground(x**2 + 2*x - 1, ZZ(3))
+    3*x**2 + 6*x - 3
+
+    """
+    if not c or not f:
+        return []
+    else:
+        return [ cf * c for cf in f ]
+
+
+def dmp_mul_ground(f, c, u, K):
+    """
+    Multiply ``f`` by a constant value in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_mul_ground(2*x + 2*y, ZZ(3))
+    6*x + 6*y
+
+    """
+    if not u:
+        return dup_mul_ground(f, c, K)
+
+    v = u - 1
+
+    return [ dmp_mul_ground(cf, c, v, K) for cf in f ]
+
+
+def dup_quo_ground(f, c, K):
+    """
+    Quotient by a constant in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x = ring("x", ZZ)
+    >>> R.dup_quo_ground(3*x**2 + 2, ZZ(2))
+    x**2 + 1
+
+    >>> R, x = ring("x", QQ)
+    >>> R.dup_quo_ground(3*x**2 + 2, QQ(2))
+    3/2*x**2 + 1
+
+    """
+    if not c:
+        raise ZeroDivisionError('polynomial division')
+    if not f:
+        return f
+
+    if K.is_Field:
+        return [ K.quo(cf, c) for cf in f ]
+    else:
+        return [ cf // c for cf in f ]
+
+
+def dmp_quo_ground(f, c, u, K):
+    """
+    Quotient by a constant in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x,y = ring("x,y", ZZ)
+    >>> R.dmp_quo_ground(2*x**2*y + 3*x, ZZ(2))
+    x**2*y + x
+
+    >>> R, x,y = ring("x,y", QQ)
+    >>> R.dmp_quo_ground(2*x**2*y + 3*x, QQ(2))
+    x**2*y + 3/2*x
+
+    """
+    if not u:
+        return dup_quo_ground(f, c, K)
+
+    v = u - 1
+
+    return [ dmp_quo_ground(cf, c, v, K) for cf in f ]
+
+
+def dup_exquo_ground(f, c, K):
+    """
+    Exact quotient by a constant in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> R.dup_exquo_ground(x**2 + 2, QQ(2))
+    1/2*x**2 + 1
+
+    """
+    if not c:
+        raise ZeroDivisionError('polynomial division')
+    if not f:
+        return f
+
+    return [ K.exquo(cf, c) for cf in f ]
+
+
+def dmp_exquo_ground(f, c, u, K):
+    """
+    Exact quotient by a constant in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y = ring("x,y", QQ)
+
+    >>> R.dmp_exquo_ground(x**2*y + 2*x, QQ(2))
+    1/2*x**2*y + x
+
+    """
+    if not u:
+        return dup_exquo_ground(f, c, K)
+
+    v = u - 1
+
+    return [ dmp_exquo_ground(cf, c, v, K) for cf in f ]
+
+
+def dup_lshift(f, n, K):
+    """
+    Efficiently multiply ``f`` by ``x**n`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_lshift(x**2 + 1, 2)
+    x**4 + x**2
+
+    """
+    if not f:
+        return f
+    else:
+        return f + [K.zero]*n
+
+
+def dup_rshift(f, n, K):
+    """
+    Efficiently divide ``f`` by ``x**n`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_rshift(x**4 + x**2, 2)
+    x**2 + 1
+    >>> R.dup_rshift(x**4 + x**2 + 2, 2)
+    x**2 + 1
+
+    """
+    return f[:-n]
+
+
+def dup_abs(f, K):
+    """
+    Make all coefficients positive in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_abs(x**2 - 1)
+    x**2 + 1
+
+    """
+    return [ K.abs(coeff) for coeff in f ]
+
+
+def dmp_abs(f, u, K):
+    """
+    Make all coefficients positive in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_abs(x**2*y - x)
+    x**2*y + x
+
+    """
+    if not u:
+        return dup_abs(f, K)
+
+    v = u - 1
+
+    return [ dmp_abs(cf, v, K) for cf in f ]
+
+
+def dup_neg(f, K):
+    """
+    Negate a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_neg(x**2 - 1)
+    -x**2 + 1
+
+    """
+    return [ -coeff for coeff in f ]
+
+
+def dmp_neg(f, u, K):
+    """
+    Negate a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_neg(x**2*y - x)
+    -x**2*y + x
+
+    """
+    if not u:
+        return dup_neg(f, K)
+
+    v = u - 1
+
+    return [ dmp_neg(cf, v, K) for cf in f ]
+
+
+def dup_add(f, g, K):
+    """
+    Add dense polynomials in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_add(x**2 - 1, x - 2)
+    x**2 + x - 3
+
+    """
+    if not f:
+        return g
+    if not g:
+        return f
+
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    if df == dg:
+        return dup_strip([ a + b for a, b in zip(f, g) ])
+    else:
+        k = abs(df - dg)
+
+        if df > dg:
+            h, f = f[:k], f[k:]
+        else:
+            h, g = g[:k], g[k:]
+
+        return h + [ a + b for a, b in zip(f, g) ]
+
+
+def dmp_add(f, g, u, K):
+    """
+    Add dense polynomials in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_add(x**2 + y, x**2*y + x)
+    x**2*y + x**2 + x + y
+
+    """
+    if not u:
+        return dup_add(f, g, K)
+
+    df = dmp_degree(f, u)
+
+    if df < 0:
+        return g
+
+    dg = dmp_degree(g, u)
+
+    if dg < 0:
+        return f
+
+    v = u - 1
+
+    if df == dg:
+        return dmp_strip([ dmp_add(a, b, v, K) for a, b in zip(f, g) ], u)
+    else:
+        k = abs(df - dg)
+
+        if df > dg:
+            h, f = f[:k], f[k:]
+        else:
+            h, g = g[:k], g[k:]
+
+        return h + [ dmp_add(a, b, v, K) for a, b in zip(f, g) ]
+
+
+def dup_sub(f, g, K):
+    """
+    Subtract dense polynomials in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_sub(x**2 - 1, x - 2)
+    x**2 - x + 1
+
+    """
+    if not f:
+        return dup_neg(g, K)
+    if not g:
+        return f
+
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    if df == dg:
+        return dup_strip([ a - b for a, b in zip(f, g) ])
+    else:
+        k = abs(df - dg)
+
+        if df > dg:
+            h, f = f[:k], f[k:]
+        else:
+            h, g = dup_neg(g[:k], K), g[k:]
+
+        return h + [ a - b for a, b in zip(f, g) ]
+
+
+def dmp_sub(f, g, u, K):
+    """
+    Subtract dense polynomials in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_sub(x**2 + y, x**2*y + x)
+    -x**2*y + x**2 - x + y
+
+    """
+    if not u:
+        return dup_sub(f, g, K)
+
+    df = dmp_degree(f, u)
+
+    if df < 0:
+        return dmp_neg(g, u, K)
+
+    dg = dmp_degree(g, u)
+
+    if dg < 0:
+        return f
+
+    v = u - 1
+
+    if df == dg:
+        return dmp_strip([ dmp_sub(a, b, v, K) for a, b in zip(f, g) ], u)
+    else:
+        k = abs(df - dg)
+
+        if df > dg:
+            h, f = f[:k], f[k:]
+        else:
+            h, g = dmp_neg(g[:k], u, K), g[k:]
+
+        return h + [ dmp_sub(a, b, v, K) for a, b in zip(f, g) ]
+
+
+def dup_add_mul(f, g, h, K):
+    """
+    Returns ``f + g*h`` where ``f, g, h`` are in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_add_mul(x**2 - 1, x - 2, x + 2)
+    2*x**2 - 5
+
+    """
+    return dup_add(f, dup_mul(g, h, K), K)
+
+
+def dmp_add_mul(f, g, h, u, K):
+    """
+    Returns ``f + g*h`` where ``f, g, h`` are in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_add_mul(x**2 + y, x, x + 2)
+    2*x**2 + 2*x + y
+
+    """
+    return dmp_add(f, dmp_mul(g, h, u, K), u, K)
+
+
+def dup_sub_mul(f, g, h, K):
+    """
+    Returns ``f - g*h`` where ``f, g, h`` are in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_sub_mul(x**2 - 1, x - 2, x + 2)
+    3
+
+    """
+    return dup_sub(f, dup_mul(g, h, K), K)
+
+
+def dmp_sub_mul(f, g, h, u, K):
+    """
+    Returns ``f - g*h`` where ``f, g, h`` are in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_sub_mul(x**2 + y, x, x + 2)
+    -2*x + y
+
+    """
+    return dmp_sub(f, dmp_mul(g, h, u, K), u, K)
+
+
+def dup_mul(f, g, K):
+    """
+    Multiply dense polynomials in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_mul(x - 2, x + 2)
+    x**2 - 4
+
+    """
+    if f == g:
+        return dup_sqr(f, K)
+
+    if not (f and g):
+        return []
+
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    n = max(df, dg) + 1
+
+    if n < 100:
+        h = []
+
+        for i in range(0, df + dg + 1):
+            coeff = K.zero
+
+            for j in range(max(0, i - dg), min(df, i) + 1):
+                coeff += f[j]*g[i - j]
+
+            h.append(coeff)
+
+        return dup_strip(h)
+    else:
+        # Use Karatsuba's algorithm (divide and conquer), see e.g.:
+        # Joris van der Hoeven, Relax But Don't Be Too Lazy,
+        # J. Symbolic Computation, 11 (2002), section 3.1.1.
+        n2 = n//2
+
+        fl, gl = dup_slice(f, 0, n2, K), dup_slice(g, 0, n2, K)
+
+        fh = dup_rshift(dup_slice(f, n2, n, K), n2, K)
+        gh = dup_rshift(dup_slice(g, n2, n, K), n2, K)
+
+        lo, hi = dup_mul(fl, gl, K), dup_mul(fh, gh, K)
+
+        mid = dup_mul(dup_add(fl, fh, K), dup_add(gl, gh, K), K)
+        mid = dup_sub(mid, dup_add(lo, hi, K), K)
+
+        return dup_add(dup_add(lo, dup_lshift(mid, n2, K), K),
+                       dup_lshift(hi, 2*n2, K), K)
+
+
+def dmp_mul(f, g, u, K):
+    """
+    Multiply dense polynomials in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_mul(x*y + 1, x)
+    x**2*y + x
+
+    """
+    if not u:
+        return dup_mul(f, g, K)
+
+    if f == g:
+        return dmp_sqr(f, u, K)
+
+    df = dmp_degree(f, u)
+
+    if df < 0:
+        return f
+
+    dg = dmp_degree(g, u)
+
+    if dg < 0:
+        return g
+
+    h, v = [], u - 1
+
+    for i in range(0, df + dg + 1):
+        coeff = dmp_zero(v)
+
+        for j in range(max(0, i - dg), min(df, i) + 1):
+            coeff = dmp_add(coeff, dmp_mul(f[j], g[i - j], v, K), v, K)
+
+        h.append(coeff)
+
+    return dmp_strip(h, u)
+
+
+def dup_sqr(f, K):
+    """
+    Square dense polynomials in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_sqr(x**2 + 1)
+    x**4 + 2*x**2 + 1
+
+    """
+    df, h = len(f) - 1, []
+
+    for i in range(0, 2*df + 1):
+        c = K.zero
+
+        jmin = max(0, i - df)
+        jmax = min(i, df)
+
+        n = jmax - jmin + 1
+
+        jmax = jmin + n // 2 - 1
+
+        for j in range(jmin, jmax + 1):
+            c += f[j]*f[i - j]
+
+        c += c
+
+        if n & 1:
+            elem = f[jmax + 1]
+            c += elem**2
+
+        h.append(c)
+
+    return dup_strip(h)
+
+
+def dmp_sqr(f, u, K):
+    """
+    Square dense polynomials in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_sqr(x**2 + x*y + y**2)
+    x**4 + 2*x**3*y + 3*x**2*y**2 + 2*x*y**3 + y**4
+
+    """
+    if not u:
+        return dup_sqr(f, K)
+
+    df = dmp_degree(f, u)
+
+    if df < 0:
+        return f
+
+    h, v = [], u - 1
+
+    for i in range(0, 2*df + 1):
+        c = dmp_zero(v)
+
+        jmin = max(0, i - df)
+        jmax = min(i, df)
+
+        n = jmax - jmin + 1
+
+        jmax = jmin + n // 2 - 1
+
+        for j in range(jmin, jmax + 1):
+            c = dmp_add(c, dmp_mul(f[j], f[i - j], v, K), v, K)
+
+        c = dmp_mul_ground(c, K(2), v, K)
+
+        if n & 1:
+            elem = dmp_sqr(f[jmax + 1], v, K)
+            c = dmp_add(c, elem, v, K)
+
+        h.append(c)
+
+    return dmp_strip(h, u)
+
+
+def dup_pow(f, n, K):
+    """
+    Raise ``f`` to the ``n``-th power in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_pow(x - 2, 3)
+    x**3 - 6*x**2 + 12*x - 8
+
+    """
+    if not n:
+        return [K.one]
+    if n < 0:
+        raise ValueError("Cannot raise polynomial to a negative power")
+    if n == 1 or not f or f == [K.one]:
+        return f
+
+    g = [K.one]
+
+    while True:
+        n, m = n//2, n
+
+        if m % 2:
+            g = dup_mul(g, f, K)
+
+            if not n:
+                break
+
+        f = dup_sqr(f, K)
+
+    return g
+
+
+def dmp_pow(f, n, u, K):
+    """
+    Raise ``f`` to the ``n``-th power in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_pow(x*y + 1, 3)
+    x**3*y**3 + 3*x**2*y**2 + 3*x*y + 1
+
+    """
+    if not u:
+        return dup_pow(f, n, K)
+
+    if not n:
+        return dmp_one(u, K)
+    if n < 0:
+        raise ValueError("Cannot raise polynomial to a negative power")
+    if n == 1 or dmp_zero_p(f, u) or dmp_one_p(f, u, K):
+        return f
+
+    g = dmp_one(u, K)
+
+    while True:
+        n, m = n//2, n
+
+        if m & 1:
+            g = dmp_mul(g, f, u, K)
+
+            if not n:
+                break
+
+        f = dmp_sqr(f, u, K)
+
+    return g
+
+
+def dup_pdiv(f, g, K):
+    """
+    Polynomial pseudo-division in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_pdiv(x**2 + 1, 2*x - 4)
+    (2*x + 4, 20)
+
+    """
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    q, r, dr = [], f, df
+
+    if not g:
+        raise ZeroDivisionError("polynomial division")
+    elif df < dg:
+        return q, r
+
+    N = df - dg + 1
+    lc_g = dup_LC(g, K)
+
+    while True:
+        lc_r = dup_LC(r, K)
+        j, N = dr - dg, N - 1
+
+        Q = dup_mul_ground(q, lc_g, K)
+        q = dup_add_term(Q, lc_r, j, K)
+
+        R = dup_mul_ground(r, lc_g, K)
+        G = dup_mul_term(g, lc_r, j, K)
+        r = dup_sub(R, G, K)
+
+        _dr, dr = dr, dup_degree(r)
+
+        if dr < dg:
+            break
+        elif not (dr < _dr):
+            raise PolynomialDivisionFailed(f, g, K)
+
+    c = lc_g**N
+
+    q = dup_mul_ground(q, c, K)
+    r = dup_mul_ground(r, c, K)
+
+    return q, r
+
+
+def dup_prem(f, g, K):
+    """
+    Polynomial pseudo-remainder in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_prem(x**2 + 1, 2*x - 4)
+    20
+
+    """
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    r, dr = f, df
+
+    if not g:
+        raise ZeroDivisionError("polynomial division")
+    elif df < dg:
+        return r
+
+    N = df - dg + 1
+    lc_g = dup_LC(g, K)
+
+    while True:
+        lc_r = dup_LC(r, K)
+        j, N = dr - dg, N - 1
+
+        R = dup_mul_ground(r, lc_g, K)
+        G = dup_mul_term(g, lc_r, j, K)
+        r = dup_sub(R, G, K)
+
+        _dr, dr = dr, dup_degree(r)
+
+        if dr < dg:
+            break
+        elif not (dr < _dr):
+            raise PolynomialDivisionFailed(f, g, K)
+
+    return dup_mul_ground(r, lc_g**N, K)
+
+
+def dup_pquo(f, g, K):
+    """
+    Polynomial exact pseudo-quotient in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_pquo(x**2 - 1, 2*x - 2)
+    2*x + 2
+
+    >>> R.dup_pquo(x**2 + 1, 2*x - 4)
+    2*x + 4
+
+    """
+    return dup_pdiv(f, g, K)[0]
+
+
+def dup_pexquo(f, g, K):
+    """
+    Polynomial pseudo-quotient in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_pexquo(x**2 - 1, 2*x - 2)
+    2*x + 2
+
+    >>> R.dup_pexquo(x**2 + 1, 2*x - 4)
+    Traceback (most recent call last):
+    ...
+    ExactQuotientFailed: [2, -4] does not divide [1, 0, 1]
+
+    """
+    q, r = dup_pdiv(f, g, K)
+
+    if not r:
+        return q
+    else:
+        raise ExactQuotientFailed(f, g)
+
+
+def dmp_pdiv(f, g, u, K):
+    """
+    Polynomial pseudo-division in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_pdiv(x**2 + x*y, 2*x + 2)
+    (2*x + 2*y - 2, -4*y + 4)
+
+    """
+    if not u:
+        return dup_pdiv(f, g, K)
+
+    df = dmp_degree(f, u)
+    dg = dmp_degree(g, u)
+
+    if dg < 0:
+        raise ZeroDivisionError("polynomial division")
+
+    q, r, dr = dmp_zero(u), f, df
+
+    if df < dg:
+        return q, r
+
+    N = df - dg + 1
+    lc_g = dmp_LC(g, K)
+
+    while True:
+        lc_r = dmp_LC(r, K)
+        j, N = dr - dg, N - 1
+
+        Q = dmp_mul_term(q, lc_g, 0, u, K)
+        q = dmp_add_term(Q, lc_r, j, u, K)
+
+        R = dmp_mul_term(r, lc_g, 0, u, K)
+        G = dmp_mul_term(g, lc_r, j, u, K)
+        r = dmp_sub(R, G, u, K)
+
+        _dr, dr = dr, dmp_degree(r, u)
+
+        if dr < dg:
+            break
+        elif not (dr < _dr):
+            raise PolynomialDivisionFailed(f, g, K)
+
+    c = dmp_pow(lc_g, N, u - 1, K)
+
+    q = dmp_mul_term(q, c, 0, u, K)
+    r = dmp_mul_term(r, c, 0, u, K)
+
+    return q, r
+
+
+def dmp_prem(f, g, u, K):
+    """
+    Polynomial pseudo-remainder in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_prem(x**2 + x*y, 2*x + 2)
+    -4*y + 4
+
+    """
+    if not u:
+        return dup_prem(f, g, K)
+
+    df = dmp_degree(f, u)
+    dg = dmp_degree(g, u)
+
+    if dg < 0:
+        raise ZeroDivisionError("polynomial division")
+
+    r, dr = f, df
+
+    if df < dg:
+        return r
+
+    N = df - dg + 1
+    lc_g = dmp_LC(g, K)
+
+    while True:
+        lc_r = dmp_LC(r, K)
+        j, N = dr - dg, N - 1
+
+        R = dmp_mul_term(r, lc_g, 0, u, K)
+        G = dmp_mul_term(g, lc_r, j, u, K)
+        r = dmp_sub(R, G, u, K)
+
+        _dr, dr = dr, dmp_degree(r, u)
+
+        if dr < dg:
+            break
+        elif not (dr < _dr):
+            raise PolynomialDivisionFailed(f, g, K)
+
+    c = dmp_pow(lc_g, N, u - 1, K)
+
+    return dmp_mul_term(r, c, 0, u, K)
+
+
+def dmp_pquo(f, g, u, K):
+    """
+    Polynomial exact pseudo-quotient in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x**2 + x*y
+    >>> g = 2*x + 2*y
+    >>> h = 2*x + 2
+
+    >>> R.dmp_pquo(f, g)
+    2*x
+
+    >>> R.dmp_pquo(f, h)
+    2*x + 2*y - 2
+
+    """
+    return dmp_pdiv(f, g, u, K)[0]
+
+
+def dmp_pexquo(f, g, u, K):
+    """
+    Polynomial pseudo-quotient in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x**2 + x*y
+    >>> g = 2*x + 2*y
+    >>> h = 2*x + 2
+
+    >>> R.dmp_pexquo(f, g)
+    2*x
+
+    >>> R.dmp_pexquo(f, h)
+    Traceback (most recent call last):
+    ...
+    ExactQuotientFailed: [[2], [2]] does not divide [[1], [1, 0], []]
+
+    """
+    q, r = dmp_pdiv(f, g, u, K)
+
+    if dmp_zero_p(r, u):
+        return q
+    else:
+        raise ExactQuotientFailed(f, g)
+
+
+def dup_rr_div(f, g, K):
+    """
+    Univariate division with remainder over a ring.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_rr_div(x**2 + 1, 2*x - 4)
+    (0, x**2 + 1)
+
+    """
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    q, r, dr = [], f, df
+
+    if not g:
+        raise ZeroDivisionError("polynomial division")
+    elif df < dg:
+        return q, r
+
+    lc_g = dup_LC(g, K)
+
+    while True:
+        lc_r = dup_LC(r, K)
+
+        if lc_r % lc_g:
+            break
+
+        c = K.exquo(lc_r, lc_g)
+        j = dr - dg
+
+        q = dup_add_term(q, c, j, K)
+        h = dup_mul_term(g, c, j, K)
+        r = dup_sub(r, h, K)
+
+        _dr, dr = dr, dup_degree(r)
+
+        if dr < dg:
+            break
+        elif not (dr < _dr):
+            raise PolynomialDivisionFailed(f, g, K)
+
+    return q, r
+
+
+def dmp_rr_div(f, g, u, K):
+    """
+    Multivariate division with remainder over a ring.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_rr_div(x**2 + x*y, 2*x + 2)
+    (0, x**2 + x*y)
+
+    """
+    if not u:
+        return dup_rr_div(f, g, K)
+
+    df = dmp_degree(f, u)
+    dg = dmp_degree(g, u)
+
+    if dg < 0:
+        raise ZeroDivisionError("polynomial division")
+
+    q, r, dr = dmp_zero(u), f, df
+
+    if df < dg:
+        return q, r
+
+    lc_g, v = dmp_LC(g, K), u - 1
+
+    while True:
+        lc_r = dmp_LC(r, K)
+        c, R = dmp_rr_div(lc_r, lc_g, v, K)
+
+        if not dmp_zero_p(R, v):
+            break
+
+        j = dr - dg
+
+        q = dmp_add_term(q, c, j, u, K)
+        h = dmp_mul_term(g, c, j, u, K)
+        r = dmp_sub(r, h, u, K)
+
+        _dr, dr = dr, dmp_degree(r, u)
+
+        if dr < dg:
+            break
+        elif not (dr < _dr):
+            raise PolynomialDivisionFailed(f, g, K)
+
+    return q, r
+
+
+def dup_ff_div(f, g, K):
+    """
+    Polynomial division with remainder over a field.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> R.dup_ff_div(x**2 + 1, 2*x - 4)
+    (1/2*x + 1, 5)
+
+    """
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    q, r, dr = [], f, df
+
+    if not g:
+        raise ZeroDivisionError("polynomial division")
+    elif df < dg:
+        return q, r
+
+    lc_g = dup_LC(g, K)
+
+    while True:
+        lc_r = dup_LC(r, K)
+
+        c = K.exquo(lc_r, lc_g)
+        j = dr - dg
+
+        q = dup_add_term(q, c, j, K)
+        h = dup_mul_term(g, c, j, K)
+        r = dup_sub(r, h, K)
+
+        _dr, dr = dr, dup_degree(r)
+
+        if dr < dg:
+            break
+        elif dr == _dr and not K.is_Exact:
+            # remove leading term created by rounding error
+            r = dup_strip(r[1:])
+            dr = dup_degree(r)
+            if dr < dg:
+                break
+        elif not (dr < _dr):
+            raise PolynomialDivisionFailed(f, g, K)
+
+    return q, r
+
+
+def dmp_ff_div(f, g, u, K):
+    """
+    Polynomial division with remainder over a field.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y = ring("x,y", QQ)
+
+    >>> R.dmp_ff_div(x**2 + x*y, 2*x + 2)
+    (1/2*x + 1/2*y - 1/2, -y + 1)
+
+    """
+    if not u:
+        return dup_ff_div(f, g, K)
+
+    df = dmp_degree(f, u)
+    dg = dmp_degree(g, u)
+
+    if dg < 0:
+        raise ZeroDivisionError("polynomial division")
+
+    q, r, dr = dmp_zero(u), f, df
+
+    if df < dg:
+        return q, r
+
+    lc_g, v = dmp_LC(g, K), u - 1
+
+    while True:
+        lc_r = dmp_LC(r, K)
+        c, R = dmp_ff_div(lc_r, lc_g, v, K)
+
+        if not dmp_zero_p(R, v):
+            break
+
+        j = dr - dg
+
+        q = dmp_add_term(q, c, j, u, K)
+        h = dmp_mul_term(g, c, j, u, K)
+        r = dmp_sub(r, h, u, K)
+
+        _dr, dr = dr, dmp_degree(r, u)
+
+        if dr < dg:
+            break
+        elif not (dr < _dr):
+            raise PolynomialDivisionFailed(f, g, K)
+
+    return q, r
+
+
+def dup_div(f, g, K):
+    """
+    Polynomial division with remainder in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x = ring("x", ZZ)
+    >>> R.dup_div(x**2 + 1, 2*x - 4)
+    (0, x**2 + 1)
+
+    >>> R, x = ring("x", QQ)
+    >>> R.dup_div(x**2 + 1, 2*x - 4)
+    (1/2*x + 1, 5)
+
+    """
+    if K.is_Field:
+        return dup_ff_div(f, g, K)
+    else:
+        return dup_rr_div(f, g, K)
+
+
+def dup_rem(f, g, K):
+    """
+    Returns polynomial remainder in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x = ring("x", ZZ)
+    >>> R.dup_rem(x**2 + 1, 2*x - 4)
+    x**2 + 1
+
+    >>> R, x = ring("x", QQ)
+    >>> R.dup_rem(x**2 + 1, 2*x - 4)
+    5
+
+    """
+    return dup_div(f, g, K)[1]
+
+
+def dup_quo(f, g, K):
+    """
+    Returns exact polynomial quotient in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x = ring("x", ZZ)
+    >>> R.dup_quo(x**2 + 1, 2*x - 4)
+    0
+
+    >>> R, x = ring("x", QQ)
+    >>> R.dup_quo(x**2 + 1, 2*x - 4)
+    1/2*x + 1
+
+    """
+    return dup_div(f, g, K)[0]
+
+
+def dup_exquo(f, g, K):
+    """
+    Returns polynomial quotient in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_exquo(x**2 - 1, x - 1)
+    x + 1
+
+    >>> R.dup_exquo(x**2 + 1, 2*x - 4)
+    Traceback (most recent call last):
+    ...
+    ExactQuotientFailed: [2, -4] does not divide [1, 0, 1]
+
+    """
+    q, r = dup_div(f, g, K)
+
+    if not r:
+        return q
+    else:
+        raise ExactQuotientFailed(f, g)
+
+
+def dmp_div(f, g, u, K):
+    """
+    Polynomial division with remainder in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x,y = ring("x,y", ZZ)
+    >>> R.dmp_div(x**2 + x*y, 2*x + 2)
+    (0, x**2 + x*y)
+
+    >>> R, x,y = ring("x,y", QQ)
+    >>> R.dmp_div(x**2 + x*y, 2*x + 2)
+    (1/2*x + 1/2*y - 1/2, -y + 1)
+
+    """
+    if K.is_Field:
+        return dmp_ff_div(f, g, u, K)
+    else:
+        return dmp_rr_div(f, g, u, K)
+
+
+def dmp_rem(f, g, u, K):
+    """
+    Returns polynomial remainder in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x,y = ring("x,y", ZZ)
+    >>> R.dmp_rem(x**2 + x*y, 2*x + 2)
+    x**2 + x*y
+
+    >>> R, x,y = ring("x,y", QQ)
+    >>> R.dmp_rem(x**2 + x*y, 2*x + 2)
+    -y + 1
+
+    """
+    return dmp_div(f, g, u, K)[1]
+
+
+def dmp_quo(f, g, u, K):
+    """
+    Returns exact polynomial quotient in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x,y = ring("x,y", ZZ)
+    >>> R.dmp_quo(x**2 + x*y, 2*x + 2)
+    0
+
+    >>> R, x,y = ring("x,y", QQ)
+    >>> R.dmp_quo(x**2 + x*y, 2*x + 2)
+    1/2*x + 1/2*y - 1/2
+
+    """
+    return dmp_div(f, g, u, K)[0]
+
+
+def dmp_exquo(f, g, u, K):
+    """
+    Returns polynomial quotient in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x**2 + x*y
+    >>> g = x + y
+    >>> h = 2*x + 2
+
+    >>> R.dmp_exquo(f, g)
+    x
+
+    >>> R.dmp_exquo(f, h)
+    Traceback (most recent call last):
+    ...
+    ExactQuotientFailed: [[2], [2]] does not divide [[1], [1, 0], []]
+
+    """
+    q, r = dmp_div(f, g, u, K)
+
+    if dmp_zero_p(r, u):
+        return q
+    else:
+        raise ExactQuotientFailed(f, g)
+
+
+def dup_max_norm(f, K):
+    """
+    Returns maximum norm of a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_max_norm(-x**2 + 2*x - 3)
+    3
+
+    """
+    if not f:
+        return K.zero
+    else:
+        return max(dup_abs(f, K))
+
+
+def dmp_max_norm(f, u, K):
+    """
+    Returns maximum norm of a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_max_norm(2*x*y - x - 3)
+    3
+
+    """
+    if not u:
+        return dup_max_norm(f, K)
+
+    v = u - 1
+
+    return max([ dmp_max_norm(c, v, K) for c in f ])
+
+
+def dup_l1_norm(f, K):
+    """
+    Returns l1 norm of a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_l1_norm(2*x**3 - 3*x**2 + 1)
+    6
+
+    """
+    if not f:
+        return K.zero
+    else:
+        return sum(dup_abs(f, K))
+
+
+def dmp_l1_norm(f, u, K):
+    """
+    Returns l1 norm of a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_l1_norm(2*x*y - x - 3)
+    6
+
+    """
+    if not u:
+        return dup_l1_norm(f, K)
+
+    v = u - 1
+
+    return sum([ dmp_l1_norm(c, v, K) for c in f ])
+
+
+def dup_l2_norm_squared(f, K):
+    """
+    Returns squared l2 norm of a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_l2_norm_squared(2*x**3 - 3*x**2 + 1)
+    14
+
+    """
+    return sum([coeff**2 for coeff in f], K.zero)
+
+
+def dmp_l2_norm_squared(f, u, K):
+    """
+    Returns squared l2 norm of a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_l2_norm_squared(2*x*y - x - 3)
+    14
+
+    """
+    if not u:
+        return dup_l2_norm_squared(f, K)
+
+    v = u - 1
+
+    return sum([ dmp_l2_norm_squared(c, v, K) for c in f ])
+
+
+def dup_expand(polys, K):
+    """
+    Multiply together several polynomials in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_expand([x**2 - 1, x, 2])
+    2*x**3 - 2*x
+
+    """
+    if not polys:
+        return [K.one]
+
+    f = polys[0]
+
+    for g in polys[1:]:
+        f = dup_mul(f, g, K)
+
+    return f
+
+
+def dmp_expand(polys, u, K):
+    """
+    Multiply together several polynomials in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_expand([x**2 + y**2, x + 1])
+    x**3 + x**2 + x*y**2 + y**2
+
+    """
+    if not polys:
+        return dmp_one(u, K)
+
+    f = polys[0]
+
+    for g in polys[1:]:
+        f = dmp_mul(f, g, u, K)
+
+    return f

llmeval-env/lib/python3.10/site-packages/sympy/polys/densebasic.py

@@ -0,0 +1,1881 @@
+"""Basic tools for dense recursive polynomials in ``K[x]`` or ``K[X]``. """
+
+
+from sympy.core.numbers import oo
+from sympy.core import igcd
+from sympy.polys.monomials import monomial_min, monomial_div
+from sympy.polys.orderings import monomial_key
+
+import random
+
+def poly_LC(f, K):
+    """
+    Return leading coefficient of ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import poly_LC
+
+    >>> poly_LC([], ZZ)
+    0
+    >>> poly_LC([ZZ(1), ZZ(2), ZZ(3)], ZZ)
+    1
+
+    """
+    if not f:
+        return K.zero
+    else:
+        return f[0]
+
+
+def poly_TC(f, K):
+    """
+    Return trailing coefficient of ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import poly_TC
+
+    >>> poly_TC([], ZZ)
+    0
+    >>> poly_TC([ZZ(1), ZZ(2), ZZ(3)], ZZ)
+    3
+
+    """
+    if not f:
+        return K.zero
+    else:
+        return f[-1]
+
+dup_LC = dmp_LC = poly_LC
+dup_TC = dmp_TC = poly_TC
+
+
+def dmp_ground_LC(f, u, K):
+    """
+    Return the ground leading coefficient.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_ground_LC
+
+    >>> f = ZZ.map([[[1], [2, 3]]])
+
+    >>> dmp_ground_LC(f, 2, ZZ)
+    1
+
+    """
+    while u:
+        f = dmp_LC(f, K)
+        u -= 1
+
+    return dup_LC(f, K)
+
+
+def dmp_ground_TC(f, u, K):
+    """
+    Return the ground trailing coefficient.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_ground_TC
+
+    >>> f = ZZ.map([[[1], [2, 3]]])
+
+    >>> dmp_ground_TC(f, 2, ZZ)
+    3
+
+    """
+    while u:
+        f = dmp_TC(f, K)
+        u -= 1
+
+    return dup_TC(f, K)
+
+
+def dmp_true_LT(f, u, K):
+    """
+    Return the leading term ``c * x_1**n_1 ... x_k**n_k``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_true_LT
+
+    >>> f = ZZ.map([[4], [2, 0], [3, 0, 0]])
+
+    >>> dmp_true_LT(f, 1, ZZ)
+    ((2, 0), 4)
+
+    """
+    monom = []
+
+    while u:
+        monom.append(len(f) - 1)
+        f, u = f[0], u - 1
+
+    if not f:
+        monom.append(0)
+    else:
+        monom.append(len(f) - 1)
+
+    return tuple(monom), dup_LC(f, K)
+
+
+def dup_degree(f):
+    """
+    Return the leading degree of ``f`` in ``K[x]``.
+
+    Note that the degree of 0 is negative infinity (the SymPy object -oo).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_degree
+
+    >>> f = ZZ.map([1, 2, 0, 3])
+
+    >>> dup_degree(f)
+    3
+
+    """
+    if not f:
+        return -oo
+    return len(f) - 1
+
+
+def dmp_degree(f, u):
+    """
+    Return the leading degree of ``f`` in ``x_0`` in ``K[X]``.
+
+    Note that the degree of 0 is negative infinity (the SymPy object -oo).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_degree
+
+    >>> dmp_degree([[[]]], 2)
+    -oo
+
+    >>> f = ZZ.map([[2], [1, 2, 3]])
+
+    >>> dmp_degree(f, 1)
+    1
+
+    """
+    if dmp_zero_p(f, u):
+        return -oo
+    else:
+        return len(f) - 1
+
+
+def _rec_degree_in(g, v, i, j):
+    """Recursive helper function for :func:`dmp_degree_in`."""
+    if i == j:
+        return dmp_degree(g, v)
+
+    v, i = v - 1, i + 1
+
+    return max([ _rec_degree_in(c, v, i, j) for c in g ])
+
+
+def dmp_degree_in(f, j, u):
+    """
+    Return the leading degree of ``f`` in ``x_j`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_degree_in
+
+    >>> f = ZZ.map([[2], [1, 2, 3]])
+
+    >>> dmp_degree_in(f, 0, 1)
+    1
+    >>> dmp_degree_in(f, 1, 1)
+    2
+
+    """
+    if not j:
+        return dmp_degree(f, u)
+    if j < 0 or j > u:
+        raise IndexError("0 <= j <= %s expected, got %s" % (u, j))
+
+    return _rec_degree_in(f, u, 0, j)
+
+
+def _rec_degree_list(g, v, i, degs):
+    """Recursive helper for :func:`dmp_degree_list`."""
+    degs[i] = max(degs[i], dmp_degree(g, v))
+
+    if v > 0:
+        v, i = v - 1, i + 1
+
+        for c in g:
+            _rec_degree_list(c, v, i, degs)
+
+
+def dmp_degree_list(f, u):
+    """
+    Return a list of degrees of ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_degree_list
+
+    >>> f = ZZ.map([[1], [1, 2, 3]])
+
+    >>> dmp_degree_list(f, 1)
+    (1, 2)
+
+    """
+    degs = [-oo]*(u + 1)
+    _rec_degree_list(f, u, 0, degs)
+    return tuple(degs)
+
+
+def dup_strip(f):
+    """
+    Remove leading zeros from ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dup_strip
+
+    >>> dup_strip([0, 0, 1, 2, 3, 0])
+    [1, 2, 3, 0]
+
+    """
+    if not f or f[0]:
+        return f
+
+    i = 0
+
+    for cf in f:
+        if cf:
+            break
+        else:
+            i += 1
+
+    return f[i:]
+
+
+def dmp_strip(f, u):
+    """
+    Remove leading zeros from ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_strip
+
+    >>> dmp_strip([[], [0, 1, 2], [1]], 1)
+    [[0, 1, 2], [1]]
+
+    """
+    if not u:
+        return dup_strip(f)
+
+    if dmp_zero_p(f, u):
+        return f
+
+    i, v = 0, u - 1
+
+    for c in f:
+        if not dmp_zero_p(c, v):
+            break
+        else:
+            i += 1
+
+    if i == len(f):
+        return dmp_zero(u)
+    else:
+        return f[i:]
+
+
+def _rec_validate(f, g, i, K):
+    """Recursive helper for :func:`dmp_validate`."""
+    if not isinstance(g, list):
+        if K is not None and not K.of_type(g):
+            raise TypeError("%s in %s in not of type %s" % (g, f, K.dtype))
+
+        return {i - 1}
+    elif not g:
+        return {i}
+    else:
+        levels = set()
+
+        for c in g:
+            levels |= _rec_validate(f, c, i + 1, K)
+
+        return levels
+
+
+def _rec_strip(g, v):
+    """Recursive helper for :func:`_rec_strip`."""
+    if not v:
+        return dup_strip(g)
+
+    w = v - 1
+
+    return dmp_strip([ _rec_strip(c, w) for c in g ], v)
+
+
+def dmp_validate(f, K=None):
+    """
+    Return the number of levels in ``f`` and recursively strip it.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_validate
+
+    >>> dmp_validate([[], [0, 1, 2], [1]])
+    ([[1, 2], [1]], 1)
+
+    >>> dmp_validate([[1], 1])
+    Traceback (most recent call last):
+    ...
+    ValueError: invalid data structure for a multivariate polynomial
+
+    """
+    levels = _rec_validate(f, f, 0, K)
+
+    u = levels.pop()
+
+    if not levels:
+        return _rec_strip(f, u), u
+    else:
+        raise ValueError(
+            "invalid data structure for a multivariate polynomial")
+
+
+def dup_reverse(f):
+    """
+    Compute ``x**n * f(1/x)``, i.e.: reverse ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_reverse
+
+    >>> f = ZZ.map([1, 2, 3, 0])
+
+    >>> dup_reverse(f)
+    [3, 2, 1]
+
+    """
+    return dup_strip(list(reversed(f)))
+
+
+def dup_copy(f):
+    """
+    Create a new copy of a polynomial ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_copy
+
+    >>> f = ZZ.map([1, 2, 3, 0])
+
+    >>> dup_copy([1, 2, 3, 0])
+    [1, 2, 3, 0]
+
+    """
+    return list(f)
+
+
+def dmp_copy(f, u):
+    """
+    Create a new copy of a polynomial ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_copy
+
+    >>> f = ZZ.map([[1], [1, 2]])
+
+    >>> dmp_copy(f, 1)
+    [[1], [1, 2]]
+
+    """
+    if not u:
+        return list(f)
+
+    v = u - 1
+
+    return [ dmp_copy(c, v) for c in f ]
+
+
+def dup_to_tuple(f):
+    """
+    Convert `f` into a tuple.
+
+    This is needed for hashing. This is similar to dup_copy().
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_copy
+
+    >>> f = ZZ.map([1, 2, 3, 0])
+
+    >>> dup_copy([1, 2, 3, 0])
+    [1, 2, 3, 0]
+
+    """
+    return tuple(f)
+
+
+def dmp_to_tuple(f, u):
+    """
+    Convert `f` into a nested tuple of tuples.
+
+    This is needed for hashing.  This is similar to dmp_copy().
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_to_tuple
+
+    >>> f = ZZ.map([[1], [1, 2]])
+
+    >>> dmp_to_tuple(f, 1)
+    ((1,), (1, 2))
+
+    """
+    if not u:
+        return tuple(f)
+    v = u - 1
+
+    return tuple(dmp_to_tuple(c, v) for c in f)
+
+
+def dup_normal(f, K):
+    """
+    Normalize univariate polynomial in the given domain.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_normal
+
+    >>> dup_normal([0, 1.5, 2, 3], ZZ)
+    [1, 2, 3]
+
+    """
+    return dup_strip([ K.normal(c) for c in f ])
+
+
+def dmp_normal(f, u, K):
+    """
+    Normalize a multivariate polynomial in the given domain.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_normal
+
+    >>> dmp_normal([[], [0, 1.5, 2]], 1, ZZ)
+    [[1, 2]]
+
+    """
+    if not u:
+        return dup_normal(f, K)
+
+    v = u - 1
+
+    return dmp_strip([ dmp_normal(c, v, K) for c in f ], u)
+
+
+def dup_convert(f, K0, K1):
+    """
+    Convert the ground domain of ``f`` from ``K0`` to ``K1``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import ring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_convert
+
+    >>> R, x = ring("x", ZZ)
+
+    >>> dup_convert([R(1), R(2)], R.to_domain(), ZZ)
+    [1, 2]
+    >>> dup_convert([ZZ(1), ZZ(2)], ZZ, R.to_domain())
+    [1, 2]
+
+    """
+    if K0 is not None and K0 == K1:
+        return f
+    else:
+        return dup_strip([ K1.convert(c, K0) for c in f ])
+
+
+def dmp_convert(f, u, K0, K1):
+    """
+    Convert the ground domain of ``f`` from ``K0`` to ``K1``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import ring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_convert
+
+    >>> R, x = ring("x", ZZ)
+
+    >>> dmp_convert([[R(1)], [R(2)]], 1, R.to_domain(), ZZ)
+    [[1], [2]]
+    >>> dmp_convert([[ZZ(1)], [ZZ(2)]], 1, ZZ, R.to_domain())
+    [[1], [2]]
+
+    """
+    if not u:
+        return dup_convert(f, K0, K1)
+    if K0 is not None and K0 == K1:
+        return f
+
+    v = u - 1
+
+    return dmp_strip([ dmp_convert(c, v, K0, K1) for c in f ], u)
+
+
+def dup_from_sympy(f, K):
+    """
+    Convert the ground domain of ``f`` from SymPy to ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_from_sympy
+
+    >>> dup_from_sympy([S(1), S(2)], ZZ) == [ZZ(1), ZZ(2)]
+    True
+
+    """
+    return dup_strip([ K.from_sympy(c) for c in f ])
+
+
+def dmp_from_sympy(f, u, K):
+    """
+    Convert the ground domain of ``f`` from SymPy to ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_from_sympy
+
+    >>> dmp_from_sympy([[S(1)], [S(2)]], 1, ZZ) == [[ZZ(1)], [ZZ(2)]]
+    True
+
+    """
+    if not u:
+        return dup_from_sympy(f, K)
+
+    v = u - 1
+
+    return dmp_strip([ dmp_from_sympy(c, v, K) for c in f ], u)
+
+
+def dup_nth(f, n, K):
+    """
+    Return the ``n``-th coefficient of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_nth
+
+    >>> f = ZZ.map([1, 2, 3])
+
+    >>> dup_nth(f, 0, ZZ)
+    3
+    >>> dup_nth(f, 4, ZZ)
+    0
+
+    """
+    if n < 0:
+        raise IndexError("'n' must be non-negative, got %i" % n)
+    elif n >= len(f):
+        return K.zero
+    else:
+        return f[dup_degree(f) - n]
+
+
+def dmp_nth(f, n, u, K):
+    """
+    Return the ``n``-th coefficient of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_nth
+
+    >>> f = ZZ.map([[1], [2], [3]])
+
+    >>> dmp_nth(f, 0, 1, ZZ)
+    [3]
+    >>> dmp_nth(f, 4, 1, ZZ)
+    []
+
+    """
+    if n < 0:
+        raise IndexError("'n' must be non-negative, got %i" % n)
+    elif n >= len(f):
+        return dmp_zero(u - 1)
+    else:
+        return f[dmp_degree(f, u) - n]
+
+
+def dmp_ground_nth(f, N, u, K):
+    """
+    Return the ground ``n``-th coefficient of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_ground_nth
+
+    >>> f = ZZ.map([[1], [2, 3]])
+
+    >>> dmp_ground_nth(f, (0, 1), 1, ZZ)
+    2
+
+    """
+    v = u
+
+    for n in N:
+        if n < 0:
+            raise IndexError("`n` must be non-negative, got %i" % n)
+        elif n >= len(f):
+            return K.zero
+        else:
+            d = dmp_degree(f, v)
+            if d == -oo:
+                d = -1
+            f, v = f[d - n], v - 1
+
+    return f
+
+
+def dmp_zero_p(f, u):
+    """
+    Return ``True`` if ``f`` is zero in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_zero_p
+
+    >>> dmp_zero_p([[[[[]]]]], 4)
+    True
+    >>> dmp_zero_p([[[[[1]]]]], 4)
+    False
+
+    """
+    while u:
+        if len(f) != 1:
+            return False
+
+        f = f[0]
+        u -= 1
+
+    return not f
+
+
+def dmp_zero(u):
+    """
+    Return a multivariate zero.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_zero
+
+    >>> dmp_zero(4)
+    [[[[[]]]]]
+
+    """
+    r = []
+
+    for i in range(u):
+        r = [r]
+
+    return r
+
+
+def dmp_one_p(f, u, K):
+    """
+    Return ``True`` if ``f`` is one in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_one_p
+
+    >>> dmp_one_p([[[ZZ(1)]]], 2, ZZ)
+    True
+
+    """
+    return dmp_ground_p(f, K.one, u)
+
+
+def dmp_one(u, K):
+    """
+    Return a multivariate one over ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_one
+
+    >>> dmp_one(2, ZZ)
+    [[[1]]]
+
+    """
+    return dmp_ground(K.one, u)
+
+
+def dmp_ground_p(f, c, u):
+    """
+    Return True if ``f`` is constant in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_ground_p
+
+    >>> dmp_ground_p([[[3]]], 3, 2)
+    True
+    >>> dmp_ground_p([[[4]]], None, 2)
+    True
+
+    """
+    if c is not None and not c:
+        return dmp_zero_p(f, u)
+
+    while u:
+        if len(f) != 1:
+            return False
+        f = f[0]
+        u -= 1
+
+    if c is None:
+        return len(f) <= 1
+    else:
+        return f == [c]
+
+
+def dmp_ground(c, u):
+    """
+    Return a multivariate constant.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_ground
+
+    >>> dmp_ground(3, 5)
+    [[[[[[3]]]]]]
+    >>> dmp_ground(1, -1)
+    1
+
+    """
+    if not c:
+        return dmp_zero(u)
+
+    for i in range(u + 1):
+        c = [c]
+
+    return c
+
+
+def dmp_zeros(n, u, K):
+    """
+    Return a list of multivariate zeros.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_zeros
+
+    >>> dmp_zeros(3, 2, ZZ)
+    [[[[]]], [[[]]], [[[]]]]
+    >>> dmp_zeros(3, -1, ZZ)
+    [0, 0, 0]
+
+    """
+    if not n:
+        return []
+
+    if u < 0:
+        return [K.zero]*n
+    else:
+        return [ dmp_zero(u) for i in range(n) ]
+
+
+def dmp_grounds(c, n, u):
+    """
+    Return a list of multivariate constants.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_grounds
+
+    >>> dmp_grounds(ZZ(4), 3, 2)
+    [[[[4]]], [[[4]]], [[[4]]]]
+    >>> dmp_grounds(ZZ(4), 3, -1)
+    [4, 4, 4]
+
+    """
+    if not n:
+        return []
+
+    if u < 0:
+        return [c]*n
+    else:
+        return [ dmp_ground(c, u) for i in range(n) ]
+
+
+def dmp_negative_p(f, u, K):
+    """
+    Return ``True`` if ``LC(f)`` is negative.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_negative_p
+
+    >>> dmp_negative_p([[ZZ(1)], [-ZZ(1)]], 1, ZZ)
+    False
+    >>> dmp_negative_p([[-ZZ(1)], [ZZ(1)]], 1, ZZ)
+    True
+
+    """
+    return K.is_negative(dmp_ground_LC(f, u, K))
+
+
+def dmp_positive_p(f, u, K):
+    """
+    Return ``True`` if ``LC(f)`` is positive.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_positive_p
+
+    >>> dmp_positive_p([[ZZ(1)], [-ZZ(1)]], 1, ZZ)
+    True
+    >>> dmp_positive_p([[-ZZ(1)], [ZZ(1)]], 1, ZZ)
+    False
+
+    """
+    return K.is_positive(dmp_ground_LC(f, u, K))
+
+
+def dup_from_dict(f, K):
+    """
+    Create a ``K[x]`` polynomial from a ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_from_dict
+
+    >>> dup_from_dict({(0,): ZZ(7), (2,): ZZ(5), (4,): ZZ(1)}, ZZ)
+    [1, 0, 5, 0, 7]
+    >>> dup_from_dict({}, ZZ)
+    []
+
+    """
+    if not f:
+        return []
+
+    n, h = max(f.keys()), []
+
+    if isinstance(n, int):
+        for k in range(n, -1, -1):
+            h.append(f.get(k, K.zero))
+    else:
+        (n,) = n
+
+        for k in range(n, -1, -1):
+            h.append(f.get((k,), K.zero))
+
+    return dup_strip(h)
+
+
+def dup_from_raw_dict(f, K):
+    """
+    Create a ``K[x]`` polynomial from a raw ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_from_raw_dict
+
+    >>> dup_from_raw_dict({0: ZZ(7), 2: ZZ(5), 4: ZZ(1)}, ZZ)
+    [1, 0, 5, 0, 7]
+
+    """
+    if not f:
+        return []
+
+    n, h = max(f.keys()), []
+
+    for k in range(n, -1, -1):
+        h.append(f.get(k, K.zero))
+
+    return dup_strip(h)
+
+
+def dmp_from_dict(f, u, K):
+    """
+    Create a ``K[X]`` polynomial from a ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_from_dict
+
+    >>> dmp_from_dict({(0, 0): ZZ(3), (0, 1): ZZ(2), (2, 1): ZZ(1)}, 1, ZZ)
+    [[1, 0], [], [2, 3]]
+    >>> dmp_from_dict({}, 0, ZZ)
+    []
+
+    """
+    if not u:
+        return dup_from_dict(f, K)
+    if not f:
+        return dmp_zero(u)
+
+    coeffs = {}
+
+    for monom, coeff in f.items():
+        head, tail = monom[0], monom[1:]
+
+        if head in coeffs:
+            coeffs[head][tail] = coeff
+        else:
+            coeffs[head] = { tail: coeff }
+
+    n, v, h = max(coeffs.keys()), u - 1, []
+
+    for k in range(n, -1, -1):
+        coeff = coeffs.get(k)
+
+        if coeff is not None:
+            h.append(dmp_from_dict(coeff, v, K))
+        else:
+            h.append(dmp_zero(v))
+
+    return dmp_strip(h, u)
+
+
+def dup_to_dict(f, K=None, zero=False):
+    """
+    Convert ``K[x]`` polynomial to a ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dup_to_dict
+
+    >>> dup_to_dict([1, 0, 5, 0, 7])
+    {(0,): 7, (2,): 5, (4,): 1}
+    >>> dup_to_dict([])
+    {}
+
+    """
+    if not f and zero:
+        return {(0,): K.zero}
+
+    n, result = len(f) - 1, {}
+
+    for k in range(0, n + 1):
+        if f[n - k]:
+            result[(k,)] = f[n - k]
+
+    return result
+
+
+def dup_to_raw_dict(f, K=None, zero=False):
+    """
+    Convert a ``K[x]`` polynomial to a raw ``dict``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dup_to_raw_dict
+
+    >>> dup_to_raw_dict([1, 0, 5, 0, 7])
+    {0: 7, 2: 5, 4: 1}
+
+    """
+    if not f and zero:
+        return {0: K.zero}
+
+    n, result = len(f) - 1, {}
+
+    for k in range(0, n + 1):
+        if f[n - k]:
+            result[k] = f[n - k]
+
+    return result
+
+
+def dmp_to_dict(f, u, K=None, zero=False):
+    """
+    Convert a ``K[X]`` polynomial to a ``dict````.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.densebasic import dmp_to_dict
+
+    >>> dmp_to_dict([[1, 0], [], [2, 3]], 1)
+    {(0, 0): 3, (0, 1): 2, (2, 1): 1}
+    >>> dmp_to_dict([], 0)
+    {}
+
+    """
+    if not u:
+        return dup_to_dict(f, K, zero=zero)
+
+    if dmp_zero_p(f, u) and zero:
+        return {(0,)*(u + 1): K.zero}
+
+    n, v, result = dmp_degree(f, u), u - 1, {}
+
+    if n == -oo:
+        n = -1
+
+    for k in range(0, n + 1):
+        h = dmp_to_dict(f[n - k], v)
+
+        for exp, coeff in h.items():
+            result[(k,) + exp] = coeff
+
+    return result
+
+
+def dmp_swap(f, i, j, u, K):
+    """
+    Transform ``K[..x_i..x_j..]`` to ``K[..x_j..x_i..]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_swap
+
+    >>> f = ZZ.map([[[2], [1, 0]], []])
+
+    >>> dmp_swap(f, 0, 1, 2, ZZ)
+    [[[2], []], [[1, 0], []]]
+    >>> dmp_swap(f, 1, 2, 2, ZZ)
+    [[[1], [2, 0]], [[]]]
+    >>> dmp_swap(f, 0, 2, 2, ZZ)
+    [[[1, 0]], [[2, 0], []]]
+
+    """
+    if i < 0 or j < 0 or i > u or j > u:
+        raise IndexError("0 <= i < j <= %s expected" % u)
+    elif i == j:
+        return f
+
+    F, H = dmp_to_dict(f, u), {}
+
+    for exp, coeff in F.items():
+        H[exp[:i] + (exp[j],) +
+          exp[i + 1:j] +
+          (exp[i],) + exp[j + 1:]] = coeff
+
+    return dmp_from_dict(H, u, K)
+
+
+def dmp_permute(f, P, u, K):
+    """
+    Return a polynomial in ``K[x_{P(1)},..,x_{P(n)}]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_permute
+
+    >>> f = ZZ.map([[[2], [1, 0]], []])
+
+    >>> dmp_permute(f, [1, 0, 2], 2, ZZ)
+    [[[2], []], [[1, 0], []]]
+    >>> dmp_permute(f, [1, 2, 0], 2, ZZ)
+    [[[1], []], [[2, 0], []]]
+
+    """
+    F, H = dmp_to_dict(f, u), {}
+
+    for exp, coeff in F.items():
+        new_exp = [0]*len(exp)
+
+        for e, p in zip(exp, P):
+            new_exp[p] = e
+
+        H[tuple(new_exp)] = coeff
+
+    return dmp_from_dict(H, u, K)
+
+
+def dmp_nest(f, l, K):
+    """
+    Return a multivariate value nested ``l``-levels.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_nest
+
+    >>> dmp_nest([[ZZ(1)]], 2, ZZ)
+    [[[[1]]]]
+
+    """
+    if not isinstance(f, list):
+        return dmp_ground(f, l)
+
+    for i in range(l):
+        f = [f]
+
+    return f
+
+
+def dmp_raise(f, l, u, K):
+    """
+    Return a multivariate polynomial raised ``l``-levels.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_raise
+
+    >>> f = ZZ.map([[], [1, 2]])
+
+    >>> dmp_raise(f, 2, 1, ZZ)
+    [[[[]]], [[[1]], [[2]]]]
+
+    """
+    if not l:
+        return f
+
+    if not u:
+        if not f:
+            return dmp_zero(l)
+
+        k = l - 1
+
+        return [ dmp_ground(c, k) for c in f ]
+
+    v = u - 1
+
+    return [ dmp_raise(c, l, v, K) for c in f ]
+
+
+def dup_deflate(f, K):
+    """
+    Map ``x**m`` to ``y`` in a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_deflate
+
+    >>> f = ZZ.map([1, 0, 0, 1, 0, 0, 1])
+
+    >>> dup_deflate(f, ZZ)
+    (3, [1, 1, 1])
+
+    """
+    if dup_degree(f) <= 0:
+        return 1, f
+
+    g = 0
+
+    for i in range(len(f)):
+        if not f[-i - 1]:
+            continue
+
+        g = igcd(g, i)
+
+        if g == 1:
+            return 1, f
+
+    return g, f[::g]
+
+
+def dmp_deflate(f, u, K):
+    """
+    Map ``x_i**m_i`` to ``y_i`` in a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_deflate
+
+    >>> f = ZZ.map([[1, 0, 0, 2], [], [3, 0, 0, 4]])
+
+    >>> dmp_deflate(f, 1, ZZ)
+    ((2, 3), [[1, 2], [3, 4]])
+
+    """
+    if dmp_zero_p(f, u):
+        return (1,)*(u + 1), f
+
+    F = dmp_to_dict(f, u)
+    B = [0]*(u + 1)
+
+    for M in F.keys():
+        for i, m in enumerate(M):
+            B[i] = igcd(B[i], m)
+
+    for i, b in enumerate(B):
+        if not b:
+            B[i] = 1
+
+    B = tuple(B)
+
+    if all(b == 1 for b in B):
+        return B, f
+
+    H = {}
+
+    for A, coeff in F.items():
+        N = [ a // b for a, b in zip(A, B) ]
+        H[tuple(N)] = coeff
+
+    return B, dmp_from_dict(H, u, K)
+
+
+def dup_multi_deflate(polys, K):
+    """
+    Map ``x**m`` to ``y`` in a set of polynomials in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_multi_deflate
+
+    >>> f = ZZ.map([1, 0, 2, 0, 3])
+    >>> g = ZZ.map([4, 0, 0])
+
+    >>> dup_multi_deflate((f, g), ZZ)
+    (2, ([1, 2, 3], [4, 0]))
+
+    """
+    G = 0
+
+    for p in polys:
+        if dup_degree(p) <= 0:
+            return 1, polys
+
+        g = 0
+
+        for i in range(len(p)):
+            if not p[-i - 1]:
+                continue
+
+            g = igcd(g, i)
+
+            if g == 1:
+                return 1, polys
+
+        G = igcd(G, g)
+
+    return G, tuple([ p[::G] for p in polys ])
+
+
+def dmp_multi_deflate(polys, u, K):
+    """
+    Map ``x_i**m_i`` to ``y_i`` in a set of polynomials in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_multi_deflate
+
+    >>> f = ZZ.map([[1, 0, 0, 2], [], [3, 0, 0, 4]])
+    >>> g = ZZ.map([[1, 0, 2], [], [3, 0, 4]])
+
+    >>> dmp_multi_deflate((f, g), 1, ZZ)
+    ((2, 1), ([[1, 0, 0, 2], [3, 0, 0, 4]], [[1, 0, 2], [3, 0, 4]]))
+
+    """
+    if not u:
+        M, H = dup_multi_deflate(polys, K)
+        return (M,), H
+
+    F, B = [], [0]*(u + 1)
+
+    for p in polys:
+        f = dmp_to_dict(p, u)
+
+        if not dmp_zero_p(p, u):
+            for M in f.keys():
+                for i, m in enumerate(M):
+                    B[i] = igcd(B[i], m)
+
+        F.append(f)
+
+    for i, b in enumerate(B):
+        if not b:
+            B[i] = 1
+
+    B = tuple(B)
+
+    if all(b == 1 for b in B):
+        return B, polys
+
+    H = []
+
+    for f in F:
+        h = {}
+
+        for A, coeff in f.items():
+            N = [ a // b for a, b in zip(A, B) ]
+            h[tuple(N)] = coeff
+
+        H.append(dmp_from_dict(h, u, K))
+
+    return B, tuple(H)
+
+
+def dup_inflate(f, m, K):
+    """
+    Map ``y`` to ``x**m`` in a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_inflate
+
+    >>> f = ZZ.map([1, 1, 1])
+
+    >>> dup_inflate(f, 3, ZZ)
+    [1, 0, 0, 1, 0, 0, 1]
+
+    """
+    if m <= 0:
+        raise IndexError("'m' must be positive, got %s" % m)
+    if m == 1 or not f:
+        return f
+
+    result = [f[0]]
+
+    for coeff in f[1:]:
+        result.extend([K.zero]*(m - 1))
+        result.append(coeff)
+
+    return result
+
+
+def _rec_inflate(g, M, v, i, K):
+    """Recursive helper for :func:`dmp_inflate`."""
+    if not v:
+        return dup_inflate(g, M[i], K)
+    if M[i] <= 0:
+        raise IndexError("all M[i] must be positive, got %s" % M[i])
+
+    w, j = v - 1, i + 1
+
+    g = [ _rec_inflate(c, M, w, j, K) for c in g ]
+
+    result = [g[0]]
+
+    for coeff in g[1:]:
+        for _ in range(1, M[i]):
+            result.append(dmp_zero(w))
+
+        result.append(coeff)
+
+    return result
+
+
+def dmp_inflate(f, M, u, K):
+    """
+    Map ``y_i`` to ``x_i**k_i`` in a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_inflate
+
+    >>> f = ZZ.map([[1, 2], [3, 4]])
+
+    >>> dmp_inflate(f, (2, 3), 1, ZZ)
+    [[1, 0, 0, 2], [], [3, 0, 0, 4]]
+
+    """
+    if not u:
+        return dup_inflate(f, M[0], K)
+
+    if all(m == 1 for m in M):
+        return f
+    else:
+        return _rec_inflate(f, M, u, 0, K)
+
+
+def dmp_exclude(f, u, K):
+    """
+    Exclude useless levels from ``f``.
+
+    Return the levels excluded, the new excluded ``f``, and the new ``u``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_exclude
+
+    >>> f = ZZ.map([[[1]], [[1], [2]]])
+
+    >>> dmp_exclude(f, 2, ZZ)
+    ([2], [[1], [1, 2]], 1)
+
+    """
+    if not u or dmp_ground_p(f, None, u):
+        return [], f, u
+
+    J, F = [], dmp_to_dict(f, u)
+
+    for j in range(0, u + 1):
+        for monom in F.keys():
+            if monom[j]:
+                break
+        else:
+            J.append(j)
+
+    if not J:
+        return [], f, u
+
+    f = {}
+
+    for monom, coeff in F.items():
+        monom = list(monom)
+
+        for j in reversed(J):
+            del monom[j]
+
+        f[tuple(monom)] = coeff
+
+    u -= len(J)
+
+    return J, dmp_from_dict(f, u, K), u
+
+
+def dmp_include(f, J, u, K):
+    """
+    Include useless levels in ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_include
+
+    >>> f = ZZ.map([[1], [1, 2]])
+
+    >>> dmp_include(f, [2], 1, ZZ)
+    [[[1]], [[1], [2]]]
+
+    """
+    if not J:
+        return f
+
+    F, f = dmp_to_dict(f, u), {}
+
+    for monom, coeff in F.items():
+        monom = list(monom)
+
+        for j in J:
+            monom.insert(j, 0)
+
+        f[tuple(monom)] = coeff
+
+    u += len(J)
+
+    return dmp_from_dict(f, u, K)
+
+
+def dmp_inject(f, u, K, front=False):
+    """
+    Convert ``f`` from ``K[X][Y]`` to ``K[X,Y]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.rings import ring
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_inject
+
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> dmp_inject([R(1), x + 2], 0, R.to_domain())
+    ([[[1]], [[1], [2]]], 2)
+    >>> dmp_inject([R(1), x + 2], 0, R.to_domain(), front=True)
+    ([[[1]], [[1, 2]]], 2)
+
+    """
+    f, h = dmp_to_dict(f, u), {}
+
+    v = K.ngens - 1
+
+    for f_monom, g in f.items():
+        g = g.to_dict()
+
+        for g_monom, c in g.items():
+            if front:
+                h[g_monom + f_monom] = c
+            else:
+                h[f_monom + g_monom] = c
+
+    w = u + v + 1
+
+    return dmp_from_dict(h, w, K.dom), w
+
+
+def dmp_eject(f, u, K, front=False):
+    """
+    Convert ``f`` from ``K[X,Y]`` to ``K[X][Y]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_eject
+
+    >>> dmp_eject([[[1]], [[1], [2]]], 2, ZZ['x', 'y'])
+    [1, x + 2]
+
+    """
+    f, h = dmp_to_dict(f, u), {}
+
+    n = K.ngens
+    v = u - K.ngens + 1
+
+    for monom, c in f.items():
+        if front:
+            g_monom, f_monom = monom[:n], monom[n:]
+        else:
+            g_monom, f_monom = monom[-n:], monom[:-n]
+
+        if f_monom in h:
+            h[f_monom][g_monom] = c
+        else:
+            h[f_monom] = {g_monom: c}
+
+    for monom, c in h.items():
+        h[monom] = K(c)
+
+    return dmp_from_dict(h, v - 1, K)
+
+
+def dup_terms_gcd(f, K):
+    """
+    Remove GCD of terms from ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_terms_gcd
+
+    >>> f = ZZ.map([1, 0, 1, 0, 0])
+
+    >>> dup_terms_gcd(f, ZZ)
+    (2, [1, 0, 1])
+
+    """
+    if dup_TC(f, K) or not f:
+        return 0, f
+
+    i = 0
+
+    for c in reversed(f):
+        if not c:
+            i += 1
+        else:
+            break
+
+    return i, f[:-i]
+
+
+def dmp_terms_gcd(f, u, K):
+    """
+    Remove GCD of terms from ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_terms_gcd
+
+    >>> f = ZZ.map([[1, 0], [1, 0, 0], [], []])
+
+    >>> dmp_terms_gcd(f, 1, ZZ)
+    ((2, 1), [[1], [1, 0]])
+
+    """
+    if dmp_ground_TC(f, u, K) or dmp_zero_p(f, u):
+        return (0,)*(u + 1), f
+
+    F = dmp_to_dict(f, u)
+    G = monomial_min(*list(F.keys()))
+
+    if all(g == 0 for g in G):
+        return G, f
+
+    f = {}
+
+    for monom, coeff in F.items():
+        f[monomial_div(monom, G)] = coeff
+
+    return G, dmp_from_dict(f, u, K)
+
+
+def _rec_list_terms(g, v, monom):
+    """Recursive helper for :func:`dmp_list_terms`."""
+    d, terms = dmp_degree(g, v), []
+
+    if not v:
+        for i, c in enumerate(g):
+            if not c:
+                continue
+
+            terms.append((monom + (d - i,), c))
+    else:
+        w = v - 1
+
+        for i, c in enumerate(g):
+            terms.extend(_rec_list_terms(c, w, monom + (d - i,)))
+
+    return terms
+
+
+def dmp_list_terms(f, u, K, order=None):
+    """
+    List all non-zero terms from ``f`` in the given order ``order``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_list_terms
+
+    >>> f = ZZ.map([[1, 1], [2, 3]])
+
+    >>> dmp_list_terms(f, 1, ZZ)
+    [((1, 1), 1), ((1, 0), 1), ((0, 1), 2), ((0, 0), 3)]
+    >>> dmp_list_terms(f, 1, ZZ, order='grevlex')
+    [((1, 1), 1), ((1, 0), 1), ((0, 1), 2), ((0, 0), 3)]
+
+    """
+    def sort(terms, O):
+        return sorted(terms, key=lambda term: O(term[0]), reverse=True)
+
+    terms = _rec_list_terms(f, u, ())
+
+    if not terms:
+        return [((0,)*(u + 1), K.zero)]
+
+    if order is None:
+        return terms
+    else:
+        return sort(terms, monomial_key(order))
+
+
+def dup_apply_pairs(f, g, h, args, K):
+    """
+    Apply ``h`` to pairs of coefficients of ``f`` and ``g``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_apply_pairs
+
+    >>> h = lambda x, y, z: 2*x + y - z
+
+    >>> dup_apply_pairs([1, 2, 3], [3, 2, 1], h, (1,), ZZ)
+    [4, 5, 6]
+
+    """
+    n, m = len(f), len(g)
+
+    if n != m:
+        if n > m:
+            g = [K.zero]*(n - m) + g
+        else:
+            f = [K.zero]*(m - n) + f
+
+    result = []
+
+    for a, b in zip(f, g):
+        result.append(h(a, b, *args))
+
+    return dup_strip(result)
+
+
+def dmp_apply_pairs(f, g, h, args, u, K):
+    """
+    Apply ``h`` to pairs of coefficients of ``f`` and ``g``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dmp_apply_pairs
+
+    >>> h = lambda x, y, z: 2*x + y - z
+
+    >>> dmp_apply_pairs([[1], [2, 3]], [[3], [2, 1]], h, (1,), 1, ZZ)
+    [[4], [5, 6]]
+
+    """
+    if not u:
+        return dup_apply_pairs(f, g, h, args, K)
+
+    n, m, v = len(f), len(g), u - 1
+
+    if n != m:
+        if n > m:
+            g = dmp_zeros(n - m, v, K) + g
+        else:
+            f = dmp_zeros(m - n, v, K) + f
+
+    result = []
+
+    for a, b in zip(f, g):
+        result.append(dmp_apply_pairs(a, b, h, args, v, K))
+
+    return dmp_strip(result, u)
+
+
+def dup_slice(f, m, n, K):
+    """Take a continuous subsequence of terms of ``f`` in ``K[x]``. """
+    k = len(f)
+
+    if k >= m:
+        M = k - m
+    else:
+        M = 0
+    if k >= n:
+        N = k - n
+    else:
+        N = 0
+
+    f = f[N:M]
+
+    if not f:
+        return []
+    else:
+        return f + [K.zero]*m
+
+
+def dmp_slice(f, m, n, u, K):
+    """Take a continuous subsequence of terms of ``f`` in ``K[X]``. """
+    return dmp_slice_in(f, m, n, 0, u, K)
+
+
+def dmp_slice_in(f, m, n, j, u, K):
+    """Take a continuous subsequence of terms of ``f`` in ``x_j`` in ``K[X]``. """
+    if j < 0 or j > u:
+        raise IndexError("-%s <= j < %s expected, got %s" % (u, u, j))
+
+    if not u:
+        return dup_slice(f, m, n, K)
+
+    f, g = dmp_to_dict(f, u), {}
+
+    for monom, coeff in f.items():
+        k = monom[j]
+
+        if k < m or k >= n:
+            monom = monom[:j] + (0,) + monom[j + 1:]
+
+        if monom in g:
+            g[monom] += coeff
+        else:
+            g[monom] = coeff
+
+    return dmp_from_dict(g, u, K)
+
+
+def dup_random(n, a, b, K):
+    """
+    Return a polynomial of degree ``n`` with coefficients in ``[a, b]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.densebasic import dup_random
+
+    >>> dup_random(3, -10, 10, ZZ) #doctest: +SKIP
+    [-2, -8, 9, -4]
+
+    """
+    f = [ K.convert(random.randint(a, b)) for _ in range(0, n + 1) ]
+
+    while not f[0]:
+        f[0] = K.convert(random.randint(a, b))
+
+    return f

llmeval-env/lib/python3.10/site-packages/sympy/polys/densetools.py

@@ -0,0 +1,1309 @@
+"""Advanced tools for dense recursive polynomials in ``K[x]`` or ``K[X]``. """
+
+
+from sympy.polys.densearith import (
+    dup_add_term, dmp_add_term,
+    dup_lshift,
+    dup_add, dmp_add,
+    dup_sub, dmp_sub,
+    dup_mul, dmp_mul,
+    dup_sqr,
+    dup_div,
+    dup_rem, dmp_rem,
+    dmp_expand,
+    dup_mul_ground, dmp_mul_ground,
+    dup_quo_ground, dmp_quo_ground,
+    dup_exquo_ground, dmp_exquo_ground,
+)
+from sympy.polys.densebasic import (
+    dup_strip, dmp_strip,
+    dup_convert, dmp_convert,
+    dup_degree, dmp_degree,
+    dmp_to_dict,
+    dmp_from_dict,
+    dup_LC, dmp_LC, dmp_ground_LC,
+    dup_TC, dmp_TC,
+    dmp_zero, dmp_ground,
+    dmp_zero_p,
+    dup_to_raw_dict, dup_from_raw_dict,
+    dmp_zeros
+)
+from sympy.polys.polyerrors import (
+    MultivariatePolynomialError,
+    DomainError
+)
+from sympy.utilities import variations
+
+from math import ceil as _ceil, log as _log
+
+def dup_integrate(f, m, K):
+    """
+    Computes the indefinite integral of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> R.dup_integrate(x**2 + 2*x, 1)
+    1/3*x**3 + x**2
+    >>> R.dup_integrate(x**2 + 2*x, 2)
+    1/12*x**4 + 1/3*x**3
+
+    """
+    if m <= 0 or not f:
+        return f
+
+    g = [K.zero]*m
+
+    for i, c in enumerate(reversed(f)):
+        n = i + 1
+
+        for j in range(1, m):
+            n *= i + j + 1
+
+        g.insert(0, K.exquo(c, K(n)))
+
+    return g
+
+
+def dmp_integrate(f, m, u, K):
+    """
+    Computes the indefinite integral of ``f`` in ``x_0`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y = ring("x,y", QQ)
+
+    >>> R.dmp_integrate(x + 2*y, 1)
+    1/2*x**2 + 2*x*y
+    >>> R.dmp_integrate(x + 2*y, 2)
+    1/6*x**3 + x**2*y
+
+    """
+    if not u:
+        return dup_integrate(f, m, K)
+
+    if m <= 0 or dmp_zero_p(f, u):
+        return f
+
+    g, v = dmp_zeros(m, u - 1, K), u - 1
+
+    for i, c in enumerate(reversed(f)):
+        n = i + 1
+
+        for j in range(1, m):
+            n *= i + j + 1
+
+        g.insert(0, dmp_quo_ground(c, K(n), v, K))
+
+    return g
+
+
+def _rec_integrate_in(g, m, v, i, j, K):
+    """Recursive helper for :func:`dmp_integrate_in`."""
+    if i == j:
+        return dmp_integrate(g, m, v, K)
+
+    w, i = v - 1, i + 1
+
+    return dmp_strip([ _rec_integrate_in(c, m, w, i, j, K) for c in g ], v)
+
+
+def dmp_integrate_in(f, m, j, u, K):
+    """
+    Computes the indefinite integral of ``f`` in ``x_j`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y = ring("x,y", QQ)
+
+    >>> R.dmp_integrate_in(x + 2*y, 1, 0)
+    1/2*x**2 + 2*x*y
+    >>> R.dmp_integrate_in(x + 2*y, 1, 1)
+    x*y + y**2
+
+    """
+    if j < 0 or j > u:
+        raise IndexError("0 <= j <= u expected, got u = %d, j = %d" % (u, j))
+
+    return _rec_integrate_in(f, m, u, 0, j, K)
+
+
+def dup_diff(f, m, K):
+    """
+    ``m``-th order derivative of a polynomial in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_diff(x**3 + 2*x**2 + 3*x + 4, 1)
+    3*x**2 + 4*x + 3
+    >>> R.dup_diff(x**3 + 2*x**2 + 3*x + 4, 2)
+    6*x + 4
+
+    """
+    if m <= 0:
+        return f
+
+    n = dup_degree(f)
+
+    if n < m:
+        return []
+
+    deriv = []
+
+    if m == 1:
+        for coeff in f[:-m]:
+            deriv.append(K(n)*coeff)
+            n -= 1
+    else:
+        for coeff in f[:-m]:
+            k = n
+
+            for i in range(n - 1, n - m, -1):
+                k *= i
+
+            deriv.append(K(k)*coeff)
+            n -= 1
+
+    return dup_strip(deriv)
+
+
+def dmp_diff(f, m, u, K):
+    """
+    ``m``-th order derivative in ``x_0`` of a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1
+
+    >>> R.dmp_diff(f, 1)
+    y**2 + 2*y + 3
+    >>> R.dmp_diff(f, 2)
+    0
+
+    """
+    if not u:
+        return dup_diff(f, m, K)
+    if m <= 0:
+        return f
+
+    n = dmp_degree(f, u)
+
+    if n < m:
+        return dmp_zero(u)
+
+    deriv, v = [], u - 1
+
+    if m == 1:
+        for coeff in f[:-m]:
+            deriv.append(dmp_mul_ground(coeff, K(n), v, K))
+            n -= 1
+    else:
+        for coeff in f[:-m]:
+            k = n
+
+            for i in range(n - 1, n - m, -1):
+                k *= i
+
+            deriv.append(dmp_mul_ground(coeff, K(k), v, K))
+            n -= 1
+
+    return dmp_strip(deriv, u)
+
+
+def _rec_diff_in(g, m, v, i, j, K):
+    """Recursive helper for :func:`dmp_diff_in`."""
+    if i == j:
+        return dmp_diff(g, m, v, K)
+
+    w, i = v - 1, i + 1
+
+    return dmp_strip([ _rec_diff_in(c, m, w, i, j, K) for c in g ], v)
+
+
+def dmp_diff_in(f, m, j, u, K):
+    """
+    ``m``-th order derivative in ``x_j`` of a polynomial in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1
+
+    >>> R.dmp_diff_in(f, 1, 0)
+    y**2 + 2*y + 3
+    >>> R.dmp_diff_in(f, 1, 1)
+    2*x*y + 2*x + 4*y + 3
+
+    """
+    if j < 0 or j > u:
+        raise IndexError("0 <= j <= %s expected, got %s" % (u, j))
+
+    return _rec_diff_in(f, m, u, 0, j, K)
+
+
+def dup_eval(f, a, K):
+    """
+    Evaluate a polynomial at ``x = a`` in ``K[x]`` using Horner scheme.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_eval(x**2 + 2*x + 3, 2)
+    11
+
+    """
+    if not a:
+        return K.convert(dup_TC(f, K))
+
+    result = K.zero
+
+    for c in f:
+        result *= a
+        result += c
+
+    return result
+
+
+def dmp_eval(f, a, u, K):
+    """
+    Evaluate a polynomial at ``x_0 = a`` in ``K[X]`` using the Horner scheme.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_eval(2*x*y + 3*x + y + 2, 2)
+    5*y + 8
+
+    """
+    if not u:
+        return dup_eval(f, a, K)
+
+    if not a:
+        return dmp_TC(f, K)
+
+    result, v = dmp_LC(f, K), u - 1
+
+    for coeff in f[1:]:
+        result = dmp_mul_ground(result, a, v, K)
+        result = dmp_add(result, coeff, v, K)
+
+    return result
+
+
+def _rec_eval_in(g, a, v, i, j, K):
+    """Recursive helper for :func:`dmp_eval_in`."""
+    if i == j:
+        return dmp_eval(g, a, v, K)
+
+    v, i = v - 1, i + 1
+
+    return dmp_strip([ _rec_eval_in(c, a, v, i, j, K) for c in g ], v)
+
+
+def dmp_eval_in(f, a, j, u, K):
+    """
+    Evaluate a polynomial at ``x_j = a`` in ``K[X]`` using the Horner scheme.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 2*x*y + 3*x + y + 2
+
+    >>> R.dmp_eval_in(f, 2, 0)
+    5*y + 8
+    >>> R.dmp_eval_in(f, 2, 1)
+    7*x + 4
+
+    """
+    if j < 0 or j > u:
+        raise IndexError("0 <= j <= %s expected, got %s" % (u, j))
+
+    return _rec_eval_in(f, a, u, 0, j, K)
+
+
+def _rec_eval_tail(g, i, A, u, K):
+    """Recursive helper for :func:`dmp_eval_tail`."""
+    if i == u:
+        return dup_eval(g, A[-1], K)
+    else:
+        h = [ _rec_eval_tail(c, i + 1, A, u, K) for c in g ]
+
+        if i < u - len(A) + 1:
+            return h
+        else:
+            return dup_eval(h, A[-u + i - 1], K)
+
+
+def dmp_eval_tail(f, A, u, K):
+    """
+    Evaluate a polynomial at ``x_j = a_j, ...`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 2*x*y + 3*x + y + 2
+
+    >>> R.dmp_eval_tail(f, [2])
+    7*x + 4
+    >>> R.dmp_eval_tail(f, [2, 2])
+    18
+
+    """
+    if not A:
+        return f
+
+    if dmp_zero_p(f, u):
+        return dmp_zero(u - len(A))
+
+    e = _rec_eval_tail(f, 0, A, u, K)
+
+    if u == len(A) - 1:
+        return e
+    else:
+        return dmp_strip(e, u - len(A))
+
+
+def _rec_diff_eval(g, m, a, v, i, j, K):
+    """Recursive helper for :func:`dmp_diff_eval`."""
+    if i == j:
+        return dmp_eval(dmp_diff(g, m, v, K), a, v, K)
+
+    v, i = v - 1, i + 1
+
+    return dmp_strip([ _rec_diff_eval(c, m, a, v, i, j, K) for c in g ], v)
+
+
+def dmp_diff_eval_in(f, m, a, j, u, K):
+    """
+    Differentiate and evaluate a polynomial in ``x_j`` at ``a`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1
+
+    >>> R.dmp_diff_eval_in(f, 1, 2, 0)
+    y**2 + 2*y + 3
+    >>> R.dmp_diff_eval_in(f, 1, 2, 1)
+    6*x + 11
+
+    """
+    if j > u:
+        raise IndexError("-%s <= j < %s expected, got %s" % (u, u, j))
+    if not j:
+        return dmp_eval(dmp_diff(f, m, u, K), a, u, K)
+
+    return _rec_diff_eval(f, m, a, u, 0, j, K)
+
+
+def dup_trunc(f, p, K):
+    """
+    Reduce a ``K[x]`` polynomial modulo a constant ``p`` in ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_trunc(2*x**3 + 3*x**2 + 5*x + 7, ZZ(3))
+    -x**3 - x + 1
+
+    """
+    if K.is_ZZ:
+        g = []
+
+        for c in f:
+            c = c % p
+
+            if c > p // 2:
+                g.append(c - p)
+            else:
+                g.append(c)
+    else:
+        g = [ c % p for c in f ]
+
+    return dup_strip(g)
+
+
+def dmp_trunc(f, p, u, K):
+    """
+    Reduce a ``K[X]`` polynomial modulo a polynomial ``p`` in ``K[Y]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3
+    >>> g = (y - 1).drop(x)
+
+    >>> R.dmp_trunc(f, g)
+    11*x**2 + 11*x + 5
+
+    """
+    return dmp_strip([ dmp_rem(c, p, u - 1, K) for c in f ], u)
+
+
+def dmp_ground_trunc(f, p, u, K):
+    """
+    Reduce a ``K[X]`` polynomial modulo a constant ``p`` in ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3
+
+    >>> R.dmp_ground_trunc(f, ZZ(3))
+    -x**2 - x*y - y
+
+    """
+    if not u:
+        return dup_trunc(f, p, K)
+
+    v = u - 1
+
+    return dmp_strip([ dmp_ground_trunc(c, p, v, K) for c in f ], u)
+
+
+def dup_monic(f, K):
+    """
+    Divide all coefficients by ``LC(f)`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x = ring("x", ZZ)
+    >>> R.dup_monic(3*x**2 + 6*x + 9)
+    x**2 + 2*x + 3
+
+    >>> R, x = ring("x", QQ)
+    >>> R.dup_monic(3*x**2 + 4*x + 2)
+    x**2 + 4/3*x + 2/3
+
+    """
+    if not f:
+        return f
+
+    lc = dup_LC(f, K)
+
+    if K.is_one(lc):
+        return f
+    else:
+        return dup_exquo_ground(f, lc, K)
+
+
+def dmp_ground_monic(f, u, K):
+    """
+    Divide all coefficients by ``LC(f)`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x,y = ring("x,y", ZZ)
+    >>> f = 3*x**2*y + 6*x**2 + 3*x*y + 9*y + 3
+
+    >>> R.dmp_ground_monic(f)
+    x**2*y + 2*x**2 + x*y + 3*y + 1
+
+    >>> R, x,y = ring("x,y", QQ)
+    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3
+
+    >>> R.dmp_ground_monic(f)
+    x**2*y + 8/3*x**2 + 5/3*x*y + 2*x + 2/3*y + 1
+
+    """
+    if not u:
+        return dup_monic(f, K)
+
+    if dmp_zero_p(f, u):
+        return f
+
+    lc = dmp_ground_LC(f, u, K)
+
+    if K.is_one(lc):
+        return f
+    else:
+        return dmp_exquo_ground(f, lc, u, K)
+
+
+def dup_content(f, K):
+    """
+    Compute the GCD of coefficients of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x = ring("x", ZZ)
+    >>> f = 6*x**2 + 8*x + 12
+
+    >>> R.dup_content(f)
+    2
+
+    >>> R, x = ring("x", QQ)
+    >>> f = 6*x**2 + 8*x + 12
+
+    >>> R.dup_content(f)
+    2
+
+    """
+    from sympy.polys.domains import QQ
+
+    if not f:
+        return K.zero
+
+    cont = K.zero
+
+    if K == QQ:
+        for c in f:
+            cont = K.gcd(cont, c)
+    else:
+        for c in f:
+            cont = K.gcd(cont, c)
+
+            if K.is_one(cont):
+                break
+
+    return cont
+
+
+def dmp_ground_content(f, u, K):
+    """
+    Compute the GCD of coefficients of ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x,y = ring("x,y", ZZ)
+    >>> f = 2*x*y + 6*x + 4*y + 12
+
+    >>> R.dmp_ground_content(f)
+    2
+
+    >>> R, x,y = ring("x,y", QQ)
+    >>> f = 2*x*y + 6*x + 4*y + 12
+
+    >>> R.dmp_ground_content(f)
+    2
+
+    """
+    from sympy.polys.domains import QQ
+
+    if not u:
+        return dup_content(f, K)
+
+    if dmp_zero_p(f, u):
+        return K.zero
+
+    cont, v = K.zero, u - 1
+
+    if K == QQ:
+        for c in f:
+            cont = K.gcd(cont, dmp_ground_content(c, v, K))
+    else:
+        for c in f:
+            cont = K.gcd(cont, dmp_ground_content(c, v, K))
+
+            if K.is_one(cont):
+                break
+
+    return cont
+
+
+def dup_primitive(f, K):
+    """
+    Compute content and the primitive form of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x = ring("x", ZZ)
+    >>> f = 6*x**2 + 8*x + 12
+
+    >>> R.dup_primitive(f)
+    (2, 3*x**2 + 4*x + 6)
+
+    >>> R, x = ring("x", QQ)
+    >>> f = 6*x**2 + 8*x + 12
+
+    >>> R.dup_primitive(f)
+    (2, 3*x**2 + 4*x + 6)
+
+    """
+    if not f:
+        return K.zero, f
+
+    cont = dup_content(f, K)
+
+    if K.is_one(cont):
+        return cont, f
+    else:
+        return cont, dup_quo_ground(f, cont, K)
+
+
+def dmp_ground_primitive(f, u, K):
+    """
+    Compute content and the primitive form of ``f`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ, QQ
+
+    >>> R, x,y = ring("x,y", ZZ)
+    >>> f = 2*x*y + 6*x + 4*y + 12
+
+    >>> R.dmp_ground_primitive(f)
+    (2, x*y + 3*x + 2*y + 6)
+
+    >>> R, x,y = ring("x,y", QQ)
+    >>> f = 2*x*y + 6*x + 4*y + 12
+
+    >>> R.dmp_ground_primitive(f)
+    (2, x*y + 3*x + 2*y + 6)
+
+    """
+    if not u:
+        return dup_primitive(f, K)
+
+    if dmp_zero_p(f, u):
+        return K.zero, f
+
+    cont = dmp_ground_content(f, u, K)
+
+    if K.is_one(cont):
+        return cont, f
+    else:
+        return cont, dmp_quo_ground(f, cont, u, K)
+
+
+def dup_extract(f, g, K):
+    """
+    Extract common content from a pair of polynomials in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_extract(6*x**2 + 12*x + 18, 4*x**2 + 8*x + 12)
+    (2, 3*x**2 + 6*x + 9, 2*x**2 + 4*x + 6)
+
+    """
+    fc = dup_content(f, K)
+    gc = dup_content(g, K)
+
+    gcd = K.gcd(fc, gc)
+
+    if not K.is_one(gcd):
+        f = dup_quo_ground(f, gcd, K)
+        g = dup_quo_ground(g, gcd, K)
+
+    return gcd, f, g
+
+
+def dmp_ground_extract(f, g, u, K):
+    """
+    Extract common content from a pair of polynomials in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_ground_extract(6*x*y + 12*x + 18, 4*x*y + 8*x + 12)
+    (2, 3*x*y + 6*x + 9, 2*x*y + 4*x + 6)
+
+    """
+    fc = dmp_ground_content(f, u, K)
+    gc = dmp_ground_content(g, u, K)
+
+    gcd = K.gcd(fc, gc)
+
+    if not K.is_one(gcd):
+        f = dmp_quo_ground(f, gcd, u, K)
+        g = dmp_quo_ground(g, gcd, u, K)
+
+    return gcd, f, g
+
+
+def dup_real_imag(f, K):
+    """
+    Return bivariate polynomials ``f1`` and ``f2``, such that ``f = f1 + f2*I``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dup_real_imag(x**3 + x**2 + x + 1)
+    (x**3 + x**2 - 3*x*y**2 + x - y**2 + 1, 3*x**2*y + 2*x*y - y**3 + y)
+
+    """
+    if not K.is_ZZ and not K.is_QQ:
+        raise DomainError("computing real and imaginary parts is not supported over %s" % K)
+
+    f1 = dmp_zero(1)
+    f2 = dmp_zero(1)
+
+    if not f:
+        return f1, f2
+
+    g = [[[K.one, K.zero]], [[K.one], []]]
+    h = dmp_ground(f[0], 2)
+
+    for c in f[1:]:
+        h = dmp_mul(h, g, 2, K)
+        h = dmp_add_term(h, dmp_ground(c, 1), 0, 2, K)
+
+    H = dup_to_raw_dict(h)
+
+    for k, h in H.items():
+        m = k % 4
+
+        if not m:
+            f1 = dmp_add(f1, h, 1, K)
+        elif m == 1:
+            f2 = dmp_add(f2, h, 1, K)
+        elif m == 2:
+            f1 = dmp_sub(f1, h, 1, K)
+        else:
+            f2 = dmp_sub(f2, h, 1, K)
+
+    return f1, f2
+
+
+def dup_mirror(f, K):
+    """
+    Evaluate efficiently the composition ``f(-x)`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_mirror(x**3 + 2*x**2 - 4*x + 2)
+    -x**3 + 2*x**2 + 4*x + 2
+
+    """
+    f = list(f)
+
+    for i in range(len(f) - 2, -1, -2):
+        f[i] = -f[i]
+
+    return f
+
+
+def dup_scale(f, a, K):
+    """
+    Evaluate efficiently composition ``f(a*x)`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_scale(x**2 - 2*x + 1, ZZ(2))
+    4*x**2 - 4*x + 1
+
+    """
+    f, n, b = list(f), len(f) - 1, a
+
+    for i in range(n - 1, -1, -1):
+        f[i], b = b*f[i], b*a
+
+    return f
+
+
+def dup_shift(f, a, K):
+    """
+    Evaluate efficiently Taylor shift ``f(x + a)`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_shift(x**2 - 2*x + 1, ZZ(2))
+    x**2 + 2*x + 1
+
+    """
+    f, n = list(f), len(f) - 1
+
+    for i in range(n, 0, -1):
+        for j in range(0, i):
+            f[j + 1] += a*f[j]
+
+    return f
+
+
+def dup_transform(f, p, q, K):
+    """
+    Evaluate functional transformation ``q**n * f(p/q)`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_transform(x**2 - 2*x + 1, x**2 + 1, x - 1)
+    x**4 - 2*x**3 + 5*x**2 - 4*x + 4
+
+    """
+    if not f:
+        return []
+
+    n = len(f) - 1
+    h, Q = [f[0]], [[K.one]]
+
+    for i in range(0, n):
+        Q.append(dup_mul(Q[-1], q, K))
+
+    for c, q in zip(f[1:], Q[1:]):
+        h = dup_mul(h, p, K)
+        q = dup_mul_ground(q, c, K)
+        h = dup_add(h, q, K)
+
+    return h
+
+
+def dup_compose(f, g, K):
+    """
+    Evaluate functional composition ``f(g)`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_compose(x**2 + x, x - 1)
+    x**2 - x
+
+    """
+    if len(g) <= 1:
+        return dup_strip([dup_eval(f, dup_LC(g, K), K)])
+
+    if not f:
+        return []
+
+    h = [f[0]]
+
+    for c in f[1:]:
+        h = dup_mul(h, g, K)
+        h = dup_add_term(h, c, 0, K)
+
+    return h
+
+
+def dmp_compose(f, g, u, K):
+    """
+    Evaluate functional composition ``f(g)`` in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_compose(x*y + 2*x + y, y)
+    y**2 + 3*y
+
+    """
+    if not u:
+        return dup_compose(f, g, K)
+
+    if dmp_zero_p(f, u):
+        return f
+
+    h = [f[0]]
+
+    for c in f[1:]:
+        h = dmp_mul(h, g, u, K)
+        h = dmp_add_term(h, c, 0, u, K)
+
+    return h
+
+
+def _dup_right_decompose(f, s, K):
+    """Helper function for :func:`_dup_decompose`."""
+    n = len(f) - 1
+    lc = dup_LC(f, K)
+
+    f = dup_to_raw_dict(f)
+    g = { s: K.one }
+
+    r = n // s
+
+    for i in range(1, s):
+        coeff = K.zero
+
+        for j in range(0, i):
+            if not n + j - i in f:
+                continue
+
+            if not s - j in g:
+                continue
+
+            fc, gc = f[n + j - i], g[s - j]
+            coeff += (i - r*j)*fc*gc
+
+        g[s - i] = K.quo(coeff, i*r*lc)
+
+    return dup_from_raw_dict(g, K)
+
+
+def _dup_left_decompose(f, h, K):
+    """Helper function for :func:`_dup_decompose`."""
+    g, i = {}, 0
+
+    while f:
+        q, r = dup_div(f, h, K)
+
+        if dup_degree(r) > 0:
+            return None
+        else:
+            g[i] = dup_LC(r, K)
+            f, i = q, i + 1
+
+    return dup_from_raw_dict(g, K)
+
+
+def _dup_decompose(f, K):
+    """Helper function for :func:`dup_decompose`."""
+    df = len(f) - 1
+
+    for s in range(2, df):
+        if df % s != 0:
+            continue
+
+        h = _dup_right_decompose(f, s, K)
+
+        if h is not None:
+            g = _dup_left_decompose(f, h, K)
+
+            if g is not None:
+                return g, h
+
+    return None
+
+
+def dup_decompose(f, K):
+    """
+    Computes functional decomposition of ``f`` in ``K[x]``.
+
+    Given a univariate polynomial ``f`` with coefficients in a field of
+    characteristic zero, returns list ``[f_1, f_2, ..., f_n]``, where::
+
+              f = f_1 o f_2 o ... f_n = f_1(f_2(... f_n))
+
+    and ``f_2, ..., f_n`` are monic and homogeneous polynomials of at
+    least second degree.
+
+    Unlike factorization, complete functional decompositions of
+    polynomials are not unique, consider examples:
+
+    1. ``f o g = f(x + b) o (g - b)``
+    2. ``x**n o x**m = x**m o x**n``
+    3. ``T_n o T_m = T_m o T_n``
+
+    where ``T_n`` and ``T_m`` are Chebyshev polynomials.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_decompose(x**4 - 2*x**3 + x**2)
+    [x**2, x**2 - x]
+
+    References
+    ==========
+
+    .. [1] [Kozen89]_
+
+    """
+    F = []
+
+    while True:
+        result = _dup_decompose(f, K)
+
+        if result is not None:
+            f, h = result
+            F = [h] + F
+        else:
+            break
+
+    return [f] + F
+
+
+def dmp_lift(f, u, K):
+    """
+    Convert algebraic coefficients to integers in ``K[X]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> from sympy import I
+
+    >>> K = QQ.algebraic_field(I)
+    >>> R, x = ring("x", K)
+
+    >>> f = x**2 + K([QQ(1), QQ(0)])*x + K([QQ(2), QQ(0)])
+
+    >>> R.dmp_lift(f)
+    x**8 + 2*x**6 + 9*x**4 - 8*x**2 + 16
+
+    """
+    if K.is_GaussianField:
+        K1 = K.as_AlgebraicField()
+        f = dmp_convert(f, u, K, K1)
+        K = K1
+
+    if not K.is_Algebraic:
+        raise DomainError(
+            'computation can be done only in an algebraic domain')
+
+    F, monoms, polys = dmp_to_dict(f, u), [], []
+
+    for monom, coeff in F.items():
+        if not coeff.is_ground:
+            monoms.append(monom)
+
+    perms = variations([-1, 1], len(monoms), repetition=True)
+
+    for perm in perms:
+        G = dict(F)
+
+        for sign, monom in zip(perm, monoms):
+            if sign == -1:
+                G[monom] = -G[monom]
+
+        polys.append(dmp_from_dict(G, u, K))
+
+    return dmp_convert(dmp_expand(polys, u, K), u, K, K.dom)
+
+
+def dup_sign_variations(f, K):
+    """
+    Compute the number of sign variations of ``f`` in ``K[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_sign_variations(x**4 - x**2 - x + 1)
+    2
+
+    """
+    prev, k = K.zero, 0
+
+    for coeff in f:
+        if K.is_negative(coeff*prev):
+            k += 1
+
+        if coeff:
+            prev = coeff
+
+    return k
+
+
+def dup_clear_denoms(f, K0, K1=None, convert=False):
+    """
+    Clear denominators, i.e. transform ``K_0`` to ``K_1``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = QQ(1,2)*x + QQ(1,3)
+
+    >>> R.dup_clear_denoms(f, convert=False)
+    (6, 3*x + 2)
+    >>> R.dup_clear_denoms(f, convert=True)
+    (6, 3*x + 2)
+
+    """
+    if K1 is None:
+        if K0.has_assoc_Ring:
+            K1 = K0.get_ring()
+        else:
+            K1 = K0
+
+    common = K1.one
+
+    for c in f:
+        common = K1.lcm(common, K0.denom(c))
+
+    if not K1.is_one(common):
+        f = dup_mul_ground(f, common, K0)
+
+    if not convert:
+        return common, f
+    else:
+        return common, dup_convert(f, K0, K1)
+
+
+def _rec_clear_denoms(g, v, K0, K1):
+    """Recursive helper for :func:`dmp_clear_denoms`."""
+    common = K1.one
+
+    if not v:
+        for c in g:
+            common = K1.lcm(common, K0.denom(c))
+    else:
+        w = v - 1
+
+        for c in g:
+            common = K1.lcm(common, _rec_clear_denoms(c, w, K0, K1))
+
+    return common
+
+
+def dmp_clear_denoms(f, u, K0, K1=None, convert=False):
+    """
+    Clear denominators, i.e. transform ``K_0`` to ``K_1``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y = ring("x,y", QQ)
+
+    >>> f = QQ(1,2)*x + QQ(1,3)*y + 1
+
+    >>> R.dmp_clear_denoms(f, convert=False)
+    (6, 3*x + 2*y + 6)
+    >>> R.dmp_clear_denoms(f, convert=True)
+    (6, 3*x + 2*y + 6)
+
+    """
+    if not u:
+        return dup_clear_denoms(f, K0, K1, convert=convert)
+
+    if K1 is None:
+        if K0.has_assoc_Ring:
+            K1 = K0.get_ring()
+        else:
+            K1 = K0
+
+    common = _rec_clear_denoms(f, u, K0, K1)
+
+    if not K1.is_one(common):
+        f = dmp_mul_ground(f, common, u, K0)
+
+    if not convert:
+        return common, f
+    else:
+        return common, dmp_convert(f, u, K0, K1)
+
+
+def dup_revert(f, n, K):
+    """
+    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.
+
+    This function computes first ``2**n`` terms of a polynomial that
+    is a result of inversion of a polynomial modulo ``x**n``. This is
+    useful to efficiently compute series expansion of ``1/f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = -QQ(1,720)*x**6 + QQ(1,24)*x**4 - QQ(1,2)*x**2 + 1
+
+    >>> R.dup_revert(f, 8)
+    61/720*x**6 + 5/24*x**4 + 1/2*x**2 + 1
+
+    """
+    g = [K.revert(dup_TC(f, K))]
+    h = [K.one, K.zero, K.zero]
+
+    N = int(_ceil(_log(n, 2)))
+
+    for i in range(1, N + 1):
+        a = dup_mul_ground(g, K(2), K)
+        b = dup_mul(f, dup_sqr(g, K), K)
+        g = dup_rem(dup_sub(a, b, K), h, K)
+        h = dup_lshift(h, dup_degree(h), K)
+
+    return g
+
+
+def dmp_revert(f, g, u, K):
+    """
+    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y = ring("x,y", QQ)
+
+    """
+    if not u:
+        return dup_revert(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)

llmeval-env/lib/python3.10/site-packages/sympy/polys/dispersion.py

@@ -0,0 +1,212 @@
+from sympy.core import S
+from sympy.polys import Poly
+
+
+def dispersionset(p, q=None, *gens, **args):
+    r"""Compute the *dispersion set* of two polynomials.
+
+    For two polynomials `f(x)` and `g(x)` with `\deg f > 0`
+    and `\deg g > 0` the dispersion set `\operatorname{J}(f, g)` is defined as:
+
+    .. math::
+        \operatorname{J}(f, g)
+        & := \{a \in \mathbb{N}_0 | \gcd(f(x), g(x+a)) \neq 1\} \\
+        &  = \{a \in \mathbb{N}_0 | \deg \gcd(f(x), g(x+a)) \geq 1\}
+
+    For a single polynomial one defines `\operatorname{J}(f) := \operatorname{J}(f, f)`.
+
+    Examples
+    ========
+
+    >>> from sympy import poly
+    >>> from sympy.polys.dispersion import dispersion, dispersionset
+    >>> from sympy.abc import x
+
+    Dispersion set and dispersion of a simple polynomial:
+
+    >>> fp = poly((x - 3)*(x + 3), x)
+    >>> sorted(dispersionset(fp))
+    [0, 6]
+    >>> dispersion(fp)
+    6
+
+    Note that the definition of the dispersion is not symmetric:
+
+    >>> fp = poly(x**4 - 3*x**2 + 1, x)
+    >>> gp = fp.shift(-3)
+    >>> sorted(dispersionset(fp, gp))
+    [2, 3, 4]
+    >>> dispersion(fp, gp)
+    4
+    >>> sorted(dispersionset(gp, fp))
+    []
+    >>> dispersion(gp, fp)
+    -oo
+
+    Computing the dispersion also works over field extensions:
+
+    >>> from sympy import sqrt
+    >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>')
+    >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>')
+    >>> sorted(dispersionset(fp, gp))
+    [2]
+    >>> sorted(dispersionset(gp, fp))
+    [1, 4]
+
+    We can even perform the computations for polynomials
+    having symbolic coefficients:
+
+    >>> from sympy.abc import a
+    >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x)
+    >>> sorted(dispersionset(fp))
+    [0, 1]
+
+    See Also
+    ========
+
+    dispersion
+
+    References
+    ==========
+
+    .. [1] [ManWright94]_
+    .. [2] [Koepf98]_
+    .. [3] [Abramov71]_
+    .. [4] [Man93]_
+    """
+    # Check for valid input
+    same = False if q is not None else True
+    if same:
+        q = p
+
+    p = Poly(p, *gens, **args)
+    q = Poly(q, *gens, **args)
+
+    if not p.is_univariate or not q.is_univariate:
+        raise ValueError("Polynomials need to be univariate")
+
+    # The generator
+    if not p.gen == q.gen:
+        raise ValueError("Polynomials must have the same generator")
+    gen = p.gen
+
+    # We define the dispersion of constant polynomials to be zero
+    if p.degree() < 1 or q.degree() < 1:
+        return {0}
+
+    # Factor p and q over the rationals
+    fp = p.factor_list()
+    fq = q.factor_list() if not same else fp
+
+    # Iterate over all pairs of factors
+    J = set()
+    for s, unused in fp[1]:
+        for t, unused in fq[1]:
+            m = s.degree()
+            n = t.degree()
+            if n != m:
+                continue
+            an = s.LC()
+            bn = t.LC()
+            if not (an - bn).is_zero:
+                continue
+            # Note that the roles of `s` and `t` below are switched
+            # w.r.t. the original paper. This is for consistency
+            # with the description in the book of W. Koepf.
+            anm1 = s.coeff_monomial(gen**(m-1))
+            bnm1 = t.coeff_monomial(gen**(n-1))
+            alpha = (anm1 - bnm1) / S(n*bn)
+            if not alpha.is_integer:
+                continue
+            if alpha < 0 or alpha in J:
+                continue
+            if n > 1 and not (s - t.shift(alpha)).is_zero:
+                continue
+            J.add(alpha)
+
+    return J
+
+
+def dispersion(p, q=None, *gens, **args):
+    r"""Compute the *dispersion* of polynomials.
+
+    For two polynomials `f(x)` and `g(x)` with `\deg f > 0`
+    and `\deg g > 0` the dispersion `\operatorname{dis}(f, g)` is defined as:
+
+    .. math::
+        \operatorname{dis}(f, g)
+        & := \max\{ J(f,g) \cup \{0\} \} \\
+        &  = \max\{ \{a \in \mathbb{N} | \gcd(f(x), g(x+a)) \neq 1\} \cup \{0\} \}
+
+    and for a single polynomial `\operatorname{dis}(f) := \operatorname{dis}(f, f)`.
+    Note that we make the definition `\max\{\} := -\infty`.
+
+    Examples
+    ========
+
+    >>> from sympy import poly
+    >>> from sympy.polys.dispersion import dispersion, dispersionset
+    >>> from sympy.abc import x
+
+    Dispersion set and dispersion of a simple polynomial:
+
+    >>> fp = poly((x - 3)*(x + 3), x)
+    >>> sorted(dispersionset(fp))
+    [0, 6]
+    >>> dispersion(fp)
+    6
+
+    Note that the definition of the dispersion is not symmetric:
+
+    >>> fp = poly(x**4 - 3*x**2 + 1, x)
+    >>> gp = fp.shift(-3)
+    >>> sorted(dispersionset(fp, gp))
+    [2, 3, 4]
+    >>> dispersion(fp, gp)
+    4
+    >>> sorted(dispersionset(gp, fp))
+    []
+    >>> dispersion(gp, fp)
+    -oo
+
+    The maximum of an empty set is defined to be `-\infty`
+    as seen in this example.
+
+    Computing the dispersion also works over field extensions:
+
+    >>> from sympy import sqrt
+    >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>')
+    >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>')
+    >>> sorted(dispersionset(fp, gp))
+    [2]
+    >>> sorted(dispersionset(gp, fp))
+    [1, 4]
+
+    We can even perform the computations for polynomials
+    having symbolic coefficients:
+
+    >>> from sympy.abc import a
+    >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x)
+    >>> sorted(dispersionset(fp))
+    [0, 1]
+
+    See Also
+    ========
+
+    dispersionset
+
+    References
+    ==========
+
+    .. [1] [ManWright94]_
+    .. [2] [Koepf98]_
+    .. [3] [Abramov71]_
+    .. [4] [Man93]_
+    """
+    J = dispersionset(p, q, *gens, **args)
+    if not J:
+        # Definition for maximum of empty set
+        j = S.NegativeInfinity
+    else:
+        j = max(J)
+    return j

llmeval-env/lib/python3.10/site-packages/sympy/polys/distributedmodules.py

@@ -0,0 +1,739 @@
+r"""
+Sparse distributed elements of free modules over multivariate (generalized)
+polynomial rings.
+
+This code and its data structures are very much like the distributed
+polynomials, except that the first "exponent" of the monomial is
+a module generator index. That is, the multi-exponent ``(i, e_1, ..., e_n)``
+represents the "monomial" `x_1^{e_1} \cdots x_n^{e_n} f_i` of the free module
+`F` generated by `f_1, \ldots, f_r` over (a localization of) the ring
+`K[x_1, \ldots, x_n]`. A module element is simply stored as a list of terms
+ordered by the monomial order. Here a term is a pair of a multi-exponent and a
+coefficient. In general, this coefficient should never be zero (since it can
+then be omitted). The zero module element is stored as an empty list.
+
+The main routines are ``sdm_nf_mora`` and ``sdm_groebner`` which can be used
+to compute, respectively, weak normal forms and standard bases. They work with
+arbitrary (not necessarily global) monomial orders.
+
+In general, product orders have to be used to construct valid monomial orders
+for modules. However, ``lex`` can be used as-is.
+
+Note that the "level" (number of variables, i.e. parameter u+1 in
+distributedpolys.py) is never needed in this code.
+
+The main reference for this file is [SCA],
+"A Singular Introduction to Commutative Algebra".
+"""
+
+
+from itertools import permutations
+
+from sympy.polys.monomials import (
+    monomial_mul, monomial_lcm, monomial_div, monomial_deg
+)
+
+from sympy.polys.polytools import Poly
+from sympy.polys.polyutils import parallel_dict_from_expr
+from sympy.core.singleton import S
+from sympy.core.sympify import sympify
+
+# Additional monomial tools.
+
+
+def sdm_monomial_mul(M, X):
+    """
+    Multiply tuple ``X`` representing a monomial of `K[X]` into the tuple
+    ``M`` representing a monomial of `F`.
+
+    Examples
+    ========
+
+    Multiplying `xy^3` into `x f_1` yields `x^2 y^3 f_1`:
+
+    >>> from sympy.polys.distributedmodules import sdm_monomial_mul
+    >>> sdm_monomial_mul((1, 1, 0), (1, 3))
+    (1, 2, 3)
+    """
+    return (M[0],) + monomial_mul(X, M[1:])
+
+
+def sdm_monomial_deg(M):
+    """
+    Return the total degree of ``M``.
+
+    Examples
+    ========
+
+    For example, the total degree of `x^2 y f_5` is 3:
+
+    >>> from sympy.polys.distributedmodules import sdm_monomial_deg
+    >>> sdm_monomial_deg((5, 2, 1))
+    3
+    """
+    return monomial_deg(M[1:])
+
+
+def sdm_monomial_lcm(A, B):
+    r"""
+    Return the "least common multiple" of ``A`` and ``B``.
+
+    IF `A = M e_j` and `B = N e_j`, where `M` and `N` are polynomial monomials,
+    this returns `\lcm(M, N) e_j`. Note that ``A`` and ``B`` involve distinct
+    monomials.
+
+    Otherwise the result is undefined.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_monomial_lcm
+    >>> sdm_monomial_lcm((1, 2, 3), (1, 0, 5))
+    (1, 2, 5)
+    """
+    return (A[0],) + monomial_lcm(A[1:], B[1:])
+
+
+def sdm_monomial_divides(A, B):
+    """
+    Does there exist a (polynomial) monomial X such that XA = B?
+
+    Examples
+    ========
+
+    Positive examples:
+
+    In the following examples, the monomial is given in terms of x, y and the
+    generator(s), f_1, f_2 etc. The tuple form of that monomial is used in
+    the call to sdm_monomial_divides.
+    Note: the generator appears last in the expression but first in the tuple
+    and other factors appear in the same order that they appear in the monomial
+    expression.
+
+    `A = f_1` divides `B = f_1`
+
+    >>> from sympy.polys.distributedmodules import sdm_monomial_divides
+    >>> sdm_monomial_divides((1, 0, 0), (1, 0, 0))
+    True
+
+    `A = f_1` divides `B = x^2 y f_1`
+
+    >>> sdm_monomial_divides((1, 0, 0), (1, 2, 1))
+    True
+
+    `A = xy f_5` divides `B = x^2 y f_5`
+
+    >>> sdm_monomial_divides((5, 1, 1), (5, 2, 1))
+    True
+
+    Negative examples:
+
+    `A = f_1` does not divide `B = f_2`
+
+    >>> sdm_monomial_divides((1, 0, 0), (2, 0, 0))
+    False
+
+    `A = x f_1` does not divide `B = f_1`
+
+    >>> sdm_monomial_divides((1, 1, 0), (1, 0, 0))
+    False
+
+    `A = xy^2 f_5` does not divide `B = y f_5`
+
+    >>> sdm_monomial_divides((5, 1, 2), (5, 0, 1))
+    False
+    """
+    return A[0] == B[0] and all(a <= b for a, b in zip(A[1:], B[1:]))
+
+
+# The actual distributed modules code.
+
+def sdm_LC(f, K):
+    """Returns the leading coefficient of ``f``. """
+    if not f:
+        return K.zero
+    else:
+        return f[0][1]
+
+
+def sdm_to_dict(f):
+    """Make a dictionary from a distributed polynomial. """
+    return dict(f)
+
+
+def sdm_from_dict(d, O):
+    """
+    Create an sdm from a dictionary.
+
+    Here ``O`` is the monomial order to use.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_from_dict
+    >>> from sympy.polys import QQ, lex
+    >>> dic = {(1, 1, 0): QQ(1), (1, 0, 0): QQ(2), (0, 1, 0): QQ(0)}
+    >>> sdm_from_dict(dic, lex)
+    [((1, 1, 0), 1), ((1, 0, 0), 2)]
+    """
+    return sdm_strip(sdm_sort(list(d.items()), O))
+
+
+def sdm_sort(f, O):
+    """Sort terms in ``f`` using the given monomial order ``O``. """
+    return sorted(f, key=lambda term: O(term[0]), reverse=True)
+
+
+def sdm_strip(f):
+    """Remove terms with zero coefficients from ``f`` in ``K[X]``. """
+    return [ (monom, coeff) for monom, coeff in f if coeff ]
+
+
+def sdm_add(f, g, O, K):
+    """
+    Add two module elements ``f``, ``g``.
+
+    Addition is done over the ground field ``K``, monomials are ordered
+    according to ``O``.
+
+    Examples
+    ========
+
+    All examples use lexicographic order.
+
+    `(xy f_1) + (f_2) = f_2 + xy f_1`
+
+    >>> from sympy.polys.distributedmodules import sdm_add
+    >>> from sympy.polys import lex, QQ
+    >>> sdm_add([((1, 1, 1), QQ(1))], [((2, 0, 0), QQ(1))], lex, QQ)
+    [((2, 0, 0), 1), ((1, 1, 1), 1)]
+
+    `(xy f_1) + (-xy f_1)` = 0`
+
+    >>> sdm_add([((1, 1, 1), QQ(1))], [((1, 1, 1), QQ(-1))], lex, QQ)
+    []
+
+    `(f_1) + (2f_1) = 3f_1`
+
+    >>> sdm_add([((1, 0, 0), QQ(1))], [((1, 0, 0), QQ(2))], lex, QQ)
+    [((1, 0, 0), 3)]
+
+    `(yf_1) + (xf_1) = xf_1 + yf_1`
+
+    >>> sdm_add([((1, 0, 1), QQ(1))], [((1, 1, 0), QQ(1))], lex, QQ)
+    [((1, 1, 0), 1), ((1, 0, 1), 1)]
+    """
+    h = dict(f)
+
+    for monom, c in g:
+        if monom in h:
+            coeff = h[monom] + c
+
+            if not coeff:
+                del h[monom]
+            else:
+                h[monom] = coeff
+        else:
+            h[monom] = c
+
+    return sdm_from_dict(h, O)
+
+
+def sdm_LM(f):
+    r"""
+    Returns the leading monomial of ``f``.
+
+    Only valid if `f \ne 0`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_LM, sdm_from_dict
+    >>> from sympy.polys import QQ, lex
+    >>> dic = {(1, 2, 3): QQ(1), (4, 0, 0): QQ(1), (4, 0, 1): QQ(1)}
+    >>> sdm_LM(sdm_from_dict(dic, lex))
+    (4, 0, 1)
+    """
+    return f[0][0]
+
+
+def sdm_LT(f):
+    r"""
+    Returns the leading term of ``f``.
+
+    Only valid if `f \ne 0`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_LT, sdm_from_dict
+    >>> from sympy.polys import QQ, lex
+    >>> dic = {(1, 2, 3): QQ(1), (4, 0, 0): QQ(2), (4, 0, 1): QQ(3)}
+    >>> sdm_LT(sdm_from_dict(dic, lex))
+    ((4, 0, 1), 3)
+    """
+    return f[0]
+
+
+def sdm_mul_term(f, term, O, K):
+    """
+    Multiply a distributed module element ``f`` by a (polynomial) term ``term``.
+
+    Multiplication of coefficients is done over the ground field ``K``, and
+    monomials are ordered according to ``O``.
+
+    Examples
+    ========
+
+    `0 f_1 = 0`
+
+    >>> from sympy.polys.distributedmodules import sdm_mul_term
+    >>> from sympy.polys import lex, QQ
+    >>> sdm_mul_term([((1, 0, 0), QQ(1))], ((0, 0), QQ(0)), lex, QQ)
+    []
+
+    `x 0 = 0`
+
+    >>> sdm_mul_term([], ((1, 0), QQ(1)), lex, QQ)
+    []
+
+    `(x) (f_1) = xf_1`
+
+    >>> sdm_mul_term([((1, 0, 0), QQ(1))], ((1, 0), QQ(1)), lex, QQ)
+    [((1, 1, 0), 1)]
+
+    `(2xy) (3x f_1 + 4y f_2) = 8xy^2 f_2 + 6x^2y f_1`
+
+    >>> f = [((2, 0, 1), QQ(4)), ((1, 1, 0), QQ(3))]
+    >>> sdm_mul_term(f, ((1, 1), QQ(2)), lex, QQ)
+    [((2, 1, 2), 8), ((1, 2, 1), 6)]
+    """
+    X, c = term
+
+    if not f or not c:
+        return []
+    else:
+        if K.is_one(c):
+            return [ (sdm_monomial_mul(f_M, X), f_c) for f_M, f_c in f ]
+        else:
+            return [ (sdm_monomial_mul(f_M, X), f_c * c) for f_M, f_c in f ]
+
+
+def sdm_zero():
+    """Return the zero module element."""
+    return []
+
+
+def sdm_deg(f):
+    """
+    Degree of ``f``.
+
+    This is the maximum of the degrees of all its monomials.
+    Invalid if ``f`` is zero.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_deg
+    >>> sdm_deg([((1, 2, 3), 1), ((10, 0, 1), 1), ((2, 3, 4), 4)])
+    7
+    """
+    return max(sdm_monomial_deg(M[0]) for M in f)
+
+
+# Conversion
+
+def sdm_from_vector(vec, O, K, **opts):
+    """
+    Create an sdm from an iterable of expressions.
+
+    Coefficients are created in the ground field ``K``, and terms are ordered
+    according to monomial order ``O``. Named arguments are passed on to the
+    polys conversion code and can be used to specify for example generators.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_from_vector
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.polys import QQ, lex
+    >>> sdm_from_vector([x**2+y**2, 2*z], lex, QQ)
+    [((1, 0, 0, 1), 2), ((0, 2, 0, 0), 1), ((0, 0, 2, 0), 1)]
+    """
+    dics, gens = parallel_dict_from_expr(sympify(vec), **opts)
+    dic = {}
+    for i, d in enumerate(dics):
+        for k, v in d.items():
+            dic[(i,) + k] = K.convert(v)
+    return sdm_from_dict(dic, O)
+
+
+def sdm_to_vector(f, gens, K, n=None):
+    """
+    Convert sdm ``f`` into a list of polynomial expressions.
+
+    The generators for the polynomial ring are specified via ``gens``. The rank
+    of the module is guessed, or passed via ``n``. The ground field is assumed
+    to be ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_to_vector
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.polys import QQ
+    >>> f = [((1, 0, 0, 1), QQ(2)), ((0, 2, 0, 0), QQ(1)), ((0, 0, 2, 0), QQ(1))]
+    >>> sdm_to_vector(f, [x, y, z], QQ)
+    [x**2 + y**2, 2*z]
+    """
+    dic = sdm_to_dict(f)
+    dics = {}
+    for k, v in dic.items():
+        dics.setdefault(k[0], []).append((k[1:], v))
+    n = n or len(dics)
+    res = []
+    for k in range(n):
+        if k in dics:
+            res.append(Poly(dict(dics[k]), gens=gens, domain=K).as_expr())
+        else:
+            res.append(S.Zero)
+    return res
+
+# Algorithms.
+
+
+def sdm_spoly(f, g, O, K, phantom=None):
+    """
+    Compute the generalized s-polynomial of ``f`` and ``g``.
+
+    The ground field is assumed to be ``K``, and monomials ordered according to
+    ``O``.
+
+    This is invalid if either of ``f`` or ``g`` is zero.
+
+    If the leading terms of `f` and `g` involve different basis elements of
+    `F`, their s-poly is defined to be zero. Otherwise it is a certain linear
+    combination of `f` and `g` in which the leading terms cancel.
+    See [SCA, defn 2.3.6] for details.
+
+    If ``phantom`` is not ``None``, it should be a pair of module elements on
+    which to perform the same operation(s) as on ``f`` and ``g``. The in this
+    case both results are returned.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_spoly
+    >>> from sympy.polys import QQ, lex
+    >>> f = [((2, 1, 1), QQ(1)), ((1, 0, 1), QQ(1))]
+    >>> g = [((2, 3, 0), QQ(1))]
+    >>> h = [((1, 2, 3), QQ(1))]
+    >>> sdm_spoly(f, h, lex, QQ)
+    []
+    >>> sdm_spoly(f, g, lex, QQ)
+    [((1, 2, 1), 1)]
+    """
+    if not f or not g:
+        return sdm_zero()
+    LM1 = sdm_LM(f)
+    LM2 = sdm_LM(g)
+    if LM1[0] != LM2[0]:
+        return sdm_zero()
+    LM1 = LM1[1:]
+    LM2 = LM2[1:]
+    lcm = monomial_lcm(LM1, LM2)
+    m1 = monomial_div(lcm, LM1)
+    m2 = monomial_div(lcm, LM2)
+    c = K.quo(-sdm_LC(f, K), sdm_LC(g, K))
+    r1 = sdm_add(sdm_mul_term(f, (m1, K.one), O, K),
+                 sdm_mul_term(g, (m2, c), O, K), O, K)
+    if phantom is None:
+        return r1
+    r2 = sdm_add(sdm_mul_term(phantom[0], (m1, K.one), O, K),
+                 sdm_mul_term(phantom[1], (m2, c), O, K), O, K)
+    return r1, r2
+
+
+def sdm_ecart(f):
+    """
+    Compute the ecart of ``f``.
+
+    This is defined to be the difference of the total degree of `f` and the
+    total degree of the leading monomial of `f` [SCA, defn 2.3.7].
+
+    Invalid if f is zero.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.distributedmodules import sdm_ecart
+    >>> sdm_ecart([((1, 2, 3), 1), ((1, 0, 1), 1)])
+    0
+    >>> sdm_ecart([((2, 2, 1), 1), ((1, 5, 1), 1)])
+    3
+    """
+    return sdm_deg(f) - sdm_monomial_deg(sdm_LM(f))
+
+
+def sdm_nf_mora(f, G, O, K, phantom=None):
+    r"""
+    Compute a weak normal form of ``f`` with respect to ``G`` and order ``O``.
+
+    The ground field is assumed to be ``K``, and monomials ordered according to
+    ``O``.
+
+    Weak normal forms are defined in [SCA, defn 2.3.3]. They are not unique.
+    This function deterministically computes a weak normal form, depending on
+    the order of `G`.
+
+    The most important property of a weak normal form is the following: if
+    `R` is the ring associated with the monomial ordering (if the ordering is
+    global, we just have `R = K[x_1, \ldots, x_n]`, otherwise it is a certain
+    localization thereof), `I` any ideal of `R` and `G` a standard basis for
+    `I`, then for any `f \in R`, we have `f \in I` if and only if
+    `NF(f | G) = 0`.
+
+    This is the generalized Mora algorithm for computing weak normal forms with
+    respect to arbitrary monomial orders [SCA, algorithm 2.3.9].
+
+    If ``phantom`` is not ``None``, it should be a pair of "phantom" arguments
+    on which to perform the same computations as on ``f``, ``G``, both results
+    are then returned.
+    """
+    from itertools import repeat
+    h = f
+    T = list(G)
+    if phantom is not None:
+        # "phantom" variables with suffix p
+        hp = phantom[0]
+        Tp = list(phantom[1])
+        phantom = True
+    else:
+        Tp = repeat([])
+        phantom = False
+    while h:
+        # TODO better data structure!!!
+        Th = [(g, sdm_ecart(g), gp) for g, gp in zip(T, Tp)
+              if sdm_monomial_divides(sdm_LM(g), sdm_LM(h))]
+        if not Th:
+            break
+        g, _, gp = min(Th, key=lambda x: x[1])
+        if sdm_ecart(g) > sdm_ecart(h):
+            T.append(h)
+            if phantom:
+                Tp.append(hp)
+        if phantom:
+            h, hp = sdm_spoly(h, g, O, K, phantom=(hp, gp))
+        else:
+            h = sdm_spoly(h, g, O, K)
+    if phantom:
+        return h, hp
+    return h
+
+
+def sdm_nf_buchberger(f, G, O, K, phantom=None):
+    r"""
+    Compute a weak normal form of ``f`` with respect to ``G`` and order ``O``.
+
+    The ground field is assumed to be ``K``, and monomials ordered according to
+    ``O``.
+
+    This is the standard Buchberger algorithm for computing weak normal forms with
+    respect to *global* monomial orders [SCA, algorithm 1.6.10].
+
+    If ``phantom`` is not ``None``, it should be a pair of "phantom" arguments
+    on which to perform the same computations as on ``f``, ``G``, both results
+    are then returned.
+    """
+    from itertools import repeat
+    h = f
+    T = list(G)
+    if phantom is not None:
+        # "phantom" variables with suffix p
+        hp = phantom[0]
+        Tp = list(phantom[1])
+        phantom = True
+    else:
+        Tp = repeat([])
+        phantom = False
+    while h:
+        try:
+            g, gp = next((g, gp) for g, gp in zip(T, Tp)
+                         if sdm_monomial_divides(sdm_LM(g), sdm_LM(h)))
+        except StopIteration:
+            break
+        if phantom:
+            h, hp = sdm_spoly(h, g, O, K, phantom=(hp, gp))
+        else:
+            h = sdm_spoly(h, g, O, K)
+    if phantom:
+        return h, hp
+    return h
+
+
+def sdm_nf_buchberger_reduced(f, G, O, K):
+    r"""
+    Compute a reduced normal form of ``f`` with respect to ``G`` and order ``O``.
+
+    The ground field is assumed to be ``K``, and monomials ordered according to
+    ``O``.
+
+    In contrast to weak normal forms, reduced normal forms *are* unique, but
+    their computation is more expensive.
+
+    This is the standard Buchberger algorithm for computing reduced normal forms
+    with respect to *global* monomial orders [SCA, algorithm 1.6.11].
+
+    The ``pantom`` option is not supported, so this normal form cannot be used
+    as a normal form for the "extended" groebner algorithm.
+    """
+    h = sdm_zero()
+    g = f
+    while g:
+        g = sdm_nf_buchberger(g, G, O, K)
+        if g:
+            h = sdm_add(h, [sdm_LT(g)], O, K)
+            g = g[1:]
+    return h
+
+
+def sdm_groebner(G, NF, O, K, extended=False):
+    """
+    Compute a minimal standard basis of ``G`` with respect to order ``O``.
+
+    The algorithm uses a normal form ``NF``, for example ``sdm_nf_mora``.
+    The ground field is assumed to be ``K``, and monomials ordered according
+    to ``O``.
+
+    Let `N` denote the submodule generated by elements of `G`. A standard
+    basis for `N` is a subset `S` of `N`, such that `in(S) = in(N)`, where for
+    any subset `X` of `F`, `in(X)` denotes the submodule generated by the
+    initial forms of elements of `X`. [SCA, defn 2.3.2]
+
+    A standard basis is called minimal if no subset of it is a standard basis.
+
+    One may show that standard bases are always generating sets.
+
+    Minimal standard bases are not unique. This algorithm computes a
+    deterministic result, depending on the particular order of `G`.
+
+    If ``extended=True``, also compute the transition matrix from the initial
+    generators to the groebner basis. That is, return a list of coefficient
+    vectors, expressing the elements of the groebner basis in terms of the
+    elements of ``G``.
+
+    This functions implements the "sugar" strategy, see
+
+    Giovini et al: "One sugar cube, please" OR Selection strategies in
+    Buchberger algorithm.
+    """
+
+    # The critical pair set.
+    # A critical pair is stored as (i, j, s, t) where (i, j) defines the pair
+    # (by indexing S), s is the sugar of the pair, and t is the lcm of their
+    # leading monomials.
+    P = []
+
+    # The eventual standard basis.
+    S = []
+    Sugars = []
+
+    def Ssugar(i, j):
+        """Compute the sugar of the S-poly corresponding to (i, j)."""
+        LMi = sdm_LM(S[i])
+        LMj = sdm_LM(S[j])
+        return max(Sugars[i] - sdm_monomial_deg(LMi),
+                   Sugars[j] - sdm_monomial_deg(LMj)) \
+            + sdm_monomial_deg(sdm_monomial_lcm(LMi, LMj))
+
+    ourkey = lambda p: (p[2], O(p[3]), p[1])
+
+    def update(f, sugar, P):
+        """Add f with sugar ``sugar`` to S, update P."""
+        if not f:
+            return P
+        k = len(S)
+        S.append(f)
+        Sugars.append(sugar)
+
+        LMf = sdm_LM(f)
+
+        def removethis(pair):
+            i, j, s, t = pair
+            if LMf[0] != t[0]:
+                return False
+            tik = sdm_monomial_lcm(LMf, sdm_LM(S[i]))
+            tjk = sdm_monomial_lcm(LMf, sdm_LM(S[j]))
+            return tik != t and tjk != t and sdm_monomial_divides(tik, t) and \
+                sdm_monomial_divides(tjk, t)
+        # apply the chain criterion
+        P = [p for p in P if not removethis(p)]
+
+        # new-pair set
+        N = [(i, k, Ssugar(i, k), sdm_monomial_lcm(LMf, sdm_LM(S[i])))
+             for i in range(k) if LMf[0] == sdm_LM(S[i])[0]]
+        # TODO apply the product criterion?
+        N.sort(key=ourkey)
+        remove = set()
+        for i, p in enumerate(N):
+            for j in range(i + 1, len(N)):
+                if sdm_monomial_divides(p[3], N[j][3]):
+                    remove.add(j)
+
+        # TODO mergesort?
+        P.extend(reversed([p for i, p in enumerate(N) if i not in remove]))
+        P.sort(key=ourkey, reverse=True)
+        # NOTE reverse-sort, because we want to pop from the end
+        return P
+
+    # Figure out the number of generators in the ground ring.
+    try:
+        # NOTE: we look for the first non-zero vector, take its first monomial
+        #       the number of generators in the ring is one less than the length
+        #       (since the zeroth entry is for the module generators)
+        numgens = len(next(x[0] for x in G if x)[0]) - 1
+    except StopIteration:
+        # No non-zero elements in G ...
+        if extended:
+            return [], []
+        return []
+
+    # This list will store expressions of the elements of S in terms of the
+    # initial generators
+    coefficients = []
+
+    # First add all the elements of G to S
+    for i, f in enumerate(G):
+        P = update(f, sdm_deg(f), P)
+        if extended and f:
+            coefficients.append(sdm_from_dict({(i,) + (0,)*numgens: K(1)}, O))
+
+    # Now carry out the buchberger algorithm.
+    while P:
+        i, j, s, t = P.pop()
+        f, g = S[i], S[j]
+        if extended:
+            sp, coeff = sdm_spoly(f, g, O, K,
+                                  phantom=(coefficients[i], coefficients[j]))
+            h, hcoeff = NF(sp, S, O, K, phantom=(coeff, coefficients))
+            if h:
+                coefficients.append(hcoeff)
+        else:
+            h = NF(sdm_spoly(f, g, O, K), S, O, K)
+        P = update(h, Ssugar(i, j), P)
+
+    # Finally interreduce the standard basis.
+    # (TODO again, better data structures)
+    S = {(tuple(f), i) for i, f in enumerate(S)}
+    for (a, ai), (b, bi) in permutations(S, 2):
+        A = sdm_LM(a)
+        B = sdm_LM(b)
+        if sdm_monomial_divides(A, B) and (b, bi) in S and (a, ai) in S:
+            S.remove((b, bi))
+
+    L = sorted(((list(f), i) for f, i in S), key=lambda p: O(sdm_LM(p[0])),
+               reverse=True)
+    res = [x[0] for x in L]
+    if extended:
+        return res, [coefficients[i] for _, i in L]
+    return res

llmeval-env/lib/python3.10/site-packages/sympy/polys/domainmatrix.py

@@ -0,0 +1,12 @@
+"""
+Stub module to expose DomainMatrix which has now moved to
+sympy.polys.matrices package. It should now be imported as:
+
+    >>> from sympy.polys.matrices import DomainMatrix
+
+This module might be removed in future.
+"""
+
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+
+__all__ = ['DomainMatrix']

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/algebraicfield.py

@@ -0,0 +1,605 @@
+"""Implementation of :class:`AlgebraicField` class. """
+
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.polys.domains.characteristiczero import CharacteristicZero
+from sympy.polys.domains.field import Field
+from sympy.polys.domains.simpledomain import SimpleDomain
+from sympy.polys.polyclasses import ANP
+from sympy.polys.polyerrors import CoercionFailed, DomainError, NotAlgebraic, IsomorphismFailed
+from sympy.utilities import public
+
+@public
+class AlgebraicField(Field, CharacteristicZero, SimpleDomain):
+    r"""Algebraic number field :ref:`QQ(a)`
+
+    A :ref:`QQ(a)` domain represents an `algebraic number field`_
+    `\mathbb{Q}(a)` as a :py:class:`~.Domain` in the domain system (see
+    :ref:`polys-domainsintro`).
+
+    A :py:class:`~.Poly` created from an expression involving `algebraic
+    numbers`_ will treat the algebraic numbers as generators if the generators
+    argument is not specified.
+
+    >>> from sympy import Poly, Symbol, sqrt
+    >>> x = Symbol('x')
+    >>> Poly(x**2 + sqrt(2))
+    Poly(x**2 + (sqrt(2)), x, sqrt(2), domain='ZZ')
+
+    That is a multivariate polynomial with ``sqrt(2)`` treated as one of the
+    generators (variables). If the generators are explicitly specified then
+    ``sqrt(2)`` will be considered to be a coefficient but by default the
+    :ref:`EX` domain is used. To make a :py:class:`~.Poly` with a :ref:`QQ(a)`
+    domain the argument ``extension=True`` can be given.
+
+    >>> Poly(x**2 + sqrt(2), x)
+    Poly(x**2 + sqrt(2), x, domain='EX')
+    >>> Poly(x**2 + sqrt(2), x, extension=True)
+    Poly(x**2 + sqrt(2), x, domain='QQ<sqrt(2)>')
+
+    A generator of the algebraic field extension can also be specified
+    explicitly which is particularly useful if the coefficients are all
+    rational but an extension field is needed (e.g. to factor the
+    polynomial).
+
+    >>> Poly(x**2 + 1)
+    Poly(x**2 + 1, x, domain='ZZ')
+    >>> Poly(x**2 + 1, extension=sqrt(2))
+    Poly(x**2 + 1, x, domain='QQ<sqrt(2)>')
+
+    It is possible to factorise a polynomial over a :ref:`QQ(a)` domain using
+    the ``extension`` argument to :py:func:`~.factor` or by specifying the domain
+    explicitly.
+
+    >>> from sympy import factor, QQ
+    >>> factor(x**2 - 2)
+    x**2 - 2
+    >>> factor(x**2 - 2, extension=sqrt(2))
+    (x - sqrt(2))*(x + sqrt(2))
+    >>> factor(x**2 - 2, domain='QQ<sqrt(2)>')
+    (x - sqrt(2))*(x + sqrt(2))
+    >>> factor(x**2 - 2, domain=QQ.algebraic_field(sqrt(2)))
+    (x - sqrt(2))*(x + sqrt(2))
+
+    The ``extension=True`` argument can be used but will only create an
+    extension that contains the coefficients which is usually not enough to
+    factorise the polynomial.
+
+    >>> p = x**3 + sqrt(2)*x**2 - 2*x - 2*sqrt(2)
+    >>> factor(p)                         # treats sqrt(2) as a symbol
+    (x + sqrt(2))*(x**2 - 2)
+    >>> factor(p, extension=True)
+    (x - sqrt(2))*(x + sqrt(2))**2
+    >>> factor(x**2 - 2, extension=True)  # all rational coefficients
+    x**2 - 2
+
+    It is also possible to use :ref:`QQ(a)` with the :py:func:`~.cancel`
+    and :py:func:`~.gcd` functions.
+
+    >>> from sympy import cancel, gcd
+    >>> cancel((x**2 - 2)/(x - sqrt(2)))
+    (x**2 - 2)/(x - sqrt(2))
+    >>> cancel((x**2 - 2)/(x - sqrt(2)), extension=sqrt(2))
+    x + sqrt(2)
+    >>> gcd(x**2 - 2, x - sqrt(2))
+    1
+    >>> gcd(x**2 - 2, x - sqrt(2), extension=sqrt(2))
+    x - sqrt(2)
+
+    When using the domain directly :ref:`QQ(a)` can be used as a constructor
+    to create instances which then support the operations ``+,-,*,**,/``. The
+    :py:meth:`~.Domain.algebraic_field` method is used to construct a
+    particular :ref:`QQ(a)` domain. The :py:meth:`~.Domain.from_sympy` method
+    can be used to create domain elements from normal SymPy expressions.
+
+    >>> K = QQ.algebraic_field(sqrt(2))
+    >>> K
+    QQ<sqrt(2)>
+    >>> xk = K.from_sympy(3 + 4*sqrt(2))
+    >>> xk  # doctest: +SKIP
+    ANP([4, 3], [1, 0, -2], QQ)
+
+    Elements of :ref:`QQ(a)` are instances of :py:class:`~.ANP` which have
+    limited printing support. The raw display shows the internal
+    representation of the element as the list ``[4, 3]`` representing the
+    coefficients of ``1`` and ``sqrt(2)`` for this element in the form
+    ``a * sqrt(2) + b * 1`` where ``a`` and ``b`` are elements of :ref:`QQ`.
+    The minimal polynomial for the generator ``(x**2 - 2)`` is also shown in
+    the :ref:`dup-representation` as the list ``[1, 0, -2]``. We can use
+    :py:meth:`~.Domain.to_sympy` to get a better printed form for the
+    elements and to see the results of operations.
+
+    >>> xk = K.from_sympy(3 + 4*sqrt(2))
+    >>> yk = K.from_sympy(2 + 3*sqrt(2))
+    >>> xk * yk  # doctest: +SKIP
+    ANP([17, 30], [1, 0, -2], QQ)
+    >>> K.to_sympy(xk * yk)
+    17*sqrt(2) + 30
+    >>> K.to_sympy(xk + yk)
+    5 + 7*sqrt(2)
+    >>> K.to_sympy(xk ** 2)
+    24*sqrt(2) + 41
+    >>> K.to_sympy(xk / yk)
+    sqrt(2)/14 + 9/7
+
+    Any expression representing an algebraic number can be used to generate
+    a :ref:`QQ(a)` domain provided its `minimal polynomial`_ can be computed.
+    The function :py:func:`~.minpoly` function is used for this.
+
+    >>> from sympy import exp, I, pi, minpoly
+    >>> g = exp(2*I*pi/3)
+    >>> g
+    exp(2*I*pi/3)
+    >>> g.is_algebraic
+    True
+    >>> minpoly(g, x)
+    x**2 + x + 1
+    >>> factor(x**3 - 1, extension=g)
+    (x - 1)*(x - exp(2*I*pi/3))*(x + 1 + exp(2*I*pi/3))
+
+    It is also possible to make an algebraic field from multiple extension
+    elements.
+
+    >>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
+    >>> K
+    QQ<sqrt(2) + sqrt(3)>
+    >>> p = x**4 - 5*x**2 + 6
+    >>> factor(p)
+    (x**2 - 3)*(x**2 - 2)
+    >>> factor(p, domain=K)
+    (x - sqrt(2))*(x + sqrt(2))*(x - sqrt(3))*(x + sqrt(3))
+    >>> factor(p, extension=[sqrt(2), sqrt(3)])
+    (x - sqrt(2))*(x + sqrt(2))*(x - sqrt(3))*(x + sqrt(3))
+
+    Multiple extension elements are always combined together to make a single
+    `primitive element`_. In the case of ``[sqrt(2), sqrt(3)]`` the primitive
+    element chosen is ``sqrt(2) + sqrt(3)`` which is why the domain displays
+    as ``QQ<sqrt(2) + sqrt(3)>``. The minimal polynomial for the primitive
+    element is computed using the :py:func:`~.primitive_element` function.
+
+    >>> from sympy import primitive_element
+    >>> primitive_element([sqrt(2), sqrt(3)], x)
+    (x**4 - 10*x**2 + 1, [1, 1])
+    >>> minpoly(sqrt(2) + sqrt(3), x)
+    x**4 - 10*x**2 + 1
+
+    The extension elements that generate the domain can be accessed from the
+    domain using the :py:attr:`~.ext` and :py:attr:`~.orig_ext` attributes as
+    instances of :py:class:`~.AlgebraicNumber`. The minimal polynomial for
+    the primitive element as a :py:class:`~.DMP` instance is available as
+    :py:attr:`~.mod`.
+
+    >>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
+    >>> K
+    QQ<sqrt(2) + sqrt(3)>
+    >>> K.ext
+    sqrt(2) + sqrt(3)
+    >>> K.orig_ext
+    (sqrt(2), sqrt(3))
+    >>> K.mod
+    DMP([1, 0, -10, 0, 1], QQ, None)
+
+    The `discriminant`_ of the field can be obtained from the
+    :py:meth:`~.discriminant` method, and an `integral basis`_ from the
+    :py:meth:`~.integral_basis` method. The latter returns a list of
+    :py:class:`~.ANP` instances by default, but can be made to return instances
+    of :py:class:`~.Expr` or :py:class:`~.AlgebraicNumber` by passing a ``fmt``
+    argument. The maximal order, or ring of integers, of the field can also be
+    obtained from the :py:meth:`~.maximal_order` method, as a
+    :py:class:`~sympy.polys.numberfields.modules.Submodule`.
+
+    >>> zeta5 = exp(2*I*pi/5)
+    >>> K = QQ.algebraic_field(zeta5)
+    >>> K
+    QQ<exp(2*I*pi/5)>
+    >>> K.discriminant()
+    125
+    >>> K = QQ.algebraic_field(sqrt(5))
+    >>> K
+    QQ<sqrt(5)>
+    >>> K.integral_basis(fmt='sympy')
+    [1, 1/2 + sqrt(5)/2]
+    >>> K.maximal_order()
+    Submodule[[2, 0], [1, 1]]/2
+
+    The factorization of a rational prime into prime ideals of the field is
+    computed by the :py:meth:`~.primes_above` method, which returns a list
+    of :py:class:`~sympy.polys.numberfields.primes.PrimeIdeal` instances.
+
+    >>> zeta7 = exp(2*I*pi/7)
+    >>> K = QQ.algebraic_field(zeta7)
+    >>> K
+    QQ<exp(2*I*pi/7)>
+    >>> K.primes_above(11)
+    [(11, _x**3 + 5*_x**2 + 4*_x - 1), (11, _x**3 - 4*_x**2 - 5*_x - 1)]
+
+    The Galois group of the Galois closure of the field can be computed (when
+    the minimal polynomial of the field is of sufficiently small degree).
+
+    >>> K.galois_group(by_name=True)[0]
+    S6TransitiveSubgroups.C6
+
+    Notes
+    =====
+
+    It is not currently possible to generate an algebraic extension over any
+    domain other than :ref:`QQ`. Ideally it would be possible to generate
+    extensions like ``QQ(x)(sqrt(x**2 - 2))``. This is equivalent to the
+    quotient ring ``QQ(x)[y]/(y**2 - x**2 + 2)`` and there are two
+    implementations of this kind of quotient ring/extension in the
+    :py:class:`~.QuotientRing` and :py:class:`~.MonogenicFiniteExtension`
+    classes.  Each of those implementations needs some work to make them fully
+    usable though.
+
+    .. _algebraic number field: https://en.wikipedia.org/wiki/Algebraic_number_field
+    .. _algebraic numbers: https://en.wikipedia.org/wiki/Algebraic_number
+    .. _discriminant: https://en.wikipedia.org/wiki/Discriminant_of_an_algebraic_number_field
+    .. _integral basis: https://en.wikipedia.org/wiki/Algebraic_number_field#Integral_basis
+    .. _minimal polynomial: https://en.wikipedia.org/wiki/Minimal_polynomial_(field_theory)
+    .. _primitive element: https://en.wikipedia.org/wiki/Primitive_element_theorem
+    """
+
+    dtype = ANP
+
+    is_AlgebraicField = is_Algebraic = True
+    is_Numerical = True
+
+    has_assoc_Ring = False
+    has_assoc_Field = True
+
+    def __init__(self, dom, *ext, alias=None):
+        r"""
+        Parameters
+        ==========
+
+        dom : :py:class:`~.Domain`
+            The base field over which this is an extension field.
+            Currently only :ref:`QQ` is accepted.
+
+        *ext : One or more :py:class:`~.Expr`
+            Generators of the extension. These should be expressions that are
+            algebraic over `\mathbb{Q}`.
+
+        alias : str, :py:class:`~.Symbol`, None, optional (default=None)
+            If provided, this will be used as the alias symbol for the
+            primitive element of the :py:class:`~.AlgebraicField`.
+            If ``None``, while ``ext`` consists of exactly one
+            :py:class:`~.AlgebraicNumber`, its alias (if any) will be used.
+        """
+        if not dom.is_QQ:
+            raise DomainError("ground domain must be a rational field")
+
+        from sympy.polys.numberfields import to_number_field
+        if len(ext) == 1 and isinstance(ext[0], tuple):
+            orig_ext = ext[0][1:]
+        else:
+            orig_ext = ext
+
+        if alias is None and len(ext) == 1:
+            alias = getattr(ext[0], 'alias', None)
+
+        self.orig_ext = orig_ext
+        """
+        Original elements given to generate the extension.
+
+        >>> from sympy import QQ, sqrt
+        >>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
+        >>> K.orig_ext
+        (sqrt(2), sqrt(3))
+        """
+
+        self.ext = to_number_field(ext, alias=alias)
+        """
+        Primitive element used for the extension.
+
+        >>> from sympy import QQ, sqrt
+        >>> K = QQ.algebraic_field(sqrt(2), sqrt(3))
+        >>> K.ext
+        sqrt(2) + sqrt(3)
+        """
+
+        self.mod = self.ext.minpoly.rep
+        """
+        Minimal polynomial for the primitive element of the extension.
+
+        >>> from sympy import QQ, sqrt
+        >>> K = QQ.algebraic_field(sqrt(2))
+        >>> K.mod
+        DMP([1, 0, -2], QQ, None)
+        """
+
+        self.domain = self.dom = dom
+
+        self.ngens = 1
+        self.symbols = self.gens = (self.ext,)
+        self.unit = self([dom(1), dom(0)])
+
+        self.zero = self.dtype.zero(self.mod.rep, dom)
+        self.one = self.dtype.one(self.mod.rep, dom)
+
+        self._maximal_order = None
+        self._discriminant = None
+        self._nilradicals_mod_p = {}
+
+    def new(self, element):
+        return self.dtype(element, self.mod.rep, self.dom)
+
+    def __str__(self):
+        return str(self.dom) + '<' + str(self.ext) + '>'
+
+    def __hash__(self):
+        return hash((self.__class__.__name__, self.dtype, self.dom, self.ext))
+
+    def __eq__(self, other):
+        """Returns ``True`` if two domains are equivalent. """
+        return isinstance(other, AlgebraicField) and \
+            self.dtype == other.dtype and self.ext == other.ext
+
+    def algebraic_field(self, *extension, alias=None):
+        r"""Returns an algebraic field, i.e. `\mathbb{Q}(\alpha, \ldots)`. """
+        return AlgebraicField(self.dom, *((self.ext,) + extension), alias=alias)
+
+    def to_alg_num(self, a):
+        """Convert ``a`` of ``dtype`` to an :py:class:`~.AlgebraicNumber`. """
+        return self.ext.field_element(a)
+
+    def to_sympy(self, a):
+        """Convert ``a`` of ``dtype`` to a SymPy object. """
+        # Precompute a converter to be reused:
+        if not hasattr(self, '_converter'):
+            self._converter = _make_converter(self)
+
+        return self._converter(a)
+
+    def from_sympy(self, a):
+        """Convert SymPy's expression to ``dtype``. """
+        try:
+            return self([self.dom.from_sympy(a)])
+        except CoercionFailed:
+            pass
+
+        from sympy.polys.numberfields import to_number_field
+
+        try:
+            return self(to_number_field(a, self.ext).native_coeffs())
+        except (NotAlgebraic, IsomorphismFailed):
+            raise CoercionFailed(
+                "%s is not a valid algebraic number in %s" % (a, self))
+
+    def from_ZZ(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ_python(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpz`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpq`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_RealField(K1, a, K0):
+        """Convert a mpmath ``mpf`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        raise DomainError('there is no ring associated with %s' % self)
+
+    def is_positive(self, a):
+        """Returns True if ``a`` is positive. """
+        return self.dom.is_positive(a.LC())
+
+    def is_negative(self, a):
+        """Returns True if ``a`` is negative. """
+        return self.dom.is_negative(a.LC())
+
+    def is_nonpositive(self, a):
+        """Returns True if ``a`` is non-positive. """
+        return self.dom.is_nonpositive(a.LC())
+
+    def is_nonnegative(self, a):
+        """Returns True if ``a`` is non-negative. """
+        return self.dom.is_nonnegative(a.LC())
+
+    def numer(self, a):
+        """Returns numerator of ``a``. """
+        return a
+
+    def denom(self, a):
+        """Returns denominator of ``a``. """
+        return self.one
+
+    def from_AlgebraicField(K1, a, K0):
+        """Convert AlgebraicField element 'a' to another AlgebraicField """
+        return K1.from_sympy(K0.to_sympy(a))
+
+    def from_GaussianIntegerRing(K1, a, K0):
+        """Convert a GaussianInteger element 'a' to ``dtype``. """
+        return K1.from_sympy(K0.to_sympy(a))
+
+    def from_GaussianRationalField(K1, a, K0):
+        """Convert a GaussianRational element 'a' to ``dtype``. """
+        return K1.from_sympy(K0.to_sympy(a))
+
+    def _do_round_two(self):
+        from sympy.polys.numberfields.basis import round_two
+        ZK, dK = round_two(self, radicals=self._nilradicals_mod_p)
+        self._maximal_order = ZK
+        self._discriminant = dK
+
+    def maximal_order(self):
+        """
+        Compute the maximal order, or ring of integers, of the field.
+
+        Returns
+        =======
+
+        :py:class:`~sympy.polys.numberfields.modules.Submodule`.
+
+        See Also
+        ========
+
+        integral_basis
+
+        """
+        if self._maximal_order is None:
+            self._do_round_two()
+        return self._maximal_order
+
+    def integral_basis(self, fmt=None):
+        r"""
+        Get an integral basis for the field.
+
+        Parameters
+        ==========
+
+        fmt : str, None, optional (default=None)
+            If ``None``, return a list of :py:class:`~.ANP` instances.
+            If ``"sympy"``, convert each element of the list to an
+            :py:class:`~.Expr`, using ``self.to_sympy()``.
+            If ``"alg"``, convert each element of the list to an
+            :py:class:`~.AlgebraicNumber`, using ``self.to_alg_num()``.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, AlgebraicNumber, sqrt
+        >>> alpha = AlgebraicNumber(sqrt(5), alias='alpha')
+        >>> k = QQ.algebraic_field(alpha)
+        >>> B0 = k.integral_basis()
+        >>> B1 = k.integral_basis(fmt='sympy')
+        >>> B2 = k.integral_basis(fmt='alg')
+        >>> print(B0[1])  # doctest: +SKIP
+        ANP([mpq(1,2), mpq(1,2)], [mpq(1,1), mpq(0,1), mpq(-5,1)], QQ)
+        >>> print(B1[1])
+        1/2 + alpha/2
+        >>> print(B2[1])
+        alpha/2 + 1/2
+
+        In the last two cases we get legible expressions, which print somewhat
+        differently because of the different types involved:
+
+        >>> print(type(B1[1]))
+        <class 'sympy.core.add.Add'>
+        >>> print(type(B2[1]))
+        <class 'sympy.core.numbers.AlgebraicNumber'>
+
+        See Also
+        ========
+
+        to_sympy
+        to_alg_num
+        maximal_order
+        """
+        ZK = self.maximal_order()
+        M = ZK.QQ_matrix
+        n = M.shape[1]
+        B = [self.new(list(reversed(M[:, j].flat()))) for j in range(n)]
+        if fmt == 'sympy':
+            return [self.to_sympy(b) for b in B]
+        elif fmt == 'alg':
+            return [self.to_alg_num(b) for b in B]
+        return B
+
+    def discriminant(self):
+        """Get the discriminant of the field."""
+        if self._discriminant is None:
+            self._do_round_two()
+        return self._discriminant
+
+    def primes_above(self, p):
+        """Compute the prime ideals lying above a given rational prime *p*."""
+        from sympy.polys.numberfields.primes import prime_decomp
+        ZK = self.maximal_order()
+        dK = self.discriminant()
+        rad = self._nilradicals_mod_p.get(p)
+        return prime_decomp(p, ZK=ZK, dK=dK, radical=rad)
+
+    def galois_group(self, by_name=False, max_tries=30, randomize=False):
+        """
+        Compute the Galois group of the Galois closure of this field.
+
+        Examples
+        ========
+
+        If the field is Galois, the order of the group will equal the degree
+        of the field:
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> k = QQ.alg_field_from_poly(x**4 + 1)
+        >>> G, _ = k.galois_group()
+        >>> G.order()
+        4
+
+        If the field is not Galois, then its Galois closure is a proper
+        extension, and the order of the Galois group will be greater than the
+        degree of the field:
+
+        >>> k = QQ.alg_field_from_poly(x**4 - 2)
+        >>> G, _ = k.galois_group()
+        >>> G.order()
+        8
+
+        See Also
+        ========
+
+        sympy.polys.numberfields.galoisgroups.galois_group
+
+        """
+        return self.ext.minpoly_of_element().galois_group(
+            by_name=by_name, max_tries=max_tries, randomize=randomize)
+
+
+def _make_converter(K):
+    """Construct the converter to convert back to Expr"""
+    # Precompute the effect of converting to SymPy and expanding expressions
+    # like (sqrt(2) + sqrt(3))**2. Asking Expr to do the expansion on every
+    # conversion from K to Expr is slow. Here we compute the expansions for
+    # each power of the generator and collect together the resulting algebraic
+    # terms and the rational coefficients into a matrix.
+
+    gen = K.ext.as_expr()
+    todom = K.dom.from_sympy
+
+    # We'll let Expr compute the expansions. We won't make any presumptions
+    # about what this results in except that it is QQ-linear in some terms
+    # that we will call algebraics. The final result will be expressed in
+    # terms of those.
+    powers = [S.One, gen]
+    for n in range(2, K.mod.degree()):
+        powers.append((gen * powers[-1]).expand())
+
+    # Collect the rational coefficients and algebraic Expr that can
+    # map the ANP coefficients into an expanded SymPy expression
+    terms = [dict(t.as_coeff_Mul()[::-1] for t in Add.make_args(p)) for p in powers]
+    algebraics = set().union(*terms)
+    matrix = [[todom(t.get(a, S.Zero)) for t in terms] for a in algebraics]
+
+    # Create a function to do the conversion efficiently:
+
+    def converter(a):
+        """Convert a to Expr using converter"""
+        ai = a.rep[::-1]
+        tosympy = K.dom.to_sympy
+        coeffs_dom = [sum(mij*aj for mij, aj in zip(mi, ai)) for mi in matrix]
+        coeffs_sympy = [tosympy(c) for c in coeffs_dom]
+        res = Add(*(Mul(c, a) for c, a in zip(coeffs_sympy, algebraics)))
+        return res
+
+    return converter

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/complexfield.py

@@ -0,0 +1,151 @@
+"""Implementation of :class:`ComplexField` class. """
+
+
+from sympy.core.numbers import Float, I
+from sympy.polys.domains.characteristiczero import CharacteristicZero
+from sympy.polys.domains.field import Field
+from sympy.polys.domains.mpelements import MPContext
+from sympy.polys.domains.simpledomain import SimpleDomain
+from sympy.polys.polyerrors import DomainError, CoercionFailed
+from sympy.utilities import public
+
+@public
+class ComplexField(Field, CharacteristicZero, SimpleDomain):
+    """Complex numbers up to the given precision. """
+
+    rep = 'CC'
+
+    is_ComplexField = is_CC = True
+
+    is_Exact = False
+    is_Numerical = True
+
+    has_assoc_Ring = False
+    has_assoc_Field = True
+
+    _default_precision = 53
+
+    @property
+    def has_default_precision(self):
+        return self.precision == self._default_precision
+
+    @property
+    def precision(self):
+        return self._context.prec
+
+    @property
+    def dps(self):
+        return self._context.dps
+
+    @property
+    def tolerance(self):
+        return self._context.tolerance
+
+    def __init__(self, prec=_default_precision, dps=None, tol=None):
+        context = MPContext(prec, dps, tol, False)
+        context._parent = self
+        self._context = context
+
+        self.dtype = context.mpc
+        self.zero = self.dtype(0)
+        self.one = self.dtype(1)
+
+    def __eq__(self, other):
+        return (isinstance(other, ComplexField)
+           and self.precision == other.precision
+           and self.tolerance == other.tolerance)
+
+    def __hash__(self):
+        return hash((self.__class__.__name__, self.dtype, self.precision, self.tolerance))
+
+    def to_sympy(self, element):
+        """Convert ``element`` to SymPy number. """
+        return Float(element.real, self.dps) + I*Float(element.imag, self.dps)
+
+    def from_sympy(self, expr):
+        """Convert SymPy's number to ``dtype``. """
+        number = expr.evalf(n=self.dps)
+        real, imag = number.as_real_imag()
+
+        if real.is_Number and imag.is_Number:
+            return self.dtype(real, imag)
+        else:
+            raise CoercionFailed("expected complex number, got %s" % expr)
+
+    def from_ZZ(self, element, base):
+        return self.dtype(element)
+
+    def from_QQ(self, element, base):
+        return self.dtype(int(element.numerator)) / int(element.denominator)
+
+    def from_ZZ_python(self, element, base):
+        return self.dtype(element)
+
+    def from_QQ_python(self, element, base):
+        return self.dtype(element.numerator) / element.denominator
+
+    def from_ZZ_gmpy(self, element, base):
+        return self.dtype(int(element))
+
+    def from_QQ_gmpy(self, element, base):
+        return self.dtype(int(element.numerator)) / int(element.denominator)
+
+    def from_GaussianIntegerRing(self, element, base):
+        return self.dtype(int(element.x), int(element.y))
+
+    def from_GaussianRationalField(self, element, base):
+        x = element.x
+        y = element.y
+        return (self.dtype(int(x.numerator)) / int(x.denominator) +
+                self.dtype(0, int(y.numerator)) / int(y.denominator))
+
+    def from_AlgebraicField(self, element, base):
+        return self.from_sympy(base.to_sympy(element).evalf(self.dps))
+
+    def from_RealField(self, element, base):
+        return self.dtype(element)
+
+    def from_ComplexField(self, element, base):
+        if self == base:
+            return element
+        else:
+            return self.dtype(element)
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        raise DomainError("there is no ring associated with %s" % self)
+
+    def get_exact(self):
+        """Returns an exact domain associated with ``self``. """
+        raise DomainError("there is no exact domain associated with %s" % self)
+
+    def is_negative(self, element):
+        """Returns ``False`` for any ``ComplexElement``. """
+        return False
+
+    def is_positive(self, element):
+        """Returns ``False`` for any ``ComplexElement``. """
+        return False
+
+    def is_nonnegative(self, element):
+        """Returns ``False`` for any ``ComplexElement``. """
+        return False
+
+    def is_nonpositive(self, element):
+        """Returns ``False`` for any ``ComplexElement``. """
+        return False
+
+    def gcd(self, a, b):
+        """Returns GCD of ``a`` and ``b``. """
+        return self.one
+
+    def lcm(self, a, b):
+        """Returns LCM of ``a`` and ``b``. """
+        return a*b
+
+    def almosteq(self, a, b, tolerance=None):
+        """Check if ``a`` and ``b`` are almost equal. """
+        return self._context.almosteq(a, b, tolerance)
+
+
+CC = ComplexField()

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/domain.py

@@ -0,0 +1,1304 @@
+"""Implementation of :class:`Domain` class. """
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.core.numbers import AlgebraicNumber
+from sympy.core import Basic, sympify
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.external.gmpy import HAS_GMPY
+from sympy.polys.domains.domainelement import DomainElement
+from sympy.polys.orderings import lex
+from sympy.polys.polyerrors import UnificationFailed, CoercionFailed, DomainError
+from sympy.polys.polyutils import _unify_gens, _not_a_coeff
+from sympy.utilities import public
+from sympy.utilities.iterables import is_sequence
+
+
+@public
+class Domain:
+    """Superclass for all domains in the polys domains system.
+
+    See :ref:`polys-domainsintro` for an introductory explanation of the
+    domains system.
+
+    The :py:class:`~.Domain` class is an abstract base class for all of the
+    concrete domain types. There are many different :py:class:`~.Domain`
+    subclasses each of which has an associated ``dtype`` which is a class
+    representing the elements of the domain. The coefficients of a
+    :py:class:`~.Poly` are elements of a domain which must be a subclass of
+    :py:class:`~.Domain`.
+
+    Examples
+    ========
+
+    The most common example domains are the integers :ref:`ZZ` and the
+    rationals :ref:`QQ`.
+
+    >>> from sympy import Poly, symbols, Domain
+    >>> x, y = symbols('x, y')
+    >>> p = Poly(x**2 + y)
+    >>> p
+    Poly(x**2 + y, x, y, domain='ZZ')
+    >>> p.domain
+    ZZ
+    >>> isinstance(p.domain, Domain)
+    True
+    >>> Poly(x**2 + y/2)
+    Poly(x**2 + 1/2*y, x, y, domain='QQ')
+
+    The domains can be used directly in which case the domain object e.g.
+    (:ref:`ZZ` or :ref:`QQ`) can be used as a constructor for elements of
+    ``dtype``.
+
+    >>> from sympy import ZZ, QQ
+    >>> ZZ(2)
+    2
+    >>> ZZ.dtype  # doctest: +SKIP
+    <class 'int'>
+    >>> type(ZZ(2))  # doctest: +SKIP
+    <class 'int'>
+    >>> QQ(1, 2)
+    1/2
+    >>> type(QQ(1, 2))  # doctest: +SKIP
+    <class 'sympy.polys.domains.pythonrational.PythonRational'>
+
+    The corresponding domain elements can be used with the arithmetic
+    operations ``+,-,*,**`` and depending on the domain some combination of
+    ``/,//,%`` might be usable. For example in :ref:`ZZ` both ``//`` (floor
+    division) and ``%`` (modulo division) can be used but ``/`` (true
+    division) cannot. Since :ref:`QQ` is a :py:class:`~.Field` its elements
+    can be used with ``/`` but ``//`` and ``%`` should not be used. Some
+    domains have a :py:meth:`~.Domain.gcd` method.
+
+    >>> ZZ(2) + ZZ(3)
+    5
+    >>> ZZ(5) // ZZ(2)
+    2
+    >>> ZZ(5) % ZZ(2)
+    1
+    >>> QQ(1, 2) / QQ(2, 3)
+    3/4
+    >>> ZZ.gcd(ZZ(4), ZZ(2))
+    2
+    >>> QQ.gcd(QQ(2,7), QQ(5,3))
+    1/21
+    >>> ZZ.is_Field
+    False
+    >>> QQ.is_Field
+    True
+
+    There are also many other domains including:
+
+        1. :ref:`GF(p)` for finite fields of prime order.
+        2. :ref:`RR` for real (floating point) numbers.
+        3. :ref:`CC` for complex (floating point) numbers.
+        4. :ref:`QQ(a)` for algebraic number fields.
+        5. :ref:`K[x]` for polynomial rings.
+        6. :ref:`K(x)` for rational function fields.
+        7. :ref:`EX` for arbitrary expressions.
+
+    Each domain is represented by a domain object and also an implementation
+    class (``dtype``) for the elements of the domain. For example the
+    :ref:`K[x]` domains are represented by a domain object which is an
+    instance of :py:class:`~.PolynomialRing` and the elements are always
+    instances of :py:class:`~.PolyElement`. The implementation class
+    represents particular types of mathematical expressions in a way that is
+    more efficient than a normal SymPy expression which is of type
+    :py:class:`~.Expr`. The domain methods :py:meth:`~.Domain.from_sympy` and
+    :py:meth:`~.Domain.to_sympy` are used to convert from :py:class:`~.Expr`
+    to a domain element and vice versa.
+
+    >>> from sympy import Symbol, ZZ, Expr
+    >>> x = Symbol('x')
+    >>> K = ZZ[x]           # polynomial ring domain
+    >>> K
+    ZZ[x]
+    >>> type(K)             # class of the domain
+    <class 'sympy.polys.domains.polynomialring.PolynomialRing'>
+    >>> K.dtype             # class of the elements
+    <class 'sympy.polys.rings.PolyElement'>
+    >>> p_expr = x**2 + 1   # Expr
+    >>> p_expr
+    x**2 + 1
+    >>> type(p_expr)
+    <class 'sympy.core.add.Add'>
+    >>> isinstance(p_expr, Expr)
+    True
+    >>> p_domain = K.from_sympy(p_expr)
+    >>> p_domain            # domain element
+    x**2 + 1
+    >>> type(p_domain)
+    <class 'sympy.polys.rings.PolyElement'>
+    >>> K.to_sympy(p_domain) == p_expr
+    True
+
+    The :py:meth:`~.Domain.convert_from` method is used to convert domain
+    elements from one domain to another.
+
+    >>> from sympy import ZZ, QQ
+    >>> ez = ZZ(2)
+    >>> eq = QQ.convert_from(ez, ZZ)
+    >>> type(ez)  # doctest: +SKIP
+    <class 'int'>
+    >>> type(eq)  # doctest: +SKIP
+    <class 'sympy.polys.domains.pythonrational.PythonRational'>
+
+    Elements from different domains should not be mixed in arithmetic or other
+    operations: they should be converted to a common domain first.  The domain
+    method :py:meth:`~.Domain.unify` is used to find a domain that can
+    represent all the elements of two given domains.
+
+    >>> from sympy import ZZ, QQ, symbols
+    >>> x, y = symbols('x, y')
+    >>> ZZ.unify(QQ)
+    QQ
+    >>> ZZ[x].unify(QQ)
+    QQ[x]
+    >>> ZZ[x].unify(QQ[y])
+    QQ[x,y]
+
+    If a domain is a :py:class:`~.Ring` then is might have an associated
+    :py:class:`~.Field` and vice versa. The :py:meth:`~.Domain.get_field` and
+    :py:meth:`~.Domain.get_ring` methods will find or create the associated
+    domain.
+
+    >>> from sympy import ZZ, QQ, Symbol
+    >>> x = Symbol('x')
+    >>> ZZ.has_assoc_Field
+    True
+    >>> ZZ.get_field()
+    QQ
+    >>> QQ.has_assoc_Ring
+    True
+    >>> QQ.get_ring()
+    ZZ
+    >>> K = QQ[x]
+    >>> K
+    QQ[x]
+    >>> K.get_field()
+    QQ(x)
+
+    See also
+    ========
+
+    DomainElement: abstract base class for domain elements
+    construct_domain: construct a minimal domain for some expressions
+
+    """
+
+    dtype: type | None = None
+    """The type (class) of the elements of this :py:class:`~.Domain`:
+
+    >>> from sympy import ZZ, QQ, Symbol
+    >>> ZZ.dtype
+    <class 'int'>
+    >>> z = ZZ(2)
+    >>> z
+    2
+    >>> type(z)
+    <class 'int'>
+    >>> type(z) == ZZ.dtype
+    True
+
+    Every domain has an associated **dtype** ("datatype") which is the
+    class of the associated domain elements.
+
+    See also
+    ========
+
+    of_type
+    """
+
+    zero: Any = None
+    """The zero element of the :py:class:`~.Domain`:
+
+    >>> from sympy import QQ
+    >>> QQ.zero
+    0
+    >>> QQ.of_type(QQ.zero)
+    True
+
+    See also
+    ========
+
+    of_type
+    one
+    """
+
+    one: Any = None
+    """The one element of the :py:class:`~.Domain`:
+
+    >>> from sympy import QQ
+    >>> QQ.one
+    1
+    >>> QQ.of_type(QQ.one)
+    True
+
+    See also
+    ========
+
+    of_type
+    zero
+    """
+
+    is_Ring = False
+    """Boolean flag indicating if the domain is a :py:class:`~.Ring`.
+
+    >>> from sympy import ZZ
+    >>> ZZ.is_Ring
+    True
+
+    Basically every :py:class:`~.Domain` represents a ring so this flag is
+    not that useful.
+
+    See also
+    ========
+
+    is_PID
+    is_Field
+    get_ring
+    has_assoc_Ring
+    """
+
+    is_Field = False
+    """Boolean flag indicating if the domain is a :py:class:`~.Field`.
+
+    >>> from sympy import ZZ, QQ
+    >>> ZZ.is_Field
+    False
+    >>> QQ.is_Field
+    True
+
+    See also
+    ========
+
+    is_PID
+    is_Ring
+    get_field
+    has_assoc_Field
+    """
+
+    has_assoc_Ring = False
+    """Boolean flag indicating if the domain has an associated
+    :py:class:`~.Ring`.
+
+    >>> from sympy import QQ
+    >>> QQ.has_assoc_Ring
+    True
+    >>> QQ.get_ring()
+    ZZ
+
+    See also
+    ========
+
+    is_Field
+    get_ring
+    """
+
+    has_assoc_Field = False
+    """Boolean flag indicating if the domain has an associated
+    :py:class:`~.Field`.
+
+    >>> from sympy import ZZ
+    >>> ZZ.has_assoc_Field
+    True
+    >>> ZZ.get_field()
+    QQ
+
+    See also
+    ========
+
+    is_Field
+    get_field
+    """
+
+    is_FiniteField = is_FF = False
+    is_IntegerRing = is_ZZ = False
+    is_RationalField = is_QQ = False
+    is_GaussianRing = is_ZZ_I = False
+    is_GaussianField = is_QQ_I = False
+    is_RealField = is_RR = False
+    is_ComplexField = is_CC = False
+    is_AlgebraicField = is_Algebraic = False
+    is_PolynomialRing = is_Poly = False
+    is_FractionField = is_Frac = False
+    is_SymbolicDomain = is_EX = False
+    is_SymbolicRawDomain = is_EXRAW = False
+    is_FiniteExtension = False
+
+    is_Exact = True
+    is_Numerical = False
+
+    is_Simple = False
+    is_Composite = False
+
+    is_PID = False
+    """Boolean flag indicating if the domain is a `principal ideal domain`_.
+
+    >>> from sympy import ZZ
+    >>> ZZ.has_assoc_Field
+    True
+    >>> ZZ.get_field()
+    QQ
+
+    .. _principal ideal domain: https://en.wikipedia.org/wiki/Principal_ideal_domain
+
+    See also
+    ========
+
+    is_Field
+    get_field
+    """
+
+    has_CharacteristicZero = False
+
+    rep: str | None = None
+    alias: str | None = None
+
+    def __init__(self):
+        raise NotImplementedError
+
+    def __str__(self):
+        return self.rep
+
+    def __repr__(self):
+        return str(self)
+
+    def __hash__(self):
+        return hash((self.__class__.__name__, self.dtype))
+
+    def new(self, *args):
+        return self.dtype(*args)
+
+    @property
+    def tp(self):
+        """Alias for :py:attr:`~.Domain.dtype`"""
+        return self.dtype
+
+    def __call__(self, *args):
+        """Construct an element of ``self`` domain from ``args``. """
+        return self.new(*args)
+
+    def normal(self, *args):
+        return self.dtype(*args)
+
+    def convert_from(self, element, base):
+        """Convert ``element`` to ``self.dtype`` given the base domain. """
+        if base.alias is not None:
+            method = "from_" + base.alias
+        else:
+            method = "from_" + base.__class__.__name__
+
+        _convert = getattr(self, method)
+
+        if _convert is not None:
+            result = _convert(element, base)
+
+            if result is not None:
+                return result
+
+        raise CoercionFailed("Cannot convert %s of type %s from %s to %s" % (element, type(element), base, self))
+
+    def convert(self, element, base=None):
+        """Convert ``element`` to ``self.dtype``. """
+
+        if base is not None:
+            if _not_a_coeff(element):
+                raise CoercionFailed('%s is not in any domain' % element)
+            return self.convert_from(element, base)
+
+        if self.of_type(element):
+            return element
+
+        if _not_a_coeff(element):
+            raise CoercionFailed('%s is not in any domain' % element)
+
+        from sympy.polys.domains import ZZ, QQ, RealField, ComplexField
+
+        if ZZ.of_type(element):
+            return self.convert_from(element, ZZ)
+
+        if isinstance(element, int):
+            return self.convert_from(ZZ(element), ZZ)
+
+        if HAS_GMPY:
+            integers = ZZ
+            if isinstance(element, integers.tp):
+                return self.convert_from(element, integers)
+
+            rationals = QQ
+            if isinstance(element, rationals.tp):
+                return self.convert_from(element, rationals)
+
+        if isinstance(element, float):
+            parent = RealField(tol=False)
+            return self.convert_from(parent(element), parent)
+
+        if isinstance(element, complex):
+            parent = ComplexField(tol=False)
+            return self.convert_from(parent(element), parent)
+
+        if isinstance(element, DomainElement):
+            return self.convert_from(element, element.parent())
+
+        # TODO: implement this in from_ methods
+        if self.is_Numerical and getattr(element, 'is_ground', False):
+            return self.convert(element.LC())
+
+        if isinstance(element, Basic):
+            try:
+                return self.from_sympy(element)
+            except (TypeError, ValueError):
+                pass
+        else: # TODO: remove this branch
+            if not is_sequence(element):
+                try:
+                    element = sympify(element, strict=True)
+                    if isinstance(element, Basic):
+                        return self.from_sympy(element)
+                except (TypeError, ValueError):
+                    pass
+
+        raise CoercionFailed("Cannot convert %s of type %s to %s" % (element, type(element), self))
+
+    def of_type(self, element):
+        """Check if ``a`` is of type ``dtype``. """
+        return isinstance(element, self.tp) # XXX: this isn't correct, e.g. PolyElement
+
+    def __contains__(self, a):
+        """Check if ``a`` belongs to this domain. """
+        try:
+            if _not_a_coeff(a):
+                raise CoercionFailed
+            self.convert(a)  # this might raise, too
+        except CoercionFailed:
+            return False
+
+        return True
+
+    def to_sympy(self, a):
+        """Convert domain element *a* to a SymPy expression (Expr).
+
+        Explanation
+        ===========
+
+        Convert a :py:class:`~.Domain` element *a* to :py:class:`~.Expr`. Most
+        public SymPy functions work with objects of type :py:class:`~.Expr`.
+        The elements of a :py:class:`~.Domain` have a different internal
+        representation. It is not possible to mix domain elements with
+        :py:class:`~.Expr` so each domain has :py:meth:`~.Domain.to_sympy` and
+        :py:meth:`~.Domain.from_sympy` methods to convert its domain elements
+        to and from :py:class:`~.Expr`.
+
+        Parameters
+        ==========
+
+        a: domain element
+            An element of this :py:class:`~.Domain`.
+
+        Returns
+        =======
+
+        expr: Expr
+            A normal SymPy expression of type :py:class:`~.Expr`.
+
+        Examples
+        ========
+
+        Construct an element of the :ref:`QQ` domain and then convert it to
+        :py:class:`~.Expr`.
+
+        >>> from sympy import QQ, Expr
+        >>> q_domain = QQ(2)
+        >>> q_domain
+        2
+        >>> q_expr = QQ.to_sympy(q_domain)
+        >>> q_expr
+        2
+
+        Although the printed forms look similar these objects are not of the
+        same type.
+
+        >>> isinstance(q_domain, Expr)
+        False
+        >>> isinstance(q_expr, Expr)
+        True
+
+        Construct an element of :ref:`K[x]` and convert to
+        :py:class:`~.Expr`.
+
+        >>> from sympy import Symbol
+        >>> x = Symbol('x')
+        >>> K = QQ[x]
+        >>> x_domain = K.gens[0]  # generator x as a domain element
+        >>> p_domain = x_domain**2/3 + 1
+        >>> p_domain
+        1/3*x**2 + 1
+        >>> p_expr = K.to_sympy(p_domain)
+        >>> p_expr
+        x**2/3 + 1
+
+        The :py:meth:`~.Domain.from_sympy` method is used for the opposite
+        conversion from a normal SymPy expression to a domain element.
+
+        >>> p_domain == p_expr
+        False
+        >>> K.from_sympy(p_expr) == p_domain
+        True
+        >>> K.to_sympy(p_domain) == p_expr
+        True
+        >>> K.from_sympy(K.to_sympy(p_domain)) == p_domain
+        True
+        >>> K.to_sympy(K.from_sympy(p_expr)) == p_expr
+        True
+
+        The :py:meth:`~.Domain.from_sympy` method makes it easier to construct
+        domain elements interactively.
+
+        >>> from sympy import Symbol
+        >>> x = Symbol('x')
+        >>> K = QQ[x]
+        >>> K.from_sympy(x**2/3 + 1)
+        1/3*x**2 + 1
+
+        See also
+        ========
+
+        from_sympy
+        convert_from
+        """
+        raise NotImplementedError
+
+    def from_sympy(self, a):
+        """Convert a SymPy expression to an element of this domain.
+
+        Explanation
+        ===========
+
+        See :py:meth:`~.Domain.to_sympy` for explanation and examples.
+
+        Parameters
+        ==========
+
+        expr: Expr
+            A normal SymPy expression of type :py:class:`~.Expr`.
+
+        Returns
+        =======
+
+        a: domain element
+            An element of this :py:class:`~.Domain`.
+
+        See also
+        ========
+
+        to_sympy
+        convert_from
+        """
+        raise NotImplementedError
+
+    def sum(self, args):
+        return sum(args)
+
+    def from_FF(K1, a, K0):
+        """Convert ``ModularInteger(int)`` to ``dtype``. """
+        return None
+
+    def from_FF_python(K1, a, K0):
+        """Convert ``ModularInteger(int)`` to ``dtype``. """
+        return None
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return None
+
+    def from_QQ_python(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return None
+
+    def from_FF_gmpy(K1, a, K0):
+        """Convert ``ModularInteger(mpz)`` to ``dtype``. """
+        return None
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpz`` object to ``dtype``. """
+        return None
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpq`` object to ``dtype``. """
+        return None
+
+    def from_RealField(K1, a, K0):
+        """Convert a real element object to ``dtype``. """
+        return None
+
+    def from_ComplexField(K1, a, K0):
+        """Convert a complex element to ``dtype``. """
+        return None
+
+    def from_AlgebraicField(K1, a, K0):
+        """Convert an algebraic number to ``dtype``. """
+        return None
+
+    def from_PolynomialRing(K1, a, K0):
+        """Convert a polynomial to ``dtype``. """
+        if a.is_ground:
+            return K1.convert(a.LC, K0.dom)
+
+    def from_FractionField(K1, a, K0):
+        """Convert a rational function to ``dtype``. """
+        return None
+
+    def from_MonogenicFiniteExtension(K1, a, K0):
+        """Convert an ``ExtensionElement`` to ``dtype``. """
+        return K1.convert_from(a.rep, K0.ring)
+
+    def from_ExpressionDomain(K1, a, K0):
+        """Convert a ``EX`` object to ``dtype``. """
+        return K1.from_sympy(a.ex)
+
+    def from_ExpressionRawDomain(K1, a, K0):
+        """Convert a ``EX`` object to ``dtype``. """
+        return K1.from_sympy(a)
+
+    def from_GlobalPolynomialRing(K1, a, K0):
+        """Convert a polynomial to ``dtype``. """
+        if a.degree() <= 0:
+            return K1.convert(a.LC(), K0.dom)
+
+    def from_GeneralizedPolynomialRing(K1, a, K0):
+        return K1.from_FractionField(a, K0)
+
+    def unify_with_symbols(K0, K1, symbols):
+        if (K0.is_Composite and (set(K0.symbols) & set(symbols))) or (K1.is_Composite and (set(K1.symbols) & set(symbols))):
+            raise UnificationFailed("Cannot unify %s with %s, given %s generators" % (K0, K1, tuple(symbols)))
+
+        return K0.unify(K1)
+
+    def unify(K0, K1, symbols=None):
+        """
+        Construct a minimal domain that contains elements of ``K0`` and ``K1``.
+
+        Known domains (from smallest to largest):
+
+        - ``GF(p)``
+        - ``ZZ``
+        - ``QQ``
+        - ``RR(prec, tol)``
+        - ``CC(prec, tol)``
+        - ``ALG(a, b, c)``
+        - ``K[x, y, z]``
+        - ``K(x, y, z)``
+        - ``EX``
+
+        """
+        if symbols is not None:
+            return K0.unify_with_symbols(K1, symbols)
+
+        if K0 == K1:
+            return K0
+
+        if K0.is_EXRAW:
+            return K0
+        if K1.is_EXRAW:
+            return K1
+
+        if K0.is_EX:
+            return K0
+        if K1.is_EX:
+            return K1
+
+        if K0.is_FiniteExtension or K1.is_FiniteExtension:
+            if K1.is_FiniteExtension:
+                K0, K1 = K1, K0
+            if K1.is_FiniteExtension:
+                # Unifying two extensions.
+                # Try to ensure that K0.unify(K1) == K1.unify(K0)
+                if list(ordered([K0.modulus, K1.modulus]))[1] == K0.modulus:
+                    K0, K1 = K1, K0
+                return K1.set_domain(K0)
+            else:
+                # Drop the generator from other and unify with the base domain
+                K1 = K1.drop(K0.symbol)
+                K1 = K0.domain.unify(K1)
+                return K0.set_domain(K1)
+
+        if K0.is_Composite or K1.is_Composite:
+            K0_ground = K0.dom if K0.is_Composite else K0
+            K1_ground = K1.dom if K1.is_Composite else K1
+
+            K0_symbols = K0.symbols if K0.is_Composite else ()
+            K1_symbols = K1.symbols if K1.is_Composite else ()
+
+            domain = K0_ground.unify(K1_ground)
+            symbols = _unify_gens(K0_symbols, K1_symbols)
+            order = K0.order if K0.is_Composite else K1.order
+
+            if ((K0.is_FractionField and K1.is_PolynomialRing or
+                 K1.is_FractionField and K0.is_PolynomialRing) and
+                 (not K0_ground.is_Field or not K1_ground.is_Field) and domain.is_Field
+                 and domain.has_assoc_Ring):
+                domain = domain.get_ring()
+
+            if K0.is_Composite and (not K1.is_Composite or K0.is_FractionField or K1.is_PolynomialRing):
+                cls = K0.__class__
+            else:
+                cls = K1.__class__
+
+            from sympy.polys.domains.old_polynomialring import GlobalPolynomialRing
+            if cls == GlobalPolynomialRing:
+                return cls(domain, symbols)
+
+            return cls(domain, symbols, order)
+
+        def mkinexact(cls, K0, K1):
+            prec = max(K0.precision, K1.precision)
+            tol = max(K0.tolerance, K1.tolerance)
+            return cls(prec=prec, tol=tol)
+
+        if K1.is_ComplexField:
+            K0, K1 = K1, K0
+        if K0.is_ComplexField:
+            if K1.is_ComplexField or K1.is_RealField:
+                return mkinexact(K0.__class__, K0, K1)
+            else:
+                return K0
+
+        if K1.is_RealField:
+            K0, K1 = K1, K0
+        if K0.is_RealField:
+            if K1.is_RealField:
+                return mkinexact(K0.__class__, K0, K1)
+            elif K1.is_GaussianRing or K1.is_GaussianField:
+                from sympy.polys.domains.complexfield import ComplexField
+                return ComplexField(prec=K0.precision, tol=K0.tolerance)
+            else:
+                return K0
+
+        if K1.is_AlgebraicField:
+            K0, K1 = K1, K0
+        if K0.is_AlgebraicField:
+            if K1.is_GaussianRing:
+                K1 = K1.get_field()
+            if K1.is_GaussianField:
+                K1 = K1.as_AlgebraicField()
+            if K1.is_AlgebraicField:
+                return K0.__class__(K0.dom.unify(K1.dom), *_unify_gens(K0.orig_ext, K1.orig_ext))
+            else:
+                return K0
+
+        if K0.is_GaussianField:
+            return K0
+        if K1.is_GaussianField:
+            return K1
+
+        if K0.is_GaussianRing:
+            if K1.is_RationalField:
+                K0 = K0.get_field()
+            return K0
+        if K1.is_GaussianRing:
+            if K0.is_RationalField:
+                K1 = K1.get_field()
+            return K1
+
+        if K0.is_RationalField:
+            return K0
+        if K1.is_RationalField:
+            return K1
+
+        if K0.is_IntegerRing:
+            return K0
+        if K1.is_IntegerRing:
+            return K1
+
+        if K0.is_FiniteField and K1.is_FiniteField:
+            return K0.__class__(max(K0.mod, K1.mod, key=default_sort_key))
+
+        from sympy.polys.domains import EX
+        return EX
+
+    def __eq__(self, other):
+        """Returns ``True`` if two domains are equivalent. """
+        return isinstance(other, Domain) and self.dtype == other.dtype
+
+    def __ne__(self, other):
+        """Returns ``False`` if two domains are equivalent. """
+        return not self == other
+
+    def map(self, seq):
+        """Rersively apply ``self`` to all elements of ``seq``. """
+        result = []
+
+        for elt in seq:
+            if isinstance(elt, list):
+                result.append(self.map(elt))
+            else:
+                result.append(self(elt))
+
+        return result
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        raise DomainError('there is no ring associated with %s' % self)
+
+    def get_field(self):
+        """Returns a field associated with ``self``. """
+        raise DomainError('there is no field associated with %s' % self)
+
+    def get_exact(self):
+        """Returns an exact domain associated with ``self``. """
+        return self
+
+    def __getitem__(self, symbols):
+        """The mathematical way to make a polynomial ring. """
+        if hasattr(symbols, '__iter__'):
+            return self.poly_ring(*symbols)
+        else:
+            return self.poly_ring(symbols)
+
+    def poly_ring(self, *symbols, order=lex):
+        """Returns a polynomial ring, i.e. `K[X]`. """
+        from sympy.polys.domains.polynomialring import PolynomialRing
+        return PolynomialRing(self, symbols, order)
+
+    def frac_field(self, *symbols, order=lex):
+        """Returns a fraction field, i.e. `K(X)`. """
+        from sympy.polys.domains.fractionfield import FractionField
+        return FractionField(self, symbols, order)
+
+    def old_poly_ring(self, *symbols, **kwargs):
+        """Returns a polynomial ring, i.e. `K[X]`. """
+        from sympy.polys.domains.old_polynomialring import PolynomialRing
+        return PolynomialRing(self, *symbols, **kwargs)
+
+    def old_frac_field(self, *symbols, **kwargs):
+        """Returns a fraction field, i.e. `K(X)`. """
+        from sympy.polys.domains.old_fractionfield import FractionField
+        return FractionField(self, *symbols, **kwargs)
+
+    def algebraic_field(self, *extension, alias=None):
+        r"""Returns an algebraic field, i.e. `K(\alpha, \ldots)`. """
+        raise DomainError("Cannot create algebraic field over %s" % self)
+
+    def alg_field_from_poly(self, poly, alias=None, root_index=-1):
+        r"""
+        Convenience method to construct an algebraic extension on a root of a
+        polynomial, chosen by root index.
+
+        Parameters
+        ==========
+
+        poly : :py:class:`~.Poly`
+            The polynomial whose root generates the extension.
+        alias : str, optional (default=None)
+            Symbol name for the generator of the extension.
+            E.g. "alpha" or "theta".
+        root_index : int, optional (default=-1)
+            Specifies which root of the polynomial is desired. The ordering is
+            as defined by the :py:class:`~.ComplexRootOf` class. The default of
+            ``-1`` selects the most natural choice in the common cases of
+            quadratic and cyclotomic fields (the square root on the positive
+            real or imaginary axis, resp. $\mathrm{e}^{2\pi i/n}$).
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, Poly
+        >>> from sympy.abc import x
+        >>> f = Poly(x**2 - 2)
+        >>> K = QQ.alg_field_from_poly(f)
+        >>> K.ext.minpoly == f
+        True
+        >>> g = Poly(8*x**3 - 6*x - 1)
+        >>> L = QQ.alg_field_from_poly(g, "alpha")
+        >>> L.ext.minpoly == g
+        True
+        >>> L.to_sympy(L([1, 1, 1]))
+        alpha**2 + alpha + 1
+
+        """
+        from sympy.polys.rootoftools import CRootOf
+        root = CRootOf(poly, root_index)
+        alpha = AlgebraicNumber(root, alias=alias)
+        return self.algebraic_field(alpha, alias=alias)
+
+    def cyclotomic_field(self, n, ss=False, alias="zeta", gen=None, root_index=-1):
+        r"""
+        Convenience method to construct a cyclotomic field.
+
+        Parameters
+        ==========
+
+        n : int
+            Construct the nth cyclotomic field.
+        ss : boolean, optional (default=False)
+            If True, append *n* as a subscript on the alias string.
+        alias : str, optional (default="zeta")
+            Symbol name for the generator.
+        gen : :py:class:`~.Symbol`, optional (default=None)
+            Desired variable for the cyclotomic polynomial that defines the
+            field. If ``None``, a dummy variable will be used.
+        root_index : int, optional (default=-1)
+            Specifies which root of the polynomial is desired. The ordering is
+            as defined by the :py:class:`~.ComplexRootOf` class. The default of
+            ``-1`` selects the root $\mathrm{e}^{2\pi i/n}$.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, latex
+        >>> K = QQ.cyclotomic_field(5)
+        >>> K.to_sympy(K([-1, 1]))
+        1 - zeta
+        >>> L = QQ.cyclotomic_field(7, True)
+        >>> a = L.to_sympy(L([-1, 1]))
+        >>> print(a)
+        1 - zeta7
+        >>> print(latex(a))
+        1 - \zeta_{7}
+
+        """
+        from sympy.polys.specialpolys import cyclotomic_poly
+        if ss:
+            alias += str(n)
+        return self.alg_field_from_poly(cyclotomic_poly(n, gen), alias=alias,
+                                        root_index=root_index)
+
+    def inject(self, *symbols):
+        """Inject generators into this domain. """
+        raise NotImplementedError
+
+    def drop(self, *symbols):
+        """Drop generators from this domain. """
+        if self.is_Simple:
+            return self
+        raise NotImplementedError  # pragma: no cover
+
+    def is_zero(self, a):
+        """Returns True if ``a`` is zero. """
+        return not a
+
+    def is_one(self, a):
+        """Returns True if ``a`` is one. """
+        return a == self.one
+
+    def is_positive(self, a):
+        """Returns True if ``a`` is positive. """
+        return a > 0
+
+    def is_negative(self, a):
+        """Returns True if ``a`` is negative. """
+        return a < 0
+
+    def is_nonpositive(self, a):
+        """Returns True if ``a`` is non-positive. """
+        return a <= 0
+
+    def is_nonnegative(self, a):
+        """Returns True if ``a`` is non-negative. """
+        return a >= 0
+
+    def canonical_unit(self, a):
+        if self.is_negative(a):
+            return -self.one
+        else:
+            return self.one
+
+    def abs(self, a):
+        """Absolute value of ``a``, implies ``__abs__``. """
+        return abs(a)
+
+    def neg(self, a):
+        """Returns ``a`` negated, implies ``__neg__``. """
+        return -a
+
+    def pos(self, a):
+        """Returns ``a`` positive, implies ``__pos__``. """
+        return +a
+
+    def add(self, a, b):
+        """Sum of ``a`` and ``b``, implies ``__add__``.  """
+        return a + b
+
+    def sub(self, a, b):
+        """Difference of ``a`` and ``b``, implies ``__sub__``.  """
+        return a - b
+
+    def mul(self, a, b):
+        """Product of ``a`` and ``b``, implies ``__mul__``.  """
+        return a * b
+
+    def pow(self, a, b):
+        """Raise ``a`` to power ``b``, implies ``__pow__``.  """
+        return a ** b
+
+    def exquo(self, a, b):
+        """Exact quotient of *a* and *b*. Analogue of ``a / b``.
+
+        Explanation
+        ===========
+
+        This is essentially the same as ``a / b`` except that an error will be
+        raised if the division is inexact (if there is any remainder) and the
+        result will always be a domain element. When working in a
+        :py:class:`~.Domain` that is not a :py:class:`~.Field` (e.g. :ref:`ZZ`
+        or :ref:`K[x]`) ``exquo`` should be used instead of ``/``.
+
+        The key invariant is that if ``q = K.exquo(a, b)`` (and ``exquo`` does
+        not raise an exception) then ``a == b*q``.
+
+        Examples
+        ========
+
+        We can use ``K.exquo`` instead of ``/`` for exact division.
+
+        >>> from sympy import ZZ
+        >>> ZZ.exquo(ZZ(4), ZZ(2))
+        2
+        >>> ZZ.exquo(ZZ(5), ZZ(2))
+        Traceback (most recent call last):
+            ...
+        ExactQuotientFailed: 2 does not divide 5 in ZZ
+
+        Over a :py:class:`~.Field` such as :ref:`QQ`, division (with nonzero
+        divisor) is always exact so in that case ``/`` can be used instead of
+        :py:meth:`~.Domain.exquo`.
+
+        >>> from sympy import QQ
+        >>> QQ.exquo(QQ(5), QQ(2))
+        5/2
+        >>> QQ(5) / QQ(2)
+        5/2
+
+        Parameters
+        ==========
+
+        a: domain element
+            The dividend
+        b: domain element
+            The divisor
+
+        Returns
+        =======
+
+        q: domain element
+            The exact quotient
+
+        Raises
+        ======
+
+        ExactQuotientFailed: if exact division is not possible.
+        ZeroDivisionError: when the divisor is zero.
+
+        See also
+        ========
+
+        quo: Analogue of ``a // b``
+        rem: Analogue of ``a % b``
+        div: Analogue of ``divmod(a, b)``
+
+        Notes
+        =====
+
+        Since the default :py:attr:`~.Domain.dtype` for :ref:`ZZ` is ``int``
+        (or ``mpz``) division as ``a / b`` should not be used as it would give
+        a ``float``.
+
+        >>> ZZ(4) / ZZ(2)
+        2.0
+        >>> ZZ(5) / ZZ(2)
+        2.5
+
+        Using ``/`` with :ref:`ZZ` will lead to incorrect results so
+        :py:meth:`~.Domain.exquo` should be used instead.
+
+        """
+        raise NotImplementedError
+
+    def quo(self, a, b):
+        """Quotient of *a* and *b*. Analogue of ``a // b``.
+
+        ``K.quo(a, b)`` is equivalent to ``K.div(a, b)[0]``. See
+        :py:meth:`~.Domain.div` for more explanation.
+
+        See also
+        ========
+
+        rem: Analogue of ``a % b``
+        div: Analogue of ``divmod(a, b)``
+        exquo: Analogue of ``a / b``
+        """
+        raise NotImplementedError
+
+    def rem(self, a, b):
+        """Modulo division of *a* and *b*. Analogue of ``a % b``.
+
+        ``K.rem(a, b)`` is equivalent to ``K.div(a, b)[1]``. See
+        :py:meth:`~.Domain.div` for more explanation.
+
+        See also
+        ========
+
+        quo: Analogue of ``a // b``
+        div: Analogue of ``divmod(a, b)``
+        exquo: Analogue of ``a / b``
+        """
+        raise NotImplementedError
+
+    def div(self, a, b):
+        """Quotient and remainder for *a* and *b*. Analogue of ``divmod(a, b)``
+
+        Explanation
+        ===========
+
+        This is essentially the same as ``divmod(a, b)`` except that is more
+        consistent when working over some :py:class:`~.Field` domains such as
+        :ref:`QQ`. When working over an arbitrary :py:class:`~.Domain` the
+        :py:meth:`~.Domain.div` method should be used instead of ``divmod``.
+
+        The key invariant is that if ``q, r = K.div(a, b)`` then
+        ``a == b*q + r``.
+
+        The result of ``K.div(a, b)`` is the same as the tuple
+        ``(K.quo(a, b), K.rem(a, b))`` except that if both quotient and
+        remainder are needed then it is more efficient to use
+        :py:meth:`~.Domain.div`.
+
+        Examples
+        ========
+
+        We can use ``K.div`` instead of ``divmod`` for floor division and
+        remainder.
+
+        >>> from sympy import ZZ, QQ
+        >>> ZZ.div(ZZ(5), ZZ(2))
+        (2, 1)
+
+        If ``K`` is a :py:class:`~.Field` then the division is always exact
+        with a remainder of :py:attr:`~.Domain.zero`.
+
+        >>> QQ.div(QQ(5), QQ(2))
+        (5/2, 0)
+
+        Parameters
+        ==========
+
+        a: domain element
+            The dividend
+        b: domain element
+            The divisor
+
+        Returns
+        =======
+
+        (q, r): tuple of domain elements
+            The quotient and remainder
+
+        Raises
+        ======
+
+        ZeroDivisionError: when the divisor is zero.
+
+        See also
+        ========
+
+        quo: Analogue of ``a // b``
+        rem: Analogue of ``a % b``
+        exquo: Analogue of ``a / b``
+
+        Notes
+        =====
+
+        If ``gmpy`` is installed then the ``gmpy.mpq`` type will be used as
+        the :py:attr:`~.Domain.dtype` for :ref:`QQ`. The ``gmpy.mpq`` type
+        defines ``divmod`` in a way that is undesirable so
+        :py:meth:`~.Domain.div` should be used instead of ``divmod``.
+
+        >>> a = QQ(1)
+        >>> b = QQ(3, 2)
+        >>> a               # doctest: +SKIP
+        mpq(1,1)
+        >>> b               # doctest: +SKIP
+        mpq(3,2)
+        >>> divmod(a, b)    # doctest: +SKIP
+        (mpz(0), mpq(1,1))
+        >>> QQ.div(a, b)    # doctest: +SKIP
+        (mpq(2,3), mpq(0,1))
+
+        Using ``//`` or ``%`` with :ref:`QQ` will lead to incorrect results so
+        :py:meth:`~.Domain.div` should be used instead.
+
+        """
+        raise NotImplementedError
+
+    def invert(self, a, b):
+        """Returns inversion of ``a mod b``, implies something. """
+        raise NotImplementedError
+
+    def revert(self, a):
+        """Returns ``a**(-1)`` if possible. """
+        raise NotImplementedError
+
+    def numer(self, a):
+        """Returns numerator of ``a``. """
+        raise NotImplementedError
+
+    def denom(self, a):
+        """Returns denominator of ``a``. """
+        raise NotImplementedError
+
+    def half_gcdex(self, a, b):
+        """Half extended GCD of ``a`` and ``b``. """
+        s, t, h = self.gcdex(a, b)
+        return s, h
+
+    def gcdex(self, a, b):
+        """Extended GCD of ``a`` and ``b``. """
+        raise NotImplementedError
+
+    def cofactors(self, a, b):
+        """Returns GCD and cofactors of ``a`` and ``b``. """
+        gcd = self.gcd(a, b)
+        cfa = self.quo(a, gcd)
+        cfb = self.quo(b, gcd)
+        return gcd, cfa, cfb
+
+    def gcd(self, a, b):
+        """Returns GCD of ``a`` and ``b``. """
+        raise NotImplementedError
+
+    def lcm(self, a, b):
+        """Returns LCM of ``a`` and ``b``. """
+        raise NotImplementedError
+
+    def log(self, a, b):
+        """Returns b-base logarithm of ``a``. """
+        raise NotImplementedError
+
+    def sqrt(self, a):
+        """Returns square root of ``a``. """
+        raise NotImplementedError
+
+    def evalf(self, a, prec=None, **options):
+        """Returns numerical approximation of ``a``. """
+        return self.to_sympy(a).evalf(prec, **options)
+
+    n = evalf
+
+    def real(self, a):
+        return a
+
+    def imag(self, a):
+        return self.zero
+
+    def almosteq(self, a, b, tolerance=None):
+        """Check if ``a`` and ``b`` are almost equal. """
+        return a == b
+
+    def characteristic(self):
+        """Return the characteristic of this domain. """
+        raise NotImplementedError('characteristic()')
+
+
+__all__ = ['Domain']

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/field.py

@@ -0,0 +1,104 @@
+"""Implementation of :class:`Field` class. """
+
+
+from sympy.polys.domains.ring import Ring
+from sympy.polys.polyerrors import NotReversible, DomainError
+from sympy.utilities import public
+
+@public
+class Field(Ring):
+    """Represents a field domain. """
+
+    is_Field = True
+    is_PID = True
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        raise DomainError('there is no ring associated with %s' % self)
+
+    def get_field(self):
+        """Returns a field associated with ``self``. """
+        return self
+
+    def exquo(self, a, b):
+        """Exact quotient of ``a`` and ``b``, implies ``__truediv__``.  """
+        return a / b
+
+    def quo(self, a, b):
+        """Quotient of ``a`` and ``b``, implies ``__truediv__``. """
+        return a / b
+
+    def rem(self, a, b):
+        """Remainder of ``a`` and ``b``, implies nothing.  """
+        return self.zero
+
+    def div(self, a, b):
+        """Division of ``a`` and ``b``, implies ``__truediv__``. """
+        return a / b, self.zero
+
+    def gcd(self, a, b):
+        """
+        Returns GCD of ``a`` and ``b``.
+
+        This definition of GCD over fields allows to clear denominators
+        in `primitive()`.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import QQ
+        >>> from sympy import S, gcd, primitive
+        >>> from sympy.abc import x
+
+        >>> QQ.gcd(QQ(2, 3), QQ(4, 9))
+        2/9
+        >>> gcd(S(2)/3, S(4)/9)
+        2/9
+        >>> primitive(2*x/3 + S(4)/9)
+        (2/9, 3*x + 2)
+
+        """
+        try:
+            ring = self.get_ring()
+        except DomainError:
+            return self.one
+
+        p = ring.gcd(self.numer(a), self.numer(b))
+        q = ring.lcm(self.denom(a), self.denom(b))
+
+        return self.convert(p, ring)/q
+
+    def lcm(self, a, b):
+        """
+        Returns LCM of ``a`` and ``b``.
+
+        >>> from sympy.polys.domains import QQ
+        >>> from sympy import S, lcm
+
+        >>> QQ.lcm(QQ(2, 3), QQ(4, 9))
+        4/3
+        >>> lcm(S(2)/3, S(4)/9)
+        4/3
+
+        """
+
+        try:
+            ring = self.get_ring()
+        except DomainError:
+            return a*b
+
+        p = ring.lcm(self.numer(a), self.numer(b))
+        q = ring.gcd(self.denom(a), self.denom(b))
+
+        return self.convert(p, ring)/q
+
+    def revert(self, a):
+        """Returns ``a**(-1)`` if possible. """
+        if a:
+            return 1/a
+        else:
+            raise NotReversible('zero is not reversible')
+
+    def is_unit(self, a):
+        """Return true if ``a`` is a invertible"""
+        return bool(a)

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/gmpyintegerring.py

@@ -0,0 +1,104 @@
+"""Implementation of :class:`GMPYIntegerRing` class. """
+
+
+from sympy.polys.domains.groundtypes import (
+    GMPYInteger, SymPyInteger,
+    factorial as gmpy_factorial,
+    gmpy_gcdex, gmpy_gcd, gmpy_lcm, sqrt as gmpy_sqrt,
+)
+from sympy.polys.domains.integerring import IntegerRing
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.utilities import public
+
+@public
+class GMPYIntegerRing(IntegerRing):
+    """Integer ring based on GMPY's ``mpz`` type.
+
+    This will be the implementation of :ref:`ZZ` if ``gmpy`` or ``gmpy2`` is
+    installed. Elements will be of type ``gmpy.mpz``.
+    """
+
+    dtype = GMPYInteger
+    zero = dtype(0)
+    one = dtype(1)
+    tp = type(one)
+    alias = 'ZZ_gmpy'
+
+    def __init__(self):
+        """Allow instantiation of this domain. """
+
+    def to_sympy(self, a):
+        """Convert ``a`` to a SymPy object. """
+        return SymPyInteger(int(a))
+
+    def from_sympy(self, a):
+        """Convert SymPy's Integer to ``dtype``. """
+        if a.is_Integer:
+            return GMPYInteger(a.p)
+        elif a.is_Float and int(a) == a:
+            return GMPYInteger(int(a))
+        else:
+            raise CoercionFailed("expected an integer, got %s" % a)
+
+    def from_FF_python(K1, a, K0):
+        """Convert ``ModularInteger(int)`` to GMPY's ``mpz``. """
+        return GMPYInteger(a.to_int())
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert Python's ``int`` to GMPY's ``mpz``. """
+        return GMPYInteger(a)
+
+    def from_QQ(K1, a, K0):
+        """Convert Python's ``Fraction`` to GMPY's ``mpz``. """
+        if a.denominator == 1:
+            return GMPYInteger(a.numerator)
+
+    def from_QQ_python(K1, a, K0):
+        """Convert Python's ``Fraction`` to GMPY's ``mpz``. """
+        if a.denominator == 1:
+            return GMPYInteger(a.numerator)
+
+    def from_FF_gmpy(K1, a, K0):
+        """Convert ``ModularInteger(mpz)`` to GMPY's ``mpz``. """
+        return a.to_int()
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert GMPY's ``mpz`` to GMPY's ``mpz``. """
+        return a
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert GMPY ``mpq`` to GMPY's ``mpz``. """
+        if a.denominator == 1:
+            return a.numerator
+
+    def from_RealField(K1, a, K0):
+        """Convert mpmath's ``mpf`` to GMPY's ``mpz``. """
+        p, q = K0.to_rational(a)
+
+        if q == 1:
+            return GMPYInteger(p)
+
+    def from_GaussianIntegerRing(K1, a, K0):
+        if a.y == 0:
+            return a.x
+
+    def gcdex(self, a, b):
+        """Compute extended GCD of ``a`` and ``b``. """
+        h, s, t = gmpy_gcdex(a, b)
+        return s, t, h
+
+    def gcd(self, a, b):
+        """Compute GCD of ``a`` and ``b``. """
+        return gmpy_gcd(a, b)
+
+    def lcm(self, a, b):
+        """Compute LCM of ``a`` and ``b``. """
+        return gmpy_lcm(a, b)
+
+    def sqrt(self, a):
+        """Compute square root of ``a``. """
+        return gmpy_sqrt(a)
+
+    def factorial(self, a):
+        """Compute factorial of ``a``. """
+        return gmpy_factorial(a)

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/modularinteger.py

@@ -0,0 +1,205 @@
+"""Implementation of :class:`ModularInteger` class. """
+
+from __future__ import annotations
+from typing import Any
+
+import operator
+
+from sympy.polys.polyutils import PicklableWithSlots
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.polys.domains.domainelement import DomainElement
+
+from sympy.utilities import public
+
+@public
+class ModularInteger(PicklableWithSlots, DomainElement):
+    """A class representing a modular integer. """
+
+    mod, dom, sym, _parent = None, None, None, None
+
+    __slots__ = ('val',)
+
+    def parent(self):
+        return self._parent
+
+    def __init__(self, val):
+        if isinstance(val, self.__class__):
+            self.val = val.val % self.mod
+        else:
+            self.val = self.dom.convert(val) % self.mod
+
+    def __hash__(self):
+        return hash((self.val, self.mod))
+
+    def __repr__(self):
+        return "%s(%s)" % (self.__class__.__name__, self.val)
+
+    def __str__(self):
+        return "%s mod %s" % (self.val, self.mod)
+
+    def __int__(self):
+        return int(self.to_int())
+
+    def to_int(self):
+        if self.sym:
+            if self.val <= self.mod // 2:
+                return self.val
+            else:
+                return self.val - self.mod
+        else:
+            return self.val
+
+    def __pos__(self):
+        return self
+
+    def __neg__(self):
+        return self.__class__(-self.val)
+
+    @classmethod
+    def _get_val(cls, other):
+        if isinstance(other, cls):
+            return other.val
+        else:
+            try:
+                return cls.dom.convert(other)
+            except CoercionFailed:
+                return None
+
+    def __add__(self, other):
+        val = self._get_val(other)
+
+        if val is not None:
+            return self.__class__(self.val + val)
+        else:
+            return NotImplemented
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __sub__(self, other):
+        val = self._get_val(other)
+
+        if val is not None:
+            return self.__class__(self.val - val)
+        else:
+            return NotImplemented
+
+    def __rsub__(self, other):
+        return (-self).__add__(other)
+
+    def __mul__(self, other):
+        val = self._get_val(other)
+
+        if val is not None:
+            return self.__class__(self.val * val)
+        else:
+            return NotImplemented
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __truediv__(self, other):
+        val = self._get_val(other)
+
+        if val is not None:
+            return self.__class__(self.val * self._invert(val))
+        else:
+            return NotImplemented
+
+    def __rtruediv__(self, other):
+        return self.invert().__mul__(other)
+
+    def __mod__(self, other):
+        val = self._get_val(other)
+
+        if val is not None:
+            return self.__class__(self.val % val)
+        else:
+            return NotImplemented
+
+    def __rmod__(self, other):
+        val = self._get_val(other)
+
+        if val is not None:
+            return self.__class__(val % self.val)
+        else:
+            return NotImplemented
+
+    def __pow__(self, exp):
+        if not exp:
+            return self.__class__(self.dom.one)
+
+        if exp < 0:
+            val, exp = self.invert().val, -exp
+        else:
+            val = self.val
+
+        return self.__class__(pow(val, int(exp), self.mod))
+
+    def _compare(self, other, op):
+        val = self._get_val(other)
+
+        if val is not None:
+            return op(self.val, val % self.mod)
+        else:
+            return NotImplemented
+
+    def __eq__(self, other):
+        return self._compare(other, operator.eq)
+
+    def __ne__(self, other):
+        return self._compare(other, operator.ne)
+
+    def __lt__(self, other):
+        return self._compare(other, operator.lt)
+
+    def __le__(self, other):
+        return self._compare(other, operator.le)
+
+    def __gt__(self, other):
+        return self._compare(other, operator.gt)
+
+    def __ge__(self, other):
+        return self._compare(other, operator.ge)
+
+    def __bool__(self):
+        return bool(self.val)
+
+    @classmethod
+    def _invert(cls, value):
+        return cls.dom.invert(value, cls.mod)
+
+    def invert(self):
+        return self.__class__(self._invert(self.val))
+
+_modular_integer_cache: dict[tuple[Any, Any, Any], type[ModularInteger]] = {}
+
+def ModularIntegerFactory(_mod, _dom, _sym, parent):
+    """Create custom class for specific integer modulus."""
+    try:
+        _mod = _dom.convert(_mod)
+    except CoercionFailed:
+        ok = False
+    else:
+        ok = True
+
+    if not ok or _mod < 1:
+        raise ValueError("modulus must be a positive integer, got %s" % _mod)
+
+    key = _mod, _dom, _sym
+
+    try:
+        cls = _modular_integer_cache[key]
+    except KeyError:
+        class cls(ModularInteger):
+            mod, dom, sym = _mod, _dom, _sym
+            _parent = parent
+
+        if _sym:
+            cls.__name__ = "SymmetricModularIntegerMod%s" % _mod
+        else:
+            cls.__name__ = "ModularIntegerMod%s" % _mod
+
+        _modular_integer_cache[key] = cls
+
+    return cls

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/old_fractionfield.py

@@ -0,0 +1,185 @@
+"""Implementation of :class:`FractionField` class. """
+
+
+from sympy.polys.domains.field import Field
+from sympy.polys.domains.compositedomain import CompositeDomain
+from sympy.polys.domains.characteristiczero import CharacteristicZero
+from sympy.polys.polyclasses import DMF
+from sympy.polys.polyerrors import GeneratorsNeeded
+from sympy.polys.polyutils import dict_from_basic, basic_from_dict, _dict_reorder
+from sympy.utilities import public
+
+@public
+class FractionField(Field, CharacteristicZero, CompositeDomain):
+    """A class for representing rational function fields. """
+
+    dtype = DMF
+    is_FractionField = is_Frac = True
+
+    has_assoc_Ring = True
+    has_assoc_Field = True
+
+    def __init__(self, dom, *gens):
+        if not gens:
+            raise GeneratorsNeeded("generators not specified")
+
+        lev = len(gens) - 1
+        self.ngens = len(gens)
+
+        self.zero = self.dtype.zero(lev, dom, ring=self)
+        self.one = self.dtype.one(lev, dom, ring=self)
+
+        self.domain = self.dom = dom
+        self.symbols = self.gens = gens
+
+    def new(self, element):
+        return self.dtype(element, self.dom, len(self.gens) - 1, ring=self)
+
+    def __str__(self):
+        return str(self.dom) + '(' + ','.join(map(str, self.gens)) + ')'
+
+    def __hash__(self):
+        return hash((self.__class__.__name__, self.dtype, self.dom, self.gens))
+
+    def __eq__(self, other):
+        """Returns ``True`` if two domains are equivalent. """
+        return isinstance(other, FractionField) and \
+            self.dtype == other.dtype and self.dom == other.dom and self.gens == other.gens
+
+    def to_sympy(self, a):
+        """Convert ``a`` to a SymPy object. """
+        return (basic_from_dict(a.numer().to_sympy_dict(), *self.gens) /
+                basic_from_dict(a.denom().to_sympy_dict(), *self.gens))
+
+    def from_sympy(self, a):
+        """Convert SymPy's expression to ``dtype``. """
+        p, q = a.as_numer_denom()
+
+        num, _ = dict_from_basic(p, gens=self.gens)
+        den, _ = dict_from_basic(q, gens=self.gens)
+
+        for k, v in num.items():
+            num[k] = self.dom.from_sympy(v)
+
+        for k, v in den.items():
+            den[k] = self.dom.from_sympy(v)
+
+        return self((num, den)).cancel()
+
+    def from_ZZ(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ_python(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpz`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpq`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_RealField(K1, a, K0):
+        """Convert a mpmath ``mpf`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_GlobalPolynomialRing(K1, a, K0):
+        """Convert a ``DMF`` object to ``dtype``. """
+        if K1.gens == K0.gens:
+            if K1.dom == K0.dom:
+                return K1(a.rep)
+            else:
+                return K1(a.convert(K1.dom).rep)
+        else:
+            monoms, coeffs = _dict_reorder(a.to_dict(), K0.gens, K1.gens)
+
+            if K1.dom != K0.dom:
+                coeffs = [ K1.dom.convert(c, K0.dom) for c in coeffs ]
+
+            return K1(dict(zip(monoms, coeffs)))
+
+    def from_FractionField(K1, a, K0):
+        """
+        Convert a fraction field element to another fraction field.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.polyclasses import DMF
+        >>> from sympy.polys.domains import ZZ, QQ
+        >>> from sympy.abc import x
+
+        >>> f = DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(1)]), ZZ)
+
+        >>> QQx = QQ.old_frac_field(x)
+        >>> ZZx = ZZ.old_frac_field(x)
+
+        >>> QQx.from_FractionField(f, ZZx)
+        (x + 2)/(x + 1)
+
+        """
+        if K1.gens == K0.gens:
+            if K1.dom == K0.dom:
+                return a
+            else:
+                return K1((a.numer().convert(K1.dom).rep,
+                           a.denom().convert(K1.dom).rep))
+        elif set(K0.gens).issubset(K1.gens):
+            nmonoms, ncoeffs = _dict_reorder(
+                a.numer().to_dict(), K0.gens, K1.gens)
+            dmonoms, dcoeffs = _dict_reorder(
+                a.denom().to_dict(), K0.gens, K1.gens)
+
+            if K1.dom != K0.dom:
+                ncoeffs = [ K1.dom.convert(c, K0.dom) for c in ncoeffs ]
+                dcoeffs = [ K1.dom.convert(c, K0.dom) for c in dcoeffs ]
+
+            return K1((dict(zip(nmonoms, ncoeffs)), dict(zip(dmonoms, dcoeffs))))
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        from sympy.polys.domains import PolynomialRing
+        return PolynomialRing(self.dom, *self.gens)
+
+    def poly_ring(self, *gens):
+        """Returns a polynomial ring, i.e. `K[X]`. """
+        raise NotImplementedError('nested domains not allowed')
+
+    def frac_field(self, *gens):
+        """Returns a fraction field, i.e. `K(X)`. """
+        raise NotImplementedError('nested domains not allowed')
+
+    def is_positive(self, a):
+        """Returns True if ``a`` is positive. """
+        return self.dom.is_positive(a.numer().LC())
+
+    def is_negative(self, a):
+        """Returns True if ``a`` is negative. """
+        return self.dom.is_negative(a.numer().LC())
+
+    def is_nonpositive(self, a):
+        """Returns True if ``a`` is non-positive. """
+        return self.dom.is_nonpositive(a.numer().LC())
+
+    def is_nonnegative(self, a):
+        """Returns True if ``a`` is non-negative. """
+        return self.dom.is_nonnegative(a.numer().LC())
+
+    def numer(self, a):
+        """Returns numerator of ``a``. """
+        return a.numer()
+
+    def denom(self, a):
+        """Returns denominator of ``a``. """
+        return a.denom()
+
+    def factorial(self, a):
+        """Returns factorial of ``a``. """
+        return self.dtype(self.dom.factorial(a))

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/old_polynomialring.py

@@ -0,0 +1,462 @@
+"""Implementation of :class:`PolynomialRing` class. """
+
+
+from sympy.polys.agca.modules import FreeModulePolyRing
+from sympy.polys.domains.characteristiczero import CharacteristicZero
+from sympy.polys.domains.compositedomain import CompositeDomain
+from sympy.polys.domains.old_fractionfield import FractionField
+from sympy.polys.domains.ring import Ring
+from sympy.polys.orderings import monomial_key, build_product_order
+from sympy.polys.polyclasses import DMP, DMF
+from sympy.polys.polyerrors import (GeneratorsNeeded, PolynomialError,
+        CoercionFailed, ExactQuotientFailed, NotReversible)
+from sympy.polys.polyutils import dict_from_basic, basic_from_dict, _dict_reorder
+from sympy.utilities import public
+from sympy.utilities.iterables import iterable
+
+# XXX why does this derive from CharacteristicZero???
+
+@public
+class PolynomialRingBase(Ring, CharacteristicZero, CompositeDomain):
+    """
+    Base class for generalized polynomial rings.
+
+    This base class should be used for uniform access to generalized polynomial
+    rings. Subclasses only supply information about the element storage etc.
+
+    Do not instantiate.
+    """
+
+    has_assoc_Ring = True
+    has_assoc_Field = True
+
+    default_order = "grevlex"
+
+    def __init__(self, dom, *gens, **opts):
+        if not gens:
+            raise GeneratorsNeeded("generators not specified")
+
+        lev = len(gens) - 1
+        self.ngens = len(gens)
+
+        self.zero = self.dtype.zero(lev, dom, ring=self)
+        self.one = self.dtype.one(lev, dom, ring=self)
+
+        self.domain = self.dom = dom
+        self.symbols = self.gens = gens
+        # NOTE 'order' may not be set if inject was called through CompositeDomain
+        self.order = opts.get('order', monomial_key(self.default_order))
+
+    def new(self, element):
+        return self.dtype(element, self.dom, len(self.gens) - 1, ring=self)
+
+    def __str__(self):
+        s_order = str(self.order)
+        orderstr = (
+            " order=" + s_order) if s_order != self.default_order else ""
+        return str(self.dom) + '[' + ','.join(map(str, self.gens)) + orderstr + ']'
+
+    def __hash__(self):
+        return hash((self.__class__.__name__, self.dtype, self.dom,
+                     self.gens, self.order))
+
+    def __eq__(self, other):
+        """Returns ``True`` if two domains are equivalent. """
+        return isinstance(other, PolynomialRingBase) and \
+            self.dtype == other.dtype and self.dom == other.dom and \
+            self.gens == other.gens and self.order == other.order
+
+    def from_ZZ(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ_python(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpz`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpq`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_RealField(K1, a, K0):
+        """Convert a mpmath ``mpf`` object to ``dtype``. """
+        return K1(K1.dom.convert(a, K0))
+
+    def from_AlgebraicField(K1, a, K0):
+        """Convert a ``ANP`` object to ``dtype``. """
+        if K1.dom == K0:
+            return K1(a)
+
+    def from_PolynomialRing(K1, a, K0):
+        """Convert a ``PolyElement`` object to ``dtype``. """
+        if K1.gens == K0.symbols:
+            if K1.dom == K0.dom:
+                return K1(dict(a))  # set the correct ring
+            else:
+                convert_dom = lambda c: K1.dom.convert_from(c, K0.dom)
+                return K1({m: convert_dom(c) for m, c in a.items()})
+        else:
+            monoms, coeffs = _dict_reorder(a.to_dict(), K0.symbols, K1.gens)
+
+            if K1.dom != K0.dom:
+                coeffs = [ K1.dom.convert(c, K0.dom) for c in coeffs ]
+
+            return K1(dict(zip(monoms, coeffs)))
+
+    def from_GlobalPolynomialRing(K1, a, K0):
+        """Convert a ``DMP`` object to ``dtype``. """
+        if K1.gens == K0.gens:
+            if K1.dom == K0.dom:
+                return K1(a.rep)  # set the correct ring
+            else:
+                return K1(a.convert(K1.dom).rep)
+        else:
+            monoms, coeffs = _dict_reorder(a.to_dict(), K0.gens, K1.gens)
+
+            if K1.dom != K0.dom:
+                coeffs = [ K1.dom.convert(c, K0.dom) for c in coeffs ]
+
+            return K1(dict(zip(monoms, coeffs)))
+
+    def get_field(self):
+        """Returns a field associated with ``self``. """
+        return FractionField(self.dom, *self.gens)
+
+    def poly_ring(self, *gens):
+        """Returns a polynomial ring, i.e. ``K[X]``. """
+        raise NotImplementedError('nested domains not allowed')
+
+    def frac_field(self, *gens):
+        """Returns a fraction field, i.e. ``K(X)``. """
+        raise NotImplementedError('nested domains not allowed')
+
+    def revert(self, a):
+        try:
+            return 1/a
+        except (ExactQuotientFailed, ZeroDivisionError):
+            raise NotReversible('%s is not a unit' % a)
+
+    def gcdex(self, a, b):
+        """Extended GCD of ``a`` and ``b``. """
+        return a.gcdex(b)
+
+    def gcd(self, a, b):
+        """Returns GCD of ``a`` and ``b``. """
+        return a.gcd(b)
+
+    def lcm(self, a, b):
+        """Returns LCM of ``a`` and ``b``. """
+        return a.lcm(b)
+
+    def factorial(self, a):
+        """Returns factorial of ``a``. """
+        return self.dtype(self.dom.factorial(a))
+
+    def _vector_to_sdm(self, v, order):
+        """
+        For internal use by the modules class.
+
+        Convert an iterable of elements of this ring into a sparse distributed
+        module element.
+        """
+        raise NotImplementedError
+
+    def _sdm_to_dics(self, s, n):
+        """Helper for _sdm_to_vector."""
+        from sympy.polys.distributedmodules import sdm_to_dict
+        dic = sdm_to_dict(s)
+        res = [{} for _ in range(n)]
+        for k, v in dic.items():
+            res[k[0]][k[1:]] = v
+        return res
+
+    def _sdm_to_vector(self, s, n):
+        """
+        For internal use by the modules class.
+
+        Convert a sparse distributed module into a list of length ``n``.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, ilex
+        >>> from sympy.abc import x, y
+        >>> R = QQ.old_poly_ring(x, y, order=ilex)
+        >>> L = [((1, 1, 1), QQ(1)), ((0, 1, 0), QQ(1)), ((0, 0, 1), QQ(2))]
+        >>> R._sdm_to_vector(L, 2)
+        [x + 2*y, x*y]
+        """
+        dics = self._sdm_to_dics(s, n)
+        # NOTE this works for global and local rings!
+        return [self(x) for x in dics]
+
+    def free_module(self, rank):
+        """
+        Generate a free module of rank ``rank`` over ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).free_module(2)
+        QQ[x]**2
+        """
+        return FreeModulePolyRing(self, rank)
+
+
+def _vector_to_sdm_helper(v, order):
+    """Helper method for common code in Global and Local poly rings."""
+    from sympy.polys.distributedmodules import sdm_from_dict
+    d = {}
+    for i, e in enumerate(v):
+        for key, value in e.to_dict().items():
+            d[(i,) + key] = value
+    return sdm_from_dict(d, order)
+
+
+@public
+class GlobalPolynomialRing(PolynomialRingBase):
+    """A true polynomial ring, with objects DMP. """
+
+    is_PolynomialRing = is_Poly = True
+    dtype = DMP
+
+    def from_FractionField(K1, a, K0):
+        """
+        Convert a ``DMF`` object to ``DMP``.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.polyclasses import DMP, DMF
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.abc import x
+
+        >>> f = DMF(([ZZ(1), ZZ(1)], [ZZ(1)]), ZZ)
+        >>> K = ZZ.old_frac_field(x)
+
+        >>> F = ZZ.old_poly_ring(x).from_FractionField(f, K)
+
+        >>> F == DMP([ZZ(1), ZZ(1)], ZZ)
+        True
+        >>> type(F)
+        <class 'sympy.polys.polyclasses.DMP'>
+
+        """
+        if a.denom().is_one:
+            return K1.from_GlobalPolynomialRing(a.numer(), K0)
+
+    def to_sympy(self, a):
+        """Convert ``a`` to a SymPy object. """
+        return basic_from_dict(a.to_sympy_dict(), *self.gens)
+
+    def from_sympy(self, a):
+        """Convert SymPy's expression to ``dtype``. """
+        try:
+            rep, _ = dict_from_basic(a, gens=self.gens)
+        except PolynomialError:
+            raise CoercionFailed("Cannot convert %s to type %s" % (a, self))
+
+        for k, v in rep.items():
+            rep[k] = self.dom.from_sympy(v)
+
+        return self(rep)
+
+    def is_positive(self, a):
+        """Returns True if ``LC(a)`` is positive. """
+        return self.dom.is_positive(a.LC())
+
+    def is_negative(self, a):
+        """Returns True if ``LC(a)`` is negative. """
+        return self.dom.is_negative(a.LC())
+
+    def is_nonpositive(self, a):
+        """Returns True if ``LC(a)`` is non-positive. """
+        return self.dom.is_nonpositive(a.LC())
+
+    def is_nonnegative(self, a):
+        """Returns True if ``LC(a)`` is non-negative. """
+        return self.dom.is_nonnegative(a.LC())
+
+    def _vector_to_sdm(self, v, order):
+        """
+        Examples
+        ========
+
+        >>> from sympy import lex, QQ
+        >>> from sympy.abc import x, y
+        >>> R = QQ.old_poly_ring(x, y)
+        >>> f = R.convert(x + 2*y)
+        >>> g = R.convert(x * y)
+        >>> R._vector_to_sdm([f, g], lex)
+        [((1, 1, 1), 1), ((0, 1, 0), 1), ((0, 0, 1), 2)]
+        """
+        return _vector_to_sdm_helper(v, order)
+
+
+class GeneralizedPolynomialRing(PolynomialRingBase):
+    """A generalized polynomial ring, with objects DMF. """
+
+    dtype = DMF
+
+    def new(self, a):
+        """Construct an element of ``self`` domain from ``a``. """
+        res = self.dtype(a, self.dom, len(self.gens) - 1, ring=self)
+
+        # make sure res is actually in our ring
+        if res.denom().terms(order=self.order)[0][0] != (0,)*len(self.gens):
+            from sympy.printing.str import sstr
+            raise CoercionFailed("denominator %s not allowed in %s"
+                                 % (sstr(res), self))
+        return res
+
+    def __contains__(self, a):
+        try:
+            a = self.convert(a)
+        except CoercionFailed:
+            return False
+        return a.denom().terms(order=self.order)[0][0] == (0,)*len(self.gens)
+
+    def from_FractionField(K1, a, K0):
+        dmf = K1.get_field().from_FractionField(a, K0)
+        return K1((dmf.num, dmf.den))
+
+    def to_sympy(self, a):
+        """Convert ``a`` to a SymPy object. """
+        return (basic_from_dict(a.numer().to_sympy_dict(), *self.gens) /
+                basic_from_dict(a.denom().to_sympy_dict(), *self.gens))
+
+    def from_sympy(self, a):
+        """Convert SymPy's expression to ``dtype``. """
+        p, q = a.as_numer_denom()
+
+        num, _ = dict_from_basic(p, gens=self.gens)
+        den, _ = dict_from_basic(q, gens=self.gens)
+
+        for k, v in num.items():
+            num[k] = self.dom.from_sympy(v)
+
+        for k, v in den.items():
+            den[k] = self.dom.from_sympy(v)
+
+        return self((num, den)).cancel()
+
+    def _vector_to_sdm(self, v, order):
+        """
+        Turn an iterable into a sparse distributed module.
+
+        Note that the vector is multiplied by a unit first to make all entries
+        polynomials.
+
+        Examples
+        ========
+
+        >>> from sympy import ilex, QQ
+        >>> from sympy.abc import x, y
+        >>> R = QQ.old_poly_ring(x, y, order=ilex)
+        >>> f = R.convert((x + 2*y) / (1 + x))
+        >>> g = R.convert(x * y)
+        >>> R._vector_to_sdm([f, g], ilex)
+        [((0, 0, 1), 2), ((0, 1, 0), 1), ((1, 1, 1), 1), ((1,
+          2, 1), 1)]
+        """
+        # NOTE this is quite inefficient...
+        u = self.one.numer()
+        for x in v:
+            u *= x.denom()
+        return _vector_to_sdm_helper([x.numer()*u/x.denom() for x in v], order)
+
+
+@public
+def PolynomialRing(dom, *gens, **opts):
+    r"""
+    Create a generalized multivariate polynomial ring.
+
+    A generalized polynomial ring is defined by a ground field `K`, a set
+    of generators (typically `x_1, \ldots, x_n`) and a monomial order `<`.
+    The monomial order can be global, local or mixed. In any case it induces
+    a total ordering on the monomials, and there exists for every (non-zero)
+    polynomial `f \in K[x_1, \ldots, x_n]` a well-defined "leading monomial"
+    `LM(f) = LM(f, >)`. One can then define a multiplicative subset
+    `S = S_> = \{f \in K[x_1, \ldots, x_n] | LM(f) = 1\}`. The generalized
+    polynomial ring corresponding to the monomial order is
+    `R = S^{-1}K[x_1, \ldots, x_n]`.
+
+    If `>` is a so-called global order, that is `1` is the smallest monomial,
+    then we just have `S = K` and `R = K[x_1, \ldots, x_n]`.
+
+    Examples
+    ========
+
+    A few examples may make this clearer.
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import QQ
+
+    Our first ring uses global lexicographic order.
+
+    >>> R1 = QQ.old_poly_ring(x, y, order=(("lex", x, y),))
+
+    The second ring uses local lexicographic order. Note that when using a
+    single (non-product) order, you can just specify the name and omit the
+    variables:
+
+    >>> R2 = QQ.old_poly_ring(x, y, order="ilex")
+
+    The third and fourth rings use a mixed orders:
+
+    >>> o1 = (("ilex", x), ("lex", y))
+    >>> o2 = (("lex", x), ("ilex", y))
+    >>> R3 = QQ.old_poly_ring(x, y, order=o1)
+    >>> R4 = QQ.old_poly_ring(x, y, order=o2)
+
+    We will investigate what elements of `K(x, y)` are contained in the various
+    rings.
+
+    >>> L = [x, 1/x, y/(1 + x), 1/(1 + y), 1/(1 + x*y)]
+    >>> test = lambda R: [f in R for f in L]
+
+    The first ring is just `K[x, y]`:
+
+    >>> test(R1)
+    [True, False, False, False, False]
+
+    The second ring is R1 localised at the maximal ideal (x, y):
+
+    >>> test(R2)
+    [True, False, True, True, True]
+
+    The third ring is R1 localised at the prime ideal (x):
+
+    >>> test(R3)
+    [True, False, True, False, True]
+
+    Finally the fourth ring is R1 localised at `S = K[x, y] \setminus yK[y]`:
+
+    >>> test(R4)
+    [True, False, False, True, False]
+    """
+
+    order = opts.get("order", GeneralizedPolynomialRing.default_order)
+    if iterable(order):
+        order = build_product_order(order, gens)
+    order = monomial_key(order)
+    opts['order'] = order
+
+    if order.is_global:
+        return GlobalPolynomialRing(dom, *gens, **opts)
+    else:
+        return GeneralizedPolynomialRing(dom, *gens, **opts)

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/pythonfinitefield.py

@@ -0,0 +1,16 @@
+"""Implementation of :class:`PythonFiniteField` class. """
+
+
+from sympy.polys.domains.finitefield import FiniteField
+from sympy.polys.domains.pythonintegerring import PythonIntegerRing
+
+from sympy.utilities import public
+
+@public
+class PythonFiniteField(FiniteField):
+    """Finite field based on Python's integers. """
+
+    alias = 'FF_python'
+
+    def __init__(self, mod, symmetric=True):
+        return super().__init__(mod, PythonIntegerRing(), symmetric)

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/rationalfield.py

@@ -0,0 +1,163 @@
+"""Implementation of :class:`RationalField` class. """
+
+
+from sympy.external.gmpy import MPQ
+
+from sympy.polys.domains.groundtypes import SymPyRational
+
+from sympy.polys.domains.characteristiczero import CharacteristicZero
+from sympy.polys.domains.field import Field
+from sympy.polys.domains.simpledomain import SimpleDomain
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.utilities import public
+
+@public
+class RationalField(Field, CharacteristicZero, SimpleDomain):
+    r"""Abstract base class for the domain :ref:`QQ`.
+
+    The :py:class:`RationalField` class represents the field of rational
+    numbers $\mathbb{Q}$ as a :py:class:`~.Domain` in the domain system.
+    :py:class:`RationalField` is a superclass of
+    :py:class:`PythonRationalField` and :py:class:`GMPYRationalField` one of
+    which will be the implementation for :ref:`QQ` depending on whether either
+    of ``gmpy`` or ``gmpy2`` is installed or not.
+
+    See also
+    ========
+
+    Domain
+    """
+
+    rep = 'QQ'
+    alias = 'QQ'
+
+    is_RationalField = is_QQ = True
+    is_Numerical = True
+
+    has_assoc_Ring = True
+    has_assoc_Field = True
+
+    dtype = MPQ
+    zero = dtype(0)
+    one = dtype(1)
+    tp = type(one)
+
+    def __init__(self):
+        pass
+
+    def get_ring(self):
+        """Returns ring associated with ``self``. """
+        from sympy.polys.domains import ZZ
+        return ZZ
+
+    def to_sympy(self, a):
+        """Convert ``a`` to a SymPy object. """
+        return SymPyRational(int(a.numerator), int(a.denominator))
+
+    def from_sympy(self, a):
+        """Convert SymPy's Integer to ``dtype``. """
+        if a.is_Rational:
+            return MPQ(a.p, a.q)
+        elif a.is_Float:
+            from sympy.polys.domains import RR
+            return MPQ(*map(int, RR.to_rational(a)))
+        else:
+            raise CoercionFailed("expected `Rational` object, got %s" % a)
+
+    def algebraic_field(self, *extension, alias=None):
+        r"""Returns an algebraic field, i.e. `\mathbb{Q}(\alpha, \ldots)`.
+
+        Parameters
+        ==========
+
+        *extension : One or more :py:class:`~.Expr`
+            Generators of the extension. These should be expressions that are
+            algebraic over `\mathbb{Q}`.
+
+        alias : str, :py:class:`~.Symbol`, None, optional (default=None)
+            If provided, this will be used as the alias symbol for the
+            primitive element of the returned :py:class:`~.AlgebraicField`.
+
+        Returns
+        =======
+
+        :py:class:`~.AlgebraicField`
+            A :py:class:`~.Domain` representing the algebraic field extension.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, sqrt
+        >>> QQ.algebraic_field(sqrt(2))
+        QQ<sqrt(2)>
+        """
+        from sympy.polys.domains import AlgebraicField
+        return AlgebraicField(self, *extension, alias=alias)
+
+    def from_AlgebraicField(K1, a, K0):
+        """Convert a :py:class:`~.ANP` object to :ref:`QQ`.
+
+        See :py:meth:`~.Domain.convert`
+        """
+        if a.is_ground:
+            return K1.convert(a.LC(), K0.dom)
+
+    def from_ZZ(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return MPQ(a)
+
+    def from_ZZ_python(K1, a, K0):
+        """Convert a Python ``int`` object to ``dtype``. """
+        return MPQ(a)
+
+    def from_QQ(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return MPQ(a.numerator, a.denominator)
+
+    def from_QQ_python(K1, a, K0):
+        """Convert a Python ``Fraction`` object to ``dtype``. """
+        return MPQ(a.numerator, a.denominator)
+
+    def from_ZZ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpz`` object to ``dtype``. """
+        return MPQ(a)
+
+    def from_QQ_gmpy(K1, a, K0):
+        """Convert a GMPY ``mpq`` object to ``dtype``. """
+        return a
+
+    def from_GaussianRationalField(K1, a, K0):
+        """Convert a ``GaussianElement`` object to ``dtype``. """
+        if a.y == 0:
+            return MPQ(a.x)
+
+    def from_RealField(K1, a, K0):
+        """Convert a mpmath ``mpf`` object to ``dtype``. """
+        return MPQ(*map(int, K0.to_rational(a)))
+
+    def exquo(self, a, b):
+        """Exact quotient of ``a`` and ``b``, implies ``__truediv__``.  """
+        return MPQ(a) / MPQ(b)
+
+    def quo(self, a, b):
+        """Quotient of ``a`` and ``b``, implies ``__truediv__``. """
+        return MPQ(a) / MPQ(b)
+
+    def rem(self, a, b):
+        """Remainder of ``a`` and ``b``, implies nothing.  """
+        return self.zero
+
+    def div(self, a, b):
+        """Division of ``a`` and ``b``, implies ``__truediv__``. """
+        return MPQ(a) / MPQ(b), self.zero
+
+    def numer(self, a):
+        """Returns numerator of ``a``. """
+        return a.numerator
+
+    def denom(self, a):
+        """Returns denominator of ``a``. """
+        return a.denominator
+
+
+QQ = RationalField()

llmeval-env/lib/python3.10/site-packages/sympy/polys/domains/ring.py

@@ -0,0 +1,118 @@
+"""Implementation of :class:`Ring` class. """
+
+
+from sympy.polys.domains.domain import Domain
+from sympy.polys.polyerrors import ExactQuotientFailed, NotInvertible, NotReversible
+
+from sympy.utilities import public
+
+@public
+class Ring(Domain):
+    """Represents a ring domain. """
+
+    is_Ring = True
+
+    def get_ring(self):
+        """Returns a ring associated with ``self``. """
+        return self
+
+    def exquo(self, a, b):
+        """Exact quotient of ``a`` and ``b``, implies ``__floordiv__``.  """
+        if a % b:
+            raise ExactQuotientFailed(a, b, self)
+        else:
+            return a // b
+
+    def quo(self, a, b):
+        """Quotient of ``a`` and ``b``, implies ``__floordiv__``. """
+        return a // b
+
+    def rem(self, a, b):
+        """Remainder of ``a`` and ``b``, implies ``__mod__``.  """
+        return a % b
+
+    def div(self, a, b):
+        """Division of ``a`` and ``b``, implies ``__divmod__``. """
+        return divmod(a, b)
+
+    def invert(self, a, b):
+        """Returns inversion of ``a mod b``. """
+        s, t, h = self.gcdex(a, b)
+
+        if self.is_one(h):
+            return s % b
+        else:
+            raise NotInvertible("zero divisor")
+
+    def revert(self, a):
+        """Returns ``a**(-1)`` if possible. """
+        if self.is_one(a) or self.is_one(-a):
+            return a
+        else:
+            raise NotReversible('only units are reversible in a ring')
+
+    def is_unit(self, a):
+        try:
+            self.revert(a)
+            return True
+        except NotReversible:
+            return False
+
+    def numer(self, a):
+        """Returns numerator of ``a``. """
+        return a
+
+    def denom(self, a):
+        """Returns denominator of `a`. """
+        return self.one
+
+    def free_module(self, rank):
+        """
+        Generate a free module of rank ``rank`` over self.
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).free_module(2)
+        QQ[x]**2
+        """
+        raise NotImplementedError
+
+    def ideal(self, *gens):
+        """
+        Generate an ideal of ``self``.
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).ideal(x**2)
+        <x**2>
+        """
+        from sympy.polys.agca.ideals import ModuleImplementedIdeal
+        return ModuleImplementedIdeal(self, self.free_module(1).submodule(
+            *[[x] for x in gens]))
+
+    def quotient_ring(self, e):
+        """
+        Form a quotient ring of ``self``.
+
+        Here ``e`` can be an ideal or an iterable.
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).quotient_ring(QQ.old_poly_ring(x).ideal(x**2))
+        QQ[x]/<x**2>
+        >>> QQ.old_poly_ring(x).quotient_ring([x**2])
+        QQ[x]/<x**2>
+
+        The division operator has been overloaded for this:
+
+        >>> QQ.old_poly_ring(x)/[x**2]
+        QQ[x]/<x**2>
+        """
+        from sympy.polys.agca.ideals import Ideal
+        from sympy.polys.domains.quotientring import QuotientRing
+        if not isinstance(e, Ideal):
+            e = self.ideal(*e)
+        return QuotientRing(self, e)
+
+    def __truediv__(self, e):
+        return self.quotient_ring(e)

llmeval-env/lib/python3.10/site-packages/sympy/polys/euclidtools.py

@@ -0,0 +1,1893 @@
+"""Euclidean algorithms, GCDs, LCMs and polynomial remainder sequences. """
+
+
+from sympy.polys.densearith import (
+    dup_sub_mul,
+    dup_neg, dmp_neg,
+    dmp_add,
+    dmp_sub,
+    dup_mul, dmp_mul,
+    dmp_pow,
+    dup_div, dmp_div,
+    dup_rem,
+    dup_quo, dmp_quo,
+    dup_prem, dmp_prem,
+    dup_mul_ground, dmp_mul_ground,
+    dmp_mul_term,
+    dup_quo_ground, dmp_quo_ground,
+    dup_max_norm, dmp_max_norm)
+from sympy.polys.densebasic import (
+    dup_strip, dmp_raise,
+    dmp_zero, dmp_one, dmp_ground,
+    dmp_one_p, dmp_zero_p,
+    dmp_zeros,
+    dup_degree, dmp_degree, dmp_degree_in,
+    dup_LC, dmp_LC, dmp_ground_LC,
+    dmp_multi_deflate, dmp_inflate,
+    dup_convert, dmp_convert,
+    dmp_apply_pairs)
+from sympy.polys.densetools import (
+    dup_clear_denoms, dmp_clear_denoms,
+    dup_diff, dmp_diff,
+    dup_eval, dmp_eval, dmp_eval_in,
+    dup_trunc, dmp_ground_trunc,
+    dup_monic, dmp_ground_monic,
+    dup_primitive, dmp_ground_primitive,
+    dup_extract, dmp_ground_extract)
+from sympy.polys.galoistools import (
+    gf_int, gf_crt)
+from sympy.polys.polyconfig import query
+from sympy.polys.polyerrors import (
+    MultivariatePolynomialError,
+    HeuristicGCDFailed,
+    HomomorphismFailed,
+    NotInvertible,
+    DomainError)
+
+
+
+
+def dup_half_gcdex(f, g, K):
+    """
+    Half extended Euclidean algorithm in `F[x]`.
+
+    Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
+    >>> g = x**3 + x**2 - 4*x - 4
+
+    >>> R.dup_half_gcdex(f, g)
+    (-1/5*x + 3/5, x + 1)
+
+    """
+    if not K.is_Field:
+        raise DomainError("Cannot compute half extended GCD over %s" % K)
+
+    a, b = [K.one], []
+
+    while g:
+        q, r = dup_div(f, g, K)
+        f, g = g, r
+        a, b = b, dup_sub_mul(a, q, b, K)
+
+    a = dup_quo_ground(a, dup_LC(f, K), K)
+    f = dup_monic(f, K)
+
+    return a, f
+
+
+def dmp_half_gcdex(f, g, u, K):
+    """
+    Half extended Euclidean algorithm in `F[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    """
+    if not u:
+        return dup_half_gcdex(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_gcdex(f, g, K):
+    """
+    Extended Euclidean algorithm in `F[x]`.
+
+    Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
+    >>> g = x**3 + x**2 - 4*x - 4
+
+    >>> R.dup_gcdex(f, g)
+    (-1/5*x + 3/5, 1/5*x**2 - 6/5*x + 2, x + 1)
+
+    """
+    s, h = dup_half_gcdex(f, g, K)
+
+    F = dup_sub_mul(h, s, f, K)
+    t = dup_quo(F, g, K)
+
+    return s, t, h
+
+
+def dmp_gcdex(f, g, u, K):
+    """
+    Extended Euclidean algorithm in `F[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    """
+    if not u:
+        return dup_gcdex(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_invert(f, g, K):
+    """
+    Compute multiplicative inverse of `f` modulo `g` in `F[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = x**2 - 1
+    >>> g = 2*x - 1
+    >>> h = x - 1
+
+    >>> R.dup_invert(f, g)
+    -4/3
+
+    >>> R.dup_invert(f, h)
+    Traceback (most recent call last):
+    ...
+    NotInvertible: zero divisor
+
+    """
+    s, h = dup_half_gcdex(f, g, K)
+
+    if h == [K.one]:
+        return dup_rem(s, g, K)
+    else:
+        raise NotInvertible("zero divisor")
+
+
+def dmp_invert(f, g, u, K):
+    """
+    Compute multiplicative inverse of `f` modulo `g` in `F[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    """
+    if not u:
+        return dup_invert(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_euclidean_prs(f, g, K):
+    """
+    Euclidean polynomial remainder sequence (PRS) in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    >>> prs = R.dup_euclidean_prs(f, g)
+
+    >>> prs[0]
+    x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    >>> prs[1]
+    3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+    >>> prs[2]
+    -5/9*x**4 + 1/9*x**2 - 1/3
+    >>> prs[3]
+    -117/25*x**2 - 9*x + 441/25
+    >>> prs[4]
+    233150/19773*x - 102500/6591
+    >>> prs[5]
+    -1288744821/543589225
+
+    """
+    prs = [f, g]
+    h = dup_rem(f, g, K)
+
+    while h:
+        prs.append(h)
+        f, g = g, h
+        h = dup_rem(f, g, K)
+
+    return prs
+
+
+def dmp_euclidean_prs(f, g, u, K):
+    """
+    Euclidean polynomial remainder sequence (PRS) in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    """
+    if not u:
+        return dup_euclidean_prs(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_primitive_prs(f, g, K):
+    """
+    Primitive polynomial remainder sequence (PRS) in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    >>> prs = R.dup_primitive_prs(f, g)
+
+    >>> prs[0]
+    x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    >>> prs[1]
+    3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+    >>> prs[2]
+    -5*x**4 + x**2 - 3
+    >>> prs[3]
+    13*x**2 + 25*x - 49
+    >>> prs[4]
+    4663*x - 6150
+    >>> prs[5]
+    1
+
+    """
+    prs = [f, g]
+    _, h = dup_primitive(dup_prem(f, g, K), K)
+
+    while h:
+        prs.append(h)
+        f, g = g, h
+        _, h = dup_primitive(dup_prem(f, g, K), K)
+
+    return prs
+
+
+def dmp_primitive_prs(f, g, u, K):
+    """
+    Primitive polynomial remainder sequence (PRS) in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    """
+    if not u:
+        return dup_primitive_prs(f, g, K)
+    else:
+        raise MultivariatePolynomialError(f, g)
+
+
+def dup_inner_subresultants(f, g, K):
+    """
+    Subresultant PRS algorithm in `K[x]`.
+
+    Computes the subresultant polynomial remainder sequence (PRS)
+    and the non-zero scalar subresultants of `f` and `g`.
+    By [1] Thm. 3, these are the constants '-c' (- to optimize
+    computation of sign).
+    The first subdeterminant is set to 1 by convention to match
+    the polynomial and the scalar subdeterminants.
+    If 'deg(f) < deg(g)', the subresultants of '(g,f)' are computed.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_inner_subresultants(x**2 + 1, x**2 - 1)
+    ([x**2 + 1, x**2 - 1, -2], [1, 1, 4])
+
+    References
+    ==========
+
+    .. [1] W.S. Brown, The Subresultant PRS Algorithm.
+           ACM Transaction of Mathematical Software 4 (1978) 237-249
+
+    """
+    n = dup_degree(f)
+    m = dup_degree(g)
+
+    if n < m:
+        f, g = g, f
+        n, m = m, n
+
+    if not f:
+        return [], []
+
+    if not g:
+        return [f], [K.one]
+
+    R = [f, g]
+    d = n - m
+
+    b = (-K.one)**(d + 1)
+
+    h = dup_prem(f, g, K)
+    h = dup_mul_ground(h, b, K)
+
+    lc = dup_LC(g, K)
+    c = lc**d
+
+    # Conventional first scalar subdeterminant is 1
+    S = [K.one, c]
+    c = -c
+
+    while h:
+        k = dup_degree(h)
+        R.append(h)
+
+        f, g, m, d = g, h, k, m - k
+
+        b = -lc * c**d
+
+        h = dup_prem(f, g, K)
+        h = dup_quo_ground(h, b, K)
+
+        lc = dup_LC(g, K)
+
+        if d > 1:        # abnormal case
+            q = c**(d - 1)
+            c = K.quo((-lc)**d, q)
+        else:
+            c = -lc
+
+        S.append(-c)
+
+    return R, S
+
+
+def dup_subresultants(f, g, K):
+    """
+    Computes subresultant PRS of two polynomials in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_subresultants(x**2 + 1, x**2 - 1)
+    [x**2 + 1, x**2 - 1, -2]
+
+    """
+    return dup_inner_subresultants(f, g, K)[0]
+
+
+def dup_prs_resultant(f, g, K):
+    """
+    Resultant algorithm in `K[x]` using subresultant PRS.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_prs_resultant(x**2 + 1, x**2 - 1)
+    (4, [x**2 + 1, x**2 - 1, -2])
+
+    """
+    if not f or not g:
+        return (K.zero, [])
+
+    R, S = dup_inner_subresultants(f, g, K)
+
+    if dup_degree(R[-1]) > 0:
+        return (K.zero, R)
+
+    return S[-1], R
+
+
+def dup_resultant(f, g, K, includePRS=False):
+    """
+    Computes resultant of two polynomials in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_resultant(x**2 + 1, x**2 - 1)
+    4
+
+    """
+    if includePRS:
+        return dup_prs_resultant(f, g, K)
+    return dup_prs_resultant(f, g, K)[0]
+
+
+def dmp_inner_subresultants(f, g, u, K):
+    """
+    Subresultant PRS algorithm in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y - y**3 - 4
+    >>> g = x**2 + x*y**3 - 9
+
+    >>> a = 3*x*y**4 + y**3 - 27*y + 4
+    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    >>> prs = [f, g, a, b]
+    >>> sres = [[1], [1], [3, 0, 0, 0, 0], [-3, 0, 0, -12, 1, 0, -54, 8, 729, -216, 16]]
+
+    >>> R.dmp_inner_subresultants(f, g) == (prs, sres)
+    True
+
+    """
+    if not u:
+        return dup_inner_subresultants(f, g, K)
+
+    n = dmp_degree(f, u)
+    m = dmp_degree(g, u)
+
+    if n < m:
+        f, g = g, f
+        n, m = m, n
+
+    if dmp_zero_p(f, u):
+        return [], []
+
+    v = u - 1
+    if dmp_zero_p(g, u):
+        return [f], [dmp_ground(K.one, v)]
+
+    R = [f, g]
+    d = n - m
+
+    b = dmp_pow(dmp_ground(-K.one, v), d + 1, v, K)
+
+    h = dmp_prem(f, g, u, K)
+    h = dmp_mul_term(h, b, 0, u, K)
+
+    lc = dmp_LC(g, K)
+    c = dmp_pow(lc, d, v, K)
+
+    S = [dmp_ground(K.one, v), c]
+    c = dmp_neg(c, v, K)
+
+    while not dmp_zero_p(h, u):
+        k = dmp_degree(h, u)
+        R.append(h)
+
+        f, g, m, d = g, h, k, m - k
+
+        b = dmp_mul(dmp_neg(lc, v, K),
+                    dmp_pow(c, d, v, K), v, K)
+
+        h = dmp_prem(f, g, u, K)
+        h = [ dmp_quo(ch, b, v, K) for ch in h ]
+
+        lc = dmp_LC(g, K)
+
+        if d > 1:
+            p = dmp_pow(dmp_neg(lc, v, K), d, v, K)
+            q = dmp_pow(c, d - 1, v, K)
+            c = dmp_quo(p, q, v, K)
+        else:
+            c = dmp_neg(lc, v, K)
+
+        S.append(dmp_neg(c, v, K))
+
+    return R, S
+
+
+def dmp_subresultants(f, g, u, K):
+    """
+    Computes subresultant PRS of two polynomials in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y - y**3 - 4
+    >>> g = x**2 + x*y**3 - 9
+
+    >>> a = 3*x*y**4 + y**3 - 27*y + 4
+    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    >>> R.dmp_subresultants(f, g) == [f, g, a, b]
+    True
+
+    """
+    return dmp_inner_subresultants(f, g, u, K)[0]
+
+
+def dmp_prs_resultant(f, g, u, K):
+    """
+    Resultant algorithm in `K[X]` using subresultant PRS.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y - y**3 - 4
+    >>> g = x**2 + x*y**3 - 9
+
+    >>> a = 3*x*y**4 + y**3 - 27*y + 4
+    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    >>> res, prs = R.dmp_prs_resultant(f, g)
+
+    >>> res == b             # resultant has n-1 variables
+    False
+    >>> res == b.drop(x)
+    True
+    >>> prs == [f, g, a, b]
+    True
+
+    """
+    if not u:
+        return dup_prs_resultant(f, g, K)
+
+    if dmp_zero_p(f, u) or dmp_zero_p(g, u):
+        return (dmp_zero(u - 1), [])
+
+    R, S = dmp_inner_subresultants(f, g, u, K)
+
+    if dmp_degree(R[-1], u) > 0:
+        return (dmp_zero(u - 1), R)
+
+    return S[-1], R
+
+
+def dmp_zz_modular_resultant(f, g, p, u, K):
+    """
+    Compute resultant of `f` and `g` modulo a prime `p`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x + y + 2
+    >>> g = 2*x*y + x + 3
+
+    >>> R.dmp_zz_modular_resultant(f, g, 5)
+    -2*y**2 + 1
+
+    """
+    if not u:
+        return gf_int(dup_prs_resultant(f, g, K)[0] % p, p)
+
+    v = u - 1
+
+    n = dmp_degree(f, u)
+    m = dmp_degree(g, u)
+
+    N = dmp_degree_in(f, 1, u)
+    M = dmp_degree_in(g, 1, u)
+
+    B = n*M + m*N
+
+    D, a = [K.one], -K.one
+    r = dmp_zero(v)
+
+    while dup_degree(D) <= B:
+        while True:
+            a += K.one
+
+            if a == p:
+                raise HomomorphismFailed('no luck')
+
+            F = dmp_eval_in(f, gf_int(a, p), 1, u, K)
+
+            if dmp_degree(F, v) == n:
+                G = dmp_eval_in(g, gf_int(a, p), 1, u, K)
+
+                if dmp_degree(G, v) == m:
+                    break
+
+        R = dmp_zz_modular_resultant(F, G, p, v, K)
+        e = dmp_eval(r, a, v, K)
+
+        if not v:
+            R = dup_strip([R])
+            e = dup_strip([e])
+        else:
+            R = [R]
+            e = [e]
+
+        d = K.invert(dup_eval(D, a, K), p)
+        d = dup_mul_ground(D, d, K)
+        d = dmp_raise(d, v, 0, K)
+
+        c = dmp_mul(d, dmp_sub(R, e, v, K), v, K)
+        r = dmp_add(r, c, v, K)
+
+        r = dmp_ground_trunc(r, p, v, K)
+
+        D = dup_mul(D, [K.one, -a], K)
+        D = dup_trunc(D, p, K)
+
+    return r
+
+
+def _collins_crt(r, R, P, p, K):
+    """Wrapper of CRT for Collins's resultant algorithm. """
+    return gf_int(gf_crt([r, R], [P, p], K), P*p)
+
+
+def dmp_zz_collins_resultant(f, g, u, K):
+    """
+    Collins's modular resultant algorithm in `Z[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = x + y + 2
+    >>> g = 2*x*y + x + 3
+
+    >>> R.dmp_zz_collins_resultant(f, g)
+    -2*y**2 - 5*y + 1
+
+    """
+
+    n = dmp_degree(f, u)
+    m = dmp_degree(g, u)
+
+    if n < 0 or m < 0:
+        return dmp_zero(u - 1)
+
+    A = dmp_max_norm(f, u, K)
+    B = dmp_max_norm(g, u, K)
+
+    a = dmp_ground_LC(f, u, K)
+    b = dmp_ground_LC(g, u, K)
+
+    v = u - 1
+
+    B = K(2)*K.factorial(K(n + m))*A**m*B**n
+    r, p, P = dmp_zero(v), K.one, K.one
+
+    from sympy.ntheory import nextprime
+
+    while P <= B:
+        p = K(nextprime(p))
+
+        while not (a % p) or not (b % p):
+            p = K(nextprime(p))
+
+        F = dmp_ground_trunc(f, p, u, K)
+        G = dmp_ground_trunc(g, p, u, K)
+
+        try:
+            R = dmp_zz_modular_resultant(F, G, p, u, K)
+        except HomomorphismFailed:
+            continue
+
+        if K.is_one(P):
+            r = R
+        else:
+            r = dmp_apply_pairs(r, R, _collins_crt, (P, p, K), v, K)
+
+        P *= p
+
+    return r
+
+
+def dmp_qq_collins_resultant(f, g, u, K0):
+    """
+    Collins's modular resultant algorithm in `Q[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y = ring("x,y", QQ)
+
+    >>> f = QQ(1,2)*x + y + QQ(2,3)
+    >>> g = 2*x*y + x + 3
+
+    >>> R.dmp_qq_collins_resultant(f, g)
+    -2*y**2 - 7/3*y + 5/6
+
+    """
+    n = dmp_degree(f, u)
+    m = dmp_degree(g, u)
+
+    if n < 0 or m < 0:
+        return dmp_zero(u - 1)
+
+    K1 = K0.get_ring()
+
+    cf, f = dmp_clear_denoms(f, u, K0, K1)
+    cg, g = dmp_clear_denoms(g, u, K0, K1)
+
+    f = dmp_convert(f, u, K0, K1)
+    g = dmp_convert(g, u, K0, K1)
+
+    r = dmp_zz_collins_resultant(f, g, u, K1)
+    r = dmp_convert(r, u - 1, K1, K0)
+
+    c = K0.convert(cf**m * cg**n, K1)
+
+    return dmp_quo_ground(r, c, u - 1, K0)
+
+
+def dmp_resultant(f, g, u, K, includePRS=False):
+    """
+    Computes resultant of two polynomials in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> f = 3*x**2*y - y**3 - 4
+    >>> g = x**2 + x*y**3 - 9
+
+    >>> R.dmp_resultant(f, g)
+    -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    """
+    if not u:
+        return dup_resultant(f, g, K, includePRS=includePRS)
+
+    if includePRS:
+        return dmp_prs_resultant(f, g, u, K)
+
+    if K.is_Field:
+        if K.is_QQ and query('USE_COLLINS_RESULTANT'):
+            return dmp_qq_collins_resultant(f, g, u, K)
+    else:
+        if K.is_ZZ and query('USE_COLLINS_RESULTANT'):
+            return dmp_zz_collins_resultant(f, g, u, K)
+
+    return dmp_prs_resultant(f, g, u, K)[0]
+
+
+def dup_discriminant(f, K):
+    """
+    Computes discriminant of a polynomial in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_discriminant(x**2 + 2*x + 3)
+    -8
+
+    """
+    d = dup_degree(f)
+
+    if d <= 0:
+        return K.zero
+    else:
+        s = (-1)**((d*(d - 1)) // 2)
+        c = dup_LC(f, K)
+
+        r = dup_resultant(f, dup_diff(f, 1, K), K)
+
+        return K.quo(r, c*K(s))
+
+
+def dmp_discriminant(f, u, K):
+    """
+    Computes discriminant of a polynomial in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y,z,t = ring("x,y,z,t", ZZ)
+
+    >>> R.dmp_discriminant(x**2*y + x*z + t)
+    -4*y*t + z**2
+
+    """
+    if not u:
+        return dup_discriminant(f, K)
+
+    d, v = dmp_degree(f, u), u - 1
+
+    if d <= 0:
+        return dmp_zero(v)
+    else:
+        s = (-1)**((d*(d - 1)) // 2)
+        c = dmp_LC(f, K)
+
+        r = dmp_resultant(f, dmp_diff(f, 1, u, K), u, K)
+        c = dmp_mul_ground(c, K(s), v, K)
+
+        return dmp_quo(r, c, v, K)
+
+
+def _dup_rr_trivial_gcd(f, g, K):
+    """Handle trivial cases in GCD algorithm over a ring. """
+    if not (f or g):
+        return [], [], []
+    elif not f:
+        if K.is_nonnegative(dup_LC(g, K)):
+            return g, [], [K.one]
+        else:
+            return dup_neg(g, K), [], [-K.one]
+    elif not g:
+        if K.is_nonnegative(dup_LC(f, K)):
+            return f, [K.one], []
+        else:
+            return dup_neg(f, K), [-K.one], []
+
+    return None
+
+
+def _dup_ff_trivial_gcd(f, g, K):
+    """Handle trivial cases in GCD algorithm over a field. """
+    if not (f or g):
+        return [], [], []
+    elif not f:
+        return dup_monic(g, K), [], [dup_LC(g, K)]
+    elif not g:
+        return dup_monic(f, K), [dup_LC(f, K)], []
+    else:
+        return None
+
+
+def _dmp_rr_trivial_gcd(f, g, u, K):
+    """Handle trivial cases in GCD algorithm over a ring. """
+    zero_f = dmp_zero_p(f, u)
+    zero_g = dmp_zero_p(g, u)
+    if_contain_one = dmp_one_p(f, u, K) or dmp_one_p(g, u, K)
+
+    if zero_f and zero_g:
+        return tuple(dmp_zeros(3, u, K))
+    elif zero_f:
+        if K.is_nonnegative(dmp_ground_LC(g, u, K)):
+            return g, dmp_zero(u), dmp_one(u, K)
+        else:
+            return dmp_neg(g, u, K), dmp_zero(u), dmp_ground(-K.one, u)
+    elif zero_g:
+        if K.is_nonnegative(dmp_ground_LC(f, u, K)):
+            return f, dmp_one(u, K), dmp_zero(u)
+        else:
+            return dmp_neg(f, u, K), dmp_ground(-K.one, u), dmp_zero(u)
+    elif if_contain_one:
+        return dmp_one(u, K), f, g
+    elif query('USE_SIMPLIFY_GCD'):
+        return _dmp_simplify_gcd(f, g, u, K)
+    else:
+        return None
+
+
+def _dmp_ff_trivial_gcd(f, g, u, K):
+    """Handle trivial cases in GCD algorithm over a field. """
+    zero_f = dmp_zero_p(f, u)
+    zero_g = dmp_zero_p(g, u)
+
+    if zero_f and zero_g:
+        return tuple(dmp_zeros(3, u, K))
+    elif zero_f:
+        return (dmp_ground_monic(g, u, K),
+                dmp_zero(u),
+                dmp_ground(dmp_ground_LC(g, u, K), u))
+    elif zero_g:
+        return (dmp_ground_monic(f, u, K),
+                dmp_ground(dmp_ground_LC(f, u, K), u),
+                dmp_zero(u))
+    elif query('USE_SIMPLIFY_GCD'):
+        return _dmp_simplify_gcd(f, g, u, K)
+    else:
+        return None
+
+
+def _dmp_simplify_gcd(f, g, u, K):
+    """Try to eliminate `x_0` from GCD computation in `K[X]`. """
+    df = dmp_degree(f, u)
+    dg = dmp_degree(g, u)
+
+    if df > 0 and dg > 0:
+        return None
+
+    if not (df or dg):
+        F = dmp_LC(f, K)
+        G = dmp_LC(g, K)
+    else:
+        if not df:
+            F = dmp_LC(f, K)
+            G = dmp_content(g, u, K)
+        else:
+            F = dmp_content(f, u, K)
+            G = dmp_LC(g, K)
+
+    v = u - 1
+    h = dmp_gcd(F, G, v, K)
+
+    cff = [ dmp_quo(cf, h, v, K) for cf in f ]
+    cfg = [ dmp_quo(cg, h, v, K) for cg in g ]
+
+    return [h], cff, cfg
+
+
+def dup_rr_prs_gcd(f, g, K):
+    """
+    Computes polynomial GCD using subresultants over a ring.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
+    and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_rr_prs_gcd(x**2 - 1, x**2 - 3*x + 2)
+    (x - 1, x + 1, x - 2)
+
+    """
+    result = _dup_rr_trivial_gcd(f, g, K)
+
+    if result is not None:
+        return result
+
+    fc, F = dup_primitive(f, K)
+    gc, G = dup_primitive(g, K)
+
+    c = K.gcd(fc, gc)
+
+    h = dup_subresultants(F, G, K)[-1]
+    _, h = dup_primitive(h, K)
+
+    c *= K.canonical_unit(dup_LC(h, K))
+
+    h = dup_mul_ground(h, c, K)
+
+    cff = dup_quo(f, h, K)
+    cfg = dup_quo(g, h, K)
+
+    return h, cff, cfg
+
+
+def dup_ff_prs_gcd(f, g, K):
+    """
+    Computes polynomial GCD using subresultants over a field.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
+    and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> R.dup_ff_prs_gcd(x**2 - 1, x**2 - 3*x + 2)
+    (x - 1, x + 1, x - 2)
+
+    """
+    result = _dup_ff_trivial_gcd(f, g, K)
+
+    if result is not None:
+        return result
+
+    h = dup_subresultants(f, g, K)[-1]
+    h = dup_monic(h, K)
+
+    cff = dup_quo(f, h, K)
+    cfg = dup_quo(g, h, K)
+
+    return h, cff, cfg
+
+
+def dmp_rr_prs_gcd(f, g, u, K):
+    """
+    Computes polynomial GCD using subresultants over a ring.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
+    and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_rr_prs_gcd(f, g)
+    (x + y, x + y, x)
+
+    """
+    if not u:
+        return dup_rr_prs_gcd(f, g, K)
+
+    result = _dmp_rr_trivial_gcd(f, g, u, K)
+
+    if result is not None:
+        return result
+
+    fc, F = dmp_primitive(f, u, K)
+    gc, G = dmp_primitive(g, u, K)
+
+    h = dmp_subresultants(F, G, u, K)[-1]
+    c, _, _ = dmp_rr_prs_gcd(fc, gc, u - 1, K)
+
+    if K.is_negative(dmp_ground_LC(h, u, K)):
+        h = dmp_neg(h, u, K)
+
+    _, h = dmp_primitive(h, u, K)
+    h = dmp_mul_term(h, c, 0, u, K)
+
+    cff = dmp_quo(f, h, u, K)
+    cfg = dmp_quo(g, h, u, K)
+
+    return h, cff, cfg
+
+
+def dmp_ff_prs_gcd(f, g, u, K):
+    """
+    Computes polynomial GCD using subresultants over a field.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
+    and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y, = ring("x,y", QQ)
+
+    >>> f = QQ(1,2)*x**2 + x*y + QQ(1,2)*y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_ff_prs_gcd(f, g)
+    (x + y, 1/2*x + 1/2*y, x)
+
+    """
+    if not u:
+        return dup_ff_prs_gcd(f, g, K)
+
+    result = _dmp_ff_trivial_gcd(f, g, u, K)
+
+    if result is not None:
+        return result
+
+    fc, F = dmp_primitive(f, u, K)
+    gc, G = dmp_primitive(g, u, K)
+
+    h = dmp_subresultants(F, G, u, K)[-1]
+    c, _, _ = dmp_ff_prs_gcd(fc, gc, u - 1, K)
+
+    _, h = dmp_primitive(h, u, K)
+    h = dmp_mul_term(h, c, 0, u, K)
+    h = dmp_ground_monic(h, u, K)
+
+    cff = dmp_quo(f, h, u, K)
+    cfg = dmp_quo(g, h, u, K)
+
+    return h, cff, cfg
+
+HEU_GCD_MAX = 6
+
+
+def _dup_zz_gcd_interpolate(h, x, K):
+    """Interpolate polynomial GCD from integer GCD. """
+    f = []
+
+    while h:
+        g = h % x
+
+        if g > x // 2:
+            g -= x
+
+        f.insert(0, g)
+        h = (h - g) // x
+
+    return f
+
+
+def dup_zz_heu_gcd(f, g, K):
+    """
+    Heuristic polynomial GCD in `Z[x]`.
+
+    Given univariate polynomials `f` and `g` in `Z[x]`, returns
+    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
+    such that::
+
+          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)
+
+    The algorithm is purely heuristic which means it may fail to compute
+    the GCD. This will be signaled by raising an exception. In this case
+    you will need to switch to another GCD method.
+
+    The algorithm computes the polynomial GCD by evaluating polynomials
+    f and g at certain points and computing (fast) integer GCD of those
+    evaluations. The polynomial GCD is recovered from the integer image
+    by interpolation.  The final step is to verify if the result is the
+    correct GCD. This gives cofactors as a side effect.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_zz_heu_gcd(x**2 - 1, x**2 - 3*x + 2)
+    (x - 1, x + 1, x - 2)
+
+    References
+    ==========
+
+    .. [1] [Liao95]_
+
+    """
+    result = _dup_rr_trivial_gcd(f, g, K)
+
+    if result is not None:
+        return result
+
+    df = dup_degree(f)
+    dg = dup_degree(g)
+
+    gcd, f, g = dup_extract(f, g, K)
+
+    if df == 0 or dg == 0:
+        return [gcd], f, g
+
+    f_norm = dup_max_norm(f, K)
+    g_norm = dup_max_norm(g, K)
+
+    B = K(2*min(f_norm, g_norm) + 29)
+
+    x = max(min(B, 99*K.sqrt(B)),
+            2*min(f_norm // abs(dup_LC(f, K)),
+                  g_norm // abs(dup_LC(g, K))) + 2)
+
+    for i in range(0, HEU_GCD_MAX):
+        ff = dup_eval(f, x, K)
+        gg = dup_eval(g, x, K)
+
+        if ff and gg:
+            h = K.gcd(ff, gg)
+
+            cff = ff // h
+            cfg = gg // h
+
+            h = _dup_zz_gcd_interpolate(h, x, K)
+            h = dup_primitive(h, K)[1]
+
+            cff_, r = dup_div(f, h, K)
+
+            if not r:
+                cfg_, r = dup_div(g, h, K)
+
+                if not r:
+                    h = dup_mul_ground(h, gcd, K)
+                    return h, cff_, cfg_
+
+            cff = _dup_zz_gcd_interpolate(cff, x, K)
+
+            h, r = dup_div(f, cff, K)
+
+            if not r:
+                cfg_, r = dup_div(g, h, K)
+
+                if not r:
+                    h = dup_mul_ground(h, gcd, K)
+                    return h, cff, cfg_
+
+            cfg = _dup_zz_gcd_interpolate(cfg, x, K)
+
+            h, r = dup_div(g, cfg, K)
+
+            if not r:
+                cff_, r = dup_div(f, h, K)
+
+                if not r:
+                    h = dup_mul_ground(h, gcd, K)
+                    return h, cff_, cfg
+
+        x = 73794*x * K.sqrt(K.sqrt(x)) // 27011
+
+    raise HeuristicGCDFailed('no luck')
+
+
+def _dmp_zz_gcd_interpolate(h, x, v, K):
+    """Interpolate polynomial GCD from integer GCD. """
+    f = []
+
+    while not dmp_zero_p(h, v):
+        g = dmp_ground_trunc(h, x, v, K)
+        f.insert(0, g)
+
+        h = dmp_sub(h, g, v, K)
+        h = dmp_quo_ground(h, x, v, K)
+
+    if K.is_negative(dmp_ground_LC(f, v + 1, K)):
+        return dmp_neg(f, v + 1, K)
+    else:
+        return f
+
+
+def dmp_zz_heu_gcd(f, g, u, K):
+    """
+    Heuristic polynomial GCD in `Z[X]`.
+
+    Given univariate polynomials `f` and `g` in `Z[X]`, returns
+    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
+    such that::
+
+          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)
+
+    The algorithm is purely heuristic which means it may fail to compute
+    the GCD. This will be signaled by raising an exception. In this case
+    you will need to switch to another GCD method.
+
+    The algorithm computes the polynomial GCD by evaluating polynomials
+    f and g at certain points and computing (fast) integer GCD of those
+    evaluations. The polynomial GCD is recovered from the integer image
+    by interpolation. The evaluation process reduces f and g variable by
+    variable into a large integer.  The final step is to verify if the
+    interpolated polynomial is the correct GCD. This gives cofactors of
+    the input polynomials as a side effect.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_zz_heu_gcd(f, g)
+    (x + y, x + y, x)
+
+    References
+    ==========
+
+    .. [1] [Liao95]_
+
+    """
+    if not u:
+        return dup_zz_heu_gcd(f, g, K)
+
+    result = _dmp_rr_trivial_gcd(f, g, u, K)
+
+    if result is not None:
+        return result
+
+    gcd, f, g = dmp_ground_extract(f, g, u, K)
+
+    f_norm = dmp_max_norm(f, u, K)
+    g_norm = dmp_max_norm(g, u, K)
+
+    B = K(2*min(f_norm, g_norm) + 29)
+
+    x = max(min(B, 99*K.sqrt(B)),
+            2*min(f_norm // abs(dmp_ground_LC(f, u, K)),
+                  g_norm // abs(dmp_ground_LC(g, u, K))) + 2)
+
+    for i in range(0, HEU_GCD_MAX):
+        ff = dmp_eval(f, x, u, K)
+        gg = dmp_eval(g, x, u, K)
+
+        v = u - 1
+
+        if not (dmp_zero_p(ff, v) or dmp_zero_p(gg, v)):
+            h, cff, cfg = dmp_zz_heu_gcd(ff, gg, v, K)
+
+            h = _dmp_zz_gcd_interpolate(h, x, v, K)
+            h = dmp_ground_primitive(h, u, K)[1]
+
+            cff_, r = dmp_div(f, h, u, K)
+
+            if dmp_zero_p(r, u):
+                cfg_, r = dmp_div(g, h, u, K)
+
+                if dmp_zero_p(r, u):
+                    h = dmp_mul_ground(h, gcd, u, K)
+                    return h, cff_, cfg_
+
+            cff = _dmp_zz_gcd_interpolate(cff, x, v, K)
+
+            h, r = dmp_div(f, cff, u, K)
+
+            if dmp_zero_p(r, u):
+                cfg_, r = dmp_div(g, h, u, K)
+
+                if dmp_zero_p(r, u):
+                    h = dmp_mul_ground(h, gcd, u, K)
+                    return h, cff, cfg_
+
+            cfg = _dmp_zz_gcd_interpolate(cfg, x, v, K)
+
+            h, r = dmp_div(g, cfg, u, K)
+
+            if dmp_zero_p(r, u):
+                cff_, r = dmp_div(f, h, u, K)
+
+                if dmp_zero_p(r, u):
+                    h = dmp_mul_ground(h, gcd, u, K)
+                    return h, cff_, cfg
+
+        x = 73794*x * K.sqrt(K.sqrt(x)) // 27011
+
+    raise HeuristicGCDFailed('no luck')
+
+
+def dup_qq_heu_gcd(f, g, K0):
+    """
+    Heuristic polynomial GCD in `Q[x]`.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
+    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2)
+    >>> g = QQ(1,2)*x**2 + x
+
+    >>> R.dup_qq_heu_gcd(f, g)
+    (x + 2, 1/2*x + 3/4, 1/2*x)
+
+    """
+    result = _dup_ff_trivial_gcd(f, g, K0)
+
+    if result is not None:
+        return result
+
+    K1 = K0.get_ring()
+
+    cf, f = dup_clear_denoms(f, K0, K1)
+    cg, g = dup_clear_denoms(g, K0, K1)
+
+    f = dup_convert(f, K0, K1)
+    g = dup_convert(g, K0, K1)
+
+    h, cff, cfg = dup_zz_heu_gcd(f, g, K1)
+
+    h = dup_convert(h, K1, K0)
+
+    c = dup_LC(h, K0)
+    h = dup_monic(h, K0)
+
+    cff = dup_convert(cff, K1, K0)
+    cfg = dup_convert(cfg, K1, K0)
+
+    cff = dup_mul_ground(cff, K0.quo(c, cf), K0)
+    cfg = dup_mul_ground(cfg, K0.quo(c, cg), K0)
+
+    return h, cff, cfg
+
+
+def dmp_qq_heu_gcd(f, g, u, K0):
+    """
+    Heuristic polynomial GCD in `Q[X]`.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
+    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y, = ring("x,y", QQ)
+
+    >>> f = QQ(1,4)*x**2 + x*y + y**2
+    >>> g = QQ(1,2)*x**2 + x*y
+
+    >>> R.dmp_qq_heu_gcd(f, g)
+    (x + 2*y, 1/4*x + 1/2*y, 1/2*x)
+
+    """
+    result = _dmp_ff_trivial_gcd(f, g, u, K0)
+
+    if result is not None:
+        return result
+
+    K1 = K0.get_ring()
+
+    cf, f = dmp_clear_denoms(f, u, K0, K1)
+    cg, g = dmp_clear_denoms(g, u, K0, K1)
+
+    f = dmp_convert(f, u, K0, K1)
+    g = dmp_convert(g, u, K0, K1)
+
+    h, cff, cfg = dmp_zz_heu_gcd(f, g, u, K1)
+
+    h = dmp_convert(h, u, K1, K0)
+
+    c = dmp_ground_LC(h, u, K0)
+    h = dmp_ground_monic(h, u, K0)
+
+    cff = dmp_convert(cff, u, K1, K0)
+    cfg = dmp_convert(cfg, u, K1, K0)
+
+    cff = dmp_mul_ground(cff, K0.quo(c, cf), u, K0)
+    cfg = dmp_mul_ground(cfg, K0.quo(c, cg), u, K0)
+
+    return h, cff, cfg
+
+
+def dup_inner_gcd(f, g, K):
+    """
+    Computes polynomial GCD and cofactors of `f` and `g` in `K[x]`.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
+    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_inner_gcd(x**2 - 1, x**2 - 3*x + 2)
+    (x - 1, x + 1, x - 2)
+
+    """
+    if not K.is_Exact:
+        try:
+            exact = K.get_exact()
+        except DomainError:
+            return [K.one], f, g
+
+        f = dup_convert(f, K, exact)
+        g = dup_convert(g, K, exact)
+
+        h, cff, cfg = dup_inner_gcd(f, g, exact)
+
+        h = dup_convert(h, exact, K)
+        cff = dup_convert(cff, exact, K)
+        cfg = dup_convert(cfg, exact, K)
+
+        return h, cff, cfg
+    elif K.is_Field:
+        if K.is_QQ and query('USE_HEU_GCD'):
+            try:
+                return dup_qq_heu_gcd(f, g, K)
+            except HeuristicGCDFailed:
+                pass
+
+        return dup_ff_prs_gcd(f, g, K)
+    else:
+        if K.is_ZZ and query('USE_HEU_GCD'):
+            try:
+                return dup_zz_heu_gcd(f, g, K)
+            except HeuristicGCDFailed:
+                pass
+
+        return dup_rr_prs_gcd(f, g, K)
+
+
+def _dmp_inner_gcd(f, g, u, K):
+    """Helper function for `dmp_inner_gcd()`. """
+    if not K.is_Exact:
+        try:
+            exact = K.get_exact()
+        except DomainError:
+            return dmp_one(u, K), f, g
+
+        f = dmp_convert(f, u, K, exact)
+        g = dmp_convert(g, u, K, exact)
+
+        h, cff, cfg = _dmp_inner_gcd(f, g, u, exact)
+
+        h = dmp_convert(h, u, exact, K)
+        cff = dmp_convert(cff, u, exact, K)
+        cfg = dmp_convert(cfg, u, exact, K)
+
+        return h, cff, cfg
+    elif K.is_Field:
+        if K.is_QQ and query('USE_HEU_GCD'):
+            try:
+                return dmp_qq_heu_gcd(f, g, u, K)
+            except HeuristicGCDFailed:
+                pass
+
+        return dmp_ff_prs_gcd(f, g, u, K)
+    else:
+        if K.is_ZZ and query('USE_HEU_GCD'):
+            try:
+                return dmp_zz_heu_gcd(f, g, u, K)
+            except HeuristicGCDFailed:
+                pass
+
+        return dmp_rr_prs_gcd(f, g, u, K)
+
+
+def dmp_inner_gcd(f, g, u, K):
+    """
+    Computes polynomial GCD and cofactors of `f` and `g` in `K[X]`.
+
+    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
+    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_inner_gcd(f, g)
+    (x + y, x + y, x)
+
+    """
+    if not u:
+        return dup_inner_gcd(f, g, K)
+
+    J, (f, g) = dmp_multi_deflate((f, g), u, K)
+    h, cff, cfg = _dmp_inner_gcd(f, g, u, K)
+
+    return (dmp_inflate(h, J, u, K),
+            dmp_inflate(cff, J, u, K),
+            dmp_inflate(cfg, J, u, K))
+
+
+def dup_gcd(f, g, K):
+    """
+    Computes polynomial GCD of `f` and `g` in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_gcd(x**2 - 1, x**2 - 3*x + 2)
+    x - 1
+
+    """
+    return dup_inner_gcd(f, g, K)[0]
+
+
+def dmp_gcd(f, g, u, K):
+    """
+    Computes polynomial GCD of `f` and `g` in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_gcd(f, g)
+    x + y
+
+    """
+    return dmp_inner_gcd(f, g, u, K)[0]
+
+
+def dup_rr_lcm(f, g, K):
+    """
+    Computes polynomial LCM over a ring in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_rr_lcm(x**2 - 1, x**2 - 3*x + 2)
+    x**3 - 2*x**2 - x + 2
+
+    """
+    fc, f = dup_primitive(f, K)
+    gc, g = dup_primitive(g, K)
+
+    c = K.lcm(fc, gc)
+
+    h = dup_quo(dup_mul(f, g, K),
+                dup_gcd(f, g, K), K)
+
+    return dup_mul_ground(h, c, K)
+
+
+def dup_ff_lcm(f, g, K):
+    """
+    Computes polynomial LCM over a field in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x = ring("x", QQ)
+
+    >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2)
+    >>> g = QQ(1,2)*x**2 + x
+
+    >>> R.dup_ff_lcm(f, g)
+    x**3 + 7/2*x**2 + 3*x
+
+    """
+    h = dup_quo(dup_mul(f, g, K),
+                dup_gcd(f, g, K), K)
+
+    return dup_monic(h, K)
+
+
+def dup_lcm(f, g, K):
+    """
+    Computes polynomial LCM of `f` and `g` in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_lcm(x**2 - 1, x**2 - 3*x + 2)
+    x**3 - 2*x**2 - x + 2
+
+    """
+    if K.is_Field:
+        return dup_ff_lcm(f, g, K)
+    else:
+        return dup_rr_lcm(f, g, K)
+
+
+def dmp_rr_lcm(f, g, u, K):
+    """
+    Computes polynomial LCM over a ring in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_rr_lcm(f, g)
+    x**3 + 2*x**2*y + x*y**2
+
+    """
+    fc, f = dmp_ground_primitive(f, u, K)
+    gc, g = dmp_ground_primitive(g, u, K)
+
+    c = K.lcm(fc, gc)
+
+    h = dmp_quo(dmp_mul(f, g, u, K),
+                dmp_gcd(f, g, u, K), u, K)
+
+    return dmp_mul_ground(h, c, u, K)
+
+
+def dmp_ff_lcm(f, g, u, K):
+    """
+    Computes polynomial LCM over a field in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, QQ
+    >>> R, x,y, = ring("x,y", QQ)
+
+    >>> f = QQ(1,4)*x**2 + x*y + y**2
+    >>> g = QQ(1,2)*x**2 + x*y
+
+    >>> R.dmp_ff_lcm(f, g)
+    x**3 + 4*x**2*y + 4*x*y**2
+
+    """
+    h = dmp_quo(dmp_mul(f, g, u, K),
+                dmp_gcd(f, g, u, K), u, K)
+
+    return dmp_ground_monic(h, u, K)
+
+
+def dmp_lcm(f, g, u, K):
+    """
+    Computes polynomial LCM of `f` and `g` in `K[X]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> R.dmp_lcm(f, g)
+    x**3 + 2*x**2*y + x*y**2
+
+    """
+    if not u:
+        return dup_lcm(f, g, K)
+
+    if K.is_Field:
+        return dmp_ff_lcm(f, g, u, K)
+    else:
+        return dmp_rr_lcm(f, g, u, K)
+
+
+def dmp_content(f, u, K):
+    """
+    Returns GCD of multivariate coefficients.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> R.dmp_content(2*x*y + 6*x + 4*y + 12)
+    2*y + 6
+
+    """
+    cont, v = dmp_LC(f, K), u - 1
+
+    if dmp_zero_p(f, u):
+        return cont
+
+    for c in f[1:]:
+        cont = dmp_gcd(cont, c, v, K)
+
+        if dmp_one_p(cont, v, K):
+            break
+
+    if K.is_negative(dmp_ground_LC(cont, v, K)):
+        return dmp_neg(cont, v, K)
+    else:
+        return cont
+
+
+def dmp_primitive(f, u, K):
+    """
+    Returns multivariate content and a primitive polynomial.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> R.dmp_primitive(2*x*y + 6*x + 4*y + 12)
+    (2*y + 6, x + 2)
+
+    """
+    cont, v = dmp_content(f, u, K), u - 1
+
+    if dmp_zero_p(f, u) or dmp_one_p(cont, v, K):
+        return cont, f
+    else:
+        return cont, [ dmp_quo(c, cont, v, K) for c in f ]
+
+
+def dup_cancel(f, g, K, include=True):
+    """
+    Cancel common factors in a rational function `f/g`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> R.dup_cancel(2*x**2 - 2, x**2 - 2*x + 1)
+    (2*x + 2, x - 1)
+
+    """
+    return dmp_cancel(f, g, 0, K, include=include)
+
+
+def dmp_cancel(f, g, u, K, include=True):
+    """
+    Cancel common factors in a rational function `f/g`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x,y = ring("x,y", ZZ)
+
+    >>> R.dmp_cancel(2*x**2 - 2, x**2 - 2*x + 1)
+    (2*x + 2, x - 1)
+
+    """
+    K0 = None
+
+    if K.is_Field and K.has_assoc_Ring:
+        K0, K = K, K.get_ring()
+
+        cq, f = dmp_clear_denoms(f, u, K0, K, convert=True)
+        cp, g = dmp_clear_denoms(g, u, K0, K, convert=True)
+    else:
+        cp, cq = K.one, K.one
+
+    _, p, q = dmp_inner_gcd(f, g, u, K)
+
+    if K0 is not None:
+        _, cp, cq = K.cofactors(cp, cq)
+
+        p = dmp_convert(p, u, K, K0)
+        q = dmp_convert(q, u, K, K0)
+
+        K = K0
+
+    p_neg = K.is_negative(dmp_ground_LC(p, u, K))
+    q_neg = K.is_negative(dmp_ground_LC(q, u, K))
+
+    if p_neg and q_neg:
+        p, q = dmp_neg(p, u, K), dmp_neg(q, u, K)
+    elif p_neg:
+        cp, p = -cp, dmp_neg(p, u, K)
+    elif q_neg:
+        cp, q = -cp, dmp_neg(q, u, K)
+
+    if not include:
+        return cp, cq, p, q
+
+    p = dmp_mul_ground(p, cp, u, K)
+    q = dmp_mul_ground(q, cq, u, K)
+
+    return p, q

llmeval-env/lib/python3.10/site-packages/sympy/polys/factortools.py

@@ -0,0 +1,1502 @@
+"""Polynomial factorization routines in characteristic zero. """
+
+from sympy.core.random import _randint
+
+from sympy.polys.galoistools import (
+    gf_from_int_poly, gf_to_int_poly,
+    gf_lshift, gf_add_mul, gf_mul,
+    gf_div, gf_rem,
+    gf_gcdex,
+    gf_sqf_p,
+    gf_factor_sqf, gf_factor)
+
+from sympy.polys.densebasic import (
+    dup_LC, dmp_LC, dmp_ground_LC,
+    dup_TC,
+    dup_convert, dmp_convert,
+    dup_degree, dmp_degree,
+    dmp_degree_in, dmp_degree_list,
+    dmp_from_dict,
+    dmp_zero_p,
+    dmp_one,
+    dmp_nest, dmp_raise,
+    dup_strip,
+    dmp_ground,
+    dup_inflate,
+    dmp_exclude, dmp_include,
+    dmp_inject, dmp_eject,
+    dup_terms_gcd, dmp_terms_gcd)
+
+from sympy.polys.densearith import (
+    dup_neg, dmp_neg,
+    dup_add, dmp_add,
+    dup_sub, dmp_sub,
+    dup_mul, dmp_mul,
+    dup_sqr,
+    dmp_pow,
+    dup_div, dmp_div,
+    dup_quo, dmp_quo,
+    dmp_expand,
+    dmp_add_mul,
+    dup_sub_mul, dmp_sub_mul,
+    dup_lshift,
+    dup_max_norm, dmp_max_norm,
+    dup_l1_norm,
+    dup_mul_ground, dmp_mul_ground,
+    dup_quo_ground, dmp_quo_ground)
+
+from sympy.polys.densetools import (
+    dup_clear_denoms, dmp_clear_denoms,
+    dup_trunc, dmp_ground_trunc,
+    dup_content,
+    dup_monic, dmp_ground_monic,
+    dup_primitive, dmp_ground_primitive,
+    dmp_eval_tail,
+    dmp_eval_in, dmp_diff_eval_in,
+    dmp_compose,
+    dup_shift, dup_mirror)
+
+from sympy.polys.euclidtools import (
+    dmp_primitive,
+    dup_inner_gcd, dmp_inner_gcd)
+
+from sympy.polys.sqfreetools import (
+    dup_sqf_p,
+    dup_sqf_norm, dmp_sqf_norm,
+    dup_sqf_part, dmp_sqf_part)
+
+from sympy.polys.polyutils import _sort_factors
+from sympy.polys.polyconfig import query
+
+from sympy.polys.polyerrors import (
+    ExtraneousFactors, DomainError, CoercionFailed, EvaluationFailed)
+
+from sympy.utilities import subsets
+
+from math import ceil as _ceil, log as _log
+
+
+def dup_trial_division(f, factors, K):
+    """
+    Determine multiplicities of factors for a univariate polynomial
+    using trial division.
+    """
+    result = []
+
+    for factor in factors:
+        k = 0
+
+        while True:
+            q, r = dup_div(f, factor, K)
+
+            if not r:
+                f, k = q, k + 1
+            else:
+                break
+
+        result.append((factor, k))
+
+    return _sort_factors(result)
+
+
+def dmp_trial_division(f, factors, u, K):
+    """
+    Determine multiplicities of factors for a multivariate polynomial
+    using trial division.
+    """
+    result = []
+
+    for factor in factors:
+        k = 0
+
+        while True:
+            q, r = dmp_div(f, factor, u, K)
+
+            if dmp_zero_p(r, u):
+                f, k = q, k + 1
+            else:
+                break
+
+        result.append((factor, k))
+
+    return _sort_factors(result)
+
+
+def dup_zz_mignotte_bound(f, K):
+    """
+    The Knuth-Cohen variant of Mignotte bound for
+    univariate polynomials in `K[x]`.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> f = x**3 + 14*x**2 + 56*x + 64
+    >>> R.dup_zz_mignotte_bound(f)
+    152
+
+    By checking `factor(f)` we can see that max coeff is 8
+
+    Also consider a case that `f` is irreducible for example `f = 2*x**2 + 3*x + 4`
+    To avoid a bug for these cases, we return the bound plus the max coefficient of `f`
+
+    >>> f = 2*x**2 + 3*x + 4
+    >>> R.dup_zz_mignotte_bound(f)
+    6
+
+    Lastly,To see the difference between the new and the old Mignotte bound
+    consider the irreducible polynomial::
+
+    >>> f = 87*x**7 + 4*x**6 + 80*x**5 + 17*x**4 + 9*x**3 + 12*x**2 + 49*x + 26
+    >>> R.dup_zz_mignotte_bound(f)
+    744
+
+    The new Mignotte bound is 744 whereas the old one (SymPy 1.5.1) is 1937664.
+
+
+    References
+    ==========
+
+    ..[1] [Abbott2013]_
+
+    """
+    from sympy.functions.combinatorial.factorials import binomial
+    d = dup_degree(f)
+    delta = _ceil(d / 2)
+    delta2 = _ceil(delta / 2)
+
+    # euclidean-norm
+    eucl_norm = K.sqrt( sum( [cf**2 for cf in f] ) )
+
+    # biggest values of binomial coefficients (p. 538 of reference)
+    t1 = binomial(delta - 1, delta2)
+    t2 = binomial(delta - 1, delta2 - 1)
+
+    lc = K.abs(dup_LC(f, K))   # leading coefficient
+    bound = t1 * eucl_norm + t2 * lc   # (p. 538 of reference)
+    bound += dup_max_norm(f, K) # add max coeff for irreducible polys
+    bound = _ceil(bound / 2) * 2   # round up to even integer
+
+    return bound
+
+def dmp_zz_mignotte_bound(f, u, K):
+    """Mignotte bound for multivariate polynomials in `K[X]`. """
+    a = dmp_max_norm(f, u, K)
+    b = abs(dmp_ground_LC(f, u, K))
+    n = sum(dmp_degree_list(f, u))
+
+    return K.sqrt(K(n + 1))*2**n*a*b
+
+
+def dup_zz_hensel_step(m, f, g, h, s, t, K):
+    """
+    One step in Hensel lifting in `Z[x]`.
+
+    Given positive integer `m` and `Z[x]` polynomials `f`, `g`, `h`, `s`
+    and `t` such that::
+
+        f = g*h (mod m)
+        s*g + t*h = 1 (mod m)
+
+        lc(f) is not a zero divisor (mod m)
+        lc(h) = 1
+
+        deg(f) = deg(g) + deg(h)
+        deg(s) < deg(h)
+        deg(t) < deg(g)
+
+    returns polynomials `G`, `H`, `S` and `T`, such that::
+
+        f = G*H (mod m**2)
+        S*G + T*H = 1 (mod m**2)
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+
+    """
+    M = m**2
+
+    e = dup_sub_mul(f, g, h, K)
+    e = dup_trunc(e, M, K)
+
+    q, r = dup_div(dup_mul(s, e, K), h, K)
+
+    q = dup_trunc(q, M, K)
+    r = dup_trunc(r, M, K)
+
+    u = dup_add(dup_mul(t, e, K), dup_mul(q, g, K), K)
+    G = dup_trunc(dup_add(g, u, K), M, K)
+    H = dup_trunc(dup_add(h, r, K), M, K)
+
+    u = dup_add(dup_mul(s, G, K), dup_mul(t, H, K), K)
+    b = dup_trunc(dup_sub(u, [K.one], K), M, K)
+
+    c, d = dup_div(dup_mul(s, b, K), H, K)
+
+    c = dup_trunc(c, M, K)
+    d = dup_trunc(d, M, K)
+
+    u = dup_add(dup_mul(t, b, K), dup_mul(c, G, K), K)
+    S = dup_trunc(dup_sub(s, d, K), M, K)
+    T = dup_trunc(dup_sub(t, u, K), M, K)
+
+    return G, H, S, T
+
+
+def dup_zz_hensel_lift(p, f, f_list, l, K):
+    r"""
+    Multifactor Hensel lifting in `Z[x]`.
+
+    Given a prime `p`, polynomial `f` over `Z[x]` such that `lc(f)`
+    is a unit modulo `p`, monic pair-wise coprime polynomials `f_i`
+    over `Z[x]` satisfying::
+
+        f = lc(f) f_1 ... f_r (mod p)
+
+    and a positive integer `l`, returns a list of monic polynomials
+    `F_1,\ F_2,\ \dots,\ F_r` satisfying::
+
+       f = lc(f) F_1 ... F_r (mod p**l)
+
+       F_i = f_i (mod p), i = 1..r
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+
+    """
+    r = len(f_list)
+    lc = dup_LC(f, K)
+
+    if r == 1:
+        F = dup_mul_ground(f, K.gcdex(lc, p**l)[0], K)
+        return [ dup_trunc(F, p**l, K) ]
+
+    m = p
+    k = r // 2
+    d = int(_ceil(_log(l, 2)))
+
+    g = gf_from_int_poly([lc], p)
+
+    for f_i in f_list[:k]:
+        g = gf_mul(g, gf_from_int_poly(f_i, p), p, K)
+
+    h = gf_from_int_poly(f_list[k], p)
+
+    for f_i in f_list[k + 1:]:
+        h = gf_mul(h, gf_from_int_poly(f_i, p), p, K)
+
+    s, t, _ = gf_gcdex(g, h, p, K)
+
+    g = gf_to_int_poly(g, p)
+    h = gf_to_int_poly(h, p)
+    s = gf_to_int_poly(s, p)
+    t = gf_to_int_poly(t, p)
+
+    for _ in range(1, d + 1):
+        (g, h, s, t), m = dup_zz_hensel_step(m, f, g, h, s, t, K), m**2
+
+    return dup_zz_hensel_lift(p, g, f_list[:k], l, K) \
+        + dup_zz_hensel_lift(p, h, f_list[k:], l, K)
+
+def _test_pl(fc, q, pl):
+    if q > pl // 2:
+        q = q - pl
+    if not q:
+        return True
+    return fc % q == 0
+
+def dup_zz_zassenhaus(f, K):
+    """Factor primitive square-free polynomials in `Z[x]`. """
+    n = dup_degree(f)
+
+    if n == 1:
+        return [f]
+
+    from sympy.ntheory import isprime
+
+    fc = f[-1]
+    A = dup_max_norm(f, K)
+    b = dup_LC(f, K)
+    B = int(abs(K.sqrt(K(n + 1))*2**n*A*b))
+    C = int((n + 1)**(2*n)*A**(2*n - 1))
+    gamma = int(_ceil(2*_log(C, 2)))
+    bound = int(2*gamma*_log(gamma))
+    a = []
+    # choose a prime number `p` such that `f` be square free in Z_p
+    # if there are many factors in Z_p, choose among a few different `p`
+    # the one with fewer factors
+    for px in range(3, bound + 1):
+        if not isprime(px) or b % px == 0:
+            continue
+
+        px = K.convert(px)
+
+        F = gf_from_int_poly(f, px)
+
+        if not gf_sqf_p(F, px, K):
+            continue
+        fsqfx = gf_factor_sqf(F, px, K)[1]
+        a.append((px, fsqfx))
+        if len(fsqfx) < 15 or len(a) > 4:
+            break
+    p, fsqf = min(a, key=lambda x: len(x[1]))
+
+    l = int(_ceil(_log(2*B + 1, p)))
+
+    modular = [gf_to_int_poly(ff, p) for ff in fsqf]
+
+    g = dup_zz_hensel_lift(p, f, modular, l, K)
+
+    sorted_T = range(len(g))
+    T = set(sorted_T)
+    factors, s = [], 1
+    pl = p**l
+
+    while 2*s <= len(T):
+        for S in subsets(sorted_T, s):
+            # lift the constant coefficient of the product `G` of the factors
+            # in the subset `S`; if it is does not divide `fc`, `G` does
+            # not divide the input polynomial
+
+            if b == 1:
+                q = 1
+                for i in S:
+                    q = q*g[i][-1]
+                q = q % pl
+                if not _test_pl(fc, q, pl):
+                    continue
+            else:
+                G = [b]
+                for i in S:
+                    G = dup_mul(G, g[i], K)
+                G = dup_trunc(G, pl, K)
+                G = dup_primitive(G, K)[1]
+                q = G[-1]
+                if q and fc % q != 0:
+                    continue
+
+            H = [b]
+            S = set(S)
+            T_S = T - S
+
+            if b == 1:
+                G = [b]
+                for i in S:
+                    G = dup_mul(G, g[i], K)
+                G = dup_trunc(G, pl, K)
+
+            for i in T_S:
+                H = dup_mul(H, g[i], K)
+
+            H = dup_trunc(H, pl, K)
+
+            G_norm = dup_l1_norm(G, K)
+            H_norm = dup_l1_norm(H, K)
+
+            if G_norm*H_norm <= B:
+                T = T_S
+                sorted_T = [i for i in sorted_T if i not in S]
+
+                G = dup_primitive(G, K)[1]
+                f = dup_primitive(H, K)[1]
+
+                factors.append(G)
+                b = dup_LC(f, K)
+
+                break
+        else:
+            s += 1
+
+    return factors + [f]
+
+
+def dup_zz_irreducible_p(f, K):
+    """Test irreducibility using Eisenstein's criterion. """
+    lc = dup_LC(f, K)
+    tc = dup_TC(f, K)
+
+    e_fc = dup_content(f[1:], K)
+
+    if e_fc:
+        from sympy.ntheory import factorint
+        e_ff = factorint(int(e_fc))
+
+        for p in e_ff.keys():
+            if (lc % p) and (tc % p**2):
+                return True
+
+
+def dup_cyclotomic_p(f, K, irreducible=False):
+    """
+    Efficiently test if ``f`` is a cyclotomic polynomial.
+
+    Examples
+    ========
+
+    >>> from sympy.polys import ring, ZZ
+    >>> R, x = ring("x", ZZ)
+
+    >>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1
+    >>> R.dup_cyclotomic_p(f)
+    False
+
+    >>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1
+    >>> R.dup_cyclotomic_p(g)
+    True
+
+    References
+    ==========
+
+    Bradford, Russell J., and James H. Davenport. "Effective tests for
+    cyclotomic polynomials." In International Symposium on Symbolic and
+    Algebraic Computation, pp. 244-251. Springer, Berlin, Heidelberg, 1988.
+
+    """
+    if K.is_QQ:
+        try:
+            K0, K = K, K.get_ring()
+            f = dup_convert(f, K0, K)
+        except CoercionFailed:
+            return False
+    elif not K.is_ZZ:
+        return False
+
+    lc = dup_LC(f, K)
+    tc = dup_TC(f, K)
+
+    if lc != 1 or (tc != -1 and tc != 1):
+        return False
+
+    if not irreducible:
+        coeff, factors = dup_factor_list(f, K)
+
+        if coeff != K.one or factors != [(f, 1)]:
+            return False
+
+    n = dup_degree(f)
+    g, h = [], []
+
+    for i in range(n, -1, -2):
+        g.insert(0, f[i])
+
+    for i in range(n - 1, -1, -2):
+        h.insert(0, f[i])
+
+    g = dup_sqr(dup_strip(g), K)
+    h = dup_sqr(dup_strip(h), K)
+
+    F = dup_sub(g, dup_lshift(h, 1, K), K)
+
+    if K.is_negative(dup_LC(F, K)):
+        F = dup_neg(F, K)
+
+    if F == f:
+        return True
+
+    g = dup_mirror(f, K)
+
+    if K.is_negative(dup_LC(g, K)):
+        g = dup_neg(g, K)
+
+    if F == g and dup_cyclotomic_p(g, K):
+        return True
+
+    G = dup_sqf_part(F, K)
+
+    if dup_sqr(G, K) == F and dup_cyclotomic_p(G, K):
+        return True
+
+    return False
+
+
+def dup_zz_cyclotomic_poly(n, K):
+    """Efficiently generate n-th cyclotomic polynomial. """
+    from sympy.ntheory import factorint
+    h = [K.one, -K.one]
+
+    for p, k in factorint(n).items():
+        h = dup_quo(dup_inflate(h, p, K), h, K)
+        h = dup_inflate(h, p**(k - 1), K)
+
+    return h
+
+
+def _dup_cyclotomic_decompose(n, K):
+    from sympy.ntheory import factorint
+
+    H = [[K.one, -K.one]]
+
+    for p, k in factorint(n).items():
+        Q = [ dup_quo(dup_inflate(h, p, K), h, K) for h in H ]
+        H.extend(Q)
+
+        for i in range(1, k):
+            Q = [ dup_inflate(q, p, K) for q in Q ]
+            H.extend(Q)
+
+    return H
+
+
+def dup_zz_cyclotomic_factor(f, K):
+    """
+    Efficiently factor polynomials `x**n - 1` and `x**n + 1` in `Z[x]`.
+
+    Given a univariate polynomial `f` in `Z[x]` returns a list of factors
+    of `f`, provided that `f` is in the form `x**n - 1` or `x**n + 1` for
+    `n >= 1`. Otherwise returns None.
+
+    Factorization is performed using cyclotomic decomposition of `f`,
+    which makes this method much faster that any other direct factorization
+    approach (e.g. Zassenhaus's).
+
+    References
+    ==========
+
+    .. [1] [Weisstein09]_
+
+    """
+    lc_f, tc_f = dup_LC(f, K), dup_TC(f, K)
+
+    if dup_degree(f) <= 0:
+        return None
+
+    if lc_f != 1 or tc_f not in [-1, 1]:
+        return None
+
+    if any(bool(cf) for cf in f[1:-1]):
+        return None
+
+    n = dup_degree(f)
+    F = _dup_cyclotomic_decompose(n, K)
+
+    if not K.is_one(tc_f):
+        return F
+    else:
+        H = []
+
+        for h in _dup_cyclotomic_decompose(2*n, K):
+            if h not in F:
+                H.append(h)
+
+        return H
+
+
+def dup_zz_factor_sqf(f, K):
+    """Factor square-free (non-primitive) polynomials in `Z[x]`. """
+    cont, g = dup_primitive(f, K)
+
+    n = dup_degree(g)
+
+    if dup_LC(g, K) < 0:
+        cont, g = -cont, dup_neg(g, K)
+
+    if n <= 0:
+        return cont, []
+    elif n == 1:
+        return cont, [g]
+
+    if query('USE_IRREDUCIBLE_IN_FACTOR'):
+        if dup_zz_irreducible_p(g, K):
+            return cont, [g]
+
+    factors = None
+
+    if query('USE_CYCLOTOMIC_FACTOR'):
+        factors = dup_zz_cyclotomic_factor(g, K)
+
+    if factors is None:
+        factors = dup_zz_zassenhaus(g, K)
+
+    return cont, _sort_factors(factors, multiple=False)
+
+
+def dup_zz_factor(f, K):
+    """
+    Factor (non square-free) polynomials in `Z[x]`.
+
+    Given a univariate polynomial `f` in `Z[x]` computes its complete
+    factorization `f_1, ..., f_n` into irreducibles over integers::
+
+                f = content(f) f_1**k_1 ... f_n**k_n
+
+    The factorization is computed by reducing the input polynomial
+    into a primitive square-free polynomial and factoring it using
+    Zassenhaus algorithm. Trial division is used to recover the
+    multiplicities of factors.
+
+    The result is returned as a tuple consisting of::
+
+              (content(f), [(f_1, k_1), ..., (f_n, k_n))
+
+    Examples
+    ========
+
+    Consider the polynomial `f = 2*x**4 - 2`::
+
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x = ring("x", ZZ)
+
+        >>> R.dup_zz_factor(2*x**4 - 2)
+        (2, [(x - 1, 1), (x + 1, 1), (x**2 + 1, 1)])
+
+    In result we got the following factorization::
+
+                 f = 2 (x - 1) (x + 1) (x**2 + 1)
+
+    Note that this is a complete factorization over integers,
+    however over Gaussian integers we can factor the last term.
+
+    By default, polynomials `x**n - 1` and `x**n + 1` are factored
+    using cyclotomic decomposition to speedup computations. To
+    disable this behaviour set cyclotomic=False.
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+
+    """
+    cont, g = dup_primitive(f, K)
+
+    n = dup_degree(g)
+
+    if dup_LC(g, K) < 0:
+        cont, g = -cont, dup_neg(g, K)
+
+    if n <= 0:
+        return cont, []
+    elif n == 1:
+        return cont, [(g, 1)]
+
+    if query('USE_IRREDUCIBLE_IN_FACTOR'):
+        if dup_zz_irreducible_p(g, K):
+            return cont, [(g, 1)]
+
+    g = dup_sqf_part(g, K)
+    H = None
+
+    if query('USE_CYCLOTOMIC_FACTOR'):
+        H = dup_zz_cyclotomic_factor(g, K)
+
+    if H is None:
+        H = dup_zz_zassenhaus(g, K)
+
+    factors = dup_trial_division(f, H, K)
+    return cont, factors
+
+
+def dmp_zz_wang_non_divisors(E, cs, ct, K):
+    """Wang/EEZ: Compute a set of valid divisors.  """
+    result = [ cs*ct ]
+
+    for q in E:
+        q = abs(q)
+
+        for r in reversed(result):
+            while r != 1:
+                r = K.gcd(r, q)
+                q = q // r
+
+            if K.is_one(q):
+                return None
+
+        result.append(q)
+
+    return result[1:]
+
+
+def dmp_zz_wang_test_points(f, T, ct, A, u, K):
+    """Wang/EEZ: Test evaluation points for suitability. """
+    if not dmp_eval_tail(dmp_LC(f, K), A, u - 1, K):
+        raise EvaluationFailed('no luck')
+
+    g = dmp_eval_tail(f, A, u, K)
+
+    if not dup_sqf_p(g, K):
+        raise EvaluationFailed('no luck')
+
+    c, h = dup_primitive(g, K)
+
+    if K.is_negative(dup_LC(h, K)):
+        c, h = -c, dup_neg(h, K)
+
+    v = u - 1
+
+    E = [ dmp_eval_tail(t, A, v, K) for t, _ in T ]
+    D = dmp_zz_wang_non_divisors(E, c, ct, K)
+
+    if D is not None:
+        return c, h, E
+    else:
+        raise EvaluationFailed('no luck')
+
+
+def dmp_zz_wang_lead_coeffs(f, T, cs, E, H, A, u, K):
+    """Wang/EEZ: Compute correct leading coefficients. """
+    C, J, v = [], [0]*len(E), u - 1
+
+    for h in H:
+        c = dmp_one(v, K)
+        d = dup_LC(h, K)*cs
+
+        for i in reversed(range(len(E))):
+            k, e, (t, _) = 0, E[i], T[i]
+
+            while not (d % e):
+                d, k = d//e, k + 1
+
+            if k != 0:
+                c, J[i] = dmp_mul(c, dmp_pow(t, k, v, K), v, K), 1
+
+        C.append(c)
+
+    if not all(J):
+        raise ExtraneousFactors  # pragma: no cover
+
+    CC, HH = [], []
+
+    for c, h in zip(C, H):
+        d = dmp_eval_tail(c, A, v, K)
+        lc = dup_LC(h, K)
+
+        if K.is_one(cs):
+            cc = lc//d
+        else:
+            g = K.gcd(lc, d)
+            d, cc = d//g, lc//g
+            h, cs = dup_mul_ground(h, d, K), cs//d
+
+        c = dmp_mul_ground(c, cc, v, K)
+
+        CC.append(c)
+        HH.append(h)
+
+    if K.is_one(cs):
+        return f, HH, CC
+
+    CCC, HHH = [], []
+
+    for c, h in zip(CC, HH):
+        CCC.append(dmp_mul_ground(c, cs, v, K))
+        HHH.append(dmp_mul_ground(h, cs, 0, K))
+
+    f = dmp_mul_ground(f, cs**(len(H) - 1), u, K)
+
+    return f, HHH, CCC
+
+
+def dup_zz_diophantine(F, m, p, K):
+    """Wang/EEZ: Solve univariate Diophantine equations. """
+    if len(F) == 2:
+        a, b = F
+
+        f = gf_from_int_poly(a, p)
+        g = gf_from_int_poly(b, p)
+
+        s, t, G = gf_gcdex(g, f, p, K)
+
+        s = gf_lshift(s, m, K)
+        t = gf_lshift(t, m, K)
+
+        q, s = gf_div(s, f, p, K)
+
+        t = gf_add_mul(t, q, g, p, K)
+
+        s = gf_to_int_poly(s, p)
+        t = gf_to_int_poly(t, p)
+
+        result = [s, t]
+    else:
+        G = [F[-1]]
+
+        for f in reversed(F[1:-1]):
+            G.insert(0, dup_mul(f, G[0], K))
+
+        S, T = [], [[1]]
+
+        for f, g in zip(F, G):
+            t, s = dmp_zz_diophantine([g, f], T[-1], [], 0, p, 1, K)
+            T.append(t)
+            S.append(s)
+
+        result, S = [], S + [T[-1]]
+
+        for s, f in zip(S, F):
+            s = gf_from_int_poly(s, p)
+            f = gf_from_int_poly(f, p)
+
+            r = gf_rem(gf_lshift(s, m, K), f, p, K)
+            s = gf_to_int_poly(r, p)
+
+            result.append(s)
+
+    return result
+
+
+def dmp_zz_diophantine(F, c, A, d, p, u, K):
+    """Wang/EEZ: Solve multivariate Diophantine equations. """
+    if not A:
+        S = [ [] for _ in F ]
+        n = dup_degree(c)
+
+        for i, coeff in enumerate(c):
+            if not coeff:
+                continue
+
+            T = dup_zz_diophantine(F, n - i, p, K)
+
+            for j, (s, t) in enumerate(zip(S, T)):
+                t = dup_mul_ground(t, coeff, K)
+                S[j] = dup_trunc(dup_add(s, t, K), p, K)
+    else:
+        n = len(A)
+        e = dmp_expand(F, u, K)
+
+        a, A = A[-1], A[:-1]
+        B, G = [], []
+
+        for f in F:
+            B.append(dmp_quo(e, f, u, K))
+            G.append(dmp_eval_in(f, a, n, u, K))
+
+        C = dmp_eval_in(c, a, n, u, K)
+
+        v = u - 1
+
+        S = dmp_zz_diophantine(G, C, A, d, p, v, K)
+        S = [ dmp_raise(s, 1, v, K) for s in S ]
+
+        for s, b in zip(S, B):
+            c = dmp_sub_mul(c, s, b, u, K)
+
+        c = dmp_ground_trunc(c, p, u, K)
+
+        m = dmp_nest([K.one, -a], n, K)
+        M = dmp_one(n, K)
+
+        for k in K.map(range(0, d)):
+            if dmp_zero_p(c, u):
+                break
+
+            M = dmp_mul(M, m, u, K)
+            C = dmp_diff_eval_in(c, k + 1, a, n, u, K)
+
+            if not dmp_zero_p(C, v):
+                C = dmp_quo_ground(C, K.factorial(k + 1), v, K)
+                T = dmp_zz_diophantine(G, C, A, d, p, v, K)
+
+                for i, t in enumerate(T):
+                    T[i] = dmp_mul(dmp_raise(t, 1, v, K), M, u, K)
+
+                for i, (s, t) in enumerate(zip(S, T)):
+                    S[i] = dmp_add(s, t, u, K)
+
+                for t, b in zip(T, B):
+                    c = dmp_sub_mul(c, t, b, u, K)
+
+                c = dmp_ground_trunc(c, p, u, K)
+
+        S = [ dmp_ground_trunc(s, p, u, K) for s in S ]
+
+    return S
+
+
+def dmp_zz_wang_hensel_lifting(f, H, LC, A, p, u, K):
+    """Wang/EEZ: Parallel Hensel lifting algorithm. """
+    S, n, v = [f], len(A), u - 1
+
+    H = list(H)
+
+    for i, a in enumerate(reversed(A[1:])):
+        s = dmp_eval_in(S[0], a, n - i, u - i, K)
+        S.insert(0, dmp_ground_trunc(s, p, v - i, K))
+
+    d = max(dmp_degree_list(f, u)[1:])
+
+    for j, s, a in zip(range(2, n + 2), S, A):
+        G, w = list(H), j - 1
+
+        I, J = A[:j - 2], A[j - 1:]
+
+        for i, (h, lc) in enumerate(zip(H, LC)):
+            lc = dmp_ground_trunc(dmp_eval_tail(lc, J, v, K), p, w - 1, K)
+            H[i] = [lc] + dmp_raise(h[1:], 1, w - 1, K)
+
+        m = dmp_nest([K.one, -a], w, K)
+        M = dmp_one(w, K)
+
+        c = dmp_sub(s, dmp_expand(H, w, K), w, K)
+
+        dj = dmp_degree_in(s, w, w)
+
+        for k in K.map(range(0, dj)):
+            if dmp_zero_p(c, w):
+                break
+
+            M = dmp_mul(M, m, w, K)
+            C = dmp_diff_eval_in(c, k + 1, a, w, w, K)
+
+            if not dmp_zero_p(C, w - 1):
+                C = dmp_quo_ground(C, K.factorial(k + 1), w - 1, K)
+                T = dmp_zz_diophantine(G, C, I, d, p, w - 1, K)
+
+                for i, (h, t) in enumerate(zip(H, T)):
+                    h = dmp_add_mul(h, dmp_raise(t, 1, w - 1, K), M, w, K)
+                    H[i] = dmp_ground_trunc(h, p, w, K)
+
+                h = dmp_sub(s, dmp_expand(H, w, K), w, K)
+                c = dmp_ground_trunc(h, p, w, K)
+
+    if dmp_expand(H, u, K) != f:
+        raise ExtraneousFactors  # pragma: no cover
+    else:
+        return H
+
+
+def dmp_zz_wang(f, u, K, mod=None, seed=None):
+    r"""
+    Factor primitive square-free polynomials in `Z[X]`.
+
+    Given a multivariate polynomial `f` in `Z[x_1,...,x_n]`, which is
+    primitive and square-free in `x_1`, computes factorization of `f` into
+    irreducibles over integers.
+
+    The procedure is based on Wang's Enhanced Extended Zassenhaus
+    algorithm. The algorithm works by viewing `f` as a univariate polynomial
+    in `Z[x_2,...,x_n][x_1]`, for which an evaluation mapping is computed::
+
+                      x_2 -> a_2, ..., x_n -> a_n
+
+    where `a_i`, for `i = 2, \dots, n`, are carefully chosen integers.  The
+    mapping is used to transform `f` into a univariate polynomial in `Z[x_1]`,
+    which can be factored efficiently using Zassenhaus algorithm. The last
+    step is to lift univariate factors to obtain true multivariate
+    factors. For this purpose a parallel Hensel lifting procedure is used.
+
+    The parameter ``seed`` is passed to _randint and can be used to seed randint
+    (when an integer) or (for testing purposes) can be a sequence of numbers.
+
+    References
+    ==========
+
+    .. [1] [Wang78]_
+    .. [2] [Geddes92]_
+
+    """
+    from sympy.ntheory import nextprime
+
+    randint = _randint(seed)
+
+    ct, T = dmp_zz_factor(dmp_LC(f, K), u - 1, K)
+
+    b = dmp_zz_mignotte_bound(f, u, K)
+    p = K(nextprime(b))
+
+    if mod is None:
+        if u == 1:
+            mod = 2
+        else:
+            mod = 1
+
+    history, configs, A, r = set(), [], [K.zero]*u, None
+
+    try:
+        cs, s, E = dmp_zz_wang_test_points(f, T, ct, A, u, K)
+
+        _, H = dup_zz_factor_sqf(s, K)
+
+        r = len(H)
+
+        if r == 1:
+            return [f]
+
+        configs = [(s, cs, E, H, A)]
+    except EvaluationFailed:
+        pass
+
+    eez_num_configs = query('EEZ_NUMBER_OF_CONFIGS')
+    eez_num_tries = query('EEZ_NUMBER_OF_TRIES')
+    eez_mod_step = query('EEZ_MODULUS_STEP')
+
+    while len(configs) < eez_num_configs:
+        for _ in range(eez_num_tries):
+            A = [ K(randint(-mod, mod)) for _ in range(u) ]
+
+            if tuple(A) not in history:
+                history.add(tuple(A))
+            else:
+                continue
+
+            try:
+                cs, s, E = dmp_zz_wang_test_points(f, T, ct, A, u, K)
+            except EvaluationFailed:
+                continue
+
+            _, H = dup_zz_factor_sqf(s, K)
+
+            rr = len(H)
+
+            if r is not None:
+                if rr != r:  # pragma: no cover
+                    if rr < r:
+                        configs, r = [], rr
+                    else:
+                        continue
+            else:
+                r = rr
+
+            if r == 1:
+                return [f]
+
+            configs.append((s, cs, E, H, A))
+
+            if len(configs) == eez_num_configs:
+                break
+        else:
+            mod += eez_mod_step
+
+    s_norm, s_arg, i = None, 0, 0
+
+    for s, _, _, _, _ in configs:
+        _s_norm = dup_max_norm(s, K)
+
+        if s_norm is not None:
+            if _s_norm < s_norm:
+                s_norm = _s_norm
+                s_arg = i
+        else:
+            s_norm = _s_norm
+
+        i += 1
+
+    _, cs, E, H, A = configs[s_arg]
+    orig_f = f
+
+    try:
+        f, H, LC = dmp_zz_wang_lead_coeffs(f, T, cs, E, H, A, u, K)
+        factors = dmp_zz_wang_hensel_lifting(f, H, LC, A, p, u, K)
+    except ExtraneousFactors:  # pragma: no cover
+        if query('EEZ_RESTART_IF_NEEDED'):
+            return dmp_zz_wang(orig_f, u, K, mod + 1)
+        else:
+            raise ExtraneousFactors(
+                "we need to restart algorithm with better parameters")
+
+    result = []
+
+    for f in factors:
+        _, f = dmp_ground_primitive(f, u, K)
+
+        if K.is_negative(dmp_ground_LC(f, u, K)):
+            f = dmp_neg(f, u, K)
+
+        result.append(f)
+
+    return result
+
+
+def dmp_zz_factor(f, u, K):
+    r"""
+    Factor (non square-free) polynomials in `Z[X]`.
+
+    Given a multivariate polynomial `f` in `Z[x]` computes its complete
+    factorization `f_1, \dots, f_n` into irreducibles over integers::
+
+                 f = content(f) f_1**k_1 ... f_n**k_n
+
+    The factorization is computed by reducing the input polynomial
+    into a primitive square-free polynomial and factoring it using
+    Enhanced Extended Zassenhaus (EEZ) algorithm. Trial division
+    is used to recover the multiplicities of factors.
+
+    The result is returned as a tuple consisting of::
+
+             (content(f), [(f_1, k_1), ..., (f_n, k_n))
+
+    Consider polynomial `f = 2*(x**2 - y**2)`::
+
+        >>> from sympy.polys import ring, ZZ
+        >>> R, x,y = ring("x,y", ZZ)
+
+        >>> R.dmp_zz_factor(2*x**2 - 2*y**2)
+        (2, [(x - y, 1), (x + y, 1)])
+
+    In result we got the following factorization::
+
+                    f = 2 (x - y) (x + y)
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+
+    """
+    if not u:
+        return dup_zz_factor(f, K)
+
+    if dmp_zero_p(f, u):
+        return K.zero, []
+
+    cont, g = dmp_ground_primitive(f, u, K)
+
+    if dmp_ground_LC(g, u, K) < 0:
+        cont, g = -cont, dmp_neg(g, u, K)
+
+    if all(d <= 0 for d in dmp_degree_list(g, u)):
+        return cont, []
+
+    G, g = dmp_primitive(g, u, K)
+
+    factors = []
+
+    if dmp_degree(g, u) > 0:
+        g = dmp_sqf_part(g, u, K)
+        H = dmp_zz_wang(g, u, K)
+        factors = dmp_trial_division(f, H, u, K)
+
+    for g, k in dmp_zz_factor(G, u - 1, K)[1]:
+        factors.insert(0, ([g], k))
+
+    return cont, _sort_factors(factors)
+
+
+def dup_qq_i_factor(f, K0):
+    """Factor univariate polynomials into irreducibles in `QQ_I[x]`. """
+    # Factor in QQ<I>
+    K1 = K0.as_AlgebraicField()
+    f = dup_convert(f, K0, K1)
+    coeff, factors = dup_factor_list(f, K1)
+    factors = [(dup_convert(fac, K1, K0), i) for fac, i in factors]
+    coeff = K0.convert(coeff, K1)
+    return coeff, factors
+
+
+def dup_zz_i_factor(f, K0):
+    """Factor univariate polynomials into irreducibles in `ZZ_I[x]`. """
+    # First factor in QQ_I
+    K1 = K0.get_field()
+    f = dup_convert(f, K0, K1)
+    coeff, factors = dup_qq_i_factor(f, K1)
+
+    new_factors = []
+    for fac, i in factors:
+        # Extract content
+        fac_denom, fac_num = dup_clear_denoms(fac, K1)
+        fac_num_ZZ_I = dup_convert(fac_num, K1, K0)
+        content, fac_prim = dmp_ground_primitive(fac_num_ZZ_I, 0, K1)
+
+        coeff = (coeff * content ** i) // fac_denom ** i
+        new_factors.append((fac_prim, i))
+
+    factors = new_factors
+    coeff = K0.convert(coeff, K1)
+    return coeff, factors
+
+
+def dmp_qq_i_factor(f, u, K0):
+    """Factor multivariate polynomials into irreducibles in `QQ_I[X]`. """
+    # Factor in QQ<I>
+    K1 = K0.as_AlgebraicField()
+    f = dmp_convert(f, u, K0, K1)
+    coeff, factors = dmp_factor_list(f, u, K1)
+    factors = [(dmp_convert(fac, u, K1, K0), i) for fac, i in factors]
+    coeff = K0.convert(coeff, K1)
+    return coeff, factors
+
+
+def dmp_zz_i_factor(f, u, K0):
+    """Factor multivariate polynomials into irreducibles in `ZZ_I[X]`. """
+    # First factor in QQ_I
+    K1 = K0.get_field()
+    f = dmp_convert(f, u, K0, K1)
+    coeff, factors = dmp_qq_i_factor(f, u, K1)
+
+    new_factors = []
+    for fac, i in factors:
+        # Extract content
+        fac_denom, fac_num = dmp_clear_denoms(fac, u, K1)
+        fac_num_ZZ_I = dmp_convert(fac_num, u, K1, K0)
+        content, fac_prim = dmp_ground_primitive(fac_num_ZZ_I, u, K1)
+
+        coeff = (coeff * content ** i) // fac_denom ** i
+        new_factors.append((fac_prim, i))
+
+    factors = new_factors
+    coeff = K0.convert(coeff, K1)
+    return coeff, factors
+
+
+def dup_ext_factor(f, K):
+    """Factor univariate polynomials over algebraic number fields. """
+    n, lc = dup_degree(f), dup_LC(f, K)
+
+    f = dup_monic(f, K)
+
+    if n <= 0:
+        return lc, []
+    if n == 1:
+        return lc, [(f, 1)]
+
+    f, F = dup_sqf_part(f, K), f
+    s, g, r = dup_sqf_norm(f, K)
+
+    factors = dup_factor_list_include(r, K.dom)
+
+    if len(factors) == 1:
+        return lc, [(f, n//dup_degree(f))]
+
+    H = s*K.unit
+
+    for i, (factor, _) in enumerate(factors):
+        h = dup_convert(factor, K.dom, K)
+        h, _, g = dup_inner_gcd(h, g, K)
+        h = dup_shift(h, H, K)
+        factors[i] = h
+
+    factors = dup_trial_division(F, factors, K)
+    return lc, factors
+
+
+def dmp_ext_factor(f, u, K):
+    """Factor multivariate polynomials over algebraic number fields. """
+    if not u:
+        return dup_ext_factor(f, K)
+
+    lc = dmp_ground_LC(f, u, K)
+    f = dmp_ground_monic(f, u, K)
+
+    if all(d <= 0 for d in dmp_degree_list(f, u)):
+        return lc, []
+
+    f, F = dmp_sqf_part(f, u, K), f
+    s, g, r = dmp_sqf_norm(f, u, K)
+
+    factors = dmp_factor_list_include(r, u, K.dom)
+
+    if len(factors) == 1:
+        factors = [f]
+    else:
+        H = dmp_raise([K.one, s*K.unit], u, 0, K)
+
+        for i, (factor, _) in enumerate(factors):
+            h = dmp_convert(factor, u, K.dom, K)
+            h, _, g = dmp_inner_gcd(h, g, u, K)
+            h = dmp_compose(h, H, u, K)
+            factors[i] = h
+
+    return lc, dmp_trial_division(F, factors, u, K)
+
+
+def dup_gf_factor(f, K):
+    """Factor univariate polynomials over finite fields. """
+    f = dup_convert(f, K, K.dom)
+
+    coeff, factors = gf_factor(f, K.mod, K.dom)
+
+    for i, (f, k) in enumerate(factors):
+        factors[i] = (dup_convert(f, K.dom, K), k)
+
+    return K.convert(coeff, K.dom), factors
+
+
+def dmp_gf_factor(f, u, K):
+    """Factor multivariate polynomials over finite fields. """
+    raise NotImplementedError('multivariate polynomials over finite fields')
+
+
+def dup_factor_list(f, K0):
+    """Factor univariate polynomials into irreducibles in `K[x]`. """
+    j, f = dup_terms_gcd(f, K0)
+    cont, f = dup_primitive(f, K0)
+
+    if K0.is_FiniteField:
+        coeff, factors = dup_gf_factor(f, K0)
+    elif K0.is_Algebraic:
+        coeff, factors = dup_ext_factor(f, K0)
+    elif K0.is_GaussianRing:
+        coeff, factors = dup_zz_i_factor(f, K0)
+    elif K0.is_GaussianField:
+        coeff, factors = dup_qq_i_factor(f, K0)
+    else:
+        if not K0.is_Exact:
+            K0_inexact, K0 = K0, K0.get_exact()
+            f = dup_convert(f, K0_inexact, K0)
+        else:
+            K0_inexact = None
+
+        if K0.is_Field:
+            K = K0.get_ring()
+
+            denom, f = dup_clear_denoms(f, K0, K)
+            f = dup_convert(f, K0, K)
+        else:
+            K = K0
+
+        if K.is_ZZ:
+            coeff, factors = dup_zz_factor(f, K)
+        elif K.is_Poly:
+            f, u = dmp_inject(f, 0, K)
+
+            coeff, factors = dmp_factor_list(f, u, K.dom)
+
+            for i, (f, k) in enumerate(factors):
+                factors[i] = (dmp_eject(f, u, K), k)
+
+            coeff = K.convert(coeff, K.dom)
+        else:  # pragma: no cover
+            raise DomainError('factorization not supported over %s' % K0)
+
+        if K0.is_Field:
+            for i, (f, k) in enumerate(factors):
+                factors[i] = (dup_convert(f, K, K0), k)
+
+            coeff = K0.convert(coeff, K)
+            coeff = K0.quo(coeff, denom)
+
+            if K0_inexact:
+                for i, (f, k) in enumerate(factors):
+                    max_norm = dup_max_norm(f, K0)
+                    f = dup_quo_ground(f, max_norm, K0)
+                    f = dup_convert(f, K0, K0_inexact)
+                    factors[i] = (f, k)
+                    coeff = K0.mul(coeff, K0.pow(max_norm, k))
+
+                coeff = K0_inexact.convert(coeff, K0)
+                K0 = K0_inexact
+
+    if j:
+        factors.insert(0, ([K0.one, K0.zero], j))
+
+    return coeff*cont, _sort_factors(factors)
+
+
+def dup_factor_list_include(f, K):
+    """Factor univariate polynomials into irreducibles in `K[x]`. """
+    coeff, factors = dup_factor_list(f, K)
+
+    if not factors:
+        return [(dup_strip([coeff]), 1)]
+    else:
+        g = dup_mul_ground(factors[0][0], coeff, K)
+        return [(g, factors[0][1])] + factors[1:]
+
+
+def dmp_factor_list(f, u, K0):
+    """Factor multivariate polynomials into irreducibles in `K[X]`. """
+    if not u:
+        return dup_factor_list(f, K0)
+
+    J, f = dmp_terms_gcd(f, u, K0)
+    cont, f = dmp_ground_primitive(f, u, K0)
+
+    if K0.is_FiniteField:  # pragma: no cover
+        coeff, factors = dmp_gf_factor(f, u, K0)
+    elif K0.is_Algebraic:
+        coeff, factors = dmp_ext_factor(f, u, K0)
+    elif K0.is_GaussianRing:
+        coeff, factors = dmp_zz_i_factor(f, u, K0)
+    elif K0.is_GaussianField:
+        coeff, factors = dmp_qq_i_factor(f, u, K0)
+    else:
+        if not K0.is_Exact:
+            K0_inexact, K0 = K0, K0.get_exact()
+            f = dmp_convert(f, u, K0_inexact, K0)
+        else:
+            K0_inexact = None
+
+        if K0.is_Field:
+            K = K0.get_ring()
+
+            denom, f = dmp_clear_denoms(f, u, K0, K)
+            f = dmp_convert(f, u, K0, K)
+        else:
+            K = K0
+
+        if K.is_ZZ:
+            levels, f, v = dmp_exclude(f, u, K)
+            coeff, factors = dmp_zz_factor(f, v, K)
+
+            for i, (f, k) in enumerate(factors):
+                factors[i] = (dmp_include(f, levels, v, K), k)
+        elif K.is_Poly:
+            f, v = dmp_inject(f, u, K)
+
+            coeff, factors = dmp_factor_list(f, v, K.dom)
+
+            for i, (f, k) in enumerate(factors):
+                factors[i] = (dmp_eject(f, v, K), k)
+
+            coeff = K.convert(coeff, K.dom)
+        else:  # pragma: no cover
+            raise DomainError('factorization not supported over %s' % K0)
+
+        if K0.is_Field:
+            for i, (f, k) in enumerate(factors):
+                factors[i] = (dmp_convert(f, u, K, K0), k)
+
+            coeff = K0.convert(coeff, K)
+            coeff = K0.quo(coeff, denom)
+
+            if K0_inexact:
+                for i, (f, k) in enumerate(factors):
+                    max_norm = dmp_max_norm(f, u, K0)
+                    f = dmp_quo_ground(f, max_norm, u, K0)
+                    f = dmp_convert(f, u, K0, K0_inexact)
+                    factors[i] = (f, k)
+                    coeff = K0.mul(coeff, K0.pow(max_norm, k))
+
+                coeff = K0_inexact.convert(coeff, K0)
+                K0 = K0_inexact
+
+    for i, j in enumerate(reversed(J)):
+        if not j:
+            continue
+
+        term = {(0,)*(u - i) + (1,) + (0,)*i: K0.one}
+        factors.insert(0, (dmp_from_dict(term, u, K0), j))
+
+    return coeff*cont, _sort_factors(factors)
+
+
+def dmp_factor_list_include(f, u, K):
+    """Factor multivariate polynomials into irreducibles in `K[X]`. """
+    if not u:
+        return dup_factor_list_include(f, K)
+
+    coeff, factors = dmp_factor_list(f, u, K)
+
+    if not factors:
+        return [(dmp_ground(coeff, u), 1)]
+    else:
+        g = dmp_mul_ground(factors[0][0], coeff, u, K)
+        return [(g, factors[0][1])] + factors[1:]
+
+
+def dup_irreducible_p(f, K):
+    """
+    Returns ``True`` if a univariate polynomial ``f`` has no factors
+    over its domain.
+    """
+    return dmp_irreducible_p(f, 0, K)
+
+
+def dmp_irreducible_p(f, u, K):
+    """
+    Returns ``True`` if a multivariate polynomial ``f`` has no factors
+    over its domain.
+    """
+    _, factors = dmp_factor_list(f, u, K)
+
+    if not factors:
+        return True
+    elif len(factors) > 1:
+        return False
+    else:
+        _, k = factors[0]
+        return k == 1

llmeval-env/lib/python3.10/site-packages/sympy/polys/fglmtools.py

@@ -0,0 +1,153 @@
+"""Implementation of matrix FGLM Groebner basis conversion algorithm. """
+
+
+from sympy.polys.monomials import monomial_mul, monomial_div
+
+def matrix_fglm(F, ring, O_to):
+    """
+    Converts the reduced Groebner basis ``F`` of a zero-dimensional
+    ideal w.r.t. ``O_from`` to a reduced Groebner basis
+    w.r.t. ``O_to``.
+
+    References
+    ==========
+
+    .. [1] J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient
+           Computation of Zero-dimensional Groebner Bases by Change of
+           Ordering
+    """
+    domain = ring.domain
+    ngens = ring.ngens
+
+    ring_to = ring.clone(order=O_to)
+
+    old_basis = _basis(F, ring)
+    M = _representing_matrices(old_basis, F, ring)
+
+    # V contains the normalforms (wrt O_from) of S
+    S = [ring.zero_monom]
+    V = [[domain.one] + [domain.zero] * (len(old_basis) - 1)]
+    G = []
+
+    L = [(i, 0) for i in range(ngens)]  # (i, j) corresponds to x_i * S[j]
+    L.sort(key=lambda k_l: O_to(_incr_k(S[k_l[1]], k_l[0])), reverse=True)
+    t = L.pop()
+
+    P = _identity_matrix(len(old_basis), domain)
+
+    while True:
+        s = len(S)
+        v = _matrix_mul(M[t[0]], V[t[1]])
+        _lambda = _matrix_mul(P, v)
+
+        if all(_lambda[i] == domain.zero for i in range(s, len(old_basis))):
+            # there is a linear combination of v by V
+            lt = ring.term_new(_incr_k(S[t[1]], t[0]), domain.one)
+            rest = ring.from_dict({S[i]: _lambda[i] for i in range(s)})
+
+            g = (lt - rest).set_ring(ring_to)
+            if g:
+                G.append(g)
+        else:
+            # v is linearly independent from V
+            P = _update(s, _lambda, P)
+            S.append(_incr_k(S[t[1]], t[0]))
+            V.append(v)
+
+            L.extend([(i, s) for i in range(ngens)])
+            L = list(set(L))
+            L.sort(key=lambda k_l: O_to(_incr_k(S[k_l[1]], k_l[0])), reverse=True)
+
+        L = [(k, l) for (k, l) in L if all(monomial_div(_incr_k(S[l], k), g.LM) is None for g in G)]
+
+        if not L:
+            G = [ g.monic() for g in G ]
+            return sorted(G, key=lambda g: O_to(g.LM), reverse=True)
+
+        t = L.pop()
+
+
+def _incr_k(m, k):
+    return tuple(list(m[:k]) + [m[k] + 1] + list(m[k + 1:]))
+
+
+def _identity_matrix(n, domain):
+    M = [[domain.zero]*n for _ in range(n)]
+
+    for i in range(n):
+        M[i][i] = domain.one
+
+    return M
+
+
+def _matrix_mul(M, v):
+    return [sum([row[i] * v[i] for i in range(len(v))]) for row in M]
+
+
+def _update(s, _lambda, P):
+    """
+    Update ``P`` such that for the updated `P'` `P' v = e_{s}`.
+    """
+    k = min([j for j in range(s, len(_lambda)) if _lambda[j] != 0])
+
+    for r in range(len(_lambda)):
+        if r != k:
+            P[r] = [P[r][j] - (P[k][j] * _lambda[r]) / _lambda[k] for j in range(len(P[r]))]
+
+    P[k] = [P[k][j] / _lambda[k] for j in range(len(P[k]))]
+    P[k], P[s] = P[s], P[k]
+
+    return P
+
+
+def _representing_matrices(basis, G, ring):
+    r"""
+    Compute the matrices corresponding to the linear maps `m \mapsto
+    x_i m` for all variables `x_i`.
+    """
+    domain = ring.domain
+    u = ring.ngens-1
+
+    def var(i):
+        return tuple([0] * i + [1] + [0] * (u - i))
+
+    def representing_matrix(m):
+        M = [[domain.zero] * len(basis) for _ in range(len(basis))]
+
+        for i, v in enumerate(basis):
+            r = ring.term_new(monomial_mul(m, v), domain.one).rem(G)
+
+            for monom, coeff in r.terms():
+                j = basis.index(monom)
+                M[j][i] = coeff
+
+        return M
+
+    return [representing_matrix(var(i)) for i in range(u + 1)]
+
+
+def _basis(G, ring):
+    r"""
+    Computes a list of monomials which are not divisible by the leading
+    monomials wrt to ``O`` of ``G``. These monomials are a basis of
+    `K[X_1, \ldots, X_n]/(G)`.
+    """
+    order = ring.order
+
+    leading_monomials = [g.LM for g in G]
+    candidates = [ring.zero_monom]
+    basis = []
+
+    while candidates:
+        t = candidates.pop()
+        basis.append(t)
+
+        new_candidates = [_incr_k(t, k) for k in range(ring.ngens)
+            if all(monomial_div(_incr_k(t, k), lmg) is None
+            for lmg in leading_monomials)]
+        candidates.extend(new_candidates)
+        candidates.sort(key=order, reverse=True)
+
+    basis = list(set(basis))
+
+    return sorted(basis, key=order)

llmeval-env/lib/python3.10/site-packages/sympy/polys/fields.py

@@ -0,0 +1,631 @@
+"""Sparse rational function fields. """
+
+from __future__ import annotations
+from typing import Any
+from functools import reduce
+
+from operator import add, mul, lt, le, gt, ge
+
+from sympy.core.expr import Expr
+from sympy.core.mod import Mod
+from sympy.core.numbers import Exp1
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import CantSympify, sympify
+from sympy.functions.elementary.exponential import ExpBase
+from sympy.polys.domains.domainelement import DomainElement
+from sympy.polys.domains.fractionfield import FractionField
+from sympy.polys.domains.polynomialring import PolynomialRing
+from sympy.polys.constructor import construct_domain
+from sympy.polys.orderings import lex
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.polys.polyoptions import build_options
+from sympy.polys.polyutils import _parallel_dict_from_expr
+from sympy.polys.rings import PolyElement
+from sympy.printing.defaults import DefaultPrinting
+from sympy.utilities import public
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.magic import pollute
+
+@public
+def field(symbols, domain, order=lex):
+    """Construct new rational function field returning (field, x1, ..., xn). """
+    _field = FracField(symbols, domain, order)
+    return (_field,) + _field.gens
+
+@public
+def xfield(symbols, domain, order=lex):
+    """Construct new rational function field returning (field, (x1, ..., xn)). """
+    _field = FracField(symbols, domain, order)
+    return (_field, _field.gens)
+
+@public
+def vfield(symbols, domain, order=lex):
+    """Construct new rational function field and inject generators into global namespace. """
+    _field = FracField(symbols, domain, order)
+    pollute([ sym.name for sym in _field.symbols ], _field.gens)
+    return _field
+
+@public
+def sfield(exprs, *symbols, **options):
+    """Construct a field deriving generators and domain
+    from options and input expressions.
+
+    Parameters
+    ==========
+
+    exprs   : py:class:`~.Expr` or sequence of :py:class:`~.Expr` (sympifiable)
+
+    symbols : sequence of :py:class:`~.Symbol`/:py:class:`~.Expr`
+
+    options : keyword arguments understood by :py:class:`~.Options`
+
+    Examples
+    ========
+
+    >>> from sympy import exp, log, symbols, sfield
+
+    >>> x = symbols("x")
+    >>> K, f = sfield((x*log(x) + 4*x**2)*exp(1/x + log(x)/3)/x**2)
+    >>> K
+    Rational function field in x, exp(1/x), log(x), x**(1/3) over ZZ with lex order
+    >>> f
+    (4*x**2*(exp(1/x)) + x*(exp(1/x))*(log(x)))/((x**(1/3))**5)
+    """
+    single = False
+    if not is_sequence(exprs):
+        exprs, single = [exprs], True
+
+    exprs = list(map(sympify, exprs))
+    opt = build_options(symbols, options)
+    numdens = []
+    for expr in exprs:
+        numdens.extend(expr.as_numer_denom())
+    reps, opt = _parallel_dict_from_expr(numdens, opt)
+
+    if opt.domain is None:
+        # NOTE: this is inefficient because construct_domain() automatically
+        # performs conversion to the target domain. It shouldn't do this.
+        coeffs = sum([list(rep.values()) for rep in reps], [])
+        opt.domain, _ = construct_domain(coeffs, opt=opt)
+
+    _field = FracField(opt.gens, opt.domain, opt.order)
+    fracs = []
+    for i in range(0, len(reps), 2):
+        fracs.append(_field(tuple(reps[i:i+2])))
+
+    if single:
+        return (_field, fracs[0])
+    else:
+        return (_field, fracs)
+
+_field_cache: dict[Any, Any] = {}
+
+class FracField(DefaultPrinting):
+    """Multivariate distributed rational function field. """
+
+    def __new__(cls, symbols, domain, order=lex):
+        from sympy.polys.rings import PolyRing
+        ring = PolyRing(symbols, domain, order)
+        symbols = ring.symbols
+        ngens = ring.ngens
+        domain = ring.domain
+        order = ring.order
+
+        _hash_tuple = (cls.__name__, symbols, ngens, domain, order)
+        obj = _field_cache.get(_hash_tuple)
+
+        if obj is None:
+            obj = object.__new__(cls)
+            obj._hash_tuple = _hash_tuple
+            obj._hash = hash(_hash_tuple)
+            obj.ring = ring
+            obj.dtype = type("FracElement", (FracElement,), {"field": obj})
+            obj.symbols = symbols
+            obj.ngens = ngens
+            obj.domain = domain
+            obj.order = order
+
+            obj.zero = obj.dtype(ring.zero)
+            obj.one = obj.dtype(ring.one)
+
+            obj.gens = obj._gens()
+
+            for symbol, generator in zip(obj.symbols, obj.gens):
+                if isinstance(symbol, Symbol):
+                    name = symbol.name
+
+                    if not hasattr(obj, name):
+                        setattr(obj, name, generator)
+
+            _field_cache[_hash_tuple] = obj
+
+        return obj
+
+    def _gens(self):
+        """Return a list of polynomial generators. """
+        return tuple([ self.dtype(gen) for gen in self.ring.gens ])
+
+    def __getnewargs__(self):
+        return (self.symbols, self.domain, self.order)
+
+    def __hash__(self):
+        return self._hash
+
+    def index(self, gen):
+        if isinstance(gen, self.dtype):
+            return self.ring.index(gen.to_poly())
+        else:
+            raise ValueError("expected a %s, got %s instead" % (self.dtype,gen))
+
+    def __eq__(self, other):
+        return isinstance(other, FracField) and \
+            (self.symbols, self.ngens, self.domain, self.order) == \
+            (other.symbols, other.ngens, other.domain, other.order)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def raw_new(self, numer, denom=None):
+        return self.dtype(numer, denom)
+    def new(self, numer, denom=None):
+        if denom is None: denom = self.ring.one
+        numer, denom = numer.cancel(denom)
+        return self.raw_new(numer, denom)
+
+    def domain_new(self, element):
+        return self.domain.convert(element)
+
+    def ground_new(self, element):
+        try:
+            return self.new(self.ring.ground_new(element))
+        except CoercionFailed:
+            domain = self.domain
+
+            if not domain.is_Field and domain.has_assoc_Field:
+                ring = self.ring
+                ground_field = domain.get_field()
+                element = ground_field.convert(element)
+                numer = ring.ground_new(ground_field.numer(element))
+                denom = ring.ground_new(ground_field.denom(element))
+                return self.raw_new(numer, denom)
+            else:
+                raise
+
+    def field_new(self, element):
+        if isinstance(element, FracElement):
+            if self == element.field:
+                return element
+
+            if isinstance(self.domain, FractionField) and \
+                self.domain.field == element.field:
+                return self.ground_new(element)
+            elif isinstance(self.domain, PolynomialRing) and \
+                self.domain.ring.to_field() == element.field:
+                return self.ground_new(element)
+            else:
+                raise NotImplementedError("conversion")
+        elif isinstance(element, PolyElement):
+            denom, numer = element.clear_denoms()
+
+            if isinstance(self.domain, PolynomialRing) and \
+                numer.ring == self.domain.ring:
+                numer = self.ring.ground_new(numer)
+            elif isinstance(self.domain, FractionField) and \
+                numer.ring == self.domain.field.to_ring():
+                numer = self.ring.ground_new(numer)
+            else:
+                numer = numer.set_ring(self.ring)
+
+            denom = self.ring.ground_new(denom)
+            return self.raw_new(numer, denom)
+        elif isinstance(element, tuple) and len(element) == 2:
+            numer, denom = list(map(self.ring.ring_new, element))
+            return self.new(numer, denom)
+        elif isinstance(element, str):
+            raise NotImplementedError("parsing")
+        elif isinstance(element, Expr):
+            return self.from_expr(element)
+        else:
+            return self.ground_new(element)
+
+    __call__ = field_new
+
+    def _rebuild_expr(self, expr, mapping):
+        domain = self.domain
+        powers = tuple((gen, gen.as_base_exp()) for gen in mapping.keys()
+            if gen.is_Pow or isinstance(gen, ExpBase))
+
+        def _rebuild(expr):
+            generator = mapping.get(expr)
+
+            if generator is not None:
+                return generator
+            elif expr.is_Add:
+                return reduce(add, list(map(_rebuild, expr.args)))
+            elif expr.is_Mul:
+                return reduce(mul, list(map(_rebuild, expr.args)))
+            elif expr.is_Pow or isinstance(expr, (ExpBase, Exp1)):
+                b, e = expr.as_base_exp()
+                # look for bg**eg whose integer power may be b**e
+                for gen, (bg, eg) in powers:
+                    if bg == b and Mod(e, eg) == 0:
+                        return mapping.get(gen)**int(e/eg)
+                if e.is_Integer and e is not S.One:
+                    return _rebuild(b)**int(e)
+            elif mapping.get(1/expr) is not None:
+                return 1/mapping.get(1/expr)
+
+            try:
+                return domain.convert(expr)
+            except CoercionFailed:
+                if not domain.is_Field and domain.has_assoc_Field:
+                    return domain.get_field().convert(expr)
+                else:
+                    raise
+
+        return _rebuild(expr)
+
+    def from_expr(self, expr):
+        mapping = dict(list(zip(self.symbols, self.gens)))
+
+        try:
+            frac = self._rebuild_expr(sympify(expr), mapping)
+        except CoercionFailed:
+            raise ValueError("expected an expression convertible to a rational function in %s, got %s" % (self, expr))
+        else:
+            return self.field_new(frac)
+
+    def to_domain(self):
+        return FractionField(self)
+
+    def to_ring(self):
+        from sympy.polys.rings import PolyRing
+        return PolyRing(self.symbols, self.domain, self.order)
+
+class FracElement(DomainElement, DefaultPrinting, CantSympify):
+    """Element of multivariate distributed rational function field. """
+
+    def __init__(self, numer, denom=None):
+        if denom is None:
+            denom = self.field.ring.one
+        elif not denom:
+            raise ZeroDivisionError("zero denominator")
+
+        self.numer = numer
+        self.denom = denom
+
+    def raw_new(f, numer, denom):
+        return f.__class__(numer, denom)
+    def new(f, numer, denom):
+        return f.raw_new(*numer.cancel(denom))
+
+    def to_poly(f):
+        if f.denom != 1:
+            raise ValueError("f.denom should be 1")
+        return f.numer
+
+    def parent(self):
+        return self.field.to_domain()
+
+    def __getnewargs__(self):
+        return (self.field, self.numer, self.denom)
+
+    _hash = None
+
+    def __hash__(self):
+        _hash = self._hash
+        if _hash is None:
+            self._hash = _hash = hash((self.field, self.numer, self.denom))
+        return _hash
+
+    def copy(self):
+        return self.raw_new(self.numer.copy(), self.denom.copy())
+
+    def set_field(self, new_field):
+        if self.field == new_field:
+            return self
+        else:
+            new_ring = new_field.ring
+            numer = self.numer.set_ring(new_ring)
+            denom = self.denom.set_ring(new_ring)
+            return new_field.new(numer, denom)
+
+    def as_expr(self, *symbols):
+        return self.numer.as_expr(*symbols)/self.denom.as_expr(*symbols)
+
+    def __eq__(f, g):
+        if isinstance(g, FracElement) and f.field == g.field:
+            return f.numer == g.numer and f.denom == g.denom
+        else:
+            return f.numer == g and f.denom == f.field.ring.one
+
+    def __ne__(f, g):
+        return not f == g
+
+    def __bool__(f):
+        return bool(f.numer)
+
+    def sort_key(self):
+        return (self.denom.sort_key(), self.numer.sort_key())
+
+    def _cmp(f1, f2, op):
+        if isinstance(f2, f1.field.dtype):
+            return op(f1.sort_key(), f2.sort_key())
+        else:
+            return NotImplemented
+
+    def __lt__(f1, f2):
+        return f1._cmp(f2, lt)
+    def __le__(f1, f2):
+        return f1._cmp(f2, le)
+    def __gt__(f1, f2):
+        return f1._cmp(f2, gt)
+    def __ge__(f1, f2):
+        return f1._cmp(f2, ge)
+
+    def __pos__(f):
+        """Negate all coefficients in ``f``. """
+        return f.raw_new(f.numer, f.denom)
+
+    def __neg__(f):
+        """Negate all coefficients in ``f``. """
+        return f.raw_new(-f.numer, f.denom)
+
+    def _extract_ground(self, element):
+        domain = self.field.domain
+
+        try:
+            element = domain.convert(element)
+        except CoercionFailed:
+            if not domain.is_Field and domain.has_assoc_Field:
+                ground_field = domain.get_field()
+
+                try:
+                    element = ground_field.convert(element)
+                except CoercionFailed:
+                    pass
+                else:
+                    return -1, ground_field.numer(element), ground_field.denom(element)
+
+            return 0, None, None
+        else:
+            return 1, element, None
+
+    def __add__(f, g):
+        """Add rational functions ``f`` and ``g``. """
+        field = f.field
+
+        if not g:
+            return f
+        elif not f:
+            return g
+        elif isinstance(g, field.dtype):
+            if f.denom == g.denom:
+                return f.new(f.numer + g.numer, f.denom)
+            else:
+                return f.new(f.numer*g.denom + f.denom*g.numer, f.denom*g.denom)
+        elif isinstance(g, field.ring.dtype):
+            return f.new(f.numer + f.denom*g, f.denom)
+        else:
+            if isinstance(g, FracElement):
+                if isinstance(field.domain, FractionField) and field.domain.field == g.field:
+                    pass
+                elif isinstance(g.field.domain, FractionField) and g.field.domain.field == field:
+                    return g.__radd__(f)
+                else:
+                    return NotImplemented
+            elif isinstance(g, PolyElement):
+                if isinstance(field.domain, PolynomialRing) and field.domain.ring == g.ring:
+                    pass
+                else:
+                    return g.__radd__(f)
+
+        return f.__radd__(g)
+
+    def __radd__(f, c):
+        if isinstance(c, f.field.ring.dtype):
+            return f.new(f.numer + f.denom*c, f.denom)
+
+        op, g_numer, g_denom = f._extract_ground(c)
+
+        if op == 1:
+            return f.new(f.numer + f.denom*g_numer, f.denom)
+        elif not op:
+            return NotImplemented
+        else:
+            return f.new(f.numer*g_denom + f.denom*g_numer, f.denom*g_denom)
+
+    def __sub__(f, g):
+        """Subtract rational functions ``f`` and ``g``. """
+        field = f.field
+
+        if not g:
+            return f
+        elif not f:
+            return -g
+        elif isinstance(g, field.dtype):
+            if f.denom == g.denom:
+                return f.new(f.numer - g.numer, f.denom)
+            else:
+                return f.new(f.numer*g.denom - f.denom*g.numer, f.denom*g.denom)
+        elif isinstance(g, field.ring.dtype):
+            return f.new(f.numer - f.denom*g, f.denom)
+        else:
+            if isinstance(g, FracElement):
+                if isinstance(field.domain, FractionField) and field.domain.field == g.field:
+                    pass
+                elif isinstance(g.field.domain, FractionField) and g.field.domain.field == field:
+                    return g.__rsub__(f)
+                else:
+                    return NotImplemented
+            elif isinstance(g, PolyElement):
+                if isinstance(field.domain, PolynomialRing) and field.domain.ring == g.ring:
+                    pass
+                else:
+                    return g.__rsub__(f)
+
+        op, g_numer, g_denom = f._extract_ground(g)
+
+        if op == 1:
+            return f.new(f.numer - f.denom*g_numer, f.denom)
+        elif not op:
+            return NotImplemented
+        else:
+            return f.new(f.numer*g_denom - f.denom*g_numer, f.denom*g_denom)
+
+    def __rsub__(f, c):
+        if isinstance(c, f.field.ring.dtype):
+            return f.new(-f.numer + f.denom*c, f.denom)
+
+        op, g_numer, g_denom = f._extract_ground(c)
+
+        if op == 1:
+            return f.new(-f.numer + f.denom*g_numer, f.denom)
+        elif not op:
+            return NotImplemented
+        else:
+            return f.new(-f.numer*g_denom + f.denom*g_numer, f.denom*g_denom)
+
+    def __mul__(f, g):
+        """Multiply rational functions ``f`` and ``g``. """
+        field = f.field
+
+        if not f or not g:
+            return field.zero
+        elif isinstance(g, field.dtype):
+            return f.new(f.numer*g.numer, f.denom*g.denom)
+        elif isinstance(g, field.ring.dtype):
+            return f.new(f.numer*g, f.denom)
+        else:
+            if isinstance(g, FracElement):
+                if isinstance(field.domain, FractionField) and field.domain.field == g.field:
+                    pass
+                elif isinstance(g.field.domain, FractionField) and g.field.domain.field == field:
+                    return g.__rmul__(f)
+                else:
+                    return NotImplemented
+            elif isinstance(g, PolyElement):
+                if isinstance(field.domain, PolynomialRing) and field.domain.ring == g.ring:
+                    pass
+                else:
+                    return g.__rmul__(f)
+
+        return f.__rmul__(g)
+
+    def __rmul__(f, c):
+        if isinstance(c, f.field.ring.dtype):
+            return f.new(f.numer*c, f.denom)
+
+        op, g_numer, g_denom = f._extract_ground(c)
+
+        if op == 1:
+            return f.new(f.numer*g_numer, f.denom)
+        elif not op:
+            return NotImplemented
+        else:
+            return f.new(f.numer*g_numer, f.denom*g_denom)
+
+    def __truediv__(f, g):
+        """Computes quotient of fractions ``f`` and ``g``. """
+        field = f.field
+
+        if not g:
+            raise ZeroDivisionError
+        elif isinstance(g, field.dtype):
+            return f.new(f.numer*g.denom, f.denom*g.numer)
+        elif isinstance(g, field.ring.dtype):
+            return f.new(f.numer, f.denom*g)
+        else:
+            if isinstance(g, FracElement):
+                if isinstance(field.domain, FractionField) and field.domain.field == g.field:
+                    pass
+                elif isinstance(g.field.domain, FractionField) and g.field.domain.field == field:
+                    return g.__rtruediv__(f)
+                else:
+                    return NotImplemented
+            elif isinstance(g, PolyElement):
+                if isinstance(field.domain, PolynomialRing) and field.domain.ring == g.ring:
+                    pass
+                else:
+                    return g.__rtruediv__(f)
+
+        op, g_numer, g_denom = f._extract_ground(g)
+
+        if op == 1:
+            return f.new(f.numer, f.denom*g_numer)
+        elif not op:
+            return NotImplemented
+        else:
+            return f.new(f.numer*g_denom, f.denom*g_numer)
+
+    def __rtruediv__(f, c):
+        if not f:
+            raise ZeroDivisionError
+        elif isinstance(c, f.field.ring.dtype):
+            return f.new(f.denom*c, f.numer)
+
+        op, g_numer, g_denom = f._extract_ground(c)
+
+        if op == 1:
+            return f.new(f.denom*g_numer, f.numer)
+        elif not op:
+            return NotImplemented
+        else:
+            return f.new(f.denom*g_numer, f.numer*g_denom)
+
+    def __pow__(f, n):
+        """Raise ``f`` to a non-negative power ``n``. """
+        if n >= 0:
+            return f.raw_new(f.numer**n, f.denom**n)
+        elif not f:
+            raise ZeroDivisionError
+        else:
+            return f.raw_new(f.denom**-n, f.numer**-n)
+
+    def diff(f, x):
+        """Computes partial derivative in ``x``.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.fields import field
+        >>> from sympy.polys.domains import ZZ
+
+        >>> _, x, y, z = field("x,y,z", ZZ)
+        >>> ((x**2 + y)/(z + 1)).diff(x)
+        2*x/(z + 1)
+
+        """
+        x = x.to_poly()
+        return f.new(f.numer.diff(x)*f.denom - f.numer*f.denom.diff(x), f.denom**2)
+
+    def __call__(f, *values):
+        if 0 < len(values) <= f.field.ngens:
+            return f.evaluate(list(zip(f.field.gens, values)))
+        else:
+            raise ValueError("expected at least 1 and at most %s values, got %s" % (f.field.ngens, len(values)))
+
+    def evaluate(f, x, a=None):
+        if isinstance(x, list) and a is None:
+            x = [ (X.to_poly(), a) for X, a in x ]
+            numer, denom = f.numer.evaluate(x), f.denom.evaluate(x)
+        else:
+            x = x.to_poly()
+            numer, denom = f.numer.evaluate(x, a), f.denom.evaluate(x, a)
+
+        field = numer.ring.to_field()
+        return field.new(numer, denom)
+
+    def subs(f, x, a=None):
+        if isinstance(x, list) and a is None:
+            x = [ (X.to_poly(), a) for X, a in x ]
+            numer, denom = f.numer.subs(x), f.denom.subs(x)
+        else:
+            x = x.to_poly()
+            numer, denom = f.numer.subs(x, a), f.denom.subs(x, a)
+
+        return f.new(numer, denom)
+
+    def compose(f, x, a=None):
+        raise NotImplementedError

llmeval-env/lib/python3.10/site-packages/sympy/polys/galoistools.py

@@ -0,0 +1,2363 @@
+"""Dense univariate polynomials with coefficients in Galois fields. """
+
+from math import ceil as _ceil, sqrt as _sqrt, prod
+
+from sympy.core.random import uniform
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.polys.polyconfig import query
+from sympy.polys.polyerrors import ExactQuotientFailed
+from sympy.polys.polyutils import _sort_factors
+
+
+def gf_crt(U, M, K=None):
+    """
+    Chinese Remainder Theorem.
+
+    Given a set of integer residues ``u_0,...,u_n`` and a set of
+    co-prime integer moduli ``m_0,...,m_n``, returns an integer
+    ``u``, such that ``u = u_i mod m_i`` for ``i = ``0,...,n``.
+
+    Examples
+    ========
+
+    Consider a set of residues ``U = [49, 76, 65]``
+    and a set of moduli ``M = [99, 97, 95]``. Then we have::
+
+       >>> from sympy.polys.domains import ZZ
+       >>> from sympy.polys.galoistools import gf_crt
+
+       >>> gf_crt([49, 76, 65], [99, 97, 95], ZZ)
+       639985
+
+    This is the correct result because::
+
+       >>> [639985 % m for m in [99, 97, 95]]
+       [49, 76, 65]
+
+    Note: this is a low-level routine with no error checking.
+
+    See Also
+    ========
+
+    sympy.ntheory.modular.crt : a higher level crt routine
+    sympy.ntheory.modular.solve_congruence
+
+    """
+    p = prod(M, start=K.one)
+    v = K.zero
+
+    for u, m in zip(U, M):
+        e = p // m
+        s, _, _ = K.gcdex(e, m)
+        v += e*(u*s % m)
+
+    return v % p
+
+
+def gf_crt1(M, K):
+    """
+    First part of the Chinese Remainder Theorem.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_crt1
+
+    >>> gf_crt1([99, 97, 95], ZZ)
+    (912285, [9215, 9405, 9603], [62, 24, 12])
+
+    """
+    E, S = [], []
+    p = prod(M, start=K.one)
+
+    for m in M:
+        E.append(p // m)
+        S.append(K.gcdex(E[-1], m)[0] % m)
+
+    return p, E, S
+
+
+def gf_crt2(U, M, p, E, S, K):
+    """
+    Second part of the Chinese Remainder Theorem.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_crt2
+
+    >>> U = [49, 76, 65]
+    >>> M = [99, 97, 95]
+    >>> p = 912285
+    >>> E = [9215, 9405, 9603]
+    >>> S = [62, 24, 12]
+
+    >>> gf_crt2(U, M, p, E, S, ZZ)
+    639985
+
+    """
+    v = K.zero
+
+    for u, m, e, s in zip(U, M, E, S):
+        v += e*(u*s % m)
+
+    return v % p
+
+
+def gf_int(a, p):
+    """
+    Coerce ``a mod p`` to an integer in the range ``[-p/2, p/2]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import gf_int
+
+    >>> gf_int(2, 7)
+    2
+    >>> gf_int(5, 7)
+    -2
+
+    """
+    if a <= p // 2:
+        return a
+    else:
+        return a - p
+
+
+def gf_degree(f):
+    """
+    Return the leading degree of ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import gf_degree
+
+    >>> gf_degree([1, 1, 2, 0])
+    3
+    >>> gf_degree([])
+    -1
+
+    """
+    return len(f) - 1
+
+
+def gf_LC(f, K):
+    """
+    Return the leading coefficient of ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_LC
+
+    >>> gf_LC([3, 0, 1], ZZ)
+    3
+
+    """
+    if not f:
+        return K.zero
+    else:
+        return f[0]
+
+
+def gf_TC(f, K):
+    """
+    Return the trailing coefficient of ``f``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_TC
+
+    >>> gf_TC([3, 0, 1], ZZ)
+    1
+
+    """
+    if not f:
+        return K.zero
+    else:
+        return f[-1]
+
+
+def gf_strip(f):
+    """
+    Remove leading zeros from ``f``.
+
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import gf_strip
+
+    >>> gf_strip([0, 0, 0, 3, 0, 1])
+    [3, 0, 1]
+
+    """
+    if not f or f[0]:
+        return f
+
+    k = 0
+
+    for coeff in f:
+        if coeff:
+            break
+        else:
+            k += 1
+
+    return f[k:]
+
+
+def gf_trunc(f, p):
+    """
+    Reduce all coefficients modulo ``p``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import gf_trunc
+
+    >>> gf_trunc([7, -2, 3], 5)
+    [2, 3, 3]
+
+    """
+    return gf_strip([ a % p for a in f ])
+
+
+def gf_normal(f, p, K):
+    """
+    Normalize all coefficients in ``K``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_normal
+
+    >>> gf_normal([5, 10, 21, -3], 5, ZZ)
+    [1, 2]
+
+    """
+    return gf_trunc(list(map(K, f)), p)
+
+
+def gf_from_dict(f, p, K):
+    """
+    Create a ``GF(p)[x]`` polynomial from a dict.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_from_dict
+
+    >>> gf_from_dict({10: ZZ(4), 4: ZZ(33), 0: ZZ(-1)}, 5, ZZ)
+    [4, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4]
+
+    """
+    n, h = max(f.keys()), []
+
+    if isinstance(n, SYMPY_INTS):
+        for k in range(n, -1, -1):
+            h.append(f.get(k, K.zero) % p)
+    else:
+        (n,) = n
+
+        for k in range(n, -1, -1):
+            h.append(f.get((k,), K.zero) % p)
+
+    return gf_trunc(h, p)
+
+
+def gf_to_dict(f, p, symmetric=True):
+    """
+    Convert a ``GF(p)[x]`` polynomial to a dict.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import gf_to_dict
+
+    >>> gf_to_dict([4, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4], 5)
+    {0: -1, 4: -2, 10: -1}
+    >>> gf_to_dict([4, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4], 5, symmetric=False)
+    {0: 4, 4: 3, 10: 4}
+
+    """
+    n, result = gf_degree(f), {}
+
+    for k in range(0, n + 1):
+        if symmetric:
+            a = gf_int(f[n - k], p)
+        else:
+            a = f[n - k]
+
+        if a:
+            result[k] = a
+
+    return result
+
+
+def gf_from_int_poly(f, p):
+    """
+    Create a ``GF(p)[x]`` polynomial from ``Z[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import gf_from_int_poly
+
+    >>> gf_from_int_poly([7, -2, 3], 5)
+    [2, 3, 3]
+
+    """
+    return gf_trunc(f, p)
+
+
+def gf_to_int_poly(f, p, symmetric=True):
+    """
+    Convert a ``GF(p)[x]`` polynomial to ``Z[x]``.
+
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import gf_to_int_poly
+
+    >>> gf_to_int_poly([2, 3, 3], 5)
+    [2, -2, -2]
+    >>> gf_to_int_poly([2, 3, 3], 5, symmetric=False)
+    [2, 3, 3]
+
+    """
+    if symmetric:
+        return [ gf_int(c, p) for c in f ]
+    else:
+        return f
+
+
+def gf_neg(f, p, K):
+    """
+    Negate a polynomial in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_neg
+
+    >>> gf_neg([3, 2, 1, 0], 5, ZZ)
+    [2, 3, 4, 0]
+
+    """
+    return [ -coeff % p for coeff in f ]
+
+
+def gf_add_ground(f, a, p, K):
+    """
+    Compute ``f + a`` where ``f`` in ``GF(p)[x]`` and ``a`` in ``GF(p)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_add_ground
+
+    >>> gf_add_ground([3, 2, 4], 2, 5, ZZ)
+    [3, 2, 1]
+
+    """
+    if not f:
+        a = a % p
+    else:
+        a = (f[-1] + a) % p
+
+        if len(f) > 1:
+            return f[:-1] + [a]
+
+    if not a:
+        return []
+    else:
+        return [a]
+
+
+def gf_sub_ground(f, a, p, K):
+    """
+    Compute ``f - a`` where ``f`` in ``GF(p)[x]`` and ``a`` in ``GF(p)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_sub_ground
+
+    >>> gf_sub_ground([3, 2, 4], 2, 5, ZZ)
+    [3, 2, 2]
+
+    """
+    if not f:
+        a = -a % p
+    else:
+        a = (f[-1] - a) % p
+
+        if len(f) > 1:
+            return f[:-1] + [a]
+
+    if not a:
+        return []
+    else:
+        return [a]
+
+
+def gf_mul_ground(f, a, p, K):
+    """
+    Compute ``f * a`` where ``f`` in ``GF(p)[x]`` and ``a`` in ``GF(p)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_mul_ground
+
+    >>> gf_mul_ground([3, 2, 4], 2, 5, ZZ)
+    [1, 4, 3]
+
+    """
+    if not a:
+        return []
+    else:
+        return [ (a*b) % p for b in f ]
+
+
+def gf_quo_ground(f, a, p, K):
+    """
+    Compute ``f/a`` where ``f`` in ``GF(p)[x]`` and ``a`` in ``GF(p)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_quo_ground
+
+    >>> gf_quo_ground(ZZ.map([3, 2, 4]), ZZ(2), 5, ZZ)
+    [4, 1, 2]
+
+    """
+    return gf_mul_ground(f, K.invert(a, p), p, K)
+
+
+def gf_add(f, g, p, K):
+    """
+    Add polynomials in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_add
+
+    >>> gf_add([3, 2, 4], [2, 2, 2], 5, ZZ)
+    [4, 1]
+
+    """
+    if not f:
+        return g
+    if not g:
+        return f
+
+    df = gf_degree(f)
+    dg = gf_degree(g)
+
+    if df == dg:
+        return gf_strip([ (a + b) % p for a, b in zip(f, g) ])
+    else:
+        k = abs(df - dg)
+
+        if df > dg:
+            h, f = f[:k], f[k:]
+        else:
+            h, g = g[:k], g[k:]
+
+        return h + [ (a + b) % p for a, b in zip(f, g) ]
+
+
+def gf_sub(f, g, p, K):
+    """
+    Subtract polynomials in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_sub
+
+    >>> gf_sub([3, 2, 4], [2, 2, 2], 5, ZZ)
+    [1, 0, 2]
+
+    """
+    if not g:
+        return f
+    if not f:
+        return gf_neg(g, p, K)
+
+    df = gf_degree(f)
+    dg = gf_degree(g)
+
+    if df == dg:
+        return gf_strip([ (a - b) % p for a, b in zip(f, g) ])
+    else:
+        k = abs(df - dg)
+
+        if df > dg:
+            h, f = f[:k], f[k:]
+        else:
+            h, g = gf_neg(g[:k], p, K), g[k:]
+
+        return h + [ (a - b) % p for a, b in zip(f, g) ]
+
+
+def gf_mul(f, g, p, K):
+    """
+    Multiply polynomials in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_mul
+
+    >>> gf_mul([3, 2, 4], [2, 2, 2], 5, ZZ)
+    [1, 0, 3, 2, 3]
+
+    """
+    df = gf_degree(f)
+    dg = gf_degree(g)
+
+    dh = df + dg
+    h = [0]*(dh + 1)
+
+    for i in range(0, dh + 1):
+        coeff = K.zero
+
+        for j in range(max(0, i - dg), min(i, df) + 1):
+            coeff += f[j]*g[i - j]
+
+        h[i] = coeff % p
+
+    return gf_strip(h)
+
+
+def gf_sqr(f, p, K):
+    """
+    Square polynomials in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_sqr
+
+    >>> gf_sqr([3, 2, 4], 5, ZZ)
+    [4, 2, 3, 1, 1]
+
+    """
+    df = gf_degree(f)
+
+    dh = 2*df
+    h = [0]*(dh + 1)
+
+    for i in range(0, dh + 1):
+        coeff = K.zero
+
+        jmin = max(0, i - df)
+        jmax = min(i, df)
+
+        n = jmax - jmin + 1
+
+        jmax = jmin + n // 2 - 1
+
+        for j in range(jmin, jmax + 1):
+            coeff += f[j]*f[i - j]
+
+        coeff += coeff
+
+        if n & 1:
+            elem = f[jmax + 1]
+            coeff += elem**2
+
+        h[i] = coeff % p
+
+    return gf_strip(h)
+
+
+def gf_add_mul(f, g, h, p, K):
+    """
+    Returns ``f + g*h`` where ``f``, ``g``, ``h`` in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_add_mul
+    >>> gf_add_mul([3, 2, 4], [2, 2, 2], [1, 4], 5, ZZ)
+    [2, 3, 2, 2]
+    """
+    return gf_add(f, gf_mul(g, h, p, K), p, K)
+
+
+def gf_sub_mul(f, g, h, p, K):
+    """
+    Compute ``f - g*h`` where ``f``, ``g``, ``h`` in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_sub_mul
+
+    >>> gf_sub_mul([3, 2, 4], [2, 2, 2], [1, 4], 5, ZZ)
+    [3, 3, 2, 1]
+
+    """
+    return gf_sub(f, gf_mul(g, h, p, K), p, K)
+
+
+def gf_expand(F, p, K):
+    """
+    Expand results of :func:`~.factor` in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_expand
+
+    >>> gf_expand([([3, 2, 4], 1), ([2, 2], 2), ([3, 1], 3)], 5, ZZ)
+    [4, 3, 0, 3, 0, 1, 4, 1]
+
+    """
+    if isinstance(F, tuple):
+        lc, F = F
+    else:
+        lc = K.one
+
+    g = [lc]
+
+    for f, k in F:
+        f = gf_pow(f, k, p, K)
+        g = gf_mul(g, f, p, K)
+
+    return g
+
+
+def gf_div(f, g, p, K):
+    """
+    Division with remainder in ``GF(p)[x]``.
+
+    Given univariate polynomials ``f`` and ``g`` with coefficients in a
+    finite field with ``p`` elements, returns polynomials ``q`` and ``r``
+    (quotient and remainder) such that ``f = q*g + r``.
+
+    Consider polynomials ``x**3 + x + 1`` and ``x**2 + x`` in GF(2)::
+
+       >>> from sympy.polys.domains import ZZ
+       >>> from sympy.polys.galoistools import gf_div, gf_add_mul
+
+       >>> gf_div(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ)
+       ([1, 1], [1])
+
+    As result we obtained quotient ``x + 1`` and remainder ``1``, thus::
+
+       >>> gf_add_mul(ZZ.map([1]), ZZ.map([1, 1]), ZZ.map([1, 1, 0]), 2, ZZ)
+       [1, 0, 1, 1]
+
+    References
+    ==========
+
+    .. [1] [Monagan93]_
+    .. [2] [Gathen99]_
+
+    """
+    df = gf_degree(f)
+    dg = gf_degree(g)
+
+    if not g:
+        raise ZeroDivisionError("polynomial division")
+    elif df < dg:
+        return [], f
+
+    inv = K.invert(g[0], p)
+
+    h, dq, dr = list(f), df - dg, dg - 1
+
+    for i in range(0, df + 1):
+        coeff = h[i]
+
+        for j in range(max(0, dg - i), min(df - i, dr) + 1):
+            coeff -= h[i + j - dg] * g[dg - j]
+
+        if i <= dq:
+            coeff *= inv
+
+        h[i] = coeff % p
+
+    return h[:dq + 1], gf_strip(h[dq + 1:])
+
+
+def gf_rem(f, g, p, K):
+    """
+    Compute polynomial remainder in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_rem
+
+    >>> gf_rem(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ)
+    [1]
+
+    """
+    return gf_div(f, g, p, K)[1]
+
+
+def gf_quo(f, g, p, K):
+    """
+    Compute exact quotient in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_quo
+
+    >>> gf_quo(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ)
+    [1, 1]
+    >>> gf_quo(ZZ.map([1, 0, 3, 2, 3]), ZZ.map([2, 2, 2]), 5, ZZ)
+    [3, 2, 4]
+
+    """
+    df = gf_degree(f)
+    dg = gf_degree(g)
+
+    if not g:
+        raise ZeroDivisionError("polynomial division")
+    elif df < dg:
+        return []
+
+    inv = K.invert(g[0], p)
+
+    h, dq, dr = f[:], df - dg, dg - 1
+
+    for i in range(0, dq + 1):
+        coeff = h[i]
+
+        for j in range(max(0, dg - i), min(df - i, dr) + 1):
+            coeff -= h[i + j - dg] * g[dg - j]
+
+        h[i] = (coeff * inv) % p
+
+    return h[:dq + 1]
+
+
+def gf_exquo(f, g, p, K):
+    """
+    Compute polynomial quotient in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_exquo
+
+    >>> gf_exquo(ZZ.map([1, 0, 3, 2, 3]), ZZ.map([2, 2, 2]), 5, ZZ)
+    [3, 2, 4]
+
+    >>> gf_exquo(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ)
+    Traceback (most recent call last):
+    ...
+    ExactQuotientFailed: [1, 1, 0] does not divide [1, 0, 1, 1]
+
+    """
+    q, r = gf_div(f, g, p, K)
+
+    if not r:
+        return q
+    else:
+        raise ExactQuotientFailed(f, g)
+
+
+def gf_lshift(f, n, K):
+    """
+    Efficiently multiply ``f`` by ``x**n``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_lshift
+
+    >>> gf_lshift([3, 2, 4], 4, ZZ)
+    [3, 2, 4, 0, 0, 0, 0]
+
+    """
+    if not f:
+        return f
+    else:
+        return f + [K.zero]*n
+
+
+def gf_rshift(f, n, K):
+    """
+    Efficiently divide ``f`` by ``x**n``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_rshift
+
+    >>> gf_rshift([1, 2, 3, 4, 0], 3, ZZ)
+    ([1, 2], [3, 4, 0])
+
+    """
+    if not n:
+        return f, []
+    else:
+        return f[:-n], f[-n:]
+
+
+def gf_pow(f, n, p, K):
+    """
+    Compute ``f**n`` in ``GF(p)[x]`` using repeated squaring.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_pow
+
+    >>> gf_pow([3, 2, 4], 3, 5, ZZ)
+    [2, 4, 4, 2, 2, 1, 4]
+
+    """
+    if not n:
+        return [K.one]
+    elif n == 1:
+        return f
+    elif n == 2:
+        return gf_sqr(f, p, K)
+
+    h = [K.one]
+
+    while True:
+        if n & 1:
+            h = gf_mul(h, f, p, K)
+            n -= 1
+
+        n >>= 1
+
+        if not n:
+            break
+
+        f = gf_sqr(f, p, K)
+
+    return h
+
+def gf_frobenius_monomial_base(g, p, K):
+    """
+    return the list of ``x**(i*p) mod g in Z_p`` for ``i = 0, .., n - 1``
+    where ``n = gf_degree(g)``
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_frobenius_monomial_base
+    >>> g = ZZ.map([1, 0, 2, 1])
+    >>> gf_frobenius_monomial_base(g, 5, ZZ)
+    [[1], [4, 4, 2], [1, 2]]
+
+    """
+    n = gf_degree(g)
+    if n == 0:
+        return []
+    b = [0]*n
+    b[0] = [1]
+    if p < n:
+        for i in range(1, n):
+            mon = gf_lshift(b[i - 1], p, K)
+            b[i] = gf_rem(mon, g, p, K)
+    elif n > 1:
+        b[1] = gf_pow_mod([K.one, K.zero], p, g, p, K)
+        for i in range(2, n):
+            b[i] = gf_mul(b[i - 1], b[1], p, K)
+            b[i] = gf_rem(b[i], g, p, K)
+
+    return b
+
+def gf_frobenius_map(f, g, b, p, K):
+    """
+    compute gf_pow_mod(f, p, g, p, K) using the Frobenius map
+
+    Parameters
+    ==========
+
+    f, g : polynomials in ``GF(p)[x]``
+    b : frobenius monomial base
+    p : prime number
+    K : domain
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_frobenius_monomial_base, gf_frobenius_map
+    >>> f = ZZ.map([2, 1, 0, 1])
+    >>> g = ZZ.map([1, 0, 2, 1])
+    >>> p = 5
+    >>> b = gf_frobenius_monomial_base(g, p, ZZ)
+    >>> r = gf_frobenius_map(f, g, b, p, ZZ)
+    >>> gf_frobenius_map(f, g, b, p, ZZ)
+    [4, 0, 3]
+    """
+    m = gf_degree(g)
+    if gf_degree(f) >= m:
+        f = gf_rem(f, g, p, K)
+    if not f:
+        return []
+    n = gf_degree(f)
+    sf = [f[-1]]
+    for i in range(1, n + 1):
+        v = gf_mul_ground(b[i], f[n - i], p, K)
+        sf = gf_add(sf, v, p, K)
+    return sf
+
+def _gf_pow_pnm1d2(f, n, g, b, p, K):
+    """
+    utility function for ``gf_edf_zassenhaus``
+    Compute ``f**((p**n - 1) // 2)`` in ``GF(p)[x]/(g)``
+    ``f**((p**n - 1) // 2) = (f*f**p*...*f**(p**n - 1))**((p - 1) // 2)``
+    """
+    f = gf_rem(f, g, p, K)
+    h = f
+    r = f
+    for i in range(1, n):
+        h = gf_frobenius_map(h, g, b, p, K)
+        r = gf_mul(r, h, p, K)
+        r = gf_rem(r, g, p, K)
+
+    res = gf_pow_mod(r, (p - 1)//2, g, p, K)
+    return res
+
+def gf_pow_mod(f, n, g, p, K):
+    """
+    Compute ``f**n`` in ``GF(p)[x]/(g)`` using repeated squaring.
+
+    Given polynomials ``f`` and ``g`` in ``GF(p)[x]`` and a non-negative
+    integer ``n``, efficiently computes ``f**n (mod g)`` i.e. the remainder
+    of ``f**n`` from division by ``g``, using the repeated squaring algorithm.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_pow_mod
+
+    >>> gf_pow_mod(ZZ.map([3, 2, 4]), 3, ZZ.map([1, 1]), 5, ZZ)
+    []
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+
+    """
+    if not n:
+        return [K.one]
+    elif n == 1:
+        return gf_rem(f, g, p, K)
+    elif n == 2:
+        return gf_rem(gf_sqr(f, p, K), g, p, K)
+
+    h = [K.one]
+
+    while True:
+        if n & 1:
+            h = gf_mul(h, f, p, K)
+            h = gf_rem(h, g, p, K)
+            n -= 1
+
+        n >>= 1
+
+        if not n:
+            break
+
+        f = gf_sqr(f, p, K)
+        f = gf_rem(f, g, p, K)
+
+    return h
+
+
+def gf_gcd(f, g, p, K):
+    """
+    Euclidean Algorithm in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_gcd
+
+    >>> gf_gcd(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 3]), 5, ZZ)
+    [1, 3]
+
+    """
+    while g:
+        f, g = g, gf_rem(f, g, p, K)
+
+    return gf_monic(f, p, K)[1]
+
+
+def gf_lcm(f, g, p, K):
+    """
+    Compute polynomial LCM in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_lcm
+
+    >>> gf_lcm(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 3]), 5, ZZ)
+    [1, 2, 0, 4]
+
+    """
+    if not f or not g:
+        return []
+
+    h = gf_quo(gf_mul(f, g, p, K),
+               gf_gcd(f, g, p, K), p, K)
+
+    return gf_monic(h, p, K)[1]
+
+
+def gf_cofactors(f, g, p, K):
+    """
+    Compute polynomial GCD and cofactors in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_cofactors
+
+    >>> gf_cofactors(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 3]), 5, ZZ)
+    ([1, 3], [3, 3], [2, 1])
+
+    """
+    if not f and not g:
+        return ([], [], [])
+
+    h = gf_gcd(f, g, p, K)
+
+    return (h, gf_quo(f, h, p, K),
+            gf_quo(g, h, p, K))
+
+
+def gf_gcdex(f, g, p, K):
+    """
+    Extended Euclidean Algorithm in ``GF(p)[x]``.
+
+    Given polynomials ``f`` and ``g`` in ``GF(p)[x]``, computes polynomials
+    ``s``, ``t`` and ``h``, such that ``h = gcd(f, g)`` and ``s*f + t*g = h``.
+    The typical application of EEA is solving polynomial diophantine equations.
+
+    Consider polynomials ``f = (x + 7) (x + 1)``, ``g = (x + 7) (x**2 + 1)``
+    in ``GF(11)[x]``. Application of Extended Euclidean Algorithm gives::
+
+       >>> from sympy.polys.domains import ZZ
+       >>> from sympy.polys.galoistools import gf_gcdex, gf_mul, gf_add
+
+       >>> s, t, g = gf_gcdex(ZZ.map([1, 8, 7]), ZZ.map([1, 7, 1, 7]), 11, ZZ)
+       >>> s, t, g
+       ([5, 6], [6], [1, 7])
+
+    As result we obtained polynomials ``s = 5*x + 6`` and ``t = 6``, and
+    additionally ``gcd(f, g) = x + 7``. This is correct because::
+
+       >>> S = gf_mul(s, ZZ.map([1, 8, 7]), 11, ZZ)
+       >>> T = gf_mul(t, ZZ.map([1, 7, 1, 7]), 11, ZZ)
+
+       >>> gf_add(S, T, 11, ZZ) == [1, 7]
+       True
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+
+    """
+    if not (f or g):
+        return [K.one], [], []
+
+    p0, r0 = gf_monic(f, p, K)
+    p1, r1 = gf_monic(g, p, K)
+
+    if not f:
+        return [], [K.invert(p1, p)], r1
+    if not g:
+        return [K.invert(p0, p)], [], r0
+
+    s0, s1 = [K.invert(p0, p)], []
+    t0, t1 = [], [K.invert(p1, p)]
+
+    while True:
+        Q, R = gf_div(r0, r1, p, K)
+
+        if not R:
+            break
+
+        (lc, r1), r0 = gf_monic(R, p, K), r1
+
+        inv = K.invert(lc, p)
+
+        s = gf_sub_mul(s0, s1, Q, p, K)
+        t = gf_sub_mul(t0, t1, Q, p, K)
+
+        s1, s0 = gf_mul_ground(s, inv, p, K), s1
+        t1, t0 = gf_mul_ground(t, inv, p, K), t1
+
+    return s1, t1, r1
+
+
+def gf_monic(f, p, K):
+    """
+    Compute LC and a monic polynomial in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_monic
+
+    >>> gf_monic(ZZ.map([3, 2, 4]), 5, ZZ)
+    (3, [1, 4, 3])
+
+    """
+    if not f:
+        return K.zero, []
+    else:
+        lc = f[0]
+
+        if K.is_one(lc):
+            return lc, list(f)
+        else:
+            return lc, gf_quo_ground(f, lc, p, K)
+
+
+def gf_diff(f, p, K):
+    """
+    Differentiate polynomial in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_diff
+
+    >>> gf_diff([3, 2, 4], 5, ZZ)
+    [1, 2]
+
+    """
+    df = gf_degree(f)
+
+    h, n = [K.zero]*df, df
+
+    for coeff in f[:-1]:
+        coeff *= K(n)
+        coeff %= p
+
+        if coeff:
+            h[df - n] = coeff
+
+        n -= 1
+
+    return gf_strip(h)
+
+
+def gf_eval(f, a, p, K):
+    """
+    Evaluate ``f(a)`` in ``GF(p)`` using Horner scheme.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_eval
+
+    >>> gf_eval([3, 2, 4], 2, 5, ZZ)
+    0
+
+    """
+    result = K.zero
+
+    for c in f:
+        result *= a
+        result += c
+        result %= p
+
+    return result
+
+
+def gf_multi_eval(f, A, p, K):
+    """
+    Evaluate ``f(a)`` for ``a`` in ``[a_1, ..., a_n]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_multi_eval
+
+    >>> gf_multi_eval([3, 2, 4], [0, 1, 2, 3, 4], 5, ZZ)
+    [4, 4, 0, 2, 0]
+
+    """
+    return [ gf_eval(f, a, p, K) for a in A ]
+
+
+def gf_compose(f, g, p, K):
+    """
+    Compute polynomial composition ``f(g)`` in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_compose
+
+    >>> gf_compose([3, 2, 4], [2, 2, 2], 5, ZZ)
+    [2, 4, 0, 3, 0]
+
+    """
+    if len(g) <= 1:
+        return gf_strip([gf_eval(f, gf_LC(g, K), p, K)])
+
+    if not f:
+        return []
+
+    h = [f[0]]
+
+    for c in f[1:]:
+        h = gf_mul(h, g, p, K)
+        h = gf_add_ground(h, c, p, K)
+
+    return h
+
+
+def gf_compose_mod(g, h, f, p, K):
+    """
+    Compute polynomial composition ``g(h)`` in ``GF(p)[x]/(f)``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_compose_mod
+
+    >>> gf_compose_mod(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 2]), ZZ.map([4, 3]), 5, ZZ)
+    [4]
+
+    """
+    if not g:
+        return []
+
+    comp = [g[0]]
+
+    for a in g[1:]:
+        comp = gf_mul(comp, h, p, K)
+        comp = gf_add_ground(comp, a, p, K)
+        comp = gf_rem(comp, f, p, K)
+
+    return comp
+
+
+def gf_trace_map(a, b, c, n, f, p, K):
+    """
+    Compute polynomial trace map in ``GF(p)[x]/(f)``.
+
+    Given a polynomial ``f`` in ``GF(p)[x]``, polynomials ``a``, ``b``,
+    ``c`` in the quotient ring ``GF(p)[x]/(f)`` such that ``b = c**t
+    (mod f)`` for some positive power ``t`` of ``p``, and a positive
+    integer ``n``, returns a mapping::
+
+       a -> a**t**n, a + a**t + a**t**2 + ... + a**t**n (mod f)
+
+    In factorization context, ``b = x**p mod f`` and ``c = x mod f``.
+    This way we can efficiently compute trace polynomials in equal
+    degree factorization routine, much faster than with other methods,
+    like iterated Frobenius algorithm, for large degrees.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_trace_map
+
+    >>> gf_trace_map([1, 2], [4, 4], [1, 1], 4, [3, 2, 4], 5, ZZ)
+    ([1, 3], [1, 3])
+
+    References
+    ==========
+
+    .. [1] [Gathen92]_
+
+    """
+    u = gf_compose_mod(a, b, f, p, K)
+    v = b
+
+    if n & 1:
+        U = gf_add(a, u, p, K)
+        V = b
+    else:
+        U = a
+        V = c
+
+    n >>= 1
+
+    while n:
+        u = gf_add(u, gf_compose_mod(u, v, f, p, K), p, K)
+        v = gf_compose_mod(v, v, f, p, K)
+
+        if n & 1:
+            U = gf_add(U, gf_compose_mod(u, V, f, p, K), p, K)
+            V = gf_compose_mod(v, V, f, p, K)
+
+        n >>= 1
+
+    return gf_compose_mod(a, V, f, p, K), U
+
+def _gf_trace_map(f, n, g, b, p, K):
+    """
+    utility for ``gf_edf_shoup``
+    """
+    f = gf_rem(f, g, p, K)
+    h = f
+    r = f
+    for i in range(1, n):
+        h = gf_frobenius_map(h, g, b, p, K)
+        r = gf_add(r, h, p, K)
+        r = gf_rem(r, g, p, K)
+    return r
+
+
+def gf_random(n, p, K):
+    """
+    Generate a random polynomial in ``GF(p)[x]`` of degree ``n``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_random
+    >>> gf_random(10, 5, ZZ) #doctest: +SKIP
+    [1, 2, 3, 2, 1, 1, 1, 2, 0, 4, 2]
+
+    """
+    return [K.one] + [ K(int(uniform(0, p))) for i in range(0, n) ]
+
+
+def gf_irreducible(n, p, K):
+    """
+    Generate random irreducible polynomial of degree ``n`` in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_irreducible
+    >>> gf_irreducible(10, 5, ZZ) #doctest: +SKIP
+    [1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]
+
+    """
+    while True:
+        f = gf_random(n, p, K)
+        if gf_irreducible_p(f, p, K):
+            return f
+
+
+def gf_irred_p_ben_or(f, p, K):
+    """
+    Ben-Or's polynomial irreducibility test over finite fields.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_irred_p_ben_or
+
+    >>> gf_irred_p_ben_or(ZZ.map([1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]), 5, ZZ)
+    True
+    >>> gf_irred_p_ben_or(ZZ.map([3, 2, 4]), 5, ZZ)
+    False
+
+    """
+    n = gf_degree(f)
+
+    if n <= 1:
+        return True
+
+    _, f = gf_monic(f, p, K)
+    if n < 5:
+        H = h = gf_pow_mod([K.one, K.zero], p, f, p, K)
+
+        for i in range(0, n//2):
+            g = gf_sub(h, [K.one, K.zero], p, K)
+
+            if gf_gcd(f, g, p, K) == [K.one]:
+                h = gf_compose_mod(h, H, f, p, K)
+            else:
+                return False
+    else:
+        b = gf_frobenius_monomial_base(f, p, K)
+        H = h = gf_frobenius_map([K.one, K.zero], f, b, p, K)
+        for i in range(0, n//2):
+            g = gf_sub(h, [K.one, K.zero], p, K)
+            if gf_gcd(f, g, p, K) == [K.one]:
+                h = gf_frobenius_map(h, f, b, p, K)
+            else:
+                return False
+
+    return True
+
+
+def gf_irred_p_rabin(f, p, K):
+    """
+    Rabin's polynomial irreducibility test over finite fields.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_irred_p_rabin
+
+    >>> gf_irred_p_rabin(ZZ.map([1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]), 5, ZZ)
+    True
+    >>> gf_irred_p_rabin(ZZ.map([3, 2, 4]), 5, ZZ)
+    False
+
+    """
+    n = gf_degree(f)
+
+    if n <= 1:
+        return True
+
+    _, f = gf_monic(f, p, K)
+
+    x = [K.one, K.zero]
+
+    from sympy.ntheory import factorint
+
+    indices = { n//d for d in factorint(n) }
+
+    b = gf_frobenius_monomial_base(f, p, K)
+    h = b[1]
+
+    for i in range(1, n):
+        if i in indices:
+            g = gf_sub(h, x, p, K)
+
+            if gf_gcd(f, g, p, K) != [K.one]:
+                return False
+
+        h = gf_frobenius_map(h, f, b, p, K)
+
+    return h == x
+
+_irred_methods = {
+    'ben-or': gf_irred_p_ben_or,
+    'rabin': gf_irred_p_rabin,
+}
+
+
+def gf_irreducible_p(f, p, K):
+    """
+    Test irreducibility of a polynomial ``f`` in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_irreducible_p
+
+    >>> gf_irreducible_p(ZZ.map([1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]), 5, ZZ)
+    True
+    >>> gf_irreducible_p(ZZ.map([3, 2, 4]), 5, ZZ)
+    False
+
+    """
+    method = query('GF_IRRED_METHOD')
+
+    if method is not None:
+        irred = _irred_methods[method](f, p, K)
+    else:
+        irred = gf_irred_p_rabin(f, p, K)
+
+    return irred
+
+
+def gf_sqf_p(f, p, K):
+    """
+    Return ``True`` if ``f`` is square-free in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_sqf_p
+
+    >>> gf_sqf_p(ZZ.map([3, 2, 4]), 5, ZZ)
+    True
+    >>> gf_sqf_p(ZZ.map([2, 4, 4, 2, 2, 1, 4]), 5, ZZ)
+    False
+
+    """
+    _, f = gf_monic(f, p, K)
+
+    if not f:
+        return True
+    else:
+        return gf_gcd(f, gf_diff(f, p, K), p, K) == [K.one]
+
+
+def gf_sqf_part(f, p, K):
+    """
+    Return square-free part of a ``GF(p)[x]`` polynomial.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_sqf_part
+
+    >>> gf_sqf_part(ZZ.map([1, 1, 3, 0, 1, 0, 2, 2, 1]), 5, ZZ)
+    [1, 4, 3]
+
+    """
+    _, sqf = gf_sqf_list(f, p, K)
+
+    g = [K.one]
+
+    for f, _ in sqf:
+        g = gf_mul(g, f, p, K)
+
+    return g
+
+
+def gf_sqf_list(f, p, K, all=False):
+    """
+    Return the square-free decomposition of a ``GF(p)[x]`` polynomial.
+
+    Given a polynomial ``f`` in ``GF(p)[x]``, returns the leading coefficient
+    of ``f`` and a square-free decomposition ``f_1**e_1 f_2**e_2 ... f_k**e_k``
+    such that all ``f_i`` are monic polynomials and ``(f_i, f_j)`` for ``i != j``
+    are co-prime and ``e_1 ... e_k`` are given in increasing order. All trivial
+    terms (i.e. ``f_i = 1``) are not included in the output.
+
+    Consider polynomial ``f = x**11 + 1`` over ``GF(11)[x]``::
+
+       >>> from sympy.polys.domains import ZZ
+
+       >>> from sympy.polys.galoistools import (
+       ...     gf_from_dict, gf_diff, gf_sqf_list, gf_pow,
+       ... )
+       ... # doctest: +NORMALIZE_WHITESPACE
+
+       >>> f = gf_from_dict({11: ZZ(1), 0: ZZ(1)}, 11, ZZ)
+
+    Note that ``f'(x) = 0``::
+
+       >>> gf_diff(f, 11, ZZ)
+       []
+
+    This phenomenon does not happen in characteristic zero. However we can
+    still compute square-free decomposition of ``f`` using ``gf_sqf()``::
+
+       >>> gf_sqf_list(f, 11, ZZ)
+       (1, [([1, 1], 11)])
+
+    We obtained factorization ``f = (x + 1)**11``. This is correct because::
+
+       >>> gf_pow([1, 1], 11, 11, ZZ) == f
+       True
+
+    References
+    ==========
+
+    .. [1] [Geddes92]_
+
+    """
+    n, sqf, factors, r = 1, False, [], int(p)
+
+    lc, f = gf_monic(f, p, K)
+
+    if gf_degree(f) < 1:
+        return lc, []
+
+    while True:
+        F = gf_diff(f, p, K)
+
+        if F != []:
+            g = gf_gcd(f, F, p, K)
+            h = gf_quo(f, g, p, K)
+
+            i = 1
+
+            while h != [K.one]:
+                G = gf_gcd(g, h, p, K)
+                H = gf_quo(h, G, p, K)
+
+                if gf_degree(H) > 0:
+                    factors.append((H, i*n))
+
+                g, h, i = gf_quo(g, G, p, K), G, i + 1
+
+            if g == [K.one]:
+                sqf = True
+            else:
+                f = g
+
+        if not sqf:
+            d = gf_degree(f) // r
+
+            for i in range(0, d + 1):
+                f[i] = f[i*r]
+
+            f, n = f[:d + 1], n*r
+        else:
+            break
+
+    if all:
+        raise ValueError("'all=True' is not supported yet")
+
+    return lc, factors
+
+
+def gf_Qmatrix(f, p, K):
+    """
+    Calculate Berlekamp's ``Q`` matrix.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_Qmatrix
+
+    >>> gf_Qmatrix([3, 2, 4], 5, ZZ)
+    [[1, 0],
+     [3, 4]]
+
+    >>> gf_Qmatrix([1, 0, 0, 0, 1], 5, ZZ)
+    [[1, 0, 0, 0],
+     [0, 4, 0, 0],
+     [0, 0, 1, 0],
+     [0, 0, 0, 4]]
+
+    """
+    n, r = gf_degree(f), int(p)
+
+    q = [K.one] + [K.zero]*(n - 1)
+    Q = [list(q)] + [[]]*(n - 1)
+
+    for i in range(1, (n - 1)*r + 1):
+        qq, c = [(-q[-1]*f[-1]) % p], q[-1]
+
+        for j in range(1, n):
+            qq.append((q[j - 1] - c*f[-j - 1]) % p)
+
+        if not (i % r):
+            Q[i//r] = list(qq)
+
+        q = qq
+
+    return Q
+
+
+def gf_Qbasis(Q, p, K):
+    """
+    Compute a basis of the kernel of ``Q``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_Qmatrix, gf_Qbasis
+
+    >>> gf_Qbasis(gf_Qmatrix([1, 0, 0, 0, 1], 5, ZZ), 5, ZZ)
+    [[1, 0, 0, 0], [0, 0, 1, 0]]
+
+    >>> gf_Qbasis(gf_Qmatrix([3, 2, 4], 5, ZZ), 5, ZZ)
+    [[1, 0]]
+
+    """
+    Q, n = [ list(q) for q in Q ], len(Q)
+
+    for k in range(0, n):
+        Q[k][k] = (Q[k][k] - K.one) % p
+
+    for k in range(0, n):
+        for i in range(k, n):
+            if Q[k][i]:
+                break
+        else:
+            continue
+
+        inv = K.invert(Q[k][i], p)
+
+        for j in range(0, n):
+            Q[j][i] = (Q[j][i]*inv) % p
+
+        for j in range(0, n):
+            t = Q[j][k]
+            Q[j][k] = Q[j][i]
+            Q[j][i] = t
+
+        for i in range(0, n):
+            if i != k:
+                q = Q[k][i]
+
+                for j in range(0, n):
+                    Q[j][i] = (Q[j][i] - Q[j][k]*q) % p
+
+    for i in range(0, n):
+        for j in range(0, n):
+            if i == j:
+                Q[i][j] = (K.one - Q[i][j]) % p
+            else:
+                Q[i][j] = (-Q[i][j]) % p
+
+    basis = []
+
+    for q in Q:
+        if any(q):
+            basis.append(q)
+
+    return basis
+
+
+def gf_berlekamp(f, p, K):
+    """
+    Factor a square-free ``f`` in ``GF(p)[x]`` for small ``p``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_berlekamp
+
+    >>> gf_berlekamp([1, 0, 0, 0, 1], 5, ZZ)
+    [[1, 0, 2], [1, 0, 3]]
+
+    """
+    Q = gf_Qmatrix(f, p, K)
+    V = gf_Qbasis(Q, p, K)
+
+    for i, v in enumerate(V):
+        V[i] = gf_strip(list(reversed(v)))
+
+    factors = [f]
+
+    for k in range(1, len(V)):
+        for f in list(factors):
+            s = K.zero
+
+            while s < p:
+                g = gf_sub_ground(V[k], s, p, K)
+                h = gf_gcd(f, g, p, K)
+
+                if h != [K.one] and h != f:
+                    factors.remove(f)
+
+                    f = gf_quo(f, h, p, K)
+                    factors.extend([f, h])
+
+                if len(factors) == len(V):
+                    return _sort_factors(factors, multiple=False)
+
+                s += K.one
+
+    return _sort_factors(factors, multiple=False)
+
+
+def gf_ddf_zassenhaus(f, p, K):
+    """
+    Cantor-Zassenhaus: Deterministic Distinct Degree Factorization
+
+    Given a monic square-free polynomial ``f`` in ``GF(p)[x]``, computes
+    partial distinct degree factorization ``f_1 ... f_d`` of ``f`` where
+    ``deg(f_i) != deg(f_j)`` for ``i != j``. The result is returned as a
+    list of pairs ``(f_i, e_i)`` where ``deg(f_i) > 0`` and ``e_i > 0``
+    is an argument to the equal degree factorization routine.
+
+    Consider the polynomial ``x**15 - 1`` in ``GF(11)[x]``::
+
+       >>> from sympy.polys.domains import ZZ
+       >>> from sympy.polys.galoistools import gf_from_dict
+
+       >>> f = gf_from_dict({15: ZZ(1), 0: ZZ(-1)}, 11, ZZ)
+
+    Distinct degree factorization gives::
+
+       >>> from sympy.polys.galoistools import gf_ddf_zassenhaus
+
+       >>> gf_ddf_zassenhaus(f, 11, ZZ)
+       [([1, 0, 0, 0, 0, 10], 1), ([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], 2)]
+
+    which means ``x**15 - 1 = (x**5 - 1) (x**10 + x**5 + 1)``. To obtain
+    factorization into irreducibles, use equal degree factorization
+    procedure (EDF) with each of the factors.
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+    .. [2] [Geddes92]_
+
+    """
+    i, g, factors = 1, [K.one, K.zero], []
+
+    b = gf_frobenius_monomial_base(f, p, K)
+    while 2*i <= gf_degree(f):
+        g = gf_frobenius_map(g, f, b, p, K)
+        h = gf_gcd(f, gf_sub(g, [K.one, K.zero], p, K), p, K)
+
+        if h != [K.one]:
+            factors.append((h, i))
+
+            f = gf_quo(f, h, p, K)
+            g = gf_rem(g, f, p, K)
+            b = gf_frobenius_monomial_base(f, p, K)
+
+        i += 1
+
+    if f != [K.one]:
+        return factors + [(f, gf_degree(f))]
+    else:
+        return factors
+
+
+def gf_edf_zassenhaus(f, n, p, K):
+    """
+    Cantor-Zassenhaus: Probabilistic Equal Degree Factorization
+
+    Given a monic square-free polynomial ``f`` in ``GF(p)[x]`` and
+    an integer ``n``, such that ``n`` divides ``deg(f)``, returns all
+    irreducible factors ``f_1,...,f_d`` of ``f``, each of degree ``n``.
+    EDF procedure gives complete factorization over Galois fields.
+
+    Consider the square-free polynomial ``f = x**3 + x**2 + x + 1`` in
+    ``GF(5)[x]``. Let's compute its irreducible factors of degree one::
+
+       >>> from sympy.polys.domains import ZZ
+       >>> from sympy.polys.galoistools import gf_edf_zassenhaus
+
+       >>> gf_edf_zassenhaus([1,1,1,1], 1, 5, ZZ)
+       [[1, 1], [1, 2], [1, 3]]
+
+    Notes
+    =====
+
+    The case p == 2 is handled by Cohen's Algorithm 3.4.8. The case p odd is
+    as in Geddes Algorithm 8.9 (or Cohen's Algorithm 3.4.6).
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+    .. [2] [Geddes92]_ Algorithm 8.9
+    .. [3] [Cohen93]_ Algorithm 3.4.8
+
+    """
+    factors = [f]
+
+    if gf_degree(f) <= n:
+        return factors
+
+    N = gf_degree(f) // n
+    if p != 2:
+        b = gf_frobenius_monomial_base(f, p, K)
+
+    t = [K.one, K.zero]
+    while len(factors) < N:
+        if p == 2:
+            h = r = t
+
+            for i in range(n - 1):
+                r = gf_pow_mod(r, 2, f, p, K)
+                h = gf_add(h, r, p, K)
+
+            g = gf_gcd(f, h, p, K)
+            t += [K.zero, K.zero]
+        else:
+            r = gf_random(2 * n - 1, p, K)
+            h = _gf_pow_pnm1d2(r, n, f, b, p, K)
+            g = gf_gcd(f, gf_sub_ground(h, K.one, p, K), p, K)
+
+        if g != [K.one] and g != f:
+            factors = gf_edf_zassenhaus(g, n, p, K) \
+                + gf_edf_zassenhaus(gf_quo(f, g, p, K), n, p, K)
+
+    return _sort_factors(factors, multiple=False)
+
+
+def gf_ddf_shoup(f, p, K):
+    """
+    Kaltofen-Shoup: Deterministic Distinct Degree Factorization
+
+    Given a monic square-free polynomial ``f`` in ``GF(p)[x]``, computes
+    partial distinct degree factorization ``f_1,...,f_d`` of ``f`` where
+    ``deg(f_i) != deg(f_j)`` for ``i != j``. The result is returned as a
+    list of pairs ``(f_i, e_i)`` where ``deg(f_i) > 0`` and ``e_i > 0``
+    is an argument to the equal degree factorization routine.
+
+    This algorithm is an improved version of Zassenhaus algorithm for
+    large ``deg(f)`` and modulus ``p`` (especially for ``deg(f) ~ lg(p)``).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_ddf_shoup, gf_from_dict
+
+    >>> f = gf_from_dict({6: ZZ(1), 5: ZZ(-1), 4: ZZ(1), 3: ZZ(1), 1: ZZ(-1)}, 3, ZZ)
+
+    >>> gf_ddf_shoup(f, 3, ZZ)
+    [([1, 1, 0], 1), ([1, 1, 0, 1, 2], 2)]
+
+    References
+    ==========
+
+    .. [1] [Kaltofen98]_
+    .. [2] [Shoup95]_
+    .. [3] [Gathen92]_
+
+    """
+    n = gf_degree(f)
+    k = int(_ceil(_sqrt(n//2)))
+    b = gf_frobenius_monomial_base(f, p, K)
+    h = gf_frobenius_map([K.one, K.zero], f, b, p, K)
+    # U[i] = x**(p**i)
+    U = [[K.one, K.zero], h] + [K.zero]*(k - 1)
+
+    for i in range(2, k + 1):
+        U[i] = gf_frobenius_map(U[i-1], f, b, p, K)
+
+    h, U = U[k], U[:k]
+    # V[i] = x**(p**(k*(i+1)))
+    V = [h] + [K.zero]*(k - 1)
+
+    for i in range(1, k):
+        V[i] = gf_compose_mod(V[i - 1], h, f, p, K)
+
+    factors = []
+
+    for i, v in enumerate(V):
+        h, j = [K.one], k - 1
+
+        for u in U:
+            g = gf_sub(v, u, p, K)
+            h = gf_mul(h, g, p, K)
+            h = gf_rem(h, f, p, K)
+
+        g = gf_gcd(f, h, p, K)
+        f = gf_quo(f, g, p, K)
+
+        for u in reversed(U):
+            h = gf_sub(v, u, p, K)
+            F = gf_gcd(g, h, p, K)
+
+            if F != [K.one]:
+                factors.append((F, k*(i + 1) - j))
+
+            g, j = gf_quo(g, F, p, K), j - 1
+
+    if f != [K.one]:
+        factors.append((f, gf_degree(f)))
+
+    return factors
+
+def gf_edf_shoup(f, n, p, K):
+    """
+    Gathen-Shoup: Probabilistic Equal Degree Factorization
+
+    Given a monic square-free polynomial ``f`` in ``GF(p)[x]`` and integer
+    ``n`` such that ``n`` divides ``deg(f)``, returns all irreducible factors
+    ``f_1,...,f_d`` of ``f``, each of degree ``n``. This is a complete
+    factorization over Galois fields.
+
+    This algorithm is an improved version of Zassenhaus algorithm for
+    large ``deg(f)`` and modulus ``p`` (especially for ``deg(f) ~ lg(p)``).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_edf_shoup
+
+    >>> gf_edf_shoup(ZZ.map([1, 2837, 2277]), 1, 2917, ZZ)
+    [[1, 852], [1, 1985]]
+
+    References
+    ==========
+
+    .. [1] [Shoup91]_
+    .. [2] [Gathen92]_
+
+    """
+    N, q = gf_degree(f), int(p)
+
+    if not N:
+        return []
+    if N <= n:
+        return [f]
+
+    factors, x = [f], [K.one, K.zero]
+
+    r = gf_random(N - 1, p, K)
+
+    if p == 2:
+        h = gf_pow_mod(x, q, f, p, K)
+        H = gf_trace_map(r, h, x, n - 1, f, p, K)[1]
+        h1 = gf_gcd(f, H, p, K)
+        h2 = gf_quo(f, h1, p, K)
+
+        factors = gf_edf_shoup(h1, n, p, K) \
+            + gf_edf_shoup(h2, n, p, K)
+    else:
+        b = gf_frobenius_monomial_base(f, p, K)
+        H = _gf_trace_map(r, n, f, b, p, K)
+        h = gf_pow_mod(H, (q - 1)//2, f, p, K)
+
+        h1 = gf_gcd(f, h, p, K)
+        h2 = gf_gcd(f, gf_sub_ground(h, K.one, p, K), p, K)
+        h3 = gf_quo(f, gf_mul(h1, h2, p, K), p, K)
+
+        factors = gf_edf_shoup(h1, n, p, K) \
+            + gf_edf_shoup(h2, n, p, K) \
+            + gf_edf_shoup(h3, n, p, K)
+
+    return _sort_factors(factors, multiple=False)
+
+
+def gf_zassenhaus(f, p, K):
+    """
+    Factor a square-free ``f`` in ``GF(p)[x]`` for medium ``p``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_zassenhaus
+
+    >>> gf_zassenhaus(ZZ.map([1, 4, 3]), 5, ZZ)
+    [[1, 1], [1, 3]]
+
+    """
+    factors = []
+
+    for factor, n in gf_ddf_zassenhaus(f, p, K):
+        factors += gf_edf_zassenhaus(factor, n, p, K)
+
+    return _sort_factors(factors, multiple=False)
+
+
+def gf_shoup(f, p, K):
+    """
+    Factor a square-free ``f`` in ``GF(p)[x]`` for large ``p``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_shoup
+
+    >>> gf_shoup(ZZ.map([1, 4, 3]), 5, ZZ)
+    [[1, 1], [1, 3]]
+
+    """
+    factors = []
+
+    for factor, n in gf_ddf_shoup(f, p, K):
+        factors += gf_edf_shoup(factor, n, p, K)
+
+    return _sort_factors(factors, multiple=False)
+
+_factor_methods = {
+    'berlekamp': gf_berlekamp,  # ``p`` : small
+    'zassenhaus': gf_zassenhaus,  # ``p`` : medium
+    'shoup': gf_shoup,      # ``p`` : large
+}
+
+
+def gf_factor_sqf(f, p, K, method=None):
+    """
+    Factor a square-free polynomial ``f`` in ``GF(p)[x]``.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.galoistools import gf_factor_sqf
+
+    >>> gf_factor_sqf(ZZ.map([3, 2, 4]), 5, ZZ)
+    (3, [[1, 1], [1, 3]])
+
+    """
+    lc, f = gf_monic(f, p, K)
+
+    if gf_degree(f) < 1:
+        return lc, []
+
+    method = method or query('GF_FACTOR_METHOD')
+
+    if method is not None:
+        factors = _factor_methods[method](f, p, K)
+    else:
+        factors = gf_zassenhaus(f, p, K)
+
+    return lc, factors
+
+
+def gf_factor(f, p, K):
+    """
+    Factor (non square-free) polynomials in ``GF(p)[x]``.
+
+    Given a possibly non square-free polynomial ``f`` in ``GF(p)[x]``,
+    returns its complete factorization into irreducibles::
+
+                 f_1(x)**e_1 f_2(x)**e_2 ... f_d(x)**e_d
+
+    where each ``f_i`` is a monic polynomial and ``gcd(f_i, f_j) == 1``,
+    for ``i != j``.  The result is given as a tuple consisting of the
+    leading coefficient of ``f`` and a list of factors of ``f`` with
+    their multiplicities.
+
+    The algorithm proceeds by first computing square-free decomposition
+    of ``f`` and then iteratively factoring each of square-free factors.
+
+    Consider a non square-free polynomial ``f = (7*x + 1) (x + 2)**2`` in
+    ``GF(11)[x]``. We obtain its factorization into irreducibles as follows::
+
+       >>> from sympy.polys.domains import ZZ
+       >>> from sympy.polys.galoistools import gf_factor
+
+       >>> gf_factor(ZZ.map([5, 2, 7, 2]), 11, ZZ)
+       (5, [([1, 2], 1), ([1, 8], 2)])
+
+    We arrived with factorization ``f = 5 (x + 2) (x + 8)**2``. We did not
+    recover the exact form of the input polynomial because we requested to
+    get monic factors of ``f`` and its leading coefficient separately.
+
+    Square-free factors of ``f`` can be factored into irreducibles over
+    ``GF(p)`` using three very different methods:
+
+    Berlekamp
+        efficient for very small values of ``p`` (usually ``p < 25``)
+    Cantor-Zassenhaus
+        efficient on average input and with "typical" ``p``
+    Shoup-Kaltofen-Gathen
+        efficient with very large inputs and modulus
+
+    If you want to use a specific factorization method, instead of the default
+    one, set ``GF_FACTOR_METHOD`` with one of ``berlekamp``, ``zassenhaus`` or
+    ``shoup`` values.
+
+    References
+    ==========
+
+    .. [1] [Gathen99]_
+
+    """
+    lc, f = gf_monic(f, p, K)
+
+    if gf_degree(f) < 1:
+        return lc, []
+
+    factors = []
+
+    for g, n in gf_sqf_list(f, p, K)[1]:
+        for h in gf_factor_sqf(g, p, K)[1]:
+            factors.append((h, n))
+
+    return lc, _sort_factors(factors)
+
+
+def gf_value(f, a):
+    """
+    Value of polynomial 'f' at 'a' in field R.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import gf_value
+
+    >>> gf_value([1, 7, 2, 4], 11)
+    2204
+
+    """
+    result = 0
+    for c in f:
+        result *= a
+        result += c
+    return result
+
+
+def linear_congruence(a, b, m):
+    """
+    Returns the values of x satisfying a*x congruent b mod(m)
+
+    Here m is positive integer and a, b are natural numbers.
+    This function returns only those values of x which are distinct mod(m).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import linear_congruence
+
+    >>> linear_congruence(3, 12, 15)
+    [4, 9, 14]
+
+    There are 3 solutions distinct mod(15) since gcd(a, m) = gcd(3, 15) = 3.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Linear_congruence_theorem
+
+    """
+    from sympy.polys.polytools import gcdex
+    if a % m == 0:
+        if b % m == 0:
+            return list(range(m))
+        else:
+            return []
+    r, _, g = gcdex(a, m)
+    if b % g != 0:
+        return []
+    return [(r * b // g + t * m // g) % m for t in range(g)]
+
+
+def _raise_mod_power(x, s, p, f):
+    """
+    Used in gf_csolve to generate solutions of f(x) cong 0 mod(p**(s + 1))
+    from the solutions of f(x) cong 0 mod(p**s).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import _raise_mod_power
+    >>> from sympy.polys.galoistools import csolve_prime
+
+    These is the solutions of f(x) = x**2 + x + 7 cong 0 mod(3)
+
+    >>> f = [1, 1, 7]
+    >>> csolve_prime(f, 3)
+    [1]
+    >>> [ i for i in range(3) if not (i**2 + i + 7) % 3]
+    [1]
+
+    The solutions of f(x) cong 0 mod(9) are constructed from the
+    values returned from _raise_mod_power:
+
+    >>> x, s, p = 1, 1, 3
+    >>> V = _raise_mod_power(x, s, p, f)
+    >>> [x + v * p**s for v in V]
+    [1, 4, 7]
+
+    And these are confirmed with the following:
+
+    >>> [ i for i in range(3**2) if not (i**2 + i + 7) % 3**2]
+    [1, 4, 7]
+
+    """
+    from sympy.polys.domains import ZZ
+    f_f = gf_diff(f, p, ZZ)
+    alpha = gf_value(f_f, x)
+    beta = - gf_value(f, x) // p**s
+    return linear_congruence(alpha, beta, p)
+
+
+def csolve_prime(f, p, e=1):
+    """
+    Solutions of f(x) congruent 0 mod(p**e).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.galoistools import csolve_prime
+
+    >>> csolve_prime([1, 1, 7], 3, 1)
+    [1]
+    >>> csolve_prime([1, 1, 7], 3, 2)
+    [1, 4, 7]
+
+    Solutions [7, 4, 1] (mod 3**2) are generated by ``_raise_mod_power()``
+    from solution [1] (mod 3).
+    """
+    from sympy.polys.domains import ZZ
+    X1 = [i for i in range(p) if gf_eval(f, i, p, ZZ) == 0]
+    if e == 1:
+        return X1
+    X = []
+    S = list(zip(X1, [1]*len(X1)))
+    while S:
+        x, s = S.pop()
+        if s == e:
+            X.append(x)
+        else:
+            s1 = s + 1
+            ps = p**s
+            S.extend([(x + v*ps, s1) for v in _raise_mod_power(x, s, p, f)])
+    return sorted(X)
+
+
+def gf_csolve(f, n):
+    """
+    To solve f(x) congruent 0 mod(n).
+
+    n is divided into canonical factors and f(x) cong 0 mod(p**e) will be
+    solved for each factor. Applying the Chinese Remainder Theorem to the
+    results returns the final answers.
+
+    Examples
+    ========
+
+    Solve [1, 1, 7] congruent 0 mod(189):
+
+    >>> from sympy.polys.galoistools import gf_csolve
+    >>> gf_csolve([1, 1, 7], 189)
+    [13, 49, 76, 112, 139, 175]
+
+    References
+    ==========
+
+    .. [1] 'An introduction to the Theory of Numbers' 5th Edition by Ivan Niven,
+           Zuckerman and Montgomery.
+
+    """
+    from sympy.polys.domains import ZZ
+    from sympy.ntheory import factorint
+    P = factorint(n)
+    X = [csolve_prime(f, p, e) for p, e in P.items()]
+    pools = list(map(tuple, X))
+    perms = [[]]
+    for pool in pools:
+        perms = [x + [y] for x in perms for y in pool]
+    dist_factors = [pow(p, e) for p, e in P.items()]
+    return sorted([gf_crt(per, dist_factors, ZZ) for per in perms])

llmeval-env/lib/python3.10/site-packages/sympy/polys/groebnertools.py

@@ -0,0 +1,862 @@
+"""Groebner bases algorithms. """
+
+
+from sympy.core.symbol import Dummy
+from sympy.polys.monomials import monomial_mul, monomial_lcm, monomial_divides, term_div
+from sympy.polys.orderings import lex
+from sympy.polys.polyerrors import DomainError
+from sympy.polys.polyconfig import query
+
+def groebner(seq, ring, method=None):
+    """
+    Computes Groebner basis for a set of polynomials in `K[X]`.
+
+    Wrapper around the (default) improved Buchberger and the other algorithms
+    for computing Groebner bases. The choice of algorithm can be changed via
+    ``method`` argument or :func:`sympy.polys.polyconfig.setup`, where
+    ``method`` can be either ``buchberger`` or ``f5b``.
+
+    """
+    if method is None:
+        method = query('groebner')
+
+    _groebner_methods = {
+        'buchberger': _buchberger,
+        'f5b': _f5b,
+    }
+
+    try:
+        _groebner = _groebner_methods[method]
+    except KeyError:
+        raise ValueError("'%s' is not a valid Groebner bases algorithm (valid are 'buchberger' and 'f5b')" % method)
+
+    domain, orig = ring.domain, None
+
+    if not domain.is_Field or not domain.has_assoc_Field:
+        try:
+            orig, ring = ring, ring.clone(domain=domain.get_field())
+        except DomainError:
+            raise DomainError("Cannot compute a Groebner basis over %s" % domain)
+        else:
+            seq = [ s.set_ring(ring) for s in seq ]
+
+    G = _groebner(seq, ring)
+
+    if orig is not None:
+        G = [ g.clear_denoms()[1].set_ring(orig) for g in G ]
+
+    return G
+
+def _buchberger(f, ring):
+    """
+    Computes Groebner basis for a set of polynomials in `K[X]`.
+
+    Given a set of multivariate polynomials `F`, finds another
+    set `G`, such that Ideal `F = Ideal G` and `G` is a reduced
+    Groebner basis.
+
+    The resulting basis is unique and has monic generators if the
+    ground domains is a field. Otherwise the result is non-unique
+    but Groebner bases over e.g. integers can be computed (if the
+    input polynomials are monic).
+
+    Groebner bases can be used to choose specific generators for a
+    polynomial ideal. Because these bases are unique you can check
+    for ideal equality by comparing the Groebner bases.  To see if
+    one polynomial lies in an ideal, divide by the elements in the
+    base and see if the remainder vanishes.
+
+    They can also be used to solve systems of polynomial equations
+    as,  by choosing lexicographic ordering,  you can eliminate one
+    variable at a time, provided that the ideal is zero-dimensional
+    (finite number of solutions).
+
+    Notes
+    =====
+
+    Algorithm used: an improved version of Buchberger's algorithm
+    as presented in T. Becker, V. Weispfenning, Groebner Bases: A
+    Computational Approach to Commutative Algebra, Springer, 1993,
+    page 232.
+
+    References
+    ==========
+
+    .. [1] [Bose03]_
+    .. [2] [Giovini91]_
+    .. [3] [Ajwa95]_
+    .. [4] [Cox97]_
+
+    """
+    order = ring.order
+
+    monomial_mul = ring.monomial_mul
+    monomial_div = ring.monomial_div
+    monomial_lcm = ring.monomial_lcm
+
+    def select(P):
+        # normal selection strategy
+        # select the pair with minimum LCM(LM(f), LM(g))
+        pr = min(P, key=lambda pair: order(monomial_lcm(f[pair[0]].LM, f[pair[1]].LM)))
+        return pr
+
+    def normal(g, J):
+        h = g.rem([ f[j] for j in J ])
+
+        if not h:
+            return None
+        else:
+            h = h.monic()
+
+            if h not in I:
+                I[h] = len(f)
+                f.append(h)
+
+            return h.LM, I[h]
+
+    def update(G, B, ih):
+        # update G using the set of critical pairs B and h
+        # [BW] page 230
+        h = f[ih]
+        mh = h.LM
+
+        # filter new pairs (h, g), g in G
+        C = G.copy()
+        D = set()
+
+        while C:
+            # select a pair (h, g) by popping an element from C
+            ig = C.pop()
+            g = f[ig]
+            mg = g.LM
+            LCMhg = monomial_lcm(mh, mg)
+
+            def lcm_divides(ip):
+                # LCM(LM(h), LM(p)) divides LCM(LM(h), LM(g))
+                m = monomial_lcm(mh, f[ip].LM)
+                return monomial_div(LCMhg, m)
+
+            # HT(h) and HT(g) disjoint: mh*mg == LCMhg
+            if monomial_mul(mh, mg) == LCMhg or (
+                not any(lcm_divides(ipx) for ipx in C) and
+                    not any(lcm_divides(pr[1]) for pr in D)):
+                D.add((ih, ig))
+
+        E = set()
+
+        while D:
+            # select h, g from D (h the same as above)
+            ih, ig = D.pop()
+            mg = f[ig].LM
+            LCMhg = monomial_lcm(mh, mg)
+
+            if not monomial_mul(mh, mg) == LCMhg:
+                E.add((ih, ig))
+
+        # filter old pairs
+        B_new = set()
+
+        while B:
+            # select g1, g2 from B (-> CP)
+            ig1, ig2 = B.pop()
+            mg1 = f[ig1].LM
+            mg2 = f[ig2].LM
+            LCM12 = monomial_lcm(mg1, mg2)
+
+            # if HT(h) does not divide lcm(HT(g1), HT(g2))
+            if not monomial_div(LCM12, mh) or \
+                monomial_lcm(mg1, mh) == LCM12 or \
+                    monomial_lcm(mg2, mh) == LCM12:
+                B_new.add((ig1, ig2))
+
+        B_new |= E
+
+        # filter polynomials
+        G_new = set()
+
+        while G:
+            ig = G.pop()
+            mg = f[ig].LM
+
+            if not monomial_div(mg, mh):
+                G_new.add(ig)
+
+        G_new.add(ih)
+
+        return G_new, B_new
+        # end of update ################################
+
+    if not f:
+        return []
+
+    # replace f with a reduced list of initial polynomials; see [BW] page 203
+    f1 = f[:]
+
+    while True:
+        f = f1[:]
+        f1 = []
+
+        for i in range(len(f)):
+            p = f[i]
+            r = p.rem(f[:i])
+
+            if r:
+                f1.append(r.monic())
+
+        if f == f1:
+            break
+
+    I = {}            # ip = I[p]; p = f[ip]
+    F = set()         # set of indices of polynomials
+    G = set()         # set of indices of intermediate would-be Groebner basis
+    CP = set()        # set of pairs of indices of critical pairs
+
+    for i, h in enumerate(f):
+        I[h] = i
+        F.add(i)
+
+    #####################################
+    # algorithm GROEBNERNEWS2 in [BW] page 232
+
+    while F:
+        # select p with minimum monomial according to the monomial ordering
+        h = min([f[x] for x in F], key=lambda f: order(f.LM))
+        ih = I[h]
+        F.remove(ih)
+        G, CP = update(G, CP, ih)
+
+    # count the number of critical pairs which reduce to zero
+    reductions_to_zero = 0
+
+    while CP:
+        ig1, ig2 = select(CP)
+        CP.remove((ig1, ig2))
+
+        h = spoly(f[ig1], f[ig2], ring)
+        # ordering divisors is on average more efficient [Cox] page 111
+        G1 = sorted(G, key=lambda g: order(f[g].LM))
+        ht = normal(h, G1)
+
+        if ht:
+            G, CP = update(G, CP, ht[1])
+        else:
+            reductions_to_zero += 1
+
+    ######################################
+    # now G is a Groebner basis; reduce it
+    Gr = set()
+
+    for ig in G:
+        ht = normal(f[ig], G - {ig})
+
+        if ht:
+            Gr.add(ht[1])
+
+    Gr = [f[ig] for ig in Gr]
+
+    # order according to the monomial ordering
+    Gr = sorted(Gr, key=lambda f: order(f.LM), reverse=True)
+
+    return Gr
+
+def spoly(p1, p2, ring):
+    """
+    Compute LCM(LM(p1), LM(p2))/LM(p1)*p1 - LCM(LM(p1), LM(p2))/LM(p2)*p2
+    This is the S-poly provided p1 and p2 are monic
+    """
+    LM1 = p1.LM
+    LM2 = p2.LM
+    LCM12 = ring.monomial_lcm(LM1, LM2)
+    m1 = ring.monomial_div(LCM12, LM1)
+    m2 = ring.monomial_div(LCM12, LM2)
+    s1 = p1.mul_monom(m1)
+    s2 = p2.mul_monom(m2)
+    s = s1 - s2
+    return s
+
+# F5B
+
+# convenience functions
+
+
+def Sign(f):
+    return f[0]
+
+
+def Polyn(f):
+    return f[1]
+
+
+def Num(f):
+    return f[2]
+
+
+def sig(monomial, index):
+    return (monomial, index)
+
+
+def lbp(signature, polynomial, number):
+    return (signature, polynomial, number)
+
+# signature functions
+
+
+def sig_cmp(u, v, order):
+    """
+    Compare two signatures by extending the term order to K[X]^n.
+
+    u < v iff
+        - the index of v is greater than the index of u
+    or
+        - the index of v is equal to the index of u and u[0] < v[0] w.r.t. order
+
+    u > v otherwise
+    """
+    if u[1] > v[1]:
+        return -1
+    if u[1] == v[1]:
+        #if u[0] == v[0]:
+        #    return 0
+        if order(u[0]) < order(v[0]):
+            return -1
+    return 1
+
+
+def sig_key(s, order):
+    """
+    Key for comparing two signatures.
+
+    s = (m, k), t = (n, l)
+
+    s < t iff [k > l] or [k == l and m < n]
+    s > t otherwise
+    """
+    return (-s[1], order(s[0]))
+
+
+def sig_mult(s, m):
+    """
+    Multiply a signature by a monomial.
+
+    The product of a signature (m, i) and a monomial n is defined as
+    (m * t, i).
+    """
+    return sig(monomial_mul(s[0], m), s[1])
+
+# labeled polynomial functions
+
+
+def lbp_sub(f, g):
+    """
+    Subtract labeled polynomial g from f.
+
+    The signature and number of the difference of f and g are signature
+    and number of the maximum of f and g, w.r.t. lbp_cmp.
+    """
+    if sig_cmp(Sign(f), Sign(g), Polyn(f).ring.order) < 0:
+        max_poly = g
+    else:
+        max_poly = f
+
+    ret = Polyn(f) - Polyn(g)
+
+    return lbp(Sign(max_poly), ret, Num(max_poly))
+
+
+def lbp_mul_term(f, cx):
+    """
+    Multiply a labeled polynomial with a term.
+
+    The product of a labeled polynomial (s, p, k) by a monomial is
+    defined as (m * s, m * p, k).
+    """
+    return lbp(sig_mult(Sign(f), cx[0]), Polyn(f).mul_term(cx), Num(f))
+
+
+def lbp_cmp(f, g):
+    """
+    Compare two labeled polynomials.
+
+    f < g iff
+        - Sign(f) < Sign(g)
+    or
+        - Sign(f) == Sign(g) and Num(f) > Num(g)
+
+    f > g otherwise
+    """
+    if sig_cmp(Sign(f), Sign(g), Polyn(f).ring.order) == -1:
+        return -1
+    if Sign(f) == Sign(g):
+        if Num(f) > Num(g):
+            return -1
+        #if Num(f) == Num(g):
+        #    return 0
+    return 1
+
+
+def lbp_key(f):
+    """
+    Key for comparing two labeled polynomials.
+    """
+    return (sig_key(Sign(f), Polyn(f).ring.order), -Num(f))
+
+# algorithm and helper functions
+
+
+def critical_pair(f, g, ring):
+    """
+    Compute the critical pair corresponding to two labeled polynomials.
+
+    A critical pair is a tuple (um, f, vm, g), where um and vm are
+    terms such that um * f - vm * g is the S-polynomial of f and g (so,
+    wlog assume um * f > vm * g).
+    For performance sake, a critical pair is represented as a tuple
+    (Sign(um * f), um, f, Sign(vm * g), vm, g), since um * f creates
+    a new, relatively expensive object in memory, whereas Sign(um *
+    f) and um are lightweight and f (in the tuple) is a reference to
+    an already existing object in memory.
+    """
+    domain = ring.domain
+
+    ltf = Polyn(f).LT
+    ltg = Polyn(g).LT
+    lt = (monomial_lcm(ltf[0], ltg[0]), domain.one)
+
+    um = term_div(lt, ltf, domain)
+    vm = term_div(lt, ltg, domain)
+
+    # The full information is not needed (now), so only the product
+    # with the leading term is considered:
+    fr = lbp_mul_term(lbp(Sign(f), Polyn(f).leading_term(), Num(f)), um)
+    gr = lbp_mul_term(lbp(Sign(g), Polyn(g).leading_term(), Num(g)), vm)
+
+    # return in proper order, such that the S-polynomial is just
+    # u_first * f_first - u_second * f_second:
+    if lbp_cmp(fr, gr) == -1:
+        return (Sign(gr), vm, g, Sign(fr), um, f)
+    else:
+        return (Sign(fr), um, f, Sign(gr), vm, g)
+
+
+def cp_cmp(c, d):
+    """
+    Compare two critical pairs c and d.
+
+    c < d iff
+        - lbp(c[0], _, Num(c[2]) < lbp(d[0], _, Num(d[2])) (this
+        corresponds to um_c * f_c and um_d * f_d)
+    or
+        - lbp(c[0], _, Num(c[2]) >< lbp(d[0], _, Num(d[2])) and
+        lbp(c[3], _, Num(c[5])) < lbp(d[3], _, Num(d[5])) (this
+        corresponds to vm_c * g_c and vm_d * g_d)
+
+    c > d otherwise
+    """
+    zero = Polyn(c[2]).ring.zero
+
+    c0 = lbp(c[0], zero, Num(c[2]))
+    d0 = lbp(d[0], zero, Num(d[2]))
+
+    r = lbp_cmp(c0, d0)
+
+    if r == -1:
+        return -1
+    if r == 0:
+        c1 = lbp(c[3], zero, Num(c[5]))
+        d1 = lbp(d[3], zero, Num(d[5]))
+
+        r = lbp_cmp(c1, d1)
+
+        if r == -1:
+            return -1
+        #if r == 0:
+        #    return 0
+    return 1
+
+
+def cp_key(c, ring):
+    """
+    Key for comparing critical pairs.
+    """
+    return (lbp_key(lbp(c[0], ring.zero, Num(c[2]))), lbp_key(lbp(c[3], ring.zero, Num(c[5]))))
+
+
+def s_poly(cp):
+    """
+    Compute the S-polynomial of a critical pair.
+
+    The S-polynomial of a critical pair cp is cp[1] * cp[2] - cp[4] * cp[5].
+    """
+    return lbp_sub(lbp_mul_term(cp[2], cp[1]), lbp_mul_term(cp[5], cp[4]))
+
+
+def is_rewritable_or_comparable(sign, num, B):
+    """
+    Check if a labeled polynomial is redundant by checking if its
+    signature and number imply rewritability or comparability.
+
+    (sign, num) is comparable if there exists a labeled polynomial
+    h in B, such that sign[1] (the index) is less than Sign(h)[1]
+    and sign[0] is divisible by the leading monomial of h.
+
+    (sign, num) is rewritable if there exists a labeled polynomial
+    h in B, such thatsign[1] is equal to Sign(h)[1], num < Num(h)
+    and sign[0] is divisible by Sign(h)[0].
+    """
+    for h in B:
+        # comparable
+        if sign[1] < Sign(h)[1]:
+            if monomial_divides(Polyn(h).LM, sign[0]):
+                return True
+
+        # rewritable
+        if sign[1] == Sign(h)[1]:
+            if num < Num(h):
+                if monomial_divides(Sign(h)[0], sign[0]):
+                    return True
+    return False
+
+
+def f5_reduce(f, B):
+    """
+    F5-reduce a labeled polynomial f by B.
+
+    Continuously searches for non-zero labeled polynomial h in B, such
+    that the leading term lt_h of h divides the leading term lt_f of
+    f and Sign(lt_h * h) < Sign(f). If such a labeled polynomial h is
+    found, f gets replaced by f - lt_f / lt_h * h. If no such h can be
+    found or f is 0, f is no further F5-reducible and f gets returned.
+
+    A polynomial that is reducible in the usual sense need not be
+    F5-reducible, e.g.:
+
+    >>> from sympy.polys.groebnertools import lbp, sig, f5_reduce, Polyn
+    >>> from sympy.polys import ring, QQ, lex
+
+    >>> R, x,y,z = ring("x,y,z", QQ, lex)
+
+    >>> f = lbp(sig((1, 1, 1), 4), x, 3)
+    >>> g = lbp(sig((0, 0, 0), 2), x, 2)
+
+    >>> Polyn(f).rem([Polyn(g)])
+    0
+    >>> f5_reduce(f, [g])
+    (((1, 1, 1), 4), x, 3)
+
+    """
+    order = Polyn(f).ring.order
+    domain = Polyn(f).ring.domain
+
+    if not Polyn(f):
+        return f
+
+    while True:
+        g = f
+
+        for h in B:
+            if Polyn(h):
+                if monomial_divides(Polyn(h).LM, Polyn(f).LM):
+                    t = term_div(Polyn(f).LT, Polyn(h).LT, domain)
+                    if sig_cmp(sig_mult(Sign(h), t[0]), Sign(f), order) < 0:
+                        # The following check need not be done and is in general slower than without.
+                        #if not is_rewritable_or_comparable(Sign(gp), Num(gp), B):
+                        hp = lbp_mul_term(h, t)
+                        f = lbp_sub(f, hp)
+                        break
+
+        if g == f or not Polyn(f):
+            return f
+
+
+def _f5b(F, ring):
+    """
+    Computes a reduced Groebner basis for the ideal generated by F.
+
+    f5b is an implementation of the F5B algorithm by Yao Sun and
+    Dingkang Wang. Similarly to Buchberger's algorithm, the algorithm
+    proceeds by computing critical pairs, computing the S-polynomial,
+    reducing it and adjoining the reduced S-polynomial if it is not 0.
+
+    Unlike Buchberger's algorithm, each polynomial contains additional
+    information, namely a signature and a number. The signature
+    specifies the path of computation (i.e. from which polynomial in
+    the original basis was it derived and how), the number says when
+    the polynomial was added to the basis.  With this information it
+    is (often) possible to decide if an S-polynomial will reduce to
+    0 and can be discarded.
+
+    Optimizations include: Reducing the generators before computing
+    a Groebner basis, removing redundant critical pairs when a new
+    polynomial enters the basis and sorting the critical pairs and
+    the current basis.
+
+    Once a Groebner basis has been found, it gets reduced.
+
+    References
+    ==========
+
+    .. [1] Yao Sun, Dingkang Wang: "A New Proof for the Correctness of F5
+           (F5-Like) Algorithm", https://arxiv.org/abs/1004.0084 (specifically
+           v4)
+
+    .. [2] Thomas Becker, Volker Weispfenning, Groebner bases: A computational
+           approach to commutative algebra, 1993, p. 203, 216
+    """
+    order = ring.order
+
+    # reduce polynomials (like in Mario Pernici's implementation) (Becker, Weispfenning, p. 203)
+    B = F
+    while True:
+        F = B
+        B = []
+
+        for i in range(len(F)):
+            p = F[i]
+            r = p.rem(F[:i])
+
+            if r:
+                B.append(r)
+
+        if F == B:
+            break
+
+    # basis
+    B = [lbp(sig(ring.zero_monom, i + 1), F[i], i + 1) for i in range(len(F))]
+    B.sort(key=lambda f: order(Polyn(f).LM), reverse=True)
+
+    # critical pairs
+    CP = [critical_pair(B[i], B[j], ring) for i in range(len(B)) for j in range(i + 1, len(B))]
+    CP.sort(key=lambda cp: cp_key(cp, ring), reverse=True)
+
+    k = len(B)
+
+    reductions_to_zero = 0
+
+    while len(CP):
+        cp = CP.pop()
+
+        # discard redundant critical pairs:
+        if is_rewritable_or_comparable(cp[0], Num(cp[2]), B):
+            continue
+        if is_rewritable_or_comparable(cp[3], Num(cp[5]), B):
+            continue
+
+        s = s_poly(cp)
+
+        p = f5_reduce(s, B)
+
+        p = lbp(Sign(p), Polyn(p).monic(), k + 1)
+
+        if Polyn(p):
+            # remove old critical pairs, that become redundant when adding p:
+            indices = []
+            for i, cp in enumerate(CP):
+                if is_rewritable_or_comparable(cp[0], Num(cp[2]), [p]):
+                    indices.append(i)
+                elif is_rewritable_or_comparable(cp[3], Num(cp[5]), [p]):
+                    indices.append(i)
+
+            for i in reversed(indices):
+                del CP[i]
+
+            # only add new critical pairs that are not made redundant by p:
+            for g in B:
+                if Polyn(g):
+                    cp = critical_pair(p, g, ring)
+                    if is_rewritable_or_comparable(cp[0], Num(cp[2]), [p]):
+                        continue
+                    elif is_rewritable_or_comparable(cp[3], Num(cp[5]), [p]):
+                        continue
+
+                    CP.append(cp)
+
+            # sort (other sorting methods/selection strategies were not as successful)
+            CP.sort(key=lambda cp: cp_key(cp, ring), reverse=True)
+
+            # insert p into B:
+            m = Polyn(p).LM
+            if order(m) <= order(Polyn(B[-1]).LM):
+                B.append(p)
+            else:
+                for i, q in enumerate(B):
+                    if order(m) > order(Polyn(q).LM):
+                        B.insert(i, p)
+                        break
+
+            k += 1
+
+            #print(len(B), len(CP), "%d critical pairs removed" % len(indices))
+        else:
+            reductions_to_zero += 1
+
+    # reduce Groebner basis:
+    H = [Polyn(g).monic() for g in B]
+    H = red_groebner(H, ring)
+
+    return sorted(H, key=lambda f: order(f.LM), reverse=True)
+
+
+def red_groebner(G, ring):
+    """
+    Compute reduced Groebner basis, from BeckerWeispfenning93, p. 216
+
+    Selects a subset of generators, that already generate the ideal
+    and computes a reduced Groebner basis for them.
+    """
+    def reduction(P):
+        """
+        The actual reduction algorithm.
+        """
+        Q = []
+        for i, p in enumerate(P):
+            h = p.rem(P[:i] + P[i + 1:])
+            if h:
+                Q.append(h)
+
+        return [p.monic() for p in Q]
+
+    F = G
+    H = []
+
+    while F:
+        f0 = F.pop()
+
+        if not any(monomial_divides(f.LM, f0.LM) for f in F + H):
+            H.append(f0)
+
+    # Becker, Weispfenning, p. 217: H is Groebner basis of the ideal generated by G.
+    return reduction(H)
+
+
+def is_groebner(G, ring):
+    """
+    Check if G is a Groebner basis.
+    """
+    for i in range(len(G)):
+        for j in range(i + 1, len(G)):
+            s = spoly(G[i], G[j], ring)
+            s = s.rem(G)
+            if s:
+                return False
+
+    return True
+
+
+def is_minimal(G, ring):
+    """
+    Checks if G is a minimal Groebner basis.
+    """
+    order = ring.order
+    domain = ring.domain
+
+    G.sort(key=lambda g: order(g.LM))
+
+    for i, g in enumerate(G):
+        if g.LC != domain.one:
+            return False
+
+        for h in G[:i] + G[i + 1:]:
+            if monomial_divides(h.LM, g.LM):
+                return False
+
+    return True
+
+
+def is_reduced(G, ring):
+    """
+    Checks if G is a reduced Groebner basis.
+    """
+    order = ring.order
+    domain = ring.domain
+
+    G.sort(key=lambda g: order(g.LM))
+
+    for i, g in enumerate(G):
+        if g.LC != domain.one:
+            return False
+
+        for term in g.terms():
+            for h in G[:i] + G[i + 1:]:
+                if monomial_divides(h.LM, term[0]):
+                    return False
+
+    return True
+
+def groebner_lcm(f, g):
+    """
+    Computes LCM of two polynomials using Groebner bases.
+
+    The LCM is computed as the unique generator of the intersection
+    of the two ideals generated by `f` and `g`. The approach is to
+    compute a Groebner basis with respect to lexicographic ordering
+    of `t*f` and `(1 - t)*g`, where `t` is an unrelated variable and
+    then filtering out the solution that does not contain `t`.
+
+    References
+    ==========
+
+    .. [1] [Cox97]_
+
+    """
+    if f.ring != g.ring:
+        raise ValueError("Values should be equal")
+
+    ring = f.ring
+    domain = ring.domain
+
+    if not f or not g:
+        return ring.zero
+
+    if len(f) <= 1 and len(g) <= 1:
+        monom = monomial_lcm(f.LM, g.LM)
+        coeff = domain.lcm(f.LC, g.LC)
+        return ring.term_new(monom, coeff)
+
+    fc, f = f.primitive()
+    gc, g = g.primitive()
+
+    lcm = domain.lcm(fc, gc)
+
+    f_terms = [ ((1,) + monom, coeff) for monom, coeff in f.terms() ]
+    g_terms = [ ((0,) + monom, coeff) for monom, coeff in g.terms() ] \
+            + [ ((1,) + monom,-coeff) for monom, coeff in g.terms() ]
+
+    t = Dummy("t")
+    t_ring = ring.clone(symbols=(t,) + ring.symbols, order=lex)
+
+    F = t_ring.from_terms(f_terms)
+    G = t_ring.from_terms(g_terms)
+
+    basis = groebner([F, G], t_ring)
+
+    def is_independent(h, j):
+        return not any(monom[j] for monom in h.monoms())
+
+    H = [ h for h in basis if is_independent(h, 0) ]
+
+    h_terms = [ (monom[1:], coeff*lcm) for monom, coeff in H[0].terms() ]
+    h = ring.from_terms(h_terms)
+
+    return h
+
+def groebner_gcd(f, g):
+    """Computes GCD of two polynomials using Groebner bases. """
+    if f.ring != g.ring:
+        raise ValueError("Values should be equal")
+    domain = f.ring.domain
+
+    if not domain.is_Field:
+        fc, f = f.primitive()
+        gc, g = g.primitive()
+        gcd = domain.gcd(fc, gc)
+
+    H = (f*g).quo([groebner_lcm(f, g)])
+
+    if len(H) != 1:
+        raise ValueError("Length should be 1")
+    h = H[0]
+
+    if not domain.is_Field:
+        return gcd*h
+    else:
+        return h.monic()

llmeval-env/lib/python3.10/site-packages/sympy/polys/heuristicgcd.py

@@ -0,0 +1,149 @@
+"""Heuristic polynomial GCD algorithm (HEUGCD). """
+
+from .polyerrors import HeuristicGCDFailed
+
+HEU_GCD_MAX = 6
+
+def heugcd(f, g):
+    """
+    Heuristic polynomial GCD in ``Z[X]``.
+
+    Given univariate polynomials ``f`` and ``g`` in ``Z[X]``, returns
+    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
+    such that::
+
+          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)
+
+    The algorithm is purely heuristic which means it may fail to compute
+    the GCD. This will be signaled by raising an exception. In this case
+    you will need to switch to another GCD method.
+
+    The algorithm computes the polynomial GCD by evaluating polynomials
+    ``f`` and ``g`` at certain points and computing (fast) integer GCD
+    of those evaluations. The polynomial GCD is recovered from the integer
+    image by interpolation. The evaluation process reduces f and g variable
+    by variable into a large integer. The final step is to verify if the
+    interpolated polynomial is the correct GCD. This gives cofactors of
+    the input polynomials as a side effect.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.heuristicgcd import heugcd
+    >>> from sympy.polys import ring, ZZ
+
+    >>> R, x,y, = ring("x,y", ZZ)
+
+    >>> f = x**2 + 2*x*y + y**2
+    >>> g = x**2 + x*y
+
+    >>> h, cff, cfg = heugcd(f, g)
+    >>> h, cff, cfg
+    (x + y, x + y, x)
+
+    >>> cff*h == f
+    True
+    >>> cfg*h == g
+    True
+
+    References
+    ==========
+
+    .. [1] [Liao95]_
+
+    """
+    assert f.ring == g.ring and f.ring.domain.is_ZZ
+
+    ring = f.ring
+    x0 = ring.gens[0]
+    domain = ring.domain
+
+    gcd, f, g = f.extract_ground(g)
+
+    f_norm = f.max_norm()
+    g_norm = g.max_norm()
+
+    B = domain(2*min(f_norm, g_norm) + 29)
+
+    x = max(min(B, 99*domain.sqrt(B)),
+            2*min(f_norm // abs(f.LC),
+                  g_norm // abs(g.LC)) + 4)
+
+    for i in range(0, HEU_GCD_MAX):
+        ff = f.evaluate(x0, x)
+        gg = g.evaluate(x0, x)
+
+        if ff and gg:
+            if ring.ngens == 1:
+                h, cff, cfg = domain.cofactors(ff, gg)
+            else:
+                h, cff, cfg = heugcd(ff, gg)
+
+            h = _gcd_interpolate(h, x, ring)
+            h = h.primitive()[1]
+
+            cff_, r = f.div(h)
+
+            if not r:
+                cfg_, r = g.div(h)
+
+                if not r:
+                    h = h.mul_ground(gcd)
+                    return h, cff_, cfg_
+
+            cff = _gcd_interpolate(cff, x, ring)
+
+            h, r = f.div(cff)
+
+            if not r:
+                cfg_, r = g.div(h)
+
+                if not r:
+                    h = h.mul_ground(gcd)
+                    return h, cff, cfg_
+
+            cfg = _gcd_interpolate(cfg, x, ring)
+
+            h, r = g.div(cfg)
+
+            if not r:
+                cff_, r = f.div(h)
+
+                if not r:
+                    h = h.mul_ground(gcd)
+                    return h, cff_, cfg
+
+        x = 73794*x * domain.sqrt(domain.sqrt(x)) // 27011
+
+    raise HeuristicGCDFailed('no luck')
+
+def _gcd_interpolate(h, x, ring):
+    """Interpolate polynomial GCD from integer GCD. """
+    f, i = ring.zero, 0
+
+    # TODO: don't expose poly repr implementation details
+    if ring.ngens == 1:
+        while h:
+            g = h % x
+            if g > x // 2: g -= x
+            h = (h - g) // x
+
+            # f += X**i*g
+            if g:
+                f[(i,)] = g
+            i += 1
+    else:
+        while h:
+            g = h.trunc_ground(x)
+            h = (h - g).quo_ground(x)
+
+            # f += X**i*g
+            if g:
+                for monom, coeff in g.iterterms():
+                    f[(i,) + monom] = coeff
+            i += 1
+
+    if f.LC < 0:
+        return -f
+    else:
+        return  f