Allow me to restate the problem in my own words. We are asked to produce a general purpose function named "agent()" which returns a positive integer. The returned result is intended to represent a choice (made by "agent()") among a discrete collection of options. There is one implicit parameter to agent - the source code for second function named "world()". This second function returns an integer result as well, but this result is to be interpreted as a kind of payoff. The objective in this exercise is to produce an agent() function which maximizes the result returned by an arbitrary world().

The code of the function world() is expected to include one or more calls to agent(). For example, when modeling a Newcomb or Parfit's hitchhiker decision, the world() will call agent() at least once on behalf of Omega in order to predict what the agent will do later. Then world calls agent() a second time, this time "for real". Or, in a symmetric Prisoner's dilemma, agent() might be called twice, once for each decision-making prisoner.

Slepnev (cousin it?) suggests that the way agent() should be structured is as a theorem-prover, rather than as a simulator. (This approach has the important technical advantage of better control over non-termination.)

Ok, that is my summary - my understanding of what is going on here. Now for my questions:

• Do I seem to understand?
• Did I leave out any key points?
• Is there any reason not to extend this to situations in which world() passes parameters to agent(). For example, if we wanted to do a PD in which the payoffs to the two players are slightly different, world() could pass different actual values in its two calls to agent(), because those two calls represent different players. So we want a parameter to represent "player id".
• Is there any reason not to allow world() to pass parameters representing random numbers to the agent()s? This would allow the agents to choose mixed or correlated strategies, if these kinds of strategies prove to be optimal.
• The way the Newcomb example was written, it was pretty clear that agent() was being assumed to be deterministic. How essential is that assumption to this whole enterprise?

That is enough questions for now. Depending on the answers, I may have follow-ups.

Edit: minor cleanups.