Newcomb’s problem has been discussed ad nauseam — in this forum and elsewhere — but after all this discussion little ground has been gained by either side. In an attempt to change this I’m going to use a novel approach: computer programming.
Ideally computer programming shouldn’t be necessary, logic alone should be sufficient to arrive to the correct answer, but as we’ve seen from the decades of discussions: that doesn’t seem to be the case. Consider what happened with Monty Hall problem where professional mathematicians consistently arrived to the wrong answer, even one of the greatest probabilists of the time — Paul Erdős — had the wrong intuition. It wasn’t until people did simulations — both manually and with computers — that the true answer saw the light of day.
Using computer simulations to find out the true answer to a very simple question shows the correct answer to Newcomb’s problem:
What is the probability that the money obtained by a one-boxer is greater than the money obtained by a two-boxer?
Several papers have attempted to answer this question with expected utility, and while this approach is correct, it’s too simplistic, and there’s a deeper answer.
We are going to refer to a choice of one-box as C1 and prediction of one-box as P1.
Basic probability
Let’s define the concept of probability starting from p=0.99. Given this, the frequency of successful independent Bernoulli trials with success probability of p will converge towards 0.99.
Using code:
mean(runif(n) < 0.99)
Note: here I’ll be using the R programming language given that it’s more succinct for this purpose, but the same can be reproduced in any programming language.
Mathematically: X_i = \mathbf{1}_{\{U_i < 0.99\}}, where U_i \sim \mathrm{Uniform}(0,1).
Gives us a result that approximates p as n increases.
If this is true (the definition of probability tells us that it is and we can verify empirically with code), then it follows that the expected utility of choosing two-box is:
money_c2 <- (1 - (runif(n) < p)) * 1000000 + 1000
mean(money_c2)
Which for p=0.99 gives us around $11,000, which aligns with the math:
Therefore it’s proven that the average money obtained by one-boxers is greater than the one obtained by two-boxers. For p=0.99 it’s $990,000 and $11,000 respectively.
Let’s suppose a counterfactual where 100% of two-boxers earn more than $1M, say 100,000 of them. Although technically not impossible, the probability of that happening would be around 10^{−436}, so pretty much 0 and certainly very far from 0.99. It doesn’t seem rational to expect the impossible.
Most two-boxers accept this fact: Why Ain’cha Rich? argument. But then argue that “irrationality” is being rewarded, so even though two-boxing results in less money overall, it’s still the rational choice. Of course, this is a tricky definition of “rationality”.
Basic probability, whether it’s through code or math cannot be denied.
money_c1 <- (runif(n) < p) * 1000000 + 0
money_c2 <- (1 - (runif(n) < p)) * 1000000 + 1000
mean(money_c1) > mean(money_c2)
The only way to argue for two-boxing is to deny basic probability, which is not only to deny probability theory and the empirical results obtained through exhaustive computation, but the philosophy of probability as well.
The case for two-boxing
Naively one might think this is case closed, since clearly one-boxers make more money than two-boxers (on average). But if that was the case there would be no controversy, and there clearly is.
The case for two-boxing begins by fixing the prediction and arguing from there: for example given that the prediction was one-box. This isn’t necessarily a valid move, but for the sake of argument let’s suppose that it is.
If the prediction was P1, then C1 gives you $1,000,000 and C2 gives you $1,001,000.
However, how does this look like from the point of view of the code? First, we have to store the predictions, so that we can filter using them later:
pred_c1_p1 <- runif(n) < p
pred_c2_p2 <- runif(n) < p
money_c1 <- pred_c1_p1 * 1000000 + 0
money_c2 <- (1 - pred_c2_p2) * 1000000 + 1000
Now we can compare:
money_c1[pred_c1_p1] > money_c2[!pred_c2_p2]
Except when we try to do that the program fails because the vectors are of different size, which gives us a hint that this is an invalid approach.
What is money_c1[pred_c1_p1]? That’s the money obtained when choosing one-box given that the prediction was one-box (i.e. 1,000,000). And money_c2[!pred_c2_p2] is the money obtained when choosing two-box given that the prediction was one-box (i.e. 1,001,000).
Obviously 1,001,000 is greater than 1,000,000, but we can’t compare apples to oranges. The amount of people that earn one are fundamentally different than the people that earn the other.
We can ignore the vector sizes and conclude that two-boxing always gives more money, but we have to remember that this analysis began with the supposition that fixing the prediction was a valid move in the first place, which we never established.
The failure of the program above tells us that C1|do(P1) is fundamentally different than C2|do(P1), namely that the sample size of the former is orders of magnitude greater than the later.
Intuitively we know why: given a high enough p, the probability that an agent is going to choose C1 and Omega predicted P1 is very low.
We can compare the size of the vectors with the following code:
length(money_c1[pred_c1_p1]) / length(money_c2[!pred_c2_p2])
For p=0.99 the result is around 100, and for p=0.9999 the result is around 10000. That means for a population of 100,000 participants, the size of C2|do(P1) is around 10.
We can fix the code to obtain 10 items from C1|do(P1) in order to match the size of C2|do(P1) and compare 10 from one, with 10 from the other:
min_size <- min(length(money_c1[pred_c1_p1]), length(money_c2[!pred_c2_p2]))
s1 <- sample(money_c1[pred_c1_p1], min_size)
s2 <- sample(money_c2[!pred_c2_p2], min_size)
mean(s1 > s2)
The result is 0, which means for each of those 10 samples, the money obtained by two-boxers is greater than the money obtained by one-boxers.
But remember the tentative conditional we started with: if the prediction was P1. We never established this was a valid move, and the complexity of the code suggests it isn’t, because we have to compare two fundamentally different objects. In order to make this possibly invalid comparison, we have to ignore 99990 elements from C1|do(P1) (99.99\%).
So the case for two-boxing begins with the assumption: if we ignore the fact that N[C1|do(P1)] is much greater than N[C2|do(P1)]. Which is another way of saying: if we ignore p.
That’s because the ratio of N[C1|do(P1)] over N[C2|do(P1)] is:
Which gives us yet another clue: what happens if p=1? In other words: what happens if the predictor is perfect? In that case the ratio becomes infinite because N[C2|do(P1)] is 0.
It’s nonsensical to say let’s obtain a sample of 0 elements from C1|do(P1) and compare them with 0 elements from C2|do(P1).
Which is why for two-boxers p=0.9999999999 is fundamentally different from p=1 even though intuitively it shouldn’t be.
Although analytically E[C1|do(P1)] < E[C2|do(P1)] holds for p=0.9999999999, it doesn’t hold in a computer program:
n <- 1e5
p <- 0.9999999999
pred_c1_p1 <- runif(n) < p
pred_c2_p2 <- runif(n) < p
money_c1 <- pred_c1_p1 * 1000000 + 0
money_c2 <- (1 - pred_c2_p2) * 1000000 + 1000
min_size <- min(length(money_c1[pred_c1_p1]), length(money_c2[!pred_c2_p2]))
In this case min_size is 0 (almost certainly), which makes the subsequent comparison impossible, and the result is NaN.
From multiple vantage points it is clear the case for two-boxing relied on an invalid assumption.
Even in the most charitable interpretation, two-boxers bear the burden of proof if they want to assume a fixed prediction — and they don’t meet it. It’s assumed without justification.
The answer
Let’s return to the original question:
The answer using programming is surprisingly simple:
mean(money_c1 > money_c2)
The probability that one-boxers will obtain more money is p^2, so if p=0.99 the probability is 98.01\%.
This contradicts the simplified calculation using expected value which states that the cross-over point is around 51%. According to this formula, the real cross-over point is:
That is: around 71\%.
Case closed. We don’t even need to calculate the expected value to arrive to the correct answer.
Explanation
There are four possible outcomes, 2 for one-boxers: \{1000000,0\}, and 2 for two-boxers: \{1000,1001000\}. The probabilities of the product are the following:
| $1,000 | $1,001,000 | |
|---|---|---|
| $1,000,000 | P(C1|P1) \cdot P(C2|P2) | P(C1|P1) \cdot P(C2|P1) |
| $0 | P(C1|P2) \cdot P(C2|P2) | P(C1|P2) \cdot P(C2|P1) |
The most likely outcome for one-boxers is $1,000,000 with probability P(C1|P1) which is p. The most likely outcome for two-boxers is $1,000 with probability P(C2|P2) which is p.
That’s why P(C1|P1) \cdot P(C2|P2) dominates: p \cdot p.
Two-box partition
What two-boxers do is begin with an assumption: if P1 (do(P1)). There’s only one cell that satisfies that predicate: P(C1|P1) \cdot P(C2|P1). Then they follow with: if P2 (do(P2)). Again, only one cell satisfies that: P(C1|P2) \cdot P(C2|P2).
When we expand the original formula using the law of total probability, we get:
We can see that in this formulation the likely probabilities are mixed with the unlikely probabilities, therefore masking p. But the real problem is that by the time we consider P(M_{C1} > M_{C2}|do(P_{x})), we already lost 2 of the 4 probability combinations; in particular p^2 which is the overwhelmingly most likely.
Two-boxers only consider P(C1|P1) \cdot P(C2|P1) and P(C1|P2) \cdot P(C2|P2). In both cases when p=1 the result is 0, making the comparison nonsensical because there’s nothing to compare to.
Moreover, this equality assumes collapsibility, which once again it’s not something that can be automatically assumed.
Simpson’s paradox
This is structurally identical to Simpson’s paradox. In Simpson’s original 2×2×2 formulation with elements \{A, B, C\}, it is possible that:
yet when aggregating over C:
The subgroup analysis reverses when the groups are combined, because it ignores the population weights of each subgroup. Mapping to our formulation: A is the probability of winning, B is two-boxing, and C is the prediction. The two-boxer shows that within each level of C (i.e. do(P1) and do(P2)), two-boxing dominates:
But when C is marginalized out correctly the conclusion reverses:
Although Simpson’s paradox is well understood, we can also verify the results using computation:
c <- runif(1e5) < 0.99
b <- (1 - c) * 0.999 + 0.001
nb <- c * 0.999
compare <- function(ma, a, mb, b) {
n <- min(length(a), length(b))
cat(sprintf('%s > %s: %s\n', ma, mb, mean(sample(a,n)) > mean(sample(b,n))))
}
compare('P(A|B,C)', b[c], 'P(A|¬B,¬C)', nb[!c])
compare('P(A|B,¬C)', b[!c], 'P(A|¬B,C)', nb[c])
compare('P(A|B)', b, 'P(A|¬B)', nb)
Which outputs:
P(A|B,C) > P(A|¬B,¬C): TRUE
P(A|B,¬C) > P(A|¬B,C): TRUE
P(A|B) > P(A|¬B): FALSE
You don’t need to understand the code or trust me, you can run it on an online R interpreter like rdrr.io.
Conclusion
The conclusion is that two-boxers begin with the assumption that the probability p doesn’t matter, and end with the conclusion that therefore the probability p doesn’t matter. But this is contingent on the unjustified assumption.
It’s nothing more than circular reasoning, which can be proved either using math or computer programs.