o
    8Va                     @   s   d dl mZ d dlmZ d dlmZ d dlmZmZ d dl	m
Z
 d dlmZ d dlmZmZmZ dd	 ZdddZdd ZdddZdd ZdS )    )reduceas_int)prod)igcdexigcdisprime)ZZ)gf_crtgf_crt1gf_crt2c                 C   s   | |d kr| S | | S )zReturn the residual mod m such that it is within half of the modulus.

    >>> from sympy.ntheory.modular import symmetric_residue
    >>> symmetric_residue(1, 6)
    1
    >>> symmetric_residue(4, 6)
    -2
        )amr   r   7/usr/lib/python3/dist-packages/sympy/ntheory/modular.pysymmetric_residue   s   	r   FTc                    s   |rt tt| } t tt|}t|| t t| }|rAt fddt|| D sAtt t|| d|d  du r= S  \ }|rJt	 ||fS  |fS )ak  Chinese Remainder Theorem.

    The moduli in m are assumed to be pairwise coprime.  The output
    is then an integer f, such that f = v_i mod m_i for each pair out
    of v and m. If ``symmetric`` is False a positive integer will be
    returned, else \|f\| will be less than or equal to the LCM of the
    moduli, and thus f may be negative.

    If the moduli are not co-prime the correct result will be returned
    if/when the test of the result is found to be incorrect. This result
    will be None if there is no solution.

    The keyword ``check`` can be set to False if it is known that the moduli
    are coprime.

    Examples
    ========

    As an example consider a set of residues ``U = [49, 76, 65]``
    and a set of moduli ``M = [99, 97, 95]``. Then we have::

       >>> from sympy.ntheory.modular import crt

       >>> crt([99, 97, 95], [49, 76, 65])
       (639985, 912285)

    This is the correct result because::

       >>> [639985 % m for m in [99, 97, 95]]
       [49, 76, 65]

    If the moduli are not co-prime, you may receive an incorrect result
    if you use ``check=False``:

       >>> crt([12, 6, 17], [3, 4, 2], check=False)
       (954, 1224)
       >>> [954 % m for m in [12, 6, 17]]
       [6, 0, 2]
       >>> crt([12, 6, 17], [3, 4, 2]) is None
       True
       >>> crt([3, 6], [2, 5])
       (5, 6)

    Note: the order of gf_crt's arguments is reversed relative to crt,
    and that solve_congruence takes residue, modulus pairs.

    Programmer's note: rather than checking that all pairs of moduli share
    no GCD (an O(n**2) test) and rather than factoring all moduli and seeing
    that there is no factor in common, a check that the result gives the
    indicated residuals is performed -- an O(n) operation.

    See Also
    ========

    solve_congruence
    sympy.polys.galoistools.gf_crt : low level crt routine used by this routine
    c                 3   s$    | ]\}}||  | kV  qd S Nr   ).0vr   resultr   r   	<genexpr>[   s   " zcrt.<locals>.<genexpr>F)check	symmetricN)
listmapr   r   r
   r   allzipsolve_congruencer   )r   r   r   r   mmr   r   r   crt   s    :r"   c                 C   s
   t | tS )zFirst part of Chinese Remainder Theorem, for multiple application.

    Examples
    ========

    >>> from sympy.ntheory.modular import crt1
    >>> crt1([18, 42, 6])
    (4536, [252, 108, 756], [0, 2, 0])
    )r   r
   )r   r   r   r   crt1g   s   
r#   c                 C   s,   t || |||t}|rt|||fS ||fS )zSecond part of Chinese Remainder Theorem, for multiple application.

    Examples
    ========

    >>> from sympy.ntheory.modular import crt1, crt2
    >>> mm, e, s = crt1([18, 42, 6])
    >>> crt2([18, 42, 6], [0, 0, 0], mm, e, s)
    (0, 4536)
    )r   r
   r   )r   r   r!   esr   r   r   r   r   crt2u   s   r&   c                  O   s  dd }| }| dd}| ddr[dd |D }i }|D ]\}}||; }||v r3||| kr2 d	S q|||< qd
d | D }~tdd |D r[tt| \}}t|||ddS d}|D ]}	|||	}|d	u rm d	S |\}
}|
| }
q_|rt|
||fS |
|fS )a  Compute the integer ``n`` that has the residual ``ai`` when it is
    divided by ``mi`` where the ``ai`` and ``mi`` are given as pairs to
    this function: ((a1, m1), (a2, m2), ...). If there is no solution,
    return None. Otherwise return ``n`` and its modulus.

    The ``mi`` values need not be co-prime. If it is known that the moduli are
    not co-prime then the hint ``check`` can be set to False (default=True) and
    the check for a quicker solution via crt() (valid when the moduli are
    co-prime) will be skipped.

    If the hint ``symmetric`` is True (default is False), the value of ``n``
    will be within 1/2 of the modulus, possibly negative.

    Examples
    ========

    >>> from sympy.ntheory.modular import solve_congruence

    What number is 2 mod 3, 3 mod 5 and 2 mod 7?

    >>> solve_congruence((2, 3), (3, 5), (2, 7))
    (23, 105)
    >>> [23 % m for m in [3, 5, 7]]
    [2, 3, 2]

    If you prefer to work with all remainder in one list and
    all moduli in another, send the arguments like this:

    >>> solve_congruence(*zip((2, 3, 2), (3, 5, 7)))
    (23, 105)

    The moduli need not be co-prime; in this case there may or
    may not be a solution:

    >>> solve_congruence((2, 3), (4, 6)) is None
    True

    >>> solve_congruence((2, 3), (5, 6))
    (5, 6)

    The symmetric flag will make the result be within 1/2 of the modulus:

    >>> solve_congruence((2, 3), (5, 6), symmetric=True)
    (-1, 6)

    See Also
    ========

    crt : high level routine implementing the Chinese Remainder Theorem

    c                    s   | \}}|\}}||| |}}}t t|||g  fdd|||fD \}}}|dkr?t||\}	}
  dkr;dS ||	9 }|||  || }}||fS )zReturn the tuple (a, m) which satisfies the requirement
        that n = a + i*m satisfy n = a1 + j*m1 and n = a2 = k*m2.

        References
        ==========

        - https://en.wikipedia.org/wiki/Method_of_successive_substitution
        c                    s   g | ]}|  qS r   r   )r   igr   r   
<listcomp>   s    z5solve_congruence.<locals>.combine.<locals>.<listcomp>   N)r   r   r   )Zc1Zc2Za1Zm1Za2Zm2r   bcZinv_a_r   r   r(   r   combine   s   	z!solve_congruence.<locals>.combiner   Fr   Tc                 S   s    g | ]\}}t |t |fqS r   r   r   rr   r   r   r   r*      s     z$solve_congruence.<locals>.<listcomp>Nc                 S   s   g | ]\}}||fqS r   r   )r   r   r1   r   r   r   r*      s    c                 s   s    | ]	\}}t |V  qd S r   r   r0   r   r   r   r      s    z#solve_congruence.<locals>.<genexpr>)r   r   )r   r+   )getitemsr   r   r   r"   r   )Zremainder_modulus_pairsZhintr/   Zrmr   Zuniqr1   r   ZrvZrminr   r   r   r       s8   4


r    N)FT)F)	functoolsr   Zsympy.core.compatibilityr   Zsympy.core.mulr   Zsympy.core.numbersr   r   Zsympy.ntheory.primetestr	   Zsympy.polys.domainsr
   Zsympy.polys.galoistoolsr   r   r   r   r"   r#   r&   r    r   r   r   r   <module>   s    
N
