o g@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)FunctionArgumentIndexError 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)sympy.simplify.combsimpr)selfkwargsrexprrr _/var/www/visachat/venv/lib/python3.10/site-packages/sympy/functions/combinatorial/factorials.py_eval_simplifys z$CombinatorialFunction._eval_simplifyN)__name__ __module__ __qualname____doc__r"r r r r!rs rc@seZdZUdZd%ddZgdZgZded<edd Z ed d Z ed d Z ddZ ddZ d&ddZddZddZddZddZddZdd Zd'd#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)r r r!fdiffUs& zfactorial.fdiff)!r'r'r'r.#r1i;?ii i#r4iSi{/i!imiisXiUiP ioikiIi/LiSi}#r5z 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) clsnNprimesprimepq L_product R_productr r r!_swingds.     zfactorial._swingcCs(|dkrdS||dd||S)Nr8r') _recursiverG)r>r?r r r!rHszfactorial._recursivecCst|}|jrj|jr tjS|tjurtjS|jrl|jrtjS|j }|dkrG|j sr?resultibitsr r r!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'r8r)r:r;rr<pow enumerate) rr?rDresr@pwmrByexbsr r r!_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'Fr8) r+ is_integeris_nonnegativeabsis_nonpositiverZerois_primerOmapr:rcr[)rrDr?aqdisprimefcr r r! _eval_Mods2    zfactorial._eval_ModTcKsddlm}||dSNrr(r'r*r()rr? piecewiserr(r r r!_eval_rewrite_as_gammas  z factorial._eval_rewrite_as_gammacKs<ddlm}|jr|jrtddd}|||d|fSdSdS)Nr)ProductrXT)integerr')sympy.concrete.productsrwrgrfr)rr?rrwrXr r r!_eval_rewrite_as_Products   z"factorial._eval_rewrite_as_ProductcC$|jdjr|jdjrdSdSdSNrTr+rfrgrr r r!_eval_is_integerzfactorial._eval_is_integercCr{r|r}r~r r r!_eval_is_positiverzfactorial._eval_is_positivecC(|jd}|jr|jr|djSdSdS)Nrr8r}rxr r r! _eval_is_even   zfactorial._eval_is_evencCr)Nrr.r}rr r r!_eval_is_compositerzfactorial._eval_is_compositecCs|jd}|js |jr dSdSr|)r+rg is_nonintegerrr r r! _eval_is_real s  zfactorial._eval_is_realNrcCsD|jd|}||d}|jrtjS|js||Std|)NrzCannot expand %s around 0) r+as_leading_termsubsrLrrM is_infinitefuncr )rrlogxcdirargarg0r r r!_eval_as_leading_terms   zfactorial._eval_as_leading_termr'TNr)r#r$r%r&r-r9r6__annotations__ classmethodrGrHrZrcrqrvrzrrrrrrr r r r!r$s*  0    ( rc@s eZdZdS)MultiFactorialN)r#r$r%r r r r!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'rr8)rrMrjrR)rr?z1z2rXr r r!_evalGszsubfactorial._evalcCsD|jr|jr|jr||S|tjurtjS|tjur tjSdSdSN)rKrOrgrrNaNrN)r>rr r r!rZTs    zsubfactorial.evalcCr{r|)r+is_oddrgr~r r r!r^rzsubfactorial._eval_is_evencCr{r|r}r~r r r!rbrzsubfactorial._eval_is_integercKs>ddlm}td}tj|t|}t||||d|fS)Nr) summationrX)sympy.concrete.summationsrrr NegativeOner)rrrrrXfr r r!_eval_rewrite_as_factorialfs z'subfactorial._eval_rewrite_as_factorialTcKs^ddlm}ddlm}m}tj|d|t t|||dd||d|dS)Nr)exp)r( lowergammar'rd) &sympy.functions.elementary.exponentialrr*r(rrrrr)rrrurrr(rr r r!rvls , z#subfactorial._eval_rewrite_as_gammacKs ddlm}||ddtjS)Nr) uppergammar'rd)r*rrExp1)rrrrr r r!_eval_rewrite_as_uppergammars z(subfactorial._eval_rewrite_as_uppergammacCr{r|r}r~r r r!_eval_is_nonnegativevrz!subfactorial._eval_is_nonnegativecCr{r|)r+is_evenrgr~r r r! _eval_is_oddzrzsubfactorial._eval_is_oddNr)r#r$r%r&rrrrZrrrrvrrrr r r r!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)Nzrkr r r!rZs zfactorial2.evalcCs@|jd}|jr|jr dS|jr|jrdS|jrdSdSdSdS)NrFT)r+rfrr is_positiverLrr?r r r!rs zfactorial2._eval_is_evencCs6|jd}|jr|djrdS|jr|djSdSdS)Nrr'Tr.)r+rfrgrrr r r!rs   zfactorial2._eval_is_integercCs<|jd}|jr |djS|jr|jrdS|jrdSdSdS)Nrr.FT)r+rrgrrrLrr r r!rs  zfactorial2._eval_is_oddcCs:|jd}|jr|djrdS|jr|ddjSdSdS)Nrr'Tr8)r+rfrgrrrr r r!rs  zfactorial2._eval_is_positiveTcKsrddlm}ddlm}ddlm}d|d||dd|dtt|ddf|dttt|ddfS)Nr)r Piecewisersr8r') (sympy.functions.elementary.miscellaneousr$sympy.functions.elementary.piecewiserr*r(rrr)rr?rurrrr(r r r!rvs   .z!factorial2._eval_rewrite_as_gammaNr) r#r$r%r&rrZrrrrrvr r r r!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||SrshiftrrXrr r!Qz&RisingFactorial.eval..c ||Srr rrr r!rU c|| Srrrrr r!rdc ||Srr rrr r!rhs F)rrrrMrrOrLrrNNegativeInfinityr isinstancergenslenrrrRr:rhrfrPrjr>rrrr rr!rZ5sZ               zRisingFactorial.evalTcKsddlm}ddlm}|s2|dkdkr(tj||d||| |dS|||||S|||||||dkftj||d||| |ddfSNrrrsTr'rrr*r(rrrrrrurrr(r r r!rvps   (*z&RisingFactorial._eval_rewrite_as_gammacKst||d|SNr')FallingFactorialrrrrr r r!!_eval_rewrite_as_FallingFactorial{z1RisingFactorial._eval_rewrite_as_FallingFactorialcKslddlm}|jr2|jr4|t||dt|d|dkftj|t| t| |dfSdSdSNrrr'Trrrfrrrrrrrrr r r!r~s  "$z*RisingFactorial._eval_rewrite_as_factorialcKs$|jrt|t||d|SdSrrfrbinomialrr r r!_eval_rewrite_as_binomialsz)RisingFactorial._eval_rewrite_as_binomialNcKsddlm}|rA||tj}|tjur#|||jddd||S|tjurAtj||d||| |djdddS||jdddSNrrs tractableT)deepr')r*r(rrrNrewriterrrrrlimitvarrr(k_limr r r!_eval_rewrite_as_tractables   2z*RisingFactorial._eval_rewrite_as_tractablecC&t|jdj|jdj|jdjfSNrr'r r+rfrgr~r r r!r z RisingFactorial._eval_is_integerrr) r#r$r%r&rrZrvrrrrrr r r r!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 generatorcrrrrrr r!rrz'FallingFactorial.eval..crrr rrr r!rrrcrrrrrr r!rrcrrr rrr r!r r)rrrrfrrOrLrMrrNrrrrrrrrrRr:rhrr rr!rZsR            zFallingFactorial.evalTcKsddlm}ddlm}|s2|dkdkr$tj|||||| S||d|||dS|||d|||d|dkftj|||||| dfSrrrr r r!rv s    ""z'FallingFactorial._eval_rewrite_as_gammacKst||d|Sr)rfrr r r! _eval_rewrite_as_RisingFactorialrz1FallingFactorial._eval_rewrite_as_RisingFactorialcKs|jr t|t||SdSrrrr r r!rz*FallingFactorial._eval_rewrite_as_binomialcKslddlm}|jr2|jr4|t|t| ||dkftj|t||dt| ddfSdSdSrrrr r r!rs  *z+FallingFactorial._eval_rewrite_as_factorialNcKsddlm}|rA||tj}|tjur)tj||||jddd|| S|tjurA||d|||djdddS||jdddSr)r*r(rrrNrrrrr r r!r%s  * &z+FallingFactorial._eval_rewrite_as_tractablecCrrrr~r r r!r/rz!FallingFactorial._eval_is_integerrr) r#r$r%r&rrZrvrrrrrr r r r!rs>  4   rc@seZdZdZdddZeddZeddZd d Zd d Z d dZ dddZ d ddZ ddZ ddZddZd!ddZdS)"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'r8)r*r)r+rr )rr,r)r?rr r r!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)Nrr8r') rOr:rrjrSr bincoefrR _factorial)rr?rrnrWrXr r r!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)basicrrs)rlrrgrfrLrrMrPrj is_numberrexpandrQr*r()r>r?rrnn_nonnegn_isintr]r(r r r!rZs0   (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)rf.0rr r r! sz%binomial._eval_Mod..z"Integers expected for binomial Modcss|]}|jVqdSr)rOrr r r!rsr'rr8rd)r+anyrallrlr:rhrrjrkrrRr[r;rrr<)rrDr?rrmr]ror@KrnkfrXdfMrBrar r r!rqs|           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+rKrrOrLrrMrPrjrRr)rhintsr?rrWrXr r r!_eval_expand_func3s      zbinomial._eval_expand_funccKst|t|t||Sr)rrr?rrr r r!rNsz#binomial._eval_rewrite_as_factorialTcKs4ddlm}||d||d|||dSrrrt)rr?rrurr(r r r!rvQs (zbinomial._eval_rewrite_as_gammaNcKs|||dS)Nr)rvr)rr?rrrr r r!rUrz#binomial._eval_rewrite_as_tractablecKs|jr t||t|SdSr)rfffrrr r r!rXrz*binomial._eval_rewrite_as_FallingFactorialcCs,|j\}}|jr |jr dS|jdurdSdSNTF)r+rfrr?rr r r!r\s   zbinomial._eval_is_integercCsF|j\}}|jr|jr|js|js|jrdS|jdur!dSdSdSdSr)r+rfrgrPrrr r r!rcs   zbinomial._eval_is_nonnegativercCs"ddlm}||j|||dS)Nrrs)rr)r*r(rr)rrrrr(r r r!rks zbinomial._eval_as_leading_termrrrr)r#r$r%r&r-rrrZrqrrrvrrrrrr r r r!r<s  ]  S  rN)/ __future__r functoolsr sympy.corerrrrsympy.core.cachersympy.core.functionr r r sympy.core.logicr sympy.core.numbersr rrsympy.core.relationalrsympy.external.gmpyrrS sympy.ntheoryrsympy.ntheory.residue_ntheoryrsympy.polys.polytoolsrmathrrrrr;rrrrrrrrrr r r r!s4        vbx"