Ë
    7^(h3  ã                   óè   — d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	m
Z
 ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ d„ Zd„ Zd„ Zed„ «       Ze G d„ d«      «       Zed„ «       Zd„ Zedd„«       Zy)z'Utilities for algebraic number theory. é    )Úsympify)Ú	factorint)ÚQQ)ÚZZ)ÚDMRankError)Úminpoly)ÚIntervalPrinter)Úpublic)Úlambdify)Úmpc                 ó~   — t        | t        «      xs, t        j                  | «      xs t	        j                  | «      S )zù
    Test whether an argument is of an acceptable type to be used as a rational
    number.

    Explanation
    ===========

    Returns ``True`` on any argument of type ``int``, :ref:`ZZ`, or :ref:`QQ`.

    See Also
    ========

    is_int

    )Ú
isinstanceÚintr   Úof_typer   ©Úcs    ú`/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/polys/numberfields/utilities.pyÚis_ratr      s+   € ô, �aœÓÒ?¤§¡¨A£Ò?´"·*±*¸Q³-Ð?ó    c                 óP   — t        | t        «      xs t        j                  | «      S )zâ
    Test whether an argument is of an acceptable type to be used as an integer.

    Explanation
    ===========

    Returns ``True`` on any argument of type ``int`` or :ref:`ZZ`.

    See Also
    ========

    is_rat

    )r   r   r   r   r   s    r   Úis_intr   )   s   € ô$ �aœÓÒ.¤§¡¨A£Ð.r   c                 óH   — t        | «      }|j                  |j                  fS )z§
    Given any argument on which :py:func:`~.is_rat` is ``True``, return the
    numerator and denominator of this number.

    See Also
    ========

    is_rat

    )r   Ú	numeratorÚdenominator)r   Úrs     r   Úget_num_denomr   >   s    € ô 	ˆ1‹€AØ�;‰;˜Ÿ™Ð%Ð%r   c                 óx  — | dz  dvrt        d«      ‚| dk(  ri ddifS | dk(  ri i fS t        | «      }i }i }d}|j                  «       D ]9  \  }}|dz  dk(  r$d||<   |dz  dk(  r|dz  }|dk\  sŒ&|dz
  dz  ||<   Œ2|dz  ||<   Œ; d|v }|s|dz  dk(  r&|d   }|dkD  sJ ‚|dk(  r|d= n|dz
  |d<   |rdnd|d<   ||fS )a  
    Extract a fundamental discriminant from an integer *a*.

    Explanation
    ===========

    Given any rational integer *a* that is 0 or 1 mod 4, write $a = d f^2$,
    where $d$ is either 1 or a fundamental discriminant, and return a pair
    of dictionaries ``(D, F)`` giving the prime factorizations of $d$ and $f$
    respectively, in the same format returned by :py:func:`~.factorint`.

    A fundamental discriminant $d$ is different from unity, and is either
    1 mod 4 and squarefree, or is 0 mod 4 and such that $d/4$ is squarefree
    and 2 or 3 mod 4. This is the same as being the discriminant of some
    quadratic field.

    Examples
    ========

    >>> from sympy.polys.numberfields.utilities import extract_fundamental_discriminant
    >>> print(extract_fundamental_discriminant(-432))
    ({3: 1, -1: 1}, {2: 2, 3: 1})

    For comparison:

    >>> from sympy import factorint
    >>> print(factorint(-432))
    {2: 4, 3: 3, -1: 1}

    Parameters
    ==========

    a: int, must be 0 or 1 mod 4

    Returns
    =======

    Pair ``(D, F)``  of dictionaries.

    Raises
    ======

    ValueError
        If *a* is not 0 or 1 mod 4.

    References
    ==========

    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
       (See Prop. 5.1.3)

    é   )r   é   zATo extract fundamental discriminant, number must be 0 or 1 mod 4.r   r   é   é   )Ú
ValueErrorr   Úitems)	ÚaÚ	a_factorsÚDÚFÚnum_3_mod_4ÚpÚeÚevenÚe2s	            r   Ú extract_fundamental_discriminantr-   M   s"  € ðl 	ˆ1�u�FÑÜÐ\Ó]Ð]ØˆA‚vØ�A�q�6ˆzÐØˆA‚vØ�2ˆvˆÜ˜!“€IØ
€AØ
€Að €KØ—‘Ó!ò ‰ˆˆ1Øˆq‰5�AŠ:ØˆAˆa‰DØ�1‰u˜ŠzØ˜qÑ �Ø�A‹vØ˜A™ !‘|��!’à˜‘6ˆAˆaŠDðð �ˆ6€DÙˆ{˜Q‰ !Ò#Øˆq‰TˆØ�AŠvˆˆvØ�Š7Ø�!‘à˜‘6ˆAˆa‰DÙ‰q˜aˆˆ!‰Øˆaˆ4€Kr   c                   ó6   — e Zd ZdZd	d„Zd„ Zd„ Zd„ Zd„ Zd„ Z	y)
ÚAlgIntPowersa‚  
    Compute the powers of an algebraic integer.

    Explanation
    ===========

    Given an algebraic integer $\theta$ by its monic irreducible polynomial
    ``T`` over :ref:`ZZ`, this class computes representations of arbitrarily
    high powers of $\theta$, as :ref:`ZZ`-linear combinations over
    $\{1, \theta, \ldots, \theta^{n-1}\}$, where $n = \deg(T)$.

    The representations are computed using the linear recurrence relations for
    powers of $\theta$, derived from the polynomial ``T``. See [1], Sec. 4.2.2.

    Optionally, the representations may be reduced with respect to a modulus.

    Examples
    ========

    >>> from sympy import Poly, cyclotomic_poly
    >>> from sympy.polys.numberfields.utilities import AlgIntPowers
    >>> T = Poly(cyclotomic_poly(5))
    >>> zeta_pow = AlgIntPowers(T)
    >>> print(zeta_pow[0])
    [1, 0, 0, 0]
    >>> print(zeta_pow[1])
    [0, 1, 0, 0]
    >>> print(zeta_pow[4])  # doctest: +SKIP
    [-1, -1, -1, -1]
    >>> print(zeta_pow[24])  # doctest: +SKIP
    [-1, -1, -1, -1]

    References
    ==========

    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*

    Nc                 óò   — || _         || _        |j                  «       | _        t	        |j
                  j                  «       «      D �cg c]  }| | z  ‘Œ
 c}dd g| _        | j                  | _        yc c}w )a-  
        Parameters
        ==========

        T : :py:class:`~.Poly`
            The monic irreducible polynomial over :ref:`ZZ` defining the
            algebraic integer.

        modulus : int, None, optional
            If not ``None``, all representations will be reduced w.r.t. this.

        Néÿÿÿÿ)	ÚTÚmodulusÚdegreeÚnÚreversedÚrepÚto_listÚpowers_n_and_upÚ
max_so_far)Úselfr2   r3   r   s       r   Ú__init__zAlgIntPowers.__init__Ï   sc   € ð ˆŒØˆŒØ—‘“ˆŒÜ4<¸Q¿U¹U¿]¹]»_Ó4MÖ N¨q !  d£Ò NÈsÐPRÐ SÐTˆÔØŸ&™&ˆ�ùò !Os   Á	A4c                 ó<   — | j                   €|S || j                   z  S ©N)r3   )r;   Úexps     r   ÚredzAlgIntPowers.redâ   s   € Ø—l‘lÐ*ˆsÐB°°d·l±lÑ0BÐBr   c                 ó$   — | j                  |«      S r>   )r@   )r;   Úothers     r   Ú__rmod__zAlgIntPowers.__rmod__å   s   € Ø�x‰x˜‹Ðr   c           
      ól  — | j                   }||k  ry | j                  }| j                  }|d   }t        |dz   |dz   «      D ]d  }||dz
  |z
     |dz
     }|j	                  |d   |z  | z  gt        d|«      D �cg c]  }||dz
  |z
     |dz
     ||   |z  z   | z  ‘Œ! c}z   «       Œf || _         y c c}w )Nr   r   )r:   r5   r9   ÚrangeÚappend)	r;   r*   Úmr5   r   r   ÚkÚbÚis	            r   Úcompute_up_throughzAlgIntPowers.compute_up_throughè   sÖ   € Ø�O‰OˆØ�Š6�6Ø�F‰FˆØ× Ñ ˆØˆa‰DˆÜ�q˜‘s˜A˜a™C“ò 	ˆAØ�!�A‘#�a‘%‘˜˜1™‘ˆAØ�H‰HØ�1‘�a‘˜$‘�Ü=BÀ1Àa»[ö#Ø89�Q�q˜‘s˜1‘u‘X˜a ™c‘] Q q¡T¨!¡VÑ+¨tÓ3ò#ñ õð	ð ˆ�ùò	#s   Á:$B1c                 óÔ   — | j                   }|dk  rt        d«      ‚||k  r t        |«      D �cg c]  }||k(  rdnd‘Œ c}S | j                  |«       | j                  ||z
     S c c}w )Nr   zExponent must be non-negative.r   )r5   r"   rE   rK   r9   )r;   r*   r5   rJ   s       r   ÚgetzAlgIntPowers.get÷   sm   € Ø�F‰FˆØˆqŠ5ÜÐ=Ó>Ð>Ø�ŠUÜ05°a³Ö9¨1˜˜aš‘A QÑ&Ò9Ð9à×#Ñ# AÔ&Ø×'Ñ'¨¨A©Ñ.Ð.ùò :s   ¯A%c                 ó$   — | j                  |«      S r>   )rM   )r;   Úitems     r   Ú__getitem__zAlgIntPowers.__getitem__  s   € Ø�x‰x˜‹~Ðr   r>   )
Ú__name__Ú
__module__Ú__qualname__Ú__doc__r<   r@   rC   rK   rM   rP   © r   r   r/   r/   ¦   s'   „ ñ%óN!ò&Còòò/ór   r/   c              #   ó  K  — |}|g| z  }	 ||k(  s	||v s| |v r|dd –— | dz
  }||   | k(  r|dz  }||   | k(  rŒ||xx   dz  cc<   t        |dz   | «      D ]  }|||<   Œ	 t        | «      D ]  }||   dk7  sŒ n |dz  }|g| z  }Œ~­w)a[  
    Generate coefficients for searching through polynomials.

    Explanation
    ===========

    Lead coeff is always non-negative. Explore all combinations with coeffs
    bounded in absolute value before increasing the bound. Skip the all-zero
    list, and skip any repeats. See examples.

    Examples
    ========

    >>> from sympy.polys.numberfields.utilities import coeff_search
    >>> cs = coeff_search(2, 1)
    >>> C = [next(cs) for i in range(13)]
    >>> print(C)
    [[1, 1], [1, 0], [1, -1], [0, 1], [2, 2], [2, 1], [2, 0], [2, -1], [2, -2],
     [1, 2], [1, -2], [0, 2], [3, 3]]

    Parameters
    ==========

    m : int
        Length of coeff list.
    R : int
        Initial max abs val for coeffs (will increase as search proceeds).

    Returns
    =======

    generator
        Infinite generator of lists of coefficients.

    Nr   r   )rE   )rG   ÚRÚR0r   ÚjrJ   s         r   Úcoeff_searchrZ     sÓ   è ø€ ðJ 
€BØ	
ˆˆa‰€AØ
Ø�Š7�a˜1‘f   a¡Ø‘A�$ŠJØ�‰EˆØ�‰d�q�bŠjØ�‰FˆAð �‰d�q�b‹jà	ˆ!‹�‰	‹Ü�q˜1‘u˜a“ò 	ˆAØˆAˆaŠDð	ä�q“ò 	ˆAØ�‰t�q‹yÙð	ð �‰FˆAØ��a‘ˆAð ùs   ‚;B
¾<B
Á;B
c                 ó   — | j                   \  }}| j                  | j                  || j                  «      «      }|j	                  «       \  }}|d| t        t        |«      «      k7  rt        d«      ‚|dd…|d…f   }|j                  «       }|S )ax  
    Extend a basis for a subspace to a basis for the whole space.

    Explanation
    ===========

    Given an $n \times r$ matrix *M* of rank $r$ (so $r \leq n$), this function
    computes an invertible $n \times n$ matrix $B$ such that the first $r$
    columns of $B$ equal *M*.

    This operation can be interpreted as a way of extending a basis for a
    subspace, to give a basis for the whole space.

    To be precise, suppose you have an $n$-dimensional vector space $V$, with
    basis $\{v_1, v_2, \ldots, v_n\}$, and an $r$-dimensional subspace $W$ of
    $V$, spanned by a basis $\{w_1, w_2, \ldots, w_r\}$, where the $w_j$ are
    given as linear combinations of the $v_i$. If the columns of *M* represent
    the $w_j$ as such linear combinations, then the columns of the matrix $B$
    computed by this function give a new basis $\{u_1, u_2, \ldots, u_n\}$ for
    $V$, again relative to the $\{v_i\}$ basis, and such that $u_j = w_j$
    for $1 \leq j \leq r$.

    Examples
    ========

    Note: The function works in terms of columns, so in these examples we
    print matrix transposes in order to make the columns easier to inspect.

    >>> from sympy.polys.matrices import DM
    >>> from sympy import QQ, FF
    >>> from sympy.polys.numberfields.utilities import supplement_a_subspace
    >>> M = DM([[1, 7, 0], [2, 3, 4]], QQ).transpose()
    >>> print(supplement_a_subspace(M).to_Matrix().transpose())
    Matrix([[1, 7, 0], [2, 3, 4], [1, 0, 0]])

    >>> M2 = M.convert_to(FF(7))
    >>> print(M2.to_Matrix().transpose())
    Matrix([[1, 0, 0], [2, 3, -3]])
    >>> print(supplement_a_subspace(M2).to_Matrix().transpose())
    Matrix([[1, 0, 0], [2, 3, -3], [0, 1, 0]])

    Parameters
    ==========

    M : :py:class:`~.DomainMatrix`
        The columns give the basis for the subspace.

    Returns
    =======

    :py:class:`~.DomainMatrix`
        This matrix is invertible and its first $r$ columns equal *M*.

    Raises
    ======

    DMRankError
        If *M* was not of maximal rank.

    References
    ==========

    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*
       (See Sec. 2.3.2.)

    NzM was not of maximal rank)	ÚshapeÚhstackÚeyeÚdomainÚrrefÚtuplerE   r   Úinv)ÚMr5   r   ÚMaugrW   ÚpivotsÚAÚBs           r   Úsupplement_a_subspacerh   =  s…   € ðF �7‰7�D€A€qð �8‰8�A—E‘E˜!˜QŸX™XÓ&Ó'€DØ—	‘	“�I€A€vØˆbˆq€z”Uœ5 ›8“_Ò$ÜÐ5Ó6Ð6ð
 	
Š!ˆQ‰Rˆ%‰€AØ	�‰‹€Að
 €Hr   Nc                 ó  — t        | «      } | j                  r| | fS | j                  st        d«      ‚t	        d| dt        «       ¬«      }t        | d¬«      }|j                  d¬«      }t        j                  d}}	 |sP |«       } |D ](  \  }}	|| j                  k  sŒ| j                  |	k  sŒ&d} n t        xj                  d	z  c_	        |sŒP|t        _	        |�|j                  	||¬
«      \  }}		fS # |t        _	        w xY w)a  
    Find a rational isolating interval for a real algebraic number.

    Examples
    ========

    >>> from sympy import isolate, sqrt, Rational
    >>> print(isolate(sqrt(2)))  # doctest: +SKIP
    (1, 2)
    >>> print(isolate(sqrt(2), eps=Rational(1, 100)))
    (24/17, 17/12)

    Parameters
    ==========

    alg : str, int, :py:class:`~.Expr`
        The algebraic number to be isolated. Must be a real number, to use this
        particular function. However, see also :py:meth:`.Poly.intervals`,
        which isolates complex roots when you pass ``all=True``.
    eps : positive element of :ref:`QQ`, None, optional (default=None)
        Precision to be passed to :py:meth:`.Poly.refine_root`
    fast : boolean, optional (default=False)
        Say whether fast refinement procedure should be used.
        (Will be passed to :py:meth:`.Poly.refine_root`.)

    Returns
    =======

    Pair of rational numbers defining an isolating interval for the given
    algebraic number.

    See Also
    ========

    .Poly.intervals

    z+complex algebraic numbers are not supportedrU   Úmpmath)ÚmodulesÚprinterT)Úpolys)ÚsqfFr    )ÚepsÚfast)r   Úis_RationalÚis_realÚNotImplementedErrorr   r	   r   Ú	intervalsr   Údpsr$   rI   Úrefine_root)
Úalgro   rp   ÚfuncÚpolyrt   ru   Údoner$   rI   s
             r   Úisolater{   ”  s  € ôN �#‹,€Cà
‡‚Ø�SˆzÐØ�[Š[Ü!Ø9ó;ð 	;ô �B˜ X´Ó7HÔI€Dä�3˜dÔ#€DØ—‘ 4�Ó(€Iä—‘˜ˆ€CðÙÙ“&ˆCà!ò ‘��1Ø˜Ÿ™“: #§%¡%¨1£*Ø�DÙðô
 —’˜!‘•ò ð ŒŒà
€Ø×Ñ  1¨#°DÐÓ9‰ˆˆ1àˆqˆ6€Møð Œ�ús   Á< C7 ÂC7 Â- C7 Ã7D)NF)rT   Úsympy.core.sympifyr   Úsympy.ntheory.factor_r   Ú!sympy.polys.domains.rationalfieldr   Úsympy.polys.domains.integerringr   Úsympy.polys.matrices.exceptionsr   Ú sympy.polys.numberfields.minpolyr   Úsympy.printing.lambdareprr	   Úsympy.utilities.decoratorr
   Úsympy.utilities.lambdifyr   rj   r   r   r   r   r-   r/   rZ   rh   r{   rU   r   r   ú<module>r…      sœ   ðÙ -å &Ý +Ý 0Ý .Ý 7Ý 4Ý 5Ý ,Ý -å ò@ò2/ò*&ð ñUó ðUðp ÷[ð [ó ð[ð| ñ4ó ð4ònTðn òEó ñEr   