Otj]dZddlmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZd d lmZmZd d lmZd d lmZmZd dlmZmZdZGddeZdZedZddZ dZ!dZ"dZ#dZ$eddZ%dS)zPrime ideals in number fields. )Poly)FF)QQ)ZZ) DomainMatrix)CoercionFailed)IntegerPowerable)public) round_twonilradical_mod_p)StructureError)ModuleEndomorphism find_min_poly) coeff_searchsupplement_a_subspacecd}d}|sd}n-|sd}n|sd}|t||zdS)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.zhave 1 as its first generator.z>> 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 parentTgenr!r"r&r#str numeratorr.denom) r' field_gen just_gensr!r"r&r# alpha_repgenss rreprzPrimeIdeal.reprUsB5!1!5 TVTV;5!Q)44<<>>?? ;??6I6666I$1$$ $$$  K)D))Q))A))))rc*|SN)r?r/s r__repr__zPrimeIdeal.__repr__syy{{rc`|j|jz|j|jzz}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_submodulezPrimeIdeal.as_submodules6n FTW tzDG3 3$#rct|tr*||kStSrA) isinstancerrGNotImplementedr'others r__eq__zPrimeIdeal.__eq__s= eZ ( ( ?$$&&%*<*<*>*>> >rc0||zS)z Convert to a :py:class:`~.Submodule` and add to another :py:class:`~.Submodule`. See Also ======== as_submodule rGrKs r__add__zPrimeIdeal.__add__  ""U**rc0||zS)z Convert to a :py:class:`~.Submodule` and multiply by another :py:class:`~.Submodule` or a rational number. See Also ======== as_submodule rOrKs r__mul__zPrimeIdeal.__mul__rQrc|jSrA)r r/s r _zeroth_powerzPrimeIdeal._zeroth_powers wrc|SrAr/s r _first_powerzPrimeIdeal._first_powers rcj|j&t|j|jg|j|_|jS)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_factorzPrimeIdeal.test_factors2   $ 4TVdj\47 S SD   rc"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 rr%zPrimeIdeal.valuations q$'''rcP||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 )rGreduce_element)r'elts rr`zPrimeIdeal.reduce_elements$2  ""11#666rc|jj|}||}|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 r5element_from_ANPr`to_ANPr'arareds r reduce_ANPzPrimeIdeal.reduce_ANP*s<2gn--a00!!#&&zz||rc|jj|}||}|t t |jS)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 r5element_from_alg_numr` field_elementlistreversedQQ_colflatres rreduce_alg_numzPrimeIdeal.reduce_alg_numGs\2gn11!44!!#&&tHSZ__->->$?$?@@AAArrA)NF)__name__ __module__ __qualname____doc__r(r0propertyr-r?rBrGrMrP__radd__rS__rmul__rUrXr[r%r`rhrprWrrrr)s=@@@@4555 ##X#)*)*)*)*V;;;z + + +H + + +H!!!(((($7776:BBBBBrrct||fd|D}tjd|jft j|}|dddf}| |j | tz|j }|S)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.) cbg|]+}|,S)modulus)inner_endomorphismmatrix).0gEr!s r z(_compute_test_factor..s8HHHa$$Q''..q.99HHHrrNr:)rendomorphism_ringrzerosr2rvstack nullspace transposer5r} convert_torr:)r!r>r matricesBr4betars` @rrZrZes</r222 AHHHHH4HHHH3 Art9bee,,3X>A ad%%''A 99RYb!1!119 B BD Krc|j|j}}|j|j|j}}}|t |jz|z|jz }|t}| }||zdkrdS| } ||z| z} | |zdk} d} ||z}t|D]n} | |dd| f|}|| z}| |}t|D]}||||| f<o||dz |dz fj|zdkrnS||z }| r, |t}n*#t $rYn$wxYw|t}| dz } | S)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.) rTNrr )r!r r2r}r:rrinvrdetr[ranger5 representroelementr)r^Pr!r r2WdADrr#need_complete_testvjcis rr]r]sT CrAdBIrx!qA R)A-7A RA A1uzzq ==??D Q!%%''Aa%1* A Eq  A !AAAqD' ++A IA Q$$&&A1XX  A$!Q$  QUAE\? "Q &! + +  E  ! LL$$!     R  A Q78 Hs>F F&%F&Ncft||j}|j}tfd|Dr|S|A||z}n9t ||j}| }fd|ddD}||z }tt|d} | D]Q} tdt| |D} | ||z} | zdkr| zcSRdS)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.) c3HK|]}|zdVdS)rN)equiv)r~rr!s r z_two_elt_rep..s3 * *AE==   * * * * * *rNcg|]}|zSrWrW)r~omr!s rrz _two_elt_rep..#s % % %RAbD % % %rr c3&K|] \}}||zV dSrArW)r~cibetais rrz_two_elt_rep..'s*;;UBuH;;;;;;rr)rr5r6allzeroabssubmodule_from_gensr}rbasis_element_pullbacksrlensumzipnorm) r>r r!r#Nppbr6omegarsearchrr"r2s ` r _two_elt_reprs[P/r222 B A * * * *T * * ***wwyy z =ABBR++D118<<>>??B  & & ( (E % % % %59 % % %DDLD #d))Q ' 'F ;;c!Tll;;;;; JJqMMR  q5A::19     rc6jj}t|}|\}}t |dkrB|dddkr0t jjdgSfd|DS)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``. rzr rc g|]V\}}tjt|t||WSdomain)rr5element_from_polyrrdegree)r~tr&r r!s rrz+_prime_decomp_easy_case..>sj   1 r1y224"3E3E3EFFxxzz1 & &   r)r5r6r factor_listrrrr2)r!r r6T_barlcfls`` r_prime_decomp_easy_caser1s A A   E    FB 2ww!||1aA 2q").."2"2BD!<<==        rc|j}|j\}}|dkr||t}n8|||tdddf}|jd|krGt |tt}||}| | |}t|fd}| } | sJ| |fS)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). rNr c|z|z SrArW)r4r!s rz._prime_decomp_compute_kernel..ss!Q$(rrz)r}shapeeyerhstackrrrsubmodule_from_matrixcompute_mult_tabdiscard_beforerkernelr) r^r!r rr2rrGphiNs ` r_prime_decomp_compute_kernelrDs"2 A 7DAq  Avv EE!RLL HHQUU1b\\!!!Q$' ( (wqzA~~ !!,,r!uu"5"5 6 6 A A" E E   ##A  A Q 2 2 2 2 3 3C 1 A     a4Krc|jj\}}||z }j|jzfdtjdD}t|||}t |||S)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 c\g|](}dd|fj)S)Nr)r5r:)r~rrr s rrz/_prime_decomp_maximal_ideal..s7 J J J1BIIa1gRXI . . J J Jrr )r#)r}rrrr) r^r!r mr2r#r>r"rs ` @r_prime_decomp_maximal_idealrys~* 8>DAq AA AHA J J J J Jagaj8I8I J J JD r1 * * *E b!UA & &&rc:|j|kr|j|ur |j|usJ|d}|j|usJgt|t }|\}}|dd} || } | | \} } } | dksJttt| | ztj tfdtt!D}d|z }||g}g}|D]}|j|usJ|jt jfd|D}|t}||}|||S)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 )powersrrc3:K|]}||zVdSrArW)r~rr alpha_powerss rrz,_prime_decomp_split_ideal..s0;;qtLO#;;;;;;rc\g|](}|zt)Sr)columnr)r~rr&r!s rrz-_prime_decomp_split_ideal..s>0 0 0 .0QVOO2a55O ) )0 0 0 r)r5 to_parentmodulerrrquogcdexrlrmrrrepto_listrrrr}rrbasis_elements columnspacerappend)r^r!rrr r"rrrm1m2UVreps1eps2idempsfactorsepsrrHrrr&s ` @@@r_prime_decomp_split_idealrs 8r>>ah"nnQ > AaDDNN  E <1    LeRUU<888A]]__FB AqB rBhhrllGAq! 6666 Xd1r6"---199;; < <==A ;;;;;U3q66]];;; ; ;D t8DD\FG MMOOx2~~~~ -AH  1 & & -0 0 0 0 0 464E4E4G4G0 0 0   MMOO & &r * *  $ $Q ' 'q Nrcp||td|t|| |jj}i}||t ||\}}|}||z}||zdkrt ||S|p$||pt||}|g}g} |r| } t| ||\} } | j dkr't| ||} | | n-t| || | |\}}|||g|| 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.) Nz)At least one of T or ZK must be provided.)radicalsrr ) ValueErrorrr5r6r discriminantrgetr poprr2rrrextend)r!r6r dKradicalrdT f_squaredstackprimesr^rrrI1I2s r prime_decomprsdn yRZDEEE ~22666y IKH zRZ1x000B   BbI1}&q"---CaC,>FB LL"b " " " # Mr)NN)NNNN)&rtsympy.polys.polytoolsrsympy.polys.domains.finitefieldr!sympy.polys.domains.rationalfieldrsympy.polys.domains.integerringr!sympy.polys.matrices.domainmatrixrsympy.polys.polyerrorsrsympy.polys.polyutilsr sympy.utilities.decoratorr basisr r exceptionsrmodulesrr utilitiesrrrrrZr]rrrrrrrWrrr s%%&&&&&&......000000......::::::111111222222,,,,,,........&&&&&&66666666::::::::,,,0yByByByByB!yByByBx +++\U U U pBBBBJ&222j''':'''TOOOOOOr