MZd0dZddlmZmZmZddlmZddl m Z ddl m Z ddl mZddlmZdTd Zd Zd Zd Zd ZdZdZdZdZdZdZdUdZdZdUdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'd Z(d!Z)d"Z*d#Z+d$Z,d%Z-d&Z.d'Z/d(Z0d)Z1d*Z2d+Z3d,Z4d-Z5d.Z6d/Z7d0Z8d1Z9d2Z:d3Z;d4Zd7Z?d8Z@d9ZAd:ZBd;ZCd<ZDd=ZEeDeEd>ZFd?ZGd@ZHdAZIdVdBZJdCZKdDZLdEZMdFZNdGZOdHZPdIZQdJZRdKZSeMeReSdLZTdTdMZUdNZVdOZWdPZXdQZYdWdRZZdSZ[y)XzADense univariate polynomials with coefficients in Galois fields. )ceilsqrtprod)uniform) SYMPY_INTS)query)ExactQuotientFailed) _sort_factorsNct||j}|j}t||D].\}}||z}|j ||\}} } ||||z|zzz }0||zS)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_s 9/usr/lib/python3/dist-packages/sympy/polys/galoistools.pygf_crtr svD QaeeA AAq 1 F''!Q-1a Q!a[ q5Lcgg}}t||j}|D]@}|j||z|j|j|d|d|zB|||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)rrappendr)rrESrrs rgf_crt1r$9sn rqA QaeeA + a 2"1%)*+ a7Nrcp|j}t||||D]\}}} } || || z|zzz }||zS)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#rrrrrrs rgf_crt2r&QsO( A!Q1o 1a Q!a[ q5Lrc ||dzkr|S||z S)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 )ars rgf_intr+ms AF{1u rct|dz S)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)fs r gf_degreer1s q6A:rc(|s |jS|dS)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 rrr0rs rgf_LCr5s vv t rc(|s |jS|dS)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 r3r4s rgf_TCr7s vv u rcB|r|dr|Sd}|D] }|rn|dz } ||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))r0kcoeffs rgf_stripr;sB ! A   FA  QR5LrcDt|Dcgc]}||z c}Scc}w)z Reduce all coefficients modulo ``p``. Examples ======== >>> from sympy.polys.galoistools import gf_trunc >>> gf_trunc([7, -2, 3], 5) [2, 3, 3] )r;)r0rr*s rgf_truncr=s! Q(a!e( ))(s c@ttt|||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=listmap)r0rrs r gf_normalrAs DQOQ ''rc|t|jg}}t|trAt |ddD]0}|j |j ||j|z2nE|\}t |ddD]1}|j |j |f|j|z3t||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 isinstancerranger!getrr=)r0rrnhr9s r gf_from_dictrJs qvvx="qA!Z q"b! +A HHQUU1aff%) * +q"b! .A HHQUUA4(1, - . Aq>rct|i}}td|dzD]'}|rt|||z |}n|||z }|s#|||<)|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-)r1rFr+)r0r symmetricrHresultr9r*s r gf_to_dictrNsa! bvA 1a!e_ qQx#A!a%A F1I Mrct||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=)r0rs rgf_from_int_polyrP2s Aq>rcH|r|Dcgc]}t||c}S|Scc}w)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] )r+)r0rrLcs rgf_to_int_polyrSBs( '(*!1**+sc4|Dcgc]}| |z c}Scc}w)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] r))r0rrr:s rgf_negrUXs&' (EeVaZ (( (s cd|s||z}n"|d|z|z}t|dkDr |dd|gzS|sgS|gS)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-Nr.r0r*rrs r gf_add_groundrXisM E rUQY!O q6A:Sb6QC<   s rcf|s| |z}n"|d|z |z}t|dkDr |dd|gzS|sgS|gS)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-Nr.rWs r gf_sub_groundrZsO BF rUQY!O q6A:Sb6QC<   s rc@|sgS|Dcgc] }||z|z c}Scc}w)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] r))r0r*rrbs r gf_mul_groundr]s(  $%'q!A#'''sc>t||j||||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] )r]invertrWs r gf_quo_groundr`s AHHQNAq 11rc\|s|S|s|St|}t|}||k(r.tt||Dcgc] \}}||z|zc}}St||z }||kDr |d|||d}} n |d|||d}} | t||Dcgc] \}}||z|zc}}zScc}}wcc}}w)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] N)r1r;rabs r0grrdfdgr*r\r9rIs rgf_addrgs   1B 1B Rx#a)=$!Q1q5A+=>> RL 7Ra5!AB%qARa5!AB%qASAY8TQa!eq[888>9s B" B(c|s|S|s t|||St|}t|}||k(r.tt||Dcgc] \}}||z |zc}}St ||z }||kDr |d|||d}} nt|d|||||d}} | t||Dcgc] \}}||z |zc}}zScc}}wcc}}w)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] N)rUr1r;rrbrcs rgf_subris  aA 1B 1B Rx#a)=$!Q1q5A+=>> RL 7Ra5!AB%qA!BQ%A&!"qASAY8TQa!eq[888>9s B8 B>c(t|}t|}||z}dg|dzz}td|dzD]R}|j} ttd||z t ||dzD]} | || ||| z zz } | |z||<Tt |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-r1rFrrCminr;) r0rdrrrerfdhrIir:js rgf_mulrp s 1B 1B bB R!V A 1b1f s1a"f~s1bzA~6 #A QqT!AE(] "E #qy!  A;rctt|}d|z}dg|dzz}td|dzD]}|j}td||z }t ||} | |z dz} || dzzdz } t|| dzD]} ||| ||| z zz }||z }| dzr|| dz} || dzz }||z||<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-rk) r0rrrermrIrnr:jminjmaxrHroelems rgf_sqrru+s 1B 2B R!V A 1b1f 1a"f~1bz 4K!Oa1f}q tTAX& #A QqT!AE(] "E #  q5TAX;D T1W Eqy!'* A;rc 6t|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] )rgrpr0rdrIrrs r gf_add_mulrxVs  !VAq!Q'A ..rc 6t|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] )rirprws r gf_sub_mulrzes  !VAq!Q'A ..rct|tr|\}}n |j}|g}|D]!\}}t||||}t ||||}#|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] )rEtuplergf_powrp)Frrlcrdr0r9s r gf_expandrvsa!UA UU A1 1aA  1aA  Hrct|}t|}|s td||krg|fS|j|d|}t|||z |dz } }}t d|dzD]^} || } t t d|| z t || z | dzD]} | || | z|z ||| z zz} | |kr| |z} | |z|| <`|d|dzt||dzdfS)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)r1ZeroDivisionErrorr_r?rFrCrlr; r0rdrrrerfinvrIdqdrrnr:ros rgf_divrs8 1B 1B  566 b1u ((1Q4 CQb"q&2rA 1b1f  !s1b1f~s262':; /A Qq1urz]QrAvY. .E / 7 SLEqy!  Wb1f:x"q&' + ++rc$t||||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-)rr0rdrrs rgf_remrs !Q1 a  rct|}t|}|s td||krgS|j|d|}|dd||z |dz } }}td|dzD]W} || } tt d|| z t || z | dzD]} | || | z|z ||| z zz} | |z|z|| <Y|d|dzS)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] rrNr-)r1rr_rFrCrlrs rgf_quors 1B 1B  566 b ((1Q4 C!b2grAv2rA 1b1f !!s1b1f~s262':; /A Qq1urz]QrAvY. .E / q ! ! Wb1f:rcDt||||\}}|s|St||)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] )rr )r0rdrrqrs rgf_exquors-& !Q1 DAq !!Q''rc0|s|S||jg|zzS)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] r3r0rHrs r gf_lshiftrs  AFF8A:~rc&|s|gfS|d| || dfS)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)rs r gf_rshiftr/s* "u 1"vq!v~rc|s |jgS|dk(r|S|dk(r t|||S|jg} |dzrt||||}|dz}|dz}|s |St|||}0)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()rrurp)r0rHrrrIs rr}r}Cs w a aaA A  q5q!Q"A FA a  H 1aO rct|}|dk(rgSdg|z}dg|d<||kr7td|D]&}t||dz ||}t||||||<(|S|dkDrgt |j |j g|||||d<td|D]0}t||dz |d||||<t|||||||<2|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()r1rFrr gf_pow_modrrrp)rdrrrHr\rnmons rgf_frobenius_monomial_baserhs ! AAv AA 3AaD1uq! (AAa!eHa+C#q!Q'AaD ( H Q155!&&/1aA6!q! )A!AE(AaD!Q/AaD!A$1a(AaD ) Hrct|}t||k\rt||||}|sgSt|}|dg}td|dzD]'}t|||||z ||} t || ||})|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] r r-)r1rrFr]rg) r0rdr\rrrrHsfrnrs rgf_frobenius_maprs2 ! A|q 1aA   ! A B%B 1a!e_! !A$!a%!Q / B1a ! Irct||||}|}|}td|D]-}t|||||}t||||}t||||}/t ||dz dz|||} | 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()rrFrrpr) r0rHrdr\rrrIrrnress r_gf_pow_pnm1d2rs q!QA A A 1a[ Q1a + 1aA  1aA  QQ Aq! ,C Jrc6|s |jgS|dk(rt||||S|dk(rtt||||||S|jg} |dzr!t||||}t||||}|dz}|dz}|s |St|||}t||||}L)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()rrrurp)r0rHrdrrrIs rrrs. w aaAq!! afQ1oq!Q// A  q5q!Q"Aq!Q"A FA a  H 1aO 1aA  rcL|r|t||||}}|rt|||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-)rgf_monicrs rgf_gcdrs6 &Aq!$1  Aq! Q rc z|r|sgStt||||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-)rrprrr0rdrrrIs rgf_lcmrsM A vaAq!aAq!1a )A Aq! Q rcj|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]) )rrrs r gf_cofactorsrsM QB|q!QA vaAq! 1aA   rc|s|s|jgggfSt|||\}}t|||\}}|sg|j||g|fS|s|j||gg|fS|j||gg} }g|j||g} } t||||\} } | sndt| |||c\}}}|j||}t || | ||}t | | | ||}t ||||| }} t ||||| } } x| | |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]_ )rrr_rrzr])r0rdrrp0r0p1r1s0s1t0t1QRrrrts rgf_gcdexr1sIB wB aA FB aA FB AHHRO$b(( Q "b((hhr1o B !((2q/"B b"a#1 1a(" R"hhr1o r2q!Q ' r2q!Q 'q#q!,bBq#q!,bB  r2:rc|s|jgfS|d}|j|r |t|fS|t||||fS)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]) r)ris_oner?r`)r0rrrs rrrssM vvrz qT 88B<tAw; }QAq11 1rct|}|jg|z|}}|ddD]!}|||z}||z}|r||||z <|dz}#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] Nr r-)r1rr;)r0rrrerIrHr:s rgf_diffrsp 1B FF8B;qA3B 1    Ab1fI Q A;rcJ|j}|D]}||z}||z }||z}|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 r3)r0r*rrrMrRs rgf_evalrs>VVF ! ! !  Mrc D|Dcgc]}t||||c}Scc}w)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] )r)r0Arrr*s r gf_multi_evalrs#+, -QWQ1a -- -sc t|dkr"tt|t||||gS|sgS|dg}|ddD]}t ||||}t ||||} |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/r;rr5rprX)r0rdrrrIrRs r gf_composers} 1v{E!QKA6788  1A qrU& 1aA  !Q1 %& Hrc|sgS|dg}|ddD],}t||||}t||||}t||||}.|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)rprXr)rdrIr0rrcompr*s rgf_compose_modrsc  aD6D qrU%dAq!$T1a+dAq!$% Krc Jt|||||}|}|dzrt||||} |} n|} |} |dz}|rat|t|||||||}t|||||}|dzr*t| t|| |||||} t|| |||} |dz}|rat|| |||| 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-)rrg) r*r\rRrHr0rrrrrVs r gf_trace_mapr s> q!Q1%A A1u 1aA    !GA 1nQ1a3Q : 1aAq ) q5q.Aq!Q7A>Aq!Q1-A a  !Q1a (! ++rct||||}|}|}td|D]-}t|||||}t||||}t||||}/|S)z& utility for ``gf_edf_shoup`` r-)rrFrrg) r0rHrdr\rrrIrrns r _gf_trace_maprBsl q!QA A A 1a[ Q1a + 1aA  1aA  Hrc |jgtd|Dcgc]}|ttd|c}zScc}w)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] r)rrFintr)rHrrrns r gf_randomrPs9 EE7eAqkCqWQ]+,C CCCs"Ac> t|||}t|||r|S)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] )rgf_irreducible_p)rHrrr0s rgf_irreducibler`s+  aA  Aq! $H rct|}|dkryt|||\}}|dkrt|j|jg||||x}}t d|dzD]S}t ||j|jg||}t|||||jgk(rt|||||}Syyt|||} t|j|jg|| ||x}}t d|dzD]S}t ||j|jg||}t|||||jgk(rt||| ||}Syy)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) r1rrrrrFrirrrr) r0rrrHrHrIrnrdr\s rgf_irred_p_ben_orrssV ! AAv Aq! DAq1uAEE166?Aq!Q77Aq!Q$ Aq155!&&/1a0AaAq!aeeW,"1aAq1  "  'q!Q / !%%!Q1==Aq!Q$ Aq155!&&/1a0AaAq!aeeW,$Q1a3   rct|}|dkryt|||\}}|j|jg}ddlm}||Dchc]}||z }}t |||} | d} td|D]A} | |vr,t| |||} t|| |||jgk7ryt| || ||} C| |k(Scc}w)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 factorintF) r1rrr sympy.ntheoryrrrFrirr) r0rrrHrxrdindicesr\rIrnrds rgf_irred_p_rabinrs ! AAv Aq! DAq A''l,1,G,"1a+A !A 1a[, <q!Q"AaAq!aeeW, Q1a +, 6M-s B?)zben-orrabinc^td}|t||||}|St|||}|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 GF_IRRED_METHOD)r_irred_methodsr)r0rrmethodirreds rrrsD $ %F v&q!Q/ L!Aq) Lrcvt|||\}}|syt|t||||||jgk(S)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 T)rrrr)r0rrrs rgf_sqf_prsA Aq! DAq aAq)1a0QUUG;;rcpt|||\}}|jg}|D]\}}t||||}|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_listrrp)r0rrrsqfrds r gf_sqf_partrsKAq !FAs A1 1aA  Hrcddgt|f\}}}}t|||\}}t|dkr|gfS t|||} | gk7rt || ||} t || ||} d} | |j gk7rft | | ||} t | | ||}t|dkDr|j|| |zft | | ||| | dz} } } | |j gk7rf| |j gk(rd}n| }|s;t||z}td|dzD] } || |z|| <|d|dz||z}}nn|r td||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-FTrNz'all=True' is not supported yet) rrr1rrrrr!rF ValueError)r0rrallrHrfactorsrrr~rdrIrnGrrs rrrsVE2s1v-AsGQ Q1 EB|a2v  Aq!  7q!Q"Aq!Q"AAw,1aA&1aA&Q>> 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 )r1rrrr?rFr!) r0rrrHrrrrnqqrRros r gf_Qmatrixrts* Q<QqA 166(AE""A a RD!a%L A 1q1uai!m $ R5&2,!#$aeAq! 4A IIqQx!Aqb1fI+-2 3 4A2hAadG   Hrc~|Dcgc] }t|c}t|}}td|D] }||||jz |z|||<"td|D]}t||D] }|||s n|j ||||}td|D]}||||z|z|||<td|D] }|||} ||||||<| |||<"td|D]>}||k7s |||}td|D]}|||||||zz |z|||<!@td|D]I}td|D]8}||k(r|j|||z |z|||<'||| |z|||<:Kg} |D]}t |s| j |!| Scc}w)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]] r)r?r/rFrr_anyr!) rrrrrHr9rnrrorbasiss r gf_Qbasisrs7" !T!W !3q6qA 1a[(Q47QUU?a'!Q(1a[8q! AtAw  hhqtAw"q! (AtAws{a'AaDG (q! A!QAd1gAaDGAaDG  q! 8AAvaDGq!8A tAw1a2a7AaDG8  8#801a[)q! )AAv551Q47?a/!QaDG8q.!Q  )) E  q6 LLO LU "sF:czt|||}t|||}t|D]%\}}tt t |||<'|g}t dt|D]}t |D]}|j} | |kst||| ||} t|| ||} | |jgk7r7| |k7r2|j|t|| ||}|j|| gt|t|k(rt|dccS| |jz } | |krt|dS)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 enumerater;r?reversedrFr/rrZrrremoverextendr ) r0rrrrrnrrr9rrdrIs r gf_berlekamprs9 1aA!QA! +1Xa[)*!+cG 1c!f g AAa%!!A$1a01aA& 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() rrrr1rrrir!rr)r0rrrnrdrr\rIs rgf_ddf_zassenhausrsFqvv'qA"1a+A A#1  Q1a + 1fQA61 = < NNAq6 "q!Q"Aq!Q"A*1a3A Q A#1  QUUG|1il+,,,rc |g}t||kr|St||z}|dk7r t|||}|j|jg}t ||kr|dk(r^|x}} t |dz D]} t | d|||} t|| ||}!t||||} ||j|jgz }nGtd|zdz ||} t| ||||}t|t||j||||} | |jgk7r.| |k7r)t| |||tt|| |||||z}t ||krt|dS)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)r1rrrr/rFrrgrrrrZgf_edf_zassenhausrr ) r0rHrrrNr\rrIrrnrds rrr?sw@cG|q! AAv &q!Q / A g,  6IA1q5\ 'q!Q1-1aA& 'q!Q"A !&&!&&! !A!a%!)Q*Aq!Q1a0Aq-155!Q7A>A  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)r1r_ceil_sqrtrrrrrFrrrirprrrrr!)r0rrrHr9r\rIrrnrrrrorrdr~s r gf_ddf_shouprsE@ ! A E%1+ A"1a+A!%%!Q15A %%!xQ//A 1a!e_4!A#1a3!4 Q42AqA qvvhAA 1a[4aAh1a3!4G! -1wA1 #Aq!Q"Aq!Q"Aq!Q"A # 1aA  1aA ! -Aq!Q"Aq!Q"AQUUG|1a!e9q=12!Q1%q1uqA --( QUUG|9Q<() Nrc t|t|}}|sgS||kr|gS|g|j|jg}}t |dz ||}|dk(r`t |||||} t || ||dz |||d} t|| ||} t|| ||} t| |||t| |||z}nt|||} t|||| ||} t | |dz dz|||} t|| ||} t|t| |j||||} t|t| | ||||}t| |||t| |||zt||||z}t|dS)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)r1rrrrrrrr gf_edf_shouprrrZrpr )r0rHrrrrrrrrIrh1h2r\h3s rrrs8 Q<QqA  Avs quuaffoQG!a%AAAv q!Q1 % Aq!a%Aq 1! 4 Aq!Q  Ar1a r1a+2q!Q'( 'q!Q / !Q1a + q1q51*aA . Aq!Q  A}Qq!4a ; Avb"a+Q 2r1a+2q!Q'(2q!Q'( 5 11rclg}t|||D]\}}|t||||z }t|dS)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 r0rrrfactorrHs r gf_zassenhausr sJG&q!Q/6 $VQ1556 5 11rclg}t|||D]\}}|t||||z }t|dS)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 r s rgf_shoupr sIG!!Q*1 <1a001 5 11r) berlekamp zassenhausshoupct|||\}}t|dkr|gfS|xs td}|t||||}||fSt |||}||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-GF_FACTOR_METHOD)rr1r_factor_methodsr)r0rrrrrs r gf_factor_sqfr<sz Q1 EB|a2v  0u/0F !&)!Q2 w; 1a( w;rct|||\}}t|dkr|gfSg}t|||dD]-\}}t|||dD]}|j ||f/|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-)rr1rrr!r )r0rrrrrdrHrIs r gf_factorrYsd Q1 EB|a2v GAq!$Q'#1q!Q'* #A NNAq6 " ## }W% %%rc,d}|D] }||z}||z }|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))r0r*rMrRs rgf_valuers1F ! !  Mrcddlm}||zdk(r||zdk(rtt|SgS|||\}}}||zdk7rgSt|Dcgc]}||z|z||z|zz|zc}Scc}w)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)r)sympy.polys.polytoolsrr?rF)r*r\rrrrrdrs rlinear_congruencers.,1uz q5A:a> !IAqkGAq!1uz 388 >> 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.domainsr!rrr)rrrr0r!f_falphabetas r_raise_mod_powerr&sHB' !Q C S! E a^ q!t #D UD! ,,rc ddlm}t|Dcgc]}t||||dk(s|}}|dk(r|Sg}t t |dgt |z}|rj|j\}} | |k(r|j|n=| dz} || z} |jt|| ||D cgc] } || | zz| fc} |rjt|Scc}wcc} w)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). rr r-) r"r!rFrr?rr/popr!rr&sorted) r0rrr!rnX1Xr#rrrpsrs r csolve_primer-s"'1X ;Aq"!5!:! ;B ;Av  A SaSR[ !"A uuw1 6 HHQKQBAB HH.>q!Q.JKq1R4xnK L  !9 <LsCC-Cc ddlm}ddlm}||}|j Dcgc]\}}t |||}}}t tt|}gg} |D]} | D cgc]} | D]} | | gz } } } |j Dcgc]\}}t||} }}t| Dcgc]}t|| |c}Scc}}wcc} } wcc}}wcc}w)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. rr r) r"r!rritemsr-r?r@r|powr)r)r0rHr!rPrrr+poolspermspoolry dist_factorspers r gf_csolver8 s0''! A+,779541aaA 5A5 UA E DE7"'6Q6AaS6667*+'')4$!QC1I4L4 EBS6#|R0B CC 674BsC(CC6C#)N)T)F)r-)\__doc__mathrrrrrsympy.core.randomrsympy.external.gmpyrsympy.polys.polyconfigrsympy.polys.polyerrorsr sympy.polys.polyutilsr rr$r&r+r1r5r7r;r=rArJrNrPrSrUrXrZr]r`rgrirprurxrzrrrrrrrr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr&r-r8r)rrr@sG33%*(6/*Z08*$((8 * ("8:  ,)"88((2" 9F 9F>(V //" 83,l!"$N(6((# J @#J". b ( . .?D22<0." :65,n   D &*Z)X  4<0 0Vr% P;|)2X6r=2@JX<2~2,2, :=&@( =F%-PD!Dr