B [@sdZddlmZmZddlmZddlmZm Z ddl m Z m Z ddlmZddlmZddlmZdd lmZdd lmZdd d ZddZddZddZddZddZddZddZddZ ddZ!d d!Z"dd#d$Z#d%d&Z$dd'd(Z%d)d*Z&d+d,Z'd-d.Z(d/d0Z)d1d2Z*d3d4Z+d5d6Z,d7d8Z-d9d:Z.d;d<Z/d=d>Z0d?d@Z1dAdBZ2dCdDZ3dEdFZ4dGdHZ5dIdJZ6dKdLZ7dMdNZ8dOdPZ9dQdRZ:dSdTZ;dUdVZd[d\Z?d]d^Z@d_d`ZAdadbZBdcddZCdedfZDdgdhZEdidjZFdkdlZGdmdnZHdodpZIdqdrZJdsdtZKdudvZLeKeLdwZMdxdyZNdzd{ZOd|d}ZPdddZQddZRddZSddZTddZUddZVddZWddZXddZYddZZeTeYeZdZ[dddZ\ddZ]ddZ^ddZ_ddZ`dddZaddZbd S)zADense univariate polynomials with coefficients in Galois fields. )print_functiondivision)uniform)ceilsqrt) SYMPY_INTSrange)prod) _sort_factors)query)ExactQuotientFailed) factorintNc Csbt||jd}|j}xDt||D]6\}}||}|||\}} } |||||7}q W||S)ay 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``. As an example 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 >>> from sympy.ntheory.modular import solve_congruence >>> 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 )start)r onezerozipgcdex) UMKpvumes_r6lib/python3.7/site-packages/sympy/polys/galoistools.pygf_crts rcCs\gg}}t||jd}x8|D]0}||||||d|d|qW|||fS)a 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]) )rr)r rappendr)rrESrrrrrgf_crt1;s   "r$c CsB|j}x2t||||D] \}}} } || || |7}qW||S)a` 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 )rr) rrrr"r#rrrrrrrrrgf_crt2Ssr%cCs||dkr|S||SdS)z 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 Nr)arrrrgf_intos r(cCs t|dS)z Return the leading degree of ``f``. Examples ======== >>> from sympy.polys.galoistools import gf_degree >>> gf_degree([1, 1, 2, 0]) 3 >>> gf_degree([]) -1 )len)frrr gf_degreesr,cCs|s |jS|dSdS)z 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 rN)r)r+rrrrgf_LCsr-cCs|s |jS|dSdS)z 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 r N)r)r+rrrrgf_TCsr.cCs>|r |dr|Sd}x|D]}|r&Pq|d7}qW||dS)z Remove leading zeros from ``f``. Examples ======== >>> from sympy.polys.galoistools import gf_strip >>> gf_strip([0, 0, 0, 3, 0, 1]) [3, 0, 1] rr)Nr)r+kcoeffrrrgf_strips   r1cstfdd|DS)z Reduce all coefficients modulo ``p``. Examples ======== >>> from sympy.polys.galoistools import gf_trunc >>> gf_trunc([7, -2, 3], 5) [2, 3, 3] csg|] }|qSrr).0r')rrr szgf_trunc..)r1)r+rr)rrgf_truncs r4cCsttt|||S)z 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] )r4listmap)r+rrrrr gf_normalsr7cCst|g}}t|trLxdt|ddD]}||||j|q*Wn6|\}x.t|ddD]}|||f|j|q`Wt||S)a 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] r ) maxkeys isinstancerrr!getrr4)r+rrnhr/rrr gf_from_dicts r>TcCsZt|i}}xFtd|dD]4}|r:t||||}n |||}|r|||<qW|S)aA 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} rr))r,rr()r+r symmetricr<resultr/r'rrr gf_to_dicts  rAcCs t||S)z Create a ``GF(p)[x]`` polynomial from ``Z[x]``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_from_int_poly >>> gf_from_int_poly([7, -2, 3], 5) [2, 3, 3] )r4)r+rrrrgf_from_int_poly4srBcs|rfdd|DS|SdS)a  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] csg|]}t|qSr)r()r2c)rrrr3Vsz"gf_to_int_poly..Nr)r+rr?r)rrgf_to_int_polyEsrDcsfdd|DS)z 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] csg|]}| qSrr)r2r0)rrrr3iszgf_neg..r)r+rrr)rrgf_neg[srEcCsN|s||}n.|d||}t|dkr<|dd|gS|sDgS|gSdS)a  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] r r)N)r*)r+r'rrrrr gf_add_groundls  rFcCsP|s| |}n.|d||}t|dkr>|dd|gS|sFgS|gSdS)a  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] r r)N)r*)r+r'rrrrr gf_sub_grounds  rGcs sgSfdd|DSdS)a  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] csg|]}|qSrr)r2b)r'rrrr3sz!gf_mul_ground..Nr)r+r'rrr)r'rr gf_mul_groundsrIcCst||||||S)a 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] )rIinvert)r+r'rrrrr gf_quo_groundsrKcs|s|S|s|St|}t|}||krDtfddt||DSt||}||krt|d|||d}}n|d|||d}}|fddt||DSdS)z 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] csg|]\}}||qSrr)r2r'rH)rrrr3szgf_add..Ncsg|]\}}||qSrr)r2r'rH)rrrr3s)r,r1rabs)r+grrdfdgr/r=r)rrgf_adds rPcs|s|S|st||St|}t|}||krLtfddt||DSt||}||kr||d|||d}}n"t|d||||d}}|fddt||DSdS)z 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] csg|]\}}||qSrr)r2r'rH)rrrr3szgf_sub..Ncsg|]\}}||qSrr)r2r'rH)rrrr3 s)rEr,r1rrL)r+rMrrrNrOr/r=r)rrgf_subs  "rQc Cst|}t|}||}dg|d}xhtd|dD]V}|j} x>ttd||t||dD]} | || ||| 7} q`W| |||<q6Wt|S)z 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] rr))r,rrr8minr1) r+rMrrrNrOdhr=ir0jrrrgf_muls$rVc Cst|}d|}dg|d}xtd|dD]}|j}td||}t||} | |d} || dd} x.t|| dD]} ||| ||| 7}q|W||7}| d@r|| d} || d7}||||<q.Wt|S)z 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] r&rr))r,rrr8rRr1) r+rrrNrSr=rTr0ZjminZjmaxr<rUelemrrrgf_sqr.s"    rXcCst|t||||||S)a 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] )rPrV)r+rMr=rrrrr gf_add_mulYs rYcCst|t||||||S)a 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] )rQrV)r+rMr=rrrrr gf_sub_mulhsrZcCsTt|tkr|\}}n|j}|g}x,|D]$\}}t||||}t||||}q(W|S)a 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] )typetuplergf_powrV)FrrlcrMr+r/rrr gf_expandys  r`c Cst|}t|}|stdn||kr.g|fS||d|}t||||d}}} xtd|dD]t} || } xJttd|| t|| | dD]$} | || | |||| 8} qW| |kr| |9} | ||| <qjW|d|dt||ddfS)a 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]_ zpolynomial divisionrr)N)r,ZeroDivisionErrorrJr5rr8rRr1) r+rMrrrNrOinvr=dqdrrTr0rUrrrgf_divs  ($recCst||||dS)z 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] r))re)r+rMrrrrrgf_remsrfc Cst|}t|}|stdn ||kr*gS||d|}|dd|||d}}} xztd|dD]h} || } xJttd|| t|| | dD]$} | || | |||| 8} qW| |||| <qjW|d|dS)aG 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] zpolynomial divisionrNr))r,rarJrr8rR) r+rMrrrNrOrbr=rcrdrTr0rUrrrgf_quos  ($rgcCs(t||||\}}|s|St||dS)a 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] N)rer )r+rMrrqrrrrgf_exquosrjcCs|s|S||jg|SdS)z 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] N)r)r+r<rrrr gf_lshiftsrkcCs,|s |gfS|d| || dfSdS)z 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]) Nr)r+r<rrrr gf_rshift2srlcCsv|s |jgS|dkr|S|dkr,t|||S|jg}x<|d@rTt||||}|d8}|dL}|sbPt|||}q6W|S)z 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] r)r&)rrXrV)r+r<rrr=rrrr]Fs  r]cCst|}|dkrgSdg|}dg|d<||krlxtd|D]*}t||d||}t||||||<q>> 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]] rr)r&)r,rrkrf gf_pow_modrrrV)rMrrr<rHrTZmonrrrgf_frobenius_monomial_baseks  rnc Cst|}t||kr"t||||}|s*gSt|}|dg}x>td|dD],}t|||||||} t|| ||}qLW|S)aT 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] r r))r,rfrrIrP) r+rMrHrrrr<ZsfrTrrrrgf_frobenius_maps  roc Csrt||||}|}|}x>td|D]0}t|||||}t||||}t||||}q"Wt||dd|||} | S)z 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)`` r)r&)rfrrorVrm) r+r<rMrHrrr=rirTZresrrr_gf_pow_pnm1d2srpcCs|s |jgS|dkr"t||||S|dkr@tt||||||S|jg}xX|d@rvt||||}t||||}|d8}|dL}|sPt|||}t||||}qJW|S)a& 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]_ r)r&)rrfrXrV)r+r<rMrrr=rrrrms$ rmcCs.x|r|t||||}}qWt|||dS)z 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] r))rfgf_monic)r+rMrrrrrgf_gcdsrrcCs>|r|s gStt||||t||||||}t|||dS)z 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] r))rgrVrrrq)r+rMrrr=rrrgf_lcms rscCs>|s|sgggfSt||||}|t||||t||||fS)a  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]) )rrrg)r+rMrrr=rrr gf_cofactorss  rtcCs |s|s|jgggfSt|||\}}t|||\}}|sNg|||g|fS|sf|||gg|fS|||gg}} g|||g} } xt||||\} } | sPt| |||\}}}|||}t|| | ||}t| | | ||}t||||| } }t||||| } } qW| | |fS)a 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]_ )rrqrJrerZrI)r+rMrrZp0Zr0Zp1Zr1Zs0s1Zt0Zt1QRr_rbrtrrrgf_gcdex4s*! rycCsB|s|jgfS|d}||r,|t|fS|t||||fSdS)z 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]) rN)rZis_oner5rK)r+rrr_rrrrqvs    rqcCsdt|}|jg||}}x@|ddD]0}|||9}||;}|rP||||<|d8}q(Wt|S)z 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] Nr r))r,rr1)r+rrrNr=r<r0rrrgf_diffs   rzcCs0|j}x$|D]}||9}||7}||;}q W|S)z 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 )r)r+r'rrr@rCrrrgf_evals   r{csfdd|DS)a  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] csg|]}t|qSr)r{)r2r')rr+rrrr3sz!gf_multi_eval..r)r+Arrr)rr+rr gf_multi_evalsr}cCsnt|dkr&tt|t||||gS|s.gS|dg}x0|ddD] }t||||}t||||}qFW|S)a 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] r)rN)r*r1r{r-rVrF)r+rMrrr=rCrrr gf_composes  r~cCsV|sgS|dg}x>|ddD].}t||||}t||||}t||||}q W|S)a& 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] rr)N)rVrFrf)rMr=r+rrcompr'rrrgf_compose_mods rc Cst|||||}|}|d@r0t||||} |} n|} |} |dL}xl|rt|t|||||||}t|||||}|d@rt| t|| |||||} t|| |||} |dL}qBWt|| |||| fS)a 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]_ r))rrP) r'rHrCr<r+rrrrrVrrr gf_trace_maps  rc CsZt||||}|}|}x>td|D]0}t|||||}t||||}t||||}q"W|S)z& utility for ``gf_edf_shoup`` r))rfrrorP) r+r<rMrHrrr=rirTrrr _gf_trace_mapEsrcs"jgfddtd|DS)a 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] csg|]}ttdqS)r)intr)r2rT)rrrrr3`szgf_random..r)rr)r<rrr)rrr gf_randomSs rcCs&x t|||}t|||r|SqWdS)a, 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] N)rgf_irreducible_p)r<rrr+rrrgf_irreduciblecs   rc Cs,t|}|dkrdSt|||\}}|dkrt|j|jg||||}}xtd|dD]F}t||j|jg||}t|||||jgkrt|||||}qXdSqXWnt |||} t |j|jg|| ||}}xZtd|dD]H}t||j|jg||}t|||||jgkr t ||| ||}qdSqWdS)a_ 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 r)Trr&F) r,rqrmrrrrQrrrrnro) r+rrr<rHr=rTrMrHrrrgf_irred_p_ben_orvs&  rc st|dkrdSt|||\}}|j|jg}fddtD}t|||}|d}xRtdD]D}||krt||||} t|| |||jgkrdSt |||||}qfW||kS)a[ 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 r)Tcsh|] }|qSrr)r2d)r<rr sz#gf_irred_p_rabin..F) r,rqrrr rnrrQrrro) r+rrrxindicesrHr=rTrMr)r<rgf_irred_p_rabins  r)zben-orZrabincCs2td}|dk r"t||||}n t|||}|S)a[ 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 ZGF_IRRED_METHODN)r _irred_methodsr)r+rrmethodZirredrrrrs  rcCs:t|||\}}|sdSt|t||||||jgkSdS)a5 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 TN)rqrrrzr)r+rrrrrrgf_sqf_psrcCs<t|||\}}|jg}x|D]\}}t||||}qW|S)a 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] ) gf_sqf_listrrV)r+rrrsqfrMrrr gf_sqf_parts rFcCshddgt|f\}}}}t|||\}}t|dkr<|gfSxt|||} | gkrt|| ||} t|| ||} d} xh| |jgkrt| | ||} t| | ||}t|dkr||| |ft| | ||| | d} } } qvW| |jgkrd}n| }|sLt||}x(td|dD]} || ||| <qW|d|d||}}q@Pq@W|r`t d||fS)a 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``) aren't 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 doesn't 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]_ r)FrTNz'all=True' is not supported yet) rrqr,rzrrrgrr!r ValueError)r+rrallr<rfactorsrir_r^rMr=rTGrrrrrrs8+   "  rc Cst|t|}}|jg|jg|d}t|ggg|d}xtd|d|dD]~}|d |d|g|d}} x:td|D],} ||| d| || d|qW||st||||<|}qZW|S)ad 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]] r)r )r,rrrr5rr!) r+rrr<rirhrvrTZqqrCrUrrr gf_Qmatrixus",rc Csdd|Dt|}}x0td|D]"}||||j||||<q$Wx&td|D]}x"t||D]}|||rjPqjWqX|||||}x.td|D] }||||||||<qWx>td|D]0}|||}||||||<||||<qWxhtd|D]Z}||kr|||} x>> 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]] cSsg|] }t|qSr)r5)r2rhrrrr3szgf_Qbasis..r)r*rrrJanyr!) rvrrr<r/rTrbrUrxrhZbasisrrr gf_Qbasiss<"     8  &  rc Cst|||}t|||}x(t|D]\}}ttt|||<q"W|g}xtdt|D]}xt|D]}|j} x| |krt ||| ||} t || ||} | |j gkr| |kr| |t || ||}||| gt|t|krt|ddS| |j 7} qrWqfWqXWt|ddS)a 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]] r)F)multiple)rr enumerater1r5reversedrr*rrGrrrremovergextendr ) r+rrrvrrTrrr/rrMr=rrr gf_berlekamps&     rcCsd|j|jgg}}}t|||}xd|t|krt|||||}t|t||j|jg||||}||jgkr|||ft||||}t ||||}t|||}|d7}q&W||jgkr||t|fgS|SdS)as 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]_ r)r&N) rrrnr,rorrrQr!rgrf)r+rrrTrMrrHr=rrrgf_ddf_zassenhauss#      rc Cs4|gt|}}t||kr |St||}|dkr@t|||}xt||kr&td|d||}|dkr|} x>> 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]] References ========== 1. [Gathen99]_ 2. [Geddes92]_ r&r)rF)r)rr,rnr*rrrmrPrrrprGrgf_edf_zassenhausrgr ) r+r<rrrrhNrHrir=rTrMrrrr@s(    rcCst|}ttt|d}t|||}t|j|jg||||}|j|jg|g|jg|d}x2td|dD] }t||d||||||<qpW|||d|}}|g|jg|d} x.td|D] }t | |d||||| |<qWg} xt | D]\}} |jg|d}} x8|D]0} t | | ||}t ||||}t ||||}qWt||||}t||||}xnt|D]b} t | | ||}t||||}||jgkr| |||d| ft||||| d}} qxWqW||jgkr| |t|f| S)a 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]_ r&r)N)r,r_ceil_sqrtrnrorrrrrrQrVrfrrrgrr!)r+rrr<r/rHr=rrTrrrrUrrMr^rrr gf_ddf_shoupxs:      $rcCsft|t|}}|sgS||kr(|gS|g|j|jg}}t|d||}|dkrt|||||} t|| ||d|||d} t|| ||} t|| ||} t | |||t | |||}nt |||} t |||| ||} t| |dd|||} t|| ||} t|t | |j||||} t|t | | ||||}t | |||t | |||t ||||}t|ddS)a 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]_ r)r&F)r)r,rrrrrmrrrrg gf_edf_shouprnrrGrVr )r+r<rrrrhrrrir=rZh1Zh2rHZh3rrrrs,  *rcCs<g}x*t|||D]\}}|t||||7}qWt|ddS)a 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]] F)r)rrr )r+rrrfactorr<rrr gf_zassenhaussrcCs<g}x*t|||D]\}}|t||||7}qWt|ddS)a 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]] F)r)rrr )r+rrrrr<rrrgf_shoupsr)Z berlekampZ zassenhausZshoupcCs^t|||\}}t|dkr$|gfS|p.td}|dk rJt||||}n t|||}||fS)a  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]]) r)ZGF_FACTOR_METHODN)rqr,r _factor_methodsr)r+rrrr_rrrr gf_factor_sqf5s   rcCszt|||\}}t|dkr$|gfSg}xDt|||dD]0\}}x&t|||dD]}|||fqTWq:W|t|fS)a 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 didn't 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]_ r))rqr,rrr!r )r+rrr_rrMr<r=rrr gf_factorRs2 rcCs&d}x|D]}||9}||7}q W|S)z 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 rr)r+r'r@rCrrrgf_values   rcspddlm}|dkr4dkr0ttSgS||\}dkrTgSfddtDS)a 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. **Reference** 1) Wikipedia http://en.wikipedia.org/wiki/Linear_congruence_theorem r)rcs(g|] }|qSrr)r2rx)rHrMrrirrr3sz%linear_congruence..)Zsympy.polys.polytoolsrr5r)r'rHrrrr)rHrMrrirlinear_congruences     rcCsBddlm}t|||}t||}t|| ||}t|||S)a0 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] r)ZZ)sympy.polys.domainsrrzrr)rrrr+rZf_fZalphaZbetarrr_raise_mod_powers !   rr)csddlmfddtD}|dkr2|Sg}tt|dgt|}x^|r|\}||krt|qP|d||fddt |DqPWt |S)aU 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). r)rcs"g|]}t|dkr|qS)r)r{)r2rT)rr+rrrr3 sz csolve_prime..r)csg|]}|fqSrr)r2r)psrurrrr3 s) rrrr5rr*popr!rrsorted)r+rrZX1Xr#rr)rr+rrrurr csolve_primes   *rcsddlmt|}fdd|D}ttt|}gg}x|D]fdd|D}qDWdd|Dtfdd|DS)a7 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. r)rcsg|]\}}t||qSr)r)r2rr)r+rrr3+ szgf_csolve..cs g|]}D]}||gq qSrr)r2ry)poolrrr3/ scSsg|]\}}t||qSr)pow)r2rrrrrr30 scsg|]}t|qSr)r)r2Zper)r dist_factorsrrr31 s)rrr itemsr5r6r\r)r+r<PrZpoolsZpermsr)rrr+rr gf_csolve s  r)N)T)T)F)N)r))c__doc__Z __future__rrZrandomrZmathrrrrZsympy.core.compatibilityrrZsympy.core.mulr Zsympy.polys.polyutilsr Zsympy.polys.polyconfigr Zsympy.polys.polyerrorsr Z sympy.ntheoryr rr$r%r(r,r-r.r1r4r7r>rArBrDrErFrGrIrKrPrQrVrXrYrZr`rerfrgrjrkrlr]rnrorprmrrrsrtryrqrzr{r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrs       +  ##+6'% %1B7-* Y(>,98L? @!( "