\h_FVSrSSKJr SSKJr SSKJrJr SSKJ r SSK r SSK J r SSK Jr SS KJrJr SS KJr SS KJr SS KJr SS KJr SSKJrJrJrJrJ r J!r!J"r" SSK#J$r$J%r%J&r& SSK'J(r(J)r)J*r* SSK+J+r+ SSK,J-r- SSK.J/r/ SSK0J1r1J2r2 SSK3J4r4 Sr5SXSjr6Sr7Sr8SYSjr9SZSjr:"SS\ 5r;\;"SS 9rS]S#jr?S$r@S%rAS&rBS'rCS(rDS)rES*rFS+rGS,rHSYS-jrIS^S.jrJS_S/jrKS`S0jrLS]S1jrMSaS2jrNSbS3jrOS]S4jrPScS5jrQS6rRS]S7jrSS8rTS9rUS]S:jrVS;rW\-"SS?9S@5rX\-"SAS=S>S?9SB5rY\-"SCS=S>S?9ScSDj5rZScSdSEjjr[SYSFjr\\-"SGS=S>S?9ScSHj5r]\-"SIS=S>S?9SJ5r^\-"SKS=S>S?9SL5r_SMr`SNraSOrbSPrcSQrdSRreSSrfSTrgSUrhSVriSWrjg)ez Integer factorization ) annotations) bisect_left) defaultdict OrderedDict)MutableMappingN)Dict)Mul)RationalInteger) num_digits)Pow)_randint)S) SYMPY_INTSgcdsqrtsqrtremiroot bit_scan1remove)isprimeMERSENNE_PRIME_EXPONENTSis_mersenne_prime)sieve primerange nextprime)digits) deprecated)flatten)as_int filldedent)_ecm_one_factorch^US:Xag[U5m[T5[U4SjT554$)a Return the B-smooth and B-power smooth values of n. The smoothness of n is the largest prime factor of n; the power- smoothness is the largest divisor raised to its multiplicity. Examples ======== >>> from sympy.ntheory.factor_ import smoothness >>> smoothness(2**7*3**2) (3, 128) >>> smoothness(2**4*13) (13, 16) >>> smoothness(2) (2, 2) See Also ======== factorint, smoothness_p r)rrc32># UH oTU-v M g7fN).0mfacss M/var/www/auris/envauris/lib/python3.13/site-packages/sympy/ntheory/factor_.py smoothness..8s3dT!W*ds) factorintmax)nr*s @r+ smoothnessr1s20 Av Q>> from sympy.ntheory.factor_ import smoothness_p, factorint >>> smoothness_p(10431, m=1) (1, [(3, (2, 2, 4)), (19, (1, 5, 5)), (61, (1, 31, 31))]) >>> smoothness_p(10431) (-1, [(3, (2, 2, 2)), (19, (1, 3, 9)), (61, (1, 5, 5))]) >>> smoothness_p(10431, power=1) (-1, [(3, (2, 2, 2)), (61, (1, 5, 5)), (19, (1, 3, 9))]) If visual=True then an annotated string will be returned: >>> print(smoothness_p(21477639576571, visual=1)) p**i=4410317**1 has p-1 B=1787, B-pow=1787 p**i=4869863**1 has p-1 B=2434931, B-pow=2434931 This string can also be generated directly from a factorization dictionary and vice versa: >>> factorint(17*9) {3: 2, 17: 1} >>> smoothness_p(_) 'p**i=3**2 has p-1 B=2, B-pow=2\np**i=17**1 has p-1 B=2, B-pow=16' >>> smoothness_p(_) {3: 2, 17: 1} The table of the output logic is: ====== ====== ======= ======= | Visual ------ ---------------------- Input True False other ====== ====== ======= ======= dict str tuple str str str tuple dict tuple str tuple str n str tuple tuple mul str tuple tuple ====== ====== ======= ======= See Also ======== factorint, smoothness )rr)TFNhasr=rz**TF)visualc>USTUS4$Nrrr')xks r+smoothness_p..sqtAw!or2keyz#p**i=%i**%i has p%+i B=%i, B-pow=%i )bool isinstancestr splitlinessplitint smoothness_ptupler.sortedlistitemsr1typer r insertappendjoin)r0r)powerr6dliivr*rvfMlinesdatr;s @r+rHrH;szf } $!S H ,,.BHHUOA&,,S1!4::4@B@ !CF@BDAqaD!  &"5HAe,, 5 ! !5)  !U %)$**,%79%7TQd:ae+<&= =>@%79678 6-DGSz4I E!ucl 1a :U3ZGH 99U 9B 9s G$1G$ c[U5[U5pUS:Xa[SU-5e[X5S$![Ga SSKJn [ SX455(Gad[ U5n[ U5nUR S:XavURS:Xa#[URUR 5*s$[URUR5[URUR 5- s$URS:Xa"[UR UR 5s$[[URUR5[UR UR 55n[[UR UR5[URUR 55nX4- s$[U[[45(a_[X5(aO[URS[5(a-URSS:a[XRS5s$[SU<SU<35ef=f)a Find the greatest integer m such that p**m divides n. Examples ======== >>> from sympy import multiplicity, Rational >>> [multiplicity(5, n) for n in [8, 5, 25, 125, 250]] [0, 1, 2, 3, 3] >>> multiplicity(3, Rational(1, 9)) -2 Note: when checking for the multiplicity of a number in a large factorial it is most efficient to send it as an unevaluated factorial or to call ``multiplicity_in_factorial`` directly: >>> from sympy.ntheory import multiplicity_in_factorial >>> from sympy import factorial >>> p = factorial(25) >>> n = 2**100 >>> nfac = factorial(n, evaluate=False) >>> multiplicity(p, nfac) 52818775009509558395695966887 >>> _ == multiplicity_in_factorial(p, n) True See Also ======== trailing r factorialc3N# UHn[U[[45v M g7fr&)rCrr )r(rTs r+r,multiplicity..sEfz!j(344fs#%rz!expecting ints or fractions, got z and z9no such integer exists: multiplicity of %s is not-defined)r! ValueError(sympy.functions.combinatorial.factorialsr]allr qp multiplicityminrCrr argsmultiplicity_in_factorialr)rdr0r]likecrosss r+reresBPay&)16 AvTWXYZZ !<?9 PF EqfE E E A Assax33!8(acc222#ACC- QSS!##0FFF#ACC-- acc* acc*, acc* acc*,|#Z1221((166!9g..q Q,Qq : :ANOO1Ps+9BI>> from sympy.ntheory import multiplicity_in_factorial >>> from sympy import factorial >>> multiplicity_in_factorial(2, 3) 1 An instructive use of this is to tell how many trailing zeros a given factorial has. For example, there are 6 in 25!: >>> factorial(25) 15511210043330985984000000 >>> multiplicity_in_factorial(10, 25) 6 For large factorials, it is much faster/feasible to use this function rather than computing the actual factorial: >>> multiplicity_in_factorial(factorial(25), 2**100) 52818775009509558395695966887 See Also ======== multiplicity rz!expecting positive integer got %sz%expecting non-negative integer got %sc3p># UH+upTU-[[TU55- US- -U-v M- g7frN)sumr)r(rUr;r0s r+r,,multiplicity_in_factorial..s5M941AF1aL))QU3Q69s36)r!r`rrGr.rLr/rf)rdr0rWr;rUs ` r+rhrhsT !9fQiDAqAv 1``, else ``False`` (e.g. 1 is not a perfect power). Explanation =========== This is a low-level helper for ``perfect_power``, for internal use. Parameters ========== n : int assume that n is a nonnegative integer next_p : int Assume that n has no factor less than next_p. i.e., all(n % p for p in range(2, next_p)) is True Examples ======== >>> from sympy.ntheory.factor_ import _perfect_power >>> _perfect_power(16) (2, 4) >>> _perfect_power(17) False Frrc^[TU5mTS:XagX1U'[R"U4SjUR555T4$)NrFc36># UHupXT--v M g7fr&r'r(rdegs r+r,/_perfect_power..done..I?tqT)rmathprodrL)r0factorsrvmultis ` r+done_perfect_power..doneDs? 5M 6 yy?w}}??BBr2i@Bc36># UHupXT--v M g7fr&r'rts r+r,!_perfect_power..Srxryr@c36># UHupXT--v M g7fr&r')r(rdru_gs r+r,rs!%E4CDA&'BZ4Cryc36># UHupXT--v M g7fr&r'rts r+r,rs!-I8G./AY8Gry(?{Gz?)_factorint_smallrvaluesrzr{rLrrr bit_lengthrrrJr.keysrGloglog2powabs)r0next_pr|r}r~r)_exacttf_maxrdt prime_iterlogn thresholdbrbrrvs @@r+_perfect_powerr"s6 AvG A EC I~ Wv >q A q5 ! " 6yy?w}}??BBz aL Av !GAGAJAv!t "!QK Q36MQZZ  a%1*!QK  A aKE  a%1* 19}A5)) \\^R " $F F+A! 1``, else ``False`` (e.g. 1 is not a perfect power). A ValueError is raised if ``n`` is not Rational. By default, the base is recursively decomposed and the exponents collected so the largest possible ``e`` is sought. If ``big=False`` then the smallest possible ``e`` (thus prime) will be chosen. If ``factor=True`` then simultaneous factorization of ``n`` is attempted since finding a factor indicates the only possible root for ``n``. This is True by default since only a few small factors will be tested in the course of searching for the perfect power. The use of ``candidates`` is primarily for internal use; if provided, False will be returned if ``n`` cannot be written as a power with one of the candidates as an exponent and factoring (beyond testing for a factor of 2) will not be attempted. Examples ======== >>> from sympy import perfect_power, Rational >>> perfect_power(16) (2, 4) >>> perfect_power(16, big=False) (4, 2) Negative numbers can only have odd perfect powers: >>> perfect_power(-4) False >>> perfect_power(-8) (-2, 3) Rationals are also recognized: >>> perfect_power(Rational(1, 2)**3) (1/2, 3) >>> perfect_power(Rational(-3, 2)**3) (-3/2, 3) Notes ===== To know whether an integer is a perfect power of 2 use >>> is2pow = lambda n: bool(n and not n & (n - 1)) >>> [(i, is2pow(i)) for i in range(5)] [(0, False), (1, True), (2, True), (3, False), (4, True)] It is not necessary to provide ``candidates``. When provided it will be assumed that they are ints. The first one that is larger than the computed maximum possible exponent will signal failure for the routine. >>> perfect_power(3**8, [9]) False >>> perfect_power(3**8, [2, 4, 8]) (3, 8) >>> perfect_power(3**8, [4, 8], big=False) (9, 4) See Also ======== sympy.core.intfunc.integer_nthroot sympy.ntheory.primetest.is_square rT)bigfactorFrrqr@)rcJ>TTU--nTTU--nTRX5U4$)z0Helper to compute final result given an exponent)func)exponentnew_numnew_denden_baseden_expr0num_basenum_exps r+ compute_tuple$perfect_power..compute_tuple)s57h#67G7h#67G66'+X5 5r2c3>># UHnTU-S:XdMUv M g7frNr')r(rdrvs r+r, perfect_power..?s?0qAEQJ0s   )r@rqrc3@># STS--nUv [U5nM7fNr@)r)rVr0s r+_factorsperfect_power.._factorscs) QYH2B) generator) candidatesrg@rr) perfect_powerrrrCr r rdrcrOner/rfrzrnextsetr!rrrGrJrreversedrziprdivisors primefactorsr)!r0rrrpprrue2rdrTodd_candidatesrcqqrvalid_candidatesr max_possible not_square min_possiblerokrfacexactr)rEEe0rrrvrrs!` @@@@@r+rrsL 1u  rtF;BDAbB7AGqAvgajjr1u 1q5)5A:6]?A--*&09Zq5!Z9 A2~F ; qE62a5= !Xz!W'='=ssACC1 6qc:B-/u_AEEBqEM2a5) G% G!!333!!33335070h 6 6 +5 J:a#*Q;!#3!"8?! q8H!":  J#),$%#6F2GA # # HHWg & 6  # # ?Jq!a%0? ?Q_  q Aca  Av 99QL  l;  1 1q/<// 12 Q3!8! A%/ JL1=s< R R ? RRR*R?RR( R8Rc\rSrSrSrSSSjjrSSjrSSjrSSjrSSjr SS jr S r SS jr \ SS j5r\RSS j5rSSSjjrSSjrSSjrSrg) FactorCacheiaTProvides a cache for prime factors. ``factor_cache`` is pre-prepared as an instance of ``FactorCache``, and ``factorint`` internally references it to speed up the factorization of prime factors. While cache is automatically added during the execution of ``factorint``, users can also manually add prime factors independently. >>> from sympy import factor_cache >>> factor_cache[15] = 5 Furthermore, by customizing ``get_external``, it is also possible to use external databases. The following is an example using http://factordb.com . .. code-block:: python import requests from sympy import factor_cache def get_external(self, n: int) -> list[int] | None: res = requests.get("http://factordb.com/api", params={"query": str(n)}) if res.status_code != requests.codes.ok: return None j = res.json() if j.get("status") in ["FF", "P"]: return list(int(p) for p, _ in j.get("factors")) factor_cache.get_external = get_external Be aware that writing this code will trigger internet access to factordb.com when calling ``factorint``. Nc.[5UlXlgr&)r_cachemaxsize)selfrs r+__init__FactorCache.__init__s-8]  r2c,[UR5$r&)lenrrs r+__len__FactorCache.__len__s4;;r2cXR;$r&)rrr0s r+ __contains__FactorCache.__contains__sKKr2cJURU5nUc[US35eU$Nz does not exist.)getKeyErrorrr0rs r+ __getitem__FactorCache.__getitem__s,! >aS 012 2 r2ctSUs=:aU::aO OX-S:Xa[U5(d[USU35e[URR US5U5URU'UR b@[ UR5UR :aURRS5 ggg)Nrrz is not a prime factor of F)rr`r/rrrrpopitemrs r+ __setitem__FactorCache.__setitem__sFaAJ!Ox'A!EF FT[[__Q2F; A << #DKK(84<<(G KK   &)H #r2cXXR;a[US35eURU gr)rrrs r+ __delitem__FactorCache.__delitem__s* KK aS 012 2 KKNr2c6URR5$r&)r__iter__rs r+rFactorCache.__iter__s{{##%%r2c"[5Ulg)zClear the cache N)rrrs r+ cache_clearFactorCache.cache_clears !m r2cUR$)z>Returns the maximum cache size; if ``None``, it is unlimited. )_maxsizers r+rFactorCache.maxsizes}}r2cUbUS::a [S5eXlUbQ[UR5U:a7URR S5 [UR5U:aM6ggg)Nrz/maxsize must be None or a non-negative integer.F)r`rrrr)rvalues r+rrs`  !NO O  dkk"U* ##E*dkk"U* r2cxU[RS::a1[R[[RU5U:XaU$XR;a*URR U5 URU$UR U5=n(a UR X5 URU$U$)zfReturn the prime factor of ``n``. If it does not exist in the cache, return the value of ``default``. r7)r_listrr move_to_end get_externaladd)rr0defaultr|s r+rFactorCache.gets  B {{;u{{A671<  KK # #A &;;q> !''* *7 * HHQ ;;q> !r2cH[USS9HnX0U'[X5upM g)NT)reverse)rJr)rr0r|rd_s r+rFactorCache.adds'.AG! 0) a new ``a`` and ``s`` will be supplied; the ``a`` will be ignored if F was supplied. The sequence of numbers generated by such functions generally have a a lead-up to some number and then loop around back to that number and begin to repeat the sequence, e.g. 1, 2, 3, 4, 5, 3, 4, 5 -- this leader and loop look a bit like the Greek letter rho, and thus the name, 'rho'. For a given function, very different leader-loop values can be obtained so it is a good idea to allow for retries: >>> from sympy.ntheory.generate import cycle_length >>> n = 16843009 >>> F = lambda x:(2048*pow(x, 2, n) + 32767) % n >>> for s in range(5): ... print('loop length = %4i; leader length = %3i' % next(cycle_length(F, s))) ... loop length = 2489; leader length = 43 loop length = 78; leader length = 121 loop length = 1482; leader length = 100 loop length = 1482; leader length = 286 loop length = 1482; leader length = 101 Here is an explicit example where there is a three element leadup to a sequence of 3 numbers (11, 14, 4) that then repeat: >>> x=2 >>> for i in range(9): ... print(x) ... x=(x**2+12)%17 ... 2 16 13 11 14 4 11 14 4 >>> next(cycle_length(lambda x: (x**2+12)%17, 2)) (3, 3) >>> list(cycle_length(lambda x: (x**2+12)%17, 2, values=True)) [2, 16, 13, 11, 14, 4] Instead of checking the differences of all generated values for a gcd with n, only the kth and 2*kth numbers are checked, e.g. 1st and 2nd, 2nd and 4th, 3rd and 6th until it has been detected that the loop has been traversed. Loops may be many thousands of steps long before rho finds a factor or reports failure. If ``max_steps`` is specified, the iteration is cancelled with a failure after the specified number of steps. Examples ======== >>> from sympy import pollard_rho >>> n=16843009 >>> F=lambda x:(2048*pow(x,2,n) + 32767) % n >>> pollard_rho(n, F=F) 257 Use the default setting with a bad value of ``a`` and no retries: >>> pollard_rho(n, a=n-2, retries=0) If retries is > 0 then perhaps the problem will correct itself when new values are generated for a: >>> pollard_rho(n, a=n-2, retries=1) 257 References ========== .. [1] Richard Crandall & Carl Pomerance (2005), "Prime Numbers: A Computational Perspective", Springer, 2nd edition, 229-231 z pollard_rho should receive n > 4rc*>[UST5T-T-$r)r)r:ar0s r+r<pollard_rho..gs3q!Q 0 then if no factor is found after the first attempt, a new ``a`` will be generated randomly (using the ``seed``) and the process repeated. Note: the value of M is lcm(1..B) = reduce(ilcm, range(2, B + 1)). A search is made for factors next to even numbers having a power smoothness less than ``B``. Choosing a larger B increases the likelihood of finding a larger factor but takes longer. Whether a factor of n is found or not depends on ``a`` and the power smoothness of the even number just less than the factor p (hence the name p - 1). Although some discussion of what constitutes a good ``a`` some descriptions are hard to interpret. At the modular.math site referenced below it is stated that if gcd(a**M - 1, n) = N then a**M % q**r is 1 for every prime power divisor of N. But consider the following: >>> from sympy.ntheory.factor_ import smoothness_p, pollard_pm1 >>> n=257*1009 >>> smoothness_p(n) (-1, [(257, (1, 2, 256)), (1009, (1, 7, 16))]) So we should (and can) find a root with B=16: >>> pollard_pm1(n, B=16, a=3) 1009 If we attempt to increase B to 256 we find that it does not work: >>> pollard_pm1(n, B=256) >>> But if the value of ``a`` is changed we find that only multiples of 257 work, e.g.: >>> pollard_pm1(n, B=256, a=257) 1009 Checking different ``a`` values shows that all the ones that did not work had a gcd value not equal to ``n`` but equal to one of the factors: >>> from sympy import ilcm, igcd, factorint, Pow >>> M = 1 >>> for i in range(2, 256): ... M = ilcm(M, i) ... >>> set([igcd(pow(a, M, n) - 1, n) for a in range(2, 256) if ... igcd(pow(a, M, n) - 1, n) != n]) {1009} But does aM % d for every divisor of n give 1? >>> aM = pow(255, M, n) >>> [(d, aM%Pow(*d.args)) for d in factorint(n, visual=True).args] [(257**1, 1), (1009**1, 1)] No, only one of them. So perhaps the principle is that a root will be found for a given value of B provided that: 1) the power smoothness of the p - 1 value next to the root does not exceed B 2) a**M % p != 1 for any of the divisors of n. By trying more than one ``a`` it is possible that one of them will yield a factor. Examples ======== With the default smoothness bound, this number cannot be cracked: >>> from sympy.ntheory import pollard_pm1 >>> pollard_pm1(21477639576571) Increasing the smoothness bound helps: >>> pollard_pm1(21477639576571, B=2000) 4410317 Looking at the smoothness of the factors of this number we find: >>> from sympy.ntheory.factor_ import smoothness_p, factorint >>> print(smoothness_p(21477639576571, visual=1)) p**i=4410317**1 has p-1 B=1787, B-pow=1787 p**i=4869863**1 has p-1 B=2434931, B-pow=2434931 The B and B-pow are the same for the p - 1 factorizations of the divisors because those factorizations had a very large prime factor: >>> factorint(4410317 - 1) {2: 2, 617: 1, 1787: 1} >>> factorint(4869863-1) {2: 1, 2434931: 1} Note that until B reaches the B-pow value of 1787, the number is not cracked; >>> pollard_pm1(21477639576571, B=1786) >>> pollard_pm1(21477639576571, B=1787) 4410317 The B value has to do with the factors of the number next to the divisor, not the divisors themselves. A worst case scenario is that the number next to the factor p has a large prime divisisor or is a perfect power. If these conditions apply then the power-smoothness will be about p/2 or p. The more realistic is that there will be a large prime factor next to p requiring a B value on the order of p/2. Although primes may have been searched for up to this level, the p/2 is a factor of p - 1, something that we do not know. The modular.math reference below states that 15% of numbers in the range of 10**15 to 15**15 + 10**4 are 10**6 power smooth so a B of 10**6 will fail 85% of the time in that range. From 10**8 to 10**8 + 10**3 the percentages are nearly reversed...but in that range the simple trial division is quite fast. References ========== .. [1] Richard Crandall & Carl Pomerance (2005), "Prime Numbers: A Computational Perspective", Springer, 2nd edition, 236-238 .. [2] https://web.archive.org/web/20150716201437/http://modular.math.washington.edu/edu/2007/spring/ent/ent-html/node81.html .. [3] https://www.cs.toronto.edu/~yuvalf/Factorization.pdf rqz*pollard_pm1 should receive n > 3 and B > 2rr@N) rGr`rrrrrzrrr) r0BrrrrrTaMrdrurvs r+ pollard_pm1r%{sB AA1uAEFFtx G 7Q;  !!!QU+ADHHQN#ARQA&B, QN q919q6M Aq1u  r2cU(a[UR55n[U5nUH2nX-S:XdM X:wa U[U'[ X-U5upUS-X'M4 U(aI[ [ U5R[ W555Hn[[XU4-5 M [U5[U5U:g4$)z Helper function for integer factorization. Trial factors ``n` against all integers given in the sequence ``candidates`` and updates the dict ``factors`` in-place. Returns the reduced value of ``n`` and a flag indicating whether any factors were found. rr) rKrr factor_cacherrJr differenceprint factor_msgrG) r|r0rverbosefactors0nfactorsrRr)r;s r+_trialr.s '7|H  5A:v"# Q!&!$DAQGJ  G //H >?A *1:. /@ q63w<8+ ++r2c U(a [S5 US:XaU(a[[5 gXS-:d[U5(a.U[U'SU[ U5'U(a[[5 g[ X5nU(dgUupXS-:d[U 5(aU [U'XU 'OE[ XX4USS9n U R5H%upU(a[[X4-5 X-X 'M' U(a[[5 g)z Helper function for integer factorization. Checks if ``n`` is a prime or a perfect power, and in those cases updates the factorization. zCheck for terminationrTr@Fr+) r) complete_msgrr'rGrr.rLr*)r|r0limit use_trialuse_rhouse_pm1r+rrdbaseexpr*rrus r+_check_terminationr8+s  %&Av  , 19}  QA  ,  q!A ID ai74== Q i'!&(JJLDAjA6)*GJ! l r2z4Trial division with ints [%i ... %i] and fail_max=%iz&Trial division with primes [%i ... %i]z7Pollard's rho with retries %i, max_steps %i and seed %iz2Pollard's p-1 with smoothness bound %i and seed %iz;Elliptic Curve with B1 bound %i, B2 bound %i, num_curves %iz %i ** %iz0Close factors satisfying Fermat condition found.zFactorization is complete.cSnUS-n[X5nUS:a8US-(d[U5nXS'X-n[X5nSnUS:aU"X5$US:aiUS-(dOUS-nSnUS-(d/US-nUS- nUS:Xa[US5upX- nO US-(dM/XS'[X5nSnUS:aU"X5$US -n XJS:aS OSU - - nS n X:aX-(aU S- n OLX-nSnX-(d,X-nUS- nUS:Xa[X5upX- nO X-(dM,XU'S n [X5nUS- nXtS-:aU"X5$X-(aU S- n OLX-nSnX-(d,X-nUS- nUS:Xa[X5upX- nO X-(dM,XU'S n [X5nUS - nXtS-:aU"X5$X:aMU"X5$) a Return the value of n and either a 0 (indicating that factorization up to the limit was complete) or else the next near-prime that would have been tested. Factoring stops if there are fail_max unsuccessful tests in a row. If factors of n were found they will be in the factors dictionary as {factor: multiplicity} and the returned value of n will have had those factors removed. The factors dictionary is modified in-place. c X-U::aX4$US4$)z]return n, d if the sqrt(n) was not reached yet, else n, 0 indicating that factoring is done. rr')r0rRs r+r~_factorint_small..doneks 3!84K!t r2r@rqr rr7rr")rfrr) r|r0r2fail_maxrr~limit2 threshold2r)mmp6failss r+rr]s:AXFQJ z1u! AAJ GAQJ >? " z1u !GAA!eaQ7"1aLEAGA !eeAJQJ ?? " !B !Vrb((F E   : QJE LAAj Q7"1-EAGA jj FOEQJ!   !? " : QJE LAAj Q7"1-EAGA jj FOEQJ!   !? "O  P ?r2c ^1[U[5(a [U5nU(a/[XUX4USSS9m1[ U14Sj[ T155/5n U $0n U(a)[U[ [45(d[XUX4USS9n Or[U[ 5(aFUR5R5V V s0sHup[U 5[U 5_M n n n O[U[5(aUn U (a[U[ [45(a[U R55Hfn [U 5(aMU RU 5n[XX#XFSS9nUR5H upX;aX==X-- ss'MX-X'M" Mh U(d[U5[LaUSLaUSLaU 0:Xa[R $SU ;a#U RS5 [R"/nO/nUR%[ U R55Vs/sHn['USS06PM sn5 [ USS06$[U[[ 45(aU $U(dU(dU(d U(deSS KJn [UU5(a[-UR.S5nUS :a0nS n[0R2"S US -5H-nUS :aSUU-nnUS:waUU- nUU-nUS:waMUUU'M/ U(a0U(a)[ U5Hn [5[6U UU 4-5 M U(a[5[85 U$UR;U5n[-U5nU(a [U5nSnUS:a[U*XUXFSS9nS US'U$U(aUS :a US :Xa0$US 0$US :a"SS 00S S 0SS 0S S 0SS 0S S S.SS 0S S0SS 0/ U$0nU(aP[=U5n[?U5S:a*[5SUSS-S[?U5S - --USS-5 O [5SU5 SnSn[AUU=(d U5nU(a[5[BS UU4-5 [EUUUU5unnU(a0U(a)[ U5Hn [5[6U UU 4-5 M US:Xa,US :aS U[U5'U(a[5[85 U$[FRIU5=n(aC[KUU5up[U5U[U5'[FRIU5=n(aMCU(aFUU:a@U(a [5SU5 [MUXUX4UU5(aU$US :aS U[U5'U$[MUXUX4UU5(aU$[OU5nUS -nUS-S :HUS -- (aUS - nUS -nUU- n[QS5Hn [SU5un!n"U"(dU(a[5[T5 UU!- UU!-4HVn#[U#XX4US9n$U$R5HupURIU S5U -UU 'M [FRWUU$5 MX U(a[5[85 Us $UUS -S -- nUS - nM US U-n&n%U=(d US -n'Sn([AU&U'5n)U(adU(a[5[XU%U)4-5 [0R2"U%U)5n*[[UUU*U5unn+U)nU+(a[MUXUX4UU5(aU$OSn+U&U':a?U(a [5SU'5 US :aS U[U5'U(a[5[85 U$U+(GdU(aU(a[5[\U%U)4-5 [_UU%U)S9n,U,(aRU,US -:d[U,5(aU,/n*O[U,UUUUUUS9n*[[UUU*SS9unn [MUXUX4UU5(aU$U(aU(a[5[`S U%U)4-5 [cUS U%U)S 9n,U,(aRU,US -:d[U,5(aU,/n*O[U,UUUUUUS9n*[[UUU*SS9unn [MUXUX4UU5(aU$U(S - n(U(aU(S:a[eU5S!:aO U&U&S -n&n%GMS"n-S#U--n.Sn/U(a[5[fU-U.U/4-5 [iUU-U.U/U-S$9n0U0(aRU0US -:d[U05(aU0/n*O[U0UUUUUUS9n*[[UUU*SS9unn [MUXUX4UU5(aU$U-S-n-S#U--n.U/S-n/Ms sn n fs snf)%a Given a positive integer ``n``, ``factorint(n)`` returns a dict containing the prime factors of ``n`` as keys and their respective multiplicities as values. For example: >>> from sympy.ntheory import factorint >>> factorint(2000) # 2000 = (2**4) * (5**3) {2: 4, 5: 3} >>> factorint(65537) # This number is prime {65537: 1} For input less than 2, factorint behaves as follows: - ``factorint(1)`` returns the empty factorization, ``{}`` - ``factorint(0)`` returns ``{0:1}`` - ``factorint(-n)`` adds ``-1:1`` to the factors and then factors ``n`` Partial Factorization: If ``limit`` (> 3) is specified, the search is stopped after performing trial division up to (and including) the limit (or taking a corresponding number of rho/p-1 steps). This is useful if one has a large number and only is interested in finding small factors (if any). Note that setting a limit does not prevent larger factors from being found early; it simply means that the largest factor may be composite. Since checking for perfect power is relatively cheap, it is done regardless of the limit setting. This number, for example, has two small factors and a huge semi-prime factor that cannot be reduced easily: >>> from sympy.ntheory import isprime >>> a = 1407633717262338957430697921446883 >>> f = factorint(a, limit=10000) >>> f == {991: 1, int(202916782076162456022877024859): 1, 7: 1} True >>> isprime(max(f)) False This number has a small factor and a residual perfect power whose base is greater than the limit: >>> factorint(3*101**7, limit=5) {3: 1, 101: 7} List of Factors: If ``multiple`` is set to ``True`` then a list containing the prime factors including multiplicities is returned. >>> factorint(24, multiple=True) [2, 2, 2, 3] Visual Factorization: If ``visual`` is set to ``True``, then it will return a visual factorization of the integer. For example: >>> from sympy import pprint >>> pprint(factorint(4200, visual=True)) 3 1 2 1 2 *3 *5 *7 Note that this is achieved by using the evaluate=False flag in Mul and Pow. If you do other manipulations with an expression where evaluate=False, it may evaluate. Therefore, you should use the visual option only for visualization, and use the normal dictionary returned by visual=False if you want to perform operations on the factors. You can easily switch between the two forms by sending them back to factorint: >>> from sympy import Mul >>> regular = factorint(1764); regular {2: 2, 3: 2, 7: 2} >>> pprint(factorint(regular)) 2 2 2 2 *3 *7 >>> visual = factorint(1764, visual=True); pprint(visual) 2 2 2 2 *3 *7 >>> print(factorint(visual)) {2: 2, 3: 2, 7: 2} If you want to send a number to be factored in a partially factored form you can do so with a dictionary or unevaluated expression: >>> factorint(factorint({4: 2, 12: 3})) # twice to toggle to dict form {2: 10, 3: 3} >>> factorint(Mul(4, 12, evaluate=False)) {2: 4, 3: 1} The table of the output logic is: ====== ====== ======= ======= Visual ------ ---------------------- Input True False other ====== ====== ======= ======= dict mul dict mul n mul dict dict mul mul dict dict ====== ====== ======= ======= Notes ===== Algorithm: The function switches between multiple algorithms. Trial division quickly finds small factors (of the order 1-5 digits), and finds all large factors if given enough time. The Pollard rho and p-1 algorithms are used to find large factors ahead of time; they will often find factors of the order of 10 digits within a few seconds: >>> factors = factorint(12345678910111213141516) >>> for base, exp in sorted(factors.items()): ... print('%s %s' % (base, exp)) ... 2 2 2507191691 1 1231026625769 1 Any of these methods can optionally be disabled with the following boolean parameters: - ``use_trial``: Toggle use of trial division - ``use_rho``: Toggle use of Pollard's rho method - ``use_pm1``: Toggle use of Pollard's p-1 method ``factorint`` also periodically checks if the remaining part is a prime number or a perfect power, and in those cases stops. For unevaluated factorial, it uses Legendre's formula(theorem). If ``verbose`` is set to ``True``, detailed progress is printed. See Also ======== smoothness, smoothness_p, divisors Fr2r3r4r5r+r6multiplec3~># UH2nTUS:a U/TU-O[RU- /TU*-v M4 g7frrr)r(rdrs r+r,factorint.._sF5(31+.a&1*1#A,1557)c!fW:MM(3s:=)r2r3r4r5r+r6Tr7evaluaterr\r=r@rrrqr)r@rqr2z Factoring %sNz..(%i other digits).. FactoringiiXzExceeded limit:r"r2r3r4r5r+)r#r)r2r3r4r5use_ecmr+r0)rrrri'd)r)5rCrdictr.rnrJr as_powers_dictrLrGrKrrpoprMrr NegativeOneextendr rar]r!rgrrr)r*r1rrDrrf trial_int_msgrr'rrr8isqrtrr fermat_msgr trial_msgr.pm1_msgr%rho_msgr r ecm_msgr#)2r0r2r3r4r5rQr+r6rH factorlist factordictr;rUr?rurRrgrTr]r:r|r)rdrcsnsmallr@rsqrt_nra2b2rrfermatrr*lowhigh_limit iterationhigh_ps found_trialcB1B2 num_curvesrrs2 @r+r.r.s j!T G)#*#*55J5(.s 568: J jS$K00q'.'.u>  As      $ $ &( &*.c!fc!fn & ( At   jS$K00 )*Cs||s#A#i")5JA ?MQS(M$%CJM " +$q'T/$%  55L   NN2 MM?DD $Z%5%5%78:8!,e,8: ;D)5)) Ac{ # # 7g5 5B!Y 166!9  7GA%%aQ/q5a1fqAq&Qaq& 07A*71:67)l#Nq Aq A E  1u Be'U<   6I1v RAQFQFQFQF! q!fq!fq!f6679 9G V r7R< .2bq6))SWr\:;=?WE F +q ! EH u~ &E mq%223 !UH=IAv7A *71:. /! { q5GCFO  , " "! "a|a&A" "! "  %  #U + gq% A AN q5GCFO'1Y!GV==1XF A A q1u Q AB aB 1XBK 6j!!eQU^ %)0)02!JJLDA!(Q!2Q!6GAJ)  D) $l#N q1ul Q!(&Cov "FI D&! i3,./!!#u-B#GQG>> from sympy import factorrat, S >>> factorrat(S(8)/9) # 8/9 = (2**3) * (3**-2) {2: 3, 3: -2} >>> factorrat(S(-1)/987) # -1/789 = -1 * (3**-1) * (7**-1) * (47**-1) {-1: 1, 3: -1, 7: -1, 47: -1} Please see the docstring for ``factorint`` for detailed explanations and examples of the following keywords: - ``limit``: Integer limit up to which trial division is done - ``use_trial``: Toggle use of trial division - ``use_rho``: Toggle use of Pollard's rho method - ``use_pm1``: Toggle use of Pollard's p-1 method - ``verbose``: Toggle detailed printing of progress - ``multiple``: Toggle returning a list of factors or dict - ``visual``: Toggle product form of output FrGc3># UH4upTUS:a U/TU-O[RU- /TU*-v M6 g7frrJ)r(rdrrs r+r,factorrat..sOI,H41+.a&1*1#A,1557)c!fW:MM,Hs.s1;?7Q;JNaJG=>tAwYJGr2r>rPrr7rL) factorratrnrJrLr.rdcopyrrGrcrrSrUrrVrWr r )ratr2r3r4r5r+r6rHr_rWrdrurgrTrs @r+rxrxusk0I!!%%AI+1#))+=G,HIKM N #%%u!! ##'46 CA#%%u$-")")") +,157 3   3 1vza1f aD Aw 7 EE"IMM?DD $QWWY/1/!,e,/1 2D)5))1s1Ec [U5nURSSXS.5 [[SSU0UD6R 55nUSSVs/sH oUS;dM UPM nnU(a[ US5(aXdS/- nU$s snf)aReturn a sorted list of n's prime factors, ignoring multiplicity and any composite factor that remains if the limit was set too low for complete factorization. Unlike factorint(), primefactors() does not return -1 or 0. Parameters ========== n : integer limit, verbose, **kwargs : Additional keyword arguments to be passed to ``factorint``. Since ``kwargs`` is new in version 1.13, ``limit`` and ``verbose`` are retained for compatibility purposes. Returns ======= list(int) : List of prime numbers dividing ``n`` Examples ======== >>> from sympy.ntheory import primefactors, factorint, isprime >>> primefactors(6) [2, 3] >>> primefactors(-5) [5] >>> sorted(factorint(123456).items()) [(2, 6), (3, 1), (643, 1)] >>> primefactors(123456) [2, 3, 643] >>> sorted(factorint(10000000001, limit=200).items()) [(101, 1), (99009901, 1)] >>> isprime(99009901) False >>> primefactors(10000000001, limit=300) [101] See Also ======== factorint, divisors NF)r6rHr2r+r0r7)r7rrr')rGupdaterJr.rr)r0r2r+kwargsr|rWrs r+rrs^ AA MMTu!78Y--f-2245GDRM9Mqj%8MA9772;'' bk] H :s BBc# ^^^^# TS::aU(d T(aSv g[T5m[TR55mSUUU4SjjmU(aU4SjT"55ShvN gT"5ShvN gNN7f)zHelper function for divisors which generates the divisors. Parameters ========== n : int a nonnegative integer proper: bool If `True`, returns the generator that outputs only the proper divisor (i.e., excluding n). rNc3>^# U[T5:XaSv gS/m[TTU5HnTRTSTU-5 M U4SjT"US-55ShvN gN7f)Nrr7c3@># UHnTH o"U-v M M g7fr&r')r(rcrdpowss r+r,-_divisors..rec_gen..sD~!t!At~r)rrrO)r0rrr`rlrec_gens @r+r_divisors..rec_gensd B<G3D:be,- DHr!u,-.Dwq1u~D D DsA"A.&A,'A.c36># UHoT:wdM Uv M g7fr&r')r(rdr0s r+r,_divisors.. s3y!FAAys  )r)r.rJr)r0properr`rlrs` @@@r+ _divisorsrsj Av!G1J  ! "BEE3wy3339 4s$A#B)A?*B9B:BBcf[[[U55U5nU(aU$[U5$)a Return all divisors of n sorted from 1..n by default. If generator is ``True`` an unordered generator is returned. The number of divisors of n can be quite large if there are many prime factors (counting repeated factors). If only the number of factors is desired use divisor_count(n). Examples ======== >>> from sympy import divisors, divisor_count >>> divisors(24) [1, 2, 3, 4, 6, 8, 12, 24] >>> divisor_count(24) 8 >>> list(divisors(120, generator=True)) [1, 2, 4, 8, 3, 6, 12, 24, 5, 10, 20, 40, 15, 30, 60, 120] Notes ===== This is a slightly modified version of Tim Peters referenced at: https://stackoverflow.com/questions/1010381/python-factorization See Also ======== primefactors, factorint, divisor_count )rr!rrJ)r0rrrVs r+rrs*@ 6#a&>6 *B2*r *r2c U(dgUS:wa[X5upU(agUS:Xag[[U5R5VVs/sHupEUS:dM US-PM snn6nU(a U(aUS-nU$s snnf)a Return the number of divisors of ``n``. If ``modulus`` is not 1 then only those that are divisible by ``modulus`` are counted. If ``proper`` is True then the divisor of ``n`` will not be counted. Examples ======== >>> from sympy import divisor_count >>> divisor_count(6) 4 >>> divisor_count(6, 2) 2 >>> divisor_count(6, proper=True) 3 See Also ======== factorint, divisors, totient, proper_divisor_count rr)divmodr r.rL)r0modulusrrr;rUs r+ divisor_countr4s{0  Aa! Av ! 2 2 4 > 4Aea!e 4 >?AV Q H?s A?  A? c[XSS9$)a Return all divisors of n except n, sorted by default. If generator is ``True`` an unordered generator is returned. Examples ======== >>> from sympy import proper_divisors, proper_divisor_count >>> proper_divisors(24) [1, 2, 3, 4, 6, 8, 12] >>> proper_divisor_count(24) 7 >>> list(proper_divisors(120, generator=True)) [1, 2, 4, 8, 3, 6, 12, 24, 5, 10, 20, 40, 15, 30, 60] See Also ======== factorint, divisors, proper_divisor_count T)rr)r)r0rs r+proper_divisorsrZs, A4 88r2c[XSS9$)z Return the number of proper divisors of ``n``. Examples ======== >>> from sympy import proper_divisor_count >>> proper_divisor_count(6) 3 >>> proper_divisor_count(6, modulus=2) 1 See Also ======== divisors, proper_divisors, divisor_count T)rr)r)r0rs r+proper_divisor_countrss& D 99r2c#L# US::a US:XaSv g[U5R5VVs/sH upX-PM nnn[S[U5-5H?nSn[UR 55HnUS-(aXSU-nUS-nM Uv MA gs snnf7f)zHelper function for udivisors which generates the unitary divisors. Parameters ========== n : int a nonnegative integer rNr@)r.rLrrr)r0rdru factorpowsrTrRr;s r+ _udivisorsrs Av 6G#,Q<#5#5#78#741!$#7J81c*o% & q||~&A1u]" !GA' '9s.B$BA$B$cd[[[U555nU(aU$[U5$)a Return all unitary divisors of n sorted from 1..n by default. If generator is ``True`` an unordered generator is returned. The number of unitary divisors of n can be quite large if there are many prime factors. If only the number of unitary divisors is desired use udivisor_count(n). Examples ======== >>> from sympy.ntheory.factor_ import udivisors, udivisor_count >>> udivisors(15) [1, 3, 5, 15] >>> udivisor_count(15) 4 >>> sorted(udivisors(120, generator=True)) [1, 3, 5, 8, 15, 24, 40, 120] See Also ======== primefactors, factorint, divisors, divisor_count, udivisor_count References ========== .. [1] https://en.wikipedia.org/wiki/Unitary_divisor .. [2] https://mathworld.wolfram.com/UnitaryDivisor.html )rr!rrJr0rrVs r+ udivisorsrs(B F3q6N #B2*r *r2cxUS:XagS[[U5Vs/sH oS:dM UPM sn5-$s snf)a] Return the number of unitary divisors of ``n``. Parameters ========== n : integer Examples ======== >>> from sympy.ntheory.factor_ import udivisor_count >>> udivisor_count(120) 8 See Also ======== factorint, divisors, udivisors, divisor_count, totient References ========== .. [1] https://mathworld.wolfram.com/UnitaryDivisorFunction.html rr@r)rr.)r0rds r+udivisor_countrs88 Av cil4l!e1l45 554s 7 7 c#X# US::ag[U5HnSU-nX:dMX-(dMUv M [SU-S- 5H$nXs=:aS:dMO MX-(dM Uv M& [SU-S-5H$nXs=:aS:dMO MX-(dM Uv M& g7f)z~Helper function for antidivisors which generates the antidivisors. Parameters ========== n : int a nonnegative integer r@Nr)r)r0rRys r+ _antidivisorsrs Av q\ aC 5QUUGqs1u  :A::!%%Gqs1u  :A::!%%Gs'B*B*&B* B*(&B* B*! B*cd[[[U555nU(aU$[U5$)a2 Return all antidivisors of n sorted from 1..n by default. Antidivisors [1]_ of n are numbers that do not divide n by the largest possible margin. If generator is True an unordered generator is returned. Examples ======== >>> from sympy.ntheory.factor_ import antidivisors >>> antidivisors(24) [7, 16] >>> sorted(antidivisors(128, generator=True)) [3, 5, 15, 17, 51, 85] See Also ======== primefactors, factorint, divisors, divisor_count, antidivisor_count References ========== .. [1] definition is described in https://oeis.org/A066272/a066272a.html )rr!rrJrs r+ antidivisorsrs'8 vc!f~ &B2*r *r2c[[U55nUS::ag[SU-S- 5[SU-S-5-[U5-[US5- S- $)an Return the number of antidivisors [1]_ of ``n``. Parameters ========== n : integer Examples ======== >>> from sympy.ntheory.factor_ import antidivisor_count >>> antidivisor_count(13) 4 >>> antidivisor_count(27) 5 See Also ======== factorint, divisors, antidivisors, divisor_count, totient References ========== .. [1] formula from https://oeis.org/A066272 r@rrr)r!rrr0s r+antidivisor_countr"sf< s1vAAv 1q !M!A#'$: :a (A. /12 33r2zfThe `sympy.ntheory.factor_.totient` has been moved to `sympy.functions.combinatorial.numbers.totient`.z1.13z%deprecated-ntheory-symbolic-functions)deprecated_since_versionactive_deprecations_targetcSSKJn U"U5$)a  Calculate the Euler totient function phi(n) .. deprecated:: 1.13 The ``totient`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.totient` instead. See its documentation for more information. See :ref:`deprecated-ntheory-symbolic-functions` for details. ``totient(n)`` or `\phi(n)` is the number of positive integers `\leq` n that are relatively prime to n. Parameters ========== n : integer Examples ======== >>> from sympy.functions.combinatorial.numbers import totient >>> totient(1) 1 >>> totient(25) 20 >>> totient(45) == totient(5)*totient(9) True See Also ======== divisor_count References ========== .. [1] https://en.wikipedia.org/wiki/Euler%27s_totient_function .. [2] https://mathworld.wolfram.com/TotientFunction.html r)totient)%sympy.functions.combinatorial.numbersr)r0_totients r+rrFsZJ A;r2zvThe `sympy.ntheory.factor_.reduced_totient` has been moved to `sympy.functions.combinatorial.numbers.reduced_totient`.cSSKJn U"U5$)a Calculate the Carmichael reduced totient function lambda(n) .. deprecated:: 1.13 The ``reduced_totient`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.reduced_totient` instead. See its documentation for more information. See :ref:`deprecated-ntheory-symbolic-functions` for details. ``reduced_totient(n)`` or `\lambda(n)` is the smallest m > 0 such that `k^m \equiv 1 \mod n` for all k relatively prime to n. Examples ======== >>> from sympy.functions.combinatorial.numbers import reduced_totient >>> reduced_totient(1) 1 >>> reduced_totient(8) 2 >>> reduced_totient(30) 4 See Also ======== totient References ========== .. [1] https://en.wikipedia.org/wiki/Carmichael_function .. [2] https://mathworld.wolfram.com/CarmichaelFunction.html r)reduced_totient)rr)r0_reduced_totients r+rrwsPZ A r2zrThe `sympy.ntheory.factor_.divisor_sigma` has been moved to `sympy.functions.combinatorial.numbers.divisor_sigma`.cSSKJn U"X5$)a Calculate the divisor function `\sigma_k(n)` for positive integer n .. deprecated:: 1.13 The ``divisor_sigma`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.divisor_sigma` instead. See its documentation for more information. See :ref:`deprecated-ntheory-symbolic-functions` for details. ``divisor_sigma(n, k)`` is equal to ``sum([x**k for x in divisors(n)])`` If n's prime factorization is: .. math :: n = \prod_{i=1}^\omega p_i^{m_i}, then .. math :: \sigma_k(n) = \prod_{i=1}^\omega (1+p_i^k+p_i^{2k}+\cdots + p_i^{m_ik}). Parameters ========== n : integer k : integer, optional power of divisors in the sum for k = 0, 1: ``divisor_sigma(n, 0)`` is equal to ``divisor_count(n)`` ``divisor_sigma(n, 1)`` is equal to ``sum(divisors(n))`` Default for k is 1. Examples ======== >>> from sympy.functions.combinatorial.numbers import divisor_sigma >>> divisor_sigma(18, 0) 6 >>> divisor_sigma(39, 1) 56 >>> divisor_sigma(12, 2) 210 >>> divisor_sigma(37) 38 See Also ======== divisor_count, totient, divisors, factorint References ========== .. [1] https://en.wikipedia.org/wiki/Divisor_function r) divisor_sigma)rr)r0r;func_divisor_sigmas r+rrsBZ a ##r2c^TS:Xa4[R"S[U5R555$[R"U4Sj[U5R 555$)zCalculate the divisor function `\sigma_k(n)` for positive integer n Parameters ========== n : int positive integer k : int nonnegative integer See Also ======== sympy.functions.combinatorial.numbers.divisor_sigma rc3*# UH oS-v M g7frmr')r(rus r+r,!_divisor_sigma..s>(=1Q(=sc3V># UHupUTUS---S- UT-S- -v M g7frmr')r(rdrur;s r+r,rs3WBV$!a!QU)nq(AqD1H5BVs&))rzr{r.rrL)r0r;s `r+_divisor_sigmarsP" Avyy> ! (;(;(=>>> 99W)A,BTBTBVW WWr2c[U5n[U5nUS::a [S5eUS::a [S5eSn[U5R5Hup4X#XA---nM U$)a= Calculate core(n, t) = `core_t(n)` of a positive integer n ``core_2(n)`` is equal to the squarefree part of n If n's prime factorization is: .. math :: n = \prod_{i=1}^\omega p_i^{m_i}, then .. math :: core_t(n) = \prod_{i=1}^\omega p_i^{m_i \mod t}. Parameters ========== n : integer t : integer core(n, t) calculates the t-th power free part of n ``core(n, 2)`` is the squarefree part of ``n`` ``core(n, 3)`` is the cubefree part of ``n`` Default for t is 2. Examples ======== >>> from sympy.ntheory.factor_ import core >>> core(24, 2) 6 >>> core(9424, 3) 1178 >>> core(379238) 379238 >>> core(15**11, 10) 15 See Also ======== factorint, sympy.solvers.diophantine.diophantine.square_factor References ========== .. [1] https://en.wikipedia.org/wiki/Square-free_integer#Squarefree_core rzn must be a positive integerrzt must be >= 2)r!r`r.rL)r0rrrdrus r+corersml q Aq AAv788 a)** aL&&(DA QUOA)r2ztThe `sympy.ntheory.factor_.udivisor_sigma` has been moved to `sympy.functions.combinatorial.numbers.udivisor_sigma`.cSSKJn U"X5$)a Calculate the unitary divisor function `\sigma_k^*(n)` for positive integer n .. deprecated:: 1.13 The ``udivisor_sigma`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.udivisor_sigma` instead. See its documentation for more information. See :ref:`deprecated-ntheory-symbolic-functions` for details. ``udivisor_sigma(n, k)`` is equal to ``sum([x**k for x in udivisors(n)])`` If n's prime factorization is: .. math :: n = \prod_{i=1}^\omega p_i^{m_i}, then .. math :: \sigma_k^*(n) = \prod_{i=1}^\omega (1+ p_i^{m_ik}). Parameters ========== k : power of divisors in the sum for k = 0, 1: ``udivisor_sigma(n, 0)`` is equal to ``udivisor_count(n)`` ``udivisor_sigma(n, 1)`` is equal to ``sum(udivisors(n))`` Default for k is 1. Examples ======== >>> from sympy.functions.combinatorial.numbers import udivisor_sigma >>> udivisor_sigma(18, 0) 4 >>> udivisor_sigma(74, 1) 114 >>> udivisor_sigma(36, 3) 47450 >>> udivisor_sigma(111) 152 See Also ======== divisor_count, totient, divisors, udivisors, udivisor_count, divisor_sigma, factorint References ========== .. [1] https://mathworld.wolfram.com/UnitaryDivisorFunction.html r)udivisor_sigma)rr)r0r;_udivisor_sigmas r+rrA s|X 1  r2zfThe `sympy.ntheory.factor_.primenu` has been moved to `sympy.functions.combinatorial.numbers.primenu`.cSSKJn U"U5$)a Calculate the number of distinct prime factors for a positive integer n. .. deprecated:: 1.13 The ``primenu`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.primenu` instead. See its documentation for more information. See :ref:`deprecated-ntheory-symbolic-functions` for details. If n's prime factorization is: .. math :: n = \prod_{i=1}^k p_i^{m_i}, then ``primenu(n)`` or `\nu(n)` is: .. math :: \nu(n) = k. Examples ======== >>> from sympy.functions.combinatorial.numbers import primenu >>> primenu(1) 0 >>> primenu(30) 3 See Also ======== factorint References ========== .. [1] https://mathworld.wolfram.com/PrimeFactor.html r)primenu)rr)r0_primenus r+rr sXJ A;r2zlThe `sympy.ntheory.factor_.primeomega` has been moved to `sympy.functions.combinatorial.numbers.primeomega`.cSSKJn U"U5$)a Calculate the number of prime factors counting multiplicities for a positive integer n. .. deprecated:: 1.13 The ``primeomega`` function is deprecated. Use :class:`sympy.functions.combinatorial.numbers.primeomega` instead. See its documentation for more information. See :ref:`deprecated-ntheory-symbolic-functions` for details. If n's prime factorization is: .. math :: n = \prod_{i=1}^k p_i^{m_i}, then ``primeomega(n)`` or `\Omega(n)` is: .. math :: \Omega(n) = \sum_{i=1}^k m_i. Examples ======== >>> from sympy.functions.combinatorial.numbers import primeomega >>> primeomega(1) 0 >>> primeomega(20) 3 See Also ======== factorint References ========== .. [1] https://mathworld.wolfram.com/PrimeFactor.html r) primeomega)rr)r0 _primeomegas r+rr sZP q>r2ct[U5nUS:a [S5eUS:a [S5e[US- $)zReturns the exponent ``i`` for the nth Mersenne prime (which has the form `2^i - 1`). Examples ======== >>> from sympy.ntheory.factor_ import mersenne_prime_exponent >>> mersenne_prime_exponent(1) 2 >>> mersenne_prime_exponent(20) 4423 rz?nth must be a positive integer; mersenne_prime_exponent(1) == 23zGThere are only 51 perfect numbers; nth must be less than or equal to 51)r!r`r)nthr0s r+mersenne_prime_exponentr sB s A1uZ[[2vbcc #AE **r2c^[T5mTS:agTS-S:XaMTR5S-S- nSUS- -SU-S- -T:wagU[;=(d [SU-S- 5$TSS-:agTS-S:Xag[ U4SjS 55(ag[ T5S:HnU(a [ [S [T5-55eU$) aReturns True if ``n`` is a perfect number, else False. A perfect number is equal to the sum of its positive, proper divisors. Examples ======== >>> from sympy.functions.combinatorial.numbers import divisor_sigma >>> from sympy.ntheory.factor_ import is_perfect, divisors >>> is_perfect(20) False >>> is_perfect(6) True >>> 6 == divisor_sigma(6) - 6 == sum(divisors(6)[:-1]) True References ========== .. [1] https://mathworld.wolfram.com/PerfectNumber.html .. [2] https://en.wikipedia.org/wiki/Perfect_number rFr@rriic38># UHupTU-U:gv M g7fr&r')r(r)rr0s r+r,is_perfect.. s C"B$!1q5A:"Bs)) r)iu)iDQaIn 1888, Sylvester stated: " ...a prolonged meditation on the subject has satisfied me that the existence of any one such [odd perfect number] -- its escape, so to say, from the complex web of conditions which hem it in on all sides -- would be little short of a miracle." I guess SymPy just found that miracle and it factors like this: %s) r!rrrrb abundancer`r"r.)r0r)results` r+ is_perfectr s0 q A1u1uz \\^a A % !a%La1f\ *a /,,K0A!Q$(0KK 2t8|3w!| C"B CCCq\Q F %% (1| %456 6 Mr2c$[U5SU-- $)aReturns the difference between the sum of the positive proper divisors of a number and the number. Examples ======== >>> from sympy.ntheory import abundance, is_perfect, is_abundant >>> abundance(6) 0 >>> is_perfect(6) True >>> abundance(10) -2 >>> is_abundant(10) False r@rrs r+rr4 s" ! q1u $$r2c[U5n[U5(agUS-S:H=(d [[U5S:5$)aPReturns True if ``n`` is an abundant number, else False. A abundant number is smaller than the sum of its positive proper divisors. Examples ======== >>> from sympy.ntheory.factor_ import is_abundant >>> is_abundant(20) True >>> is_abundant(15) False References ========== .. [1] https://mathworld.wolfram.com/AbundantNumber.html Fr?rr!rrBrrs r+ is_abundantrH s:( q A!}} q5A: /ilQ.//r2ch[U5n[U5(ag[[U5S:5$)aUReturns True if ``n`` is a deficient number, else False. A deficient number is greater than the sum of its positive proper divisors. Examples ======== >>> from sympy.ntheory.factor_ import is_deficient >>> is_deficient(20) False >>> is_deficient(15) True References ========== .. [1] https://mathworld.wolfram.com/DeficientNumber.html Frrrs r+ is_deficientrb s-( q A!}}  ! q !!r2cjX:g=(a) X-[U5s=:H=(a [U5:H$s $)aReturns True if the numbers `m` and `n` are "amicable", else False. Amicable numbers are two different numbers so related that the sum of the proper divisors of each is equal to that of the other. Examples ======== >>> from sympy.functions.combinatorial.numbers import divisor_sigma >>> from sympy.ntheory.factor_ import is_amicable >>> is_amicable(220, 284) True >>> divisor_sigma(220) == divisor_sigma(284) True References ========== .. [1] https://en.wikipedia.org/wiki/Amicable_numbers r)r)r0s r+ is_amicabler| s0, 6 Eae~a0EEN14EEEEEr2c^TS:agTS-=(aC [T5(+=(a, [U4Sj[T5R555$)zReturns True if the numbers `n` is Carmichael number, else False. Parameters ========== n : Integer References ========== .. [1] https://en.wikipedia.org/wiki/Carmichael_number .. [2] https://oeis.org/A002997 1Fr@c3\># UH!upUS:H=(a TS- US- -S:Hv M# g7f)rrNr')r(rdrur0s r+r, is_carmichael.. s3R=QTQqAv01q5QU+q00=Qs),)rrbr.rLrs`r+ is_carmichaelr sK 3w q5 S^ S RYq\=O=O=QR RSr2c"SUs=::aU::anO OkUS-S:Xa3[US-US5Vs/sHn[U5(dMUPM sn$[XS5Vs/sHn[U5(dMUPM sn$[S5es snfs snf)z[Returns a list of the number of Carmichael in the range See Also ======== is_carmichael rr@rzQThe provided range is not valid. x and y must be non-negative integers and x <= y)rrr`)r:rrTs r+ find_carmichael_numbers_in_ranger s| A{{ q5A:$QUAq1F1!]15EA1F F$Q1~B~!q1AA~B Blmm GBsBBB 3B cSn/n[U5U:a7[U5(aURU5 US- n[U5U:aM7U$)zoReturns the first n Carmichael numbers. Parameters ========== n : Integer See Also ======== is_carmichael rr@)rrrO)r0rT carmichaelss r+find_first_n_carmichaelsr sT AK k Q       q ! Q k Q  r2c[[U55n[U5nUS::a [S5eUS:XagSUS- US- --$)a Returns the additive digital root of a natural number ``n`` in base ``b`` which is a single digit value obtained by an iterative process of summing digits, on each iteration using the result from the previous iteration to compute a digit sum. Examples ======== >>> from sympy.ntheory.factor_ import dra >>> dra(3110, 12) 8 References ========== .. [1] https://en.wikipedia.org/wiki/Digital_root r(Base should be an integer greater than 1r)rr!r`)r0rnums r+drar sO* fQi.Cq AAvCDD ax qQU# #$r2c[[U55n[U5nUS::a [S5eX:a1SnUS:a [X5upUS:XagX#-nUS:aM UnX:aM1U$)a Returns the multiplicative digital root of a natural number ``n`` in a given base ``b`` which is a single digit value obtained by an iterative process of multiplying digits, on each iteration using the result from the previous iteration to compute the digit multiplication. Examples ======== >>> from sympy.ntheory.factor_ import drm >>> drm(9876, 10) 0 >>> drm(49, 10) 8 References ========== .. [1] https://mathworld.wolfram.com/MultiplicativeDigitalRoot.html rrr)rr!r`r)r0rmulrs r+drmr sx0 F1IAq AAvCDD %!e!rs#0* &0) &"DDDKK220-3 4 G  ? + dNDHAFnb FJ38:*z8 v F!+H# L92:,6"+J6B0+@"3H  jBD* D*Z  zBD% D%P  vBD>$ D>$BX,@F  xBD;! D;!|  jBD) D)X  pBD* D*Z+*8v%(04"4F2S*n$2%@$ r2