U Š±Ëh¨Gã@s¼ddlmZddlmZmZmZddlmZddl m Z ddl m Z mZGdd„dƒZ Gdd „d ƒZd d „Zd!d d„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zd"dd „Zd S)#é)Ú_randint)ÚgcdÚinvertÚsqrt)Ú_sqrt_mod_prime_power)Úisprime)Úlogrc@seZdZddd„Zdd„ZdS)ÚSievePolynomial©NcCs||_||_||_dS)aÄThis 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_coeffÚaÚb)Úselfr r r r r ú4/tmp/pip-unpacked-wheel-6t8vlncq/sympy/ntheory/qs.pyÚ__init__ szSievePolynomial.__init__cCs$d}|jD]}||9}||7}q |S)z¢ Compute the value of the sieve polynomial at point x. Parameters ========== x : Integer parameter for sieve polynomial r)r )rÚxZansZcoeffr r rÚevals   zSievePolynomial.eval)r NN)Ú__name__Ú __module__Ú __qualname__rrr r r rr s r c@seZdZdZdd„ZdS)ÚFactorBaseElemz7This class stores an element of the `factor_base`. cCs.||_||_||_d|_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)ÚprimeÚtmem_pÚlog_pÚsoln1Úsoln2Úa_invÚb_ainv)rrrrr r rr2s zFactorBaseElem.__init__N)rrrÚ__doc__rr r r rr/src Cs¶ddlm}g}d\}}| d|¡D]†}t||dd|ƒdkr$|dkr\|dkr\t|ƒd}|dkrx|dkrxt|ƒd}t||dƒd}tt|ƒd ƒ}| t |||ƒ¡q$|||fS) açGenerate `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©NNééièNiˆé) Zsympy.ntheory.generaterZ primerangeÚpowÚlenrÚroundrÚappendr) Ú prime_boundÚnrÚ factor_baseÚidx_1000Úidx_5000rZresiduerr r rÚ_generate_factor_baseFs   r-Ncsèt|ƒ}td|ƒ|}d\}} } |dkr.dn|} |dkrFt|ƒdn|} tdƒD]†} d}g}||kr¤d}|dksz||kr†|| | ƒ}qj||j}||9}| |¡q^||}| dksÌt|dƒt| dƒkrR|} |}|} qR|}| }g}|D]R}||j}||jt|||ƒ|}||dkr*||}| |||¡qêt |ƒ}t ||d|||||g||ƒ}|D]n‰|ˆjdkrˆqpt|ˆjƒˆ_ ‡fdd„|Dƒˆ_ ˆj ˆj|ˆjˆ_ ˆj ˆj |ˆjˆ_qp||fS) agThis 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 r")NNNNrr!é2cs g|]}d|ˆjˆj‘qS)r")rr)Ú.0Zb_elem©Úfbr rÚ £sz0_initialize_first_polynomial..)rrr%Úrangerr'ÚabsrrÚsumr rrrr)ÚNÚMr*r+r,ÚseedÚrandintZ approx_valZbest_aZbest_qZ best_ratioÚstartÚendÚ_r ÚqZrand_pÚpZratioÚBÚvalZq_lÚgammar Úgr r0rÚ_initialize_first_polynomialcsN       &rCc Csøddlm}d}|}|ddkr2|d7}|d}q||d|ƒddkrPd}nd}|jd|||d} |j} t| | d| | | | |g| | ƒ}|D]T} | | jdkr²qž| j|| j|d| j| _| j|| j|d| j| _qž|S)aÐInitialization 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)Úceilingr!r"éÿÿÿÿ) Z#sympy.functions.elementary.integersrDr r r rrrr) r6r*ÚirBr?rDÚvÚjZneg_powr r r1r r rÚ_initialize_ith_poly©s$   & "rIcCs¤dgd|d}|D]ˆ}|jdkr&qt||j|jd||jƒD]}|||j7<qD|jdkrhqt||j|jd||jƒD]}|||j7<q†q|S)a¨Sieve 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 rr"r!N)rr3rrr)r7r*Ú sieve_arrayÚfactorÚidxr r rÚ_gen_sieve_arrayÑs  " "rMcCs¦g}|dkr | d¡|d9}n | d¡|D]R}||jdkrL| d¡q.d}||jdkrr|d7}||j}qP| |d¡q.|dkr’|dfSt|ƒr¢|dfSdS)abHere 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 rr!rEr"TFr )r'rr)Únumr*ÚvecrKZ factor_expr r rÚ_check_smoothnessìs&     rPc CsDt|ƒ}t||ƒd|}g} tƒ} d|dj} t|ƒD]þ\} } | |krNq<| |}| |¡}t||ƒ\}}|dkrxq<|j||j}|dkr*|}|| kr q<||kr¸||f||<q>> 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.ArachchigerNFr!Tr")ÚcopyÚdeepcopyr%r3rTr') ÚAr`r^ÚrowÚcolÚmarkÚcÚrZc1Zr2Ú dependent_rowrLr@r r rÚ _gauss_mod_2`s*       *ricCsæ||d}||dg}||dg}||d} t| ƒD]f\} } | dkr>> 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 r#réédr!r") r-rSr%rCrIrMr]r_rir3rlrWr)r6r(r7rYr8r+r,r*rZZith_polyrXr[Ú thresholdZith_sieve_polyZB_arrayrJZs_relZp_fr^rhrerjZN_copyrkrKr r rÚqsµsD'     rr)N)rmrn)Zsympy.core.randomrZsympy.external.gmpyrrrrRZsympy.ntheory.residue_ntheoryrZ sympy.ntheoryrÚmathrr rr-rCrIrMrPr]r_rirlrrr r r rÚs   ' F(&@-(