\hZ:SSKJrJr SSKJr SSKJrJrJrJ r SSK J r SSK Jr SSKJr "SS5r"S S 5rS rS rS rSrSrSrSSjrSSjrg))explog)_randint) bit_scan1gcdinvertsqrt)_perfect_power)isprime)_sqrt_mod_prime_powerc&\rSrSrSrSrSrSrg)SievePolynomial cdXlX lUS-UlSU-U-UlUS-U- Ulg)zThis class denotes the sieve polynomial. Provide methods to compute `(a*x + b)**2 - N` and `a*x + b` when given `x`. Parameters ========== a : parameter of the sieve polynomial b : parameter of the sieve polynomial N : number to be factored N)aba2abb2)selfrrNs H/var/www/auris/envauris/lib/python3.13/site-packages/sympy/ntheory/qs.py__init__SievePolynomial.__init__ s7Q$A#a%Q$(c:URU-UR-$N)rrrxs reval_uSievePolynomial.eval_usvvax$&&  rcZURU-UR-U-UR-$r)rrrrs reval_vSievePolynomial.eval_v s' DGG#Q&00r)rrrrrN)__name__ __module__ __qualname____firstlineno__rr!r$__static_attributes__rrrr s&!1rrc\rSrSrSrSrSrg)FactorBaseElem$z7This class stores an element of the `factor_base`. cRXlX lX0lSUlSUlSUlg)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_psoln1soln2b_ainv)rr0r1r2s rrFactorBaseElem.__init__'s*      r)r5r2r0r3r4r1N)r&r'r(r)__doc__rr*r+rrr-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)sieve)NNrii) sympy.ntheory.generater9 primerangepowlenr roundrappendr-) prime_boundnr9 factor_baseidx_1000idx_5000r0residuer2s r_generate_factor_baserH<s-K#H!!![1 q19"E *a /t| 0{+a/t| 0{+a/+Aa8;G#e*U*+E   ~eeD E2 { **rc#Z# [SU-5S- [U5- nU=(d SnU=(d [U5S- nSupn [S5Hn Sn /n[U 5U:aYSnUS:XdX;aU"Xx5nUS:XaMX;aMX/RnU U-n UR U5 [U 5U:aMY[ [U 5U- 5nU b [ US- 5[ U S- 5:dMUn U n Un M U n U n/nUHYnUURnUUR[U U-U5-U-nSU-U:aUU- nUR U U-U-5 M[ [U5n[U UU5nUHnU UR-S:Xa SUl M[U UR5nUVs/sHnSU-U-UR-PM snUl UURU- -UR-Ul UUR*U- -UR-Ul M Uv [SS[U5S- -5Hn[U5nSUUS-- S--S- nURSU-UU--nUR n [U UU5nUHtnURcMURUURU-- UR-Ul URUURU-- UR-Ul Mv Uv M GMs snf7f)aGenerate sieve polynomials indefinitely. Information such as `soln1` in the `factor_base` associated with the polynomial is modified in place. 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 randint : A callable that takes two integers (a, b) and returns a random integer n such that a <= n <= b, similar to `random.randint`. rrr:)NNN2N)rr?ranger0rArabsr1rsumrr3r5r4rrr)rMrDrErFrandint approx_valstartendbest_abest_q best_ratio_rqrand_ppratioBvalq_lgammargfba_invb_elemivneg_pows r_generate_polynomialrfYs$ QqS!c!f$J ME  ,s;'!+C %5" rAAAa&:%kV[$U0FkV['--Q a&:%A+,E!S^c*q.6I%I" "   Cc"((C$++fQ#Xs.CCcIEw}e  HHQVE\ "  F Aq! $B288|q 1bhh'EABCv6%"((2CBIryy1}-9BH zA~."((:BHq!c!fQh-(A! A!A,!+,q0Gai!n$AA1a(A!88#HHwryy|';;rxxGHHwryy|';;rxxG " G)U HDs,BL+L+ 3L+6L+L&EL+cS/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 rrr:)r3rKr0r2r4)rNrD sieve_arrayfactoridxs r_gen_sieve_arrayrks#qsQw-K <<  !ll*fll:AaCNC   , O <<1  !ll*fll:AaCNC   , O rc6US:aUS-nSnOSn[US5Hwup4XR-(aMSnXR-nXR-S:Xa'US- nXR-nXR-S:XaM'US-(dMoUSU-- nMy X 4$)zCheck if `num` is smooth with respect to the given `factor_base` and compute its factorization vector. Parameters ========== num : integer whose smootheness is to be checked factor_base : factor_base primes rr:r) enumerater0)numrDvecrcr`es r_check_smoothnessrrs Qw r ;* >   HHn! FA HH CHHn! q55 16MC+ 8Orc[U5[U5S- -U- S-n/n[5n SUSR-n [X1*5HupX:aM UR U 5n [ X5upUS:Xa$UR URU 5X45 MTX:dM[[U5(dMmX-S:XaU RU5 MURU 5nX;aNURU5unnnUU-[X5-U-nU U-US--n UU-nUR UX45 MUX4X_'M X4$)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 rr;rmr:r) rsetr0rnr$rrrAr!r addpopr)rrNrDrh sieve_polypartial_relations ERROR_TERMaccumulated_valsmooth_relations proper_factorpartial_relation_upper_boundr r\rdrprouu_prevv_prevvec_prevs r_trial_division_stagersT.1vAq(:5>OEM#&{2'<'<#< K,     a $Q4 !8  # #Z%6%6q%91$B C  /GCLLw!|!!#&!!!$A'+<+@+@+E(fHVC^+a/fHQ&x ''A 4*+Q!&'-(  **rc#~# UVs/sHo3SPM nn[U5nS/U-n[U5HjnSU-n[U5HSn XIU-=n (dMXU - n XU 'SXi'[U S-U5Hn XLU-(dMXL==U -ss'M Mh Ml [XdU5HupnU(aMUSUSnn[XdU5H,unnnU(dMU U-(dMUUS-nUUS-nM. [U5nS[ UU- U5=ns=:aU:dM~O MUv M gs snf7f)aoFinds proper factor of N using fast gaussian reduction for modulo 2 matrix. Parameters ========== N : Number to be factored smooth_relations : Smooth relations vectors matrix col : Number of columns in the matrix Reference ========== .. [1] A fast algorithm for gaussian elimination over GF(2) and its implementation on the GAPP. Cetin K.Koc, Sarath N.Arachchige rFr:TrN)r?rKzipisqrtr)rr|col s_relationmatrixrowmarkposmrcrYadd_coljmatrelrrdm1mat1rel1r_s r _find_factorr sW /? ?.> m.>F ? f+C 7S=DSz HsAIM!q!Qi-q q1uc*Ay1}} W, +4)9:  1vs1v1!$0@ANBdrcDjjT!W T!W B !H SQ]" 'a ' 'G;@s/D=D8AD=+D=AD="D=.9D=+D=c .[[XX#U55$)a Performs 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 seed : seed of random number generator Returns ======= set(int) : A set of factors of N without considering multiplicity. Returns ``{N}`` if factorization fails. Examples ======== >>> from sympy.ntheory import qs >>> qs(25645121643901801, 2000, 10000) {5394769, 4753701529} >>> qs(9804659461513846513, 2000, 10000) {4641991, 2112166839943} See Also ======== qs_factor References ========== .. [1] https://pdfs.semanticscholar.org/5c52/8a975c1405bd35c65993abf5a4edb667c1db.pdf .. [2] https://www.rieselprime.de/ziki/Self-initializing_quadratic_sieve )ru qs_factor)rrBrNrzseeds rqsr:sb y= >>rc JUS:a [S5e0n/n0nUS-S:Xa)SnUS-nUS-S:XaUS-nUS- nUS-S:XaMXS'[U5(aSXP'U$[US5=n (a U upXU 'U$Un [U5n [ X5upn[ U5S-S-n[ XXX5Htn[X/5n[XUUUXs5unnUU- nUH8nU U-(aMSnU U-n U U-S:XaU U-n US- nU U-S:XaMXU'M: U[ U5::dMt O [X[ U5S-5HOnU U-S:XdMSnU U-n U U-S:XaU U-n US- nU U-S:XaMXU'U S:Xd[U 5(dMO O U S:waSX['U$)aUPerforms factorization using Self-Initializing Quadratic Sieve. 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 seed : seed of random number generator Returns ======= dict[int, int] : Factors of N. Returns ``{N: 1}`` if factorization fails. Note that the key is not always a prime number. Examples ======== >>> from sympy.ntheory import qs_factor >>> qs_factor(1009 * 100003, 2000, 10000) {1009: 1, 100003: 1} See Also ======== qs rzN should be greater than 1rr:id) ValueErrorr r rrHr?rfrkrr)rrBrNrzrfactorsr|ryrqresultrCN_copyrOrErFrD thresholdr_rhs_relp_frYris rrrns @ 1u566G 1uz  a!eqj !GA FA!eqj qzz 1%%v%  FtnG&;K&K#H K 3&+I !! x Q&q6 *1k1N_l sE!AzA qLF1*/1 Q1*/AJ ,- - R qC 4Dq4HI F?a A v F6/Q&6!Q6/Q& FO{gfooJ{ NrN)i)mathrrsympy.core.randomrsympy.external.gmpyrrrr rsympy.ntheory.factor_r sympy.ntheory.primetestr sympy.ntheory.residue_ntheoryr rr-rHrfrkrrrrrrr+rrrs\&EE0+?1160+:HV68/+d*Z1?hUr