o GZh@sLddlmZddlmZddlmZmZmZmZddl m Z ddl m Z m Z mZddlmZddlmZmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd l m!Z"m#Z#m$Z%Gddde Z&Gddde&Z!Gddde&Z'Gddde&Z(Gddde&Z)Gddde&Z*Gddde&Z+e*Z,e+Z-Gddde&Z.dS)) annotations)reduce)SsympifyDummyMod)cacheit)DefinedFunctionArgumentIndexError PoleError) fuzzy_and)IntegerpiI)Eq)gmpy)sieve) binomial_mod)Poly) factorialprodsqrtc@seZdZdZddZdS)CombinatorialFunctionz(Base class for combinatorial functions. cKs<ddlm}||}|d}|||d||kr|S|S)Nr)combsimpmeasureratio)Zsympy.simplify.combsimpr)selfkwargsrexprrrW/var/www/auris/lib/python3.10/site-packages/sympy/functions/combinatorial/factorials.py_eval_simplifys z$CombinatorialFunction._eval_simplifyN)__name__ __module__ __qualname____doc__r!rrrr rs rc@seZdZUdZd$ddZgdZgZded<edd Z ed d Z ed d Z ddZ ddZ d%ddZddZddZddZddZddZdd Zd!d"Zd#S)&raImplementation of factorial function over nonnegative integers. By convention (consistent with the gamma function and the binomial coefficients), factorial of a negative integer is complex infinity. The factorial is very important in combinatorics where it gives the number of ways in which `n` objects can be permuted. It also arises in calculus, probability, number theory, etc. There is strict relation of factorial with gamma function. In fact `n! = gamma(n+1)` for nonnegative integers. Rewrite of this kind is very useful in case of combinatorial simplification. Computation of the factorial is done using two algorithms. For small arguments a precomputed look up table is used. However for bigger input algorithm Prime-Swing is used. It is the fastest algorithm known and computes `n!` via prime factorization of special class of numbers, called here the 'Swing Numbers'. Examples ======== >>> from sympy import Symbol, factorial, S >>> n = Symbol('n', integer=True) >>> factorial(0) 1 >>> factorial(7) 5040 >>> factorial(-2) zoo >>> factorial(n) factorial(n) >>> factorial(2*n) factorial(2*n) >>> factorial(S(1)/2) factorial(1/2) See Also ======== factorial2, RisingFactorial, FallingFactorial cCsHddlm}m}|dkr||jdd|d|jddSt||)Nr)gamma polygammar&)'sympy.functions.special.gamma_functionsr'r(argsr )rargindexr'r(rrr fdiffUs& zfactorial.fdiff)!r&r&r&r-#r0i;?ii i#r3iSi{/i!imiisXiUiP ioikiIi/LiSi}#r4z list[int]_small_factorialsc Cs|dkr |j|Stt|g}}td|dD]&}d|}} ||}|dkr5|d@dkr4||9}nnq"|dkr@||qt|d|ddD]}||d@dkr\||qMtt|dd|d}t|}||S)N!r-r&Tr) _small_swingint_sqrtr primerangeappendr) clsnNZprimesprimepqZ L_productZ R_productrrr _swingds.     zfactorial._swingcCs(|dkrdS||dd||S)Nr7r&) _recursiverC)r=r>rrr rDszfactorial._recursivecCst|}|jrj|jr tjS|tjurtjS|jrl|jrtjS|j }|dkrG|j sresultibitsrrr evals4  zfactorial.evalc Csdtt|}}dg|}d}td|dD]2}|dkr1d||}}|r1||7}||}|s'||kr@||||||<q|t||||}qt|D]\} } | dks[| dkr\qO| dkrcdS|t| | ||}qO|S)Nr&r7r)r9r:rr;pow enumerate) rr>rBresr?pwmr@yexbsrrr _facmods( zfactorial._facmodcCs|jd}|jrw|jry|jr{t|}||}|jrtjS|j}|dkr9|r)d|S|dur5|djr7tjSdSdS|jr}|jrt t |||f\}}}|rm|d|krm| |d|}t ||d|}|dri| }||S| ||}||SdSdSdSdSdS)Nrr&Fr7) r* is_integeris_nonnegativeabsZis_nonpositiverZerois_primerKmapr9r^rV)rrBr>aqdisprimeZfcrrr _eval_Mods2    zfactorial._eval_ModTcKsddlm}||dSNrr'r&r)r')rr> piecewiserr'rrr _eval_rewrite_as_gammas  z factorial._eval_rewrite_as_gammacKs<ddlm}|jr|jrtddd}|||d|fSdSdS)Nr)ProductrST)integerr&)Zsympy.concrete.productsrprbrar)rr>rrprSrrr _eval_rewrite_as_Products   z"factorial._eval_rewrite_as_ProductcC$|jdjr|jdjrdSdSdSNrTr*rarbrrrr _eval_is_integerzfactorial._eval_is_integercCrsrtrurvrrr _eval_is_positiverxzfactorial._eval_is_positivecC(|jd}|jr|jr|djSdSdS)Nrr7rurxrrr _eval_is_even   zfactorial._eval_is_evencCrz)Nrr-rur{rrr _eval_is_compositer~zfactorial._eval_is_compositecCs|jd}|js |jr dSdSrt)r*rbZ is_nonintegerr{rrr _eval_is_real s  zfactorial._eval_is_realcCsD|jd|}||d}|jrtjS|js||Std|)NrzCannot expand %s around 0) r*Zas_leading_termsubsrHrrI is_infinitefuncr )rr|logxcdirargZarg0rrr _eval_as_leading_terms   zfactorial._eval_as_leading_termNr&T)r"r#r$r%r,r8r5__annotations__ classmethodrCrDrUr^rjrorrrwryr}rrrrrrr r$s*  0    (  rc@s eZdZdS)MultiFactorialN)r"r#r$rrrr rsrc@sfeZdZdZeeddZeddZddZdd Z d d Z dd dZ ddZ ddZ ddZdS) subfactorialaThe subfactorial counts the derangements of $n$ items and is defined for non-negative integers as: .. math:: !n = \begin{cases} 1 & n = 0 \\ 0 & n = 1 \\ (n-1)(!(n-1) + !(n-2)) & n > 1 \end{cases} It can also be written as ``int(round(n!/exp(1)))`` but the recursive definition with caching is implemented for this function. An interesting analytic expression is the following [2]_ .. math:: !x = \Gamma(x + 1, -1)/e which is valid for non-negative integers `x`. The above formula is not very useful in case of non-integers. `\Gamma(x + 1, -1)` is single-valued only for integral arguments `x`, elsewhere on the positive real axis it has an infinite number of branches none of which are real. References ========== .. [1] https://en.wikipedia.org/wiki/Subfactorial .. [2] https://mathworld.wolfram.com/Subfactorial.html Examples ======== >>> from sympy import subfactorial >>> from sympy.abc import n >>> subfactorial(n + 1) subfactorial(n + 1) >>> subfactorial(5) 44 See Also ======== factorial, uppergamma, sympy.utilities.iterables.generate_derangements cCsN|stjS|dkr tjSd\}}td|dD] }||d||}}q|S)Nr&)r&rr7)rrIrdrN)rr>Zz1Zz2rSrrr _evalGszsubfactorial._evalcCsD|jr|jr|jr||S|tjurtjS|tjur tjSdSdSN)rGrKrbrrNaNrJ)r=rrrr rUTs    zsubfactorial.evalcCrsrt)r*is_oddrbrvrrr r}^rxzsubfactorial._eval_is_evencCrsrtrurvrrr rwbrxzsubfactorial._eval_is_integercKs>ddlm}td}tj|t|}t||||d|fS)Nr) summationrS)Zsympy.concrete.summationsrrr NegativeOner)rrrrrSfrrr _eval_rewrite_as_factorialfs z'subfactorial._eval_rewrite_as_factorialTcKs^ddlm}ddlm}m}tj|d|t t|||dd||d|dS)Nr)exp)r' lowergammar&r_) Z&sympy.functions.elementary.exponentialrr)r'rrrrr)rrrnrrr'rrrr rols , z#subfactorial._eval_rewrite_as_gammacKs ddlm}||ddtjS)Nr) uppergammar&r_)r)rrZExp1)rrrrrrr _eval_rewrite_as_uppergammars z(subfactorial._eval_rewrite_as_uppergammacCrsrtrurvrrr _eval_is_nonnegativevrxz!subfactorial._eval_is_nonnegativecCrsrt)r*is_evenrbrvrrr _eval_is_oddzrxzsubfactorial._eval_is_oddNr)r"r#r$r%rrrrUr}rwrrorrrrrrr rs)     rc@sFeZdZdZeddZddZddZdd Zd d Z dd dZ dS) factorial2aAThe double factorial `n!!`, not to be confused with `(n!)!` The double factorial is defined for nonnegative integers and for odd negative integers as: .. math:: n!! = \begin{cases} 1 & n = 0 \\ n(n-2)(n-4) \cdots 1 & n\ \text{positive odd} \\ n(n-2)(n-4) \cdots 2 & n\ \text{positive even} \\ (n+2)!!/(n+2) & n\ \text{negative odd} \end{cases} References ========== .. [1] https://en.wikipedia.org/wiki/Double_factorial Examples ======== >>> from sympy import factorial2, var >>> n = var('n') >>> n n >>> factorial2(n + 1) factorial2(n + 1) >>> factorial2(5) 15 >>> factorial2(-1) 1 >>> factorial2(-5) 1/3 See Also ======== factorial, RisingFactorial, FallingFactorial cCs~|jr=|js td|jr&|jr|d}d|t|St|t|dS|jr9|tj d|dt| StddS)Nzrrr r}s zfactorial2._eval_is_evencCs6|jd}|jr|djrdS|jr|djSdSdS)Nrr&Tr-)r*rarbrrrrr rws   zfactorial2._eval_is_integercCs<|jd}|jr |djS|jr|jrdS|jrdSdSdS)Nrr-FT)r*rrbrrrHrrrr rs  zfactorial2._eval_is_oddcCs:|jd}|jr|djrdS|jr|ddjSdSdS)Nrr&Tr7)r*rarbrrrrrr rys  zfactorial2._eval_is_positiveTcKsrddlm}ddlm}ddlm}d|d||dd|dtt|ddf|dttt|ddfS)Nr)r Piecewiserlr7r&) Z(sympy.functions.elementary.miscellaneousr$sympy.functions.elementary.piecewiserr)r'rrr)rr>rnrrrr'rrr ros   .z!factorial2._eval_rewrite_as_gammaNr) r"r#r$r%rrUr}rwrryrorrrr rs%     rc@PeZdZdZeddZdddZddZd d Zd d Z dddZ ddZ d S)RisingFactorialap Rising factorial (also called Pochhammer symbol [1]_) is a double valued function arising in concrete mathematics, hypergeometric functions and series expansions. It is defined by: .. math:: \texttt{rf(y, k)} = (x)^k = x \cdot (x+1) \cdots (x+k-1) where `x` can be arbitrary expression and `k` is an integer. For more information check "Concrete mathematics" by Graham, pp. 66 or visit https://mathworld.wolfram.com/RisingFactorial.html page. When `x` is a `~.Poly` instance of degree $\ge 1$ with a single variable, `(x)^k = x(y) \cdot x(y+1) \cdots x(y+k-1)`, where `y` is the variable of `x`. This is as described in [2]_. Examples ======== >>> from sympy import rf, Poly >>> from sympy.abc import x >>> rf(x, 0) 1 >>> rf(1, 5) 120 >>> rf(x, 5) == x*(1 + x)*(2 + x)*(3 + x)*(4 + x) True >>> rf(Poly(x**3, x), 2) Poly(x**6 + 3*x**5 + 3*x**4 + x**3, x, domain='ZZ') Rewriting is complicated unless the relationship between the arguments is known, but rising factorial can be rewritten in terms of gamma, factorial, binomial, and falling factorial. >>> from sympy import Symbol, factorial, ff, binomial, gamma >>> n = Symbol('n', integer=True, positive=True) >>> R = rf(n, n + 2) >>> for i in (rf, ff, factorial, binomial, gamma): ... R.rewrite(i) ... RisingFactorial(n, n + 2) FallingFactorial(2*n + 1, n + 2) factorial(2*n + 1)/factorial(n - 1) binomial(2*n + 1, n + 2)*factorial(n + 2) gamma(2*n + 2)/gamma(n) See Also ======== factorial, factorial2, FallingFactorial References ========== .. [1] https://en.wikipedia.org/wiki/Pochhammer_symbol .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268, 1995. cstt|}tjus|tjurtjStjurt|S|jr|jr'tjS|jrntjur2tjStj ur@|j r=tj StjSt t r`j }t|dkrRtdtfddtt|dStfddtt|dStjurvtjStj ur~tjSt t rj }t|dkrtddtfddtdtt|ddSdtfddtdtt|ddS|jdkrȈjrʈjrtjSdSdSdS) Nr&0rf only defined for polynomials on one generatorc||SrshiftrrSr|rr Qz&RisingFactorial.eval..c ||Srrrrrr rU c|| Srrrrrr rdc ||Srrrrrr rhs F)rrrrIrrKrHrrJNegativeInfinityr isinstancergenslenrrrNr9rcrarLrdr=r|rrrrr rU5sZ               zRisingFactorial.evalTcKsddlm}ddlm}|s2|dkdkr(tj||d||| |dS|||||S|||||||dkftj||d||| |ddfSNrrrlTr&rrr)r'rrrr|rrnrrr'rrr rops   (*z&RisingFactorial._eval_rewrite_as_gammacKst||d|SNr&)FallingFactorialrr|rrrrr !_eval_rewrite_as_FallingFactorial{z1RisingFactorial._eval_rewrite_as_FallingFactorialcKslddlm}|jr2|jr4|t||dt|d|dkftj|t| t| |dfSdSdSNrrr&Trrrarrrrr|rrrrrr r~s  "$z*RisingFactorial._eval_rewrite_as_factorialcKs$|jrt|t||d|SdSrrarbinomialrrrr _eval_rewrite_as_binomialsz)RisingFactorial._eval_rewrite_as_binomialNcKsddlm}|rA||tj}|tjur#|||jddd||S|tjurAtj||d||| |djdddS||jdddSNrrl tractableT)deepr&)r)r'rrrJrewriterrrr|rlimitvarrr'Zk_limrrr _eval_rewrite_as_tractables   2z*RisingFactorial._eval_rewrite_as_tractablecC&t|jdj|jdj|jdjfSNrr&r r*rarbrvrrr rw z RisingFactorial._eval_is_integerrr) r"r#r$r%rrUrorrrrrwrrrr rs=  :   rc@r)ra0 Falling factorial (related to rising factorial) is a double valued function arising in concrete mathematics, hypergeometric functions and series expansions. It is defined by .. math:: \texttt{ff(x, k)} = (x)_k = x \cdot (x-1) \cdots (x-k+1) where `x` can be arbitrary expression and `k` is an integer. For more information check "Concrete mathematics" by Graham, pp. 66 or [1]_. When `x` is a `~.Poly` instance of degree $\ge 1$ with single variable, `(x)_k = x(y) \cdot x(y-1) \cdots x(y-k+1)`, where `y` is the variable of `x`. This is as described in >>> from sympy import ff, Poly, Symbol >>> from sympy.abc import x >>> n = Symbol('n', integer=True) >>> ff(x, 0) 1 >>> ff(5, 5) 120 >>> ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4) True >>> ff(Poly(x**2, x), 2) Poly(x**4 - 2*x**3 + x**2, x, domain='ZZ') >>> ff(n, n) factorial(n) Rewriting is complicated unless the relationship between the arguments is known, but falling factorial can be rewritten in terms of gamma, factorial and binomial and rising factorial. >>> from sympy import factorial, rf, gamma, binomial, Symbol >>> n = Symbol('n', integer=True, positive=True) >>> F = ff(n, n - 2) >>> for i in (rf, ff, factorial, binomial, gamma): ... F.rewrite(i) ... RisingFactorial(3, n - 2) FallingFactorial(n, n - 2) factorial(n)/2 binomial(n, n - 2)*factorial(n - 2) gamma(n + 1)/2 See Also ======== factorial, factorial2, RisingFactorial References ========== .. [1] https://mathworld.wolfram.com/FallingFactorial.html .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268, 1995. cs|tt|}tjus|tjurtjS|jr |kr tS|jr|jr)tjS|jrptj ur4tj Stj urB|j r?tj Stj St t rbj}t|dkrTtdtfddtt|dStfddtt|dStj urxtj Stj urtj St t rj}t|dkrtddtfddtdtt|ddSdtfddtdtt|ddSdS) Nr&z0ff only defined for polynomials on one generatorcrrrrrrr rrz'FallingFactorial.eval..crrrrrrr rrrcrrrrrrr rrcrrrrrrr r r)rrrrarrKrHrIrrJrrrrrrrrrNr9rcrrrr rUsR            zFallingFactorial.evalTcKsddlm}ddlm}|s2|dkdkr$tj|||||| S||d|||dS|||d|||d|dkftj|||||| dfSrrrrrr ro s    ""z'FallingFactorial._eval_rewrite_as_gammacKst||d|Sr)rfrrrr _eval_rewrite_as_RisingFactorialrz1FallingFactorial._eval_rewrite_as_RisingFactorialcKs|jr t|t||SdSrrrrrr rz*FallingFactorial._eval_rewrite_as_binomialcKslddlm}|jr2|jr4|t|t| ||dkftj|t||dt| ddfSdSdSrrrrrr rs  *z+FallingFactorial._eval_rewrite_as_factorialNcKsddlm}|rA||tj}|tjur)tj||||jddd|| S|tjurA||d|||djdddS||jdddSr)r)r'rrrJrrrrrrr r%s  * &z+FallingFactorial._eval_rewrite_as_tractablecCrrrrvrrr rw/rz!FallingFactorial._eval_is_integerrr) r"r#r$r%rrUrorrrrrwrrrr rs>  4   rc@s~eZdZdZdddZeddZeddZd d Zd d Z d dZ dddZ dddZ ddZ ddZddZddZdS) ra Implementation of the binomial coefficient. It can be defined in two ways depending on its desired interpretation: .. math:: \binom{n}{k} = \frac{n!}{k!(n-k)!}\ \text{or}\ \binom{n}{k} = \frac{(n)_k}{k!} First, in a strict combinatorial sense it defines the number of ways we can choose `k` elements from a set of `n` elements. In this case both arguments are nonnegative integers and binomial is computed using an efficient algorithm based on prime factorization. The other definition is generalization for arbitrary `n`, however `k` must also be nonnegative. This case is very useful when evaluating summations. For the sake of convenience, for negative integer `k` this function will return zero no matter the other argument. To expand the binomial when `n` is a symbol, use either ``expand_func()`` or ``expand(func=True)``. The former will keep the polynomial in factored form while the latter will expand the polynomial itself. See examples for details. Examples ======== >>> from sympy import Symbol, Rational, binomial, expand_func >>> n = Symbol('n', integer=True, positive=True) >>> binomial(15, 8) 6435 >>> binomial(n, -1) 0 Rows of Pascal's triangle can be generated with the binomial function: >>> for N in range(8): ... print([binomial(N, i) for i in range(N + 1)]) ... [1] [1, 1] [1, 2, 1] [1, 3, 3, 1] [1, 4, 6, 4, 1] [1, 5, 10, 10, 5, 1] [1, 6, 15, 20, 15, 6, 1] [1, 7, 21, 35, 35, 21, 7, 1] As can a given diagonal, e.g. the 4th diagonal: >>> N = -4 >>> [binomial(N, i) for i in range(1 - N)] [1, -4, 10, -20, 35] >>> binomial(Rational(5, 4), 3) -5/128 >>> binomial(Rational(-5, 4), 3) -195/128 >>> binomial(n, 3) binomial(n, 3) >>> binomial(n, 3).expand(func=True) n**3/6 - n**2/2 + n/3 >>> expand_func(binomial(n, 3)) n*(n - 2)*(n - 1)/6 In many cases, we can also compute binomial coefficients modulo a prime p quickly using Lucas' Theorem [2]_, though we need to include `evaluate=False` to postpone evaluation: >>> from sympy import Mod >>> Mod(binomial(156675, 4433, evaluate=False), 10**5 + 3) 28625 Using a generalisation of Lucas's Theorem given by Granville [3]_, we can extend this to arbitrary n: >>> Mod(binomial(10**18, 10**12, evaluate=False), (10**5 + 3)**2) 3744312326 References ========== .. [1] https://www.johndcook.com/blog/binomial_coefficients/ .. [2] https://en.wikipedia.org/wiki/Lucas%27s_theorem .. [3] Binomial coefficients modulo prime powers, Andrew Granville, Available: https://web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf r&cCsddlm}|dkr$|j\}}t|||d|d|d||dS|dkrB|j\}}t|||d||d|d|dSt||)Nr)r(r&r7)r)r(r*rr )rr+r(r>rrrr r,s     zbinomial.fdiffcCs|jrn|jrO|dkrOt|t|}}||krtjS||dkr$||}tdur0tt||S||d}}td|dD] }|d7}|||}q>t|S||d}}td|dD] }|d7}||9}q]|t|SdS)Nrr7r&) rKr9rrdrOr ZbincoefrN _factorial)rr>rrhrRrSrrr rs(   zbinomial._evalcCstt||f\}}||}|j|j}}|js |s|dur#|jr#tjS|djs3|s.|dur5|djr5|S|jrZ|jsB|rE|rE|jrEtjS|j rX| ||}|rV|j ddS|SdS|durc|rctj S|j rddl m}||d||d|||dSdS)NFr&T)basicrrl)rfrrbrarHrrIrLrdZ is_numberrexpandrMr)r')r=r>rrhZn_nonnegZn_isintrXr'rrr rUs0   (z binomial.evalcCs|j\}}tdd|||fDrtdtdd|||fDrptt||f\}}t|d}}|dkr9tjS|dkrL| |d}|drJdnd}||krStjS|j }t|}|r||kr||}}|si|r|t |||||}||||}}|si|sin||} || kr| |}} d} t d|dD]} | | |} q| } t |d| dD]} | | |} q|| 9}t | d|dD]} || |}q|t | | ||d|9}||;}nt ||kr|dkrt|||}nytt |} td|dD]j}|||kr|||}q||dkrq|| kr,||||kr+|||}q||}}d}}|dkrXt|||||k}||||}}||7}|dks:|dkri|t |||9}||;}qt||SdS) Ncss|]}|jduVqdS)FN)ra.0r|rrr sz%binomial._eval_Mod..z"Integers expected for binomial Modcss|]}|jVqdSr)rKrrrr rsr&rr7r_)r*anyrallrfr9rcrrdrerrNrVr:rrr;)rrBr>rrgrXrir?KrhZkfrSZdfMr@rarrr rjs|           zbinomial._eval_ModcKs|jd}|jr t|jS|jd}||jr||}|jrJ|jr$tjS|jr*tjS|jdd}}t d|dD] }||||9}q9|t |St|jS)z Function to expand binomial(n, k) when m is positive integer Also, n is self.args[0] and k is self.args[1] while using binomial(n, k) rr&) r*rGrrKrHrrIrLrdrNr)rhintsr>rrRrSrrr _eval_expand_func3s      zbinomial._eval_expand_funccKst|t|t||Sr)rrr>rrrrr rNsz#binomial._eval_rewrite_as_factorialTcKs4ddlm}||d||d|||dSrkrm)rr>rrnrr'rrr roQs (zbinomial._eval_rewrite_as_gammaNcKs|||dS)Nr)ror)rr>rrrrrr rUrz#binomial._eval_rewrite_as_tractablecKs|jr t||t|SdSr)raffrrrrr rXrz*binomial._eval_rewrite_as_FallingFactorialcCs,|j\}}|jr |jr dS|jdurdSdSNTF)r*rarr>rrrr rw\s   zbinomial._eval_is_integercCsF|j\}}|jr|jr|js|js|jrdS|jdur!dSdSdSdSr)r*rarbrLrrrrr rcs   zbinomial._eval_is_nonnegativecCs"ddlm}||j|||dS)Nrrl)rr)r)r'rr)rr|rrr'rrr rks zbinomial._eval_as_leading_termrrr)r"r#r$r%r,rrrUrjrrrorrrwrrrrrr r<s  ]  S   rN)/ __future__r functoolsrZ sympy.corerrrrZsympy.core.cacherZsympy.core.functionr r r Zsympy.core.logicr Zsympy.core.numbersr rrZsympy.core.relationalrZsympy.external.gmpyrrOZ sympy.ntheoryrZsympy.ntheory.residue_ntheoryrZsympy.polys.polytoolsrmathrrrrr:rrrrrrrrrrrrr s4        vbx"