
    sg]                        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mZ d
dlmZ d
dlmZmZ d
dlmZmZ d Z G d de      Zd Zed        ZddZ d Z!d Z"d Z#d Z$edd       Z%y)zPrime ideals in number fields.     )Poly)FF)QQ)ZZ)DomainMatrix)CoercionFailed)IntegerPowerable)public   )	round_twonilradical_mod_p)StructureError)ModuleEndomorphismfind_min_poly)coeff_searchsupplement_a_subspacec                     d}d}| j                         sd}n%| j                         sd}n| j                         sd}|t        ||z         y)a  
    Several functions in this module accept an argument which is to be a
    :py:class:`~.Submodule` representing the maximal order in a number field,
    such as returned by the :py:func:`~sympy.polys.numberfields.basis.round_two`
    algorithm.

    We do not attempt to check that the given ``Submodule`` actually represents
    a maximal order, but we do check a basic set of formal conditions that the
    ``Submodule`` must satisfy, at a minimum. The purpose is to catch an
    obviously ill-formed argument.
    z4The submodule representing the maximal order should Nz'be a direct submodule of a power basis.zhave 1 as its first generator.z<have square matrix, of maximal rank, in Hermite Normal Form.)is_power_basis_submodulestarts_with_unityis_sq_maxrank_HNFr   )	submoduleprefixconds      R/var/www/html/venv/lib/python3.12/site-packages/sympy/polys/numberfields/primes.py*_check_formal_conditions_for_maximal_orderr      s\     DFD--/8((*/((*MVd]++     c                       e Zd ZdZddZd Zed        ZddZd Z	d Z
d	 Zd
 ZeZd ZeZd Zd Zd Zd Zd Zd Zd Zy)
PrimeIdealz8
    A prime ideal in a ring of algebraic integers.
    Nc                     t        |       || _        || _        || _        || _        d| _        ||| _        y| j                  ||z        | _        y)a  
        Parameters
        ==========

        ZK : :py:class:`~.Submodule`
            The maximal order where this ideal lives.
        p : int
            The rational prime this ideal divides.
        alpha : :py:class:`~.PowerBasisElement`
            Such that the ideal is equal to ``p*ZK + alpha*ZK``.
        f : int
            The inertia degree.
        e : int, ``None``, optional
            The ramification index, if already known. If ``None``, we will
            compute it here.

        N)r   ZKpalphaf_test_factor	valuatione)selfr    r!   r"   r#   r&   s         r   __init__zPrimeIdeal.__init__.   sN    $ 	326
 mB)?r   c                     | j                   rd| j                   dS d| j                   d| j                  j                          dS )N(), )is_inertr!   r"   as_exprr'   s    r   __str__zPrimeIdeal.__str__H   sB    ==tvvha= 466("TZZ//12!44r   c                 H    | j                   | j                  j                  k(  S )zv
        Say whether the rational prime we divide is inert, i.e. stays prime in
        our ring of integers.
        )r#   r    nr/   s    r   r-   zPrimeIdeal.is_inertM   s     vv""r   c                    |xs* | j                   j                  j                  j                  }| j                  | j
                  | j                  | j                  f\  }}}}t        |j                  |      j                               }|j                  dkD  rd| d|j                   }d| d| d}|r|S d| d| d	| d
