# Universal agents and utility functions

I'm Anja Heinisch, the new visiting fellow at SI. I've been researching replacing AIXI's reward system with a proper utility function. Here I will describe my AIXI+utility function model, address concerns about restricting the model to bounded or finite utility, and analyze some of the implications of modifiable utility functions, e.g. [wireheading](http://wiki.lesswrong.com/wiki/Wireheading "wireheading") and [dynamic consistency](http://en.wikipedia.org/wiki/Dynamic_inconsistency "dynamic inconsistency"). Comments, questions and advice (especially about related research and material) will be highly appreciated.

### Introduction to AIXI

[Marcus Hutter's (2003)](http://www.hutter1.net/ai/aixigentle.pdf "AIXI gentle") universal agent AIXI  addresses the problem of rational action in a (partially) unknown computable universe, given infinite computing power and a halting oracle. The agent interacts with its environment in discrete time cycles, producing an action-perception sequence ![](http://www.codecogs.com/png.latex?y_1x_1y_2x_2\dots "y_1x_1y_2x_2\dots") with actions (agent outputs)  ![](http://www.codecogs.com/png.latex?y_i "y_i") and perceptions (environment outputs)  ![](http://www.codecogs.com/png.latex?x_i "x_i") chosen from finite sets ![](http://www.codecogs.com/png.latex?\mathcal{Y} "\mathcal{Y}") and ![](http://www.codecogs.com/png.latex?\mathcal{X} "\mathcal{X}"). The perceptions are pairs ![](http://www.codecogs.com/png.latex?x_i=(o_i,r_i) "x_i=(o_i,r_i)"), where ![](http://www.codecogs.com/png.latex?o_i "o_i") is the observationpart and ![](http://www.codecogs.com/png.latex?r_i "r_i") denotes a reward_._ At time k the agent chooses its next action ![](http://www.codecogs.com/png.latex?\.{y}_k "\.{y}_k") according to the expectimax principle:

![](http://www.codecogs.com/png.latex?\.{y}_k=\textrm{arg}\max_{y_k}\sum_{x_k}\max_{y_{k+1}}\sum_{x_{k+1}}\dots\max_{y_{m_k}}\sum_{x_{m_k}}(r_k+\dots+r_{m_k})M(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}). "\.{y}_k=\textrm{arg}\max_{y_k}\sum_{x_k}\max_{y_{k+1}}\sum_{x_{k+1}}\dots\max_{y_{m_k}}\sum_{x_{m_k}}(r_k+\dots+r_{m_k})M(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}).")

Here M denotes the updated [Solomonoff prior](/lw/dhg/an_intuitive_explanation_of_solomonoff_induction/ "Solomonoff tutorial") summing over all programs ![](http://www.codecogs.com/png.latex?q\in%20Q_k "q\in Q_k") that are consistent with the history ![](http://www.codecogs.com/png.latex?\.{y}\.{x}_{%3Ck} "\.{y}\.{x}_{<k}")^[\[1\]](#Notation)^ and which will, when run on the universal Turing machine T with successive inputs ![](http://www.codecogs.com/png.latex?y_{k:m_k} "y_{k:m_k}"), compute outputs ![](http://www.codecogs.com/png.latex?\underline{x}_{k:m_k} "\underline{x}_{k:m_k}"), i.e.

### ![](http://www.codecogs.com/png.latex?M(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})=\sum_{q\in%20Q_k,\:%20T(q,y_{k:m_k})=x_{k:m_k}}\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!2^{-\ell(q)} "M(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})=\sum_{q\in%20Q_k,\:%20T(q,y_{k:m_k})=x_{k:m_k}}\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!2^{-\ell(q)}")

AIXI is a [dualistic](http://en.wikipedia.org/wiki/Dualism_(philosophy_of_mind) "Cartesian dualism") framework in the sense that the algorithm that constitutes the agent is not part of the environment, since it is not computable. Even considering that any running implementation of AIXI would have to be computable, AIXI accurately simulating AIXI accurately simulating AIXI ad infinitem doesn't really seem feasible. Potential consequences of this separation of mind and matter include [difficulties](http://wiki.lesswrong.com/wiki/Anvil_problem "Anvil problem") the agent may have [predicting the effects of its actions](/lw/8qy/aixi_and_existential_despair/ "Existential despair") on the world. 

### Utility vs rewards

So, why is it a bad idea to work with a reward system? Say the AIXI agent is rewarded whenever a human called Bob pushes a button. Then a sufficiently smart AIXI will figure out that instead of furthering Bob’s goals it can also threaten or deceive Bob into pushing the button, or get another human to replace Bob. On the other hand, if the reward is computed in a little box somewhere and then displayed on a screen, it might still be possible to reprogram the box or find a side channel attack. Intuitively you probably wouldn't even blame the agent for doing that -- people try to game the system all the time. 

You can visualize AIXI's computation as maximizing bars displayed on this screen; the agent is unable to connect the bars to any pattern in the environment, they are just there. It wants them to be as high as possible and it will utilize any means at its disposal. For a more detailed analysis of the problems arising through reinforcement learning, see [Dewey (2011)](http://www.danieldewey.net/learning-what-to-value.pdf "Value Learning").

Is there a way to bind the optimization process to actual patterns in the environment? To design a framework in which the screen informs the agent about the patterns it should optimize for? The answer is, yes, we can just define a utility function

![](http://www.codecogs.com/png.latex?U:\bigcup_{m_k=1}^\infty(\mathcal{Y}\times\mathcal{X})^{m_k}\rightarrow\mathbb{R} "U:\bigcup_{m_k=1}^\infty(\mathcal{Y}\times\mathcal{X})^{m_k}\rightarrow\mathbb{R}")

that assigns a value ![](http://www.codecogs.com/png.latex?U(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}) "U(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})") to every possible future history ![](http://www.codecogs.com/png.latex?\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k} "\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}") and use it to replace the reward system in the agent specification:

![](http://www.codecogs.com/png.latex?{y}_k=\textrm{arg}\max_{y_k}\sum_{x_k}\max_{y_{k+1}}\sum_{x_{k+1}}\dots\max_{y_{m_k}}\sum_{x_{m_k}}U(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})M(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}). "{y}_k=\textrm{arg}\max_{y_k}\sum_{x_k}\max_{y_{k+1}}\sum_{x_{k+1}}\dots\max_{y_{m_k}}\sum_{x_{m_k}}U(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})M(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}).")

When I say "we can just define" I am actually referring to the _really hard_ question of how to recognize and describe the patterns we value in the universe. Contrasted with the necessity to specify rewards in the original AIXI framework, this is a strictly harder problem, because the utility function has to be known ahead of time and the reward system can always be represented in the framework of utility functions by setting

![](http://www.codecogs.com/png.latex?U(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})=r_k+\dots+r_{m_k}. "U(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})=r_k+\dots+r_{m_k}.")

For the same reasons, this is also a strictly safer approach.

### Infinite utility

The original AIXI framework must necessarily place upper and lower bound on the rewards that are achievable, because the rewards are part of the perceptions and ![](http://www.codecogs.com/png.latex?\mathcal{X} "\mathcal{X}") is finite. The utility function approach does not have this problem, as the expected utility 

![](http://www.codecogs.com/png.latex?\sum_{x_i}u(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:i})M(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:i}) "\sum_{x_i}u(\.{y}\.{x}_{<k}y\underline{x}_{k:i})M(\.{y}\.{x}_{<k}y\underline{x}_{k:i})")

is always finite as long as we stick to a finite set of possible perceptions, even if the utility function is not bounded. Relaxing this constraint and allowing ![](http://www.codecogs.com/png.latex?\mathcal{X} "\mathcal{X}") to be infinite and the utility to be unbounded creates divergence of expected utility (for a proof see [d](http://arxiv.org/PS_cache/arxiv/pdf/0712/0712.4318v1.pdf "Divergence")[e Blanc 2008](http://arxiv.org/PS_cache/arxiv/pdf/0712/0712.4318v1.pdf "Divergence")). This closely corresponds to the question of how to be a consequentialist in an infinite universe, discussed by [Bostrom (2011)](http://www.nickbostrom.com/ethics/infinite.pdf "Infinite Ethics"). The underlying problem here is that (using the [standard approach to infinities](http://wiki.lesswrong.com/wiki/Quick_reference_guide_to_the_infinite "infinities")) these expected utilities will become incomparable. One possible solution to this problem could be to use a larger subfield than ![](http://www.codecogs.com/png.latex?\mathbb{R} "\mathbb{R}") of the [surreal numbers](http://en.wikipedia.org/wiki/Surreal_number "Surreals"), my favorite^[\[2\]](#Hyperreals)^ so far being the [Levi-Civita field](http://en.wikipedia.org/wiki/Levi-Civita_field "Levi-Civita") generated by the infinitesimal ![](http://www.codecogs.com/png.latex?\varepsilon "\varepsilon"):

![](http://www.codecogs.com/png.latex?\mathcal{R}=\{\sum_{q\in\mathbb{Q}}a_q\varepsilon^q|a_q\in\mathbb{R}\}, "\mathcal{R}=\{\sum_{q\in\mathbb{Q}}a_q\varepsilon^q|a_q\in\mathbb{R}\},")

with the usual power-series addition and multiplication. Levi-Civita numbers can be written and approximated as 

![](http://www.codecogs.com/png.latex?\lim_{n\rightarrow%20\infty}\sum_{i=0}^n%20a_{q_i}\varepsilon^{q_i} "\lim_{n\rightarrow \infty}\sum_{i=0}^n a_{q_i}\varepsilon^{q_i}")

(see [Berz 1996](http://bt.pa.msu.edu/pub/papers/rscrptsf/rscrptsf.pdf "Berz")), which makes them suitable for representation on a computer using floating point arithmetic. If we allow the range of our utility function to be ![](http://www.codecogs.com/png.latex?\mathcal{R} "\mathcal{R}"), we gain the possibility of generalizing the framework to work with an infinite set of possible perceptions, therefore allowing for continuous parameters. We also allow for a much broader set of utility functions, no longer excluding the assignment of infinite (or infinitesimal) utility to a single event. I recently met someone who argued convincingly that his (ideal) utility function assigns infinite negative utility to every time instance that he is not alive, therefore making him prefer life to any finite but huge amount of suffering.

Note that finiteness of ![](http://www.codecogs.com/png.latex?\mathcal{Y} "\mathcal{Y}") is still needed to guarantee the existence of actions with maximal expected utility, and the finite (but dynamic) horizon ![](http://www.codecogs.com/png.latex?m_k "m_k") remains a very problematic assumption, as described in [Legg (2008)](http://www.vetta.org/documents/Machine_Super_Intelligence.pdf "Horizon problem").

### Modifiable utility functions

Any implementable approximation of AIXI implies a weakening of the underlying dualism. Now the agent's hardware is part of the environment and at least in the case of a powerful agent, it can no longer afford to neglect the effect its actions may have on its source code and data. One question that has been asked is whether AIXI can [protect itself from harm](/lw/8rl/would_aixi_protect_itself/ "AIXI & anvils"). [Hibbard (2012)](http://arxiv.org/pdf/1111.3934v2) shows that an agent similar to the one described above, equipped with the ability to modify its policy responsible for choosing future actions, would not do so, given that it starts out with the (meta-)policy to always use the optimal policy, and the additional constraint to change only if that leads to a strict improvement. [Ring and Orseau (2011)](http://www.idsia.ch/~ring/Ring%2COrseau%3B%20Delusion%2C%20Survival%2C%20and%20Intelligent%20Agents%2C%20AGI%202011.pdf "Delusion Box") study under which circumstances a universal agent would try to tamper with the sensory information it receives. They introduce the concept of a delusion box, a device that filters and distorts the perception data before it is written into the part of the memory that is read during the calculation of utility. 

A further complication to take into account is the possibility that the part of memory that contains the utility function may get rewritten, either by accident, by deliberate choice (programmers trying to correct a mistake), or in an attempt to wirehead. To analyze this further we will now consider what can happen if the screen flashes different goals in different time cycles. Let 

![](http://www.codecogs.com/png.latex?u_k:\bigcup_{i=1}^\infty(\mathcal{Y}\times\mathcal{X})^i\rightarrow%20\mathbb{R} "u_k:\bigcup_{i=1}^\infty(\mathcal{Y}\times\mathcal{X})^i\rightarrow \mathbb{R}")

denote the utility function the agent will have at time k.

Even though we will only analyze instances in which the agent knows at time k, which utility function ![](http://www.codecogs.com/png.latex?u_i "u_i") it will have at future times ![](http://www.codecogs.com/png.latex?k\leq%20i\leq%20m_k "k\leq i\leq m_k") (possibly depending on the actions ![](http://www.codecogs.com/png.latex?y_{k:i-1} "y_{k:i-1}") before that), we note that for every fixed future history ![](http://www.codecogs.com/png.latex?\.{y}\.{x}_{%3Ck}y\underline{x}_{k:i} "\.{y}\.{x}_{<k}y\underline{x}_{k:i}") the agent knows the utility function ![](http://www.codecogs.com/png.latex?u_i "u_i") that is displayed on the screen because the screen is part of its perception data ![](http://www.codecogs.com/png.latex?\underline{x}_i "\underline{x}_i").

This leads to three different agent models worthy of further investigation:

*   **Agent 1** will optimize for the goals that are displayed on the screen right now and act as if it would continue to do so in the future. We describe this with the utility function   ![](http://www.codecogs.com/png.latex?U_1(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})=u_{k}(\.{y}\.{x}_{%3Ck}y\underline{x}_k)+u_{k}}(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:k+1})+\dots+u_{k}(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}). "U_1(\.{y}\.{x}_{<k}y\underline{x}_{k:m_k})=u_{k}(\.{y}\.{x}_{<k}y\underline{x}_k)+u_{k}}(\.{y}\.{x}_{<k}y\underline{x}_{k:k+1})+\dots+u_{k}(\.{y}\.{x}_{<k}y\underline{x}_{k:m_k}).")
*   **Agent 2** will try to anticipate future changes to its utility function and maximize the utility it experiences at every time cycle as shown on the screen at that time. This is captured by![](http://www.codecogs.com/png.latex?U_2(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})=u_{k}(\.{y}\.{x}_{%3Ck}y\underline{x}_k)+u_{k+1}}(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:k+1})+\dots+u_{m_k}(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}). "U_2(\.{y}\.{x}_{<k}y\underline{x}_{k:m_k})=u_{k}(\.{y}\.{x}_{<k}y\underline{x}_k)+u_{k+1}}(\.{y}\.{x}_{<k}y\underline{x}_{k:k+1})+\dots+u_{m_k}(\.{y}\.{x}_{<k}y\underline{x}_{k:m_k}).")
*   **Agent 3** will, at time k, try to maximize the utility it derives in hindsight, displayed on the screen at the time horizon  ![](http://www.codecogs.com/png.latex?U_3(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k})=u_{m_k}(\.{y}\.{x}_{%3Ck}y\underline{x}_k)+u_{m_k}}(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:k+1})+\dots+u_{m_k}(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:m_k}). "U_3(\.{y}\.{x}_{<k}y\underline{x}_{k:m_k})=u_{m_k}(\.{y}\.{x}_{<k}y\underline{x}_k)+u_{m_k}}(\.{y}\.{x}_{<k}y\underline{x}_{k:k+1})+\dots+u_{m_k}(\.{y}\.{x}_{<k}y\underline{x}_{k:m_k}).")

Of course arbitrary mixtures of these are possible.

The type of wireheading that is of interest here is captured by the Simpleton Gambit described by [Orseau and Ring (2011)](http://www.idsia.ch/~ring/Orseau,Ring;Self-modification%20and%20Mortality%20in%20Artificial%20Agents,%20AGI%202011.pdf "Simpleton"), a Faustian deal that offers the agent maximal utility in exchange for its willingness to be turned into a Simpleton that always takes the same default action at all future times. We will first consider a simplified version of this scenario: The Simpleton future, where the agent knows for certain that it will be turned into a Simpleton at time k+1, no matter what it does in the remaining time cycle. Assume that for all possible action-perception combinations the utility given by the current utility function is not maximal, i.e.  ![](http://www.codecogs.com/png.latex?u_k(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:i})%3CU_\max "u_k(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:i})%3CU_\max") holds for all ![](http://www.codecogs.com/png.latex?y\underline{x}_{k:i} "y\underline{x}_{k:i}"). Assume further that the agents actions influence the future outcomes, at least from its current perspective. That is, for all ![](http://www.codecogs.com/png.latex?k\leq%20i\leq%20m_k "k\leq i\leq m_k") there exist  ![](http://www.codecogs.com/png.latex?y'\underline{x}'_{k:i}\neq%20y\underline{x}_{k:i} "y'\underline{x}'_{k:i}\neq%20y\underline{x}_{k:i}") with ![](http://www.codecogs.com/png.latex?u_k(\.{y}\.{x}_{%3Ck}y'\underline{x}'_{k:i})\neq%20u_k(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:i}) "u_k(\.{y}\.{x}_{%3Ck}y'\underline{x}'_{k:i})\neq%20u_k(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:i})"). Let ![](http://www.codecogs.com/png.latex?u_{k+1} "u_{k+1}") be the Simpleton utility function, assigning equal but maximal utility ![](http://www.codecogs.com/png.latex?u_k(\.{y}\.{x}_{%3Ck}y\underline{x}_{k:i})=U_\max "u_k(\.{y}\.{x}_{<k}y\underline{x}_{k:i})=U_\max") to all possible futures. While Agent 1 will optimize as before, not adapting its behavior to the knowledge that its utility function will change, Agent 3 will be paralyzed, having to rely on whatever method its implementation uses to break ties. Agent 2 on the other hand will try to maximize only the utility ![](http://www.codecogs.com/png.latex?u_k(\.{y}\.{x}_{%3Ck}y\underline{x}_k) "u_k(\.{y}\.{x}_{<k}y\underline{x}_k)").

Now consider the actual Simpleton Gambit: At time k the agent gets to choose between changing,![](http://www.codecogs.com/png.latex?y_k=\textit{c} "y_k=\textit{c}"), resulting in ![](http://www.codecogs.com/png.latex?u_{k+i}\equiv%20U_\max "u_{k+i}\equiv U_\max") and ![](http://www.codecogs.com/png.latex?y_k=\textit{nc} "y_k=\textit{nc}") (not changing), leading to ![](http://www.codecogs.com/png.latex?u_{k+i}\equiv%20u_k "u_{k+i}\equiv u_k") for all ![](http://www.codecogs.com/png.latex?k+1\leq%20i\leq%20m_k "k+1\leq i\leq m_k"). We assume that![](http://www.codecogs.com/png.latex?\.{y}_k "\.{y}_k") has no further effects on the environment. As before, Agent 1 will optimize for business as usual, whether or not it chooses to change depends entirely on whether the screen specifically mentions the memory pointer to the utility function or not.

Agent 2 will change if and only if the utility of changing compared to not changing according to what the screen currently says is strictly smaller than the comparative advantage of always having maximal utility in the future. That is,

![](http://www.codecogs.com/png.latex?\sum_{x_k}[u_k(\.{y}\.{x}_{%3Ck}\textit{nc\,}\,\underline{x}_k)M(\.{y}\.{x}_{%3Ck}\textit{nc\,}\underline{x}_k)-u_k(\.{y}\.{x}_{%3Ck}\textit{c\,}\underline{x}_k)M(\.{y}\.{x}_{%3Ck}\textit{c\,}\underline{x}_k)] "\sum_{x_k}[u_k(\.{y}\.{x}_{%3Ck}\textit{nc\,}\,\underline{x}_k)M(\.{y}\.{x}_{%3Ck}\textit{nc\,}\underline{x}_k)-u_k(\.{y}\.{x}_{%3Ck}\textit{c\,}\underline{x}_k)M(\.{y}\.{x}_{%3Ck}\textit{c\,}\underline{x}_k)]")

is strictly less than

![](http://www.codecogs.com/png.latex?(m_k-k)U_{\max}-\sum_{x_k}\max_{y_{k+1}}\dots\sum_{x_{m_k}}[u_k(\.{y}\.{x}_{%3Ck}\textit{nc\,}\underline{x}_ky\underline{x}_{k+1})+\dots "(m_k-k)U_{\max}-\sum_{x_k}\max_{y_{k+1}}\dots\sum_{x_{m_k}}[u_k(\.{y}\.{x}_{%3Ck}\textit{nc\,}\underline{x}_ky\underline{x}_{k+1})+\dots")

![](http://www.codecogs.com/png.latex?\dots+u_k(\.{y}\.{x}_{%3Ck}\textit{nc\,}\underline{x}_ky\underline{x}_{k+1:m_k})]M(\.{y}\.{x}_{%3Ck}\textit{nc\,}\underline{x}_ky\underline{x}_{k+1:m_k}). "\dots+u_k(\.{y}\.{x}_{%3Ck}\textit{nc\,}\underline{x}_ky\underline{x}_{k+1:m_k})]M(\.{y}\.{x}_{%3Ck}\textit{nc\,}\underline{x}_ky\underline{x}_{k+1:m_k}).")

This seems quite analogous to humans, who sometimes tend to choose maximal bliss over future optimization power, especially if the optimization opportunities are meager anyhow. Many people do seem to choose their goals so as to maximize the happiness felt by achieving them at least some of the time; this is also advice that I have frequently encountered in self-help literature, e.g. [here](/lw/3w3/how_to_beat_procrastination/ "Procrastination"). Agent 3 will definitely change, as it only evaluates situations using its final utility function.

Comparing the three proposed agents, we notice that Agent 1 is dynamically inconsistent: it will optimize for future opportunities, that it predictably will not take later. Agent 3 on the other hand will wirehead whenever possible (and we can reasonably assume that opportunities to do so will exist in even moderately complex environments). This leaves us with Agent model 2 and I invite everyone to point out its flaws.

[\[1\]](#re:Notation) Dotted actions/ perceptions, like ![](http://www.codecogs.com/png.latex?\.{y}_i "\.{y}_i") denote past events, underlined perceptions ![](http://www.codecogs.com/png.latex?\underline{x}_i "\underline{x}_i") denote random variables to be observed at future times.

[\[2\]](#re:Hyperreals) [Bostrom (2011)](http://api.viglink.com/api/click?format=go&key=9f37ca02a1e3cbd4f3d0a3618a39fbca&loc=http%3A%2F%2Flesswrong.com%2Fr%2FAnja-drafts%2Flw%2Ffeo%2Funiversal_agents_and_utility_functions%2F%23Hyperreals&v=1&libid=1352865529158&out=http%3A%2F%2Fwww.nickbostrom.com%2Fethics%2Finfinite.pdf&ref=http%3A%2F%2Flesswrong.com%2Fr%2FAnja-drafts%2Fedit%2Ffeo&title=Universal%20agents%20and%20utility%20functions%20-%20Drafts%20for%20Anja&txt=Bostrom%20(2011)&jsonp=vglnk_jsonp_13528655488862) proposes using [hyperreal numbers](http://en.wikipedia.org/wiki/Hyperreal_number "Hyperreals"), which rely heavily on the axiom of choice for the ultrafilter to be used and I don't see how those could be implemented.