U L?hM@sdZddlmZmZmZmZmZmZmZm Z m Z m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZddlmZmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,ddl-m.Z.m/Z/dd Z0d d Z1d d Z2ddZ3ddZ4ddZ5ddZ6ddZ7ddZ8ddZ9ddZ:ddZ;d2d!d"Zd5d'd(Z?d6d)d*Z@d7d+d,ZAd-d.ZBd/d0ZCd1S)8z8Square-free decomposition algorithms and related tools. ) dup_negdmp_negdup_subdmp_subdup_muldmp_muldup_quodmp_quodup_mul_grounddmp_mul_ground) dup_stripdup_LC dmp_ground_LC dmp_zero_p dmp_ground dup_degree dmp_degree dmp_degree_indmp_degree_list dmp_raise dmp_inject dup_convert) dup_diffdmp_diff dmp_diff_in dup_shift dmp_shift dup_monicdmp_ground_monic dup_primitivedmp_ground_primitive) dup_inner_gcd dmp_inner_gcddup_gcddmp_gcd dmp_resultant dmp_primitive) gf_sqf_list gf_sqf_part)MultivariatePolynomialError DomainErrorcCs&tdd|D}|t|ks"tdS)z=Sanity check the degrees of a computed factorization in K[x].css|]\}}|t|VqdS)N)r).0fackr.I/var/www/html/venv/lib/python3.8/site-packages/sympy/polys/sqfreetools.py $sz%_dup_check_degrees..N)sumrAssertionError)fresultdegr.r.r/_dup_check_degrees"sr6csXdg|d}|D]*\}t||}fddt||D}qt|t||ksTtdS)z=Sanity check the degrees of a computed factorization in K[X].rcsg|]\}}||qSr.r.)r+Zd1Zd2r-r.r/ -sz&_dmp_check_degrees..N)rziptupler2)r3ur4Zdegsr,Zdegs_facr.r8r/_dmp_check_degrees(s   r=cCs&|sdStt|t|d|| SdS)a Return ``True`` if ``f`` is a square-free polynomial in ``K[x]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_sqf_p(x**2 - 2*x + 1) False >>> R.dup_sqf_p(x**2 - 1) True Tr7N)rr#r)r3Kr.r.r/ dup_sqf_p1sr?cCsdt||rdSt|dD]D}t|d|||}t||r:qt||||}t|||dkrdSqdS)a Return ``True`` if ``f`` is a square-free polynomial in ``K[X]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> R.dmp_sqf_p(x**2 + 2*x*y + y**2) False >>> R.dmp_sqf_p(x**2 + y**2) True Tr7rF)rrangerr$r)r3r<r>ifpgcdr.r.r/ dmp_sqf_pGs  rDcCs|jstddt|jdd|j}}t|d|dd\}}t||d|j}t||jr^qzq*t ||j ||d}}q*|||fS)ag Find a shift of `f` in `K[x]` that has square-free norm. The domain `K` must be an algebraic number field `k(a)` (see :ref:`QQ(a)`). Returns `(s,g,r)`, such that `g(x)=f(x-sa)`, `r(x)=\text{Norm}(g(x))` and `r` is a square-free polynomial over `k`. Examples ======== We first create the algebraic number field `K=k(a)=\mathbb{Q}(\sqrt{3})` and rings `K[x]` and `k[x]`: >>> from sympy.polys import ring, QQ >>> from sympy import sqrt >>> K = QQ.algebraic_field(sqrt(3)) >>> R, x = ring("x", K) >>> _, X = ring("x", QQ) We can now find a square free norm for a shift of `f`: >>> f = x**2 - 1 >>> s, g, r = R.dup_sqf_norm(f) The choice of shift `s` is arbitrary and the particular values returned for `g` and `r` are determined by `s`. >>> s == 1 True >>> g == x**2 - 2*sqrt(3)*x + 2 True >>> r == X**4 - 8*X**2 + 4 True The invariants are: >>> g == f.shift(-s*K.unit) True >>> g.norm() == r True >>> r.is_squarefree True Explanation =========== This is part of Trager's algorithm for factorizing polynomials over algebraic number fields. In particular this function is algorithm ``sqfr_norm`` from [Trager76]_. See Also ======== dmp_sqf_norm: Analogous function for multivariate polynomials over ``k(a)``. dmp_norm: Computes the norm of `f` directly without any shift. dup_ext_factor: Function implementing Trager's algorithm that uses this. sympy.polys.polytools.sqf_norm: High-level interface for using this function. ground domain must be algebraicrr7TZfront) is_Algebraicr*rmodto_listdomrr%r?runit)r3r>sgh_rr.r.r/ dup_sqf_normisA rQc#s|d}dg|}||fV|jt||}ddtt|t|dD}|D]>}|}d||<fdd|D} t|| ||} || fVqPd} | d7} | g|} | g|} t|| ||}| |fVqdS)z9Generate a sequence of candidate shifts for dmp_sqf_norm.r7rcSsg|]\}}|dkr|qS)rr.)r+ZdirAr.r.r/r9sz(_dmp_sqf_norm_shifts..csg|]} |qSr.r.)r+Zs1iar.r/r9sN)rKrsortedr:r@copyr)r3r<r>ns0dZ var_indicesrAs1Za1f1jZsjZajfjr.rRr/_dmp_sqf_norm_shiftss$       r]cCs|s t||\}}}|g||fS|js.tdt|j|dd|j}t|||D]B\}}t|||dd\}}t |||d|j}t |||jrTqqT|||fS)a Find a shift of ``f`` in ``K[X]`` that has square-free norm. The domain `K` must be an algebraic number field `k(a)` (see :ref:`QQ(a)`). Returns `(s,g,r)`, such that `g(x_1,x_2,\cdots)=f(x_1-s_1 a, x_2 - s_2 a, \cdots)`, `r(x)=\text{Norm}(g(x))` and `r` is a square-free polynomial over `k`. Examples ======== We first create the algebraic number field `K=k(a)=\mathbb{Q}(i)` and rings `K[x,y]` and `k[x,y]`: >>> from sympy.polys import ring, QQ >>> from sympy import I >>> K = QQ.algebraic_field(I) >>> R, x, y = ring("x,y", K) >>> _, X, Y = ring("x,y", QQ) We can now find a square free norm for a shift of `f`: >>> f = x*y + y**2 >>> s, g, r = R.dmp_sqf_norm(f) The choice of shifts ``s`` is arbitrary and the particular values returned for ``g`` and ``r`` are determined by ``s``. >>> s [0, 1] >>> g == x*y - I*x + y**2 - 2*I*y - 1 True >>> r == X**2*Y**2 + X**2 + 2*X*Y**3 + 2*X*Y + Y**4 + 2*Y**2 + 1 True The required invariants are: >>> g == f.shift_list([-si*K.unit for si in s]) True >>> g.norm() == r True >>> r.is_squarefree True Explanation =========== This is part of Trager's algorithm for factorizing polynomials over algebraic number fields. In particular this function is a multivariate generalization of algorithm ``sqfr_norm`` from [Trager76]_. See Also ======== dup_sqf_norm: Analogous function for univariate polynomials over ``k(a)``. dmp_norm: Computes the norm of `f` directly without any shift. dmp_ext_factor: Function implementing Trager's algorithm that uses this. sympy.polys.polytools.sqf_norm: High-level interface for using this function. rEr7rTrF) rQrGr*rrHrIrJr]rr%rD)r3r<r>rLrMrPrNrOr.r.r/ dmp_sqf_normsB r^cCsP|jstdt|j|dd|j}t|||dd\}}t|||d|jS)aE Norm of ``f`` in ``K[X]``, often not square-free. The domain `K` must be an algebraic number field `k(a)` (see :ref:`QQ(a)`). Examples ======== We first define the algebraic number field `K = k(a) = \mathbb{Q}(\sqrt{2})`: >>> from sympy import QQ, sqrt >>> from sympy.polys.sqfreetools import dmp_norm >>> k = QQ >>> K = k.algebraic_field(sqrt(2)) We can now compute the norm of a polynomial `p` in `K[x,y]`: >>> p = [[K(1)], [K(1),K.unit]] # x + y + sqrt(2) >>> N = [[k(1)], [k(2),k(0)], [k(1),k(0),k(-2)]] # x**2 + 2*x*y + y**2 - 2 >>> dmp_norm(p, 1, K) == N True In higher level functions that is: >>> from sympy import expand, roots, minpoly >>> from sympy.abc import x, y >>> from math import prod >>> a = sqrt(2) >>> e = (x + y + a) >>> e.as_poly([x, y], extension=a).norm() Poly(x**2 + 2*x*y + y**2 - 2, x, y, domain='QQ') This is equal to the product of the expressions `x + y + a_i` where the `a_i` are the conjugates of `a`: >>> pa = minpoly(a) >>> pa _x**2 - 2 >>> rs = roots(pa, multiple=True) >>> rs [sqrt(2), -sqrt(2)] >>> n = prod(e.subs(a, r) for r in rs) >>> n (x + y - sqrt(2))*(x + y + sqrt(2)) >>> expand(n) x**2 + 2*x*y + y**2 - 2 Explanation =========== Given an algebraic number field `K = k(a)` any element `b` of `K` can be represented as polynomial function `b=g(a)` where `g` is in `k[x]`. If the minimal polynomial of `a` over `k` is `p_a` then the roots `a_1`, `a_2`, `\cdots` of `p_a(x)` are the conjugates of `a`. The norm of `b` is the product `g(a1) \times g(a2) \times \cdots` and is an element of `k`. As in [Trager76]_ we extend this norm to multivariate polynomials over `K`. If `b(x)` is a polynomial in `k(a)[X]` then we can think of `b` as being alternately a function `g_X(a)` where `g_X` is an element of `k[X][y]` i.e. a polynomial function with coefficients that are elements of `k[X]`. Then the norm of `b` is the product `g_X(a1) \times g_X(a2) \times \cdots` and will be an element of `k[X]`. See Also ======== dmp_sqf_norm: Compute a shift of `f` so that the `\text{Norm}(f)` is square-free. sympy.polys.polytools.Poly.norm: Higher-level function that calls this. rEr7rTrF)rGr*rrHrIrJrr%)r3r<r>rMrNrOr.r.r/dmp_norm9s Hr_cCs,t|||j}t||j|j}t||j|S)z3Compute square-free part of ``f`` in ``GF(p)[x]``. )rrJr(rH)r3r>rMr.r.r/dup_gf_sqf_partsr`cCs tddS)z3Compute square-free part of ``f`` in ``GF(p)[X]``. +multivariate polynomials over finite fieldsNNotImplementedErrorr3r<r>r.r.r/dmp_gf_sqf_partsrecCst|jrt||S|s|S|t||r2t||}t|t|d||}t|||}|jrbt ||St ||dSdS)a Returns square-free part of a polynomial in ``K[x]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_sqf_part(x**3 - 3*x - 2) x**2 - x - 2 See Also ======== sympy.polys.polytools.Poly.sqf_part r7N) is_FiniteFieldr` is_negativer rr#rris_Fieldrr)r3r>rCsqfr.r.r/ dup_sqf_parts    rjc Cs|st||S|jr t|||St||r.|S|t|||rLt|||}|}t|dD]}t|t |d|||||}q\t ||||}|j rt |||St |||dSdS)z Returns square-free part of a polynomial in ``K[X]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> R.dmp_sqf_part(x**3 + 2*x**2*y + x*y**2) x**2 + x*y r7N)rjrfrerrgrrr@r$rr rhrr )r3r<r>rCrArir.r.r/ dmp_sqf_parts     rkFcCsr|}t|||j}t||j|j|d\}}t|D]"\}\}}t||j||f||<q2t|||||j|fS)zrmf_origcoefffactorsrAr-r.r.r/dup_gf_sqf_lists rscCs tddS)zrmr.r.r/dmp_gf_sqf_listsrtc Cs|jrt|||dS|}|jr4t||}t||}n.t||\}}|t||rbt||}| }t|dkrv|gfSgd}}t |d|}t |||\}} } t | d|} t | | |}|s| | |fqt | ||\}} } |st|dkr| ||f|d7}qt ||||fS)a Return square-free decomposition of a polynomial in ``K[x]``. Uses Yun's algorithm from [Yun76]_. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16 >>> R.dup_sqf_list(f) (2, [(x + 1, 2), (x + 2, 3)]) >>> R.dup_sqf_list(f, all=True) (2, [(1, 1), (x + 1, 2), (x + 2, 3)]) See Also ======== dmp_sqf_list: Corresponding function for multivariate polynomials. sympy.polys.polytools.sqf_list: High-level function for square-free factorization of expressions. sympy.polys.polytools.Poly.sqf_list: Analogous method on :class:`~.Poly`. References ========== [Yun76]_ rlrr7)rfrsrhr rrrgrrrr!rappendr6) r3r>rmrprqr4rArNrMpqrXr.r.r/ dup_sqf_lists4"          rxcCslt|||d\}}|rP|dddkrPt|dd||}|dfg|ddSt|g}|dfg|SdS)a Return square-free decomposition of a polynomial in ``K[x]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16 >>> R.dup_sqf_list_include(f) [(2, 1), (x + 1, 2), (x + 2, 3)] >>> R.dup_sqf_list_include(f, all=True) [(2, 1), (x + 1, 2), (x + 2, 3)] rlrr7N)rxr r )r3r>rmrqrrrMr.r.r/dup_sqf_list_includeAs  rycs|st|||dS|jr(t||||dS|}|jrLt|||}t|||}n4t|||\}}|t|||rt|||}| }t ||}|dkr|gfSt |||\}}i|dkrNt |d||}t ||||\} } } d} t | d||} t | | ||}t||r| | <qNt | |||\} } } |s>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = x**5 + 2*x**4*y + x**3*y**2 >>> R.dmp_sqf_list(f) (1, [(x + y, 2), (x, 3)]) >>> R.dmp_sqf_list(f, all=True) (1, [(1, 1), (x + y, 2), (x, 3)]) Explanation =========== Uses Yun's algorithm for univariate polynomials from [Yun76]_ recrusively. The multivariate polynomial is treated as a univariate polynomial in its leading variable. Then Yun's algorithm computes the square-free factorization of the primitive and the content is factored recursively. It would be better to use a dedicated algorithm for multivariate polynomials instead. See Also ======== dup_sqf_list: Corresponding function for univariate polynomials. sympy.polys.polytools.sqf_list: High-level function for square-free factorization of expressions. sympy.polys.polytools.Poly.sqf_list: Analogous method on :class:`~.Poly`. rlrr7csg|]}||fqSr.r.)r+rAr4r.r/r9sz dmp_sqf_list..)rxrfrtrhrrr rgrrr&rr"rr dmp_sqf_listrrTr=)r3r<r>rmrprqr5contentrNrMrvrwrArXZ coeff_contentZresult_contentr,r.rzr/r{]sP&          r{cCs|st|||dSt||||d\}}|rf|dddkrft|dd|||}|dfg|ddSt||}|dfg|SdS)ah Return square-free decomposition of a polynomial in ``K[x]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = x**5 + 2*x**4*y + x**3*y**2 >>> R.dmp_sqf_list_include(f) [(1, 1), (x + y, 2), (x, 3)] >>> R.dmp_sqf_list_include(f, all=True) [(1, 1), (x + y, 2), (x, 3)] rlrr7N)ryr{r r)r3r<r>rmrqrrrMr.r.r/dmp_sqf_list_includes r}cCs|s tdt||}t|s"gSt|t||j||}t||}t|D]6\}\}}t|t||| ||}||df||<qJt |||}t|s|S|dfg|SdS)z Compute greatest factorial factorization of ``f`` in ``K[x]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_gff_list(x**5 + 2*x**4 - x**3 - 2*x**2) [(x, 1), (x + 2, 4)] zDgreatest factorial factorization doesn't exist for a zero polynomialr7N) ValueErrorrrr#rone dup_gff_listrnrr)r3r>rMHrArNr-r.r.r/rs   rcCs|st||St|dS)z Compute greatest factorial factorization of ``f`` in ``K[X]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) N)rr)rdr.r.r/ dmp_gff_list s  rN)F)F)F)F)F)F)D__doc__Zsympy.polys.densearithrrrrrrrr r r Zsympy.polys.densebasicr r rrrrrrrrrrZsympy.polys.densetoolsrrrrrrrrr Zsympy.polys.euclidtoolsr!r"r#r$r%r&Zsympy.polys.galoistoolsr'r(Zsympy.polys.polyerrorsr)r*r6r=r?rDrQr]r^r_r`rerjrkrsrtrxryr{r}rrr.r.r.r/s408,  "R(VQ$%   M  l %