\c@sddlmZddlmZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZddlmZddlmZdd lZd Zd Zd Zd ZdZdZdZdZdZdZdZe dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*d dZ,d Z-d!Z.d"Z/d#Z0d$Z1d%Z2d&Z3d'Z4d(Z5d)Z6d S(*i(tDummy(trange(t nextprime(tcrt(tPolynomialRing(tgf_gcdt gf_from_dicttgf_gcdextgf_divtgf_lcm(tModularGCDFailed(tsqrtNcCs|j}|p|s+|j|j|jfS|sq|j|jjkr[| |j|j fS||j|jfSnF|s|j|jjkr| |j |jfS||j|jfSndS(sn Compute the GCD of two polynomials in trivial cases, i.e. when one or both polynomials are zero. N(tringtzerotLCtdomaintonetNone(tftgR ((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt _trivial_gcds  cCs|jj}x|r|}|j}|j|j|}xYtr|j}||kraPn||j||fj||jj|}q?W|}|}qW|j|j|j|j|S(sM Compute the GCD of two univariate polynomials in `\mathbb{Z}_p[x]`. ( R RtdegreetinvertRtTruet mul_monomt mul_groundt trunc_ground(tfptgptptdomtremtdegtlcinvtdegrem((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt_gf_gcd$s      7 cCs|jjj|j|j}d}t|}x ||dkrRt|}q3W|j|}|j|}t|||}|j}|S(s Compute an upper bound for the degree of the GCD of two univariate integer polynomials `f` and `g`. The function chooses a suitable prime `p` and computes the GCD of `f` and `g` in `\mathbb{Z}_p[x]`. The choice of `p` guarantees that the degree in `\mathbb{Z}_p[x]` is greater than or equal to the degree in `\mathbb{Z}[x]`. Parameters ========== f : PolyElement univariate integer polynomial g : PolyElement univariate integer polynomial ii(R RtgcdRRRR#R(RRtgammaRRRthptdeghp((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt_degree_bound_univariate;s  cCs|j}|jjd}|jj}x^t|dD]L}t||g|j|||j||gdtd||f>> from sympy.polys.modulargcd import _chinese_remainder_reconstruction_univariate >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> p = 3 >>> q = 5 >>> hp = -x**3 - 1 >>> hq = 2*x**3 - 2*x**2 + x >>> hpq = _chinese_remainder_reconstruction_univariate(hp, hq, p, q) >>> hpq 2*x**3 + 3*x**2 + 6*x + 5 >>> hpq.trunc_ground(p) == hp True >>> hpq.trunc_ground(q) == hq True iit symmetric( RR tgensR RRtcoeffRt strip_zero(R&thqRtqtntxthpqti((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt,_chinese_remainder_reconstruction_univariate\s6  J cCs|j|jkr!|jjjs'tt||}|dk rF|S|j}|j\}}|j\}}|jj||}t||}|dkr|||j |||j ||fS|jj|j |j }d} d} xt rt | } x || dkr.t | } qW|j | } |j | } t| | | } | j}||kr}qn||krd} |}qn| j |j | } | dkr| } | }qnt| || | }| | 9} ||ks|}qn|j|j}|j|\}}|j|\}}| r| r|j dkrn| }n|j |}|j ||}|j ||}|||fSqWdS(s Computes the GCD of two polynomials in `\mathbb{Z}[x]` using a modular algorithm. The algorithm computes the GCD of two univariate integer polynomials `f` and `g` by computing the GCD in `\mathbb{Z}_p[x]` for suitable primes `p` and then reconstructing the coefficients with the Chinese Remainder Theorem. Trial division is only made for candidates which are very likely the desired GCD. Parameters ========== f : PolyElement univariate integer polynomial g : PolyElement univariate integer polynomial Returns ======= h : PolyElement GCD of the polynomials `f` and `g` cff : PolyElement cofactor of `f`, i.e. `\frac{f}{h}` cfg : PolyElement cofactor of `g`, i.e. `\frac{g}{h}` Examples ======== >>> from sympy.polys.modulargcd import modgcd_univariate >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> f = x**5 - 1 >>> g = x - 1 >>> h, cff, cfg = modgcd_univariate(f, g) >>> h, cff, cfg (x - 1, x**4 + x**3 + x**2 + x + 1, 1) >>> cff * h == f True >>> cfg * h == g True >>> f = 6*x**2 - 6 >>> g = 2*x**2 + 4*x + 2 >>> h, cff, cfg = modgcd_univariate(f, g) >>> h, cff, cfg (2*x + 2, 3*x - 3, x + 1) >>> cff * h == f True >>> cfg * h == g True References ========== 1. [Monagan00]_ iiN(R Rtis_ZZtAssertionErrorRRt primitiveR$R(RRRRRR#RR3t quo_groundtcontenttdiv(RRtresultR tcftcgtchtboundR%tmRRRR&R'thlastmthmthtfquotfremtgquotgremtcfftcfg((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pytmodgcd_univariates`C'   -         c Cs |j}|j}|j}i}xQ|jD]C\}}|d |kr[i||d >> from sympy.polys.modulargcd import _primitive >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> p = 3 >>> f = x**2*y**2 + x**2*y - y**2 - y >>> _primitive(f, p) (y**2 + y, x**2 - 1) >>> R, x, y, z = ring("x, y, z", ZZ) >>> f = x*y*z - y**2*z**2 >>> _primitive(f, p) (z, x*y - y**2*z) itsymbolsi(R Rtngenst itertermstitertvaluesRRtcloneRJt from_denseRtquotset_ring( RRR RtktcoeffstmonomR+tconttyringtcontf((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt _primitives)   %cCsR|jj}d|d}x1|jD]#}|d |kr'|d }q'q'W|S(s Compute the degree of a multivariate polynomial `f \in K[x_0, \ldots, x_{k-2}, y] \cong K[y][x_0, \ldots, x_{k-2}]`. Parameters ========== f : PolyElement polynomial in `K[x_0, \ldots, x_{k-2}, y]` Returns ======= degf : Integer tuple degree of `f` in `x_0, \ldots, x_{k-2}` Examples ======== >>> from sympy.polys.modulargcd import _deg >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2*y**2 + x**2*y - 1 >>> _deg(f) (2,) >>> R, x, y, z = ring("x, y, z", ZZ) >>> f = x**2*y**2 + x**2*y - 1 >>> _deg(f) (2, 2) >>> f = x*y*z - y**2*z**2 >>> _deg(f) (1, 1) iii(i(R RKt itermonoms(RRStdegfRU((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt_deg[s ( c Cs|j}|j}|jd|j|d}|jd}t|}|j}xC|jD]5\}}|d |kr^||||d7}q^q^W|S(s Compute the leading coefficient of a multivariate polynomial `f \in K[x_0, \ldots, x_{k-2}, y] \cong K[y][x_0, \ldots, x_{k-2}]`. Parameters ========== f : PolyElement polynomial in `K[x_0, \ldots, x_{k-2}, y]` Returns ======= lcf : PolyElement polynomial in `K[y]`, leading coefficient of `f` Examples ======== >>> from sympy.polys.modulargcd import _LC >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2*y**2 + x**2*y - 1 >>> _LC(f) y**2 + y >>> R, x, y, z = ring("x, y, z", ZZ) >>> f = x**2*y**2 + x**2*y - 1 >>> _LC(f) 1 >>> f = x*y*z - y**2*z**2 >>> _LC(f) z RJiii(R RKRORJR*R\R RL( RR RSRWtyR[tlcfRUR+((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt_LCs(     cCs^|j}|j}xE|jD]7\}}||f|| ||d}|||>> from sympy.polys.modulargcd import _chinese_remainder_reconstruction_multivariate >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> p = 3 >>> q = 5 >>> hp = x**3*y - x**2 - 1 >>> hq = -x**3*y - 2*x*y**2 + 2 >>> hpq = _chinese_remainder_reconstruction_multivariate(hp, hq, p, q) >>> hpq 4*x**3*y + 5*x**2 + 3*x*y**2 + 2 >>> hpq.trunc_ground(p) == hp True >>> hpq.trunc_ground(q) == hq True >>> R, x, y, z = ring("x, y, z", ZZ) >>> p = 6 >>> q = 5 >>> hp = 3*x**4 - y**3*z + z >>> hq = -2*x**4 + z >>> hpq = _chinese_remainder_reconstruction_multivariate(hp, hq, p, q) >>> hpq 3*x**4 + 5*y**3*z + z >>> hpq.trunc_ground(p) == hp True >>> hpq.trunc_ground(q) == hq True cSs#t||g||gdtdS(NR)i(RR(tcptcqRR.((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pytcrt_ls( tsettmonomst intersectiontdifference_updateR RR t isinstanceRt._chinese_remainder_reconstruction_multivariate( R&R-RR.thpmonomsthqmonomsRwR R1RuRU((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyR{s"H      % ! !cCs|j}|r.|jj}|jj|}n|j}|j|}xt||D]\} } |j} |j} x<|D]4} | | krqyn| || 9} | | | 9} qyW|j| |} | j| }|| j||7}qTW|j|S(s Reconstruct a polynomial `h_p` in `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]` from a list of evaluation points in `\mathbb{Z}_p` and a list of polynomials in `\mathbb{Z}_p[x_0, \ldots, x_{i-1}, x_{i+1}, \ldots, x_{k-1}]`, which are the images of `h_p` evaluated in the variable `x_i`. It is also possible to reconstruct a parameter of the ground domain, i.e. if `h_p` is a polynomial over `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]`. In this case, one has to set ``ground=True``. Parameters ========== evalpoints : list of Integer objects list of evaluation points in `\mathbb{Z}_p` hpeval : list of PolyElement objects list of polynomials in (resp. over) `\mathbb{Z}_p[x_0, \ldots, x_{i-1}, x_{i+1}, \ldots, x_{k-1}]`, images of `h_p` evaluated in the variable `x_i` ring : PolyRing `h_p` will be an element of this ring i : Integer index of the variable which has to be reconstructed p : Integer prime number, modulus of `h_p` ground : Boolean indicates whether `x_i` is in the ground domain, default is ``False`` Returns ======= hp : PolyElement interpolated polynomial in (resp. over) `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]` ( R RR*tzipRRRRRR(t evalpointsthpevalR R2RtgroundR&RR]RmRptnumertdenomtbR+((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt_interpolate_multivariateys$'        c4Cs|j|jkr!|jjjs'tt||}|dk rF|S|j}|j\}}|j\}}|jj||}t||\}}||kodknr|||j |||j ||fSt |d} t |d} | j } | j } t| | \} }| |koHdknrz|||j |||j ||fS|jj|j |j }|jj| j | j }||}d}d}xt rt|}x ||dkrt|}qW|j|}|j|}t||\}}t||\}}t|||}|j }||krvqn||krd}|}qntt|t||}|j }|j }|j }t| || || ||d}||krqnd}g} g}!t}"x t|D]}#|jd|#}$|$|s[q3n|jd|#j|}%|jd|#j|}&t|%|&|}'|'j }(|(|krq3n"|(|krd}|(}t }"Pn|'j |$j|}'| j|#|!j|'|d7}||kr3Pq3q3W|"r?qn||krQqnt| |!|d|})t|)|d})|)|j|})|)j d}*|*| krqn|*| krd}|*} qn|)j |j|})|dkr|}|)}+qnt|)|+||},||9}|,|+ks;|,}+qn|,j|,j}-|j|-\}.}/|j|-\}0}1|/ r|1 r|-j dkr| }n|-j |}-|.j ||}2|0j ||}3|-|2|3fSqWdS(s! Computes the GCD of two polynomials in `\mathbb{Z}[x, y]` using a modular algorithm. The algorithm computes the GCD of two bivariate integer polynomials `f` and `g` by calculating the GCD in `\mathbb{Z}_p[x, y]` for suitable primes `p` and then reconstructing the coefficients with the Chinese Remainder Theorem. To compute the bivariate GCD over `\mathbb{Z}_p`, the polynomials `f \; \mathrm{mod} \, p` and `g \; \mathrm{mod} \, p` are evaluated at `y = a` for certain `a \in \mathbb{Z}_p` and then their univariate GCD in `\mathbb{Z}_p[x]` is computed. Interpolating those yields the bivariate GCD in `\mathbb{Z}_p[x, y]`. To verify the result in `\mathbb{Z}[x, y]`, trial division is done, but only for candidates which are very likely the desired GCD. Parameters ========== f : PolyElement bivariate integer polynomial g : PolyElement bivariate integer polynomial Returns ======= h : PolyElement GCD of the polynomials `f` and `g` cff : PolyElement cofactor of `f`, i.e. `\frac{f}{h}` cfg : PolyElement cofactor of `g`, i.e. `\frac{g}{h}` Examples ======== >>> from sympy.polys.modulargcd import modgcd_bivariate >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2 - y**2 >>> g = x**2 + 2*x*y + y**2 >>> h, cff, cfg = modgcd_bivariate(f, g) >>> h, cff, cfg (x + y, x - y, x + y) >>> cff * h == f True >>> cfg * h == g True >>> f = x**2*y - x**2 - 4*y + 4 >>> g = x + 2 >>> h, cff, cfg = modgcd_bivariate(f, g) >>> h, cff, cfg (x + 2, x*y - x - 2*y + 2, 1) >>> cff * h == f True >>> cfg * h == g True References ========== 1. [Monagan00]_ iiN(R RR4R5RRR6R$RrRRbRRRRRRYR#R_RdtFalseRRctappendRRRR{R7R8R9(4RRR:R R;R<R=RqRkR`tgswaptdegyftdegygtyboundt xcontboundReRfRgR?RRRRhRiRjt degconthpRlt degcontfpt degcontgptdegdeltatNR/RRtunluckyRmtdeltaaRnRoRptdeghpaR&tdegyhpR@RARBRCRDRERFRGRH((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pytmodgcd_bivariatesI'  -  -                         c#Cs/|j}|j}|dkrt|||j|}|j}||dkrYdS||dkr|||d>> from sympy.polys.modulargcd import modgcd_multivariate >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2 - y**2 >>> g = x**2 + 2*x*y + y**2 >>> h, cff, cfg = modgcd_multivariate(f, g) >>> h, cff, cfg (x + y, x - y, x + y) >>> cff * h == f True >>> cfg * h == g True >>> R, x, y, z = ring("x, y, z", ZZ) >>> f = x*z**2 - y*z**2 >>> g = x**2*z + z >>> h, cff, cfg = modgcd_multivariate(f, g) >>> h, cff, cfg (z, x*z - y*z, x**2 + 1) >>> cff * h == f True >>> cfg * h == g True References ========== 1. [Monagan00]_ 2. [Brown71]_ See also ======== _modgcd_multivariate_p iiN(R RR4R5RRRKR6R$RRRRbR~tdegreesRdtlistRRRRR RR{R9(RRR:R RSR;R<R=R%RgR2tfdegtgdegRRR?RRRR&R@RARBRCRDRERFRGRH((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pytmodgcd_multivariate'sdN'    5=         cCsO|j}t|j|j||j\}}|j||j|fS(s_ Compute `\frac f g` modulo `p` for two univariate polynomials over `\mathbb Z_p`. (R Rtto_denseRRP(RRRR tdensequotdenserem((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt_gf_divs *cCsv|j}|j}|j}|d}||d}||j}} ||j} } xh| j|krt|| |d} | || | j|}} | | | | j|} } qYW| | } }|j|kst|||dkrdS|j }|dkrV|j ||}| j |j|} |j |j|}n|j }|| ||S(s  Reconstruct a rational function `\frac a b` in `\mathbb Z_p(t)` from .. math:: c = \frac a b \; \mathrm{mod} \, m, where `c` and `m` are polynomials in `\mathbb Z_p[t]` and `m` has positive degree. The algorithm is based on the Euclidean Algorithm. In general, `m` is not irreducible, so it is possible that `b` is not invertible modulo `m`. In that case ``None`` is returned. Parameters ========== c : PolyElement univariate polynomial in `\mathbb Z[t]` p : Integer prime number m : PolyElement modulus, not necessarily irreducible Returns ======= frac : FracElement either `\frac a b` in `\mathbb Z(t)` or ``None`` References ========== 1. [Hoeij04]_ iiiN( R RRR RRRR#RRRRtto_field(tcRR?R RtMRtDtr0ts0tr1ts1RQRmRtlcR!tfield((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt!_rational_function_reconstructions*%    " *   c Cs|j}x|jD]\}}|dkrMt|||}|sdSnX|jj}xI|j|jD]2\} } t| ||} | sdS| || RQRmRR((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt _integer_rational_reconstructions$$      c Cs|j}t|jtr0t}|jj}nt}|jj}x@|jD]2\}}||||}|swdS|||>> from sympy.polys.modulargcd import _func_field_modgcd_m >>> from sympy.polys import ring, ZZ >>> R, x, z = ring('x, z', ZZ) >>> minpoly = (z**2 - 2).drop(0) >>> f = x**2 + 2*x*z + 2 >>> g = x + z >>> _func_field_modgcd_m(f, g, minpoly) x + z >>> D, t = ring('t', ZZ) >>> R, x, z = ring('x, z', D) >>> minpoly = (z**2-3).drop(0) >>> f = x**2 + (t + 1)*x*z + 3*t >>> g = x*z + 3*t >>> _func_field_modgcd_m(f, g, minpoly) x + t*z References ========== 1. [Hoeij04]_ See also ======== _func_field_modgcd_p RiiN(R RRzRRKRORR6RRRRRRRRRRLRRR~R{RRt clear_denomsRRRRRR(RRRR RRStQQdomaintQQringR;R<R%RlRtprimesthplistRRRRtminpolypR&RRUR+RAR?R.R-tLMhqRBR((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyt_func_field_modgcd_m'szB          -"       #c Cs|j}t|jtr*|jj}n |j}|j}xF|jD]8}x/|jD]$}|rY|j||j}qYqYWqIWx|j D]\}}|j}|jj}t|jtr|j |d}nt |} xt | D]} || r||| ||}|d| | df|krY|||d| | df>> from sympy.polys.modulargcd import func_field_modgcd >>> from sympy.polys import AlgebraicField, QQ, ring >>> from sympy import sqrt >>> A = AlgebraicField(QQ, sqrt(2)) >>> R, x = ring('x', A) >>> f = x**2 - 2 >>> g = x + sqrt(2) >>> h, cff, cfg = func_field_modgcd(f, g) >>> h == x + sqrt(2) True >>> cff * h == f True >>> cfg * h == g True >>> R, x, y = ring('x, y', A) >>> f = x**2 + 2*sqrt(2)*x*y + 2*y**2 >>> g = x + sqrt(2)*y >>> h, cff, cfg = func_field_modgcd(f, g) >>> h == x + sqrt(2)*y True >>> cff * h == f True >>> cfg * h == g True >>> f = x + sqrt(2)*y >>> g = x + y >>> h, cff, cfg = func_field_modgcd(f, g) >>> h == R.one True >>> cff * h == f True >>> cfg * h == g True References ========== 1. [Hoeij04]_ tzRJRiiN(R RRKt is_AlgebraicR5RRRRORJRRRRPtmodRRRRRRRRRRR7RRQ(RRR RR/R:RtZZringRtg_RRBtcontx0ftcontx0gtcontx0htZZring_tcontx0h_((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pyRRs<h     + (7tsympyRtsympy.core.compatibilityRt sympy.ntheoryRtsympy.ntheory.modularRtsympy.polys.domainsRtsympy.polys.galoistoolsRRRRR tsympy.polys.polyerrorsR tmpmathR RRR#R(R3RIRYR\R_RbRrR{RRRRRRRRRRRRRRRRRRRRRRR(((s5lib/python2.7/site-packages/sympy/polys/modulargcd.pytsP(    ! A = 0 5 K b A B F   8 E  @ = : 3