o
    8VaG                     @   s   d dl mZmZ d dlmZ d dlmZ d dlmZm	Z	 d dl
Z
e
 ZG dd dZG dd	 d	Zd
d Zd ddZdd Zdd Zdd Zdd Zdd Zdd Zdd Zd!ddZdS )"    )igcdmod_inverse)_sqrt_mod_prime_power)isprime)logsqrtNc                   @   s$   e Zd Zg ddfddZdd ZdS )SievePolynomialNc                 C   s   || _ || _|| _dS )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   2/usr/lib/python3/dist-packages/sympy/ntheory/qs.py__init__
   s   
zSievePolynomial.__init__c                 C   s$   d}| j D ]
}||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   xZansZcoeffr   r   r   eval    s
   	

zSievePolynomial.eval)__name__
__module____qualname__r   r   r   r   r   r   r   	   s    r   c                   @   s   e Zd ZdZdd ZdS )FactorBaseElemz7This class stores an element of the `factor_base`.
    c                 C   s.   || _ || _|| _d| _d| _d| _d| _dS )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)r   r   r   r   r   r   r   r   3   s   
zFactorBaseElem.__init__N)r   r   r   __doc__r   r   r   r   r   r   0   s    r   c           	      C   s   ddl m} g }d\}}|d| D ]C}t||d d |dkrU|dkr.|du r.t|d }|dkr<|du r<t|d }t||dd }tt|d	 }|t	||| q|||fS )
a  Generate `factor_base` for Quadratic Sieve. The `factor_base`
    consists of all the 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     )
