But I still can't see how anybody can get round the book in a safe example.
Robin, are you a programmer? No matter. Imagine a computer simulation of a simple 2D world where the agents in the world are simple dots that apply a constant force always in their direction of movement. In other words, they all move straight. There are also walls all around the edge of the screen, and a few walls as obstacles inside the screen. Imagine that if they hit each other or a wall, they bounce off and continue moving straight in the direction of the bounce. You've seen screen savers with similar behavior, so nothing new here.
Imagine that this simulation has a timeline running horizontally along the bottom, and pre-calculates the entire system from time 0 until 60 units of time. You can then click anywhere on the timeline and a window pops up showing you the world at that time. You can open up multiple windows in time in this manner by clicking on more than one spot on the timeline. Pretty simple system so far, and completely deterministic.
Now, let's give our agents some perception of their world and a memory of that perception. At each unit of time, each agent can "remember" the positions of all other agents and walls that it has a straight-line view of within a 300-pixel radius for the 30 previous units of time.
Now let's give the agents a bit of intelligence. Mind you, this is going to be completely deterministic intelligence. We will write a function that looks at the agent's memory, sees which other agents or walls it is currently on a collision course with, and if it is within, say 50 pixels of colliding with another agent or wall it will turn 90 degrees to the right. Let's provide each agent the same behavior for now.
When we start the simulation, we can give each agent a starting position, direction, and force, and then the simulation can calculate the entire 60 units of time for every agent by calling each agent's function for each unit of time from 0 to 60 (we have a very fast computer, so this happens almost instantly). We can then click on any point along the timeline and open up a view to the world at that time. Nothing exciting yet, the world is completely deterministic, although it is clear that we are not constrained by the timeline for this world since we can view the past, present, and future simultaneously by opening up multiple windows.
Now, imagine that we want to interact with the world by inserting a new wall into the world at time 30 (it will simply appear in the world at time 30). If we did this, we would have to recalculate all of the memories and positions of all agents from time 30 through time 60 because the new wall might affect their futures (but since the new wall didn't exist before time 30, we don't have to recalculate their past). Also, we really only have to recalculate the memory and positions of those agents who are directly or indirectly affected by the new wall. For example, if the world were divided in half by a wall so that all agents on one side of the world didn't know of the existance of the agents on the other side of the world, we would only have to recalculate the futures for the agents on the side of the world with the new wall (the others would be unaffected by the presence of this new wall). Note that if we never interact with the world, we never have to recalculate the timeline at all (it would be as if we didn't exist).
Now, imagine we want to give one of the agents free will, or at something like it. We can't give it "real" free will, but we'll give it something that meets our goal which is to make it so that we as the programmer cannot predict what the agent will choose. We replace this agent's deterministic function with a new one that is "non-deterministic." Instead of always turning right like the other agents, this "free agent" randomely "chooses" between turning left or stopping for 5 units of time. Every time this function is called, it will return one of these choices, but we have no way of knowing which.
So far so good. One more thing to do before we begin the simulation. Let's set up a "safe" of walls surrounding an empty square somewhere in the middle of the world. No agents have access to the inside of the safe.
Now, we begin the simulation by recalculating the entire timeline from 0 to 60. We open up a window at time 30 and notice that the free agent is turning left at this time to avoid running into a wall. We then click on the timeline at time 10 and open up a new window.
Even as we watch the free agent in this second window, we already know that at time 30 the agent will turn left even though it has "free will" which is unpredictable to us. As long as we don't interact with the world before time 30, this will be true. If we interact with the world after time 30, only the free agent's future will be altered so the choice to turn left at time 30 won't be affected.
Now at time 10, we insert a new wall on which is written the word "LEFT" completely contained inside the safe. Since no agents have access this new wall cannot affect any agent. Nothing needs to be recalculated, and the free agent will turn left as expected at time 30.
We have foreknowledge of the agent's future but the agent has free will. As long as we're careful about how we interact with the world, we can ensure that the foreknowledge will be accurate. Even if we decide to interact with the world, as long as we do it after time 30 or in such a way that it won't affect the free agent's history at time 30, we know that the agent will always turn left at time 30. For example, we could remove one of the walls to the safe at time 40, and the agent could run into the message wall, but it won't affect the agent's past behavior at time 30. Even if we DID want to interfere with the free agent's history at time 30 by placing a new wall into the world in front of the agent, say at time 20, we would instantly know what the agent's new future is at time 30.
-Bri