o
    §ƒðjE   ã                   @   sŒ   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mZmZ dd	lmZ d
d„ Zddd„Zdd„ Ze
ddd„ƒZdS )z,Computing integral bases for number fields. é    )ÚPoly)ÚAlgebraicField)ÚZZ)ÚQQ)Úpublicé   )ÚModuleEndomorphismÚModuleHomomorphismÚ
PowerBasis)Ú extract_fundamental_discriminantc                 C   s¾   | j }t| |d�}| ¡ \}}|dksJ ‚td||d�}|D ]\}}||9 }q|| }	t|td�}
t|	td�}|
| |  | }t||d�}|}||	fD ]}| |¡}qK|| }| ¡ }||fS )zz
    Apply the "Dedekind criterion" to test whether the order needs to be
    enlarged relative to a given prime *p*.
    ©Úmodulusr   ©Údomain)Úgenr   Úfactor_listr   ÚgcdÚdegree)ÚTÚpÚxÚT_barÚlcÚflÚg_barÚti_barÚ_Úh_barÚgÚhÚfÚf_barÚZ_barÚbÚU_barÚm© r&   ú /tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/venv/lib/python3.10/site-packages/sympy/polys/numberfields/basis.pyÚ_apply_Dedekind_criterion   s$   
r(   Nc                    sH   | j }ˆ du r|‰ ˆ |k rˆ |9 ‰ ˆ |k st| ‡ fdd„ƒ}|j|d�S )aþ  
    Compute the nilradical mod *p* for a given order *H*, and prime *p*.

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

    This is the ideal $I$ in $H/pH$ consisting of all elements some positive
    power of which is zero in this quotient ring, i.e. is a multiple of *p*.

    Parameters
    ==========

    H : :py:class:`~.Submodule`
        The given order.
    p : int
        The rational prime.
    q : int, optional
        If known, the smallest power of *p* that is $>=$ the dimension of *H*.
        If not provided, we compute it here.

    Returns
    =======

    :py:class:`~.Module` representing the nilradical mod *p* in *H*.

    References
    ==========

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

    Nc                    s   | ˆ  S ©Nr&   ©r   ©Úqr&   r'   Ú<lambda>K   s    z"nilradical_mod_p.<locals>.<lambda>r   )Únr   Úkernel)ÚHr   r,   r.   Úphir&   r+   r'   Únilradical_mod_p%   s   !ÿr2   c           
         sŠ   t | ||d�}| jj| j|j | jd�}|||   }| ¡ ‰ t| ˆ ‡ fdd„ƒ}|j|d�}| jj| j|j | j| d�}||  }	|	|fS )zD
    Perform the second enlargement in the Round Two algorithm.
    r+   )Údenomc                    s
   ˆ   | ¡S r)   )Úinner_endomorphismr*   ©ÚEr&   r'   r-   W   s   
 z%_second_enlargement.<locals>.<lambda>r   )r2   ÚparentÚsubmodule_from_matrixÚmatrixr3   Úendomorphism_ringr	   r/   )