S )a  
        Print a representation of this prime ideal.

        Examples
        ========

        >>> from sympy import cyclotomic_poly, QQ
        >>> from sympy.abc import x, zeta
        >>> T = cyclotomic_poly(7, x)
        >>> K = QQ.algebraic_field((T, zeta))
        >>> P = K.primes_above(11)
        >>> print(P[0].repr())
        [ (11, x**3 + 5*x**2 + 4*x - 1) e=1, f=3 ]
        >>> print(P[0].repr(field_gen=zeta))
        [ (11, zeta**3 + 5*zeta**2 + 4*zeta - 1) e=1, f=3 ]
        >>> print(P[0].repr(field_gen=zeta, just_gens=True))
        (11, zeta**3 + 5*zeta**2 + 4*zeta - 1)

        Parameters
        ==========

        field_gen : :py:class:`~.Symbol`, ``None``, optional (default=None)
            The symbol to use for the generator of the field. This will appear
            in our representation of ``self.alpha``. If ``None``, we use the
            variable of the defining polynomial of ``self.ZK``.
        just_gens : bool, optional (default=False)
            If ``True``, just print the "(p, alpha)" part, showing "just the
            generators" of the prime ideal. Otherwise, print a string of the
            form "[ (p, alpha) e=..., f=... ]", giving the ramification index
            and inertia degree, along with the generators.

        )xr   r*   z)/r,   r+   z[ z e=z, f=z ])r    parentTgenr!   r"   r&   r#   str	numeratorr.   denom)	r'   	field_gen	just_gensr!   r"   r&   r#   	alpha_repgenss	            r   reprzPrimeIdeal.reprU   s    B 5!1!1!5!5	TVVTVV;5!Q)4<<>?	;;?I;b6I1#R	{!$KD6QCtA3b))r   c                 "    | j                         S N)r?   r/   s    r   __repr__zPrimeIdeal.__repr__   s    yy{r   c                     | j                   | j                  z  | j                  | j                  z  z   }d|_        d|_        |S )a  
        Represent this prime ideal as a :py:class:`~.Submodule`.

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

        The :py:class:`~.PrimeIdeal` class serves to bundle information about
        a prime ideal, such as its inertia degree, ramification index, and
        two-generator representation, as well as to offer helpful methods like
        :py:meth:`~.PrimeIdeal.valuation` and
        :py:meth:`~.PrimeIdeal.test_factor`.

        However, in order to be added and multiplied by other ideals or
        rational numbers, it must first be converted into a
        :py:class:`~.Submodule`, which is a class that supports these
        operations.

        In many cases, the user need not perform this conversion deliberately,
        since it is automatically performed by the arithmetic operator methods
        :py:meth:`~.PrimeIdeal.__add__` and :py:meth:`~.PrimeIdeal.__mul__`.

        Raising a :py:class:`~.PrimeIdeal` to a non-negative integer power is
        also supported.

        Examples
        ========

        >>> from sympy import Poly, cyclotomic_poly, prime_decomp
        >>> T = Poly(cyclotomic_poly(7))
        >>> P0 = prime_decomp(7, T)[0]
        >>> print(P0**6 == 7*P0.ZK)
        True

        Note that, on both sides of the equation above, we had a
        :py:class:`~.Submodule`. In the next equation we recall that adding
        ideals yields their GCD. This time, we need a deliberate conversion
        to :py:class:`~.Submodule` on the right:

        >>> print(P0 + 7*P0.ZK == P0.as_submodule())
        True

        Returns
        =======

        :py:class:`~.Submodule`
            Will be equal to ``self.p * self.ZK + self.alpha * self.ZK``.

        See Also
        ========

        __add__
        __mul__

        FT)r!   r    r"   _starts_with_unity_is_sq_maxrank_HNF)r'   Ms     r   as_submodulezPrimeIdeal.as_submodule   s>    n FFTWWtzzDGG33$#r   c                 p    t        |t              r!| j                         |j                         k(  S t        S rA   )
