XhZ:ddlmZmZddlmZddlmZmZmZm Z ddl m Z ddl mZddlmZGddZGd d Zd Zd Zd ZdZdZdZddZddZdS))explog)_randint) bit_scan1gcdinvertsqrt)_perfect_power)isprime)_sqrt_mod_prime_powerc eZdZdZdZdZdS)SievePolynomialcj||_||_|dz|_d|z|z|_|dz|z |_dS)a4This 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 b/var/www/tools.fuzzalab.pt/emblema-extractor/venv/lib/python3.11/site-packages/sympy/ntheory/qs.py__init__zSievePolynomial.__init__ s?Q$A#a%Q$(c&|j|z|jzSN)rrrxs reval_uzSievePolynomial.eval_usvax$&  rc<|j|z|jz|z|jzSr)rrrrs reval_vzSievePolynomial.eval_v s! DG#Q&00rN)__name__ __module__ __qualname__rrr!rrrr sA&!!!11111rrceZdZdZdZdS)FactorBaseElemz7This class stores an element of the `factor_base`. cZ||_||_||_d|_d|_d|_dS)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)r*r+s rrzFactorBaseElem.__init__'s4      rN)r"r#r$__doc__rr%rrr'r'$s-rr'cddlm}g}d\}}|d|D]}t||dz dz|dkr|dkr|t |dz }|dkr|t |dz }t ||dd}t t|d z}|t||||||fS) 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)NNriNi) sympy.ntheory.generater1 primerangepowlenr roundrappendr') prime_boundnr1 factor_baseidx_1000idx_5000r)residuer+s r_generate_factor_baser@<s-,,,,,K#Hh!!![11FF q519"E * *a / /t|| 0{++a/t|| 0{++a/+Aua88;G#e**U*++E   ~eWeDD E E E X{ **rc#Ktd|zdz t|z }|pd}|pt|dz } d\} } } tdD]} d} g}t| |kr\d}|dks||vr|||}|dk||v||j}| |z} ||t| |k\t t| |z }| &t |dz t | dz kr|} | } |} | } | }g}|D]\}||j}||jt| |z|z|z}d|z|kr||z }|| |z|z]t|}t| ||}|D]v| jzdkrd_ t| jfd|D_ j|z zjz_ j |z zjz_ w|Vtddt|dz zD]}t|}d||dzz dzzdz }|jd|z||zz}|j} t| ||}|D]Tj  j |j |zz jz_ j |j |zz jz_ U|V) a6 Generate 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`. rrr2T)NNN2Nc0g|]}d|zzjzSr)r)).0b_elema_invfbs r z(_generate_polynomial..s(CCCv6%"(2CCCr)rr7ranger)r9rabsr*rsumrr,r.r-rrr)rMr<r=r>randint approx_valstartendbest_abest_q best_ratio_rqrand_ppratioBvalq_lgammargivneg_powrGrHs @@r_generate_polynomialrbYsv QqS!c!ff$J ME  ,s;''!+C5%5" r # #AAAa&&:%%kkVq[[$WUC00FkkVq[['-Q   a&&:%%A+,,E!S^^c*q.6I6I%I%I"     # #Cc"(C$+fQ#Xs.C.CCcIEw}}e  HHQVE\ " " " " FF Aq! $ $ ; ;B28|q  1bh''ECCCCCCCCBIry1}-9BH zA~."(:BHHq!c!ffQh-((  A! A!A,!+,q0Gai!n$AA1a((A! H H8#Hwry|';;rxGHwry|';;rxGGGGGk5rcTdgd|zdzz}|D]}|j t||jz|jzd|z|jD]}||xx|jz cc<|jdkrWt||jz|jzd|z|jD]}||xx|jz cc<|S)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 rrr2)r,rJr)r+r-)rMr< sieve_arrayfactoridxs r_gen_sieve_arrayrgs#qsQw-K - - <  !fl*fl:AaCNN - -C     ,     <1   !fl*fl:AaCNN - -C     ,     - rc|dkr|dz}d}nd}t|dD]T\}}||jzrd}||jz}||jzdkr|dz }||jz}||jzdk|dzr|d|zz }U||fS)z Check 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 rr2r) enumerater))numr<vecr_rHes r_check_smoothnessrns Qww r ;**  2 >    BHn!! FA BH CBHn!! q5  16MC 8Orct|t|dz z|z dz}g}t} d|djz} t|| D]\} } | |kr || } t | |\}}|dkr,||| | |fg|| krt|r||zdkr| ||| }||vr\| |\}}}||zt||z|z}| |z|dzz} ||z}||| |f|| |f||<|| fS)a)Trial 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 rr3rir2r) rsetr)rjr!rnr9rr addpopr)rrMr<rd sieve_polypartial_relations ERROR_TERMaccumulated_valsmooth_relations proper_factorpartial_relation_upper_boundrr[r`rlrkuu_prevv_prevvec_prevs r_trial_division_stagers.1vvAq(:5>OEEM#&{2'<#< K!,,553     a $Q 44S !88  # #Z%6%6q%9%91c$B C C C C / / /GCLL /3w!||!!#&&&!!!$$A'''+<+@+@+E+E(fHVC^^+a/fHQ&x ''As 4444*+Q!#& ] **rc#tKd|D}t|}dg|z}t|D]n}d|z}t|D]W}|||zx} rH| ||z } |||<d||<t|dz|D]} || |zr|| xx| zcc<nXot|||D]\}} } |r | d| d}}t|||D]#\}}}|r| |zr||dz}||dz}$t|}dt ||z |x}cxkr|krn|VdS)a Finds 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 cg|] }|d SrDr%)rE s_relations rrIz _find_factor..s ? ? ? jm ? ? ?rFr2TrN)r7rJzipisqrtr)rrxcolmatrixrowmarkposmr_rXadd_coljmatrelr{r`m1mat1rel1r^s r _find_factorr s @ ?.> ? ? ?F f++C 7S=DSzz   Hs  A1IM!q fQi-q Qq1uc**--Aay1}-q W,  4)9::   3   1vs1v1!$0@AA  NBd cDj T!W T!W  !HH SQ]]" ' ' ' 'a ' ' ' ' 'GGG  rc Btt|||||S)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 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:rMrvseeds rqsr:s#b yKJ== > >>rc |dkrtdi}g}i}|dzdkr(d}|dz}|dzdkr|dz}|dz }|dzdk||d<t|rd||<|St|dx} r | \} }||| <|S|} t|} t ||\} }}t |dzdz}t |||| || D]w}t||}t|||||||\}}||z }|D]0}| |zrd}| |z} | |zdkr| |z} |dz }| |zdk|||<1|t |krnxt||t |dzD]J}| |zdkr?d}| |z} | |zdkr| |z} |dz }| |zdk|||<| dkst| rnK| dkrd|| <|S)a Performs 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 1rr2id) ValueErrorr r rr@r7rbrgrr)rr:rMrvrfactorsrxrurmresultr;N_copyrNr=r>r< thresholdr^rds_relp_frXres rrrns@ 1uu5666G 1uzz  a!eqjj !GA FA!eqjj qzz 1%%%v1  FtnnG&;K&K&K#Hh K  3&+I !!Q Xx Q Q&q+66 *1ak1N_akll sE!  Az A qLF1*//1 Q1*//GAJJ ,-- - - E .q"2C 4D4Dq4HII   F?a  A v F6/Q&&6!Q6/Q&& GFO{{gfoo{ {{ NrN)rr)mathrrsympy.core.randomrsympy.external.gmpyrrrr rsympy.ntheory.factor_r sympy.ntheory.primetestr sympy.ntheory.residue_ntheoryr rr'r@rbrgrnrrrrr%rrrsr&&&&&&EEEEEEEEEEEE000000++++++??????1111111160+++:HHHV68/+/+/+d***Z1?1?1?1?hUUUUUUr