# Center Court at Wimbledon The number of possible tennis games that can be played in a single environment — that is, rendered by a single [Program](Program.md) — is very large. Consider a rendering of the Center Court at Wimbledon from the point of view of a player. Suppose, very conservatively, that in each second of the game the player can move in one of two perceptibly different ways (perceptibly, that is, to the player). Then after two seconds there are four possible games, after three seconds, eight possible games, and so on. After about four minutes the number of possible games that are perceptibly different from one another exceeds the number of atoms in the universe, and it continues to rise exponentially. For a program to render that one environment accurately, it must be capable of responding in any one of those myriad, perceptibly different ways, depending on how the player chooses to behave. If two programs respond in the same way to every possible action by the user, then they render the same environment; if they would respond perceptibly differently to even one possible action, they render different environments. That remains so even if the user never happens to perform the action that shows up the difference. The environment a program renders is a [Logical Property](Logical%20Property.md) of the program, independent of whether the program is ever executed. This is because there is a deep connection between [Logic and Programs](Logic%20and%20Programs.md). [Computation is a Logical Process](Computation%20is%20a%20Logical%20Process.md). This means that *result* of a computation is not dependent on whether a the corresponding computation was enacted or not. It is a fixed property of the program (and the computation it would have caused to be performed). This is entirely analogous to a true [Proposition](Proposition.md) being true, regardless of if it is [*proved*](Proof.md) to be true. For instance, the number $6892346983459091245$ is either prime or not prime. One of those propositions is true. This holds regardless of whether we execute a proof of either proposition. So, a rendered environment is accurate in so far as it would respond in the intended way to every possible action of the user. Thus its accuracy depends not only on experiences which users of it actually have, but also on experiences they do not have, but would have had if they had chosen to behave differently during the rendering. This gives rise to an important difference between image generation and virtual-reality generation. The accuracy of an image generator’s rendering can in principle be experienced, measured and certified by the user, but the accuracy of a virtual-reality rendering never can be. If you are a tennis fan who knows Wimbledon’s Centre Court perfectly, you can never confirm that a purported rendering of it is accurate. Even if you are free to explore the rendered Centre Court for however long you like, and to ‘[kick](Dr%20Johnsons%20Criteria.md)’ it in whatever way you like, and even if you have equal access to the real Centre Court for comparison, you cannot ever certify that the program does indeed render the real location. For you can never know what would have happened if only you had explored a little more, or looked over your shoulder at the right moment. Perhaps if you had sat on the rendered umpire’s chair and shouted ‘fault!’, a nuclear submarine would have surfaced through the grass and torpedoed the Scoreboard. On the other hand, if you find even one difference between the rendering and the intended environment, you can immediately certify that the rendering is inaccurate. This is heavily related to the [Asymmetry Between Experimental Refutation and Experimental Confirmation](Asymmetry%20Between%20Experimental%20Refutation%20and%20Experimental%20Confirmation.md). --- Date: 20241214 Links to: Tags: References: * []()