sympyr   Z
primerangepowlenr   roundr   appendr   )	prime_boundnr   factor_baseidx_1000idx_5000r   Zresiduer   r   r   r   _generate_factor_baseG   s   
r-   c                    s  |dur	t | td|  | }d\}}}	|du rdn|}
|du r(t|d n|}tdD ]N}d}g }||k rbd}|dksB||v rPt |
|}|dksB||v sB|| j}||9 }|| ||k s8|| }|	du svt|d t|	d k r||}|}|}	q.|}|}g }t	|D ]*\}}|| j}|| j
t|| | | }||d kr|| }||| |  qt|}t|| d| | || |  g||}|D ]4 | j dkrqt| j _ fdd|D  _ j j
|   j  _ j j
 |   j  _q||fS )	ah  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 intialized 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 don't have to calculate
    `2*b*mod_inverse(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 numbe in the factor_base near 1000
    idx_5000 : index of primenumber in the factor_base near to 5000
    seed : Generate pseudoprime numbers
    Nr!   )NNNr   r    2   c                    s    g | ]}d |  j   j qS )r!   )r   r   ).0Zb_elemfbr   r   
<listcomp>   s     z0_initialize_first_polynomial.<locals>.<listcomp>)rgenseedr   r%   rangeZrandintr   r'   abs	enumerater   r   sumr   r   r   r   r   )NMr*   r+   r,   r4   Z
approx_valZbest_aZbest_qZ
best_ratiostartend_r
   qZrand_ppZratioBidxvalZq_lZgammar   gr   r0   r   _initialize_first_polynomiald   sV   



 
&rD   c                 C   s  ddl m} d}|}|d dkr|d7 }|d }|d dks||d|  d dkr-d}nd}|jd| ||d    }	|j}
t|
|
 d|
 |	 |	|	 |  g|
|	}|D ]*}|
|j dkr^qT|j||j|d    |j |_|j||j|d    |j |_qT|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!   )	r#   rE   r   r
   r   r   r   r   r   )r9   r*   irC   r@   rE   vjZneg_powr   r
   r1   r   r   r   _initialize_ith_poly   s&   & "rJ   c                 C   s   dgd|  d  }|D ]D}|j du rqt| |j  |j d|  |jD ]}||  |j7  < q"|jdkr4qt| |j |j d|  |jD ]}||  |j7  < qCq|S )a  Sieve Stage of the Quadratic Sieve. For every prime in the factor_base
    that doesn't 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
    r   r!   r    N)r   r5   r   r   r   )r:   r*   sieve_arrayfactorrA   r   r   r   _gen_sieve_array   s   
"
"rM   c                 C   s   g }| dk r| d | d9 } n| d |D ]/}| |j dkr&| d qd}| |j dkr?|d7 }| |j } | |j dks/| |d  q| dkrO|dfS t| rW| dfS dS )ab  Here 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
    r   r    rF   r!   TFr   )r'   r   r   )Znumr*   vecrL   Z
factor_expr   r   r   _check_smoothness   s(   




rO   c              	   C   s>  t t| }t|| d | }g }	t }
d|d j }t|D ]z\}}||k r)q || }||}t||\}}|du r>q |j| |j	 }|du r|}||krQq ||vr\||f||< q || \}}|
| zt|| }W n ty|   |
| Y q w || | }|| ||  }t||\}}|	|||f q |	|
fS )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
    r"      rF   NF)r   floatr   setr   r7   r   rO   r
   r   popr   
ValueErroraddr'   )r9   r:   r*   rK   Z
sieve_polypartial_relations
ERROR_TERMZsqrt_nZaccumulated_valsmooth_relationsproper_factorZpartial_relation_upper_boundrA   rB   r   rH   rN   Z	is_smoothuZlarge_primeZu_prevZv_prevZlarge_prime_invr   r   r   _trial_division_stage  sD   


r[   c                 C   s    g }| D ]	}| |d  q|S )z|Build a 2D matrix from smooth relations.

    Parameters
    ==========

    smooth_relations : Stores smooth relations
    r!   )r'   )rX   matrixZ
s_relationr   r   r   _build_matrixT  s   r]   c                 C   s   ddl }|| }t|}t|d }dg| }t|D ]D}t|D ]}|| | dkr. nq"d||< t|D ](}||kr>q7|| | dkr_t|D ]}	||	 | ||	 |  d ||	 |< qJq7qg }
t|D ]\}}|dkrx|
|| |g qg|
||fS )a  Fast gaussian reduction for modulo 2 matrix.

    Parameters
    ==========

    A : Matrix

    Examples
    ========

    >>> 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.Arachchiger   NFr    Tr!   )copyZdeepcopyr%   r5   r7   r'   )Ar^   r\   rowcolmarkcrZc1Zr2dependent_rowrA   rB   r   r   r   _gauss_mod_2b  s2   

&
rf   c                 C   s   ddl m} | | d }|| d g}|| d g}	| | d }
t|
D ]3\}}|dkrWtt|D ]$}|| | dkrV|| dkrV||| d  |	|| d   nq2q$d}d}|D ]}||9 }q^|	D ]}||9 }qg||dd }t|| |S )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
    r   )integer_nthrootr    Tr!   )r#   rg   r7   r5   r%   r'   r   )Zdependent_rowsrb   gauss_matrixindexrX   r9   rg   Zidx_in_smoothZindependent_uZindependent_vZdept_rowrA   rB   r`   rZ   rH   rG   r   r   r   _find_factor  s*   

rj        c                 C   s  |d9 }t | t|| \}}}g }d}	i }
t }dt| d }	 |	dkr2t| ||||\}}nt| ||	||}|	d7 }	|	dt|d  krJd}	t||}t| |||||
|\}}||7 }||O }t|t|| krnnq#t	|}t
|\}}}| }tt|D ];}t|||||| }|dkr|| k r|| || dkr|| }|| dkst|r||  |S |dkr |S q|S )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 muliple 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
    r"   r      d   Tr    r!   )r3   r4   r-   rR   r%   rD   rJ   rM   r[   r]   rf   r5   rj   rU   r   )r9   r(   r:   rW   r4   r+   r,   r*   rX   Zith_polyrV   rY   Z	thresholdZith_sieve_polyZB_arrayrK   Zs_relZp_fr\   re   rb   rh   ZN_copyri   rL   r   r   r   qs  sR   '



 ro   )N)rk   rl   )Zsympy.core.numbersr   r   Zsympy.ntheory.residue_ntheoryr   Zsympy.ntheoryr   Zmathr   r   ZrandomZRandomr3   r   r   r-   rD   rJ   rM   rO   r[   r]   rf   rj   ro   r   r   r   r   <module>   s$    '
G(&@-)