o o h@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 ljmkZkddllmmZnmoZpmqZredkrddlsmtZtndZtddZuddZvddZwddZxddZyddZzddZ{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_polyNcCsbg}|D](}d} t|||\}}|s||d}}nnq |dkr%td|||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``. rTtrial division failed)r1 RuntimeErrorappendrZ)ffactorsKresultfactorkqrrrk/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/polys/factortools.pydup_trial_divisionXsrtc Csjg}|D],}d} t||||\}}t||r||d}}nnq |dkr)td|||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``. rTrfrg)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 z(dup_zz_mignotte_bound..rf) (sympy.functions.combinatorial.factorialsrwr_ceilsqrtsumabsrr:) rjrlrwddeltadelta2 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 Cstt|}t||}|dkr$t|||||d|}t||||gS|}|d} ttt|} t|g|} |d| D] } t | t| |||} q>t|| |} || ddD] } t | t| |||} qZt | | ||\}}}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=gcdexrCintr_log2rrr rrangerdup_zz_hensel_lift)prjf_listlrlrqrFrrorrf_irrr_rrrrrsrs0      (rcCs(||dkr ||}|sdS||dkS)NrxTrrr)fcrpplrrrrrs_test_plGs  rcsvt|}|dkr |gSddlm}|d}t||}t||}tt|||dd|||}t|dd||d|d}ttdt |} td| t | } g} t d| dD];} || ro|| dkrpqc| | } t || } t| | |sqct| | |d}| | |ft|dkst| dkrnqct| d d d \}ttt d|d}fd d |D}t||||}t t|}t|}gd}}|}d|t|krt||D]|dkr d}D] }|||d}q||}t|||s qn-|g}D] }t||||}qt|||}t||d}|d}|r8||dkr8q|g}t|}|dkr_|g}D] }t||||}qMt|||}|D] }t||||}qat|||}t||}t||}|||kr|}fdd |D}t||d}t||d}||t||}nq|d7}d|t|ks||gS)z4Factor primitive square-free polynomials in `Z[x]`. rfr)isprimerxcSs t|dS)Nrf)r)xrrrrrsps z#dup_zz_zassenhaus..)keycsg|]}t|qSrr)r)rzff)rrrrs tz%dup_zz_zassenhaus..csg|]}|vr|qSrrrr)rzi)rrrrsr)r sympy.ntheoryrr:rrrrrr_logrconvertrr r rirminrsetr`rr-rCrHr<)rjrlrrrArBCgammarrpxrfsqfxfsqfrmodularrsorted_TrrkrrrprrrT_SG_normH_normrr)rrrsdup_zz_zassenhausNs   *$                7rcCsrt||}t||}t|dd|}|r5ddlm}|t|}|D]}||r4||dr4dSq%dSdS)z2Test irreducibility using Eisenstein's criterion. rfNr factorintrxT)rrrErrrkeys)rjrlrtce_fcre_ffrrrrrrsdup_zz_irreducible_ps     rFcCs|jrz||}}t|||}WntyYdSw|js"dSt||}t||}|dks8|dkr:|dkr:dS|sQt||\}}||jksO||dfgkrQdSt |}gg} } t |ddD] } | d|| q`t |dddD] } | d|| qst t | |} t t | |} t| t| d||} |t| |rt| |} | |krdSt||} |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)is_QQget_ringrr^is_ZZrrdup_factor_listrrrinsertr/rr+r9 is_negativer'rOdup_cyclotomic_prV)rjrl irreducibleK0rrcoeffrkrrrrrrrrrrrsrsN        rcCs\ddlm}|j|j g}||D]\}}tt|||||}t|||d|}q|S)z1Efficiently generate n-th cyclotomic polynomial. rrrf)rrritemsr3r )rrlrrrrorrrrrsdup_zz_cyclotomic_polys rcsddlm}jj gg}||D]*\}fdd|D}||td|D]}fdd|D}||q,q|S)Nrrcs g|] }tt||qSrr)r3r )rzrrlrrrrsr, z-_dup_cyclotomic_decompose..rfcsg|]}t|qSrr)r )rzrprrrrsr0r)rrrrextendr)rrlrrroQrrrrrs_dup_cyclotomic_decompose&s   rcCst||t||}}t|dkrdS|dks|dvrdStdd|ddDr,dSt|}t||}||s<|Sg}td||D] }||vrP||qE|S) 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|Pr}z+dup_zz_cyclotomic_factor..rrx)rrranyris_oneri)rjrllc_ftc_frrrrrrrrrsdup_zz_cyclotomic_factor6s"    rcCst||\}}t|}t||dkr| t||}}|dkr#|gfS|dkr,||gfStdr:t||r:||gfSd}tdrEt||}|durNt||}|t|ddfS)z:Factor square-free (non-primitive) polynomials in `Z[x]`. rrfUSE_IRREDUCIBLE_IN_FACTORNUSE_CYCLOTOMIC_FACTORF)multiple) rHrrr'r[rrrrZ)rjrlcontrrrkrrrrrsdup_zz_factor_sqfbs"     rcCs tdkr t|ddd}|\}}dd|D}|t|fSt||\}}t|}t||dkr;| t||}}|dkrC|gfS|dkrN||dfgfStdr^t ||r^||dfgfSt ||}d}td rnt ||}|durwt ||}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)coeffs)rzfacexprrrrrsrs&z!dup_zz_factor..rrfrr)rrernrZrHrrr'r[rrVrrrtrX)rjrlf_flintrrkrrrrrrrrs dup_zz_factors2.        rcCsv||g}|D]-}t|}t|D]}|dkr%|||}||}|dks||r.dSq||q|ddS)z,Wang/EEZ: Compute a set of valid divisors. rfN)rreversedgcdrri)Ecsctrlrmrprqrrrrrsdmp_zz_wang_non_divisorss      rc stt||dstdt||}t|s tdt|\}}t|r8| t|}}|dfdd|D} t| ||} | durW||| fStd)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]R} t| |} t| ||} ttt|D]6}d||||}}\}}| |sH| ||d} }| |r;|dkr]t| t||| || |d} | |<q'|| qt| sjt gg}}t ||D]E\} } t | || |} t| |}| |r|| }n| || }| |||} }t| | ||| } }t| || |} || || qt| |r|||fSgg}}t ||D]\} } |t| || ||t| |d|qt||t|d||}|||fS)z0Wang/EEZ: Compute correct leading coefficients. rrf)rrrrrr.r0riallr\ziprJrrr=r>)rjrrrrrrurlrJrrrrrrorrrCCHHrccrCCCHHHrrrrrsdmp_zz_wang_lead_coeffssF "            rc Cst|dkrK|\}}t||}t||}t||||\}} } t|||}t| ||} t||||\} }t| | |||} t||}t| |} || g} | S|dg} t|ddD]}| dt || d|qXgdgg} }t || D]\}}t ||g|dgd|d|\} }| | | |qsg| |dg} } t | |D]#\}}t||}t||}t t||||||}t||}| |q| S)z2Wang/EEZ: Solve univariate Diophantine equations. rxrrfr)rrr rr rrrrr-rdmp_zz_diophantinerir )rrrrlrrrjrrrrrprmrrrqrrrrrsdup_zz_diophantine7s:               r c s|sDdd|D}t|}t|D]0\} } | sqt||| } tt|| D]\} \} }t|| }tt| ||| <q(q|St|}t|}|d|dd}}gg}}|D]}| t ||| t |||q`t |||}dt ||||}fdd|D}t||D] \} }t || |}qt|}tj| g|}t|}td|D]}t|rn{t||}t||d||}t|sHt||d}t ||||} t| D]\} }tt|d|| | <qtt|| D]\} \} }t| ||| <qt| |D] \}}t |||}q3t|}qŇfdd|D}|S) z4Wang/EEZ: Solve multivariate Diophantine equations. cSsg|]}gqSrrrrrzrrrrrrsrjsz&dmp_zz_diophantine..rNrfcsg|] }t|dqSrf)rrzr)rlrrrrsrrcsg|] }t|qSrr)rDr )rlrrurrrsrr )r enumerater rr=rCr)rr5rir4rKrr8rDrrrrrr.rLr@ factorialrr*)rrrrrrurlrrrrrjrrrrrrrjrrrrrorr)rlrrurrsrgs\ 5      rc Cs|gt||d}}} t|}tt|ddD]\} } t|d| || || |} |dt| || | |qtt||dd} t t d|d||D]\}} } t||d}}|d|d||dd}}tt ||D]&\} \}}tt ||| |||d|}|gt |ddd|d||| <qwt |j| g||}t||}t| t|||||}t| ||}t d|D]x}t||rnpt||||}t||d| |||}t||ds;t||||d|d|}t|||| ||d|}tt ||D]\} \}}t|t |d|d||||}t|||||| <q t| t|||||}t||||}qqQt||||krHt|S)z-Wang/EEZ: Parallel Hensel lifting algorithm. rfNrrx)rlistrrrKrrDmaxrrrrJrrrrr,r5rrr.rLr@rrr6r\)rjrLCrrrurlrrrrrrrrrwIrrrrrrdjrorrrrrrrrsdmp_zz_wang_hensel_liftingsB "&    rc s2ddlm}t|tt||d\}}t||}||} dur0|dkr.dndtgjg|df\} } } } z)t|||| |\}}}t |\}}t |} | dkr_|gWS||||| fg} Wn t yqYnwt d}t d}t d}t | |krt |D]r}fd d t |D} t| | vr| t| nqzt|||| |\}}}Wn t yYqwt |\}}t |}| dur|| kr|| krg|} } nqn|} | dkr|gS| ||||| ft | |krnq|7t | |ksd \}}}| D]"\}}}}}t|}|dur(||kr'|}|}n|}|d7}q | |\}}}}} |}zt|||||| |\}}}t|||| | |}Wntyqt d rmt||dYStd wg}|D] }t||\}}t||rt||}||qv|S)a` Factor primitive square-free polynomials in `Z[X]`. Given a multivariate polynomial `f` in `Z[x_1,...,x_n]`, which is primitive and square-free in `x_1`, computes factorization of `f` into irreducibles over integers. The procedure is based on Wang's Enhanced Extended Zassenhaus algorithm. The algorithm works by viewing `f` as a univariate polynomial in `Z[x_2,...,x_n][x_1]`, for which an evaluation mapping is computed:: x_2 -> 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) nextprimerfNrxEEZ_NUMBER_OF_CONFIGSEEZ_NUMBER_OF_TRIESEEZ_MODULUS_STEPcsg|] } qSrrrrr rlmodrandintrrrsr"szdmp_zz_wang..)NrrEEZ_RESTART_IF_NEEDEDz3we need to restart algorithm with better parameters)rrr dmp_zz_factorrrrzerorrrr_r[rtupleaddrir:rrr\ dmp_zz_wangrIrrr()rjrurlrseedrrrrrhistoryconfigsrrqrrrrreez_num_configs eez_num_tries eez_mod_steprrs_norms_argr_s_normorig_frrkrmrrrrsr$s           %      r$c Cs|st||St||r|jgfSt|||\}}t|||dkr+| t|||}}tddt||Dr;|gfSt|||\}}g}t ||dkr_t |||}t |||}t ||||}t ||d|dD] \}}|d|g|fqit||||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]_ rcs|]}|dkVqdSrNrrrzrrrrrrsr|r}z dmp_zz_factor..rf)rrr!rIrr(rrrPrrWr$rvr rrYrZ) rjrurlrrrrkrrorrrrrsr ms&$       r csJt|}t|\}}fdd|D}|}||fS)z>Factor univariate polynomials into irreducibles in `QQ_I[x]`. cs g|] \}}t||fqSrr)rrzrrrK1rrrsrrz#dup_qq_i_factor..)as_AlgebraicFieldrrr)rjrrrkrrr4rsdup_qq_i_factors   r7c Cs|}t|||}t||\}}g}|D]*\}}t||\}} t| ||} t| d|\} } || |||}|| |fq|}|||}||fS)z>Factor univariate polynomials into irreducibles in `ZZ_I[x]`. r) get_fieldrr7rArIrir) rjrr5rrk new_factorsrr fac_denomfac_num fac_num_ZZ_Icontentfac_primrrrrrsdup_zz_i_factors    r?csPt|}t|\}}fdd|D}|}||fS)z@Factor multivariate polynomials into irreducibles in `QQ_I[X]`. cs"g|] \}}t||fqSrr)rr3rr5rurrrsrs"z#dmp_qq_i_factor..)r6rdmp_factor_listr)rjrurrrkrrr@rsdmp_qq_i_factors  rBcCs|}t||||}t|||\}}g}|D],\}}t|||\} } t| |||} t| ||\} } || || |}|| |fq|}|||}||fS)z@Factor multivariate polynomials into irreducibles in `ZZ_I[X]`. )r8rrBrBrIrir)rjrurr5rrkr9rrr:r;r<r=r>rrrrrsdmp_zz_i_factors  rCcCst|t||}}t||}|dkr|gfS|dkr"||dfgfSt|||}}t||\}}}t||j}t|dkrI|||t|fgfS||j} t |D] \} \} } t | |j|} t | ||\} } }t | | |} | || <qRt |||}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        rGcs|st|St||}t||}tddt||Dr#|gfSt|||}}t||\}}}t||j}t |dkrF|g}n1t |D],\} \} } t | |j} t | ||\} } }fdd|D} t | | |} | || <qJt|||}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. csr0r1rrr2rrrrrsr|r}z!dmp_ext_factor..rfcsg|]}|jqSrr)rF)rzsirlrrrsrrz"dmp_ext_factor..)rGrrGrrrWrUdmp_factor_list_includerErrrrRrNrvrY)rjrurlrrrrrqrkrrnrrrrmrrrIrsdmp_ext_factorTs(/      rKcCs`t|||j}t||j|j\}}t|D]\}\}}t||j||f||<q|||j|fS)z2Factor univariate polynomials over finite fields. )rrErrrr)rjrlrrkrrorrrrrs dup_gf_factors rLcCstd)z4Factor multivariate polynomials over finite fields. z+multivariate polynomials over finite fields)NotImplementedError)rjrurlrrrrrs dmp_gf_factorsrNc Cs4t||\}}t||\}}|jrt||\}}n|jr$t||\}}n|jr/t||\}}n|jr:t ||\}}n|j sK|| }}t |||}nd}|j rc|}t|||\}}t |||}n|}|jrpt||\}}n7|jrt|d|\}} t|| |j\}}t|D]\} \}} t|| || f|| <q|||j}ntd||j rt|D]\} \}} t |||| f|| <q|||}|||}|rt|D]'\} \}} t||} t|| |}t |||}|| f|| <|||| | }q|||}|}|r|d|j |j!g|f||t"|fS);Factor univariate polynomials into irreducibles in `K[x]`. Nr#factorization not supported over %s)#r%rHis_FiniteFieldrL is_AlgebraicrGis_GaussianRingr?is_GaussianFieldr7is_Exact get_exactris_FieldrrArris_Polyr#rArErr$rr]quor:r?mulpowrrr!rZ) rjrrrrrk K0_inexactrldenomrurromax_normrrrrrsrsZ        rcCsTt||\}}|st|gdfgSt|dd||}||ddfg|ddS)rOrfrN)rrr=)rjrlrrkrrrrrrsrDs rDcCs|st||St|||\}}t|||\}}|jr$t|||\}}n|jr1t|||\}}n |jr=t|||\}}n|j rIt |||\}}n|j s[|| }}t ||||}nd}|jru|}t||||\} }t ||||}n|}|jrt|||\} }} t|| |\}}t|D]\} \}} t|| | || f|| <qn7|jrt|||\}} t|| |j\}}t|D]\} \}} t|| || f|| <q|||j}ntd||jr:t|D]\} \}} t ||||| f|| <q|||}||| }|r:t|D]+\} \}} t|||}t||||}t ||||}|| f|| <| ||!|| }q|||}|}tt"|D]%\} }|sIq@d|| dd| |j#i}|$dt%||||fq@||t&|fS)=Factor multivariate polynomials into irreducibles in `K[X]`. NrP)rr r)'rr&rIrQrNrRrKrSrCrTrBrUrVrrWrrBrr!r rr"rXr#rArEr$rr]rYr;r@rZr[rrrrrZ)rjrurrrrrkr\rlr]levelsrrror^rtermrrrrrsrAsl       rAcCsf|st||St|||\}}|st||dfgSt|dd|||}||ddfg|ddS)r_rfrN)rDrArr>)rjrurlrrkrrrrrrsrJMs rJcCs t|d|S)z_ Returns ``True`` if a univariate polynomial ``f`` has no factors over its domain. r)dmp_irreducible_p)rjrlrrrrrsdup_irreducible_p[s rccCs<t|||\}}|s dSt|dkrdS|d\}}|dkS)za Returns ``True`` if a multivariate polynomial ``f`` has no factors over its domain. TrfFr)rAr)rjrurlrrkrorrrrrsrbcs  rb)F)NN)__doc__sympy.external.gmpyrsympy.core.randomrsympy.polys.galoistoolsrrrrrr r r r r rsympy.polys.densebasicrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&sympy.polys.densearithr'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@sympy.polys.densetoolsrArBrCrDrErFrGrHrIrJrKrLrMrNrOsympy.polys.euclidtoolsrPrQrRsympy.polys.sqfreetoolsrSrTrUrVrWrXrYsympy.polys.polyutilsrZsympy.polys.polyconfigr[sympy.polys.polyerrorsr\r]r^r_sympy.utilitiesr`mathrarrbrrcrrdrertrvrrrrrrrrrrrrrrrrr rrr$r r7r?rBrCrGrKrLrNrrDrArJrcrbrrrrrrrssn  4hpD $    < 99i S ,T60D 4C  bN B M