isinstancer   rG   NotImplementedr'   others     r   __eq__zPrimeIdeal.__eq__   s/    eZ($$&%*<*<*>>>r   c                 (    | j                         |z   S )z
        Convert to a :py:class:`~.Submodule` and add to another
        :py:class:`~.Submodule`.

        See Also
        ========

        as_submodule

        rG   rK   s     r   __add__zPrimeIdeal.__add__          "U**r   c                 (    | j                         |z  S )z
        Convert to a :py:class:`~.Submodule` and multiply by another
        :py:class:`~.Submodule` or a rational number.

        See Also
        ========

        as_submodule

        rO   rK   s     r   __mul__zPrimeIdeal.__mul__   rQ   r   c                     | j                   S rA   )r    r/   s    r   _zeroth_powerzPrimeIdeal._zeroth_power   s    wwr   c                     | S rA    r/   s    r   _first_powerzPrimeIdeal._first_power   s    r   c                     | j                   1t        | j                  | j                  g| j                        | _         | j                   S )aO  
        Compute a test factor for this prime ideal.

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

        Write $\mathfrak{p}$ for this prime ideal, $p$ for the rational prime
        it divides. Then, for computing $\mathfrak{p}$-adic valuations it is
        useful to have a number $\beta \in \mathbb{Z}_K$ such that
        $p/\mathfrak{p} = p \mathbb{Z}_K + \beta \mathbb{Z}_K$.

        Essentially, this is the same as the number $\Psi$ (or the "reagent")
        from Kummer's 1847 paper (*Ueber die Zerlegung...*, Crelle vol. 35) in
        which ideal divisors were invented.
        )r$   _compute_test_factorr!   r"   r    r/   s    r   test_factorzPrimeIdeal.test_factor   s;      $ 4TVVdjj\477 SD   r   c                     t        ||       S )z
        Compute the $\mathfrak{p}$-adic valuation of integral ideal I at this
        prime ideal.

        Parameters
        ==========

        I : :py:class:`~.Submodule`

        See Also
        ========

        prime_valuation

        )prime_valuation)r'   Is     r   r%   zPrimeIdeal.valuation   s      q$''r   c                 @    | j                         j                  |      S )a  
        Reduce a :py:class:`~.PowerBasisElement` to a "small representative"
        modulo this prime ideal.

        Parameters
        ==========

        elt : :py:class:`~.PowerBasisElement`
            The element to be reduced.

        Returns
        =======

        :py:class:`~.PowerBasisElement`
            The reduced element.

        See Also
        ========

        reduce_ANP
        reduce_alg_num
        .Submodule.reduce_element

        )rG   reduce_element)r'   elts     r   r`   zPrimeIdeal.reduce_element  s    2   "11#66r   c                     | j                   j                  j                  |      }| j                  |      }|j	                         S )a  
        Reduce an :py:class:`~.ANP` to a "small representative" modulo this
        prime ideal.

        Parameters
        ==========

        elt : :py:class:`~.ANP`
            The element to be reduced.

        Returns
        =======

        :py:class:`~.ANP`
            The reduced element.

        See Also
        ========

        reduce_element
        reduce_alg_num
        .Submodule.reduce_element

        )r    r5   element_from_ANPr`   to_ANPr'   ara   reds       r   
reduce_ANPzPrimeIdeal.reduce_ANP*  s8    2 ggnn--a0!!#&zz|r   c                     | j                   j                  j                  |      }| j                  |      }|j	                  t        t        |j                  j                                           S )a  
        Reduce an :py:class:`~.AlgebraicNumber` to a "small representative"
        modulo this prime ideal.

        Parameters
        ==========

        elt : :py:class:`~.AlgebraicNumber`
            The element to be reduced.

        Returns
        =======

        :py:class:`~.AlgebraicNumber`
            The reduced element.

        See Also
        ========

        reduce_element
        reduce_ANP
        .Submodule.reduce_element

        )	r    r5   element_from_alg_numr`   field_elementlistreversedQQ_colflatre   s       r   reduce_alg_numzPrimeIdeal.reduce_alg_numG  sP    2 ggnn11!4!!#&tHSZZ__->$?@AAr   rA   )NF)__name__
