gMbdZddlmZmZmZmZmZmZmZm 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/dZ0d Z1d Z2d Z3d Z4d Z5dZ6dZ7dZ8dZ9dZ:dZ;ddZddZ?ddZ@ddZAdZBdZCdS)z8Square-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 DomainErrorcbtd|D}|t|ksJdS)z=Sanity check the degrees of a computed factorization in K[x].c3@K|]\}}|t|zVdS)N)r).0facks S/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/polys/sqfreetools.py z%_dup_check_degrees..$s1 9 9hsAa*S//! 9 9 9 9 9 9N)sumr)fresultdegs r1_dup_check_degreesr8"s; 9 9& 9 9 9 9 9C *Q--      r3cdg|dzz}|D]1\}t||}fdt||D}2t|t||ksJdS)z=Sanity check the degrees of a computed factorization in K[X].rc&g|] \}}||zzSr<)r.d1d2r0s r1 z&_dmp_check_degrees..-s%>>>BQV >>>r3N)rziptuple)r5ur6degsr/degs_facr0s @r1_dmp_check_degreesrE(s 3!a%=D??Q"3**>>>>#dH*=*=>>> ;;/!Q// / / / / / /r3c f|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 Tr:)rr$r)r5Ks r1 dup_sqf_prH1s; @tga!Q):):A>>????r3ct||rdSt|dzD]P}t|d|||}t||r&t||||}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 Tr:rF)rrangerr%r)r5rBrGifpgcds r1 dmp_sqf_prNGs !Qt 1Q3ZZ   Aq!Q ' ' b!    aQ"" a # #q ( (55 ) 4r3cZ|jstddt|jdd|j}} t |d|d\}}t||d|j}t||jrnt||j ||dz}}`|||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 algebraicrr:Tfront) is_Algebraicr+rmodto_listdomrr&rHrunit)r5rGsgh_rs r1 dup_sqf_normr]isB >=;<<< i Aqu55qA3!Q...1 !Q15 ) ) Q   3 Q++QUqA3 a7Nr3c #K|dz}dg|z}||fV|jt||}dtt|t |dzD}|D]A}|}d||<fd|D} t || ||} || fVBd} | dz } | g|z}  | zg|z} t || ||}| |fV.)z9Generate a sequence of candidate shifts for dmp_sqf_norm.r:rc$g|] \}}|dk |S)rr<)r.dirKs r1r?z(_dmp_sqf_norm_shifts..s!GGGQQ1r3cg|]} |z Sr<r<)r.s1ias r1r?z(_dmp_sqf_norm_shifts..s # # #qbf # # #r3)rWrsortedr@rJcopyr)r5rBrGns0d var_indicesrKs1a1f1jsjajfjrcs @r1_dmp_sqf_norm_shiftsrqs+ AA qB a%KKK A 1AGG&Qac ););"<"<GGGK WWYY1 # # # # # # # q"a # #"f  A QS1WbdVaZ q"a # #"f r3c|st||\}}}|g||fS|jstdt|j|dzd|j}t|||D]M\}}t|||d\}}t|||dz|j}t|||jrnN|||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. rPr:rTrQ) r]rSr+rrTrUrVrqrr&rN)r5rBrGrXrYr\rZr[s r1 dmp_sqf_normrssD q!$$1asAqy >=;<<<!%--//1q5!QU33A$Q1--1!Q...1 !QAqu - - Q15 ! !  E  a7Nr3c|jstdt|j|dzd|j}t |||d\}}t|||dz|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. rPr:rTrQ)rSr+rrTrUrVrr&)r5rBrGrYrZr[s r1dmp_normru9suP >=;<<<!%--//1q5!QU33A aAT * * *DAq Aq1uae , ,,r3ct|||j}t||j|j}t||j|S)z3Compute square-free part of ``f`` in ``GF(p)[x]``. )rrVr)rT)r5rGrYs r1dup_gf_sqf_partrws>Aq!%  AAquae$$A q!% # ##r3c td)z3Compute square-free part of ``f`` in ``GF(p)[X]``. +multivariate polynomials over finite fieldsNotImplementedErrorr5rBrGs r1dmp_gf_sqf_partr} K L LLr3cZ|jrt||S|s|S|t||rt ||}t |t |d||}t|||}|jrt||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 r:) is_FiniteFieldrw is_negativerrr$rr is_Fieldrr )r5rGrMsqfs r1 dup_sqf_partrs$ %q!$$$ }}VAq\\"" AqMM !XaA&& * *C !S!  Cz(a   S!$$Q''r3c |st||S|jrt|||St||r|S|t |||rt |||}|}t|dzD]%}t|t|d|||||}&t||||}|j rt|||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 r:)rrr}rrrrrJr%rr rrr!)r5rBrGrMrKrs r1 dmp_sqf_partrs  "Aq!!!(q!Q'''!Q}}]1a++,, Aq!   C 1Q3ZZ==c;q!Q155q!<< !S!Q  Cz2Q***#CA..q11r3Fc2|}t|||j}t||j|j|\}}t |D]#\}\}}t||j||f||<$t |||||j|fS)z>> 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]_ rrr:)rrrrrr rrrrr"rappendr8) r5rGrrrr6rKrZrYpqrhs r1 dup_sqf_listrsD .q!---- Fzq!  aOO A&&q ==1 & & 1 AFE!}}byAAFAqAAq!$$GAq!  Q1   Aq!    MM1a& ! ! ! 1a((1a  "*Q--!## MM1a& ! ! ! Q vv&&& &=r3ct|||\}}|r?|dddkr-t|dd||}|dfg|ddzSt|g}|dfg|zS)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)] rrr:N)rr r )r5rGrrrrYs r1dup_sqf_list_includerAs$"!QC000NE7"71:a=A%% 71:a=% 3 3Ax'!""+%% ug  Ax'!!r3c|st|||S|jrt||||S|}|jr#t |||}t |||}nLt |||\}}|t |||rt|||}| }t||}|dkr|gfSt|||\}}i|dkrt|d||}t||||\} } } d} t| d||} t| | ||}t||r| | <n7t| |||\} } } |st| |dkr| | <| dz } qt||dz ||\}}||z}|D]-\}} |g}| vrt!| |||| <(|| <.fdt#Dt%|||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`. rrr:Tc$g|] }||f Sr<r<)r.rKr6s r1r?z dmp_sqf_list..s! 5 5 5vay!n 5 5 5r3)rrrrrrr!rrrr'rr#rr dmp_sqf_listrrdrE)r5rBrGrrrr7contentrZrYrrrKrh coeff_contentresult_contentr/r6s @r1rr]sL +Aqc****1q!QC0000 FzaA&& Q1 % %'1a00q ==q!Q// 0 0 1a  AFE Q  C Qwwbyq!Q''JGQ F axx Q1a 1a++1a  Aq!$$A1a##A!Q q #Aq!Q//GAq! jA&&**q FA %1!A#qc$J$J$J!M> ]E!Qe ;;q 3155F1IIF1II 5 5 5 5fVnn 5 5 5Fvq&))) &=r3c |st|||St||||\}}|r@|dddkr.t|dd|||}|dfg|ddzSt||}|dfg|zS)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)] rrr:N)rrr r)r5rBrGrrrrYs r1dmp_sqf_list_includers$ 3#Aqc2222!!Qs333NE7"71:a=A%% 71:a=%A 6 6Ax'!""+%% ua Ax'!!r3c |stdt||}t|sgSt|t ||j||}t ||}t|D]<\}\}}t|t ||| ||}||dzf||<=t|||}t|s|S|dfg|zS)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 polynomialr:) ValueErrorrrr$rone dup_gff_listrrr )r5rGrYHrKrZr0s r1rrs a_```!QA a==  AyAE1--q 1 1 A  "1  IAv19Q1q11155Aq1u:AaDD Aq!  !}} HF8a< r3cD|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*r|s r1 dmp_gff_listr s* -Aq!!!)!,,,r3N)F)D__doc__sympy.polys.densearithrrrrrrr r r r sympy.polys.densebasicr rrrrrrrrrrrsympy.polys.densetoolsrrrrrrrr r!sympy.polys.euclidtoolsr"r#r$r%r&r'sympy.polys.galoistoolsr(r)sympy.polys.polyerrorsr*r+r8rErHrNr]rqrsrurwr}rrrrrrrrrrr<r3r1rs>>$$$$$$$$$$$$$$$$$$$$$$$$ )))))))))))))))))))))) """"""""""""""""    000@@@,DOOOd%%%PSSSlN-N-N-b$$$MMM !(!(!(H"2"2"2J , , , , MMMM JJJJZ""""8iiiiX"""">" " " J-----r3