ЦiGSSKJr SSKJrJrJr SSKJr SSK J r SSK J r Jr "SS5r "SS 5rS rSS jrS rSrSrSrSrSrSrSSjrg ))_randint)gcdinvertsqrt)_sqrt_mod_prime_power)isprime)logrc$\rSrSrSSjrSrSrg)SievePolynomialNc(XlX lX0lg)aTThis class denotes the seive polynomial. If ``g(x) = (a*x + b)**2 - N``. `g(x)` can be expanded to ``a*x**2 + 2*a*b*x + b**2 - N``, so the coefficient is stored in the form `[a**2, 2*a*b, b**2 - N]`. This ensures faster `eval` method because we dont have to perform `a**2, 2*a*b, b**2` every time we call the `eval` method. As multiplication is more expensive than addition, by using modified_coefficient we get a faster seiving process. Parameters ========== modified_coeff : modified_coefficient of sieve polynomial a : parameter of the sieve polynomial b : parameter of the sieve polynomial N)modified_coeffab)selfrrrs O/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/sympy/ntheory/qs.py__init__SievePolynomial.__init__ s$-c@SnURH nX!-nX#- nM U$)zz Compute the value of the sieve polynomial at point x. Parameters ========== x : Integer parameter for sieve polynomial r)r)rxanscoeffs revalSievePolynomial.evals.((E HC LC) r)rrr)NN)__name__ __module__ __qualname____firstlineno__rr__static_attributes__rrrr r s , rr c\rSrSrSrSrSrg)FactorBaseElem/z7This class stores an element of the `factor_base`. c`XlX lX0lSUlSUlSUlSUlg)z Initialization of factor_base_elem. Parameters ========== prime : prime number of the factor_base tmem_p : Integer square root of x**2 = n mod prime log_p : Compute Natural Logarithm of the prime N)primetmem_plog_psoln1soln2a_invb_ainv)rr&r'r(s rrFactorBaseElem.__init__2s/       r)r+r,r(r&r)r*r'N)rrrr __doc__rr!rrrr#r#/s rr#cbSSKJn /nSupEURSU5Hn[XS- S-U5S:XdMUS:aUc[ U5S- nUS:aUc[ U5S- n[ XS5Sn[ [U5S-5nUR[XgU55 M XEU4$) aGenerate `factor_base` for Quadratic Sieve. The `factor_base` consists of all the points whose ``legendre_symbol(n, p) == 1`` and ``p < num_primes``. Along with the prime `factor_base` also stores natural logarithm of prime and the residue n modulo p. It also returns the of primes numbers in the `factor_base` which are close to 1000 and 5000. Parameters ========== prime_bound : upper prime bound of the factor_base n : integer to be factored r)sieveNNii) sympy.ntheory.generater0 primerangepowlenrroundr appendr#) prime_boundnr0 factor_baseidx_1000idx_5000r&residuer(s r_generate_factor_baserAFs-K#H!!![1 q19"E *a /t| 0{+a/t| 0{+a/+Aa8;G#e*U*+E   ~eeD E2 { **rNcp[U5n[SU-5U- nSupn UcSOUn Uc[U5S- OUn [S5Hn Sn/nX:aRSnUS:XdUU;aU"X5nUS:XaMUU;aMUURnUU-nUR U5 X:aMRX- nU b [ US- 5[ U S- 5:dMUn UnUn M UnU n/nUHYnUURnUUR[UU-U5-U-nUUS- :aUU- nUR UU-U-5 M[ [U5n[X-SU-U-UU-U- /UU5nUHnUUR-S:XaM[UUR5Ul UVs/sH"nSU-UR-UR-PM$ snUl URURU- -UR-Ul URUR*U- -UR-UlM UU4$s snf)a#This step is the initialization of the 1st sieve polynomial. Here `a` is selected as a product of several primes of the factor_base such that `a` is about to ``sqrt(2*N) / M``. Other initial values of factor_base elem are also initialized which includes a_inv, b_ainv, soln1, soln2 which are used when the sieve polynomial is changed. The b_ainv is required for fast polynomial change as we do not have to calculate `2*b*invert(a, prime)` every time. We also ensure that the `factor_base` primes which make `a` are between 1000 and 5000. Parameters ========== N : Number to be factored M : sieve interval factor_base : factor_base primes idx_1000 : index of prime number in the factor_base near 1000 idx_5000 : index of prime number in the factor_base near to 5000 seed : Generate pseudoprime numbers r3)NNNrr22)rrr8ranger&r:absr'rsumr r+r,r)r*)NMr=r>r?seedrandint approx_valbest_abest_q best_ratiostartend_rqrand_ppratioBvalq_lgammargfbb_elems r_initialize_first_polynomialr]csP*tnGacQJ "2FJ!AxE"*"2#k Q C 2Y  nFA+1 ,A+1F#))A FA HHV  n  UQY#j1n2E!EFFJ AA A#$$C ''&c3*??#E 37?%KE C  AAac!eQqS1W-q!4A rxx<1  !RXX&@ABfQvXbhh&1B HHbii!m,8HHryyj1n-9  a4KCs)H3cSSKJn SnUnUS-S:XaUS- nUS-nUS-S:XaMU"USU-- 5S-S:XaSnOSnURSU-XFS- --n URn [ X-SU -U -X-U- /X5nUH}n XR -S:XaMU R XRUS- -- U R -U lU RXRUS- -- U R -U lM U$)aInitialization stage of ith poly. After we finish sieving 1`st polynomial here we quickly change to the next polynomial from which we will again start sieving. Suppose we generated ith sieve polynomial and now we want to generate (i + 1)th polynomial, where ``1 <= i <= 2**(j - 1) - 1`` where `j` is the number of prime factors of the coefficient `a` then this function can be used to go to the next polynomial. If ``i = 2**(j - 1) - 1`` then go to _initialize_first_polynomial stage. Parameters ========== N : number to be factored factor_base : factor_base primes i : integer denoting ith polynomial g : (i - 1)th polynomial B : array that stores a//q_l*gamma r)ceilingr2r3) #sympy.functions.elementary.integersr_rrr r&r)r,r*) rGr=irZrVr_vjneg_powrrr[s r_initialize_ith_polyrfs$< A A a%1* Q a a%1*qAqDzQ!# aia%  A Aac!eQS1W-q4A xx<1  HHwyyQ'777288CHHwyyQ'777288C  HrcS/SU-S--nUHnURcM[XR-UR-SU-UR5HnX$==UR- ss'M URS:XaMt[XR-UR-SU-UR5HnX$==UR- ss'M M U$)aSieve Stage of the Quadratic Sieve. For every prime in the factor_base that does not divide the coefficient `a` we add log_p over the sieve_array such that ``-M <= soln1 + i*p <= M`` and ``-M <= soln2 + i*p <= M`` where `i` is an integer. When p = 2 then log_p is only added using ``-M <= soln1 + i*p <= M``. Parameters ========== M : sieve interval factor_base : factor_base primes rr3r2)r)rDr&r(r*)rHr= sieve_arrayfactoridxs r_gen_sieve_arrayrks#qsQw-K <<  !ll*fll:AaCNC   , O <<1  !ll*fll:AaCNC   , O rc/nUS:aURS5 US-nOURS5 UHwnXR-S:waURS5 M(SnXR-S:Xa'US- nXR-nXR-S:XaM'URUS-5 My US:XaUS4$[U5(aUS4$g)a6Here we check that if `num` is a smooth number or not. If `a` is a smooth number then it returns a vector of prime exponents modulo 2. For example if a = 2 * 5**2 * 7**3 and the factor base contains {2, 3, 5, 7} then `a` is a smooth number and this function returns ([1, 0, 0, 1], True). If `a` is a partial relation which means that `a` a has one prime factor greater than the `factor_base` then it returns `(a, False)` which denotes `a` is a partial relation. Parameters ========== a : integer whose smootheness is to be checked factor_base : factor_base primes rr2r`r3TFr1)r:r&r)numr=vecri factor_exps r_check_smoothnessrps C Qw 1  r  1    " JJqM  LL A% !OJ LL CLL A% :>" axDys||Ez rct[U5n[X-5S-U- n/n [5n SUSR-n [ U5HupX:aM X- nUR U5n[ X5unnUcM4URU-UR-nUSLa`UnUU :aM_UU;a UU4UU'MnUUunnURU5 [UU5nUU-U-nUU-UU--n[ X5unnU RUUU45 M X4$![a U RU5 Mf=f)aTrial division stage. Here we trial divide the values generetated by sieve_poly in the sieve interval and if it is a smooth number then it is stored in `smooth_relations`. Moreover, if we find two partial relations with same large prime then they are combined to form a smooth relation. First we iterate over sieve array and look for values which are greater than accumulated_val, as these values have a high chance of being smooth number. Then using these values we find smooth relations. In general, let ``t**2 = u*p modN`` and ``r**2 = v*p modN`` be two partial relations with the same large prime p. Then they can be combined ``(t*r/p)**2 = u*v modN`` to form a smooth relation. Parameters ========== N : Number to be factored M : sieve interval factor_base : factor_base primes sieve_array : stores log_p values sieve_poly : polynomial from which we find smooth relations partial_relations : stores partial relations with one large prime ERROR_TERM : error term for accumulated_val r4r`F)isqrtr setr& enumeraterrprrpoprZeroDivisionErroraddr:)rGrHr=rh sieve_polypartial_relations ERROR_TERMsqrt_naccumulated_valsmooth_relations proper_factorpartial_relation_upper_boundrjrWrrcrn is_smoothu large_primeu_prevv_prevlarge_prime_invs r_trial_division_stagersv.1XF!*oe+j8OEM#&{2'<'<#< k*   G OOA *1:Y    LLNZ\\ )  K99"3323Q!+.!2;!?!%%k2&,[!&>> from sympy.ntheory.qs import _gauss_mod_2 >>> _gauss_mod_2([[0, 1, 1], [1, 0, 1], [0, 1, 0], [1, 1, 1]]) ([[[1, 0, 1], 3]], [True, True, True, False], [[0, 1, 0], [1, 0, 0], [0, 0, 1], [1, 0, 1]]) Reference ========== .. [1] A fast algorithm for gaussian elimination over GF(2) and its implementation on the GAPP. Cetin K.Koc, Sarath N.ArachchigerNFr2Tr3)copydeepcopyr8rDrur:) Arrrowcolmarkcrc1r2 dependent_rowrjrWs r _gauss_mod_2r`s, ]]1 F f+C fQi.C 73;D 3ZsAy|q Q*Bwy}!*B&,jnvz!}&D%IFJrN%  MdO %<  &+s!3 4$  &&rcXSnXFS/nXFS/nXSn [U 5HlupU S:XdM [[U55HGn X,U S:XdMXS:XdMURXLS5 URXLS5 Mj Mn Sn SnUHnX-n M UHnX-nM [ U5n[ X- U5$)a_Finds proper factor of N. Here, transform the dependent rows as a combination of independent rows of the gauss_matrix to form the desired relation of the form ``X**2 = Y**2 modN``. After obtaining the desired relation we obtain a proper factor of N by `gcd(X - Y, N)`. Parameters ========== dependent_rows : denoted dependent rows in the reduced matrix form mark : boolean array to denoted dependent and independent rows gauss_matrix : Reduced form of the smooth relations matrix index : denoted the index of the dependent_rows smooth_relations : Smooth relations vectors matrix N : Number to be factored r2rT)rurDr8r:rsr)dependent_rowsr gauss_matrixindexr~rG idx_in_smooth independent_u independent_vdept_rowrjrWrrrcrbs r _find_factorrs #)!,M%4Q78M%4Q78M$Q'Hh' !8S./$S)Q.493D!(()9)>q)AB!(()9)>q)AB 0( A A     aA qua=rc US-n[X5upVn/nSn 0n [5n S[U5-S-n U S:Xa[XXuU5upO[ XU W W5n U S- n U S[U5S- -:aSn [ X'5n[ XXXU5unnUU- nU U-n [U5[U5U -:aOM[U5n[U5unnnUn[[U55Hyn[UUUUX5nUS:dMUU:dM"U RU5 UU-S:XaUU-nUU-S:XaM[U5(aU RU5 U $US:XdMx U $ U $)aPerforms factorization using Self-Initializing Quadratic Sieve. In SIQS, let N be a number to be factored, and this N should not be a perfect power. If we find two integers such that ``X**2 = Y**2 modN`` and ``X != +-Y modN``, then `gcd(X + Y, N)` will reveal a proper factor of N. In order to find these integers X and Y we try to find relations of form t**2 = u modN where u is a product of small primes. If we have enough of these relations then we can form ``(t1*t2...ti)**2 = u1*u2...ui modN`` such that the right hand side is a square, thus we found a relation of ``X**2 = Y**2 modN``. Here, several optimizations are done like using multiple polynomials for sieving, fast changing between polynomials and using partial relations. The use of partial relations can speeds up the factoring by 2 times. Parameters ========== N : Number to be Factored prime_bound : upper bound for primes in the factor base M : Sieve Interval ERROR_TERM : Error term for checking smoothness threshold : Extra smooth relations for factorization seed : generate pseudo prime numbers Examples ======== >>> from sympy.ntheory import qs >>> qs(25645121643901801, 2000, 10000) {5394769, 4753701529} >>> qs(9804659461513846513, 2000, 10000) {4641991, 2112166839943} References ========== .. [1] https://pdfs.semanticscholar.org/5c52/8a975c1405bd35c65993abf5a4edb667c1db.pdf .. [2] https://www.rieselprime.de/ziki/Self-initializing_quadratic_sieve r4rdr2r3) rArtr8r]rfrkrrrrDrrxr)rGr;rHr{rIr>r?r=r~ith_polyrzr thresholdith_sieve_polyB_arrayrhs_relp_frrrrN_copyrris rqsrsNJ&;K&K#H HEM#k""c)I  q=&B1`h&i #NG1!(N\cdNA  q3wnxy sE!  C $4y$@ @  + ,F(4V(<%M4 Fs=)*mT<HX\ A:&1*   f %6/Q&6!6/Q&v!!&) { + r)N)i)sympy.core.randomrsympy.external.gmpyrrrrssympy.ntheory.residue_ntheoryr sympy.ntheoryrmathr r r#rAr]rfrkrprrrrrrrrrsf&::?!$$N.+:CL% P6#L<+@ *'Z%PJr