a RG5d@sdZddlmZmZmZddlmZddl m Z ddl m Z ddl mZddlmZdd d Zd d Zd dZddZddZddZddZddZddZddZddZdd d!Zd"d#Zdd$d%Zd&d'Zd(d)Z d*d+Z!d,d-Z"d.d/Z#d0d1Z$d2d3Z%d4d5Z&d6d7Z'd8d9Z(d:d;Z)dd?Z+d@dAZ,dBdCZ-dDdEZ.dFdGZ/dHdIZ0dJdKZ1dLdMZ2dNdOZ3dPdQZ4dRdSZ5dTdUZ6dVdWZ7dXdYZ8dZd[Z9d\d]Z:d^d_Z;d`daZdfdgZ?dhdiZ@djdkZAdldmZBdndoZCdpdqZDdrdsZEeDeEdtZFdudvZGdwdxZHdydzZIdd|d}ZJd~dZKddZLddZMddZNddZOddZPddZQddZRddZSeMeReSdZTdddZUddZVddZWddZXddZYdddZZddZ[dS)zADense univariate polynomials with coefficients in Galois fields. )ceilsqrtprod)uniform) SYMPY_INTS)query)ExactQuotientFailed) _sort_factorsNc Cs^t||jd}|j}t||D]6\}}||}|||\}} } |||||7}q||S)aH 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 start)ronezerozipgcdex) UMKpvumes_rS/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/polys/galoistools.pygf_crt s"rcCsXgg}}t||jd}|D]0}||||||d|d|q|||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]) r r)rr appendr)rrESrrrrrgf_crt19s   r!c Cs>|j}t||||D] \}}} } || || |7}q||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 )r r) rrrrr rrrrrrrrrgf_crt2Qsr"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 Nrarrrrgf_intms 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 lenfrrr 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 rNr 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 rNr-r.rrrgf_TCsr0cCs<|r |dr|Sd}|D]}|r&q0q|d7}q||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  r3cstfdd|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 zgf_trunc..)r3r+rrr6rgf_truncs r:cCsttt|||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] )r:listmapr+rrrrr gf_normalsr>cCst|g}}t|trHt|ddD]}||||j|q(n2|\}t|ddD]}|||f|j|qZt||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 isinstancerrangergetr r:)r+rrnhr1rrr gf_from_dicts rFTcCsVt|i}}td|dD]4}|r8t||||}n |||}|r|||<q|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,rBr&)r+r symmetricrDresultr1r%rrr gf_to_dicts  rIcCs t||S)z 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] )r:r9rrrgf_from_int_poly2s rJcs|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&)r5cr6rrr7Sr8z"gf_to_int_poly..Nr)r+rrGrr6rgf_to_int_polyBsrLcsfdd|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)r5r2r6rrr7fr8zgf_neg..rr=rr6rgf_negXsrMcCsN|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] rr'Nr(r+r%rrrrr gf_add_groundis  rOcCsP|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] rr'Nr(rNrrr gf_sub_grounds  rPcs 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)r5br$rrr7r8z!gf_mul_ground..NrrNrr$r gf_mul_groundsrRcCst||||||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] )rRinvertrNrrr gf_quo_groundsrTcs|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|]\}}||qSrrr5r%rQr6rrr7r8zgf_add..Ncsg|]\}}||qSrrrUr6rrr7r8)r,r3rabsr+grrdfdgr1rErr6rgf_adds r[cs|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|]\}}||qSrrrUr6rrr7r8zgf_sub..Ncsg|]\}}||qSrrrUr6rrr7 r8)rMr,r3rrVrWrr6rgf_subs  "r\c Cst|}t|}||}dg|d}td|dD]R}|j} ttd||t||dD]} | || ||| 7} q\| |||<q4t|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,rBr r?minr3) r+rXrrrYrZdhrEir2jrrrgf_mul s"rbc Cst|}d|}dg|d}td|dD]}|j}td||}t||} | |d} || dd} t|| dD]} ||| ||| 7}qx||7}| d@r|| d} || d7}||||<q,t|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]) r+rrrYr_rEr`r2jminjmaxrDraelemrrrgf_sqr+s"    rfcCst|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] )r[rbr+rXrErrrrr gf_add_mulVs rhcCst|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] )r\rbrgrrr gf_sub_mulesricCsNt|tr|\}}n|j}|g}|D]$\}}t||||}t||||}q$|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] )rAtupler gf_powrb)FrrlcrXr+r1rrr gf_expandvs   rnc Cst|}t|}|stdn||kr.g|fS||d|}t||||d}}} td|dD]p} || } ttd|| t|| | dD]$} | || | |||| 8} q| |kr| |9} | ||| <qh|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]_ polynomial divisionrr'N)r,ZeroDivisionErrorrSr;rBr?r^r3 r+rXrrrYrZinvrEZdqdrr`r2rarrrgf_divs  &"rtcCst||||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')rtr+rXrrrrrgf_remsrvc Cst|}t|}|stdn ||kr*gS||d|}|dd|||d}}} td|dD]d} || } ttd|| t|| | dD]$} | || | |||| 8} q| |||| <qh|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] rorNr')r,rprSrBr?r^rqrrrgf_quos  &"rwcCs(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)rtr)r+rXrrqrrrrgf_exquosrzcCs|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] Nr-r+rDrrrr gf_lshiftsr|cCs,|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]) Nrr{rrr gf_rshift/sr}cCsr|s |jgS|dkr|S|dkr,t|||S|jg}|d@rRt||||}|d8}|dL}|s`qnt|||}q4|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#)r rfrb)r+rDrrrErrrrkCs rkcCst|}|dkrgSdg|}dg|d<||krhtd|D]*}t||d||}t||||||<q:nh|dkrt|j|jg|||||d<td|D]8}t||d|d||||<t|||||||<q|S)ah 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]] rr'r#)r,rBr|rv gf_pow_modr r rb)rXrrrDrQr`monrrrgf_frobenius_monomial_basehs  rc Cs|t|}t||kr"t||||}|s*gSt|}|dg}td|dD],}t|||||||} t|| ||}qJ|S)aS 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] rr')r,rvrBrRr[) r+rXrQrrrrDsfr`rrrrgf_frobenius_maps  rc Csnt||||}|}|}td|D]0}t|||||}t||||}t||||}q t||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#)rvrBrrbr~) r+rDrXrQrrrEryr`resrrr_gf_pow_pnm1d2srcCs|s |jgS|dkr"t||||S|dkr@tt||||||S|jg}|d@rtt||||}t||||}|d8}|dL}|sqt|||}t||||}qH|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#)r rvrfrb)r+rDrXrrrErrrr~s" r~cCs*|r|t||||}}qt|||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')rvgf_monicrurrrgf_gcdsrcCs>|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')rwrbrrr+rXrrrErrrgf_lcms rcCs>|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]) )rrwrrrr gf_cofactorss   rcCs|s|s|jgggfSt|||\}}t|||\}}|sNg|||g|fS|sf|||gg|fS|||gg}} g|||g} } t||||\} } | sqt| |||\}}}|||}t|| | ||}t| | | ||}t||||| } }t||||| } } q| | |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]_ )r rrSrtrirR)r+rXrrp0r0p1r1s0s1t0t1QRrmrrrtrrrgf_gcdex1s(! rcCsB|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)r is_oner;rT)r+rrrmrrrrss    rcCs`t|}|jg||}}|ddD]0}|||9}||;}|rN||||<|d8}q&t|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] Nrr')r,r r3)r+rrrYrErDr2rrrgf_diffs   rcCs,|j}|D]}||9}||7}||;}q |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%rrrHrKrrrgf_evals  rcsfdd|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|qSrrr4rr+rrrr7r8z!gf_multi_eval..r)r+Arrrrr gf_multi_evalsrcCsjt|dkr&tt|t||||gS|s.gS|dg}|ddD] }t||||}t||||}qD|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)r3rr/rbrO)r+rXrrrErKrrr gf_composes  rcCsR|sgS|dg}|ddD].}t||||}t||||}t||||}q|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)rbrOrv)rXrEr+rrcompr%rrrgf_compose_mods rc Cst|||||}|}|d@r0t||||} |} n|} |} |dL}|rt|t|||||||}t|||||}|d@rt| t|| |||||} t|| |||} |dL}q@t|| |||| 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')rr[) r%rQrKrDr+rrrrrVrrr gf_trace_map s  rc CsVt||||}|}|}td|D]0}t|||||}t||||}t||||}q |S)z& utility for ``gf_edf_shoup`` r')rvrBrr[) r+rDrXrQrrrEryr`rrr _gf_trace_mapBsrcs"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|]}ttdqSr)intrr5r`rrrrr7]r8zgf_random..r)r rB)rDrrrrr gf_randomPs rcCs"t|||}t|||r|SqdS)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)rDrrr+rrrgf_irreducible`s  rc Cs(t|}|dkrdSt|||\}}|dkrt|j|jg||||}}td|dD]H}t||j|jg||}t|||||jgkrt|||||}qVdSqVnt |||} t |j|jg|| ||}}td|dD]J}t||j|jg||}t|||||jgkrt ||| ||}qdSqdS)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,rr~r r rBr\rrrr) r+rrrDrHrEr`rXrQrrrgf_irred_p_ben_orss&  rc st|dkrdSt|||\}}|j|jg}ddlm}fdd|D}t|||}|d}tdD]F} | |vrt||||} t || |||jgkrdSt |||||}qp||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'Tr factorintcsh|] }|qSrr)r5drDrr r8z#gf_irred_p_rabin..F) r,rr r sympy.ntheoryrrrBr\rr) r+rrrxrindicesrQrEr`rXrrrgf_irred_p_rabins    r)zben-orZrabincCs2td}|dur"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)rrrr )r+rrrrrrgf_sqf_psrcCs8t|||\}}|jg}|D]\}}t||||}q|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_listr rb)r+rrrsqfrXrrr gf_sqf_parts  rFcCs\ddgt|f\}}}}t|||\}}t|dkr<|gfSt|||} | gkrt|| ||} t|| ||} d} | |jgkrt| | ||} t| | ||}t|dkr||| |ft| | ||| | d} } } qp| |jgkrd}n| }|sFt||}td|dD]} || ||| <q |d|d||}}q<qFq<|rTt 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``) 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]_ r'FrTNz'all=True' is not supported yet) rrr,rrrwr rrB ValueError)r+rrallrDrfactorsryrmrlrXrEr`Grrrrrrs6+       rc Cst|t|}}|jg|jg|d}t|ggg|d}td|d|dD]z}|d |d|g|d}} td|D],} ||| d| || d|q||st||||<|}qX|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,rr r r;rBr) r+rrrDryrxrr`qqrKrarrr gf_Qmatrixts"*rc Csdd|Dt|}}td|D]"}||||j||||<q"td|D]}t||D]}|||r`qxq`qP|||||}td|D] }||||||||<qtd|D]0}|||}||||||<||||<qtd|D]V}||kr|||} td|D].}||||||| ||||<q"qqPtd|D]\}td|D]J}||kr|j|||||||<n||| ||||<qpqbg} |D]} t| r| | q| S)a_ 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]] cSsg|] }t|qSr)r;)r5rxrrrr7r8zgf_Qbasis..r)r)rBr rSanyr) rrrrDr1r`rrrarrxbasisrrr gf_Qbasiss<     2  " rc Cs t|||}t|||}t|D]\}}ttt|||<q |g}tdt|D]}t|D]}|j} | |kr^t ||| ||} t || ||} | |j gkr| |kr| |t || ||}||| gt|t|krt|ddS| |j 7} qhq^qRt|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'Fmultiple)rr enumerater3r;reversedrBr)r rPrr removerwextendr ) r+rrrrr`rrr1rrXrErrr gf_berlekamps&    rcCsd|j|jgg}}}t|||}d|t|krt|||||}t|t||j|jg||||}||jgkr|||ft||||}t ||||}t|||}|d7}q$||jgkr||t|fgS|SdS)a{ 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) r r rr,rrr\rrwrv)r+rrr`rXrrQrErrrgf_ddf_zassenhauss#      rc Cs8|g}t||kr|St||}|dkr6t|||}|j|jg}t||kr,|dkr|}} t|dD]"} t| d|||} t|| ||}qlt||||} ||j|jg7}n@t d|d||} t | |||||}t|t ||j||||} | |jgkrB| |krBt | |||t t || |||||}qBt|ddS)a 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 r#r'Fr)r,rr r r)rBr~r[rrrrPgf_edf_zassenhausrwr ) r+rDrrrNrQrrEryr`rXrrrr?s.      rcCst|}ttt|d}t|||}t|j|jg||||}|j|jg|g|jg|d}td|dD] }t||d||||||<qn|||d|}}|g|jg|d} td|D] }t | |d||||| |<qg} t | D]\}} |jg|d}} |D]0} t | | ||}t ||||}t ||||}qt||||}t||||}t|D]b} t | | ||}t||||}||jgkr| |||d| ft||||| d}} qhq||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_sqrtrrr r rBrrr\rbrvrrwrr)r+rrrDr1rQrErr`rrrrarrXrlrrr gf_ddf_shoups:    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#Fr)r,rr r rr~rrrw gf_edf_shouprrrPrbr )r+rDrrrrxrrryrErh1h2rQh3rrrrs6      rcCs8g}t|||D]\}}|t||||7}qt|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]] Fr)rrr r+rrrfactorrDrrr gf_zassenhaus srcCs8g}t|||D]\}}|t||||7}qt|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]] Fr)rrr rrrrgf_shoup sr)Z berlekampZ zassenhausZshoupcCs^t|||\}}t|dkr$|gfS|p.td}|durJt||||}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)rr,r_factor_methodsr)r+rrrrmrrrr gf_factor_sqf<s   rcCsrt|||\}}t|dkr$|gfSg}t|||dD],\}}t|||dD]}|||fqPq8|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 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]_ r')rr,rrrr )r+rrrmrrXrDrErrr gf_factorYs2 rcCs"d}|D]}||9}||7}q|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%rHrKrrrgf_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. References ========== .. [1] https://en.wikipedia.org/wiki/Linear_congruence_theorem r)rcs(g|] }|qSrr)r5rrQrXrryrrr7r8z%linear_congruence..)sympy.polys.polytoolsrr;rB)r%rQrrrrrrlinear_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] rZZ)sympy.polys.domainsrrrr)rrrr+rZf_falphabetarrr_raise_mod_powers !   rr'csddlmfddtD}|dkr2|Sg}tt|dgt|}|r|\}||krr|qN|d||fddt |DqNt |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). rrcs"g|]}t|dkr|qSrrr)rr+rrrr7 r8z csolve_prime..r'csg|]}|fqSrr)r5r)psrrrrr7 r8) rrrBr;rr)poprrrsorted)r+rrZX1Xr rr)rr+rrrrr csolve_primes   (rcsddlmddlm}||}fdd|D}ttt|}gg}|D]fdd|D}qNdd|Dtfdd|DS) a= 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. rrrcsg|]\}}t||qSr)rr5rrr*rrr75 r8zgf_csolve..cs g|]}D]}||gq qSrr)r5ry)poolrrr79 r8cSsg|]\}}t||qSr)powrrrrr7: r8csg|]}t|qSr)r)r5per)r dist_factorsrrr7; r8) rrrritemsr;r<rjr)r+rDrPrpoolspermsr)rrr+rr gf_csolve s  r)N)T)T)F)N)r')\__doc__mathrrrrrsympy.core.randomrsympy.external.gmpyrsympy.polys.polyconfigrsympy.polys.polyerrorsrsympy.polys.polyutilsr rr!r"r&r,r/r0r3r:r>rFrIrJrLrMrOrPrRrTr[r\rbrfrhrirnrtrvrwrzr|r}rkrrrr~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrs      -  ##+6'% %1B7-, Y(>,9@L? @#( "