__module____qualname____doc__r(   r0   propertyr-   r?   rB   rG   rM   rP   __radd__rS   __rmul__rU   rX   r[   r%   r`   rh   rp   rW   r   r   r   r   )   sx    @45
 # #)*V;z
+ H+ H!(($76:Br   r   c                    t        |       |j                         }|D cg c]#  }|j                  |      j                  |       % }} t	        j
                  d|j                  ft        |             j                  | }|j                         dddf   j                         }|j                  |j                  |j                  t              z  |j                        }|S c c}w )a  
    Compute the test factor for a :py:class:`~.PrimeIdeal` $\mathfrak{p}$.

    Parameters
    ==========

    p : int
        The rational prime $\mathfrak{p}$ divides

    gens : list of :py:class:`PowerBasisElement`
        A complete set of generators for $\mathfrak{p}$ over *ZK*, EXCEPT that
        an element equivalent to rational *p* can and should be omitted (since
        it has no effect except to waste time).

    ZK : :py:class:`~.Submodule`
        The maximal order where the prime ideal $\mathfrak{p}$ lives.

    Returns
    =======

    :py:class:`~.PowerBasisElement`

    References
    ==========

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

    modulusr   Nr:   )r   endomorphism_ringinner_endomorphismmatrixr   zerosr2   r   vstack	nullspace	transposer5   
convert_tor   r:   )	r!   r>   r    EgmatricesBr4   betas	            r   rZ   rZ   e  s    < /r2
ACGHa$$Q'..q.9HHH3Artt9be,33X>A 	
ad%%'A99RYYb!119BDK Is   (C&c                 d   |j                   |j                  }}|j                  |j                  |j                  }}}|j                  t              j                         | j                  z  |z  | j                  z  }|j                  t              }|j                         }||z  dk7  ry|j                         }	||z  |j                         z  }
|
|z  dk(  }d}	 ||z  }t        |      D ]Z  }|j                  |dd|f   |      }||	z  }|j                  |      j                         }t        |      D ]  }||   |||f<    \ ||dz
  |dz
  f   j                  |z  dk7  r	 |S ||z  }|r	 |j                  t              }n|j                  t              }|dz  }# t         $ r Y |S w xY w)a  
    Compute the *P*-adic valuation for an integral ideal *I*.

    Examples
    ========

    >>> from sympy import QQ
    >>> from sympy.polys.numberfields import prime_valuation
    >>> K = QQ.cyclotomic_field(5)
    >>> P = K.primes_above(5)
    >>> ZK = K.maximal_order()
    >>> print(prime_valuation(25*ZK, P[0]))
    8

    Parameters
    ==========

    I : :py:class:`~.Submodule`
        An integral ideal whose valuation is desired.

    P : :py:class:`~.PrimeIdeal`
        The prime at which to compute the valuation.

    Returns
    =======

    int

    See Also
    ========

    .PrimeIdeal.valuation

    References
    ==========

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

    r   Nr{   r   )r!   r    r2   r~   r:   r   r   invr   detr[   ranger5   	representro   elementr   )r^   Pr!   r    r2   WdADr   r#   need_complete_testvjcis                   r   r]   r]     s   T CCrAddBIIrxx!qA	R)A-7A 	
RA	A1uz==?D	Q!%%'Aa%1*	A
 Eq 	A		!AqD'	+AIAQ$$&A1X A$!Q$	 QUAE\?""Q&!+ H E LL$
 R A	Q7 , " 
 Hs   1F" "	F/.F/Nc                     t        |       |j                  }|j                  }t        fd| D              r|j	                         S |:||z  }n2t        |j                  |       j                  j                               }|j                         }|dd D cg c]  }|z  	 }	}|	| z  }	t        t        |	      d      }
|
D ]A  }t        d t        ||	      D              }|j                  |      |z  }|z  dk7  s<|z  c S  yc c}w )a  
    Given a set of *ZK*-generators of a prime ideal, compute a set of just two
    *ZK*-generators for the same ideal, one of which is *p* itself.

    Parameters
    ==========

    gens : list of :py:class:`PowerBasisElement`
        Generators for the prime ideal over *ZK*, the ring of integers of the
        field $K$.

    ZK : :py:class:`~.Submodule`
        The maximal order in $K$.

    p : int
        The rational prime divided by the prime ideal.

    f : int, optional
        The inertia degree of the prime ideal, if known.

    Np : int, optional
        The norm $p^f$ of the prime ideal, if known.
        NOTE: There is no reason to supply both *f* and *Np*. Either one will
        save us from having to compute the norm *Np* ourselves. If both are known,
        *Np* is preferred since it saves one exponentiation.

    Returns
    =======

    :py:class:`~.PowerBasisElement` representing a single algebraic integer
    alpha such that the prime ideal is equal to ``p*ZK + alpha*ZK``.

    References
    ==========

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

    c              3   F   K   | ]  }|z  j                  d         yw)r   N)equiv).0r   r!   s     r   	<genexpr>z_two_elt_rep.<locals>.<genexpr>  s     
*AE==
*s   !Nr   c              3   ,   K   | ]  \  }}||z    y wrA   rW   )r   cibetais      r   r   z_two_elt_rep.<locals>.<genexpr>'  s     ;UBuH;s   r   )r   r5   r6   allzeroabssubmodule_from_gensr~   r   basis_element_pullbacksr   lensumzipnorm)r>   r    r!   r#   Nppbr6   omegaomr   searchr   r"   r2   s     `           r   _two_elt_repr     s
   P /r2	B
A 
*T
**wwy	z=ABR++D188<<>?B&&(E 9%RAbD%D%DLD#d)Q'F ;c!Tl;; JJqMRq5A:19 &s   Dc                    |j                   j                  }t        ||       }|j                         \  }}t	        |      dk(  r=|d   d   dk(  r2t        || |j                   j                         |j                  d      gS |D cg c]J  \  }}t        || |j                   j                  t        |t                    |j                         |      L c}}S c c}}w )a?  
    Compute the decomposition of rational prime *p* in the ring of integers
    *ZK* (given as a :py:class:`~.Submodule`), in the "easy case", i.e. the
    case where *p* does not divide the index of $\theta$ in *ZK*, where
    $\theta$ is the generator of the ``PowerBasis`` of which *ZK* is a
    ``Submodule``.
    ry   r   r   domain)r5   r6   r   factor_listr   r   r   r2   element_from_polyr   degree)r!   r    r6   T_barlcfltr&   s           r   _prime_decomp_easy_caser   1  s     			AAE FB
2w!|1aA2q")).."2BDD!<==  1 r1yy224"3EFxxz1&   s   ACc                 ,   | j                   }|j                  \  }}|dk(  r|j                  |t              }n,|j	                  |j                  |t              dddf         }|j                  d   |k  r6t        |j                  t                          j                  t              }|j                  |      }|j                          |j                  |      }t        |fd      }|j                        }	|	j                         sJ |	|fS )a+  
    Parameters
    ==========

    I : :py:class:`~.Module`
        An ideal of ``ZK/pZK``.
    p : int
        The rational prime being factored.
    ZK : :py:class:`~.Submodule`
        The maximal order.

    Returns
    =======

    Pair ``(N, G)``, where:

        ``N`` is a :py:class:`~.Module` representing the kernel of the map
        ``a |--> a**p - a`` on ``(O/pO)/I``, guaranteed to be a module with
        unity.

        ``G`` is a :py:class:`~.Module` representing a basis for the separable
        algebra ``A = O/I`` (see Cohen).

    r   Nr   c                     | z  | z
  S rA   rW   )r4   r!   s    r   <lambda>z._prime_decomp_compute_kernel.<locals>.<lambda>s  s    !Q$( r   ry   )r~   shapeeyer   hstackr   r   r   submodule_from_matrixcompute_mult_tabdiscard_beforer   kernelr   )
