o 8Vaz@sdZddlmZddlmZmZddlm Z ddl m Z ddl m Z ddlmZddlmZdd lmZdd d Zd dZddZddZddZddZddZddZddZddZdd Zdd"d#Zd$d%Z dd&d'Z!d(d)Z"d*d+Z#d,d-Z$d.d/Z%d0d1Z&d2d3Z'd4d5Z(d6d7Z)d8d9Z*d:d;Z+dd?Z-d@dAZ.dBdCZ/dDdEZ0dFdGZ1dHdIZ2dJdKZ3dLdMZ4dNdOZ5dPdQZ6dRdSZ7dTdUZ8dVdWZ9dXdYZ:dZd[Z;d\d]ZdbdcZ?dddeZ@dfdgZAdhdiZBdjdkZCdldmZDdndoZEdpdqZFdrdsZGdtduZHeGeHdvZIdwdxZJdydzZKd{d|ZLdd~dZMddZNddZOddZPddZQddZRddZSddZTddZUddZVePeUeVdZWdddZXddZYddZZddZ[ddZ\dddZ]ddZ^d S)zADense univariate polynomials with coefficients in Galois fields. )uniform)ceilsqrt) SYMPY_INTS)prod) factorint)query)ExactQuotientFailed) _sort_factorsNc Cs^t||jd}|j}t||D]\}}||}|||\}} } |||||7}q||S)aH Chinese Remainder Theorem. Given a set of integer residues ``u_0,...,u_n`` and a set of co-prime integer moduli ``m_0,...,m_n``, returns an integer ``u``, such that ``u = u_i mod m_i`` for ``i = ``0,...,n``. Examples ======== Consider a set of residues ``U = [49, 76, 65]`` and a set of moduli ``M = [99, 97, 95]``. Then we have:: >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_crt >>> gf_crt([49, 76, 65], [99, 97, 95], ZZ) 639985 This is the correct result because:: >>> [639985 % m for m in [99, 97, 95]] [49, 76, 65] Note: this is a low-level routine with no error checking. See Also ======== sympy.ntheory.modular.crt : a higher level crt routine sympy.ntheory.modular.solve_congruence start)ronezerozipgcdex) UMKpvumes_r9/usr/lib/python3/dist-packages/sympy/polys/galoistools.pygf_crts"rcCsXgg}}t||jd}|D]}||||||d|d|q|||fS)a First part of the Chinese Remainder Theorem. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_crt1 >>> gf_crt1([99, 97, 95], ZZ) (912285, [9215, 9405, 9603], [62, 24, 12]) r r)rr appendr)rrESrrrrrgf_crt1<s   r"c Cs>|j}t||||D]\}}} } || || |7}q ||S)a` Second part of the Chinese Remainder Theorem. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_crt2 >>> U = [49, 76, 65] >>> M = [99, 97, 95] >>> p = 912285 >>> E = [9215, 9405, 9603] >>> S = [62, 24, 12] >>> gf_crt2(U, M, p, E, S, ZZ) 639985 )rr) rrrr r!rrrrrrrrrgf_crt2Tsr#cCs||dkr|S||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 rarrrrgf_intps r'cCs t|dS)z Return the leading degree of ``f``. Examples ======== >>> from sympy.polys.galoistools import gf_degree >>> gf_degree([1, 1, 2, 0]) 3 >>> gf_degree([]) -1 lenfrrr gf_degrees r-cC|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 rrr,rrrrgf_LCr1cCr.)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 rr/r0rrrgf_TCr2r3cCs:|r|dr|Sd}|D] }|rn|d7}q ||dS)z Remove leading zeros from ``f``. Examples ======== >>> from sympy.polys.galoistools import gf_strip >>> gf_strip([0, 0, 0, 3, 0, 1]) [3, 0, 1] rr(Nr)r,kcoeffrrrgf_strips   r6cstfdd|DS)z Reduce all coefficients modulo ``p``. Examples ======== >>> from sympy.polys.galoistools import gf_trunc >>> gf_trunc([7, -2, 3], 5) [2, 3, 3] csg|]}|qSrr.0r&rrr zgf_trunc..)r6r,rrr9rgf_truncs r=cCsttt|||S)z Normalize all coefficients in ``K``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_normal >>> gf_normal([5, 10, 21, -3], 5, ZZ) [1, 2] )r=listmapr,rrrrr gf_normalsrAcCst|g}}t|tr$t|ddD]}||||j|qn|\}t|ddD]}|||f|j|q-t||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 isinstancerrangergetrr=)r,rrnhr4rrr gf_from_dicts  rITcCsVt|i}}td|dD]}|rt||||}n|||}|r(|||<q|S)aA Convert a ``GF(p)[x]`` polynomial to a dict. Examples ======== >>> from sympy.polys.galoistools import gf_to_dict >>> gf_to_dict([4, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4], 5) {0: -1, 4: -2, 10: -1} >>> gf_to_dict([4, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4], 5, symmetric=False) {0: 4, 4: 3, 10: 4} rr()r-rEr')r,r symmetricrGresultr4r&rrr gf_to_dicts rLcCs t||S)z Create a ``GF(p)[x]`` polynomial from ``Z[x]``. Examples ======== >>> from sympy.polys.galoistools import gf_from_int_poly >>> gf_from_int_poly([7, -2, 3], 5) [2, 3, 3] )r=r<rrrgf_from_int_poly5s rMcs|r fdd|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] csg|]}t|qSr)r')r8cr9rrr:Vz"gf_to_int_poly..r)r,rrJrr9rgf_to_int_polyEsrPcsfdd|DS)z Negate a polynomial in ``GF(p)[x]``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_neg >>> gf_neg([3, 2, 1, 0], 5, ZZ) [2, 3, 4, 0] csg|]}| qSrr)r8r5r9rrr:irOzgf_neg..rr@rr9rgf_neg[rQcCsJ|s||}n|d||}t|dkr|dd|gS|s"gS|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] rr(Nr)r,r&rrrrr gf_add_groundls  rTcCsL|s| |}n|d||}t|dkr|dd|gS|s#gS|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] rr(Nr)rSrrr gf_sub_grounds  rUcssgSfdd|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] csg|]}|qSrr)r8br%rrr:z!gf_mul_ground..rrSrr%r gf_mul_groundsrXcCst||||||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] )rXinvertrSrrr gf_quo_groundrZcs|s|S|s|St|}t|}||kr"tfddt||DSt||}||kr:|d|||d}}n |d|||d}}|fddt||DS)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] cg|] \}}||qSrrr8r&rVr9rrr:zgf_add..Ncr\rrr]r9rrr:r^)r-r6rabsr,grrdfdgr4rHrr9rgf_adds rdcs|s|S|s t||St|}t|}||kr&tfddt||DSt||}||kr>|d|||d}}nt|d||||d}}|fddt||DS)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] cg|] \}}||qSrrr]r9rrr:r^zgf_sub..Ncrerrr]r9rrr: r^)rQr-r6rr_r`rr9rgf_subs  "rfc Cst|}t|}||}dg|d}td|dD])}|j} ttd||t||dD]} | || ||| 7} q.| |||<qt|S)z Multiply polynomials in ``GF(p)[x]``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_mul >>> gf_mul([3, 2, 4], [2, 2, 2], 5, ZZ) [1, 0, 3, 2, 3] rr(r-rErrBminr6) r,rarrrbrcdhrHir5jrrrgf_muls"rlc Cst|}d|}dg|d}td|dD]O}|j}td||}t||} | |d} || dd} t|| dD]} ||| ||| 7}q<||7}| d@r_|| d} || d7}||||<qt|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(rg) r,rrrbrirHrjr5ZjminZjmaxrGrkelemrrrgf_sqr.s"    rncCt|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] )rdrlr,rarHrrrrr gf_add_mulYs rqcCro)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] )rfrlrprrr gf_sub_mulhsrrcCsPt|tur |\}}n|j}|g}|D]\}}t||||}t||||}q|S)a Expand results of :func:`~.factor` in ``GF(p)[x]``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_expand >>> gf_expand([([3, 2, 4], 1), ([2, 2], 2), ([3, 1], 3)], 5, ZZ) [4, 3, 0, 3, 0, 1, 4, 1] )typetupler gf_powrl)Frrlcrar,r4rrr gf_expandys   rxc Cst|}t|}|std||krg|fS||d|}t||||d}}} td|dD]8} || } ttd|| t|| | dD]} | || | |||| 8} qJ| |kre| |9} | ||| <q3|d|dt||ddfS)a  Division with remainder in ``GF(p)[x]``. Given univariate polynomials ``f`` and ``g`` with coefficients in a finite field with ``p`` elements, returns polynomials ``q`` and ``r`` (quotient and remainder) such that ``f = q*g + r``. Consider polynomials ``x**3 + x + 1`` and ``x**2 + x`` in GF(2):: >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_div, gf_add_mul >>> gf_div(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ) ([1, 1], [1]) As result we obtained quotient ``x + 1`` and remainder ``1``, thus:: >>> gf_add_mul(ZZ.map([1]), ZZ.map([1, 1]), ZZ.map([1, 1, 0]), 2, ZZ) [1, 0, 1, 1] References ========== .. [1] [Monagan93]_ .. [2] [Gathen99]_ polynomial divisionrr(N)r-ZeroDivisionErrorrYr>rErBrhr6 r,rarrrbrcinvrHZdqZdrrjr5rkrrrgf_divs &"$r}cCst||||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()r}r,rarrrrrgf_remrRrc Cst|}t|}|std||krgS||d|}|dd|||d}}} td|dD]2} || } ttd|| t|| | dD]} | || | |||| 8} qJ| |||| <q3|d|dS)aG Compute exact quotient in ``GF(p)[x]``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_quo >>> gf_quo(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ) [1, 1] >>> gf_quo(ZZ.map([1, 0, 3, 2, 3]), ZZ.map([2, 2, 2]), 5, ZZ) [3, 2, 4] ryrNr()r-rzrYrErBrhr{rrrgf_quos &"rcCs$t||||\}}|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] )r}r )r,rarrqrrrrgf_exquos rcCs|s|S||jg|S)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] r/r,rGrrrr gf_lshiftsrcCs(|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]) Nrrrrr gf_rshift2srcCst|s|jgS|dkr |S|dkrt|||S|jg} |d@r*t||||}|d8}|dL}|s3 |St|||}q)z Compute ``f**n`` in ``GF(p)[x]`` using repeated squaring. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_pow >>> gf_pow([3, 2, 4], 3, 5, ZZ) [2, 4, 4, 2, 2, 1, 4] r(r$)r rnrl)r,rGrrrHrrrruFs"  rucCst|}|dkr gSdg|}dg|d<||kr5td|D]}t||d||}t||||||<q|S|dkrit|j|jg|||||d<td|D]}t||d|d||||<t|||||||<qL|S)ah return the list of ``x**(i*p) mod g in Z_p`` for ``i = 0, .., n - 1`` where ``n = gf_degree(g)`` Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_frobenius_monomial_base >>> g = ZZ.map([1, 0, 2, 1]) >>> gf_frobenius_monomial_base(g, 5, ZZ) [[1], [4, 4, 2], [1, 2]] rr(r$)r-rErr gf_pow_modr rrl)rarrrGrVrjZmonrrrgf_frobenius_monomial_baseks   rc Cs|t|}t||krt||||}|sgSt|}|dg}td|dD]}t|||||||} t|| ||}q%|S)aT compute gf_pow_mod(f, p, g, p, K) using the Frobenius map Parameters ========== f, g : polynomials in ``GF(p)[x]`` b : frobenius monomial base p : prime number K : domain Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_frobenius_monomial_base, gf_frobenius_map >>> f = ZZ.map([2, 1 , 0, 1]) >>> g = ZZ.map([1, 0, 2, 1]) >>> p = 5 >>> b = gf_frobenius_monomial_base(g, p, ZZ) >>> r = gf_frobenius_map(f, g, b, p, ZZ) >>> gf_frobenius_map(f, g, b, p, ZZ) [4, 0, 3] rr()r-rrErXrd) r,rarVrrrrGZsfrjrrrrgf_frobenius_maps  rc Csnt||||}|}|}td|D]}t|||||}t||||}t||||}qt||dd|||} | S)z utility function for ``gf_edf_zassenhaus`` Compute ``f**((p**n - 1) // 2)`` in ``GF(p)[x]/(g)`` ``f**((p**n - 1) // 2) = (f*f**p*...*f**(p**n - 1))**((p - 1) // 2)`` r(r$)rrErrlr) r,rGrarVrrrHrrjresrrr_gf_pow_pnm1d2srcCs|s|jgS|dkrt||||S|dkr tt||||||S|jg} |d@r;t||||}t||||}|d8}|dL}|sD |St|||}t||||}q%)a* Compute ``f**n`` in ``GF(p)[x]/(g)`` using repeated squaring. Given polynomials ``f`` and ``g`` in ``GF(p)[x]`` and a non-negative integer ``n``, efficiently computes ``f**n (mod g)`` i.e. the remainder of ``f**n`` from division by ``g``, using the repeated squaring algorithm. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_pow_mod >>> gf_pow_mod(ZZ.map([3, 2, 4]), 3, ZZ.map([1, 1]), 5, ZZ) [] References ========== .. [1] [Gathen99]_ r(r$)r rrnrl)r,rGrarrrHrrrrs& rcCs,|r|t||||}}|st|||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_monicr~rrrgf_gcdsrcCs>|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()rrlrrr,rarrrHrrrgf_lcms rcCs>|s |s gggfSt||||}|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]) )rrrrrr gf_cofactorss   rcCs|s |s |jgggfSt|||\}}t|||\}}|s'g|||g|fS|s3|||gg|fS|||gg}} g|||g} } t||||\} } | sTn6t| |||\}}}|||}t|| | ||}t| | | ||}t||||| } }t||||| } } qH| | |fS)a Extended Euclidean Algorithm in ``GF(p)[x]``. Given polynomials ``f`` and ``g`` in ``GF(p)[x]``, computes polynomials ``s``, ``t`` and ``h``, such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. The typical application of EEA is solving polynomial diophantine equations. Consider polynomials ``f = (x + 7) (x + 1)``, ``g = (x + 7) (x**2 + 1)`` in ``GF(11)[x]``. Application of Extended Euclidean Algorithm gives:: >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_gcdex, gf_mul, gf_add >>> s, t, g = gf_gcdex(ZZ.map([1, 8, 7]), ZZ.map([1, 7, 1, 7]), 11, ZZ) >>> s, t, g ([5, 6], [6], [1, 7]) As result we obtained polynomials ``s = 5*x + 6`` and ``t = 6``, and additionally ``gcd(f, g) = x + 7``. This is correct because:: >>> S = gf_mul(s, ZZ.map([1, 8, 7]), 11, ZZ) >>> T = gf_mul(t, ZZ.map([1, 7, 1, 7]), 11, ZZ) >>> gf_add(S, T, 11, ZZ) == [1, 7] True References ========== .. [1] [Gathen99]_ )r rrYr}rrrX)r,rarrZp0Zr0Zp1Zr1Zs0s1Zt0t1QRrwr|rtrrrgf_gcdex4s,!  rcCs>|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)rZis_oner>rZ)r,rrrwrrrrvs    rcCs`t|}|jg||}}|ddD]}|||9}||;}|r'||||<|d8}qt|S)z Differentiate polynomial in ``GF(p)[x]``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_diff >>> gf_diff([3, 2, 4], 5, ZZ) [1, 2] Nrr()r-rr6)r,rrrbrHrGr5rrrgf_diffs   rcCs,|j}|D]}||9}||7}||;}q|S)z Evaluate ``f(a)`` in ``GF(p)`` using Horner scheme. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_eval >>> gf_eval([3, 2, 4], 2, 5, ZZ) 0 r/)r,r&rrrKrNrrrgf_evals  rcsfdd|DS)a  Evaluate ``f(a)`` for ``a`` in ``[a_1, ..., a_n]``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_multi_eval >>> gf_multi_eval([3, 2, 4], [0, 1, 2, 3, 4], 5, ZZ) [4, 4, 0, 2, 0] csg|] }t|qSrrr7rr,rrrr:z!gf_multi_eval..r)r,Arrrrr gf_multi_evalr[rcCsjt|dkrtt|t||||gS|sgS|dg}|ddD]}t||||}t||||}q"|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*r6rr1rlrT)r,rarrrHrNrrr gf_composes  rcCsR|sgS|dg}|ddD]}t||||}t||||}t||||}q|S)a& Compute polynomial composition ``g(h)`` in ``GF(p)[x]/(f)``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_compose_mod >>> gf_compose_mod(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 2]), ZZ.map([4, 3]), 5, ZZ) [4] rr(N)rlrTr)rarHr,rrcompr&rrrgf_compose_mods rc Cst|||||}|}|d@rt||||} |} n|} |} |dL}|rVt|t|||||||}t|||||}|d@rPt| t|| |||||} t|| |||} |dL}|s"t|| |||| fS)a Compute polynomial trace map in ``GF(p)[x]/(f)``. Given a polynomial ``f`` in ``GF(p)[x]``, polynomials ``a``, ``b``, ``c`` in the quotient ring ``GF(p)[x]/(f)`` such that ``b = c**t (mod f)`` for some positive power ``t`` of ``p``, and a positive integer ``n``, returns a mapping:: a -> a**t**n, a + a**t + a**t**2 + ... + a**t**n (mod f) In factorization context, ``b = x**p mod f`` and ``c = x mod f``. This way we can efficiently compute trace polynomials in equal degree factorization routine, much faster than with other methods, like iterated Frobenius algorithm, for large degrees. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_trace_map >>> gf_trace_map([1, 2], [4, 4], [1, 1], 4, [3, 2, 4], 5, ZZ) ([1, 3], [1, 3]) References ========== .. [1] [Gathen92]_ r()rrd) r&rVrNrGr,rrrrrVrrr gf_trace_maps" rc CsVt||||}|}|}td|D]}t|||||}t||||}t||||}q|S)z& utility for ``gf_edf_shoup`` r()rrErrd) r,rGrarVrrrHrrjrrr _gf_trace_mapEsrcs"jgfddtd|DS)a Generate a random polynomial in ``GF(p)[x]`` of degree ``n``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_random >>> gf_random(10, 5, ZZ) #doctest: +SKIP [1, 2, 3, 2, 1, 1, 1, 2, 0, 4, 2] csg|] }ttdqSr)intrr8rjrrrrr:`szgf_random..r)r rE)rGrrrrr gf_randomSs" rcCs t|||}t|||r|Sq)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)rGrrr,rrrgf_irreduciblecs   rc Cs$t|}|dkr dSt|||\}}|dkrQt|j|jg||||}}td|dD]#}t||j|jg||}t|||||jgkrLt|||||}q+dSdSt |||} t |j|jg|| ||}}td|dD]#}t||j|jg||}t|||||jgkrt ||| ||}qldSdS)a_ Ben-Or's polynomial irreducibility test over finite fields. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_irred_p_ben_or >>> gf_irred_p_ben_or(ZZ.map([1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]), 5, ZZ) True >>> gf_irred_p_ben_or(ZZ.map([3, 2, 4]), 5, ZZ) False r(Trr$F) r-rrr rrErfrrrr) r,rrrGrHrHrjrarVrrrgf_irred_p_ben_orvs( rc st|dkr dSt|||\}}|j|jg}fddtD}t|||}|d}tdD]#}||vrMt||||} t|| |||jgkrMdSt |||||}q2||kS)a[ Rabin's polynomial irreducibility test over finite fields. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_irred_p_rabin >>> gf_irred_p_rabin(ZZ.map([1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]), 5, ZZ) True >>> gf_irred_p_rabin(ZZ.map([3, 2, 4]), 5, ZZ) False r(Tcsh|]}|qSrr)r8drGrr r;z#gf_irred_p_rabin..F) r-rr rrrrErfrr) r,rrrxindicesrVrHrjrarrrgf_irred_p_rabins  r)zben-orZrabincCs4td}|durt||||}|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 ZGF_IRRED_METHODN)r_irred_methodsr)r,rrmethodZirredrrrrs  rcCs6t|||\}}|s dSt|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 )r,rrrrrrgf_sqf_psrcCs8t|||\}}|jg}|D] \}}t||||}q|S)a Return square-free part of a ``GF(p)[x]`` polynomial. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_sqf_part >>> gf_sqf_part(ZZ.map([1, 1, 3, 0, 1, 0, 2, 2, 1]), 5, ZZ) [1, 4, 3] ) gf_sqf_listr rl)r,rrrsqfrarrr gf_sqf_parts  rFcCs`ddgt|f\}}}}t|||\}}t|dkr|gfS t|||} | gkr|t|| ||} t|| ||} d} | |jgkrqt| | ||} t| | ||}t|dkr\||| |ft| | ||| | d} } } | |jgks?| |jgkrzd}n| }|st||}td|dD] } || ||| <q|d|d||}}nnq|rt d||fS)a Return the square-free decomposition of a ``GF(p)[x]`` polynomial. Given a polynomial ``f`` in ``GF(p)[x]``, returns the leading coefficient of ``f`` and a square-free decomposition ``f_1**e_1 f_2**e_2 ... f_k**e_k`` such that all ``f_i`` are monic polynomials and ``(f_i, f_j)`` for ``i != j`` are co-prime and ``e_1 ... e_k`` are given in increasing order. All trivial terms (i.e. ``f_i = 1``) aren't included in the output. Consider polynomial ``f = x**11 + 1`` over ``GF(11)[x]``:: >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import ( ... gf_from_dict, gf_diff, gf_sqf_list, gf_pow, ... ) ... # doctest: +NORMALIZE_WHITESPACE >>> f = gf_from_dict({11: ZZ(1), 0: ZZ(1)}, 11, ZZ) Note that ``f'(x) = 0``:: >>> gf_diff(f, 11, ZZ) [] This phenomenon doesn't happen in characteristic zero. However we can still compute square-free decomposition of ``f`` using ``gf_sqf()``:: >>> gf_sqf_list(f, 11, ZZ) (1, [([1, 1], 11)]) We obtained factorization ``f = (x + 1)**11``. This is correct because:: >>> gf_pow([1, 1], 11, 11, ZZ) == f True References ========== .. [1] [Geddes92]_ r(FTrNz'all=True' is not supported yet) rrr-rrrr rrE ValueError)r,rrallrGrfactorsrrwrvrarHrjGrrrrrrs<+      !rc Cst|t|}}|jg|jg|d}t|ggg|d}td|d|dD]=}|d |d|g|d}} td|D]} ||| d| || d|qD||sgt||||<|}q,|S)ad Calculate Berlekamp's ``Q`` matrix. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_Qmatrix >>> gf_Qmatrix([3, 2, 4], 5, ZZ) [[1, 0], [3, 4]] >>> gf_Qmatrix([1, 0, 0, 0, 1], 5, ZZ) [[1, 0, 0, 0], [0, 4, 0, 0], [0, 0, 1, 0], [0, 0, 0, 4]] r(r)r-rr rr>rEr) r,rrrGrrrrjZqqrNrkrrr gf_Qmatrixus"*rc Csdd|Dt|}}td|D]}||||j||||<qtd|D]}t||D] }|||r9nq/q(|||||}td|D]}||||||||<qJtd|D]}|||}||||||<||||<q`td|D](}||kr|||} td|D]}||||||| ||||<qq~q(td|D]+}td|D]#}||kr|j|||||||<q||| ||||<qqg} |D] } t| r| | q| S)a_ Compute a basis of the kernel of ``Q``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_Qmatrix, gf_Qbasis >>> gf_Qbasis(gf_Qmatrix([1, 0, 0, 0, 1], 5, ZZ), 5, ZZ) [[1, 0, 0, 0], [0, 0, 1, 0]] >>> gf_Qbasis(gf_Qmatrix([3, 2, 4], 5, ZZ), 5, ZZ) [[1, 0]] cSsg|]}t|qSr)r>)r8rrrrr:r;zgf_Qbasis..r)r*rEr rYanyr) rrrrGr4rjr|rkrrZbasisrrr gf_QbasissF    *  rc Cst|||}t|||}t|D]\}}ttt|||<q|g}tdt|D]X}t|D]Q}|j} | |krt ||| ||} t || ||} | |j gkre| |kre| |t || ||}||| gt|t|krwt|ddS| |j 7} | |ks8q/q)t|ddS)a Factor a square-free ``f`` in ``GF(p)[x]`` for small ``p``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_berlekamp >>> gf_berlekamp([1, 0, 0, 0, 1], 5, ZZ) [[1, 0, 2], [1, 0, 3]] r(FZmultiple)rr enumerater6r>reversedrEr*rrUrr removerextendr ) r,rrrrrjrrr4rrarHrrr gf_berlekamps,      rcCsd|j|jgg}}}t|||}d|t|kr_t|||||}t|t||j|jg||||}||jgkrS|||ft||||}t ||||}t|||}|d7}d|t|ks||jgkrn||t|fgS|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$) r rrr-rrrfrrr)r,rrrjrarrVrHrrrgf_ddf_zassenhauss#     rc Cs*|g}t||kr |St||}|dkrt|||}t||krtd|d||}|dkrV|}tdd||dD]} t|d|||}t||||}q>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_edf_zassenhaus >>> gf_edf_zassenhaus([1,1,1,1], 1, 5, ZZ) [[1, 1], [1, 2], [1, 3]] References ========== .. [1] [Gathen99]_ .. [2] [Geddes92]_ r$r(rFr)r-rr*rrErrdrrrUr gf_edf_zassenhausrr ) r,rGrrrNrVrrHrjrarrrr@s,      rcCst|}ttt|d}t|||}t|j|jg||||}|j|jg|g|jg|d}td|dD]}t||d||||||<q7|||d|}}|g|jg|d} td|D]}t | |d||||| |<qcg} t | D]i\}} |jg|d}} |D]} t | | ||}t ||||}t ||||}qt||||}t||||}t|D]/} t | | ||}t||||}||jgkr| |||d| ft||||| d}} qqz||jgkr| |t|f| S)a Kaltofen-Shoup: Deterministic Distinct Degree Factorization Given a monic square-free polynomial ``f`` in ``GF(p)[x]``, computes partial distinct degree factorization ``f_1,...,f_d`` of ``f`` where ``deg(f_i) != deg(f_j)`` for ``i != j``. The result is returned as a list of pairs ``(f_i, e_i)`` where ``deg(f_i) > 0`` and ``e_i > 0`` is an argument to the equal degree factorization routine. This algorithm is an improved version of Zassenhaus algorithm for large ``deg(f)`` and modulus ``p`` (especially for ``deg(f) ~ lg(p)``). Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_ddf_shoup, gf_from_dict >>> f = gf_from_dict({6: ZZ(1), 5: ZZ(-1), 4: ZZ(1), 3: ZZ(1), 1: ZZ(-1)}, 3, ZZ) >>> gf_ddf_shoup(f, 3, ZZ) [([1, 1, 0], 1), ([1, 1, 0, 1, 2], 2)] References ========== .. [1] [Kaltofen98]_ .. [2] [Shoup95]_ .. [3] [Gathen92]_ r$r(N)r-r_ceil_sqrtrrr rrErrrfrlrrrrr)r,rrrGr4rVrHrrjrrrrkrrarvrrr gf_ddf_shoupxs<      rcCsft|t|}}|s gS||kr|gS|g|j|jg}}t|d||}|dkr]t|||||} t|| ||d|||d} t|| ||} t|| ||} t | |||t | |||}nPt |||} t |||| ||} t| |dd|||} t|| ||} t|t | |j||||} t|t | | ||||}t | |||t | |||t ||||}t|ddS)a Gathen-Shoup: Probabilistic Equal Degree Factorization Given a monic square-free polynomial ``f`` in ``GF(p)[x]`` and integer ``n`` such that ``n`` divides ``deg(f)``, returns all irreducible factors ``f_1,...,f_d`` of ``f``, each of degree ``n``. This is a complete factorization over Galois fields. This algorithm is an improved version of Zassenhaus algorithm for large ``deg(f)`` and modulus ``p`` (especially for ``deg(f) ~ lg(p)``). Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_edf_shoup >>> gf_edf_shoup(ZZ.map([1, 2837, 2277]), 1, 2917, ZZ) [[1, 852], [1, 1985]] References ========== .. [1] [Shoup91]_ .. [2] [Gathen92]_ r(r$Fr)r-rr rrrrrr gf_edf_shouprrrUrlr )r,rGrrrrrrrrHrZh1Zh2rVZh3rrrrs6       rcC8g}t|||D] \}}|t||||7}qt|ddS)a Factor a square-free ``f`` in ``GF(p)[x]`` for medium ``p``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_zassenhaus >>> gf_zassenhaus(ZZ.map([1, 4, 3]), 5, ZZ) [[1, 1], [1, 3]] Fr)rrr r,rrrZfactorrGrrr gf_zassenhaus rcCr)a Factor a square-free ``f`` in ``GF(p)[x]`` for large ``p``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_shoup >>> gf_shoup(ZZ.map([1, 4, 3]), 5, ZZ) [[1, 1], [1, 3]] Fr)rrr rrrrgf_shouprr)Z berlekampZ zassenhausZshoupcCsdt|||\}}t|dkr|gfS|ptd}|dur(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(ZGF_FACTOR_METHODN)rr-r_factor_methodsr)r,rrrrwrrrr gf_factor_sqf5s   rcCsrt|||\}}t|dkr|gfSg}t|||dD]\}}t|||dD] }|||fq(q|t|fS)a Factor (non square-free) polynomials in ``GF(p)[x]``. Given a possibly non square-free polynomial ``f`` in ``GF(p)[x]``, returns its complete factorization into irreducibles:: f_1(x)**e_1 f_2(x)**e_2 ... f_d(x)**e_d where each ``f_i`` is a monic polynomial and ``gcd(f_i, f_j) == 1``, for ``i != j``. The result is given as a tuple consisting of the leading coefficient of ``f`` and a list of factors of ``f`` with their multiplicities. The algorithm proceeds by first computing square-free decomposition of ``f`` and then iteratively factoring each of square-free factors. Consider a non square-free polynomial ``f = (7*x + 1) (x + 2)**2`` in ``GF(11)[x]``. We obtain its factorization into irreducibles as follows:: >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_factor >>> gf_factor(ZZ.map([5, 2, 7, 2]), 11, ZZ) (5, [([1, 2], 1), ([1, 8], 2)]) We arrived with factorization ``f = 5 (x + 2) (x + 8)**2``. We didn't recover the exact form of the input polynomial because we requested to get monic factors of ``f`` and its leading coefficient separately. Square-free factors of ``f`` can be factored into irreducibles over ``GF(p)`` using three very different methods: Berlekamp efficient for very small values of ``p`` (usually ``p < 25``) Cantor-Zassenhaus efficient on average input and with "typical" ``p`` Shoup-Kaltofen-Gathen efficient with very large inputs and modulus If you want to use a specific factorization method, instead of the default one, set ``GF_FACTOR_METHOD`` with one of ``berlekamp``, ``zassenhaus`` or ``shoup`` values. References ========== .. [1] [Gathen99]_ r()rr-rrrr )r,rrrwrrarGrHrrr gf_factorRs2  rcCs"d}|D] }||9}||7}q|S)z Value of polynomial 'f' at 'a' in field R. Examples ======== >>> from sympy.polys.galoistools import gf_value >>> gf_value([1, 7, 2, 4], 11) 2204 rr)r,r&rKrNrrrgf_values   rcspddlm}|dkrdkrttSgS||\}dkr*gSfddtDS)a Returns the values of x satisfying a*x congruent b mod(m) Here m is positive integer and a, b are natural numbers. This function returns only those values of x which are distinct mod(m). Examples ======== >>> from sympy.polys.galoistools import linear_congruence >>> linear_congruence(3, 12, 15) [4, 9, 14] There are 3 solutions distinct mod(15) since gcd(a, m) = gcd(3, 15) = 3. References ========== .. [1] https://en.wikipedia.org/wiki/Linear_congruence_theorem r)rcs(g|]}|qSrr)r8rrVrarrrrr:s(z%linear_congruence..)Zsympy.polys.polytoolsrr>rE)r&rVrrrrrrlinear_congruences     rcCsBddlm}t|||}t||}t|| ||}t|||S)a0 Used in gf_csolve to generate solutions of f(x) cong 0 mod(p**(s + 1)) from the solutions of f(x) cong 0 mod(p**s). Examples ======== >>> from sympy.polys.galoistools import _raise_mod_power >>> from sympy.polys.galoistools import csolve_prime These is the solutions of f(x) = x**2 + x + 7 cong 0 mod(3) >>> f = [1, 1, 7] >>> csolve_prime(f, 3) [1] >>> [ i for i in range(3) if not (i**2 + i + 7) % 3] [1] The solutions of f(x) cong 0 mod(9) are constructed from the values returned from _raise_mod_power: >>> x, s, p = 1, 1, 3 >>> V = _raise_mod_power(x, s, p, f) >>> [x + v * p**s for v in V] [1, 4, 7] And these are confirmed with the following: >>> [ i for i in range(3**2) if not (i**2 + i + 7) % 3**2] [1, 4, 7] rZZ)sympy.polys.domainsrrrr)rrrr,rZf_fZalphaZbetarrr_raise_mod_powers !   rr(csddlmfddtD}|dkr|Sg}tt|dgt|}|rV|\}||kr9|n|d||fddt |D|s)t |S)aU Solutions of f(x) congruent 0 mod(p**e). Examples ======== >>> from sympy.polys.galoistools import csolve_prime >>> csolve_prime([1, 1, 7], 3, 1) [1] >>> csolve_prime([1, 1, 7], 3, 2) [1, 4, 7] Solutions [7, 4, 1] (mod 3**2) are generated by ``_raise_mod_power()`` from solution [1] (mod 3). rrcs"g|] }t|dkr|qSrrr)rr,rrrr: s"z csolve_prime..r(csg|] }|fqSrr)r8r)psrrrrr: r^) rrrEr>rr*poprrrsorted)r,rrZX1Xr!rr)rr,rrrrr csolve_primes   &rcsddlmt|}fdd|D}ttt|}gg}|D] fdd|D}q!dd|Dtfdd|DS)a= To solve f(x) congruent 0 mod(n). n is divided into canonical factors and f(x) cong 0 mod(p**e) will be solved for each factor. Applying the Chinese Remainder Theorem to the results returns the final answers. Examples ======== Solve [1, 1, 7] congruent 0 mod(189): >>> from sympy.polys.galoistools import gf_csolve >>> gf_csolve([1, 1, 7], 189) [13, 49, 76, 112, 139, 175] References ========== .. [1] 'An introduction to the Theory of Numbers' 5th Edition by Ivan Niven, Zuckerman and Montgomery. rrcsg|] \}}t||qSr)rr8rrr+rrr:- r^zgf_csolve..cs g|] }D]}||gqqSrr)r8ry)poolrrr:1 s cSsg|] \}}t||qSr)powrrrrr:2 rcsg|]}t|qSr)r)r8Zper)r dist_factorsrrr:3 rW)rrritemsr>r?rtr)r,rGPrZpoolsZpermsr)rrr,rr gf_csolve s r)N)T)F)r()___doc__ZrandomrZmathrrrrZsympy.core.compatibilityrZsympy.core.mulrZ sympy.ntheoryrZsympy.polys.polyconfigrZsympy.polys.polyerrorsr Zsympy.polys.polyutilsr rr"r#r'r-r1r3r6r=rArIrLrMrPrQrTrUrXrZrdrfrlrnrqrrrxr}rrrrrrurrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrs        -  ##+6'% %1B7-* Y(>,98L? @# ( "