U Zʹj@s@dZddlmZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDddlEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTddlUmVZVmWZWmXZXdd lYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`dd lambZbdd lcmdZddd lemfZfmgZgmhZhmiZidd ljmkZkddllmmZnmoZpmqZredkr ddlsmtZtndZtddZuddZvddZwddZxddZyddZzddZ{d d!Z|d"d#Z}d]d%d&Z~d'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Zd^d=d>Zd?d@ZdAdBZdCdDZdEdFZdGdHZdIdJZdKdLZdMdNZdOdPZdQdRZdSdTZdUdVZdWdXZdYdZZd[d\ZdS)_z:Polynomial factorization routines in characteristic zero. ) GROUND_TYPES)_randint) gf_from_int_polygf_to_int_poly gf_lshift gf_add_mulgf_mulgf_divgf_remgf_gcdexgf_sqf_p gf_factor_sqf gf_factor)dup_LCdmp_LC dmp_ground_LCdup_TC dup_convert dmp_convert dup_degree dmp_degree dmp_degree_indmp_degree_list dmp_from_dict dmp_zero_pdmp_onedmp_nest dmp_raise dup_strip dmp_ground dup_inflate dmp_exclude dmp_include dmp_inject dmp_eject dup_terms_gcd dmp_terms_gcd)dup_negdmp_negdup_adddmp_adddup_subdmp_subdup_muldmp_muldup_sqrdmp_powdup_divdmp_divdup_quodmp_quo dmp_expand dmp_add_mul dup_sub_mul dmp_sub_mul dup_lshift dup_max_norm dmp_max_norm dup_l1_normdup_mul_grounddmp_mul_grounddup_quo_grounddmp_quo_ground)dup_clear_denomsdmp_clear_denoms dup_truncdmp_ground_trunc dup_content dup_monicdmp_ground_monic dup_primitivedmp_ground_primitive dmp_eval_tail dmp_eval_indmp_diff_eval_in dup_shift dmp_shift dup_mirror) dmp_primitive dup_inner_gcd dmp_inner_gcd) dup_sqf_p dup_sqf_norm dmp_sqf_norm dup_sqf_part dmp_sqf_part_dup_check_degrees_dmp_check_degrees) _sort_factors)query)ExtraneousFactors DomainErrorCoercionFailedEvaluationFailed)subsets)ceilloglog2flint) fmpz_polyNcCs`g}|D]N}d}t|||\}}|s8||d}}qq8q|dkrHtd|||fqt|S)z Determine multiplicities of factors for a univariate polynomial using trial division. An error will be raised if any factor does not divide ``f``. rtrial division failed)r1 RuntimeErrorappendrZ)ffactorsKresultfactorkqrrrV/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/polys/factortools.pydup_trial_divisionXsrtc Cshg}|D]V}d}t||||\}}t||r@||d}}qq@q|dkrPtd|||fqt|S)z Determine multiplicities of factors for a multivariate polynomial using trial division. An error will be raised if any factor does not divide ``f``. rrfrg)r2rrhrirZ) rjrkurlrmrnrorprqrrrrrsdmp_trial_divisionts rvc Csddlm}t|}t|d}t|d}|tdd|D}||d|}||d|d}|t||} |||| } | t||7} t| dd} | S)a The Knuth-Cohen variant of Mignotte bound for univariate polynomials in ``K[x]``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> f = x**3 + 14*x**2 + 56*x + 64 >>> R.dup_zz_mignotte_bound(f) 152 By checking ``factor(f)`` we can see that max coeff is 8 Also consider a case that ``f`` is irreducible for example ``f = 2*x**2 + 3*x + 4``. To avoid a bug for these cases, we return the bound plus the max coefficient of ``f`` >>> f = 2*x**2 + 3*x + 4 >>> R.dup_zz_mignotte_bound(f) 6 Lastly, to see the difference between the new and the old Mignotte bound consider the irreducible polynomial: >>> f = 87*x**7 + 4*x**6 + 80*x**5 + 17*x**4 + 9*x**3 + 12*x**2 + 49*x + 26 >>> R.dup_zz_mignotte_bound(f) 744 The new Mignotte bound is 744 whereas the old one (SymPy 1.5.1) is 1937664. References ========== ..[1] [Abbott13]_ r)binomialcss|]}|dVqdS)rxNrr.0cfrrrrrs sz(dup_zz_mignotte_bound..rf) Z(sympy.functions.combinatorial.factorialsrwr_ceilsqrtsumabsrr:) rjrlrwddeltaZdelta2Z eucl_normt1t2lcboundrrrrrsdup_zz_mignotte_bounds)   rcCsLt|||}tt|||}tt||}|||dd|||S)z7Mignotte bound for multivariate polynomials in `K[X]`. rfrx)r;rrrrr~)rjrurlabnrrrrrsdmp_zz_mignotte_bounds rcCsJ|d}t||||}t|||}tt|||||\} } t| ||} t| ||} tt|||t| |||} tt|| |||} tt|| |||} tt|| |t|| ||} tt| |jg|||}tt|||| |\}}t|||}t|||}tt|||t|| ||} tt|||||}tt|| |||}| | ||fS)a  One step in Hensel lifting in `Z[x]`. Given positive integer `m` and `Z[x]` polynomials `f`, `g`, `h`, `s` and `t` such that:: f = g*h (mod m) s*g + t*h = 1 (mod m) lc(f) is not a zero divisor (mod m) lc(h) = 1 deg(f) = deg(g) + deg(h) deg(s) < deg(h) deg(t) < deg(g) returns polynomials `G`, `H`, `S` and `T`, such that:: f = G*H (mod m**2) S*G + T*H = 1 (mod m**2) References ========== .. [1] [Gathen99]_ rx)r7rCr1r-r)r+one)mrjghstrlMerprqruGHrcrSTrrrrrsdup_zz_hensel_steps$     rc Csvt|}t||}|dkrHt|||||d|}t||||gS|}|d} ttt|} t|g|} |d| D]} t | t| |||} q|t|| |} || ddD]} t | t| |||} qt | | ||\}}}t | |} t | |} t ||}t ||}t d| dD],}t ||| | ||||d\} } }}}qt|| |d| ||t|| || d||S)a Multifactor Hensel lifting in `Z[x]`. Given a prime `p`, polynomial `f` over `Z[x]` such that `lc(f)` is a unit modulo `p`, monic pair-wise coprime polynomials `f_i` over `Z[x]` satisfying:: f = lc(f) f_1 ... f_r (mod p) and a positive integer `l`, returns a list of monic polynomials `F_1,\ F_2,\ \dots,\ F_r` satisfying:: f = lc(f) F_1 ... F_r (mod p**l) F_i = f_i (mod p), i = 1..r References ========== .. [1] [Gathen99]_ rfrrxN)lenrr=ZgcdexrCintr}_log2rrr rrangerdup_zz_hensel_lift)prjZf_listlrlrqrFrrorrZf_irrr_rrrrrsrs0      *rcCs(||dkr||}|sdS||dkS)NrxTrrr)fcrpplrrrrrs_test_plGs  rcs|t|}|dkr|gSddlm}|d}t||}t||}tt|||dd|||}t|dd||d|d}ttdt |} td| t | } g} t d| dD]|} || r|| dkrq| | } t || } t| | |sqt| | |d}| | |ft|dkspz#dup_zz_zassenhaus..)keycsg|]}t|qSrr)r)rzff)rrrrs tsz%dup_zz_zassenhaus..csg|]}|kr|qSrrrr)rzi)rrrrsrs)r sympy.ntheoryrr:rrrr~r}r_logrconvertrr r rirminrsetr`rr-rCrHr<)rjrlrrrArBCgammarrZpxrZfsqfxZfsqfrZmodularrZsorted_TrrkrrrprrrZT_SZG_normZH_normrr)rrrsdup_zz_zassenhausNs   *$               rcCsnt||}t||}t|dd|}|rjddlm}|t|}|D]}||rJ||drJdSqJdS)z2Test irreducibility using Eisenstein's criterion. rfNr factorintrxT)rrrErrrkeys)rjrlrtcZe_fcrZe_ffrrrrrrsdup_zz_irreducible_ps     rFcCs|jr>z||}}t|||}WqHtk r:YdSXn |jsHdSt||}t||}|dkst|dkrx|dkrxdS|st||\}}||jks||dfgkrdSt |}gg} } t |ddD]} | d|| qt |dddD]} | d|| qt t | |} t t | |} t| t| d||} |t| |rLt| |} | |krZdSt||} |t| |rt| |} | | krt| |rdSt| |} t | || krt| |rdSdS)ad Efficiently test if ``f`` is a cyclotomic polynomial. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1 >>> R.dup_cyclotomic_p(f) False >>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1 >>> R.dup_cyclotomic_p(g) True References ========== Bradford, Russell J., and James H. Davenport. "Effective tests for cyclotomic polynomials." In International Symposium on Symbolic and Algebraic Computation, pp. 244-251. Springer, Berlin, Heidelberg, 1988. FrfrrT)Zis_QQget_ringrr^is_ZZrrdup_factor_listrrrinsertr/rr+r9 is_negativer'rOdup_cyclotomic_prV)rjrlZ irreducibleK0rrcoeffrkrrrrrrrrrrrsrsL         rcCs\ddlm}|j|j g}||D]0\}}tt|||||}t|||d|}q&|S)z1Efficiently generate n-th cyclotomic polynomial. rrrf)rrritemsr3r )rrlrrrrorrrrrsdup_zz_cyclotomic_polys  rcsddlm}jj gg}||D]T\}fdd|D}||td|D]"}fdd|D}||qXq(|S)Nrrcs g|]}tt||qSrr)r3r )rzrrlrrrrsr,sz-_dup_cyclotomic_decompose..rfcsg|]}t|qSrr)r )rzrprrrrsr0s)rrrrextendr)rrlrrroQrrrrrs_dup_cyclotomic_decompose&s  rcCst||t||}}t|dkr&dS|dks6|dkr:dStdd|ddDrXdSt|}t||}||sx|Sg}td||D]}||kr||q|SdS) a Efficiently factor polynomials `x**n - 1` and `x**n + 1` in `Z[x]`. Given a univariate polynomial `f` in `Z[x]` returns a list of factors of `f`, provided that `f` is in the form `x**n - 1` or `x**n + 1` for `n >= 1`. Otherwise returns None. Factorization is performed using cyclotomic decomposition of `f`, which makes this method much faster that any other direct factorization approach (e.g. Zassenhaus's). References ========== .. [1] [Weisstein09]_ rNrf)rrfcss|]}t|VqdS)N)boolryrrrrrsr|Psz+dup_zz_cyclotomic_factor..rrx)rrranyris_oneri)rjrlZlc_fZtc_frrrrrrrrrsdup_zz_cyclotomic_factor6s     rcCst||\}}t|}t||dkr6| t||}}|dkrF|gfS|dkrX||gfStdrtt||rt||gfSd}tdrt||}|dkrt||}|t|ddfS)z:Factor square-free (non-primitive) polynomials in `Z[x]`. rrfUSE_IRREDUCIBLE_IN_FACTORNUSE_CYCLOTOMIC_FACTORF)Zmultiple) rHrrr'r[rrrrZ)rjrlcontrrrkrrrrrsdup_zz_factor_sqfbs"     rcCs tdkr@t|ddd}|\}}dd|D}|t|fSt||\}}t|}t||dkrv| t||}}|dkr|gfS|dkr||dfgfStdrt ||r||dfgfSt ||}d}td rt ||}|dkrt ||}t |||}t||||fS) a Factor (non square-free) polynomials in `Z[x]`. Given a univariate polynomial `f` in `Z[x]` computes its complete factorization `f_1, ..., f_n` into irreducibles over integers:: f = content(f) f_1**k_1 ... f_n**k_n The factorization is computed by reducing the input polynomial into a primitive square-free polynomial and factoring it using Zassenhaus algorithm. Trial division is used to recover the multiplicities of factors. The result is returned as a tuple consisting of:: (content(f), [(f_1, k_1), ..., (f_n, k_n)) Examples ======== Consider the polynomial `f = 2*x**4 - 2`:: >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_zz_factor(2*x**4 - 2) (2, [(x - 1, 1), (x + 1, 1), (x**2 + 1, 1)]) In result we got the following factorization:: f = 2 (x - 1) (x + 1) (x**2 + 1) Note that this is a complete factorization over integers, however over Gaussian integers we can factor the last term. By default, polynomials `x**n - 1` and `x**n + 1` are factored using cyclotomic decomposition to speedup computations. To disable this behaviour set cyclotomic=False. References ========== .. [1] [Gathen99]_ rdNrcSs&g|]\}}|ddd|fqS)Nr)Zcoeffs)rzfacexprrrrrsrsz!dup_zz_factor..rrfrr)rrernrZrHrrr'r[rrVrrrtrX)rjrlZf_flintrrkrrrrrrrrs dup_zz_factors2.        rcCsp||g}|D]T}t|}t|D]4}|dkrD|||}||}q&||r"dSq"||q|ddS)z,Wang/EEZ: Compute a set of valid divisors. rfN)rreversedgcdrri)Ecsctrlrmrprqrrrrrsdmp_zz_wang_non_divisorss       rc stt||ds tdt||}t|s@tdt|\}}t|rp| t|}}|dfdd|D} t| ||} | dk r||| fStddS)z2Wang/EEZ: Test evaluation points for suitability. rfzno luckcsg|]\}}t|qSrr)rJ)rzrrrrlvrrrsrsz+dmp_zz_wang_test_points..N) rJrr_rSrHrrr'r) rjrrrrurlrrrrDrrrrsdmp_zz_wang_test_pointss  rc Csgdgt||d}} } |D]} t| |} t| ||} ttt|D]f}d||||}}\}}| |s| ||d} }qn|dkrNt| t||| || |d} | |<qN|| q"t| st gg}}t ||D]\} } t | || |} t| |}| |r|| }n4| || }| |||} }t| | ||| } }t| || |} || || q| |r|||fSgg}}t ||D]2\} } |t| || ||t| |d|qt||t|d||}|||fS)z0Wang/EEZ: Compute correct leading coefficients. rrf)rrrrrr.r0riallr\ziprJrrr=r>)rjrrrrrrurlrJrrrrrrorrrCCZHHrccrZCCCZHHHrrrrrsdmp_zz_wang_lead_coeffssB $           rc Cst|dkr|\}}t||}t||}t||||\}} } t|||}t| ||} t||||\} }t| | |||} t||}t| |} || g} n|dg} t|ddD]}| dt || d|qgdgg} }t || D]<\}}t ||g|dgd|d|\} }| | | |qg| |dg} } t | |D]H\}}t||}t||}t t||||||}t||}| |q@| S)z2Wang/EEZ: Solve univariate Diophantine equations. rxrrfr)rrr rr rrrrr-rdmp_zz_diophantinerir )rrrrlrrrjrrrrrprmrrrqrrrrrsdup_zz_diophantine7s8               rc s|sdd|D}t|}t|D]`\} } | s0q"t||| } tt|| D]0\} \} }t|| }tt| ||| <qPq"n*t|}t|}|d|dd}}gg}}|D].}| t ||| t |||qt |||}dt ||||}fdd|D}t||D]\} }t || |}q:t|}tj| g|}t|}td|D] }t|rqt||}t||d||}t|st||d}t ||||} t| D]&\} }tt|d|| | <q tt|| D] \} \} }t| ||| <qBt| |D]\}}t |||}qnt|}qfdd|D}|S) z4Wang/EEZ: Solve multivariate Diophantine equations. cSsg|]}gqSrrrrrzrrrrrrsrjsz&dmp_zz_diophantine..rNrfcsg|]}t|dqSrf)rrzr)rlrrrrsrsrcsg|]}t|qSrr)rDr)rlrrurrrsrs)r enumeraterrr=rCr)rr5rir4rKrr8rDrrrrrr.rLr@ factorialrr*)rrrrrrurlrrrrrjrrrrrrrjrrrrrorr)rlrrurrsrgsV        rc Cs|gt||d}}} t|}tt|ddD]>\} } t|d| || || |} |dt| || | |q6tt||dd} t t d|d||D]\}} } t||d}}|d|d||dd}}tt ||D]L\} \}}tt ||| |||d|}|gt |ddd|d||| <qt |j| g||}t||}t| t|||||}t| ||}t d|D]}t||rqt||||}t||d| |||}t||dst||||d|d|}t|||| ||d|}tt ||D]>\} \}}t|t |d|d||||}t|||||| <qt| t|||||}t||||}qqt||||krtn|SdS)z-Wang/EEZ: Parallel Hensel lifting algorithm. rfNrrx)rlistrrrKrrDmaxrrrrJrrrrr,r5rrr.rLr@rrr6r\)rjrLCrrrurlrrrrrrrrrwIrrrrrrZdjrorrrrrrrrsdmp_zz_wang_hensel_liftings@""&    rc sNddlm}t|tt||d\}}t||}||} dkr`|dkr\dndtgjg|df\} } } } zRt|||| |\}}}t |\}}t |} | dkr|gWS||||| fg} Wnt k rYnXt d}t d}t d}t | |kr"t |D]}fd d t |D} t| | kr| t| nqzt|||| |\}}}Wnt k rYqYnXt |\}}t |}| dk r|| kr|| krg|} } nqn|} | dkr|gS| ||||| ft | |krqq|7qd \}}}| D]D\}}}}}t|}|dk rf||krj|}|}n|}|d7}q0| |\}}}}} |}z4t|||||| |\}}}t|||| | |}Wn>tk rt d rt||dYStd YnXg}|D]@}t||\}}t||r a_2, ..., x_n -> a_n where `a_i`, for `i = 2, \dots, n`, are carefully chosen integers. The mapping is used to transform `f` into a univariate polynomial in `Z[x_1]`, which can be factored efficiently using Zassenhaus algorithm. The last step is to lift univariate factors to obtain true multivariate factors. For this purpose a parallel Hensel lifting procedure is used. The parameter ``seed`` is passed to _randint and can be used to seed randint (when an integer) or (for testing purposes) can be a sequence of numbers. References ========== .. [1] [Wang78]_ .. [2] [Geddes92]_ r) nextprimerfNrxZEEZ_NUMBER_OF_CONFIGSZEEZ_NUMBER_OF_TRIESZEEZ_MODULUS_STEPcsg|]} qSrrrrrrlmodrandintrrrsr"szdmp_zz_wang..)NrrZEEZ_RESTART_IF_NEEDEDz3we need to restart algorithm with better parameters)rrr dmp_zz_factorrrrzerorrrr_r[rtupleaddrir:rrr\ dmp_zz_wangrIrrr()rjrurlrseedrrrrrhistoryZconfigsrrqrrrrrZeez_num_configsZ eez_num_triesZ eez_mod_stepZrrZs_normZs_argrZ_s_normorig_frrkrmrrrrsrs                   rc Cs|st||St||r"|jgfSt|||\}}t|||dkrV| t|||}}tddt||Drv|gfSt|||\}}g}t ||dkrt |||}t |||}t ||||}t ||d|dD]\}}|d|g|fqt||||t|fS)a Factor (non square-free) polynomials in `Z[X]`. Given a multivariate polynomial `f` in `Z[x]` computes its complete factorization `f_1, \dots, f_n` into irreducibles over integers:: f = content(f) f_1**k_1 ... f_n**k_n The factorization is computed by reducing the input polynomial into a primitive square-free polynomial and factoring it using Enhanced Extended Zassenhaus (EEZ) algorithm. Trial division is used to recover the multiplicities of factors. The result is returned as a tuple consisting of:: (content(f), [(f_1, k_1), ..., (f_n, k_n)) Consider polynomial `f = 2*(x**2 - y**2)`:: >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> R.dmp_zz_factor(2*x**2 - 2*y**2) (2, [(x - y, 1), (x + y, 1)]) In result we got the following factorization:: f = 2 (x - y) (x + y) References ========== .. [1] [Gathen99]_ rcss|]}|dkVqdSrNrrrzrrrrrrsr|sz dmp_zz_factor..rf)rrrrIrr(rrrPrrWrrvrrrYrZ) rjrurlrrrrkrrorrrrrsrms&$      rcsJt|}t|\}}fdd|D}|}||fS)z>Factor univariate polynomials into irreducibles in `QQ_I[x]`. cs g|]\}}t||fqSrr)rrzrrrK1rrrsrsz#dup_qq_i_factor..)as_AlgebraicFieldrrr)rjrrrkrrrrsdup_qq_i_factors   r c Cs|}t|||}t||\}}g}|D]T\}}t||\}} t| ||} t| d|\} } || |||}|| |fq*|}|||}||fS)z>Factor univariate polynomials into irreducibles in `ZZ_I[x]`. r) get_fieldrr rArIrir) rjrr rrk new_factorsrr fac_denomfac_num fac_num_ZZ_Icontentfac_primrrrrrsdup_zz_i_factors    rcsPt|}t|\}}fdd|D}|}||fS)z@Factor multivariate polynomials into irreducibles in `QQ_I[X]`. cs"g|]\}}t||fqSrr)rrrr rurrrsrsz#dmp_qq_i_factor..)r rdmp_factor_listr)rjrurrrkrrrrsdmp_qq_i_factors  rcCs|}t||||}t|||\}}g}|D]X\}}t|||\} } t| |||} t| ||\} } || || |}|| |fq.|}|||}||fS)z@Factor multivariate polynomials into irreducibles in `ZZ_I[X]`. )r rrrBrIrir)rjrurr rrkr rrrrrrrrrrrrsdmp_zz_i_factors  rcCst|t||}}t||}|dkr.|gfS|dkrD||dfgfSt|||}}t||\}}}t||j}t|dkr|||t|fgfS||j} t |D]@\} \} } t | |j|} t | ||\} } }t | | |} | || <qt |||}t||||fS)aN Factor univariate polynomials over algebraic number fields. The domain `K` must be an algebraic number field `k(a)` (see :ref:`QQ(a)`). Examples ======== First define the algebraic number field `K = \mathbb{Q}(\sqrt{2})`: >>> from sympy import QQ, sqrt >>> from sympy.polys.factortools import dup_ext_factor >>> K = QQ.algebraic_field(sqrt(2)) We can now factorise the polynomial `x^2 - 2` over `K`: >>> p = [K(1), K(0), K(-2)] # x^2 - 2 >>> p1 = [K(1), -K.unit] # x - sqrt(2) >>> p2 = [K(1), +K.unit] # x + sqrt(2) >>> dup_ext_factor(p, K) == (K.one, [(p1, 1), (p2, 1)]) True Usually this would be done at a higher level: >>> from sympy import factor >>> from sympy.abc import x >>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2)) Explanation =========== Uses Trager's algorithm. In particular this function is algorithm ``alg_factor`` from [Trager76]_. If `f` is a polynomial in `k(a)[x]` then its norm `g(x)` is a polynomial in `k[x]`. If `g(x)` is square-free and has irreducible factors `g_1(x)`, `g_2(x)`, `\cdots` then the irreducible factors of `f` in `k(a)[x]` are given by `f_i(x) = \gcd(f(x), g_i(x))` where the GCD is computed in `k(a)[x]`. The first step in Trager's algorithm is to find an integer shift `s` so that `f(x-sa)` has square-free norm. Then the norm is factorized in `k[x]` and the GCD of (shifted) `f` with each factor gives the shifted factors of `f`. At the end the shift is undone to recover the unshifted factors of `f` in `k(a)[x]`. The algorithm reduces the problem of factorization in `k(a)[x]` to factorization in `k[x]` with the main additional steps being to compute the norm (a resultant calculation in `k[x,y]`) and some polynomial GCDs in `k(a)[x]`. In practice in SymPy the base field `k` will be the rationals :ref:`QQ` and this function factorizes a polynomial with coefficients in an algebraic number field like `\mathbb{Q}(\sqrt{2})`. See Also ======== dmp_ext_factor: Analogous function for multivariate polynomials over ``k(a)``. dup_sqf_norm: Subroutine ``sqfr_norm`` also from [Trager76]_. sympy.polys.polytools.factor: The high-level function that ultimately uses this function as needed. rrf)rrrFrVrTdup_factor_list_includedomrunitrrrQrMrtrX)rjrlrrrrrrqrkrrrnrrrrrrrsdup_ext_factors(B        rcs|st|St||}t||}tddt||DrF|gfSt|||}}t||\}}}t||j}t |dkr|g}nbt |D]X\} \} } t | |j} t | ||\} } }fdd|D} t | | |} | || <qt|||}t|||||fS)aFactor multivariate polynomials over algebraic number fields. The domain `K` must be an algebraic number field `k(a)` (see :ref:`QQ(a)`). Examples ======== First define the algebraic number field `K = \mathbb{Q}(\sqrt{2})`: >>> from sympy import QQ, sqrt >>> from sympy.polys.factortools import dmp_ext_factor >>> K = QQ.algebraic_field(sqrt(2)) We can now factorise the polynomial `x^2 y^2 - 2` over `K`: >>> p = [[K(1),K(0),K(0)], [], [K(-2)]] # x**2*y**2 - 2 >>> p1 = [[K(1),K(0)], [-K.unit]] # x*y - sqrt(2) >>> p2 = [[K(1),K(0)], [+K.unit]] # x*y + sqrt(2) >>> dmp_ext_factor(p, 1, K) == (K.one, [(p1, 1), (p2, 1)]) True Usually this would be done at a higher level: >>> from sympy import factor >>> from sympy.abc import x, y >>> factor(x**2*y**2 - 2, extension=sqrt(2)) (x*y - sqrt(2))*(x*y + sqrt(2)) Explanation =========== This is Trager's algorithm for multivariate polynomials. In particular this function is algorithm ``alg_factor`` from [Trager76]_. See :func:`dup_ext_factor` for explanation. See Also ======== dup_ext_factor: Analogous function for univariate polynomials over ``k(a)``. dmp_sqf_norm: Multivariate version of subroutine ``sqfr_norm`` also from [Trager76]_. sympy.polys.polytools.factor: The high-level function that ultimately uses this function as needed. css|]}|dkVqdSrrrrrrrrrsr|sz!dmp_ext_factor..rfcsg|]}|jqSrr)r)rzsirlrrrsrsz"dmp_ext_factor..)rrrGrrrWrUdmp_factor_list_includerrrrrRrNrvrY)rjrurlrrrrrqrkrrnrrrrmrrrrsdmp_ext_factorTs(/      rcCs`t|||j}t||j|j\}}t|D]"\}\}}t||j||f||<q*|||j|fS)z2Factor univariate polynomials over finite fields. )rrrrrr)rjrlrrkrrorrrrrs dup_gf_factors r cCs tddS)z4Factor multivariate polynomials over finite fields. z+multivariate polynomials over finite fieldsN)NotImplementedError)rjrurlrrrrrs dmp_gf_factorsr"c CsDt||\}}t||\}}|jr4t||\}}n|jrLt||\}}n|jrdt||\}}n|jr|t ||\}}n|j s|| }}t |||}nd}|j r|}t|||\}}t |||}n|}|jrt||\}}nr|jrNt|d|\}} t|| |j\}}t|D]"\} \}} t|| || f|| <q|||j}n td||j rt|D]"\} \}} t |||| f|| <qj|||}|||}|rt|D]P\} \}} t||} t|| |}t |||}|| f|| <|||| | }q|||}|}|r4|d|j |j!g|f||t"|fS);Factor univariate polynomials into irreducibles in `K[x]`. Nr#factorization not supported over %s)#r%rHis_FiniteFieldr  is_Algebraicris_GaussianRingris_GaussianFieldr is_Exact get_exactris_FieldrrArris_Polyr#rrrr$rr]quor:r?mulpowrrrrZ) rjrrrrrk K0_inexactrldenomrurromax_normrrrrrsrsZ        rcCsXt||\}}|s"t|gdfgSt|dd||}||ddfg|ddSdS)r#rfrN)rrr=)rjrlrrkrrrrrrsrs rcCs|st||St|||\}}t|||\}}|jrHt|||\}}n:|jrbt|||\}}n |jr|t|||\}}n|j rt |||\}}n|j s|| }}t ||||}nd}|jr|}t||||\} }t ||||}n|}|jrLt|||\} }} t|| |\}}t|D]$\} \}} t|| | || f|| <q$nr|jrt|||\}} t|| |j\}}t|D]"\} \}} t|| || f|| <q~|||j}n td||jrt|D]$\} \}} t ||||| f|| <q|||}||| }|rt|D]V\} \}} t|||}t||||}t ||||}|| f|| <| ||!|| }q|||}|}tt"|D]J\} }|sqd|| dd| |j#i}|$dt%||||fq||t&|fS)=Factor multivariate polynomials into irreducibles in `K[X]`. Nr$)rrr)'rr&rIr%r"r&rr'rr(rr)r*rr+rrBrr!rrr"r,r#rrr$rr]r-r;r@r.r/rrrrrZ)rjrurrrrrkr0rlr1Zlevelsrrror2rtermrrrrrsrsj       rcCsj|st||St|||\}}|s2t||dfgSt|dd|||}||ddfg|ddSdS)r3rfrN)rrrr>)rjrurlrrkrrrrrrsrMs rcCs t|d|S)z_ Returns ``True`` if a univariate polynomial ``f`` has no factors over its domain. r)dmp_irreducible_p)rjrlrrrrrsdup_irreducible_p[sr6cCs@t|||\}}|sdSt|dkr(dS|d\}}|dkSdS)za Returns ``True`` if a multivariate polynomial ``f`` has no factors over its domain. TrfFrN)rr)rjrurlrrkrorrrrrsr5cs  r5)F)NN)__doc__Zsympy.external.gmpyrZsympy.core.randomrZsympy.polys.galoistoolsrrrrrr r r r r rZsympy.polys.densebasicrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&Zsympy.polys.densearithr'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@Zsympy.polys.densetoolsrArBrCrDrErFrGrHrIrJrKrLrMrNrOZsympy.polys.euclidtoolsrPrQrRZsympy.polys.sqfreetoolsrSrTrUrVrWrXrYZsympy.polys.polyutilsrZZsympy.polys.polyconfigr[Zsympy.polys.polyerrorsr\r]r^r_Zsympy.utilitiesr`mathrar}rbrrcrrdrertrvrrrrrrrrrrrrrrrrrrrrrr rrrrrr r"rrrrr6r5rrrrrrrssl  4hpD $    < 99i S ,T60D4 C  bN B M