No, that's not necessarily true. Let's say you were born March 13. Consider the number

0.130301001000100001000001000000100000001000000001...

where the first four digits after the decimal point are 13-03 (not 03/13 because you're French :~) ) and then comes

one zero

one one

two zeros

one one

three zeros

one one

four zeros

one one

five zeros

one one

... and so on forever.

The sequence of digits goes on forever; it doesn't consist of the same digits repeated, like 0.123123123123..., so it's irrational. And your birthday doesn't occur more than once.

(Please don't tell us what your actual birthdate is.)

Pi, however, is special; not only is it irrational, like most numbers, but it's also believed to be *normal,* which means that every sequence of N digits occurs as often as every other sequence of N digits. That's what the paragraph you cited is saying. So in π, specifically, yes, you'll probably find your birthday infinitely many times.

Nothing to it. You just do and then you do arithmetic as usual.

But what you really need to learn is more complicated than that. The bignum library gives you exact large integers, and exact rationals, but it can't give you exact reals, and the problem you're trying to solve involves the digits of the decimal expansion of a real number. There actually are arithmetic packages that would give you arbitrary precision real numbers (but of course not infinite precision), but not in Snap*!*. So what you'd have to do is this:

- Pick one of your formulas, say (2a) in your list.
- Add the first thousand terms using exact rational arithmetic.
- Convert the result to a long decimal fraction
*not by doing arithmetic on it* (which would eliminate all but ≈15½ digits of precision) but by manipulating it as text.
- If your birthday is in the result, you're done.
- If not, go back to step 2, but add the first ten thousand terms. Etc.

I always tell my students that there are two kinds of programming that they should never try to do themselves, but should instead hire an expert. One is security; the other is arithmetic on real numbers. If you do it yourself, you'll probably get an answer, but the answer will almost certainly be wrong.