o oÇ hLåã@stddlmZddlmZddlmZddlmZddlm Z m Z m Z m Z m Z ddlmZddlmZddlZd d „Zd d „Zd d„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„ZdJd d!„Zd"d#„Zd$d%„Z d&d'„Z!d(d)„Z"d*d+„Z#d,d-„Z$d.d/„Z%d0d1„Z&d2d3„Z'dKd4d5„Z(d6d7„Z)d8d9„Z*d:d;„Z+dd?„Z-d@dA„Z.dBdC„Z/dDdE„Z0dFdG„Z1dHdI„Z2dS)Lé)ÚDummy)Ú nextprime©Úcrt)ÚPolynomialRing)Úgf_gcdÚ gf_from_dictÚgf_gcdexÚgf_divÚgf_lcm)ÚModularGCDFailed)ÚsqrtNcCs†|j}|s|s|j|j|jfS|s(|j|jjkr!| |j|j fS||j|jfS|sA|j|jjkr:| |j |jfS||j|jfSdS)zn Compute the GCD of two polynomials in trivial cases, i.e. when one or both polynomials are zero. N)ÚringÚzeroÚLCÚdomainÚone)ÚfÚgr©rúj/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/polys/modulargcd.pyÚ _trivial_gcd srcCsˆ|jj}|r7|}| ¡}| |j|¡} | ¡}||krn|| ||f¡ ||j¡ |¡}q|}|}|s| | |j|¡¡ |¡S)zM Compute the GCD of two univariate polynomials in `\mathbb{Z}_p[x]`. )rrÚdegreeÚinvertrÚ mul_monomÚ mul_groundÚ trunc_ground)ÚfpÚgpÚpÚdomÚremÚdegÚlcinvÚdegremrrrÚ_gf_gcd#s&üôr%cCsl|jj |j|j¡}d}t|ƒ}||dkr t|ƒ}||dks| |¡}| |¡}t|||ƒ}| ¡}|S)aø 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 ér)rrÚgcdrrrr%r)rrÚgammarrrÚhpÚdeghprrrÚ_degree_bound_univariate:s  ÿ   r+cCsn| ¡}|jjd}|jj}t|dƒD]}t||g| ||¡| ||¡gddd||f<q| ¡|S)a Construct a polynomial `h_{pq}` in `\mathbb{Z}_{p q}[x]` 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]` and `\mathbb{Z}_q[x]` respectively. The coefficients of the polynomial `h_{pq}` are computed with the Chinese Remainder Theorem. The symmetric representation in `\mathbb{Z}_p[x]`, `\mathbb{Z}_q[x]` and `\mathbb{Z}_{p q}[x]` is used. It is assumed that `h_p` and `h_q` have the same degree. Parameters ========== hp : PolyElement univariate integer polynomial with coefficients in `\mathbb{Z}_p` hq : PolyElement univariate 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_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ÚgensrÚrangerÚcoeffÚ strip_zero)r)ÚhqrÚqÚnÚxÚhpqÚirrrÚ,_chinese_remainder_reconstruction_univariate[s6 6r8cCsÒ|j|jkr |jjjs J‚t||ƒ}|dur|S|j}| ¡\}}| ¡\}}|j ||¡}t||ƒ}|dkrH||ƒ| ||¡| ||¡fS|j |j|j¡}d} d} t | ƒ} || dkrjt | ƒ} || dks`|  | ¡} |  | ¡} t | | | ƒ} |   ¡}||krƒqU||krŒd} |}qU|  |¡  | ¡} | dkr| } | }qUt | || | ƒ}| | 9} ||ks¯|}qU| | ¡¡}| |¡\}}| |¡\}}|sè|sè|jdkrÐ| }| |¡}| ||¡}| ||¡}|||fSqV)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&)rrÚis_ZZrÚ primitiver'r+rrrrr%rr8Ú quo_groundÚcontentÚdiv)rrÚresultrÚcfÚcgÚchÚboundr(Úmrrrr)r*ÚhlastmÚhmÚhÚfquoÚfremÚgquoÚgremÚcffÚcfgrrrÚmodgcd_univariateœsdC    "  ÿ      ÙrMc CsÆ|j}|j}|j}i}| ¡D] \}}|dd…|vr#i||dd…<|||dd…|d<qg}t| ¡ƒD] }t|t|||ƒ||ƒ}q8|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) Néÿÿÿÿr&©Úsymbols)rrÚngensÚ itertermsÚiterÚvaluesrrÚclonerPÚ from_denserÚquoÚset_ring) rrrr ÚkÚcoeffsÚmonomr0ÚcontÚyringÚcontfrrrÚ _primitives)r_cCsB|jj}d|d}| ¡D]}|dd…|kr|dd…}q|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&NrN)rrQÚ itermonoms)rrYÚdegfr[rrrÚ_degZs(   €rbc Cst|j}|j}|j|j|dd}|jd}t|ƒ}|j}| ¡D]\}}|dd…|kr7||||d7}q!|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&rOrNrN)rrQrUrPr.rbrrR) rrrYr]ÚyraÚlcfr[r0rrrÚ_LCŠs( €recCsP|j}|j}| ¡D]\}}||f|d|…||dd…}|||<q |S)zS Make the variable `x_i` the leading one in a multivariate polynomial `f`. Nr&)rrrR)rr7rÚfswapr[r0Ú monomswaprrrÚ_swap¿s & rhcCs:|j}|j |j|j¡}|j t|dƒjt|dƒj¡}||}d}t|ƒ}||dkr5t|ƒ}||dks+| |¡}| |¡}t||ƒ\} }t||ƒ\} }t| | |ƒ} |   ¡} tt |ƒt |ƒ|ƒ} t |ƒD],}|   d|¡|spqe|  d|¡ |¡}|  d|¡ |¡}t|||ƒ}|  ¡}|| fSt |  ¡|  ¡ƒ| 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)rrr'rrhrrr_r%rrer/ÚevaluateÚmin)rrrÚgamma1Úgamma2Ú badprimesrrrÚcontfpÚcontgpÚconthpÚ ycontboundÚdeltaÚaÚfpaÚgpaÚhpaÚxboundrrrÚ_degree_bound_bivariateËs2*  ÿ      rxc CsÌt| ¡ƒ}t| ¡ƒ}| |¡}| |¡| |¡|jjj}|jj}t|jjtƒr.t } ndd„} |D]} | || || ||ƒ|| <q4|D] } | || |||ƒ|| <qF|D] } | ||| ||ƒ|| <qV|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)NTr,rr)ÚcpÚcqrr3rrrÚcrt_ksz<_chinese_remainder_reconstruction_multivariate..crt_) ÚsetÚmonomsÚ intersectionÚdifference_updaterrrÚ isinstancerÚ._chinese_remainder_reconstruction_multivariate) r)r2rr3ÚhpmonomsÚhqmonomsr}rr6r{r[rrrrs" H     rFcCs®|j}|r|jj}|jj|}n|j}|j|}t||ƒD]4\} } |j} |j} |D]} | | kr0q)| || 9} | | | 9} q)| | |¡} |  | ¡}||  |¡|7}q| |¡S)a 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}]` ) rrr.ÚziprrrrXr)Ú evalpointsÚhpevalrr7rÚgroundr)rrcrsrvÚnumerÚdenomÚbr0rrrÚ_interpolate_multivariatexs$'     r‹c4Cs(|j|jkr |jjjs J‚t||ƒ}|dur|S|j}| ¡\}}| ¡\}}|j ||¡}t||ƒ\}}||kr?dkrRnn||ƒ| ||¡| ||¡fSt|dƒ} t|dƒ} |   ¡} |   ¡} t| | ƒ\} }| |krudkrˆnn||ƒ| ||¡| ||¡fS|j |j |j ¡}|j | j | j ¡}||}d}d} t |ƒ}||dkr·t |ƒ}||dks­|  |¡}|  |¡}t ||ƒ\}}t ||ƒ\}}t|||ƒ}|  ¡}||krÞq¢||krçd}|}q¢tt|ƒt|ƒ|ƒ}|  ¡}|  ¡}|  ¡}t| || || ||ƒd}||krq¢d}g} g}!d}"t|ƒD]]}#| d|#¡}$|$|s.q| d|#¡  |¡}%| d|#¡  |¡}&t|%|&|ƒ}'|'  ¡}(|(|krQq|(|kr^d}|(}d}"n|' |$¡  |¡}'|  |#¡|! |'¡|d7}||kr{nq|"rq¢||kr‡q¢t| |!|d|ƒ})t |)|ƒd})|)| |¡})|)  d¡}*|*| kr¨q¢|*| kr²d}|*} q¢|) |¡  |¡})|dkrÄ|}|)}+q¢t|)|+||ƒ},||9}|,|+ks×|,}+q¢|, |, ¡¡}-| |-¡\}.}/| |-¡\}0}1|/s|1s|-j dkrû| }|- |¡}-|. ||¡}2|0 ||¡}3|-|2|3fSq£)a! 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]_ Nrr&TF)rrr9rr:r'rxrrhrrrrr_r%rerjr/riÚappendr‹rXrr;r<r=)4rrr>rr?r@rArwrqrfÚgswapÚdegyfÚdegygÚyboundÚ xcontboundrkrlrmrCrrrrnrorpÚ degconthprrÚ degcontfpÚ degcontgpÚdegdeltaÚNr4r…r†ÚunluckyrsÚdeltaartrurvÚdeghpar)ÚdegyhprDrErFrGrHrIrJrKrLrrrÚmodgcd_bivariate¹sàI   "  "  ÿ    ÿÿ          ÿ          ™r›c#Cs|j}|j}|dkr-t|||ƒ |¡}| ¡}||dkrdS||dkr+||d<t‚|S| |d¡} | |d¡} t||ƒ\} }t||ƒ\} }t| | |ƒ} |  ¡}|  ¡}|  ¡}|||dkredS|||dkru|||d<t‚t|ƒ}t|ƒ}t|||ƒ}|}t|dƒD]}|ttt ||ƒƒtt ||ƒƒ|ƒ9}q‹| ¡}t | || |||d||d|ƒd}||krÂdSd}d}g}g}t t|ƒƒ}|r†t   |d¡d}| |¡| d|¡|séqÐ| d|¡|}| |d|¡ |¡}| |d|¡ |¡} t|| |||ƒ}!|!dur |d7}||krdSqÐ|!jr.|  |¡ |¡}|S|! |¡ |¡}!| |¡| |!¡|d7}||kr„t||||d|ƒ}t||ƒd|  |¡}| |d¡}"|"||dkrqdS|"||dkr‚|"||d<t‚|S|sÓdS)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)rrQr%rrr r_rer/rhrjÚlistÚrandomÚsampleÚremoveriÚ_modgcd_multivariate_pÚ is_groundrXrrŒr‹)#rrrÚdegboundÚ contboundrrYrFÚdeghrŽrr^ÚcontgÚconthÚdegcontfÚdegcontgÚdegconthrdÚlcgrrÚevaltestr7r•r–r4Údr…ÚhevalÚpointsrsr˜ÚfaÚgaÚhaÚdegyhrrrr s˜0     &ÿÿ        Õ-r cCs|j|jkr |jjjs J‚t||ƒ}|dur|S|j}|j}| ¡\}}| ¡\}}|j ||¡}|j |j|j¡}|jj} t |ƒD]} | |j t || ƒjt || ƒj¡9} qBdd„t |  ¡|  ¡ƒDƒ} t | ƒ} d} d} t|ƒ}| |dkrt|ƒ}| |dksw| |¡}| |¡}z t|||| | ƒ}Wn ty d} Yqlw|dur¦ql| |¡ |¡}| dkr·|} |}qlt|||| ƒ}| |9} ||ksÉ|}ql| ¡d}| |¡\}}| |¡\}}|s|s|jdkrë| }| |¡}| ||¡}| ||¡}|||fSqm)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)rj)Ú.0ÚfdegÚgdegrrrÚ ˆsz'modgcd_multivariate..r&Tr)rrr9rrQr:r'rrr/rhr„Údegreesrœrrr r rrr=)rrr>rrYr?r@rAr(rmr7r¢r£rCrrrr)rDrErFrGrHrIrJrKrLrrrÚmodgcd_multivariate&sjN    $  ÿ   þ     Ør¸cCs6|j}t| ¡| ¡||jƒ\}}| |¡| |¡fS)z_ Compute `\frac f g` modulo `p` for two univariate polynomials over `\mathbb Z_p`. )rr Úto_denserrV)rrrrÚdensequoÚdenseremrrrÚ_gf_div¹sr¼cCs|j}|j}| ¡}|d}||d}||j}} ||j} } |  ¡|krLt|| |ƒd} | || |  |¡}} | | | |  |¡} } |  ¡|ks&| | } }| ¡|ks_t|||ƒdkradS|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) rrrrrr¼rr%rrrÚto_field)ÚcrrCrrÚMr–ÚDÚr0Ús0Úr1Ús1rWrsrŠÚlcr#ÚfieldrrrÚ!_rational_function_reconstructionÃs,%     ý  rÈc Cs„|j}| ¡D]8\}}|dkrt|||ƒ}|sdSn |jj}| |¡ ¡D]\} } t| ||ƒ} | s6dS| || <q&|||<q|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)rrRrÈrÚdrop_to_ground) rErrCrrYrFr[r0ÚcoeffhÚmonr¿rArrrÚ$_rational_reconstruction_func_coeffss. ÿ   rÌcCs@|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`. )rr r¹rrV)rrrrÚsÚtrFrrrÚ _gf_gcdexKs rÏcCs4|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` )rrXÚ ground_newrr!)rÚminpolyrrÚp_rrrÚ_truncYs  rÓc CsÚ|j}t|||ƒ}t|||ƒ}|rW|}| d¡}t| |¡||ƒ\}}} | dks*dS | d¡} | |kr5n|| |¡ |¡} t|| | |df¡| ||ƒ}q+|}|}|st| |¡||ƒ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)rrÓrrÏÚdmp_LCrXr) rrrÑrrr!r"r#Ú_r'r$rWÚlcfinvrrrÚ_euclidean_algorithmxs*    "ûðr×c Cs*|j}|j|jd|jdfd}| |¡}|}| ¡}| ¡}| d¡} t|ƒ |¡} |j} |r“||kr“t|ƒ |¡} || | ||df¡| }|rR| |¡}| d¡}|r‰|| kr‰t| |¡ƒ |¡} |  | ¡| d|| f¡| }|r~| |¡}| d¡}|r‰|| ks]| ¡}|r“||ks5|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&rrO) rrUrPrXrrerrrr) rrFrÑrrÚzxringr!r$r¤ÚdegmÚlchÚlcmÚlcremrrrÚ_trial_division°s2!          ú ðrÝcCsF|jj|jjj |¡d}|j}| ¡D] \}}| ||¡||<q|S)z[ Evaluate a polynomial `f` at `a` in the `i`-th variable of the ground domain. ©r)rrUrÚdroprrRri)rr7rsrr¯r[r0rrrÚ_evaluate_groundõs ràc& Csê|j}|j}t|tƒr|j}nt||||ƒS|dkr |j ¡}n|j |d¡}|j|jj ¡d}|j|d}d} d} |  |¡|  |¡} |j } g} g}g}t t |ƒƒ}|rót  |d¡d}| |¡|dkrv|  |d|¡|dk}n |  |d|¡ |¡dk}|r†qUt| |d|ƒ}t||d|ƒ}| || |¡g¡dkr£qUt||d|ƒ}t||d|ƒ}t||||ƒ}|durÉ| d7} | | krÈdSqU|dkrÏ|S| ¡gdg|d}|dkr| ¡D] \}}|d|dkr|jt|dd…ƒkr|j|dd…<qä|g}|g}|dkr|j ¡j}n|jj ¡j}|jjd}t| ||ƒD]\}} }!|!|krD| |¡| | ¡|||9}q*| |¡}|  |¡| |¡| |¡| d7} t||||d|dd}"t|"||||dƒ}"|"durzqU|dkr¡|jj }#|#jj}$|" !¡D]}|#j "t#|$ $¡|j% $¡||#jƒ¡}$q‹n*|jjj }#|#jj}$|" !¡D]}| !¡D]}%|#j "t#|$ $¡|%j% $¡||#jƒ¡}$q´q®| &|$ |¡¡}$||" '|$¡ (¡ƒ |¡}"t)||"||ƒsñt)||"||ƒsñ|"S|sXdS)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&rÞrNT)r‡)*rrr€rrQr×r¾rÉrUrÔrrœr/rržrŸrirràr!Ú_func_field_modgcd_prrRÚLMÚtupleÚget_ringrr.r„rŒr‹rÌrÇÚ itercoeffsrVr r¹r‰Ú domain_newrÚas_exprrÝ)&rrrÑrrrrYÚqdomainÚqringr4r¬r(rrr…r­ÚLMlistr®rsÚtestÚgammaaÚminpolyar¯r°r±râr[r0Ú evalpoints_aÚheval_arCrÎrŠÚhbÚLMhbrFr Údenr¿rrrrás²*      *€      €        ÿÿ    ÿÿ ¦\rác CsÔ|dkr||7}||j}}||j}}t|dƒ}t|ƒ|kr<||}||||}}||||}}t|ƒ|ks tt|ƒƒ|krFdS|dkrR| | } } 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]_ rr½N)rrr ÚintÚabsÚ get_field) r¿rCrrÂrÃrÄrÅrBrWrsrŠrÇrrrÚ _integer_rational_reconstruction©s&$     ý röc Cs`|j}t|jtƒrt}|jj}nt}|jj}| ¡D]\}}||||ƒ}|s)dS|||<q|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)rr€rrÚ#_rational_reconstruction_int_coeffsrrörR) rErCrrFÚreconstructionrr[r0rÊrrrr÷és)    r÷cCs†|j}|j}t|tƒr|j}|jj|j ¡d}|j|d}n d}|j|j ¡d}| ¡\}}| ¡\} }| |¡| |¡} |j } d} g} g}g} t | ƒ} |   | ¡dkrXqK|dkrc| | dk}n|   | ¡dk}|rmqK|  | ¡}|  | ¡}|  | ¡}t |||| ƒ}|durˆqK|dkr|j S| ¡gdg|}|dkrÀ| ¡D]\}}|d|dkr¿|jt|dd…ƒkr¿|j|dd…<q¡|}| }t| ||ƒD]\}}}||krÞt||||ƒ}||9}qÊ|  | ¡| |¡| |¡t|||ƒ}|durùqK|dkr| ¡d}n|jj }| ¡D]}|j || ¡d¡}q | |¡}| |¡}| ¡d}t| |¡||ƒsBt| | ¡||ƒsB|SqL)aí Compute the GCD of two polynomials in `\mathbb Q(t_1, \ldots, t_k)[z]/(m_{\alpha}(z))[x]` using a modular algorithm. The algorithm computes the GCD of two polynomials `f` and `g` by calculating the GCD in `\mathbb Z_p(t_1, \ldots, t_k)[z] / (\check m_{\alpha}(z))[x]` for suitable primes `p` and the primitive associate `\check m_{\alpha}(z)` of `m_{\alpha}(z)`. Then the coefficients are reconstructed with the Chinese Remainder Theorem and Rational Reconstruction. To compute the GCD over `\mathbb Z_p(t_1, \ldots, t_k)[z] / (\check m_{\alpha})[x]`, the recursive subroutine ``_func_field_modgcd_p`` is used. To verify the result in `\mathbb Q(t_1, \ldots, t_k)[z] / (m_{\alpha}(z))[x]`, a fraction free trial division is used. Parameters ========== f, g : PolyElement polynomials in `\mathbb Z[t_1, \ldots, t_k][x, z]` minpoly : PolyElement irreducible polynomial in `\mathbb Z[t_1, \ldots, t_k][z]` Returns ======= h : PolyElement the primitive associate in `\mathbb Z[t_1, \ldots, t_k][x, z]` of the GCD of `f` and `g` Examples ======== >>> 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 rÞrr&TN)rrr€rrQrUrõr:rÔrrrrárrrRrârãr„rrŒr÷Ú clear_denomsrårÛrrXrÝ)rrrÑrrrYÚQQdomainÚQQringr?r@r(rrrÚprimesÚhplistrêrërrÚminpolypr)râr[r0rErCr3r2ÚLMhqrFròrrrÚ_func_field_modgcd_m&s‚B      &€€         ÿÁrc Cs |j}t|jtƒr|jj}n|j}|j}| ¡D]}| ¡D] }|r)| ||j¡}qq|  ¡D]^\}}| ¡}|jj}t|jtƒrJ|  |dd…¡}t |ƒ} t | ƒD]:} || rŒ|  || |¡|}|d| | df|vr||||d| | df<qR||d| | df|7<qRq/|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)rr€rrrråÚto_listrÛÚ denominatorrRrÚlenr/Úconvert) rrÚf_rròr0r¿r[rCr4r7rrrÚ _to_ZZ_polyÂs4    €þ   €ù rc Csð|j}|j}t|jjtƒrH| ¡D]4\}}| ¡D]+\}}|df|}|| |¡gdg|dƒ} ||vr<| ||<q||| 7<qq|S| ¡D])\}}|df}|| |¡gdg|dƒ} ||vrm| ||<qL||| 7<qL|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&)rrr€rrrR) rrrrr[r0rËÚcoefrCr¿rrrÚ _to_ANP_polyüs& ù÷  rcCs*|j}| ¡D] \}}| |¡||<q|S)zo Change representation of the minimal polynomial from ``DMP`` to ``PolyElement`` for a given ring. )rÚtermsr)rÑrÚminpoly_r[r0rrrÚ_minpoly_from_dense/sr cCsx|j}|jtd|jƒŽ}|jj}|| ¡ƒ}|j}| ¡D]}t||ƒd}||j kr1||fSq||  |  |¡¡fS)z¿ Compute the content in `x_0` and the primitive part of a polynomial `f` in `\mathbb Q(\alpha)[x_0, x_1, \ldots, x_{n-1}] \cong \mathbb Q(\alpha)[x_1, \ldots, x_{n-1}][x_0]`. r&r) rrÉr/rQrrçrråÚfunc_field_modgcdrrWrX)rÚfringrr rr\r0rrrÚ_primitive_in_x0<s    ÿrcCst|j}|j}|j}||jkr|jsJ‚t||ƒ}|dur|Stdƒ}|j|j|f|j ¡d}|dkrUt ||ƒ}t ||ƒ} |  d¡  |j   ¡¡} t|| | ƒ} t| |ƒ} nTt|ƒ\} }t|ƒ\} }t| | ƒd}|jtd|ƒŽ}t ||ƒ}t ||ƒ} t|j |  d¡ƒ} t|| | ƒ} t| |ƒ} t| ƒ\}} | | |¡9} ||  |¡9}||  |¡9}|  | j¡} | | | ¡| | ¡fS)a Compute the GCD of two polynomials `f` and `g` in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]` using a modular algorithm. The algorithm first computes the primitive associate `\check m_{\alpha}(z)` of the minimal polynomial `m_{\alpha}` in `\mathbb{Z}[z]` and the primitive associates of `f` and `g` in `\mathbb{Z}[x_1, \ldots, x_{n-1}][z]/(\check m_{\alpha})[x_0]`. Then it computes the GCD in `\mathbb Q(x_1, \ldots, x_{n-1})[z]/(m_{\alpha}(z))[x_0]`. This is done by calculating the GCD in `\mathbb{Z}_p(x_1, \ldots, x_{n-1})[z]/(\check m_{\alpha}(z))[x_0]` for suitable primes `p` and then reconstructing the coefficients with the Chinese Remainder Theorem and Rational Reconstuction. The GCD over `\mathbb{Z}_p(x_1, \ldots, x_{n-1})[z]/(\check m_{\alpha}(z))[x_0]` is computed with a recursive subroutine, which evaluates the polynomials at `x_{n-1} = a` for suitable evaluation points `a \in \mathbb Z_p` and then calls itself recursively until the ground domain does no longer contain any parameters. For `\mathbb{Z}_p[z]/(\check m_{\alpha}(z))[x_0]` the Euclidean Algorithm is used. The results of those recursive calls are then interpolated and Rational Function Reconstruction is used to obtain the correct coefficients. The results, both in `\mathbb Q(x_1, \ldots, x_{n-1})[z]/(m_{\alpha}(z))[x_0]` and `\mathbb{Z}_p(x_1, \ldots, x_{n-1})[z]/(\check m_{\alpha}(z))[x_0]`, are verified by a fraction free trial division. Apart from the above GCD computation some GCDs in `\mathbb Q(\alpha)[x_1, \ldots, x_{n-1}]` have to be calculated, because treating the polynomials as univariate ones can result in a spurious content of the GCD. For this ``func_field_modgcd`` is called recursively. Parameters ========== f, g : PolyElement polynomials in `\mathbb Q(\alpha)[x_0, \ldots, x_{n-1}]` Returns ======= h : PolyElement monic 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 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]_ NÚz)rPrr&r)rrrQÚ is_AlgebraicrrrUrPrärrßrVÚmodrrrrr rÉr/r rXr;rrW)rrrrr4r>rÚZZringrÚg_rÑrFÚcontx0fÚcontx0gÚcontx0hÚZZring_Úcontx0h_rrrr Qs<h             r )F)N)3Úsympy.core.symbolrÚ sympy.ntheoryrÚsympy.ntheory.modularrÚsympy.polys.domainsrÚsympy.polys.galoistoolsrrr r r Úsympy.polys.polyerrorsr Úmpmathr rrr%r+r8rMr_rbrerhrxrr‹r›r r¸r¼rÈrÌrÏrÓr×rÝràrárör÷rrrr rr rrrrÚs\     !A=05 K bAU BF 8E'@=:3