o jgT@sdZddlmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZmZmZmZdd lmZeGd d d e ee Zd dZdS)z1Implementation of :class:`AlgebraicField` class. )AddMul)S)CharacteristicZero)Field) SimpleDomain)ANP)CoercionFailed DomainError NotAlgebraicIsomorphismFailed)publicc@s8eZdZdZeZdZZdZdZ dZ ddddZ dd Z d d Z d d ZddZddddZddZddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Z d2d3Z!d4d5Z"d6d7Z#d8d9Z$d:d;Z%dd?Z'd@dAZ(dBdCZ)dHdEdFZ*dS)IAlgebraicFieldaP#Algebraic number field :ref:`QQ(a)` A :ref:`QQ(a)` domain represents an `algebraic number field`_ `\mathbb{Q}(a)` as a :py:class:`~.Domain` in the domain system (see :ref:`polys-domainsintro`). A :py:class:`~.Poly` created from an expression involving `algebraic numbers`_ will treat the algebraic numbers as generators if the generators argument is not specified. >>> from sympy import Poly, Symbol, sqrt >>> x = Symbol('x') >>> Poly(x**2 + sqrt(2)) Poly(x**2 + (sqrt(2)), x, sqrt(2), domain='ZZ') That is a multivariate polynomial with ``sqrt(2)`` treated as one of the generators (variables). If the generators are explicitly specified then ``sqrt(2)`` will be considered to be a coefficient but by default the :ref:`EX` domain is used. To make a :py:class:`~.Poly` with a :ref:`QQ(a)` domain the argument ``extension=True`` can be given. >>> Poly(x**2 + sqrt(2), x) Poly(x**2 + sqrt(2), x, domain='EX') >>> Poly(x**2 + sqrt(2), x, extension=True) Poly(x**2 + sqrt(2), x, domain='QQ') A generator of the algebraic field extension can also be specified explicitly which is particularly useful if the coefficients are all rational but an extension field is needed (e.g. to factor the polynomial). >>> Poly(x**2 + 1) Poly(x**2 + 1, x, domain='ZZ') >>> Poly(x**2 + 1, extension=sqrt(2)) Poly(x**2 + 1, x, domain='QQ') It is possible to factorise a polynomial over a :ref:`QQ(a)` domain using the ``extension`` argument to :py:func:`~.factor` or by specifying the domain explicitly. >>> from sympy import factor, QQ >>> factor(x**2 - 2) x**2 - 2 >>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2)) >>> factor(x**2 - 2, domain='QQ') (x - sqrt(2))*(x + sqrt(2)) >>> factor(x**2 - 2, domain=QQ.algebraic_field(sqrt(2))) (x - sqrt(2))*(x + sqrt(2)) The ``extension=True`` argument can be used but will only create an extension that contains the coefficients which is usually not enough to factorise the polynomial. >>> p = x**3 + sqrt(2)*x**2 - 2*x - 2*sqrt(2) >>> factor(p) # treats sqrt(2) as a symbol (x + sqrt(2))*(x**2 - 2) >>> factor(p, extension=True) (x - sqrt(2))*(x + sqrt(2))**2 >>> factor(x**2 - 2, extension=True) # all rational coefficients x**2 - 2 It is also possible to use :ref:`QQ(a)` with the :py:func:`~.cancel` and :py:func:`~.gcd` functions. >>> from sympy import cancel, gcd >>> cancel((x**2 - 2)/(x - sqrt(2))) (x**2 - 2)/(x - sqrt(2)) >>> cancel((x**2 - 2)/(x - sqrt(2)), extension=sqrt(2)) x + sqrt(2) >>> gcd(x**2 - 2, x - sqrt(2)) 1 >>> gcd(x**2 - 2, x - sqrt(2), extension=sqrt(2)) x - sqrt(2) When using the domain directly :ref:`QQ(a)` can be used as a constructor to create instances which then support the operations ``+,-,*,**,/``. The :py:meth:`~.Domain.algebraic_field` method is used to construct a particular :ref:`QQ(a)` domain. The :py:meth:`~.Domain.from_sympy` method can be used to create domain elements from normal SymPy expressions. >>> K = QQ.algebraic_field(sqrt(2)) >>> K QQ >>> xk = K.from_sympy(3 + 4*sqrt(2)) >>> xk # doctest: +SKIP ANP([4, 3], [1, 0, -2], QQ) Elements of :ref:`QQ(a)` are instances of :py:class:`~.ANP` which have limited printing support. The raw display shows the internal representation of the element as the list ``[4, 3]`` representing the coefficients of ``1`` and ``sqrt(2)`` for this element in the form ``a * sqrt(2) + b * 1`` where ``a`` and ``b`` are elements of :ref:`QQ`. The minimal polynomial for the generator ``(x**2 - 2)`` is also shown in the :ref:`dup-representation` as the list ``[1, 0, -2]``. We can use :py:meth:`~.Domain.to_sympy` to get a better printed form for the elements and to see the results of operations. >>> xk = K.from_sympy(3 + 4*sqrt(2)) >>> yk = K.from_sympy(2 + 3*sqrt(2)) >>> xk * yk # doctest: +SKIP ANP([17, 30], [1, 0, -2], QQ) >>> K.to_sympy(xk * yk) 17*sqrt(2) + 30 >>> K.to_sympy(xk + yk) 5 + 7*sqrt(2) >>> K.to_sympy(xk ** 2) 24*sqrt(2) + 41 >>> K.to_sympy(xk / yk) sqrt(2)/14 + 9/7 Any expression representing an algebraic number can be used to generate a :ref:`QQ(a)` domain provided its `minimal polynomial`_ can be computed. The function :py:func:`~.minpoly` function is used for this. >>> from sympy import exp, I, pi, minpoly >>> g = exp(2*I*pi/3) >>> g exp(2*I*pi/3) >>> g.is_algebraic True >>> minpoly(g, x) x**2 + x + 1 >>> factor(x**3 - 1, extension=g) (x - 1)*(x - exp(2*I*pi/3))*(x + 1 + exp(2*I*pi/3)) It is also possible to make an algebraic field from multiple extension elements. >>> K = QQ.algebraic_field(sqrt(2), sqrt(3)) >>> K QQ >>> p = x**4 - 5*x**2 + 6 >>> factor(p) (x**2 - 3)*(x**2 - 2) >>> factor(p, domain=K) (x - sqrt(2))*(x + sqrt(2))*(x - sqrt(3))*(x + sqrt(3)) >>> factor(p, extension=[sqrt(2), sqrt(3)]) (x - sqrt(2))*(x + sqrt(2))*(x - sqrt(3))*(x + sqrt(3)) Multiple extension elements are always combined together to make a single `primitive element`_. In the case of ``[sqrt(2), sqrt(3)]`` the primitive element chosen is ``sqrt(2) + sqrt(3)`` which is why the domain displays as ``QQ``. The minimal polynomial for the primitive element is computed using the :py:func:`~.primitive_element` function. >>> from sympy import primitive_element >>> primitive_element([sqrt(2), sqrt(3)], x) (x**4 - 10*x**2 + 1, [1, 1]) >>> minpoly(sqrt(2) + sqrt(3), x) x**4 - 10*x**2 + 1 The extension elements that generate the domain can be accessed from the domain using the :py:attr:`~.ext` and :py:attr:`~.orig_ext` attributes as instances of :py:class:`~.AlgebraicNumber`. The minimal polynomial for the primitive element as a :py:class:`~.DMP` instance is available as :py:attr:`~.mod`. >>> K = QQ.algebraic_field(sqrt(2), sqrt(3)) >>> K QQ >>> K.ext sqrt(2) + sqrt(3) >>> K.orig_ext (sqrt(2), sqrt(3)) >>> K.mod # doctest: +SKIP DMP_Python([1, 0, -10, 0, 1], QQ) The `discriminant`_ of the field can be obtained from the :py:meth:`~.discriminant` method, and an `integral basis`_ from the :py:meth:`~.integral_basis` method. The latter returns a list of :py:class:`~.ANP` instances by default, but can be made to return instances of :py:class:`~.Expr` or :py:class:`~.AlgebraicNumber` by passing a ``fmt`` argument. The maximal order, or ring of integers, of the field can also be obtained from the :py:meth:`~.maximal_order` method, as a :py:class:`~sympy.polys.numberfields.modules.Submodule`. >>> zeta5 = exp(2*I*pi/5) >>> K = QQ.algebraic_field(zeta5) >>> K QQ >>> K.discriminant() 125 >>> K = QQ.algebraic_field(sqrt(5)) >>> K QQ >>> K.integral_basis(fmt='sympy') [1, 1/2 + sqrt(5)/2] >>> K.maximal_order() Submodule[[2, 0], [1, 1]]/2 The factorization of a rational prime into prime ideals of the field is computed by the :py:meth:`~.primes_above` method, which returns a list of :py:class:`~sympy.polys.numberfields.primes.PrimeIdeal` instances. >>> zeta7 = exp(2*I*pi/7) >>> K = QQ.algebraic_field(zeta7) >>> K QQ >>> K.primes_above(11) [(11, _x**3 + 5*_x**2 + 4*_x - 1), (11, _x**3 - 4*_x**2 - 5*_x - 1)] The Galois group of the Galois closure of the field can be computed (when the minimal polynomial of the field is of sufficiently small degree). >>> K.galois_group(by_name=True)[0] S6TransitiveSubgroups.C6 Notes ===== It is not currently possible to generate an algebraic extension over any domain other than :ref:`QQ`. Ideally it would be possible to generate extensions like ``QQ(x)(sqrt(x**2 - 2))``. This is equivalent to the quotient ring ``QQ(x)[y]/(y**2 - x**2 + 2)`` and there are two implementations of this kind of quotient ring/extension in the :py:class:`~.QuotientRing` and :py:class:`~.MonogenicFiniteExtension` classes. Each of those implementations needs some work to make them fully usable though. .. _algebraic number field: https://en.wikipedia.org/wiki/Algebraic_number_field .. _algebraic numbers: https://en.wikipedia.org/wiki/Algebraic_number .. _discriminant: https://en.wikipedia.org/wiki/Discriminant_of_an_algebraic_number_field .. _integral basis: https://en.wikipedia.org/wiki/Algebraic_number_field#Integral_basis .. _minimal polynomial: https://en.wikipedia.org/wiki/Minimal_polynomial_(field_theory) .. _primitive element: https://en.wikipedia.org/wiki/Primitive_element_theorem TFNaliascGs|jstdddlm}t|dkr#t|dtr#|ddd}n|}|dur7t|dkr7t|ddd}||_ |||d|_ |j j j |_ ||_ |_d|_|j f|_|_||d|dg|_|j|j ||_|j|j ||_d|_d|_i|_dS)a Parameters ========== dom : :py:class:`~.Domain` The base field over which this is an extension field. Currently only :ref:`QQ` is accepted. *ext : One or more :py:class:`~.Expr` Generators of the extension. These should be expressions that are algebraic over `\mathbb{Q}`. alias : str, :py:class:`~.Symbol`, None, optional (default=None) If provided, this will be used as the alias symbol for the primitive element of the :py:class:`~.AlgebraicField`. If ``None``, while ``ext`` consists of exactly one :py:class:`~.AlgebraicNumber`, its alias (if any) will be used. z&ground domain must be a rational fieldrto_number_fieldNrr)is_QQr sympy.polys.numberfieldsrlen isinstancetuplegetattrorig_extextminpolyrepmoddomaindomngenssymbolsgensunitdtypezeroto_listone_maximal_order _discriminant_nilradicals_mod_p)selfr!rrrrr.Z/var/www/html/zoom/venv/lib/python3.10/site-packages/sympy/polys/domains/algebraicfield.py__init__s.     zAlgebraicField.__init__cCs|||j|jSN)r&rr(r!)r-elementr.r.r/newFszAlgebraicField.newcCst|jdt|jdS)N<>)strr!rr-r.r.r/__str__IszAlgebraicField.__str__cCst|jj|j|j|jfSr1)hash __class____name__r&r!rr7r.r.r/__hash__LszAlgebraicField.__hash__cCs&t|tr|j|jko|j|jkStS)z0Returns ``True`` if two domains are equivalent. )rrr&rNotImplemented)r-otherr.r.r/__eq__Os zAlgebraicField.__eq__cGs t|jg|jf|Rd|iS)z?Returns an algebraic field, i.e. `\mathbb{Q}(\alpha, \ldots)`. r)rr!r)r-r extensionr.r.r/algebraic_fieldVs zAlgebraicField.algebraic_fieldcCs |j|S)z@Convert ``a`` of ``dtype`` to an :py:class:`~.AlgebraicNumber`. )r field_elementr-ar.r.r/ to_alg_numZ zAlgebraicField.to_alg_numcCst|ds t||_||S)z.Convert ``a`` of ``dtype`` to a SymPy object. _converter)hasattr_make_converterrGrCr.r.r/to_sympy^s   zAlgebraicField.to_sympyc Csnz ||j|gWStyYnwddlm}z ||||jWSttfy6td||fw)z)Convert SymPy's expression to ``dtype``. rrz(%s is not a valid algebraic number in %s) r! from_sympyr rrr native_coeffsr r )r-rDrr.r.r/rKfs   zAlgebraicField.from_sympycC||j||Sz.Convert a Python ``int`` object to ``dtype``. r!convertK1rDK0r.r.r/from_ZZuzAlgebraicField.from_ZZcCrMrNrOrQr.r.r/from_ZZ_pythonyrUzAlgebraicField.from_ZZ_pythoncCrMz3Convert a Python ``Fraction`` object to ``dtype``. rOrQr.r.r/from_QQ}rUzAlgebraicField.from_QQcCrMrWrOrQr.r.r/from_QQ_pythonrUzAlgebraicField.from_QQ_pythoncCrM)z,Convert a GMPY ``mpz`` object to ``dtype``. rOrQr.r.r/ from_ZZ_gmpyrUzAlgebraicField.from_ZZ_gmpycCrM)z,Convert a GMPY ``mpq`` object to ``dtype``. rOrQr.r.r/ from_QQ_gmpyrUzAlgebraicField.from_QQ_gmpycCrM)z.Convert a mpmath ``mpf`` object to ``dtype``. rOrQr.r.r/from_RealFieldrUzAlgebraicField.from_RealFieldcCs td|)z)Returns a ring associated with ``self``. z#there is no ring associated with %s)r r7r.r.r/get_ringrFzAlgebraicField.get_ringcC|j|S)z#Returns True if ``a`` is positive. )r! is_positiveLCrCr.r.r/r_zAlgebraicField.is_positivecCr^)z#Returns True if ``a`` is negative. )r! is_negativer`rCr.r.r/rbrazAlgebraicField.is_negativecCr^)z'Returns True if ``a`` is non-positive. )r!is_nonpositiver`rCr.r.r/rcrazAlgebraicField.is_nonpositivecCr^)z'Returns True if ``a`` is non-negative. )r!is_nonnegativer`rCr.r.r/rdrazAlgebraicField.is_nonnegativecCs|S)zReturns numerator of ``a``. r.rCr.r.r/numerszAlgebraicField.numercCs|jS)zReturns denominator of ``a``. )r)rCr.r.r/denomszAlgebraicField.denomcC|||S)z=Convert AlgebraicField element 'a' to another AlgebraicField rKrJrQr.r.r/from_AlgebraicFieldraz"AlgebraicField.from_AlgebraicFieldcCrg)z4Convert a GaussianInteger element 'a' to ``dtype``. rhrQr.r.r/from_GaussianIntegerRingraz'AlgebraicField.from_GaussianIntegerRingcCrg)z5Convert a GaussianRational element 'a' to ``dtype``. rhrQr.r.r/from_GaussianRationalFieldraz)AlgebraicField.from_GaussianRationalFieldcCs.ddlm}|||jd\}}||_||_dS)Nr) round_two)radicals)sympy.polys.numberfields.basisrlr,r*r+)r-rlZKdKr.r.r/ _do_round_twos  zAlgebraicField._do_round_twocC|jdur ||jS)z Compute the maximal order, or ring of integers, of the field. Returns ======= :py:class:`~sympy.polys.numberfields.modules.Submodule`. See Also ======== integral_basis N)r*rqr7r.r.r/ maximal_orders zAlgebraicField.maximal_ordercsh}|jjd}fddt|D}|dkr%fdd|DS|dkr2fdd|DS|S)as Get an integral basis for the field. Parameters ========== fmt : str, None, optional (default=None) If ``None``, return a list of :py:class:`~.ANP` instances. If ``"sympy"``, convert each element of the list to an :py:class:`~.Expr`, using ``self.to_sympy()``. If ``"alg"``, convert each element of the list to an :py:class:`~.AlgebraicNumber`, using ``self.to_alg_num()``. Examples ======== >>> from sympy import QQ, AlgebraicNumber, sqrt >>> alpha = AlgebraicNumber(sqrt(5), alias='alpha') >>> k = QQ.algebraic_field(alpha) >>> B0 = k.integral_basis() >>> B1 = k.integral_basis(fmt='sympy') >>> B2 = k.integral_basis(fmt='alg') >>> print(B0[1]) # doctest: +SKIP ANP([mpq(1,2), mpq(1,2)], [mpq(1,1), mpq(0,1), mpq(-5,1)], QQ) >>> print(B1[1]) 1/2 + alpha/2 >>> print(B2[1]) alpha/2 + 1/2 In the last two cases we get legible expressions, which print somewhat differently because of the different types involved: >>> print(type(B1[1])) >>> print(type(B2[1])) See Also ======== to_sympy to_alg_num maximal_order rc s.g|]}ttdd|fqSr1)r3listreversedflat).0jMr-r.r/ s.z1AlgebraicField.integral_basis..sympycg|]}|qSr.)rJrwbr7r.r/r{algcr}r.)rEr~r7r.r/r{r)rs QQ_matrixshaperange)r-fmtronBr.ryr/integral_basiss- zAlgebraicField.integral_basiscCrr)z"Get the discriminant of the field.N)r+rqr7r.r.r/ discriminant s zAlgebraicField.discriminantcCs8ddlm}|}|}|j|}|||||dS)z@Compute the prime ideals lying above a given rational prime *p*.r) prime_decomp)rorpradical)sympy.polys.numberfields.primesrrsrr,get)r-prrorpradr.r.r/ primes_aboves  zAlgebraicField.primes_abovecCs|jj|||dS)a Compute the Galois group of the Galois closure of this field. Examples ======== If the field is Galois, the order of the group will equal the degree of the field: >>> from sympy import QQ >>> from sympy.abc import x >>> k = QQ.alg_field_from_poly(x**4 + 1) >>> G, _ = k.galois_group() >>> G.order() 4 If the field is not Galois, then its Galois closure is a proper extension, and the order of the Galois group will be greater than the degree of the field: >>> k = QQ.alg_field_from_poly(x**4 - 2) >>> G, _ = k.galois_group() >>> G.order() 8 See Also ======== sympy.polys.numberfields.galoisgroups.galois_group )by_name max_tries randomize)rminpoly_of_element galois_group)r-rrrr.r.r/rs zAlgebraicField.galois_groupr1)FrF)+r; __module__ __qualname____doc__r r&is_AlgebraicField is_Algebraic is_Numericalhas_assoc_Ringhas_assoc_Fieldr0r3r8r<r?rArErJrKrTrVrXrYrZr[r\r]r_rbrcrdrerfrirjrkrqrsrrrrr.r.r.r/rsPeJ 7rcsj}jjtj|g}tdjD] }| ||d qdd|Dt j fddDfdd}|S)z/Construct the converter to convert back to ExprcSs$g|]}tddt|DqS)css"|] }|dddVqdS)Nr) as_coeff_Mulrwtr.r.r/ Ps z-_make_converter...)dictr make_args)rwrr.r.r/r{P$z#_make_converter..cs g|] fddDqS)csg|] }|tjqSr.)rrZeror)rDtodomr.r/r{Rsz._make_converter...r.)rw)termsr)rDr/r{Rs csZ|dddjjfddD}fdd|D}tddt|D}|S)z!Convert a to Expr using converterNrcs$g|]}tddt|DqS)css|] \}}||VqdSr1r.)rwmijajr.r.r/rZsz@_make_converter..converter...)sumzip)rwmi)air.r/r{Zrz6_make_converter..converter..csg|]}|qSr.r.)rwc)tosympyr.r/r{[scss|] \}}t||VqdSr1r)rwrrDr.r.r/r\sz5_make_converter..converter..)r(r!rJrr)rD coeffs_dom coeffs_sympyres)K algebraicsmatrix)rrr/ converterVs z"_make_converter..converter) ras_exprr!rKrOnerrdegreeappendexpandsetunion)rgenpowersrrr.)rrrrrr/rI;s    rIN)rsympy.core.addrsympy.core.mulrsympy.core.singletonr&sympy.polys.domains.characteristiczerorsympy.polys.domains.fieldr sympy.polys.domains.simpledomainrsympy.polys.polyclassesr sympy.polys.polyerrorsr r r r sympy.utilitiesrrrIr.r.r.r/s"         0