\c@ s~dZddlmZmZddlmZddlmZm Z ddl m Z m Z ddlmZddlmZddlmZdd lmZdd lmZdZd Zd Zd ZdZdZdZdZdZ dZ!dZ"dZ#e$dZ%dZ&e$dZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.d Z/d!Z0d"Z1d#Z2d$Z3d%Z4d&Z5d'Z6d(Z7d)Z8d*Z9d+Z:d,Z;d-Z<d.Z=d/Z>d0Z?d1Z@d2ZAd3ZBd4ZCd5ZDd6ZEd7ZFd8ZGd9ZHd:ZId;ZJd<ZKd=ZLd>ZMd?ZNieMd@6eNdA6ZOdBZPdCZQdDZReSdEZTdFZUdGZVdHZWdIZXdJZYdKZZdLZ[dMZ\dNZ]ieWdO6e\dP6e]dQ6Z^dZdRZ_dSZ`dTZadUZbdVZcdWdXZddYZedZS([sADense univariate polynomials with coefficients in Galois fields. i(tprint_functiontdivision(tuniform(tceiltsqrt(t SYMPY_INTStrange(tprod(t factorint(tquery(tExactQuotientFailed(t _sort_factorsc C st|d|j}|j}xXt||D]G\}}||}|j||\}} } |||||7}q.W||S(s 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 >>> 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 tstart(Rtonetzerotziptgcdex( tUtMtKtptvtutmtetst_((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_crts#  cC svgg}}t|d|j}xD|D]<}|j|||j|j|d|d|q)W|||fS(s 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 ii(RR tappendR(RRtEtSRR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_crt1>s   )c C sS|j}x?t||||D](\}}} } || || |7}qW||S(s` 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( RRRRRRRRRRR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_crt2Vs (cC s ||dkr|S||SdS(s 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 iN((taR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_intrscC st|dS(s Return the leading degree of ``f``. Examples ======== >>> from sympy.polys.galoistools import gf_degree >>> gf_degree([1, 1, 2, 0]) 3 >>> gf_degree([]) -1 i(tlen(tf((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_degreescC s|s |jS|dSdS(s 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 iN(R(R$R((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_LCscC s|s |jS|dSdS(s 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 iN(R(R$R((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_TCscC sH| s|dr|Sd}x"|D]}|r2Pq"|d7}q"W||S(s Remove leading zeros from ``f``. Examples ======== >>> from sympy.polys.galoistools import gf_strip >>> gf_strip([0, 0, 0, 3, 0, 1]) [3, 0, 1] ii((R$tktcoeff((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_strips cC s!tg|D]}||^q S(s Reduce all coefficients modulo ``p``. Examples ======== >>> from sympy.polys.galoistools import gf_trunc >>> gf_trunc([7, -2, 3], 5) [2, 3, 3] (R*(R$RR!((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_truncs cC sttt|||S(s 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+tlisttmap(R$RR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_normalscC st|jg}}t|trhxt|ddD]&}|j|j||j|q;WnI|\}x=t|ddD])}|j|j|f|j|qWt||S(s 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] i( tmaxtkeyst isinstanceRRRtgetRR+(R$RRtnthR(((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_from_dicts' 'cC svt|i}}x\td|dD]G}|rMt||||}n|||}|r'|||>> 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} ii(R%RR"(R$Rt symmetricR3tresultR(R!((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_to_dictscC s t||S(s 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] (R+(R$R((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_from_int_poly7scC s.|r&g|D]}t||^q S|SdS(s  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] N(R"(R$RR6tc((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_to_int_polyHs cC sg|D]}| |^qS(s 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] ((R$RRR)((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_neg^scC s[|s||}n3|d||}t|dkrF|d |gS|sPgS|gSdS(s  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] iiN(R#(R$R!RR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_add_groundos cC s\|s| |}n3|d||}t|dkrG|d |gS|sQgS|gSdS(s  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] iiN(R#(R$R!RR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_sub_groundscC s-|s gSg|D]}|||^qSdS(s  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] N((R$R!RRtb((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_mul_groundscC st||j||||S(s 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] (R@tinvert(R$R!RR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_quo_groundsc C s|s |S|s|St|}t|}||krltgt||D]\}}|||^qKSt||}||kr|| ||} }n|| ||} }| gt||D]\}}|||^qSdS(s 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] N(R%R*Rtabs( R$tgRRtdftdgR!R?R(R4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_adds   4 c C s|s |S|s t|||St|}t|}||krxtgt||D]\}}|||^qWSt||}||kr|| ||} }n!t|| ||||} }| gt||D]\}}|||^qSdS(s 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] N(R<R%R*RRC( R$RDRRRERFR!R?R(R4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_subs   4 !c C st|}t|}||}dg|d}xtd|dD]k}|j} xKttd||t||dD] } | || ||| 7} qW| |||>> 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] ii(R%RRR/tminR*( R$RDRRRERFtdhR4tiR)tj((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_muls    0c C st|}d|}dg|d}xtd|dD]}|j}td||}t||} | |d} || dd} x5t|| dD] } ||| ||| 7}qW||7}| d@r|| d} || d7}n||||>> 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] iii(R%RRR/RIR*( R$RRRERJR4RKR)tjmintjmaxR3RLtelem((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_sqr1s"     cC s"t|t||||||S(s 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] (RGRM(R$RDR4RR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_add_mul\s cC s"t|t||||||S(s 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] (RHRM(R$RDR4RR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_sub_mulkscC sxt|tkr!|\}}n |j}|g}x>|D]6\}}t||||}t||||}q:W|S(s 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] (ttypettupleR tgf_powRM(tFRRtlcRDR$R(((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_expand|s  c C sDt|}t|}|s-tdn||krCg|fS|j|d|}t||||d}}} xtd|dD]} || } xWttd|| t|| | dD](} | || | |||| 8} qW| |kr| |9} n| ||| >> 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]_ spolynomial divisionii(R%tZeroDivisionErrorRAR,RR/RIR*( R$RDRRRERFtinvR4tdqtdrRKR)RL((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_divs     " 4&  cC st||||dS(s 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] i(R^(R$RDRR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_remsc C st|}t|}|s-tdn||kr=gS|j|d|}||||d}}} xtd|dD]|} || } xWttd|| t|| | dD](} | || | |||| 8} qW| |||| >> 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] spolynomial divisionii(R%RZRARR/RI( R$RDRRRERFR[R4R\R]RKR)RL((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_quos    4&cC s8t||||\}}|s%|St||dS(s 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(R^R (R$RDRRtqtr((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_exquoscC s |s |S||jg|SdS(s 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$R3R((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_lshift!scC s(|s|gfS|| || fSdS(s 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]) N((R$R3R((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_rshift5s cC s|s|jgS|dkr |S|dkr<t|||S|jg}x\tr|d@r}t||||}|d8}n|dL}|sPnt|||}qKW|S(s 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] ii(R RQtTrueRM(R$R3RRR4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyRVIs         cC s)t|}|dkrgSdg|}dg|d<||krxtd|D]9}t||d||}t||||||>> 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]] iii(R%RRdR_t gf_pow_modR RRM(RDRRR3R?RKtmon((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_frobenius_monomial_basens       (%$c C st|}t||kr6t||||}n|s@gSt|}|dg}xQtd|dD]<}t|||||||} t|| ||}qmW|S(sT 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] ii(R%R_RR@RG( R$RDR?RRRR3tsfRKR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_frobenius_maps   !c C st||||}|}|}xYtd|D]H}t|||||}t||||}t||||}q1Wt||dd|||} | S(s 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)`` ii(R_RRkRMRg( R$R3RDR?RRR4RbRKtres((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt_gf_pow_pnm1d2s cC s|s|jgS|dkr/t||||S|dkrZtt||||||S|jg}xtr|d@rt||||}t||||}|d8}n|dL}|sPnt|||}t||||}qiW|S(s* 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]_ ii(R R_RQRfRM(R$R3RDRRR4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyRgs$        cC s=x&|r(|t||||}}qWt|||dS(s 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] i(R_tgf_monic(R$RDRR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_gcds  cC sY| s| rgStt||||t||||||}t|||dS(s 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] i(R`RMRoRn(R$RDRRR4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_lcm s cC s[| r| rgggfSt||||}|t||||t||||fS(s  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]) (RoR`(R$RDRRR4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_cofactors s  cC s|p |s|jgggfSt|||\}}t|||\}}|sqg|j||g|fS|s|j||gg|fS|j||gg}} g|j||g} } xtrt||||\} } | sPnt| |||\}}}|j||}t|| | ||}t| | | ||}t||||| } }t||||| } } qW| | |fS(s 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 RnRARfR^RSR@(R$RDRRtp0tr0tp1tr1ts0ts1tt0tt1tQtRRXR[Rtt((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_gcdex7s*!   cC sY|s|jgfS|d}|j|r<|t|fS|t||||fSdS(s 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]) iN(Rtis_oneR,RB(R$RRRX((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyRnys   cC s}t|}|jg||}}xM|d D]A}|||9}||;}|re||||>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_diff >>> gf_diff([3, 2, 4], 5, ZZ) [1, 2] ii(R%RR*(R$RRRER4R3R)((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_diffs  cC s<|j}x,|D]$}||9}||7}||;}qW|S(s 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!RRR7R:((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_evals     cC s&g|D]}t||||^qS(s  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] (R(R$tARRR!((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_multi_evalscC st|dkr7tt|t||||gS|sAgS|dg}x<|dD]0}t||||}t||||}qYW|S(s 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] ii(R#R*RR&RMR=(R$RDRRR4R:((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_composes% cC so|s gS|dg}xQ|dD]E}t||||}t||||}t||||}q"W|S(s& 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] ii(RMR=R_(RDR4R$RRtcompR!((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_compose_mods c C st|||||}|}|d@rFt||||} |} n |} |} |dL}x|rt|t|||||||}t|||||}|d@rt| t|| |||||} t|| |||} n|dL}q_Wt|| |||| fS(s 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]_ i(RRG( R!R?R:R3R$RRRRRtV((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_trace_maps     ' 'c C st||||}|}|}xYtd|D]H}t|||||}t||||}t||||}q1W|S(s& utility for ``gf_edf_shoup`` i(R_RRkRG( R$R3RDR?RRR4RbRK((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt _gf_trace_mapHscC s?|jggtd|D]!}|ttd|^qS(s 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] i(R RtintR(R3RRRK((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_randomVs cC s9x2tr4t|||}t|||r|SqWdS(s, 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(RfRtgf_irreducible_p(R3RRR$((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_irreduciblefs c C st|}|dkrtSt|||\}}|dkrt|j|jg||||}}x8td|dD]g}t||j|jg||}t|||||jgkrt |||||}q|t Sq|Wnt |||} t |j|jg|| ||}}x|td|dD]g}t||j|jg||}t|||||jgkrt ||| ||}q8t Sq8WtS(s_ 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 iiii( R%RfRnRgR RRRHRoRtFalseRiRk( R$RRR3RtHR4RKRDR?((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_irred_p_ben_orys&   (!! (!!c  st|dkrtSt|||\}}|j|jg}fdtD}t|||}|d}xxtdD]g}||krt||||} t || |||jgkrt Snt |||||}qW||kS(s[ 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 ic sh|]}|qS(((t.0td(R3(s6lib/python2.7/site-packages/sympy/polys/galoistools.pys s ( R%RfRnR RRRiRRHRoRRk( R$RRRtxtindicesR?R4RKRD((R3s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_irred_p_rabins    !sben-ortrabincC sGtd}|dk r1t||||}nt|||}|S(s[ 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 tGF_IRRED_METHODN(R tNonet_irred_methodsR(R$RRtmethodtirred((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyRs   cC sQt|||\}}|s"tSt|t||||||jgkSdS(s5 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 N(RnRfRoRR (R$RRR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_sqf_pscC sTt|||\}}|jg}x)|D]!\}}t||||}q+W|S(s 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] (t gf_sqf_listR RM(R$RRRtsqfRD((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_sqf_parts  cC sdtgt|f\}}}}t|||\}}t|dkrX|gfSxutrt|||} | gkrit|| ||} t|| ||} d} x| |jgkrDt| | ||} t| | ||}t|dkr|j || |fnt| | ||| | d} } } qW| |jgkr`t}qi| }n|st||}x-t d|dD]} || ||| >> 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]_ iis'all=True' is not supported yet( RRRnR%RfRRoR`R RRt ValueError(R$RRtallR3RtfactorsRbRXRWRDR4RKtGRR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyRs8+$   +  c C st|t|}}|jg|jg|d}t|ggg|d}xtd|d|dD]}|d |d|g|d}} xAtd|D]0} |j|| d| || d|qW||st||||>> 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]] ii(R%RR RR,RR( R$RRR3RbRaRzRKtqqR:RL((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_Qmatrixxs"%.  c C sg|D]}t|^qt|}}x8td|D]'}||||j||||>> 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]] i(R,R#RR RAtanyR( RzRRRaR3R(RKR[RLR|tbasis((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_Qbasiss<,%" 9 $#  c C st|||}t|||}x6t|D](\}}ttt|||>> 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]] itmultiple(RRt enumerateR*R,treversedRR#RR>RoR tremoveR`textendR R( R$RRRzRRKRRR(RRDR4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_berlekamps&    cC s6d|j|jgg}}}t|||}xd|t|krt|||||}t|t||j|jg||||}||jgkr|j||ft||||}t ||||}t|||}n|d7}q5W||jgkr.||t|fgS|SdS(s{ 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]_ iiN( R RRiR%RkRoRHRR`R_(R$RRRKRDRR?R4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_ddf_zassenhaus s# 0c C s|g}t||kr|St||}|dkrPt|||}nxGt||krtd|d||}|dkr|}xPtdd||dD]3} t|d|||}t||||}qWt||||} nBt||||||}t|t ||j ||||} | |j gkrS| |krSt | |||t t || |||||}qSqSWt |dtS(s 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]] References ========== .. [1] [Gathen99]_ .. [2] [Geddes92]_ iiiR(R%RiR#RRRgRGRoRmR>R tgf_edf_zassenhausR`R R( R$R3RRRtNR?RbR4RKRD((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyRCs(   "',cC st|}ttt|d}t|||}t|j|jg||||}|j|jg|g|jg|d}x?td|dD]*}t||d|||||| 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]_ ii(R%Rt_ceilt_sqrtRiRkR RRRRRHRMR_RoR`RR(R$RRR3R(R?R4RRKRRRRLRRDRW((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_ddf_shoup{s: $*(( "(cC st|t|}}|s#gS||kr6|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|dtS(s 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]_ iiR(R%RR RRRgRRoR`t gf_edf_shoupRiRR>RMR R(R$R3RRRRaRRRbR4Rth1th2R?th3((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyRs,  & '$;cC sRg}x9t|||D]%\}}|t||||7}qWt|dtS(s 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]] R(RRR R(R$RRRtfactorR3((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_zassenhausscC sRg}x9t|||D]%\}}|t||||7}qWt|dtS(s 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]] R(RRR R(R$RRRRR3((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_shoupst berlekampt zassenhaustshoupcC st|||\}}t|dkr4|gfS|pCtd}|dk rkt||||}nt|||}||fS(s  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]]) itGF_FACTOR_METHODN(RnR%R Rt_factor_methodsR(R$RRRRXR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_factor_sqf8s  cC st|||\}}t|dkr4|gfSg}xXt|||dD]@\}}x1t|||dD]}|j||fqtWqQW|t|fS(s 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]_ i(RnR%RRRR (R$RRRXRRDR3R4((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_factorUs2 #cC s/d}x"|D]}||9}||7}q W|S(s 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 i((R$R!R7R:((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytgf_values   cC sddlm}||dkrG||dkr@tt|SgSn|||\}}}||dkrsgSgt|D]$}|||||||^qS(s 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 i(Ri(tsympy.polys.polytoolsRR,R(R!R?RRRbRRDR|((s6lib/python2.7/site-packages/sympy/polys/galoistools.pytlinear_congruencescC sYddlm}t|||}t||}t|| ||}t|||S(s0 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] i(tZZ(tsympy.polys.domainsRRRR(RRRR$Rtf_ftalphatbeta((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt_raise_mod_powers !ic C sddlm}gt|D]'}t||||dkr|^q}|dkrZ|Sg}tt|dgt|}x|r |j\}} | |kr|j|q| d} || } |j gt || ||D]} || | | f^qqWt |S(sU 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). i(Rii( RRRRR,RR#tpopRRRtsorted( R$RRRRKtX1tXRRRRwtpsR((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt csolve_primes: "    AcC sddlm}t|}g|jD]\}}t|||^q)}ttt|}gg}x;|D]3} g|D] } | D]} | | g^qq}qrWg|jD]\}}t||^q} t g|D]} t | | |^qS(s= 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. i(R( RRRtitemsRR,R-RUtpowRR(R$R3RtPRRRtpoolstpermstpoolRtyt dist_factorstper((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyt gf_csolve s 1  1.N(ft__doc__t __future__RRtrandomRtmathRRRRtsympy.core.compatibilityRRtsympy.core.mulRt sympy.ntheoryRtsympy.polys.polyconfigR tsympy.polys.polyerrorsR tsympy.polys.polyutilsR RRRR R"R%R&R'R*R+R.R5RfR8R9R;R<R=R>R@RBRGRHRMRQRRRSRYR^R_R`RcRdReRVRiRkRmRgRoRpRqR}RnRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR(((s6lib/python2.7/site-packages/sympy/polys/galoistools.pyts .                   # #  +    6  '    % %  1    B       7    - )     Y ( > , 9 8 L ?     @  # ( "