r0   r   r,   ÚIpÚBÚCr1   ÚgammaÚGÚH1r&   r5   r'   Ú_second_enlargementO   s   rA   c                 C   sŽ  d}t | tƒr| | j ¡ }} | jr| jr| jttfvr t	dƒ‚|  
¡ \} }|  ¡ }|  ¡ }t t|ƒ¡}t|ƒ\}}t|p?| ƒ}| ¡ }	d}
|rž| ¡ \}}t| |ƒ\}}|dkr[qG| t|td�¡}|	j|| |	 |d�}	||krtqG|}||k r‚||9 }||k szt|	||ƒ\}}
||	krœ|}	t|	||ƒ\}}
||	ksŽ|sI|
dur«t |tƒr«|
||< |	}d|_d|_||j ¡ d  |jd|   }||fS )a  
    Zassenhaus's "Round 2" algorithm.

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

    Carry out Zassenhaus's "Round 2" algorithm on an irreducible polynomial
    *T* over :ref:`ZZ` or :ref:`QQ`. This computes an integral basis and the
    discriminant for the field $K = \mathbb{Q}[x]/(T(x))$.

    Alternatively, you may pass an :py:class:`~.AlgebraicField` instance, in
    place of the polynomial *T*, in which case the algorithm is applied to the
    minimal polynomial for the field's primitive element.

    Ordinarily this function need not be called directly, as one can instead
    access the :py:meth:`~.AlgebraicField.maximal_order`,
    :py:meth:`~.AlgebraicField.integral_basis`, and
    :py:meth:`~.AlgebraicField.discriminant` methods of an
    :py:class:`~.AlgebraicField`.

    Examples
    ========

    Working through an AlgebraicField:

    >>> from sympy import Poly, QQ
    >>> from sympy.abc import x
    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
    >>> K = QQ.alg_field_from_poly(T, "theta")
    >>> print(K.maximal_order())
    Submodule[[2, 0, 0], [0, 2, 0], [0, 1, 1]]/2
    >>> print(K.discriminant())
    -503
    >>> print(K.integral_basis(fmt='sympy'))
    [1, theta, theta/2 + theta**2/2]

    Calling directly:

    >>> from sympy import Poly
    >>> from sympy.abc import x
    >>> from sympy.polys.numberfields.basis import round_two
    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
    >>> print(round_two(T))
    (Submodule[[2, 0, 0], [0, 2, 0], [0, 1, 1]]/2, -503)

    The nilradicals mod $p$ that are sometimes computed during the Round Two
    algorithm may be useful in further calculations. Pass a dictionary under
    `radicals` to receive these:

    >>> T = Poly(x**3 + 3*x**2 + 5)
    >>> rad = {}
    >>> ZK, dK = round_two(T, radicals=rad)
    >>> print(rad)
    {3: Submodule[[-1, 1, 0], [-1, 0, 1]]}

    Parameters
    ==========

    T : :py:class:`~.Poly`, :py:class:`~.AlgebraicField`
        Either (1) the irreducible polynomial over :ref:`ZZ` or :ref:`QQ`
        defining the number field, or (2) an :py:class:`~.AlgebraicField`
        representing the number field itself.

    radicals : dict, optional
        This is a way for any $p$-radicals (if computed) to be returned by
        reference. If desired, pass an empty dictionary. If the algorithm
        reaches the point where it computes the nilradical mod $p$ of the ring
        of integers $Z_K$, then an $\mathbb{F}_p$-basis for this ideal will be
        stored in this dictionary under the key ``p``. This can be useful for
        other algorithms, such as prime decomposition.

    Returns
    =======

    Pair ``(ZK, dK)``, where:

        ``ZK`` is a :py:class:`~sympy.polys.numberfields.modules.Submodule`
        representing the maximal order.

        ``dK`` is the discriminant of the field $K = \mathbb{Q}[x]/(T(x))$.

    See Also
    ========

    .AlgebraicField.maximal_order
    .AlgebraicField.integral_basis
    .AlgebraicField.discriminant

    References
    ==========

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

    NzDRound 2 requires an irreducible univariate polynomial over ZZ or QQ.r   r   )Úhnf_modulusTé   )Ú
isinstancer   ÚextÚminpoly_of_elementÚis_univariateÚis_irreducibler   r   r   Ú
ValueErrorÚ)make_monic_over_integers_by_scaling_rootsr   ÚdiscriminantÚ
from_sympyÚabsr   r
   Úwhole_submoduleÚpopitemr(   Úelement_from_polyr   ÚaddrA   ÚdictÚ_starts_with_unityÚ_is_sq_maxrank_HNFr9   Údetr3   )r   ÚradicalsÚKr   r.   ÚDÚ	D_modulusÚFÚZthetar0   Únilradr   Úer$   r%   ÚUr,   r@   ÚZKÚdKr&   r&   r'   Ú	round_two^   sT   `
ÿÿþê  ra   r)   )Ú__doc__Úsympy.polys.polytoolsr   Ú"sympy.polys.domains.algebraicfieldr   Úsympy.polys.domains.integerringr   Ú!sympy.polys.domains.rationalfieldr   Úsympy.utilities.decoratorr   Úmodulesr   r	   r
   Ú	utilitiesr   r(   r2   rA   ra   r&   r&   r&   r'   Ú<module>   s    
*