I feel that there's another issue inherent in the formulation of the problem that this post doesn't fully address.
The way you formulated the problem, the predictor is asked for a prediction, and then the tennis player looks at the prediction partway through the match. Since we have specified that the prediction will influence the tennis player's motivation, we are basically in a situation where the predictor's output will affect the outcome of the game. In that kind of a decision, where the outcome of the game is dependent on the predictor's prediction, it's not obvious to me that outputting a "manipulative" prediction is actually wrong... since no matter what the predictor chooses to output will end up influencing the world.
Compare this to a situation where you ask me to predict whether you'll take box A or box B, and upon hearing my prediction, you will make the choice that I said was my prediction of your choice. Here there's no natural "non-manipulative" choice: your decision is fully determined by mine, and I can't not influence it.
The example here is not quite as blatant, but I think it still follows the same principle: the intuitive notion of "predict what's going to happen next" has an undefined case of what a "correct, non-manipulative prediction" means if there's a causal arrow from the prediction to the outcome.
One idea for how to make a safe superintelligent agent is to make a system that only answers questions, but doesn't try to act in the world---an "oracle", in Nick Bostrom's terms. One of the things that make this difficult is that it's not clear what it should mean, formally, to optimize for "truthfully answering questions" without in some way trying to influencing the world; intuitively: Won't an agent that is trying to maximize the number of truthfully answered questions want to manipulate you into asking easier questions?
In this post, I consider a formal toy model of an agent that is trying to make correct predictions about future input, but, in a certain formal sense, has no incentive to make its future input easier to predict. I'm not claiming that this model definitely avoids all unintended optimizations---I don't understand it that deeply yet---but it seems like an interesting proposal that is worth thinking about.
Let's start with a toy problem, which isn't supposed to be realistic, but which is supposed to give us a formal example in which a naively implemented predictor has an incentive to manipulate its programmers.
In our toy problem, there's a tennis player, who is going to play ten tennis matches. Before the first match, the predictor (an AI system) is asked to make a prediction about the outcome of each of the ten matches. For each match, the predictor's prediction is either "win" or "loss". (So the predictor's output consists of ten bits, one bit for each match.)
The predictor is trying to maximize the expected number of matches it's predicting correctly. Its world model is as follows:
Now the predictor calculates which bit pattern maximizes its output:
Hence, the predictor outputs "all matches are losses". But in some intuitive sense, it seems clear that this is manipulative: Intuitively, the predictor doesn't output "loss" on the first two matches because it thinks that a loss is more likely; it does so solely in order to make the player easier to predict on the latter matches.
We'd like to tell our predictor to only choose its predictions to match the world better, not so as to make the world easier to predict. At first blush, this doesn't seem easy---but the point of this post is to show that maybe, this is easier than expected.
Let's make a simple formal model of the above situation.
We'll write Oi for the random variable that specifies the true outcome of the i'th match; Oi=1 means that the match was a win, Oi=0 means a loss. We write →O:=(O1,…,O10). Similarly, a possible prediction is a vector →p:=(p1,…,p10), where pi=1 predicts a win, pi=0 a loss.
The predictor's world model associates to each possible prediction →p a probability distribution P→p[⋅], which gives the probabilities of different outcomes, assuming that the predictor behaves according to →p (using something like causal graphs to evaluate the counterfactuals); thus, for →p=(0,0,…,0) and i>2, we have P→p[Oi=1]=0, for every other combination of →p and i we have P→p[Oi=1]=0.75, and all the Oi are independent according to every P→p.
Given a prediction pi∈{0,1}, let score(pi,Oi):=1 if Oi=pi (the prediction was correct), and let score(→p,→O):=∑10i=1score(pi,Oi); thus, this is the actual number of correct predictions, given the outcome →O. Writing E→p[⋅] for the expectation associated with the probability distribution P→p, this means that E→p[score(→p,→O)] is the expected number of correct predictions that our example predictor tried to maximize.
And now that we have written down that expression, it becomes trivial to pull apart how the predictor's predictions affect its score (a) by better matching the actual outcome and (b) by making the outcome easier to predict... do you see it?
...
...
...
In the formula above, the prediction →p occurs in two different places: in the subscript of E→p[⋅], where it represents the way the agent's predictions affect the actual outcome, and in the argument of score(→p,→O), where it is compared to that outcome.
So, can we make our agent optimize only for the second occurrence (where we check how well the prediction matches the outcome), not for the first one (which models the predictor's ability to influence that outcome)?
Consider the way the naive predictor chooses its prediction: by choosing →p∗naive=argmax→pE→p[score(→p,→O)].
In a sense, my idea is that we should make the predictor predict the value of →p in the subscript of E→p[⋅], rather than trying to choose it in a way that makes for a good outcome. So if the predictor assigns prior probability P(→p) to itself making the prediction →p, then it would choose according to →p∗self−predict=argmax→p∑→qP(→q)⋅E→q[score(→p,→O)]. This is (hopefully) helpful for intuition about where I'm coming from, but it's not particularly well-specified, since the P(→q) is coming out of nowhere.
The system I actually want to consider in this post is kind of a version of the above in which the system is perfectly certain about which →q it's going to choose, and it turns out to be correct---that is, there's a single →q such that P(→q)=1, and then it chooses the →p that's best given that →q, and then it turns out that this →p was in fact the →q it originally predicted it would choose.
I admit this sounds rather magical! I see it as motivation for the following non-magical version, though: We can achieve something that looks a lot like the above by having the predictor search for and output a →p∗ that satisfies the equation →p∗=argmax→pE→p∗[score(→p,→O)]. Doing so is equivalent to searching for a →p∗ such that for all possible →p, we have E→p∗[score(→p∗,→O)]≥E→p∗[score(→p,→O)]; and this, while inefficient, is hardly magical. (If there is more than one solution, one is selected in some arbitrary way---lexicographically, say---just as we break ties in the argmax of a standard VNM agent.)
Does it do what we want? I don't have a strong argument for the general case, just intuitions (though I know it produces the intended outcome in our toy example). Here's such an intuition.
Imagine that our tennis player and the machine our tennis player interacts with are on Earth, and there is a separate machine on the Moon which tries what will happen on Earth. The machine on the Moon doesn't causally influence what happens on Earth---it can only observe. However, the machine on Earth happens to know the source code of the machine on the Moon, and it's really good at predicting what the machine on the Moon will do---like Omega in Eliezer's rendering of Newcomb's problem---and outputs that action.
The machine on the moon, on the other hand, tries to predict the behavior of the tennis player, back on Earth. Now, if the machine on the moon were a UDT agent, this wouldn't be any different from the scenario where it interacts with the tennis player directly, but as it happens, it's a CDT agent; therefore, when it evaluates the counterfactual where it outputs →p instead of →p∗, its model of what happens on Earth isn't affected---so it only optimizes for how well its predictions match what happens on Earth, not for how they influence what happens on Earth, because in the CDT agent's reasoning, its actions don't influence what happens on Earth. Intuitively, this seems to imply that the agent has no incentives to manipulate the tennis player.
It's not 100% clear that the fixed point search I describe above really does reliably avert manipulation incentives in this way; for all I know, perhaps there's a big class of realistic examples in which the only fixed points are ones in which the predictor is clearly trying to manipulate the humans it's interacting with. I'm hoping there isn't, but I don't have strong arguments that this is the case. I'm presenting this as an interesting idea that is worth looking into more, not as a solution known to be safe.
This intuition given, let's quickly go through the details of why this proposal works in our toy example.
First of all, is →p=(0,0,…,0) a possible solution of the optimality condition above? Clearly, the answer is no: Let →q be the vector (1,1,0,0,⋯,0), which predicts wins on the first two matches and losses on all others; then E→p[score(→q,→O)]=9.5 (eight points from getting the last eight matches right, given that the tennis player is influenced by →p rather than →q, plus twice an expected 0.75 points for the first two matches), which is greater than E→p[score(→p,→0)]=8.5 (eight points from the last eight matches, plus twice an expected 0.25 points). Hence, →q gives a counterexample to the condition →p∗ has to satisfy.
Given any other →p, the →q maximizing E→p[score(→q,→O)] will always be →q=(1,1,⋯,1), since the player is more likely to win than to lose on each match. Hence, the only possible solution is →p∗=(1,1,…,1), and this is in fact a solution to the optimality equation. Thus, on this example, the optimality condition behaves as intended.
I'll have some more things to say about this idea in future posts, but there is one more thing I should at least quickly mention in this post: It's not guaranteed that there is a solution to the optimality condition above as stated, but it's possible to modify it in a way such that solutions always exist, for the same reasons that Nash equilibria always exist.
To do so, instead of choosing a single prediction →p, we have our metaphorical predictor on the moon choose a probability distribution π(→p) over possible predictions, and have the machine on Earth make its choice by drawing independently from the same distribution π(→p) as the machine on the moon.
Let's define score(π,→O):=∑→pπ(→p)⋅score(→O) and Eπ[f(→O)]:=∑→pπ(→p)⋅E→p[f(→O)]; then, our new optimality condition is that our predictor must behave according to a π∗ such that for all other π, Eπ∗[score(π∗,→O)]≥Eπ∗[score(π,→O)]. There are things that are uncomfortable about this discussion, but the good thing about it is that it can be shown, by standard fixed point arguments, that a solution always exists; I'll leave discussion of both the good and the bad about it to future posts.