o o 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"Zd2d'd(Z?d2d)d*Z@d2d+d,ZAd-d.ZBd/d0ZCd1S)3z8Square-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|ksJdS)z=Sanity check the degrees of a computed factorization in K[x].css |] \}}|t|VqdS)N)r).0fackr.k/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/polys/sqfreetools.py $sz%_dup_check_degrees..N)sumr)fresultdegr.r.r/_dup_check_degrees"sr5csXdg|d}|D]\}t||}fddt||D}q t|t||ks*JdS)z=Sanity check the degrees of a computed factorization in K[X].rcsg|] \}}||qSr.r.)r+d1d2r-r.r/ -z&_dmp_check_degrees..N)rziptuple)r2ur3degsr,degs_facr.r9r/_dmp_check_degrees(s   rAcCs"|sdStt|t|d|| S)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 Tr6)rr#r)r2Kr.r.r/ dup_sqf_p1srCcCsdt||rdSt|dD]"}t|d|||}t||rq t||||}t|||dkr/dSq dS)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 Tr6rF)rrangerr$r)r2r>rBifpgcdr.r.r/ dmp_sqf_pGs  rHcCs|jstddt|jdd|j}} t|d|dd\}}t||d|j}t||jr/nt ||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 algebraicrr6Tfront) is_Algebraicr*rmodto_listdomrr%rCrunit)r2rBsgh_rr.r.r/ dup_sqf_normisA  rVc#s|d}dg|}||fV|jt||}ddtt|t|dD}|D]}|}d||<fdd|D} t|| ||} || fVq)d} | d7} | g|} | g|} t|| ||}| |fVqL)z9Generate a sequence of candidate shifts for dmp_sqf_norm.r6rcSsg|] \}}|dkr|qS)rr.)r+dirEr.r.r/r:r;z(_dmp_sqf_norm_shifts..csg|]} |qSr.r.)r+s1iar.r/r:s)rPrsortedr<rDcopyr)r2r>rBns0d var_indicesrEs1a1f1jsjajfjr.rYr/_dmp_sqf_norm_shiftss*       rhcCs|st||\}}}|g||fS|jstdt|j|dd|j}t|||D]!\}}t|||dd\}}t |||d|j}t |||jrKnq*|||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. rIr6rTrJ) rVrLr*rrMrNrOrhrr%rH)r2r>rBrQrRrUrSrTr.r.r/ dmp_sqf_normsB  ricCsP|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. rIr6rTrJ)rLr*rrMrNrOrr%)r2r>rBrRrSrTr.r.r/dmp_norm9s HrjcCs,t|||j}t||j|j}t||j|S)z3Compute square-free part of ``f`` in ``GF(p)[x]``. )rrOr(rM)r2rBrRr.r.r/dup_gf_sqf_partsrkcCtd)z3Compute square-free part of ``f`` in ``GF(p)[X]``. +multivariate polynomials over finite fieldsNotImplementedErrorr2r>rBr.r.r/dmp_gf_sqf_partrqcCsp|jrt||S|s |S|t||rt||}t|t|d||}t|||}|jr1t ||St ||dS)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 r6) is_FiniteFieldrk is_negativer rr#rris_Fieldrr)r2rBrGsqfr.r.r/ dup_sqf_parts    rwc Cs|st||S|jrt|||St||r|S|t|||r&t|||}|}t|dD]}t|t |d|||||}q.t ||||}|j rNt |||St |||dS)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 r6)rwrsrqrrtrrrDr$rr rurr )r2r>rBrGrErvr.r.r/ dmp_sqf_parts     rxFcCsr|}t|||j}t||j|j|d\}}t|D]\}\}}t||j||f||<qt|||||j|fS)zrBrzr.r.r/dmp_gf_sqf_listrrrc Cs|jr t|||dS|}|jrt||}t||}nt||\}}|t||r1t||}| }t|dkr;|gfSgd}}t |d|}t |||\}} } t | d|} t | | |}|sf| | |fnt | ||\}} } |swt|dkr~| ||f|d7}qPt ||||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]_ ryrr6)rsrrur rrrtrrrr!rappendr5) r2rBrzr}r~r3rErSrRpqr_r.r.r/ dup_sqf_lists8"         rcCsht|||d\}}|r(|dddkr(t|dd||}|dfg|ddSt|g}|dfg|S)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)] ryrr6N)rr r )r2rBrzr~rrRr.r.r/dup_sqf_list_includeAs  rcs|s t|||dS|jrt||||dS|}|jr&t|||}t|||}nt|||\}}|t|||r@t|||}| }t ||}|dkrM|gfSt |||\}}i|dkrt |d||}t ||||\} } } d} t | d||} t | | ||}t||r| | <nt | |||\} } } |st | |dkr| | <| d7} qot||d||d\}}||9}|D]\}} |g}| vrt| |||| <q|| <qfddtDt|||fS)a1 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(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`. ryrr6Tcsg|]}||fqSr.r.)r+rEr3r.r/r:sz dmp_sqf_list..)rrsrrurrr rtrrr&rr"rr dmp_sqf_listrr[rA)r2r>rBrzr}r~r4contentrSrRrrrEr_ coeff_contentresult_contentr,r.rr/r]sT&       rcCs~|s t|||dSt||||d\}}|r3|dddkr3t|dd|||}|dfg|ddSt||}|dfg|S)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)] ryrr6N)rrr r)r2r>rBrzr~rrRr.r.r/dmp_sqf_list_includes rcCs|stdt||}t|sgSt|t||j||}t||}t|D]\}\}}t|t||| ||}||df||<q%t |||}t|sM|S|dfg|S)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 polynomialr6) ValueErrorrrr#rone dup_gff_listr{rr)r2rBrRHrErSr-r.r.r/rs   rcCs|st||St|)z Compute greatest factorial factorization of ``f`` in ``K[X]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) )rr)rpr.r.r/ dmp_gff_list s rN)F)D__doc__sympy.polys.densearithrrrrrrrr r r sympy.polys.densebasicr r rrrrrrrrrrsympy.polys.densetoolsrrrrrrrrr sympy.polys.euclidtoolsr!r"r#r$r%r&sympy.polys.galoistoolsr'r(sympy.polys.polyerrorsr)r*r5rArCrHrVrhrirjrkrqrwrxrrrrrrrrr.r.r.r/s608,  "R(VQ$ %   M  l %