Why do you need statements of the form “A()==a implies U()==u” instead of “U(a)==u”?
Or if you insist that A is a function, those of the form “U(()↦a)==u”.
Then A would of course just pick the action with the highest (provable) utility.
The difference is that you no longer have need to prove things about A inside A, which is impossible.
But you can easily rewrite U() as U’(A’). I think that solves all the problems with self-referential A. At least this works for the example in this post. How would U look for, say, Newcomb’s problem?
One of the motivations for our branch of decision theory research is that the physics of our world looks more like an argumentless function containing many logical correlates of you than like a function receiving you as an argument. Of course having a general way to derive one representation from the other would be great news for us. You can view the post as supplying one possible way to do just that :-)
Mathematically, the two forms are equivalent as far as I can tell. For any U that contains A, you can rewrite it to U=U’(A). If A is a part of U, then in order to proof things about U, A would have to simulate or proof things about itself, which leads to all kinds of problems. However, if A knows that U=U’(A), it can consider different choices x in U’(x) without these problems.
For any U that contains A, you can rewrite it to U=U’(A).
...In many different ways. For example, you could rewrite it to a U’ that ignores its argument and just repeats the source code of U. Or if U contains one original copy of A and one slightly tweaked but logically equivalent copy, your rewrite might pick up on one but not the other, so you end up defecting in the Prisoner’s Dilemma against someone equivalent to yourself. To find the “one true rewrite” from U to U’, you’ll need the sort of math that we’re developing :-)
Also, do you mean U()=U’(A) (dependence on source code) or U()=U’(A()) (dependence on return value)? There’s a subtle difference, and the form U()=U’(A) is much harder to reason about, because U’(X) could do all sorts of silly things when X!=A and still stay equivalent to U when X=A.
Why do you need statements of the form “A()==a implies U()==u” instead of “U(a)==u”? Or if you insist that A is a function, those of the form “U(()↦a)==u”.
Then A would of course just pick the action with the highest (provable) utility.
The difference is that you no longer have need to prove things about A inside A, which is impossible.
U does not receive an action as an argument, U is a program with no arguments that includes A as a subprogram.
But you can easily rewrite U() as U’(A’). I think that solves all the problems with self-referential A. At least this works for the example in this post. How would U look for, say, Newcomb’s problem?
still works fine if A is a parameter of U.
One of the motivations for our branch of decision theory research is that the physics of our world looks more like an argumentless function containing many logical correlates of you than like a function receiving you as an argument. Of course having a general way to derive one representation from the other would be great news for us. You can view the post as supplying one possible way to do just that :-)
Mathematically, the two forms are equivalent as far as I can tell. For any U that contains A, you can rewrite it to U=U’(A). If A is a part of U, then in order to proof things about U, A would have to simulate or proof things about itself, which leads to all kinds of problems. However, if A knows that U=U’(A), it can consider different choices x in U’(x) without these problems.
...In many different ways. For example, you could rewrite it to a U’ that ignores its argument and just repeats the source code of U. Or if U contains one original copy of A and one slightly tweaked but logically equivalent copy, your rewrite might pick up on one but not the other, so you end up defecting in the Prisoner’s Dilemma against someone equivalent to yourself. To find the “one true rewrite” from U to U’, you’ll need the sort of math that we’re developing :-)
Also, do you mean U()=U’(A) (dependence on source code) or U()=U’(A()) (dependence on return value)? There’s a subtle difference, and the form U()=U’(A) is much harder to reason about, because U’(X) could do all sorts of silly things when X!=A and still stay equivalent to U when X=A.