o o ha@sXdZddlmZmZmZmZddlmZmZddl m Z ddl m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZGdddeZGdddeZGdddZ d(ddZ!ddZ"d)ddZ#ddZ$d*ddZ%d d!Z&e'd"krdd#l(Z(d$e(j)d%d#vZ*d&e(j)d%d#vZ+e%e*e+d'Z,e-e,d#Sd#S)+a Galois resolvents Each of the functions in ``sympy.polys.numberfields.galoisgroups`` that computes Galois groups for a particular degree $n$ uses resolvents. Given the polynomial $T$ whose Galois group is to be computed, a resolvent is a polynomial $R$ whose roots are defined as functions of the roots of $T$. One way to compute the coefficients of $R$ is by approximating the roots of $T$ to sufficient precision. This module defines a :py:class:`~.Resolvent` class that handles this job, determining the necessary precision, and computing $R$. In some cases, the coefficients of $R$ are symmetric in the roots of $T$, meaning they are equal to fixed functions of the coefficients of $T$. Therefore another approach is to compute these functions once and for all, and record them in a lookup table. This module defines code that can compute such tables. The tables for polynomials $T$ of degrees 4 through 6, produced by this code, are recorded in the resolvent_lookup.py module. )evalffastlog_evalf_with_bounded_errorquad_to_mpmath)symbolsDummy)dup_eval)ZZ)lex)preprocess_roots)Poly)xring)symmetric_polylambdify) MPContext) prec_to_dpsc@ eZdZdS)GaloisGroupExceptionN__name__ __module__ __qualname__rr~/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/polys/numberfields/galois_resolvents.pyr'rc@r)ResolventExceptionNrrrrrr+rrc@sJeZdZdZddZdddZdddZed d Zd d Z dddZ dS) Resolventa If $G$ is a subgroup of the symmetric group $S_n$, $F$ a multivariate polynomial in $\mathbb{Z}[X_1, \ldots, X_n]$, $H$ the stabilizer of $F$ in $G$ (i.e. the permutations $\sigma$ such that $F(X_{\sigma(1)}, \ldots, X_{\sigma(n)}) = F(X_1, \ldots, X_n)$), and $s$ a set of left coset representatives of $H$ in $G$, then the resolvent polynomial $R(Y)$ is the product over $\sigma \in s$ of $Y - F(X_{\sigma(1)}, \ldots, X_{\sigma(n)})$. For example, consider the resolvent for the form $$F = X_0 X_2 + X_1 X_3$$ and the group $G = S_4$. In this case, the stabilizer $H$ is the dihedral group $D4 = < (0123), (02) >$, and a set of representatives of $G/H$ is $\{I, (01), (03)\}$. The resolvent can be constructed as follows: >>> from sympy.combinatorics.permutations import Permutation >>> from sympy.core.symbol import symbols >>> from sympy.polys.numberfields.galoisgroups import Resolvent >>> X = symbols('X0 X1 X2 X3') >>> F = X[0]*X[2] + X[1]*X[3] >>> s = [Permutation([0, 1, 2, 3]), Permutation([1, 0, 2, 3]), ... Permutation([3, 1, 2, 0])] >>> R = Resolvent(F, X, s) This resolvent has three roots, which are the conjugates of ``F`` under the three permutations in ``s``: >>> R.root_lambdas[0](*X) X0*X2 + X1*X3 >>> R.root_lambdas[1](*X) X0*X3 + X1*X2 >>> R.root_lambdas[2](*X) X0*X1 + X2*X3 Resolvents are useful for computing Galois groups. Given a polynomial $T$ of degree $n$, we will use a resolvent $R$ where $Gal(T) \leq G \leq S_n$. We will then want to substitute the roots of $T$ for the variables $X_i$ in $R$, and study things like the discriminant of $R$, and the way $R$ factors over $\mathbb{Q}$. From the symmetry in $R$'s construction, and since $Gal(T) \leq G$, we know from Galois theory that the coefficients of $R$ must lie in $\mathbb{Z}$. This allows us to compute the coefficients of $R$ by approximating the roots of $T$ to sufficient precision, plugging these values in for the variables $X_i$ in the coefficient expressions of $R$, and then simply rounding to the nearest integer. In order to determine a sufficient precision for the roots of $T$, this ``Resolvent`` class imposes certain requirements on the form ``F``. It could be possible to design a different ``Resolvent`` class, that made different precision estimates, and different assumptions about ``F``. ``F`` must be homogeneous, and all terms must have unit coefficient. Furthermore, if $r$ is the number of terms in ``F``, and $t$ the total degree, and if $m$ is the number of conjugates of ``F``, i.e. the number of permutations in ``s``, then we require that $m < r 2^t$. Again, it is not impossible to work with forms ``F`` that violate these assumptions, but this ``Resolvent`` class requires them. Since determining the integer coefficients of the resolvent for a given polynomial $T$ is one of the main problems this class solves, we take some time to explain the precision bounds it uses. The general problem is: Given a multivariate polynomial $P \in \mathbb{Z}[X_1, \ldots, X_n]$, and a bound $M \in \mathbb{R}_+$, compute an $\varepsilon > 0$ such that for any complex numbers $a_1, \ldots, a_n$ with $|a_i| < M$, if the $a_i$ are approximated to within an accuracy of $\varepsilon$ by $b_i$, that is, $|a_i - b_i| < \varepsilon$ for $i = 1, \ldots, n$, then $|P(a_1, \ldots, a_n) - P(b_1, \ldots, b_n)| < 1/2$. In other words, if it is known that $P(a_1, \ldots, a_n) = c$ for some $c \in \mathbb{Z}$, then $P(b_1, \ldots, b_n)$ can be rounded to the nearest integer in order to determine $c$. To derive our error bound, consider the monomial $xyz$. Defining $d_i = b_i - a_i$, our error is $|(a_1 + d_1)(a_2 + d_2)(a_3 + d_3) - a_1 a_2 a_3|$, which is bounded above by $|(M + \varepsilon)^3 - M^3|$. Passing to a general monomial of total degree $t$, this expression is bounded by $M^{t-1}\varepsilon(t + 2^t\varepsilon/M)$ provided $\varepsilon < M$, and by $(t+1)M^{t-1}\varepsilon$ provided $\varepsilon < M/2^t$. But since our goal is to make the error less than $1/2$, we will choose $\varepsilon < 1/(2(t+1)M^{t-1})$, which implies the condition that $\varepsilon < M/2^t$, as long as $M \geq 2$. Passing from the general monomial to the general polynomial is easy, by scaling and summing error bounds. In our specific case, we are given a homogeneous polynomial $F$ of $r$ terms and total degree $t$, all of whose coefficients are $\pm 1$. We are given the $m$ permutations that make the conjugates of $F$, and we want to bound the error in the coefficients of the monic polynomial $R(Y)$ having $F$ and its conjugates as roots (i.e. the resolvent). For $j$ from $1$ to $m$, the coefficient of $Y^{m-j}$ in $R(Y)$ is the $j$th elementary symmetric polynomial in the conjugates of $F$. This sums the products of these conjugates, taken $j$ at a time, in all possible combinations. There are $\binom{m}{j}$ such combinations, and each product of $j$ conjugates of $F$ expands to a sum of $r^j$ terms, each of unit coefficient, and total degree $jt$. An error bound for the $j$th coeff of $R$ is therefore $$\binom{m}{j} r^j (jt + 1) M^{jt - 1} \varepsilon$$ When our goal is to evaluate all the coefficients of $R$, we will want to use the maximum of these error bounds. It is clear that this bound is strictly increasing for $j$ up to the ceiling of $m/2$. After that point, the first factor $\binom{m}{j}$ begins to decrease, while the others continue to increase. However, the binomial coefficient never falls by more than a factor of $1/m$ at a time, so our assumptions that $M \geq 2$ and $m < r 2^t$ are enough to tell us that the constant coefficient of $R$, i.e. that where $j = m$, has the largest error bound. Therefore we can use $$r^m (mt + 1) M^{mt - 1} \varepsilon$$ as our error bound for all the coefficients. Note that this bound is also (more than) adequate to determine whether any of the roots of $R$ is an integer. Each of these roots is a single conjugate of $F$, which contains less error than the trace, i.e. the coefficient of $Y^{m - 1}$. By rounding the roots of $R$ to the nearest integers, we therefore get all the candidates for integer roots of $R$. By plugging these candidates into $R$, we can check whether any of them actually is a root. Note: We take the definition of resolvent from Cohen, but the error bound is ours. References ========== .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*. (Def 6.3.2) c s|_|_|_t|_d|_d|_tD]*\}}t |dkr(t dt |}||jkr:|jdur:t d||_|jd7_q|j|j|j}}}||d|ks\t dt d} t||||d| ||d|_ t||d| |d|_fd d t|jD|_t d } t d d dt|Dd} D]}| | |9} qt| | } fdd | D|_dS)a[ Parameters ========== F : :py:class:`~.Expr` polynomial in the symbols in *X* X : list of :py:class:`~.Symbol` s : list of :py:class:`~.Permutation` representing the cosets of the stabilizer of *F* in some subgroup $G$ of $S_n$, where $n$ is the length of *X*. Nrz.Resolvent class expects forms with unit coeffsz)Resolvent class expects homogeneous formsz!Resolvent class expects m < r*2^tMcs g|] }t|qSrr).0j)FXsrr z&Resolvent.__init__..Y css|]}d|VqdS)RNrr!irrr sz%Resolvent.__init__..csg|]}t|qSrrr!c)r*rrr&s)r#r$r%lenmtrr termsabsrsumrcoeff_prec_funcroot_prec_funcrange root_lambdasjoincoeffs esf_lambdas) selfr#r$r%monomcoeffr2r1r3r r(fCr)r#r*r$r%r__init__s<   *zResolvent.__init__r<cCsFt|d}|dkr |jn|j}td||di\}}}}t|dS)a For a given upper bound *M* on the magnitude of the complex numbers to be plugged in for this resolvent's symbols, compute a sufficient precision for evaluating those complex numbers, such that the coefficients, or the integer roots, of the resolvent can be determined. Parameters ========== M : real number Upper bound on magnitude of the complex numbers to be plugged in. target : str, 'coeffs' or 'roots', default='coeffs' Name the task for which a sufficient precision is desired. This is either determining the coefficients of the resolvent ('coeffs') or determining its possible integer roots ('roots'). The latter may require significantly lower precision. Returns ======= int $m$ such that $2^{-m}$ is a sufficient upper bound on the error in approximating the complex numbers to be plugged in. rr<r)maxr7r8rr)r>r targetrAr3_rrrget_precs  zResolvent.get_precc stt|\}t|jdd}fdd|D}tdd|Dd}|j||d}t|jd}||d}|_ t |fd d|D} fd d| D} | S) a Approximate the roots of a given polynomial *T* to sufficient precision in order to evaluate this resolvent's coefficients, or determine whether the resolvent has an integer root. Parameters ========== T : :py:class:`~.Poly` target : str, 'coeffs' or 'roots', default='coeffs' Set the approximation precision to be sufficient for the desired task, which is either determining the coefficients of the resolvent ('coeffs') or determining its possible integer roots ('roots'). The latter may require significantly lower precision. Returns ======= list of elements of :ref:`CC` F)radicalscs g|] }tt|ddqS)r)r1)rrr!r3)r@rrr&8s z7Resolvent.approximate_roots_of_poly..cs|]}t|VqdSN)r5)r!brrrr-:z6Resolvent.approximate_roots_of_poly..rrEcsg|] }|jddqS)T) return_mpmath) eval_approxrI)drrr&Acsg|] }|qSr)mpcrI)r@ctxrrr&BrR) rr mpfstr all_rootsrDrGr_mpf_precr) r>TrE scaled_rootsapprox0r r1npapprox1r)r@rTrQrapproximate_roots_of_polys   z#Resolvent.approximate_roots_of_polycCs"t|tr|Stt|j|SrK) isinstanceintr contextnint)arrr round_mpfFs zResolvent.round_mpfcs8j|ddfddjD}fddt|DS)a For a given polynomial *T*, round the roots of this resolvent to the nearest integers. Explanation =========== None of the integers returned by this method is guaranteed to be a root of the resolvent; however, if the resolvent has any integer roots (for the given polynomial *T*), then they must be among these. If the coefficients of the resolvent are also desired, then this method should not be used. Instead, use the ``eval_for_poly`` method. This method may be significantly faster than ``eval_for_poly``. Parameters ========== T : :py:class:`~.Poly` Returns ======= dict Keys are the indices of those permutations in ``self.s`` such that the corresponding root did round to a rational integer. Values are :ref:`ZZ`. rootsrNcg|]}|qSrrrIapprox_roots_of_Trrr&rz>Resolvent.round_roots_to_integers_for_poly..cs.i|]\}}|jdkr||jqS)r)rfimagreal)r!r,r3)r>rr ss  z>Resolvent.round_roots_to_integers_for_poly..)r`r: enumerate)r>rZapprox_roots_of_selfr)rjr>r round_roots_to_integers_for_polyQs   z*Resolvent.round_roots_to_integers_for_polyFc s|j|ddfdd|jDfdd|jD}g}|D]}||jdkr0td||||jqd\}}|retD] \}} || jdkrQqDt ||| j} t sd| |}}nqD|||fS) a Compute the integer values of the coefficients of this resolvent, when plugging in the roots of a given polynomial. Parameters ========== T : :py:class:`~.Poly` find_integer_root : ``bool``, default ``False`` If ``True``, then also determine whether the resolvent has an integer root, and return the first one found, along with its index, i.e. the index of the permutation ``self.s[i]`` it corresponds to. Returns ======= Tuple ``(R, a, i)`` ``R`` is this resolvent as a dense univariate polynomial over :ref:`ZZ`, i.e. a list of :ref:`ZZ`. If *find_integer_root* was ``True``, then ``a`` and ``i`` are the first integer root found, and its index, if one exists. Otherwise ``a`` and ``i`` are both ``None``. r<rNcrhrrrIrirrr&rkz+Resolvent.eval_for_poly..crhrrr.)rprrr&rkrz%Got non-integer coeff for resolvent: )NN) r`r:r=rfrlrappendrmrorr ) r>rZfind_integer_rootapprox_coeffs_of_selfr*r/a0i0r,r3rer)rjrpr eval_for_polyys$  zResolvent.eval_for_polyN)r<F) rrr__doc__rCrGr` staticmethodrfrqrwrrrrr/s > "2  (rPcCs@d}d}|D]}|dkr||krd\}}n|d7}||7}q|S)z#Line wrap a polynomial expression. rr)) rrr)textwidthoutcolr/rrrwraps  rcCstddt|DS)zAForm the symbols s1, s2, ..., sn to stand for elem. symm. polys. cSsg|] }d|dqS)r%rrr+rrrr&rRzs_vars..)rr9)r]rrrs_varssrFc sddl}ddl}fdd|D}ddtt|D}g}tdt|dD]a} |r=tdtd| d |j|} t| g|R} |} |rbtd | | d td |j|} t|d | | } |} |rtd | | d |j| | q(g}t |D];\} }|rtdtd| dd |j|} ||}|} | ||rtd | | d |jqg}g}t t}t t |D]k\} }|rtdtd| dd |j|} | \}}}|} |dkrd|ddd|d }t|t|j|}| || | | |rGtt|td | | d |jq||fS)z Compute the coefficients of a resolvent as functions of the coefficients of the associated polynomial. F must be a sparse polynomial. rNc s$g|]}tt|qSrcomposelistzip)r!sigmar#r$rrr&sz6sparse_symmetrize_resolvent_coeffs..cSsg|] }td|qS)r()rr+rrrr&rRrz----z#Computing symmetric poly of degree z...ztook z secondszlambdifying...z(Plugging root forms into elem symm poly z-----zCoeff zGot nonzero remainder z for resolvent (F, X, s) = (, ))timesysr9r0printstdoutflushrrrrrorr symmetrizerrVas_exprr)r#r$r%verboserr root_formsr( coeff_formsr,t0Gt1rBr<rAg symmetrizedsymmetrization_timesssABremrFmsgB_strrrr"sparse_symmetrize_resolvent_coeffss|              rcsJddlm}ddlmtdtt\}}|dddddddddddd}ddddddddddddddddg}dddd}dddddddg}tdtt\}}|dddd dddddddd ddddd dddd dddd ddddd} d d ddd ddd ddd dd d dd g} td tt\} } | |} ddd ddd ddfd d | jD}t|}d gfddt ddD}ddddd d }d gfddt dD}|||f|||f| || f|| |f|| |fdS)z=Define all the resolvents for polys T of degree 4 through 6. r)PGL2F5 Permutationz X0,X1,X2,X3rrzX0,X1,X2,X3,X4zX0,X1,X2,X3,X4,X5c s$h|]}tt|qSrr)r!r%)r$term0rr Bs$z$define_resolvents..csg|] }dd|qS)rrr)r!r]rrrr&DrRz%define_resolvents..cs,g|]}tdD] }d||dqqS)rr)r9)r!r,r"rrrr&Hs ))rr)rr)rrrr)rr) sympy.combinatorics.galoisr sympy.combinatorics.permutationsrr r r elementsr6r9)rR4X4F40s40F41s41R5X5F51s51R6X6Hr4F61s61F62s62r)rr$rrdefine_resolventssh  P        *****      8"0rcst}i}d}d}d}|D]I\}\}} } t|| | |d\} } |t| 7}|dkr2t| }| d}tt| } dddd| Dd d fd d | D||<|rXnqd |dd|dd|dd}|D]\}}|d|d7}|d|d7}|d7}ql|d7}|S)zO Generate the whole lookup table of coeff lambdas, for all resolvents. r)rrrzlambda rcsrJrK)rV)r!vrrrr-grMz)generate_lambda_lookup..:z , cs g|] }dt|dqS)z (r)r)r!rAheadrrr&hr'z*generate_lambda_lookup..z# This table was generated by a call to # `sympy.polys.numberfields.galois_resolvents.generate_lambda_lookup()`. # The entire job took z.2fzs. # Of this, Case (6, 1) took z4s. # The final polynomial of Case (6, 1) alone took zs. resolvent_coeff_lambdas = { z z: [ z r}z ], z} )ritemsrr6rr0r;)r trial_runjobs lambda_lists total_time time_for_61time_for_61_lastkr#r$r%rtimessvtableLrrrgenerate_lambda_lookupUsB    rcsNddlm}|}|||f}|jddtdgfdd|DS)a[ Use the lookup table, to return a resolvent (as dup) for a given polynomial *T*. Parameters ========== T : Poly The polynomial whose resolvent is needed number : int For some degrees, there are multiple resolvents. Use this to indicate which one you want. Returns ======= dup r)resolvent_coeff_lambdasrNcrhrrr.T_coeffsrrr&rkz+get_resolvent_by_lookup..))sympy.polys.numberfields.resolvent_lookuprdegreerepto_listr )rZnumberrrrrrrget_resolvent_by_lookups  r__main__Nz-vrz-t)rr)r{rx)FF).rysympy.core.evalfrrrrsympy.core.symbolrrsympy.polys.densetoolsrsympy.polys.domainsr sympy.polys.orderingsr sympy.polys.polyrootsr sympy.polys.polytoolsr sympy.polys.ringsr sympy.polys.specialpolysrsympy.utilities.lambdifyrmpmathrmpmath.libmp.libmpfr Exceptionrrrrrrrrrrrargvrrrrrrrrs@            N G+