B dd(@stddlmZddlmZddlmZddlmZddlm Z m Z m Z m Z m Z ddlmZddlmZddlZd d Zd d Zd dZddZddZddZddZddZddZddZddZdJd d!Zd"d#Zd$d%Z d&d'Z!d(d)Z"d*d+Z#d,d-Z$d.d/Z%d0d1Z&d2d3Z'dKd4d5Z(d6d7Z)d8d9Z*d:d;Z+dd?Z-d@dAZ.dBdCZ/dDdEZ0dFdGZ1dHdIZ2dS)L)Dummy) nextprime)crt)PolynomialRing)gf_gcd gf_from_dictgf_gcdexgf_divgf_lcm)ModularGCDFailed)sqrtNcCs|j}|s|s|j|j|jfS|sR|j|jjkrB| |j|j fS||j|jfSn2|s|j|jjkrv| |j |jfS||j|jfSdS)zn Compute the GCD of two polynomials in trivial cases, i.e. when one or both polynomials are zero. N)ringzeroLCdomainone)fgr rc/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/sympy/polys/modulargcd.py _trivial_gcd srcCs|jj}xh|rp|}|}||j|}x<|}||kr>> 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 rr%T) symmetric)rr gensrrangercoeffZ strip_zero)r(hqrqnxhpqirrr,_chinese_remainder_reconstruction_univariate[s6 8r5cCs|j|jkr|jjjstt||}|dk r0|S|j}|\}}|\}}|j||}t||}|dkr||||||||fS|j|j |j }d} d} x.t | } x|| dkrt | } qW| | } | | } t | | | } | }||krqn||krd} |}q| | | } | dkr>| } | }qt| || | }| | 9} ||ksd|}q||}||\}}||\}}|s|s|j dkr| }||}|||}|||}|||fSqWdS)a 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]_ Nrr%)r ris_ZZAssertionErrorr primitiver&r*rrrrr$rr5 quo_groundcontentdiv)rrresultr cfcgchboundr'mrrrr(r)hlastmhmhfquofremgquogremcffcfgrrrmodgcd_univariates`C    "          rKc Cs|j}|j}|j}i}xL|D]@\}}|dd|krHi||dd<|||dd|d<q Wg}x*t|D]}t|t|||||}qvW|j|j |dd} | | |} | | | |fS)a Compute the content and the primitive part of a polynomial in `\mathbb{Z}_p[x_0, \ldots, x_{k-2}, y] \cong \mathbb{Z}_p[y][x_0, \ldots, x_{k-2}]`. Parameters ========== f : PolyElement integer polynomial in `\mathbb{Z}_p[x0, \ldots, x{k-2}, y]` p : Integer modulus of `f` Returns ======= contf : PolyElement integer polynomial in `\mathbb{Z}_p[y]`, content of `f` ppf : PolyElement primitive part of `f`, i.e. `\frac{f}{contf}` Examples ======== >>> 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) Nr%)symbols)r rngens itertermsitervaluesrrclonerM from_denserquoset_ring) rrr rkZcoeffsmonomr.contyringcontfrrr _primitives)r[cCsF|jj}d|d}x,|D] }|dd|kr|dd}qW|S)a 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) )rr%NrL)r rNZ itermonoms)rrVdegfrWrrr_degZs ( r]c Csx|j}|j}|j|j|dd}|jd}t|}|j}x8|D],\}}|dd|krD||||d7}qDW|S)a 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 r%)rMrNrL)r rNrRrMr,r]rrO) rr rVrYyr\lcfrWr.rrr_LCs( r`cCsT|j}|j}xB|D]6\}}||f|d|||dd}|||<qW|S)zS Make the variable `x_i` the leading one in a multivariate polynomial `f`. Nr%)r rrO)rr4r fswaprWr.Z monomswaprrr_swaps & rbcCs4|j}|j|j|j}|jt|djt|dj}||}d}t|}x||dkrbt|}qLW||}||}t||\} }t||\} }t| | |} | } tt |t ||} x`t |D]T}| d||sq| d||}| d||}t|||}| }|| fSWt | | | fS)a Compute upper degree bounds for the GCD of two bivariate integer polynomials `f` and `g`. The GCD is viewed as a polynomial in `\mathbb{Z}[y][x]` and the function returns an upper bound for its degree and one for the degree of its content. This is done by choosing a suitable prime `p` and computing the GCD of the contents of `f \; \mathrm{mod} \, p` and `g \; \mathrm{mod} \, p`. The choice of `p` guarantees that the degree of the content in `\mathbb{Z}_p[y]` is greater than or equal to the degree in `\mathbb{Z}[y]`. To obtain the degree bound in the variable `x`, the polynomials are evaluated at `y = a` for a suitable `a \in \mathbb{Z}_p` and then their GCD in `\mathbb{Z}_p[x]` is computed. If no such `a` exists, i.e. the degree in `\mathbb{Z}_p[x]` is always smaller than the one in `\mathbb{Z}[y][x]`, then the bound is set to the minimum of the degrees of `f` and `g` in `x`. Parameters ========== f : PolyElement bivariate integer polynomial g : PolyElement bivariate integer polynomial Returns ======= xbound : Integer upper bound for the degree of the GCD of the polynomials `f` and `g` in the variable `x` ycontbound : Integer upper bound for the degree of the content of the GCD of the polynomials `f` and `g` in the variable `y` References ========== 1. [Monagan00]_ r%r)r rr&rrbrrr[r$rr`r-evaluatemin)rrr gamma1gamma2 badprimesrrrcontfpcontgpconthp ycontbounddeltaafpagpahpaxboundrrr_degree_bound_bivariates0*      rrc Cst|}t|}||}|||||jjj}|jj}t|jjtr\t } ndd} x&|D]} | || || |||| <qjWx"|D]} | || ||||| <qWx"|D]} | ||| |||| <qW|S)a: Construct a polynomial `h_{pq}` in `\mathbb{Z}_{p q}[x_0, \ldots, x_{k-1}]` such that .. math :: h_{pq} = h_p \; \mathrm{mod} \, p h_{pq} = h_q \; \mathrm{mod} \, q for relatively prime integers `p` and `q` and polynomials `h_p` and `h_q` in `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]` and `\mathbb{Z}_q[x_0, \ldots, x_{k-1}]` respectively. The coefficients of the polynomial `h_{pq}` are computed with the Chinese Remainder Theorem. The symmetric representation in `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]`, `\mathbb{Z}_q[x_0, \ldots, x_{k-1}]` and `\mathbb{Z}_{p q}[x_0, \ldots, x_{k-1}]` is used. Parameters ========== hp : PolyElement multivariate integer polynomial with coefficients in `\mathbb{Z}_p` hq : PolyElement multivariate integer polynomial with coefficients in `\mathbb{Z}_q` p : Integer modulus of `h_p`, relatively prime to `q` q : Integer modulus of `h_q`, relatively prime to `p` Examples ======== >>> 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 cSst||g||gdddS)NT)r+r)r)cpZcqrr0rrrcrt_ksz<_chinese_remainder_reconstruction_multivariate..crt_) setmonoms intersectiondifference_updater rr isinstancer._chinese_remainder_reconstruction_multivariate) r(r/rr0ZhpmonomsZhqmonomsrvrr3rtrWrrrrzs"H         rzFcCs|j}|r |jj}|jj|}n|j}|j|}xzt||D]l\} } |j} |j} x.|D]&} | | krdqV| || 9} | | | 9} qVW|| |} | | }|| ||7}q>> 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]_ Nrr%FT)r rr6r7rr8r&rrrrbrrrrr[r$r`rdr-rcappendrrUrzr9r:r;)4rrr<r r=r>r?rqrkraZgswapdegyfdegygZyboundZ xcontboundrerfrgrArrrrhrirjZ degconthprlZ degcontfpZ degcontgpdegdeltaNr1r|r}ZunluckyrmdeltaarnrorpZdeghpar(ZdegyhprBrCrDrErFrGrHrIrJrrrmodgcd_bivariatesI   "  "                       rc#Cs$|j}|j}|dkrZt||||}|}||dkr>dS||dkrV||d<t|S||d} ||d} t||\} }t||\} }t| | |} | }| }| }|||dkrdS|||dkr|||d<tt|}t|}t|||}|}x:t|dD]*}|ttt ||tt |||9}qW|}t | || |||d||d|d}||krdSd}d}g}g}t t|}xt|rt |dd}|||d||sq|d||}||d||}||d||} t|| |||}!|!dkrR|d7}||krdSq|!jrn| ||}|S|!||}!||||!|d7}||krt||||d|}t||d| |}||d}"|"||dkrdS|"||dkr|"||d<t|SqWdS)a Compute the GCD of two polynomials in `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]`. The algorithm reduces the problem step by step by evaluating the polynomials `f` and `g` at `x_{k-1} = a` for suitable `a \in \mathbb{Z}_p` and then calls itself recursively to compute the GCD in `\mathbb{Z}_p[x_0, \ldots, x_{k-2}]`. If these recursive calls are successful for enough evaluation points, the GCD in `k` variables is interpolated, otherwise the algorithm returns ``None``. Every time a GCD or a content is computed, their degrees are compared with the bounds. If a degree greater then the bound is encountered, then the current call returns ``None`` and a new evaluation point has to be chosen. If at some point the degree is smaller, the correspondent bound is updated and the algorithm fails. Parameters ========== f : PolyElement multivariate integer polynomial with coefficients in `\mathbb{Z}_p` g : PolyElement multivariate integer polynomial with coefficients in `\mathbb{Z}_p` p : Integer prime number, modulus of `f` and `g` degbound : list of Integer objects ``degbound[i]`` is an upper bound for the degree of the GCD of `f` and `g` in the variable `x_i` contbound : list of Integer objects ``contbound[i]`` is an upper bound for the degree of the content of the GCD in `\mathbb{Z}_p[x_i][x_0, \ldots, x_{i-1}]`, ``contbound[0]`` is not used can therefore be chosen arbitrarily. Returns ======= h : PolyElement GCD of the polynomials `f` and `g` or ``None`` References ========== 1. [Monagan00]_ 2. [Brown71]_ r%rN)r rNr$rrr r[r`r-rbrdlistrandomsampleremoverc_modgcd_multivariate_pZ is_groundrUrrr)#rrrdegbound contboundr rVrDdeghrrrZZcontgZconthZdegcontfZdegcontgZdegconthr_ZlcgrlZevaltestr4rrr1dr|hevalpointsrmrfagahaZdegyhrrrrs0     *"           rcCs|j|jkr|jjjstt||}|dk r0|S|j}|j}|\}}|\}}|j||}|j|j|j}|jj } x2t |D]&} | |jt || jt || j9} qWddt | | D} t| } d} d}x6t|}x| |dkrt|}qW||}||}yt|||| | }Wntk rHd} wYnX|dkrVq|||}| dkrz|} |}qt|||| }| |9} ||ks|}q|d}||\}}||\}}|s|s|jdkr| }||}|||}|||}|||fSqWdS)a Compute the GCD of two polynomials in `\mathbb{Z}[x_0, \ldots, x_{k-1}]` using a modular algorithm. The algorithm computes the GCD of two multivariate integer polynomials `f` and `g` by calculating the GCD in `\mathbb{Z}_p[x_0, \ldots, x_{k-1}]` for suitable primes `p` and then reconstructing the coefficients with the Chinese Remainder Theorem. To compute the multivariate GCD over `\mathbb{Z}_p` the recursive subroutine :func:`_modgcd_multivariate_p` is used. To verify the result in `\mathbb{Z}[x_0, \ldots, x_{k-1}]`, trial division is done, but only for candidates which are very likely the desired GCD. Parameters ========== f : PolyElement multivariate integer polynomial g : PolyElement multivariate 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_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 NcSsg|]\}}t||qSr)rd).0ZfdegZgdegrrr sz'modgcd_multivariate..r%r)r rr6r7rrNr8r&rrr-rbr{degreesrrrrr rrzr;)rrr<r rVr=r>r?r'rgr4rrrArrrr(rBrCrDrErFrGrHrIrJrrrmodgcd_multivariate&sdN   &         rcCs6|j}t||||j\}}||||fS)z_ Compute `\frac f g` modulo `p` for two univariate polynomials over `\mathbb Z_p`. )r r to_denserrS)rrrr ZdensequoZdenseremrrr_gf_divsrcCs|j}|j}|}|d}||d}||j}} ||j} } xP| |krt|| |d} | || | |}} | | | | |} } qBW| | } }||kst|||dkrdS|j}|dkr| ||}| ||} | ||}| }|| ||S)a  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]_ r%rN) r rrrrrrr$rrrto_field)crrAr rMrDr0s0r1s1rTrmrlcr"fieldrrr!_rational_function_reconstructions*%      rc Cs|j}xz|D]n\}}|dkr6t|||}|svdSn@|jj}x6||D]$\} } t| ||} | sjdS| || <qNW|||<qW|S)a Reconstruct every coefficient `c_h` of a polynomial `h` in `\mathbb Z_p(t_k)[t_1, \ldots, t_{k-1}][x, z]` from the corresponding coefficient `c_{h_m}` of a polynomial `h_m` in `\mathbb Z_p[t_1, \ldots, t_k][x, z] \cong \mathbb Z_p[t_k][t_1, \ldots, t_{k-1}][x, z]` such that .. math:: c_{h_m} = c_h \; \mathrm{mod} \, m, where `m \in \mathbb Z_p[t]`. The reconstruction is based on the Euclidean Algorithm. In general, `m` is not irreducible, so it is possible that this fails for some coefficient. In that case ``None`` is returned. Parameters ========== hm : PolyElement polynomial in `\mathbb Z[t_1, \ldots, t_k][x, z]` p : Integer prime number, modulus of `\mathbb Z_p` m : PolyElement modulus, polynomial in `\mathbb Z[t]`, not necessarily irreducible ring : PolyRing `\mathbb Z(t_k)[t_1, \ldots, t_{k-1}][x, z]`, `h` will be an element of this ring k : Integer index of the parameter `t_k` which will be reconstructed Returns ======= h : PolyElement reconstructed polynomial in `\mathbb Z(t_k)[t_1, \ldots, t_{k-1}][x, z]` or ``None`` See also ======== _rational_function_reconstruction rN)rrOrrdrop_to_ground) rCrrAr rVrDrWr.coeffhmonrr?rrr$_rational_reconstruction_func_coeffss.    rcCs@|j}t||||j\}}}||||||fS)z Extended Euclidean Algorithm for two univariate polynomials over `\mathbb Z_p`. Returns polynomials `s, t` and `h`, such that `h` is the GCD of `f` and `g` and `sf + tg = h \; \mathrm{mod} \, p`. )r rrrrS)rrrr strDrrr _gf_gcdexKs rcCs4|j}||}||}||||g|S)a Compute the reduced representation of a polynomial `f` in `\mathbb Z_p[z] / (\check m_{\alpha}(z))[x]` Parameters ========== f : PolyElement polynomial in `\mathbb Z[x, z]` minpoly : PolyElement polynomial `\check m_{\alpha} \in \mathbb Z[z]`, not necessarily irreducible p : Integer prime number, modulus of `\mathbb Z_p` Returns ======= ftrunc : PolyElement polynomial in `\mathbb Z[x, z]`, reduced modulo `\check m_{\alpha}(z)` and `p` )r rUZ ground_newrr )rminpolyrr Zp_rrr_truncYs  rc Cs|j}t|||}t|||}x|r|}|d}t||||\}}} | dksVdSxN|d} | |krlP||||} t||| |df| ||}qXW|}|}q Wt||||d|} t|| ||S)a  Compute the monic GCD of two univariate polynomials in `\mathbb{Z}_p[z]/(\check m_{\alpha}(z))[x]` with the Euclidean Algorithm. In general, `\check m_{\alpha}(z)` is not irreducible, so it is possible that some leading coefficient is not invertible modulo `\check m_{\alpha}(z)`. In that case ``None`` is returned. Parameters ========== f, g : PolyElement polynomials in `\mathbb Z[x, z]` minpoly : PolyElement polynomial in `\mathbb Z[z]`, not necessarily irreducible p : Integer prime number, modulus of `\mathbb Z_p` Returns ======= h : PolyElement GCD of `f` and `g` in `\mathbb Z[z, x]` or ``None``, coefficients are in `\left[ -\frac{p-1} 2, \frac{p-1} 2 \right]` rr%N)r rrrdmp_LCrUr) rrrrr r r!r"_r&r#rTZlcfinvrrr_euclidean_algorithmxs&    &rc Cs(|j}|j|jd|jdfd}||}|}|}|}|d} t||} |j} x|r"||kr"t||} || |||df| }|r||}|d}xb|r|| krt|||} | | |d|| f| }|r ||}|d}qW|}q`W|S)a= Check if `h` divides `f` in `\mathbb K[t_1, \ldots, t_k][z]/(m_{\alpha}(z))`, where `\mathbb K` is either `\mathbb Q` or `\mathbb Z_p`. This algorithm is based on pseudo division and does not use any fractions. By default `\mathbb K` is `\mathbb Q`, if a prime number `p` is given, `\mathbb Z_p` is chosen instead. Parameters ========== f, h : PolyElement polynomials in `\mathbb Z[t_1, \ldots, t_k][x, z]` minpoly : PolyElement polynomial `m_{\alpha}(z)` in `\mathbb Z[t_1, \ldots, t_k][z]` p : Integer or None if `p` is given, `\mathbb K` is set to `\mathbb Z_p` instead of `\mathbb Q`, default is ``None`` Returns ======= rem : PolyElement remainder of `\frac f h` References ========== .. [1] [Hoeij02]_ r%r)rM) r rRrMrUrr`rrrr) rrDrrr Zzxringr r#rZdegmZlchlcmZlcremrrr_trial_divisions.!       rcCsJ|jj|jjj|d}|j}x$|D]\}}|||||<q*W|S)z[ Evaluate a polynomial `f` at `a` in the `i`-th variable of the ground domain. )r)r rRrdroprrOrc)rr4rmr rrWr.rrr_evaluate_grounds rc& Cs|j}|j}t|tr|j}nt||||S|dkr@|j}n$|j|d}|j|jjd}|j|d}d} d} | || |} |j } g} g}g}t t |}xV|rt |dd}|||dkr| |d||dk}n| |d||dk}|rqt| |d|}t||d|}||||gdkrNqt||d|}t||d|}t||||}|dkr| d7} | | krdSq|dkr|S|gdg|d}|dkrxN|D]B\}}|d|dkr|jt|ddkr|j|dd<qW|g}|g}|dkr@|jj}n|jjj}|jjd}xFt| ||D]6\}} }!|!|krh|||| |||9}qhW||}| |||||| d7} t||||d|dd}"t|"||||d}"|"dkr q|dkr\|jj }#|#jj}$x|"!D](}|#j"t#|$$|j%$||#j}$q.Wn\|jjj }#|#jj}$xH|"!D]<}x4|!D](}%|#j"t#|$$|%j%$||#j}$qWqxW|&|$|}$||"'|$(|}"t)||"||st)||"||s|"SqWdS)a Compute the GCD of two polynomials `f` and `g` in `\mathbb Z_p(t_1, \ldots, t_k)[z]/(\check m_\alpha(z))[x]`. The algorithm reduces the problem step by step by evaluating the polynomials `f` and `g` at `t_k = a` for suitable `a \in \mathbb Z_p` and then calls itself recursively to compute the GCD in `\mathbb Z_p(t_1, \ldots, t_{k-1})[z]/(\check m_\alpha(z))[x]`. If these recursive calls are successful, the GCD over `k` variables is interpolated, otherwise the algorithm returns ``None``. After interpolation, Rational Function Reconstruction is used to obtain the correct coefficients. If this fails, a new evaluation point has to be chosen, otherwise the desired polynomial is obtained by clearing denominators. The result is verified with a fraction free trial division. Parameters ========== f, g : PolyElement polynomials in `\mathbb Z[t_1, \ldots, t_k][x, z]` minpoly : PolyElement polynomial in `\mathbb Z[t_1, \ldots, t_k][z]`, not necessarily irreducible p : Integer prime number, modulus of `\mathbb Z_p` Returns ======= h : PolyElement primitive associate in `\mathbb Z[t_1, \ldots, t_k][x, z]` of the GCD of the polynomials `f` and `g` or ``None``, coefficients are in `\left[ -\frac{p-1} 2, \frac{p-1} 2 \right]` References ========== 1. [Hoeij04]_ r%)rrNT)r~)*r rryrrNrrrrRrrrr-rrrrcrrr _func_field_modgcd_prrOLMtupleget_ringrr,r{rrrr itercoeffsrSr rrZ domain_newras_exprr)&rrrrr rrVZqdomainZqringr1rr'rlr|rLMlistrrmtestZgammaaZminpolyarrrrrWr.Z evalpoints_aZheval_arArrZhbZLMhbrDrdenrrrrrs*         *            rc Cs|dkr||7}||j}}||j}}t|d}x8||krl||}||||}}||||}}q6Wt||kr~dS|dkr| | } } n|dkr||} } ndS|} | | | | S)a Reconstruct a rational number `\frac a b` from .. math:: c = \frac a b \; \mathrm{mod} \, m, where `c` and `m` are integers. The algorithm is based on the Euclidean Algorithm. In general, `m` is not a prime number, so it is possible that `b` is not invertible modulo `m`. In that case ``None`` is returned. Parameters ========== c : Integer `c = \frac a b \; \mathrm{mod} \, m` m : Integer modulus, not necessarily prime domain : IntegerRing `a, b, c` are elements of ``domain`` Returns ======= frac : Rational either `\frac a b` in `\mathbb Q` or ``None`` References ========== 1. [Wang81]_ rrN)rrr abs get_field) rrArrrrrr@rTrmrrrrr _integer_rational_reconstructions$$      rc Csb|j}t|jtr t}|jj}n t}|jj}x0|D]$\}}||||}|sRdS|||<q6W|S)a Reconstruct every rational coefficient `c_h` of a polynomial `h` in `\mathbb Q[t_1, \ldots, t_k][x, z]` from the corresponding integer coefficient `c_{h_m}` of a polynomial `h_m` in `\mathbb Z[t_1, \ldots, t_k][x, z]` such that .. math:: c_{h_m} = c_h \; \mathrm{mod} \, m, where `m \in \mathbb Z`. The reconstruction is based on the Euclidean Algorithm. In general, `m` is not a prime number, so it is possible that this fails for some coefficient. In that case ``None`` is returned. Parameters ========== hm : PolyElement polynomial in `\mathbb Z[t_1, \ldots, t_k][x, z]` m : Integer modulus, not necessarily prime ring : PolyRing `\mathbb Q[t_1, \ldots, t_k][x, z]`, `h` will be an element of this ring Returns ======= h : PolyElement reconstructed polynomial in `\mathbb Q[t_1, \ldots, t_k][x, z]` or ``None`` See also ======== _integer_rational_reconstruction N)rryrr#_rational_reconstruction_int_coeffsr rrO) rCrAr rDZreconstructionrrWr.rrrrrs)    rcCs|j}|j}t|tr>|j}|jj|jd}|j|d}nd}|j|jd}|\}}|\} }||||} |j } d} g} g}g}x t | } | | dkrq|dkr| | dk}n| | dk}|rq| | }| | }| | }t |||| }|dkrq|dkr$|j S|gdg|}|dkrxN|D]B\}}|d|dkrL|jt|ddkrL|j|dd<qLW|}| }x>> 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 )rrr%N)r rryrrNrRrr8rrrrrrrrOrrr{rzrrZ clear_denomsrrrrUr)rrrr rrVZQQdomainZQQringr=r>r'rlrZprimesZhplistrrrrZminpolypr(rrWr.rCrAr0r/ZLMhqrDrrrr_func_field_modgcd_m&szB         *          rc Cs,|j}t|jtr|jj}n|j}|j}x2|D]&}x |jD]}|r>|||j}q>Wq2Wx| D]\}}|j}|jj}t|jtr| |dd}t |} xt | D]t} || r||| ||}|d| | df|kr|||d| | df<q||d| | df|7<qWqfW|S)a Compute an associate of a polynomial `f \in \mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]` in `\mathbb Z[x_1, \ldots, x_{n-1}][z] / (\check m_{\alpha}(z))[x_0]`, where `\check m_{\alpha}(z) \in \mathbb Z[z]` is the primitive associate of the minimal polynomial `m_{\alpha}(z)` of `\alpha` over `\mathbb Q`. Parameters ========== f : PolyElement polynomial in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]` ring : PolyRing `\mathbb Z[x_1, \ldots, x_{n-1}][x_0, z]` Returns ======= f_ : PolyElement associate of `f` in `\mathbb Z[x_1, \ldots, x_{n-1}][x_0, z]` r%Nr) rryrrrrrepr denominatorrOrlenr-) rr f_rrr.rrWrAr1r4rrr _to_ZZ_polys,    (rc Cs|j}|j}t|jjtrx|D]l\}}xb|D]V\}}|df|}|||gdg|d} ||kr|| ||<q6||| 7<q6Wq$Wn`x^|D]R\}}|df}|||gdg|d} ||kr| ||<q||| 7<qW|S)ar Convert a polynomial `f \in \mathbb Z[x_1, \ldots, x_{n-1}][z]/(\check m_{\alpha}(z))[x_0]` to a polynomial in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]`, where `\check m_{\alpha}(z) \in \mathbb Z[z]` is the primitive associate of the minimal polynomial `m_{\alpha}(z)` of `\alpha` over `\mathbb Q`. Parameters ========== f : PolyElement polynomial in `\mathbb Z[x_1, \ldots, x_{n-1}][x_0, z]` ring : PolyRing `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]` Returns ======= f_ : PolyElement polynomial in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]` rr%)rrryr rrO) rr rrrWr.rZcoefrArrrr _to_ANP_polys"   rcCs.|j}x"|D]\}}||||<qW|S)zo Change representation of the minimal polynomial from ``DMP`` to ``PolyElement`` for a given ring. )rZtermsr)rr Zminpoly_rWr.rrr_minpoly_from_dense/srcCsx|j}|jtd|j}|jj}||}|j}x0|D]$}t||d}||j kr<||fSq>> 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]_ Nz)rMrr%r)r rrNZ is_Algebraicr7rrrRrMrrrrSmodrrrrrrr-rrUr9rrT)rrr rr1r<rZZZringrZg_rrDZcontx0fZcontx0gZcontx0hZZZring_Zcontx0h_rrrrQs<h             r)F)N)3Zsympy.core.symbolrZ sympy.ntheoryrZsympy.ntheory.modularrZsympy.polys.domainsrZsympy.polys.galoistoolsrrrr r Zsympy.polys.polyerrorsr Zmpmathr rrr$r*r5rKr[r]r`rbrrrzrrrrrrrrrrrrrrrrrrrrrrrrrsZ      !A=05 Kb AU BF8 E'@=:3