At this point I don’t know where the <pre> tag is being stripped out. More important, I don’t know why. Offhand, I can’t see any particular security risk in letting folks post monospaced content, but what do I know.

<pre> does work; I’ve inserted the tags.

Using the Sage script at http://sage.math.washington.edu/home/cwitty/factorial_trailing.py, I have computed that the 11 digits just before the trailing zeroes start are: 01630550016 (and this time the script has comments). It took a little under 3 minutes to check this, with the call decimal_factorial_nz_trailing(2*1312000, 11); each additional digit would multiply the run time by about 5. (The times could be improved a lot by writing in Cython instead of Python, or by managing to prove a simple number theory fact; but the algorithm would still be exponential in the number of digits, so you’d only get a few more digits.)

While testing this on small examples, I noticed an interesting pattern; this makes it seem plausible that a much better algorithm might be found that could give a lot more digits. The pattern is that factorial(5^k) shares some trailing non-zero digits with factorial(5^(k+4)).

Here are the last 40 trailing non-zero digits of factorial(5^k) for 1<=k<=11, grouped by k mod 4 (trailing “…” are all the omitted zero digits).

(5^1)!:                                           12...
(5^5)!:  ...9717371988442487977107852522487820582912...
(5^9)!:  ...7560245386243275657453531611594764582912...

(5^2)!:                         15511210043330985984...
(5^6)!:  ...3093071149756783641357004124179329449984...
(5^10)!: ...9413837847010778827395667973098369449984...

(5^3)!:  ...1888345755854705552432637556500713177088...
(5^7)!:  ...3145601082485362382639921420238835417088...
(5^11)!: ...3953887529406591222834142592565235417088...

(5^4)!:  ...7534383573517418356160192763514392150016...
(5^8)!:  ...9246874176784347390937558035477630550016...

Note that 9 of the 11 trailing non-zero digits of B! occur already in (5^8)!.

If the <pre> tag were supported in comments here, then all the digits would line up nicely above; hopefully it’s still easy to see the common digits anyway.

No; turns out Sage on my cell phone is too slow to be interesting. (The biggest problem is that it doesn’t have enough RAM, so almost everything uses swap space.)

I actually did the big computation on sage.math.washington.edu (24 cores, 128 GB RAM), which was purchased by William Stein using National Science Foundation Grant No. DMS-0821725. But in retrospect, I’m pretty sure I could have run it on my laptop and still finished in reasonable time. (Not my cell phone, though.)

btw, ur CAPTCHA==<3

Dealing with numbers this large is confusing.

Yeah, I agree wholeheartedly. I had the same feeling when I first looked at the difference between approximations to log B^B and log B!. In floating-point notation these numbers have the same exponent and no change in the first six digits of the significand. How can subtracting 25^1,312,000 have so little effect? It took some pondering to accept that 0.000001 x 10^1,184,103 is not a small difference!

Thank you Carl Witty and Alexander.

Carl, I have to ask: Did you get those results running Sage on your cell phone?

I wrote this script: http://sage.math.washington.edu/home/cwitty/factorial_digits.sage
which uses interval arithmetic (based on the MPFI and MPFR libraries) and the lngamma function to compute both the number of digits in the factorial result and some leading digits of the actual factorial. Again, I tested with smaller values, and the results seemed correct. (Sorry the script is undocumented. The first argument to the function is the number of bits to use; the second argument is the number you’re taking the factorial of. If the given precision is insufficient, the function returns None; if it has enough precision, it returns a pair of the number of digits and of the leading digits, scaled to lie between 0.1 and 1.)

Computing with 1,000,000-bit floating-point numbers was not enough; but using 10-million bit numbers, and a little over 6 minutes of CPU time, I got both the exact number of digits in B! and the first 1,176,194 digits of B!. The number of digits in B! is at http://sage.math.washington.edu/home/cwitty/num_digits_in_B_factorial.txt (this is a 1,834,104-digit number); the first 1,176,195 digits of B! are at http://sage.math.washington.edu/home/cwitty/leading_digits_of_B_factorial.txt (but the question mark after the final 2 means that it might actually be a 1, so I’m not counting that digit as “known”).

Dealing with numbers this large is confusing. When I noticed that the number of digits in the number of trailing zeroes of B! was 1,834,097, and the number of digits in the number of digits of B! was 1,834,104, my first thought was “OK, so almost all the digits are trailing zeroes”. But of course that’s totally wrong… what this actually shows is that almost none of the digits are trailing zeroes.

I wrote this Sage one-liner to compute the number of digits in n!:

sage: def n_digits_in_factorial(k): return (RR(k+1).lngamma() / log(10.0)).ceiling()

I checked that this gives the correct answer for several test cases, ranging from 2 to 100000; so I believe it is correct (although for large n, only the first digits of the result will be correct).

Then I get this result:

sage: RR(n_digits_in_factorial(25^1312000))
3.58756666520195e1834103

which agrees with your computation, so I think your result is correct.

Well, skipping a bit of messing with sums, the number of trailing zeros should be:

$$
Z = \sum_{m=1}^{m=\infty} \lfloor \frac {N} {10^m} \rfloor
$$

where $N$ is the number in question ($25^1312000$), and sum is actually a finite one with $\lfloor \log_{10} {N} \rfloor$ non-zero elements.

After that, we can notice that $Z$ is more than $N/10$ and less than $N/9$, and go no further, or try to compute $Z$ explicitly (in some sense of the word).

I wrote a Python script for this (well, Python has a nice long integer arithmetics). It goes like this:

Z = 0
N = 25**1312000

m = 1
N /= 5

while True:
____a = N >> m

____if a == 0:
________break

____Z += a

____m += 1
____N /= 5

Here I take advantage of the fact that $N$ is a power of $5$, therefore all divisions by $5$ are precise.

The script is running. I am quite optimistic about it — I do still believe it’s going to finish in a couple of days or so.

Another problem would be to extract some information about $Z$ later, like exact number of digits or first several most significant bits.

Yes.

The number of trailing zeroes in n! is $\lfloor n/5 \rfloor + \lfloor n/5^2 \rfloor + \lfloor n/5^3 \rfloor + \ldots$.

I’m not sure how to calculate this for an arbitrary very large n. But fortunately, B is a power of 5, so each of the terms in the above series is also a power of 5, and you can use the formula for the sum of a geometric series to see that the number of trailing zeroes is (B-1)/(5-1).

This takes only a few seconds to compute; just for fun, I’ve posted the resulting 1,834,097-digit number at http://sage.math.washington.edu/home/cwitty/num_trailing_zeroes_in_B_factorial.txt (I used Sage to do the computation).