Not a mathematician here at all so perhaps my question is phrased incorrectly.
Let’s say through thorough testing in reality, we can prove with certainty Pi is correct up until 5 decimal places,
3.14159
The computers that are calculating Pi to an endless degree, how do they validate new values that are calculated as correct and cannot be otherwise?
In: 434
Mathematician here:
Some numbers are really easy to write out and work with. Whole numbers and fractions are super easy to work with.
Pi is more difficult to write out, but easy to work with. By this I mean, we have methods of approximating pi with fractions. Mathematicians can determine a maximum error depending on the number of calculations you used. The more calculations you complete, the smaller your maximum error becomes. By making this maximum error small enough, you can verify a certain number of decimal places in your approximation.
Let’s say that you wanted to measure something, like the height of a room. You might start with a simple guess: it looks 10 feet high. You might then base it on a size you know: you’re 6 feet tall and it looks like 2 of you could fit the space, so it seems 12 feet high. You decide to be more accurate, so you grab your hockey stick and reach up to the ceiling, estimating that the space is 11 feet high. You then stand on top of a 5 foot shelving unit, on your tip toes, and put your head against the ceiling, getting a measurement of 11 feet 5 inches. You can continue this method over and over with more and more accurate measuring devices to get better measurements.
This is similar to many of the ways pi is calculated. You’re doing an infinite number of measurements to get better and better results. The first measurement might give the result 3. The next, 3.2. The next, 3.17. The next, 3.145. And so on. Each new measurement confirms a certain amount of numbers that came in the earlier calculations and gets you closer to cementing the next number in the sequence.
When a computer approximates pi, what it’s typically doing is using an infinite sum that’s equal to pi. Here’s [one example](http://www.mathmavericktutor.com/wp-content/uploads/2016/03/PI-Sum1-1024×175.png) of such a sum (you would just multiply your final answer by 4 to get pi). Computers obviously can’t add up infinitely many terms, so instead, they just add a bunch of terms. These sums will always start adding smaller and smaller numbers, so there will always be a *finite* point in the sum where we know our error will be less than, for example, 1/1000. That would tell us that our first 3 digits are accurate, since we can’t be more than 0.001 away from pi. So people will just tell the computer to run until it is within their accepted error bound and that will let them know that every digit of their approximation, up to their magnitude of error, is accurate.
To put it very simply, the way to calculate Pi is exact and known. It just takes more and more effort the longer you go on. They way you can validate each new digit is to simply calculate it again.
It is actually possible to calculate the N-th digit of pie, so its not like we have to keep calculating it from the start over and over again.
Very smart people has found ways to represent pi as a sum of numbers. This sum they created has a pattern, but it has infinite sums, that results in pi. Because of that we are able to predict each decimal, but because the sum is infinite, so is the decimals for pi.
No-one seems to be really answering the question asked.
To verify “newly calculated digits of pi” you need to either:
1. Calculate it twice using two different methods, or
2. Randomly check some of the new digits using a method that only calculates one digit “anywhere” in the sequence.
In the first case it takes at least twice as long because if you’re calculating with the fastest algorithm you’ll have to check with only the second fastest algorithm.
In the second case you need to use an algorithm like Bailey-Borwein-Plouffe that can calculate one digit (actually one hexadecimal digit) anywhere in the sequence. So you might be calculating 1 million new digits but after you can just check 1000 of the new ones with BBP and if they’re all correct then you have confidence that all 1 million are correct.
To make it more worse, **approximate PI by random**:
from random import random
def interpolierePI(versuche = 1000000):
pi, im = 0, 0
for loop in range(versuche):
Xcord = random()
Ycord = random()
if(Xcord * Xcord + Ycord * Ycord <= 1):
im += 1
return(4 * im / versuche)
for i in range(10):
test = 10**i
print(test, interpolierePI(test))
> how do they validate new values that are calculated as correct and cannot be otherwise?
Like this:
* a mathematician proves that a certain algorithm will generate digits of pi. Their proof can be checked.
* someone codes the algorithm into a computer program. This program can be checked.
* someone runs the program. The program can be run multiple times on different computers to check the work.
Fun fact: in the 1800’s a mathematician called William Shanks spent two decades calculating 707 digits of pi using pen and paper, finishing in 1873. This got him the world record for the most digits ever calculated.
His record stood for over 70 years, until someone else tried to break it in 1946, and discovered William Shanks had made a mistake – only 527 of his digits were correct.
There are various known algorithms that have been proven to spit out digits of pi. As long as these are implemented correctly, there isn’t really any doubt that they work. Some of these algorithms are “spigot algorithms” that allow you to calculate a given decimal place without having to calculate all the previous ones, which makes it especially easy to perform checks: if someone claims they have calculated a billion digits of pi, you can just pick a random sample and check them instead of repeating their entire calculation.
In practice, calculating new digits of pi is a pretty niche activity and nobody really uses the results for anything. So they may not be checked particularly carefully. It’s always possible that a bug or hardware fault will cause mistakes.
I’ll use an example the helped my brain comprehend it.Say we are trying to split 10 into 3 even parts.
Well we know it can’t be 4,4,4 because that would be over 10. It also can’t be 3,3,3 because that would be under. Therefore it must be 3.x, 3.x, 3.x.
What should x be? Well we know it can’t be 3.4 because that would equal more than 10 and 3.3 because that would be under. Therefore it must be 3.3x, 3.3x, 3.3x.
As you can probably tell, you can do this over and over and over. 1/3 of 10 is also an infinite number. Obviously computers can do this kind of calculation much quicker and easier than us now, but there is a way to work out each decimal, it’s just a little different from the example I’ve given.
Latest Answers