The goal is to make pre-commitments unnecessary, including retro-active pre-commitments. I think it’s misleading to frame the agent taking an action now as the same agent that hypothetically considers it from a position of radical ignorance (together with all other possible actions in all alternative states, forming a policy). The usual UDT perspective is to only have the abstract radically ignorant agent, so that the thing that carries out actions is not really an agent, it’s just an automaton that carries out the policy chosen by the abstract radically ignorant agent, according to what it says to do in the current situation.
I think a better way is to distinguish them as different agents coordinating with each other (with knowledgeable future concrete agents selectively deferring to abstract ignorant past agents on some things), probably with different preferences even. The advantage of radical ignorance is a coherent way of looking at all ways it might get resolved, not needing to deal with counterfactuals relative to what you’ve already accepted as a part of you, not needing to excise or factor out this deeply integrated knowledge to consider its alternatives. But it’s the agent in the present that decides whether to take the advice offered by that less committed perspective, that decides which more ignorant abstract agents to use as intermediaries for coordination with other knowledgeable concrete agents (such as alternative versions of yourself that need to act in different situations).
The first paragraph is my response to how you describe UDT in the post, I think the slightly different framing where only the abstract algorithm is the agent fits UDT better. It only makes the decision to choose the policy, but it doesn’t make commitments for itself, because it only exists for that single decision, influencing all the concrete situations where that decision (policy) gets accessed/observed/computed (in part).
The second paragraph is the way I think about how to improve on UDT, but I don’t have a formulation of it that I like. Specifically, I don’t like for those past abstract agents to be an explicit part of a multi-step history, like in Logical Induction (or a variant that includes utilities), with explicit stages. It seems too much of a cludge and doesn’t seem to have a prospect of describing coordination between different agents (with different preferences and priors).
Past stages should be able to take into account their influence on any computations at all that choose to listen to them, not just things that were explicitly included as later stages or receiving messages or causal observations, in a particular policy formulation game. Influence on outcomes mediated purely through choice of behavior that an abstract algorithm makes for itself also seems more in spirit of UDT. The issue with UDT is that it tries to do too much in that single policy-choosing thing that it wants to be an algorithm but that mostly can’t be an actual algorithm, rather than working through smaller actual algorithms that form parts of a larger setting, interacting through choice of their behavior and by observing each other’s behavior.
The goal is to make pre-commitments unnecessary, including retro-active pre-commitments. I think it’s misleading to frame the agent taking an action now as the same agent that hypothetically considers it from a position of radical ignorance (together with all other possible actions in all alternative states, forming a policy). The usual UDT perspective is to only have the abstract radically ignorant agent, so that the thing that carries out actions is not really an agent, it’s just an automaton that carries out the policy chosen by the abstract radically ignorant agent, according to what it says to do in the current situation.
I think a better way is to distinguish them as different agents coordinating with each other (with knowledgeable future concrete agents selectively deferring to abstract ignorant past agents on some things), probably with different preferences even. The advantage of radical ignorance is a coherent way of looking at all ways it might get resolved, not needing to deal with counterfactuals relative to what you’ve already accepted as a part of you, not needing to excise or factor out this deeply integrated knowledge to consider its alternatives. But it’s the agent in the present that decides whether to take the advice offered by that less committed perspective, that decides which more ignorant abstract agents to use as intermediaries for coordination with other knowledgeable concrete agents (such as alternative versions of yourself that need to act in different situations).
This sounds like how Scott formulated it, but as far as I know none of the actual (semi)formalizations look like this this.
The first paragraph is my response to how you describe UDT in the post, I think the slightly different framing where only the abstract algorithm is the agent fits UDT better. It only makes the decision to choose the policy, but it doesn’t make commitments for itself, because it only exists for that single decision, influencing all the concrete situations where that decision (policy) gets accessed/observed/computed (in part).
The second paragraph is the way I think about how to improve on UDT, but I don’t have a formulation of it that I like. Specifically, I don’t like for those past abstract agents to be an explicit part of a multi-step history, like in Logical Induction (or a variant that includes utilities), with explicit stages. It seems too much of a cludge and doesn’t seem to have a prospect of describing coordination between different agents (with different preferences and priors).
Past stages should be able to take into account their influence on any computations at all that choose to listen to them, not just things that were explicitly included as later stages or receiving messages or causal observations, in a particular policy formulation game. Influence on outcomes mediated purely through choice of behavior that an abstract algorithm makes for itself also seems more in spirit of UDT. The issue with UDT is that it tries to do too much in that single policy-choosing thing that it wants to be an algorithm but that mostly can’t be an actual algorithm, rather than working through smaller actual algorithms that form parts of a larger setting, interacting through choice of their behavior and by observing each other’s behavior.