r^   r!   r    r   r2   rr   GphiNs
    `        r   _prime_decomp_compute_kernelr   D  s    2 	
A77DAq 	AvEE!RLHHQUU1b\!Q$'(wwqzA~!!,,r!u"56AA"E
  #A
 	A
Q 2
3C

1
A   a4Kr   c                 B   | j                   j                  \  }}||z
  }|j                   | j                   z  }t        |j                  d         D cg c]&  }|j                  |dd|f   |j                        ( }}t        ||||      }	t        |||	|      S c c}w )a  
    We have reached the case where we have a maximal (hence prime) ideal *I*,
    which we know because the quotient ``O/I`` is a field.

    Parameters
    ==========

    I : :py:class:`~.Module`
        An ideal of ``O/pO``.
    p : int
        The rational prime being factored.
    ZK : :py:class:`~.Submodule`
        The maximal order.

    Returns
    =======

    :py:class:`~.PrimeIdeal` instance representing this prime

    r   Nr{   )r#   )r~   r   r   r5   r:   r   r   )
r^   r!   r    mr2   r#   r   r   r>   r"   s
             r   _prime_decomp_maximal_idealr   y  s    * 88>>DAq	AA
		AHHA8=aggaj8IJ1BIIa1gRXXI.JDJr1*Eb!UA&& Ks   +Bc                    | j                   |k(  r|j                   |u r|j                   |u sJ  |d      j                         }|j                  |u sJ g t        |t	        |            }|j                         \  }}|d   d   }	|j                  |	      }
|	j                  |
      \  }}}|dk(  sJ t        t        t        ||	z  t              j                  j                                     t        fdt        t!                    D              }d|z
  }||g}g }|D ]  }|j                         }|j                  |u sJ  | j"                  j%                  t	        |            j&                  |j)                         D cg c]   }||z  j+                  t	        |            " c} }|j-                         j%                  t              }|j/                  |      }|j1                  |        |S c c}w )z
    Perform the step in the prime decomposition algorithm where we have determined
    the quotient ``ZK/I`` is _not_ a field, and we want to perform a non-trivial
    factorization of *I* by locating an idempotent element of ``ZK/I``.
    r   )powersr   r   c              3   4   K   | ]  }|   |   z    y wrA   rW   )r   r   r   alpha_powerss     r   r   z,_prime_decomp_split_ideal.<locals>.<genexpr>  s     ;qtLO#;s   )r5   	to_parentmoduler   r   r   quogcdexrl   rm   r   r   repto_listr   r   r   r~   r   r   basis_elementscolumncolumnspacer   append)r^   r!   r   r   r    r"   r   r   r   m1m2UVr   eps1eps2idempsfactorsepsr&   r   r   r   Hr   r   s                           @@r   _prime_decomp_split_idealr     s    88r>ahh"nQ>>
 aDNNE<<1LeRU<8A ]]_FB	AqB	
rBhhrlGAq!6M6Xd1r6"-1199;<=A;U3q6];;Dt8DD\FG MMOxx2~~-AHH1&--464E4E4G0
.0QVOO2a5O)0
  MMO&&r*$$Q'q N0
s   %G>
c                 ,   ||t        d      |t        |       ||j                  j                  }i }||t	        ||      \  }}|j                         }||z  }|| z  dk7  rt        | |      S |xs |j                  |       xs t        ||       }|g}g }	|rv|j                         }
t        |
| |      \  }}|j                  dk(  rt        |
| |      }|	j                  |       n%t        |
| |||      \  }}|j                  ||g       |rv|	S )a  
    Compute the decomposition of rational prime *p* in a number field.

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

    Ordinarily this should be accessed through the
    :py:meth:`~.AlgebraicField.primes_above` method of an
    :py:class:`~.AlgebraicField`.

    Examples
    ========

    >>> from sympy import Poly, QQ
    >>> from sympy.abc import x, theta
    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
    >>> K = QQ.algebraic_field((T, theta))
    >>> print(K.primes_above(2))
    [[ (2, x**2 + 1) e=1, f=1 ], [ (2, (x**2 + 3*x + 2)/2) e=1, f=1 ],
     [ (2, (3*x**2 + 3*x)/2) e=1, f=1 ]]

    Parameters
    ==========

    p : int
        The rational prime whose decomposition is desired.

    T : :py:class:`~.Poly`, optional
        Monic irreducible polynomial defining the number field $K$ in which to
        factor. NOTE: at least one of *T* or *ZK* must be provided.

    ZK : :py:class:`~.Submodule`, optional
        The maximal order for $K$, if already known.
        NOTE: at least one of *T* or *ZK* must be provided.

    dK : int, optional
        The discriminant of the field $K$, if already known.

    radical : :py:class:`~.Submodule`, optional
        The nilradical mod *p* in the integers of $K$, if already known.

    Returns
    =======

    List of :py:class:`~.PrimeIdeal` instances.

    References
    ==========

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

    z)At least one of T or ZK must be provided.)radicalsr   r   )
ValueErrorr   r5   r6   r   discriminantr   getr   popr   r2   r   r   r   extend)r!   r6   r    dKradicalr   dT	f_squaredstackprimesr^   r   r   r   I1I2s                   r   prime_decompr     s'   n 	yRZDEE	~226yIIKKH	zRZ1x0B	
	BbI1}&q"--CaC,<R,CGIEF
IIK+Aq"5133!8+Aq"5AMM!.q!Q2>FBLL"b"  Mr   )NN)NNNN)&rt   sympy.polys.polytoolsr   sympy.polys.domains.finitefieldr   !sympy.polys.domains.rationalfieldr   sympy.polys.domains.integerringr   !sympy.polys.matrices.domainmatrixr   sympy.polys.polyerrorsr   sympy.polys.polyutilsr	   sympy.utilities.decoratorr
   basisr   r   
exceptionsr   modulesr   r   	utilitiesr   r   r   r   rZ   r]   r   r   r   r   r   r   rW   r   r   <module>r     s    % & . 0 . : 1 2 , . & 6 :,0yB! yBx	+\ U UpBJ&2j':'T O Or   