+ iZ:^RIHtHt^RIHt^RIHtHtHtH t ^RI H t ^RI Ht^RIHt!RR4t!R R 4tR tR tR tRtRtRtRRltRRltR#))explog)_randint) bit_scan1gcdinvertsqrt)_perfect_power)isprime)_sqrt_mod_prime_powerc2a]tRt^ toRtRtRtRtVtR#)SievePolynomialc WnW nV^,Vn^V,V,VnV^,V, VnR#)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&&&&p/Users/tonyclaw/.openclaw/workspace/skills/math-calculator/venv/lib/python3.14/site-packages/sympy/ntheory/qs.py__init__SievePolynomial.__init__ s7Q$A#a%Q$(cJVPV,VP,#N)rrrxs&&reval_uSievePolynomial.eval_usvvax$&&  rczVPV,VP,V,VP,#r)rrrrs&&reval_vSievePolynomial.eval_v s' DGG#Q&00r)rrrrrN) __name__ __module__ __qualname____firstlineno__rrr"__static_attributes____classdictcell__ __classdict__s@rrr s&!11rrc*a]tRt^$toRtRtRtVtR#)FactorBaseElemz7This class stores an element of the `factor_base`. c TWnW nW0nRVnRVnRVnR#)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)rr/r0r1s&&&&rrFactorBaseElem.__init__'s*      r)r4r1r/r2r3r0N)r$r%r&r'__doc__rr(r)r*s@rr-r-$srr-c^RIHp.pRRrTVP^V4Fp\W^, ^,V4^8XgK$VR8dVf\ V4^, pVR8dVf\ V4^, p\ W^4^,p\ \V4R,4pVP\WgV44K WEV3#)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 )sieveNii) sympy.ntheory.generater8 primerangepowlenr roundrappendr-) prime_boundnr8 factor_baseidx_1000idx_5000r/residuer1s && r_generate_factor_baserF<s-Kth!!![1 q19"E *a /t| 0{+a/t| 0{+a/+Aa8;G#e*U*+E   ~eeD E2 { **rc#"\^V,4^, \V4, pT;'g^pT;'g\V4^, pRRRrp \^24Fp ^p .p\V 4V8dH^pV^8XgW9d V!Wx4pKW/,PpV V,p VP V4KW\ \V 4V, 4pV e*\ V^, 4\ V ^, 48gKTp T p Tp K T p T p.pVF~pVV,PpVV,P\V V,V4,V,p^V,V8d VV, pVP V V,V,4K \V4p\V VV4pVFpV VP,^8Xd RVn K$\V VP4pVUu.uF$p^V,V,VP,NK& upVn VVPV, ,VP,Vn VVP)V, ,VP,Vn K Vx\^^\V4^, ,4EFp\V4p^VV^,, ^,,^, pVP^V,VV,,,pVP p \V VV4pVFpVPfKVPVVPV,,, VP,Vn VPVVPV,,, VP,Vn K VxEK EK}uupi5i)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`. N)rr=ranger/r?rabsr0rsumrr2r4r3rrr)rMrBrCrDrandint approx_valstartendbest_abest_q best_ratio_rqrand_ppratioBvalq_lgammargfba_invb_elemivneg_pows&&&&&& r_generate_polynomialrcYs  QqS!c!f$J MME  , ,s;'!+C %)4 rAAAa&:%kV[$U0F'--Q A+,E!S^c*q.6I%I" "   Cc"((C$++fQ#Xs.CCcIEw}e  HHQVE\ "  F Aq! $B288|q 1bhh'EABCv6%"((22CBIryy1}-9BH zA~."((:BHq!c!fQh-(A! A!A,!+,q0Gai!n$AA1a(A!88#HHwryy|';;rxxGHHwryy|';;rxxG " G) Ds >OCO C,O7*O!F5Oc^.^V,^,,pVFpVPfK\WP,VP,^V,VP4F!pW$;;,VP, uu&K# VP^8XdK\WP,VP,^V,VP4F!pW$;;,VP, uu&K# K V#)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 )r2rHr/r1r3)rKrB sieve_arrayfactoridxs&& r_gen_sieve_arrayrhs#qsQw-K <<  !ll*fll:AaCNC   , O <<1  !ll*fll:AaCNC   , O rcbV^8d VR,p^pM^p\V^4Fwr4WP,'dK^pWP,pWP,^8XdV^, pWP,pK4V^,'gKxV^V,, pK W 3#)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 ) enumerater/)numrBvecr`r]es&& r_check_smoothnessros Qw r ;* >>   HHn! FA HH C q55 16MC+ 8Orc \V4\V4^, ,V, R,p.p\4p ^VR,P,p \W1)4EFwrW8dKVP V 4p \ W4wrV^8Xd%VP VPV 4W34KWW8gK_\V4'gKrW,^8XdV PV4KVPV 4pW9dlVPV4wpppVV,\W4,V,pV V,V^,,p VV,pVP VW34EKVW3W_&EK W3#)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 r9rj) rsetr/rkr"ror?rr addpopr)rrKrBre sieve_polypartial_relations ERROR_TERMaccumulated_valsmooth_relations proper_factorpartial_relation_upper_boundrrYrarmrluu_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#,"VUu.uF q3^,NK pp\V4pR.V,p\V4Fp^V,p\V4Fyp WI,V,;p 'gKWV ,, p WV &RWi&\V ^,V4F.p WL,V,'gKWL;;,V ,uu&K0 K K \WdV4FwrpV'dKV^,V^,pp\WdV4FBwpppV'gKV V,'gK"VV^,,pVV^,,pKD \V4p^\ VV, V4;pu;8d V8gKMKVxK R#uupi5i)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 FTN)r=rHzipisqrtr)rrxcol s_relationmatrixrowmarkposmr`rVadd_coljmatrelr{ram1mat1rel1r\s&&& r _find_factorr s\ /? ?.> mm.>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;@s0FFAF-?F1A'F F.AFFc .\\WW#V44#)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 )rq qs_factor)rr@rKrvseeds&&&&&rqsr:sb y= >>rc V^8d \R4h/p.p/pV^,^8Xd2^pV^,pV^,^8XdV^,pV^, pK"W^&\V4'd^WP&V#\V^4;p 'd V wrWV &V#Tp \V4p \ W4wrp\ V4^i,^d,p\ WWW4Fp\W/4p\WVVVWs4wppVV, pVFEpV V,'dK^pV V,p V V,^8XdV V,p V^, pK"WV&KG V\ V48:gKM \W\ V4^,4F^pV V,^8XgK^pV V,p V V,^8XdV V,p V^, pK"WV&V ^8Xg\V 4'gK^M V ^8wd^W[&V#)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 zN should be greater than 1) ValueErrorr r rrFr=rcrhrr)rr@rKrvrfactorsrxrurnresultrAN_copyrLrCrDrB thresholdr\res_relp_frVrfs&&&&& rrrns@ 1u566G 1uz  a!eqj !GA FA qzz 1%%v%  FtnG&;K&K#H K 3&+I !! x Q&q6 *1k1N_l sE!AzzA qLF1*/1 QAJ ,- - R qC 4Dq4HI F?a A v F6/Q&6!QFO{gfooJ{ NrN)i)mathrrsympy.core.randomrsympy.external.gmpyrrrr rsympy.ntheory.factor_r sympy.ntheory.primetestr sympy.ntheory.residue_ntheoryr rr-rFrcrhrorrrrrrrs\&EE0+?1160+:HV68/+d*Z1?hUr