Ed2dZddlmZmZmZddlmZddl m Z ddl m Z ddl mZddlmZdWd Zd Zd Zd Zd ZdZdZdZdZdZdZdXdZdZdXdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&d Z'd!Z(d"Z)d#Z*d$Z+d%Z,d&Z-d'Z.d(Z/d)Z0d*Z1d+Z2d,Z3d-Z4d.Z5d/Z6d0Z7d1Z8d2Z9d3Z:d4Z;d5Zd8Z?d9Z@d:ZAd;ZBd<ZCd=ZDd>ZEeDeEd?ZFd@ZGdAZHdBZIdYdDZJdEZKdFZLdGZMdHZNdIZOdJZPdKZQdLZRdMZSeMeReSdNZTdWdOZUdPZVdQZWdRZXdSZYdZdUZZdVZ[dS)[zADense univariate polynomials with coefficients in Galois fields. )ceilsqrtprod)uniform) SYMPY_INTS)query)ExactQuotientFailed) _sort_factorsNct||j}|j}t||D]2\}}||z}|||\}} } ||||z|zzz }3||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 7lib/python3.11/site-packages/sympy/polys/galoistools.pygf_crtr s|D QaeA AAq 1 F''!Q--1a Q!a[ q5Lcgg}}t||j}|D]R}|||z|||d|d|zS|||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$9s rqA QaeA ++ a 2""1%)**** a7Nrcj|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!Q1oo 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 rc&t|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 q66A: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 v 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 v u rcN|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;sU ! A   E FAA QRR5Lrc:tfd|DS)z Reduce all coefficients modulo ``p``. Examples ======== >>> from sympy.polys.galoistools import gf_trunc >>> gf_trunc([7, -2, 3], 5) [2, 3, 3] cg|]}|zSr)r)).0r*rs r zgf_trunc..s(((a!e(((r)r;r0rs `rgf_truncrAs( ((((Q((( ) ))rcXttt|||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] )rAlistmapr0rrs r gf_normalrFs" DQOOQ ' ''rct|g}}t|trFt |ddD]3}||||j|z4nJ|\}t |ddD]4}|||f|j|z5t||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!getrrA)r0rrnhr9s r gf_from_dictrOs qvvxx=="qA!Z  .q"b!! + +A HHQUU1af%%) * * * * +q"b!! . .A HHQUUA4((1, - - - - Aq>>rTct|i}}td|dzD]0}|rt|||z |}n |||z }|r|||<1|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-)r1rKr+)r0r symmetricrMresultr9r*s r gf_to_dictrSss! bvA 1a!e__  qQx##AA!a%A  F1I Mrc"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] )rAr@s rgf_from_int_polyrU2s Aq>>rc(|rfd|DS|S)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] c0g|]}t|Sr))r+)r>crs rr?z"gf_to_int_poly..Ss!***!1***rr))r0rrQs ` rgf_to_int_polyrYBs, ****q****rc fd|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] cg|]}| z Sr)r))r>r:rs rr?zgf_neg..fs ( ( (EeVaZ ( ( (rr)rEs ` rgf_negr\Xs ) ( ( (Q ( ( ((rc~|s||z}n/|d|z|z}t|dkr|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_groundr_isb  E rUQY!O q66A: SbS6QC<   s rc|s| |z}n/|d|z |z}t|dkr|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.r^s r gf_sub_groundrasd  BF rUQY!O q66A: SbS6QC<   s rc,sgSfd|DS)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] c g|] }|zz Sr)r))r>br*rs rr?z!gf_mul_ground..s!'''q!A#'''rr)r^s `` r gf_mul_groundres0 ( '''''A''''rcNt||||||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] )reinvertr^s r gf_quo_groundrhs$ AHHQNNAq 1 11rcn|s|S|s|St|}t|}||kr)tfdt||DSt||z }||kr|d|||d}}n|d|||d}}|fdt||DzS)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] c&g|] \}}||zzSr)r)r>r*rdrs rr?zgf_add..%===$!Q1q5A+===rNc&g|] \}}||zzSr)r)rks rr?zgf_add..%888TQa!eq[888r)r1r;rabsr0grrdfdgr9rNs ` rgf_addrts   1B 1B Rx 9====#a))===>>> RLL 7 RaR5!ABB%qAARaR5!ABB%qA8888SAYY88888rc|s|S|st||St|}t|}||kr)tfdt||DSt ||z }||kr|d|||d}}n#t|d||||d}}|fdt||DzS)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] c&g|] \}}||z zSr)r)rks rr?zgf_sub..rlrNc&g|] \}}||z zSr)r)rks rr?zgf_sub.. rnr)r\r1r;rrorps ` rgf_subrxs  aA 1B 1B Rx 9====#a))===>>> RLL 7 .RaR5!ABB%qAA!BQB%A&&!""qA8888SAYY88888rcZt|}t|}||z}dg|dzz}td|dzD]]}|j} ttd||z t ||dzD]} | || ||| z zz } | |z||<^t |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-r1rKrrHminr;) r0rqrrrrrsdhrNir:js rgf_mulr s 1B 1B bB R!V A 1b1f  s1a"f~~s1bzzA~66 # #A QqT!AE(] "EEqy! A;;rct|}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-rz) r0rrrrr|rNr}r:jminjmaxrMr~elems rgf_sqrr+s  1B 2B R!V A 1b1f  1a"f~~1bzz 4K!Oa1f}q tTAX&& # #A QqT!AE(] "EE  q5 TAX;D T1W Eqy! A;;rc Ft|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] )rtrr0rqrNrrs r gf_add_mulrVs& !VAq!Q''A . ..rc Ft|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] )rxrrs r gf_sub_mulres& !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] )rJtuplergf_powr)Frrlcrqr0r9s r gf_expandrvso!UAA U A1 1aA   1aA   Hrc8t|}t|}|std||krg|fS||d|}t|||z |dz } }}t d|dzD]r} || } t t d|| z t || z | dzD]} | || | z|z ||| z zz} | |kr| |z} | |z|| <s|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)r1ZeroDivisionErrorrgrCrKrHr{r; r0rqrrrrrsinvrNdqdrr}r:r~s rgf_divrsH8 1B 1B  5666 b1u ((1Q4  CQb"q&2rA 1b1f    !s1b1f~~s262':;; / /A Qq1urz]QrAvY. .EE 7  SLEqy! Wb1fW:x"q&'' ++ ++rc2t||||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-)rr0rqrrs rgf_remrs !Q1  a  rct|}t|}|std||krgS||d|}|dd||z |dz } }}td|dzD]j} || } tt d|| z t || z | dzD]} | || | z|z ||| z zz} | |z|z|| <k|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-)r1rrgrKrHr{rs rgf_quors 1B 1B  5666 b ((1Q4  C!!!b2grAv2rA 1b1f  !!!s1b1f~~s262':;; / /A Qq1urz]QrAvY. .EE q ! Wb1fW:rcTt||||\}}|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 )r0rqrrqrs rgf_exquors8& !Q1  DAq (!!Q'''rc&|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] r3r0rMrs r gf_lshiftrs# AF8A:~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/s3 "u 1"vq!v~rc|s|jgS|dkr|S|dkrt|||S|jg} |dzrt||||}|dz}|dz}|snt|||}6|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()rrr)r0rMrrrNs rrrCs w a aaA A  q5 q!Q""A FA a   1aOO  Hrct|}|dkrgSdg|z}dg|d<||krCtd|D]1}t||dz ||}t||||||<2nz|dkrtt |j|jg|||||d<td|D]A}t||dz |d||||<t|||||||<B|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()r1rKrr gf_pow_modrrr)rqrrrMrdr}mons rgf_frobenius_monomial_baserhs ! AAv AA 3AaD1u)q! ( (AAa!eHa++C#q!Q''AaDD ( Q)15!&/1aA66!q! ) )A!AE(AaD!Q//AaD!A$1a((AaDD Hrc8t|}t||krt||||}|sgSt|}|dg}td|dzD]5}t|||||z ||} t || ||}6|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-)r1rrKrert) r0rqrdrrrrMsfr}rs rgf_frobenius_maprs2 ! A||q 1aA    ! A B%B 1a!e__!! !A$!a%!Q / / B1a  Irct||||}|}|}td|D]9}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()rrKrrr) r0rMrqrdrrrNrr}ress r_gf_pow_pnm1d2rs q!QA A A 1a[[ Q1a + + 1aA   1aA   QQ Aq! , ,C Jrc^|s|jgS|dkrt||||S|dkr!tt||||||S|jg} |dzr)t||||}t||||}|dz}|dz}|sn$t|||}t||||}Z|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()rrrr)r0rMrqrrrNs rrrs. 0w a0aAq!!! a0fQ1ooq!Q/// A  q5 q!Q""Aq!Q""A FA a   1aOO 1aA    Hrc`|r|t||||}}|t|||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_gcdrsF %&Aq!$$1 % Aq!  Q rc |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-)rrrrr0rqrrrNs rgf_lcmrse A vaAq!!aAq!!1a ) )A Aq!  Q rc|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_cofactorsrs` QB|q!QA vaAq!! 1aA    rcx|s |s |jgggfSt|||\}}t|||\}}|sg|||g|fS|s|||gg|fS|||gg} }g|||g} } t||||\} } | sn|t| |||c\}}}|||}t || | ||}t | | | ||}t ||||| }} t ||||| } } | | |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]_ )rrrgrrre)r0rqrrp0r0p1r1s0s1t0t1QRrrrts rgf_gcdexr1sB wB aA  FB aA  FB )AHHROO$b(( )Q "b((hhr1oo B !((2q//"B1b"a##1  1a((" R"hhr1oo r2q!Q ' ' r2q!Q ' 'q#q!,,bBq#q!,,bB1 r2:rc|s |jgfS|d}||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_onerCrh)r0rrrs rrrss\ 2vrz qT 88B<< 2tAww; }QAq111 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;)r0rrrrrNrMr:s rgf_diffrs} 1B F8B;qA3B3 1     Ab1fI Q A;;rc<|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*rrrRrXs rgf_evalrs<VF ! ! !  Mrc(fd|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] c4g|]}t|Sr)r)r>r*rr0rs rr?z!gf_multi_eval..s' - - -QWQ1a - - -rr))r0Arrs` ``r gf_multi_evalrs' . - - - - -! - - --rc 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;rr5rr_)r0rqrrrNrXs r gf_composers 1vv{9E!QKKA667888  1A qrrU&& 1aA   !Q1 % % Hrc|sgS|dg}|ddD]8}t||||}t||||}t||||}9|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)rr_r)rqrNr0rrcompr*s rgf_compose_modrss  aD6D qrrU%%dAq!$$T1a++dAq!$$ Krc t|||||}|}|dzrt||||} |} n|} |} |dz}|rxt|t|||||||}t|||||}|dzr6t| t|| |||||} t|| |||} |dz}|xt|| |||| 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-)rrt) r*rdrXrMr0rrrrrVs r gf_trace_mapr s > q!Q1%%A A1u 1aA     !GA  1nQ1a33Q : : 1aAq ) ) q5 .q.Aq!Q77A>>Aq!Q1--A a  !Q1a ( (! ++rct||||}|}|}td|D]9}t|||||}t||||}t||||}:|S)z& utility for ``gf_edf_shoup`` r-)rrKrrt) r0rMrqrdrrrNrr}s r _gf_trace_maprBsz q!QA A A 1a[[ Q1a + + 1aA   1aA   HrcRjgfdtd|DzS)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] c \g|](}ttd)Sr)intr)r>r}rrs rr?zgf_random..]s3CCCqqWQ]]++,,CCCrr)rrK)rMrrs ``r gf_randomrPs5 E7CCCCCeAqkkCCC CCrcN 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)rMrrr0s rgf_irreducibler`s6 aA   Aq! $ $ Hrct|}|dkrdSt|||\}}|dkrt|j|jg||||x}}t d|dzD]R}t ||j|jg||}t|||||jgkrt|||||}PdSnt|||} t|j|jg|| ||x}}t d|dzD]R}t ||j|jg||}t|||||jgkrt||| ||}PdSdS)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) r1rrrrrKrxrrrr) r0rrrMrHrNr}rqrds rgf_irred_p_ben_orrss ! AAvt Aq!  DAq1uAE16?Aq!Q777Aq!Q$  Aq15!&/1a00AaAq!!aeW, "1aAq11uu   'q!Q / / !%!Q1===Aq!Q$  Aq15!&/1a00AaAq!!aeW, $Q1a33uu 4rc t| dkrdSt|||\}}|j|jg}ddlm} fd| D}t |||}|d}td D]J} | |vr1t||||} t|| |||jgkrdSt|||||}K||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 factorintch|]}|zSr)r))r>drMs r z#gf_irred_p_rabin..s,,,1,,,rF) r1rrr sympy.ntheoryrrrKrxrr) r0rrrxrindicesrdrNr}rqrMs @rgf_irred_p_rabinrs  ! AAvt Aq!  DAq A'''''',,,,iill,,,G"1a++A !A 1a[[,, < q!Q""AaAq!!aeW, uu Q1a + + 6Mr)zben-orrabincztd}|t||||}nt|||}|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 rrrsH $ % %F *v&q!Q// Aq)) Lrct|||\}}|sdSt|t||||||jgkS)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_prsO Aq!  DAq <taAq))1a00QUG;;rcrt|||\}}|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_listrr)r0rrrsqfrqs r gf_sqf_partrsOAq ! !FAs A1 1aA   HrFcddgt|f\}}}}t|||\}}t|dkr|gfS t|||} | gkrt || ||} t || ||} d} | |jgkrvt | | ||} t | | ||}t|dkr||| |zft | | ||| | dz} } } | |jgkv| |jgkrd}n| }|sIt||z}td|dzD]} || |z|| <|d|dz||z}}nn|rtd||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!rK ValueError)r0rrallrMrfactorsrrrrqrNr}Grrs rrrsVE2s1vv-AsGQ Q1  EB||a2v  Aq!   7 q!Q""Aq!Q""AAw, 71aA&&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 )r1rrrrCrKr!) r0rrrMrrrr}qqrXr~s r gf_Qmatrixrts* Q<<QqA 16(AE""A a RD!a%L A 1q1uai!m $ $  R5&2,!#$aeAq! 4 4A IIqQx!Aqb1fI+-2 3 3 3 3A 2hhAadG  Hrc8d|Dt|}}td|D]$}||||jz |z|||<%td|D]"}t||D]}|||rn'|||||}td|D]}||||z|z|||< td|D]2}|||}||||||<||||<3td|D]U}||krM|||} td|D].}||||||| zz |z|||</V$td|D]Y}td|D]F}||kr#|j|||z |z|||<+||| |z|||<GZg} |D]&} t | r| | '| 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]] c,g|]}t|Sr))rC)r>rs rr?zgf_Qbasis..s ! ! !T!WW ! ! !rr)r/rKrrganyr!) rrrrMr9r}rr~rrbasiss r gf_Qbasisr st" " !a ! ! !3q66qA 1a[[((Q47QU?a'!Q 1a[[88q!  AtAw   hhqtAw""q! ( (AtAws{a'AaDGGq!  A!QAd1gAaDGAaDGGq! 8 8AAv 8aDGq!88A tAw1a2a7AaDGG  81a[[))q! ) )AAv )51Q47?a/!QaDG8q.!Q  ) E  q66  LLOOO Lrct|||}t|||}t|D]1\}}tt t |||<2|g}t dt|D]}t |D]}|j} | |krt||| ||} t|| ||} | |j gkrD| |kr>| |t|| ||}||| gt|t|krt|dccS| |j z } | |kόt|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;rCreversedrKr/rrarrremoverextendr ) r0rrrrr}rrr9rrqrNs r gf_berlekamprs 1aA!QA! ++1Xa[[))**!cG 1c!ff  g  AAa% !!A$1a001aA&&<+AF+NN1%%%q!Q**ANNAq6***w<<3q66)B(5AAAAAAAAQU a%  $ 5 1 1 11rc "d|j|jgg}}}t|||}d|zt|krt |||||}t |t ||j|jg||||}||jgkrL|||ft||||}t||||}t|||}|dz }d|zt|k||jgkr||t|fgzS|S)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() rrrr1rrrxr!rr)r0rrr}rqrrdrNs rgf_ddf_zassenhausrs/Fqv'qA"1a++A A#1   Q1a + + 1fQA661 = = < 4 NNAq6 " " "q!Q""Aq!Q""A*1a33A Q A#1   QUG|1ill+,,,rc |g}t||kr|St||z}|dkrt|||}|j|jg}t ||kr|dkrb|x}} t |dz D]'} t | d|||} t|| ||}(t||||} ||j|jgz }nRtd|zdz ||} t| |||||}t|t||j||||} | |jgkr;| |kr5t| |||tt|| |||||z}t ||kt|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/rKrrtrrrragf_edf_zassenhausrr ) r0rMrrrNrdrrNrr}rqs rrr?s@cG||q! AAv0 &q!Q / / A g,, A 6 ?IA1q5\\ ' 'q!Q1--1aA&&q!Q""A !&!&! !AA!a%!)Q**Aq!Q1a00Aq-15!Q77A>>A < AAF A'1a33#F1aA$6$61a@@AG! g,, A& 5 1 1 11rct|}ttt|dz}t |||}t |j|jg||||}|j|jg|g|jg|dz zz}td|dzD]!}t ||dz ||||||<"|||d|}}|g|jg|dz zz} td|D]!}t| |dz ||||| |<"g} t| D]\}} |jg|dz } }|D]8} t| | ||}t||||}t||||}9t||||}t||||}t!|D]i} t| | ||}t||||}||jgkr | |||dzz| z ft||||| dz } }j||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)r1r_ceil_sqrtrrrrrKrrrxrrrrrr!)r0rrrMr9rdrNrr}rrrr~rrqrs r gf_ddf_shouprs@ ! A E%1++  A"1a++A!%!Q155A %!xQ//A 1a!e__44!A#1a33! Q42A2qA qvhAA 1a[[44aAh1a33!G! --1wA1 # #Aq!Q""Aq!Q""Aq!Q""AA 1aA   1aA  ! - -Aq!Q""Aq!Q""AQUG| 31a!e9q=1222!Q1%%q1uqAA - QUG|*9Q<<())) Nrc ht|t|}}|sgS||kr|gS|g|j|jg}}t |dz ||}|dkr{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_shouprrrarr )r0rMrrrrrrrrNrh1h2rdh3s rrrs8 Q<<QqA  Avs quafoQG!a%AAAv( q!Q1 % % Aq!a%Aq 1 1! 4 Aq!Q   Ar1a r1a++2q!Q''( 'q!Q / / !Q1a + + q1q51*aA . . Aq!Q   A}Qq!44a ; ; Avb"a++Q 2 2r1a++2q!Q''(2q!Q''( 5 1 1 11rcg}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 r0rrrfactorrMs r gf_zassenhausr$ sVG&q!Q//66 $VQ1555 5 1 1 11rcg}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& sUG!!Q**11 <1a000 5 1 1 11r) berlekamp zassenhausshoupct|||\}}t|dkr|gfS|ptd}|t||||}nt |||}||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-<s Q1  EB||a2v  0u/00F )!&)!Q221a(( w;rct|||\}}t|dkr|gfSg}t|||dD]6\}}t|||dD]}|||f7|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-)rr1rr-r!r )r0rrrrrqrMrNs r gf_factorr/Ysd 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*rRrXs rgf_valuer1s1F ! !  Mrcddlm}|zdkr'zdkrttSgS||\}zdkrgSfdtDS)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)rc8g|]}zz|zzzzSr)r))r>rrdrqrrs rr?z%linear_congruence..s3 < < > !IeAqkkGAq!1uz < < < < < < <588 < < <>> 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.domainsr8rr1r5)rrrr0r8f_falphabetas r_raise_mod_powerr=sbB'&&&&& !Q  C S!  E a^^ q!t #D UD! , ,,rr-c  ddlmfdtD}|dkr|Sg}tt |dgt |z}|rr|\ }||kr| n=|dz |z| fdt |D|rt|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). rr7c@g|]}t|dk|Srr)r>r}r8r0rs rr?z csolve_prime.. s1 ; ; ;Aq"!5!5!: ;! ; ; ;rr-c$g|] }|zzf Sr)r))r>rpsrrs rr?z csolve_prime.. s%KKKq1R4xnKKKr) r9r8rKrCrr/popr!rr=sorted) r0rrX1Xr#rr8rArrs `` @@@@r csolve_primerFs"'&&&&& ; ; ; ; ; ;U1XX ; ; ;BAv  A SaSR[ ! !""A Muuww1 6 M HHQKKKKQBAB HHKKKKKK.>q!Q.J.JKKK L L L M !99rc\ ddlmddlm}||}fd|D}t t t|}gg}|D] fd|D}d|Dtfd|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. rr7rc8g|]\}}t||Sr))rF)r>rrr0s rr?zgf_csolve..5 s)55541aaA  555rc&g|] }D]}||gz Sr)r))r>rypools rr?zgf_csolve..9 s,666Q66AaS6666rc4g|]\}}t||Sr))pow)r>rrs rr?zgf_csolve..: s$444$!QC1II444rc2g|]}t|Sr))r)r>perr8 dist_factorss rr?zgf_csolve..; s%BBBS6#|R00BBBr) r9r8rritemsrCrDrrC) r0rMrPrEpoolspermsr8rPrKs ` @@@r gf_csolverU s0'&&&&&'''''' ! A555517799555A UA  E DE776666%66644!''))444L BBBBBEBBB C CCr)N)T)F)r-)\__doc__mathrrrrrsympy.core.randomrsympy.external.gmpyrsympy.polys.polyconfigrsympy.polys.polyerrorsr sympy.polys.polyutilsr rr$r&r+r1r5r7r;rArFrOrSrUrYr\r_rarerhrtrxrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrr$r&r,r-r/r1r5r=rFrUr)rrr]sFGG3333333333%%%%%%******((((((666666//////****Z08*$((8 * * * ((("8:    ,)))"88((((222" 9 9 9F 9 9 9F>(((V / / ////"   83,3,3,l!!!"$$$N(((6((# # # J   @###J". . . b   (   .   .???D2222<0..."   :65,5,5,n     D D D &***Z)))X  4<<<0   0VVVVr% % % P;;;|)2)2)2X666r=2=2=2@JJJX<2<2<2~222,222, :=&=&=&@( = = =F%-%-%-PD!D!D!D!D!Dr