Free Agency and Determinism: Is There a Sensible Definition of Computational Sourcehood?

Can free agency be compatible with determinism? Compatibilists argue that the answer is yes, and it has been suggested that the computer science principle of “computational irreducibility” sheds light on this compatibility. It implies that there cannot, in general, be shortcuts to predict the behavior of agents, explaining why deterministic agents often appear to act freely. In this paper, we introduce a variant of computational irreducibility that intends to capture more accurately aspects of actual (as opposed to apparent) free agency, including computational sourcehood, i.e., the phenomenon that the successful prediction of a process’ behavior must typically involve an almost-exact representation of the relevant features of that process, regardless of the time it takes to arrive at the prediction. We argue that this can be understood as saying that the process itself is the source of its actions, and we conjecture that many computational processes have this property. The main contribution of this paper is technical, in that we analyze whether and how a sensible formal definition of computational sourcehood is possible. While we do not answer the question completely, we show how it is related to finding a particular simulation preorder on Turing machines, we uncover concrete stumbling blocks towards constructing such a definition, and demonstrate that structure-preserving (as opposed to merely simple or efficient) functions between levels of simulation play a crucial role.


Introduction
Do humans, animals, some machines, or other systems or processes have some sort of control over their actions that deserves to be called "free will"? This question has been discussed in various forms in the philosophical literature over the last two millenia (see, e.g., Ref. [1] for an introduction). At first sight, the fact that agents are subject to the same laws of nature as stones and atoms seems to be in tension with an intuitive understanding of free will; after all, when an agent has taken a decision, they will fundamentally never have had the "freedom to do otherwise". Moreover, one might be inclined to think that it is not the agent, but rather the laws of nature (and initial conditions) that represents the "source" of the agent's actions. While quantum theory suggests that the fundamental laws of nature are best understood as probabilistic rather than deterministic, it has been convincingly argued [2][3][4] that decisions are not free simply because they are random. Therefore, the question of compatibility of determinism and free will remains relevant even in the face of indeterminism (for the complementary question of compatibility of free agency and indeterminism, see, e.g., [5]).
Among the various positions in the debate, compatibilism [3,6] amounts to the claim of a positive answer to this question. Compatibilists have argued against the incompatibility of free will and determinism in a variety of ways, such as by rejecting the idea that the freedom to do otherwise is necessary for free will; by claiming that the freedom to do otherwise is compatible with determinism; or by formulating ways in which sourcehood can be ascribed to an agent even in a deterministic world (for an overview, see Ref. [7]).
In a complementary development, there have been proposals to analyze the relation between determinism and free will via theoretical computer science. After all, we do not live in an arbitrary deterministic (or probabilistic) world, but in a world that seems to comply with physical versions of the Church-Turing thesis [8,9]. This suggests to treat decision-making systems (including agents) and predictors as algorithms in some sense, and to contemplate aspects of free will with information-theoretic notions and methods. Two such approaches (described in more detail in Section 2 below) offer an explanation for why some physical systems (in particular human agents) appear to have free will. One approach, computational irreducibility [10][11][12][13], demonstrates that the behavior of many physical systems cannot be predicted without simulating every single step of their time evolution in full detail. Another approach, based on time complexity arguments [14], shows that it takes typically more time to predict an agent's actions than it takes the agent to come to its decision by itself. In a nutshell, decision making systems do not in general admit shortcuts. However, as already noted by Bringsjord [15], this insight in itself may explain some of the phenomenology of free will, but it does not have much to say about whether agents are actually free.
In this paper, we suggest to study a variant of computational irreducibility that is intended to formalize an aspect of actual free will more directly, a computational notion of sourcehood. In a nutshell, we ascribe computational sourcehood to a computable process P if attempts to reproduce its outputs can typically only succeed by running an almost-exact step-by-step simulation that contains all functionally relevant aspects of P. In contrast to computational irreducibility, we do not focus on the time it takes to perform the simulation, i.e., computational sourcehood claims that such "cloning" of the simulated process is also necessary if the simulation takes an arbitrarily long time. Thus, if we regard the collection of all relevant abstract information-theoretic elements of P as (part of) an agent, then it is always this agent that is invoked when P's behavior is generated, reproduced or predicted. We conjecture that this kind of sourcehood is indeed "typical", i.e., that it can be attributed to a large variety of computational processes.
We will follow a careful terminology choice also made by Müller and Briegel [5]: we will mostly avoid talking about "free will" (unless when we follow other authors), and use the notion of "free agency" instead, in order to avoid arousing associations with specifically human aspects of this notion. As Müller and Briegel put it, "In philosophy, free will is mostly tied to specifically human traits, such as being the proper subject of moral praise and blame, or a capacity for conscious deliberation or for the linguistic expression of self-reflective thought." These traits are irrelevant for the purpose of this paper, since we will concentrate on a single specific notion, that of sourcehood, and the question of whether a technical, formal definition of it can be found. It is clear that the specifically human notions mentioned above can play no role in such a definition.
For similar reasons, details of the human decision-making process (as described, for example, by neuroscience or biology) will play no role in our analysis, and so will questions of semantics as discussed in general theories of information [16]. Similarly to Lloyd's, our analysis will operate on a more abstract level, and the in-principle applicability of our results to physical systems, including humans, can be motivated by the simple observation that "[. . .] because the known laws of physics can be simulated on a computer, the dynamics of the brain can be simulated by a computer in principle-it is not necessary that we know how to simulate the operation of the brain in practice." [14]. A different motivation for our approach (and those by Lloyd and Wolfram) may come from versions of the computational theory of mind [17].
The purpose of our paper is not to argue for any of those views, but to consider a specific technical question about algorithms that can be motivated by them.
Our article is organized as follows. In Section 2, we give a brief summary of previous "no-shortcut" approaches to apparent free agency, including computational irreducibility and time complexity arguments. We introduce the idea of computational sourcehood and its difference to computational irreducibility with a thought experiment ("John the cook") in Section 3 and more formally in Section 4. Section 5 contains the technical results of this paper, including successively improved attempts at formally defining a version of computational sourcehood that is non-trivial, meaningful, and has the chance to lead to a sensible formulation of our main conjecture (that many processes are the computational sources of their behaviors). Finally, we conclude in Section 6.

No-Shortcut Approaches to Apparent Free Agency
In this section, we briefly summarize two approaches intended to explain the phenomenology of free agency using a computational perspective. Both approaches have in common that they identify the huge effort necessary to predict an agent's decisions as an account of apparent freedom. As we will see, the approaches differ in how they expose the difficulty of agent predictions. While the first approach (which is closely related to ours) focuses on the non-existence of shortcuts and simplifications in the prediction process, the second approach focuses on computation time and uncomputability.

Computational Irreducibility
One concept in computer science that has been suggested to shed new light on the relation between free agency and determinism is computational irreducibility, proposed by S. Wolfram [10].
To explain this concept, let us consider the success of scientific predictions. Most physical systems are extremely complex objects constructed from a vast number of smaller parts. Nonetheless, often the behavior of crucial properties of such complex systems can be described with a few equations. For example, in mechanics, many of the considered physical systems are extended objects. Such systems consist of countless atoms, which themselves are built from smaller particles. However, as we know from our mechanics lectures, predicting the evolution of the mechanical properties of these systems often does not require a simulation of all the individual parts. e.g., in astronomy, the orbits of gas planets can be well approximated via Kepler's laws, without the need to consider all the gas molecules involved in the movement of the planet.
These considerations teach us that the behavior of some important properties of complex physical systems can be predicted without having to model all their microscopic features. This implies that these predictions are possible because the simulation allows for massive shortcuts and simplifications. Now, Wolfram's concept of computational irreducibility refers to the observation that not all physical properties and complex systems allow for such shortcuts and simplifications. In other words, there exist physical questions that require a near-perfect simulation of all the details involved to be answered. While Wolfram formulates this notion for computable processes, he follows a strong intuition that our physical world does indeed correspond to a computation of some sort. Physical versions of the Church-Turing thesis aim to substantiate such intuitions in different possible ways [8,9].
In their book [10], Wolfram suggests the possibility that agents, including humans, show behavior that is computationally irreducible, even if the agent is deterministic. In other words, answering some questions about the future of an agent might require full simulation of all functionally relevant details of the agent's thought process and environment. Wolfram argues that this might be the origin of apparent free will: "And it is this, I believe, that is the ultimate origin of the apparent freedom of human will. For even though all the components of our brains presumably follow definite laws, I strongly suspect that their overall behavior corresponds to an irreducible computation whose outcome can never in effect be found by reasonable laws." This explanation of free will was criticized by S. Bringsjord [15] as being "epistemologically correct", but "metaphysically wrong", in particular: "If someone's will is apparently free, it hardly follows that that will is in fact free. Nowhere in ANKS [his book] does Wolfram even intimate that he maintains that our decisions are in fact free." We will reconsider this distinction, and the role of computational notions in its analysis, in Section 4, where we take it as an inspiration to introduce a modified version of computational irreducibility.
While Wolfram discusses the phenomenology and implications of computational irreducibility and provides examples in terms of cellular automata, he does not give an exact formalization of this notion in Ref. [10]. Such a formal definition has been proposed via Turing machines by H. Zwirn and J.-P. Delahaye [11,12]. In a nutshell, they call a function f : N → N computationally irreducible if all efficient Turing machines computing f (n) will essentially also have to compute f (1), . . . , f (n − 1). While this corresponds to a straightforward implementation of the main properties of Wolfram's examples (in particular if f (n) encodes the nth row of a cellular automaton), it is not clear whether this formulation is the most suitable one for the study of free agency. Additionally, since many choices of detail have to be made in the construction of the definition, it is not clear how many functions actually satisfy it.

Lloyd's Time Complexity Argument
Secondly, we consider S. Lloyd's [14] idealization of agents as Turing machines, more specifically as computable deciders. Such deciders are Turing machines that map a description of a decision problem to a yes/no answer, or fail to come to a conclusion. More formally, a (computable) decider d is identified with a Turing machine that receives an input string k, and outputs d(k) ∈ {0, 1} or fails to halt, i.e., d(k) undefined. Lloyd considers a function f (d, k) that is supposed to predict the answers of all such deciders d for all inputs k. By adapting the proof of the halting problem, Lloyd argues that such a function must be uncomputable: "The unpredictability of the decision-making process does not arise from any lack of determinism-the Turing machines involved could be deterministic, or could possess a probabilistic guessing module, or could be quantum mechanical. In all cases, the unpredictability arises because of uncomputability." Nonetheless, as Lloyd points out, decisions in real environments usually have to be made within a limited amount of time. Therefore, he considers time-limited deciders and argues that for such time-limited deciders a program predicting all decisions is computable. However: "In summary, applying the Hartmanis-Stearns diagonalization procedure shows that any general method for answering the question 'Does decider d make a decision in time T, and what is that decision?' must for some decisions take strictly longer than T to come up with an answer. That is, any general method for determining d's decision must sometimes take longer than it takes d actually to make the decision." Using the diagonalization argument to discuss self-reference of universal deciders, Lloyd arrives at the following conclusion about free will: "Now we see why most people regard themselves as possessing free will. Even if the world and their decision-making process is completely mechanistic-even deterministic-no decider can know in general what her decision will be without going through a process at least as involved as the decider's own decision-making process. In particular, the decider herself cannot know beforehand what her decision will be without effectively simulating the entire decision-making process. However, simulating the decision-making process takes at least as much effort as the decision-making process itself."

John the Cook: A Thought Experiment
To set the stage, consider the following thought experiment. Suppose that John Smith is a very talented (and emotional) cook. Every morning, he decides what kind of breakfast to prepare, but their repertoire of meals is very large. On some mornings, he might remember their late Canadian wife and then prepare a particular omelette with cranberries and maple syrup. On other mornings, he might prepare a Pho soup in memory of their travels to Vietnam. The number of different breakfasts he might cook extends into the thousands.
Suppose we would like to predict what John is going to eat tomorrow morning. Furthermore, suppose that our prediction task is made particularly easy by assuming that physics is perfectly deterministic, and, in fact, computable and discrete at some microscopic scale. Since we know that John is going to spend the evening and night in their apartment, we are going to build a huge machine around their house; it scans the apartment to perfect accuracy, and then simulates their apartment (including John's brain and body) on an extremely powerful computer. We would like our simulation to tell us John's choice of breakfast well before dawn; it is certainly more fun to make a prediction before the predicted event has happened. To set the stage, consider the following thought experiment (illustrated in Figure 1).

Figure 1.
A universal computer (in the safe, on the right) reproduces the outputs of another process, i.e., its observable actions (John preparing breakfast, on the left). Computational sourcehood means that this prediction cannot typically be successfully performed without representing all relevant elements (here: thoughts, emotions) of that process in the simulation.
However, we are familiar with the phenomenon of computational irreducibility and are thus warned that the simulation may have to be really detailed in order to succeed. Furthermore, Lloyd's arguments [14] apply, so we should be prepared that our simulation finishes only after John has arrived at their decision. Therefore, we take precautions; directly after scanning John and their apartment, before starting the simulation, we put the scan data and the computer into an immensely secure safe.
If the simulation finishes before breakfast, we can directly confront John with our successful prediction. Otherwise, we can invite John to our laboratory and let them witness how we open the safe and obtain the delayed prediction. In both cases, we might then be inclined to say (unjustifiably, as we argue below): "See, John? You think that you and your emotions were irreducibly involved in the decision to prepare the Canadian omelette, but what happened in the safe was only determined by your (and your apartment's) physical state yesterday night. Your thoughts and emotions this morning had no impact on the decision whatsoever!" However, would this denial of free agency indeed by justified? We argue that the answer to this question does not depend on any possible time delay in this thought experiment. The crux of the situation-that reproducing the decision seems in principle possible without an element that John regards as a crucial aspect of their free will-is the same regardless of the simulation time. However, this suggests that questions of efficiency should ultimately be irrelevant for the problem of free agency.
We argue that the relevant question is a different one. An important aspect of John's impression to make a free, autonomous choice is that the particular class of emotions and thoughts in their mind are in some meaningful sense the source of the decision, the choice of breakfast. That is, not only have they been involved in the causal chain of physical events leading to a particular decision, but their presence seems indispensable to ultimately arrive at the decision. This motivates us to ask a specific question about the simulation in the safe: did the simulation necessarily contain correlates of these emotions and thoughts? In other words, did the simulation-and does every successful simulation-also have to "think about John's late wife" in some sense?
If the answer is "no" and such simulations can typically predict the decision by completely unrelated means-say, either by a drastic shortcut or by a completely different method-then John may rightly be worried. On the other hand, a positive answer to this question opens up the possibility to ascribe John sourcehood for their decisions. As is standard for some compatibilist positions [7], we can do so by interpreting these thoughts and emotions as parts of John's identity. In other words, if we identify John the agent not with the particular matter that encompasses their brain in the apartment, but with the collection of functionally relevant structures represented in their brain, then this agent is the source of its decisions; the simulated process in the safe has simply contained another representation of John.
It is not the purpose of this paper to make these conceptual ideas and arguments philosophically fully rigorous. Instead, the above merely serves as a motivation to consider a specific technical question in computer science: can we find a formal definition of a notion of "computational sourcehood" which expresses the property above in a sensible way? That is, if an algorithm simulates the behavior of another one, does it typically have to reproduce its features exactly? We argue that the possibility of formalization of this idea is a necessary condition for even considering any philosophically advanced and detailed instantiation of these ideas; the impossibility of formalization is often an important indicator that the motivating ideas cannot hold water.

Computational Sourcehood
Let us begin by rephrasing some aspects of the "John the cook" thought experiments in computer science terminology. Think of John as a Turing machine (TM) T, with the configuration of John's apartment and the content of their brain yesterday night as the input, and think of the computer in the safe as a universal TM U. (Here we focus on TMs only because it is the most well-known model of computation, and we think that our results are independent of the choice of model that is used to implement computations.) John's observable actions (in particular, their choice of breakfast) are to be found among T's outputs, and U is able to reproduce these outputs exactly. Does this tell us anything about the way how U arrives at these outputs?
Intuitively, universal TMs simulate other TMs T exactly and step by step; as we will explain below, this is certainly true for all universal TMs that are described in standard textbooks. Now, if this is true for the computer in the safe, then the answer to the above question is positive: yes, the computer has reproduced copies of the neural correlates (representations) of John's thoughts and emotions. However, is this so by necessity?
Universal TMs U can be fed a description of another TM T together with some input x, and they can use this to compute the output of T on input x. It seems extremely hard to imagine that there would be any other way for U to do so rather than by simulating T step by step-with perhaps some rare exceptions (some TMs T may have obvious inefficiencies that can easily be shortcut by U). Thus, it is natural to conjecture that there is a large class of Turing machines T such that all universal TMs have to resort to some form of step-by-step simulation to simulate them on most inputs: There is a large class of Turing machines T that are "the source of their own actions" in the following sense. Consider any TM U that is universal, i.e., that can emulate every other TM T; that is, for every TM T and every input x on which T halts, where T → p T is an effective description of the TM T. Then, for all T ∈ T, the universal TM U will generate the output U(p T , x) for most inputs x in such a way that it contains during its simulation, in suitable form and at suitable time steps, exact copies of the subsequent states that the machine T takes during its computation on input x. We may then speak of either T, or a given pair (T, x), as an instance of "computational sourcehood". Establishing a formal version of this conjecture would allow us to reason that John can be viewed in a specific sense as the "source of their own actions", assuming that the Turing machine T he implements is contained in the set T. However, regardless of the problem of free agency, establishing or disproving formal versions of the above might yield interesting insights into the nature of universal computation.
Clearly, this notion of computational sourcehood is closely related to computational irreducibility, as both concepts claim that an exact representation is necessary for prediction. However, computational irreducibility focuses more on the impossibility to speed up a computation, whereas computational sourcehood claims more generally that every successful prediction of the results of a computation must involve an exact image of the original, even slow ones. This implies, in particular, that no essential speed-ups are possible, but it makes additional claims about the structure of simulations, including those that take substantially longer time.

Textbook Universal Turing Machines Behave as Conjectured
It is a straightforward yet cumbersome exercise to formally construct a universal TM in a rigorous way. We will now sketch a construction given in the textbook by Hennie [18]; for another choice, see, e.g., Hopcroft et al. [19].
TMs come in different versions. What all definitions have in common is a finite set Q of internal states of the machine, including an identified initial state q 0 (and sometimes a final state q f = q 0 ). Every TM has a finite number n of tapes, such that each tape has a set of cells that is either indexed by the natural numbers N = {0, 1, 2, . . .} (a "one-way infinite" tape) or by the integers Z = {. . . , −2, −1, 0, 1, 2, . . .} (a "two-way infinite" tape). Every tape cell contains one symbol of a finite alphabet Σ, and there is a special "blank symbol" # ∈ Σ that is carried by all but finitely many tape cells. For every tape, the TM has a tape head that moves along that tape and points at a particular cell at any given time.
Single steps of operation are determined by a (perhaps partial) transition function, which we may write as We interpret this as follows. At every time step, if the TM is in internal state q and reads the symbols σ = (σ 1 , . . . , σ n ) on its n tapes (the content of the cells where the tape heads are pointing), then it replaces the tape contents by σ = (σ 1 , . . . , σ n ), transitions into the new internal state q , and moves the head on tape i either to the left (if d i = L), to the right (if The initial state of the TM-in particular, the way that the input is supplied to the tapes-depends on the convention of choice, except that the initial internal state is always assumed to be q 0 . For our purpose, we assume that all but a finite number of tape cells must initially carry the blank symbol #, so that the input is finite in this sense. If, at any time step, the TM reaches the state q f , then it "halts", and the content of one or all of the tapes is-according to some choice of convention-interpreted as the TM's output. Depending on the choice of convention, there may also be other events that are interpreted as "halting" (in particular, if the TM is not assumed to have a distinguished state q f ∈ Q); for example, trying to turn left from cell 0 of a one-way infinite tape, or having δ undefined on the current combination of q and σ.
Hennie [18] makes a particular choice of convention for defining TMs and for constructing a universal TM. He considers TMs that have a single (n = 1) one-way infinite tape, no final state q f , and a finite alphabet Σ = {0, 1, . . . , k}, where 0 denotes the blank symbol. The set of internal states is denoted Q = {0, 1, . . . , m}, where q 0 := 0 is the initial state. The tape head direction can be either left (L = 0) or right (R = 1), but the head cannot stay at its current position. The TM is assumed to halt if it either runs off the tape (to the left of cell 0), or if it lands in a combination of internal state q and tape symbol σ, such that δ(q, σ) is undefined. Hennie is not particularly explicit in defining what the "input" or "output" of the TM computation shall be (some function of the initial resp. final tape pattern): the choice of convention for how to do so can be adapted to the desired context.
Values of the transition function like Hence, every TM T can be represented as a finite list of such quintuples. We will consider this list to be ordered, and by convention to start with a quintuple that begins with the starting state q 0 . We now obtain the first step of Hennie's construction of a universal TM, the choice of description p T of a TM T. The description p T will be a binary string, namely a unary representation of the quintuples that define T. This is best explained by one of Hennie's examples. Consider the TM described by the quintuples (q 0 , 1, 0, R, g 1 ), (q 1 , 0, 1, R, q 2 ), (q 1 , 1, 1, R, q 1 ), (q 2 , 0, 0, L, q 3 ), (q 3 , 0, 0, R, q 0 ), (q 3 , 1, 1, L, q 3 ).
Recalling that internal states and directions are also integers, we obtain the equivalent (but less readable) form Denoting k consecutive 1's by 1 k , the unary representation of a quintuple is (a, b, c, d, e) → 1 a+1 01 b+1 01 c+1 01 d+1 01 e+1 , and we will describe a sequence of quintuples by concatenating the descriptions of each quintuple, separated by pairs of blank symbols (zeros). That is, our representation of the example TM becomes 1011010110110011010110110111001101101101101100 111010101011110011110101011010011110110110101111.
In addition to the description p T of the TM T, we also have to supply our universal TM U with the tape content x of TM T. Formally, where p T , x is the initial tape content of U that by definition encodes the pair p T and x. Note that we cannot simply define p T , x to be the concatenation of p T and x; first, the machine needs to know where p T ends and x starts; and second, the alphabet Σ U of U will, in general, be different from the alphabet Σ T of T (potentially containing fewer elements), so that x cannot in general be directly copied from T's tape to that of U.
Hennie chooses the following construction. Given the initial tape content x = x 1 x 2 x 3 . . . of T (with x i ∈ Σ T ), consider the unary encoding By construction, the TM U shall contain three distinguished "marking symbols" A, B, C ∈ Σ U \ {0, 1}. Then, the full encoding is defined as In summary, the cells between A and B represent a buffer region that is large enough to contain a unary representation of T's current internal state q and currently scanned tape symbol σ. The region between B and C contains the description of T, and the rest of the tape contains a description of T's initial tape content.
In essence, the TM U is constructed to work as follows. It copies the current description of T's internal state q (which is what succeeds the B marker) and the current description of T's scanned tape cell σ (succeeding the C marker) into the buffer region. Then, U scans the p T region to find the quintuple beginning with the combination (q, σ) inscribed in the buffer region (if no such quintuple is found then U halts) and moves the B marker in front of that quintuple. Finally, U reads the direction d ∈ {L, R} and new tape symbol description σ ∈ Σ T , updates T's tape description accordingly, and moves the C marker either left or right (if it moves left then it checks whether this would imply that simulated T runs off the tape; if so U halts). Then it restarts this cycle.
For a more detailed description of U, see [18] (Sec. 2.3). In principle, to define U, one would have to give the detailed definition of its transition function δ U (or, equivalently, its long list of defining quintuples). This would be extremely cumbersome. Hence, what is done instead is to argue that subroutines such as "copying" or "searching" can be incorporated into the definition of U by effectively using other TMs as "submachines". This is explained in [18] (Sec. 2.1).
More generally, in the rest of the paper, we will often simply describe in words how a TM is supposed to work on the contents of its tapes, and assume that this can in fact be implemented in the definition of the TM in some way. In addition to the possibility of checking the validity formally for each single case, such reasoning is standardly justified via the Church-Turing thesis.
To formulate in (semi-formal) detail how Hennie's construction satisfies our conjecture, let us introduce one additional piece of notation. Given any TM T, input x, and time t ∈ N, denote by C T (x, t) the configuration of T after having computed for t steps on input x. With "configuration", we mean a complete description of the content of its tapes, of its internal state q, and of the location of its tape head(s). The (countable) set of all possible configurations of TM T will be denoted C T . The countable set of all configurations that any Turing machine of this sort can hold is denoted C := T TM C T ; this is the set of all configurations where the control is in some integer state, the tape head points somewhere, and finitely many tape cells are filled by integers (and the rest with blanks). This allows us to formulate the following observation.

Observation 1.
Hennie's universal TM U has the following property. There exists a "simple" function ϕ : C U → C and, for every TM T, an increasing function τ T : N → N, such that In other words, the time evolution of T on input x can "easily be read off" from the time evolution of U on inputs p T and x, with a possible slowdown t → τ T (t). Moreover, the function τ T has a simple characterization in the following way. If we follow the step-by-step evolution of U(p T , x) for times τ = 1, 2, 3, . . ., then we can directly observe whether τ = τ T (t) for some t or not. Namely, if U has returned to the beginning of its simulation cycle at time τ, then this is the case, and otherwise not. We can determine t by starting at t = 0, and by increasing t by one whenever U's computation restarts its cycle.
In other words, Hennie's universal TM works exactly as described in our Informal Conjecture; it simulates every TM T step by step, and reproduces exact images of the computational state of T at suitable time steps.
In most textbooks, emphasis is placed on the fact that the simulation of T by U leads to a slowdown that is at most polynomial; in our notation, this means that the function t → τ t grows at most polynomially. However, for our purpose, this fact is not particularly relevant; as discussed earlier, we are not interested in the time it takes to arrive at a prediction, but in the information that is involved in generating the prediction.
The function ϕ is essentially an extended "snapshot function" of the simulated TM [20]. It can easily be described in words: the obtain T's internal state q at time t, just look at the buffer region to the right of symbol A at time τ t . To see the position of the tape head, simply search for the marker C and count groups of ones; to determine the content of type cell i, count i groups of ones right of the left-most 000 and translate the corresponding 1 x i +1 into x i . This is a very "simple" function; yet, in what sense a general definition of "simple" should apply to all universal computers is a non-trivial question that we will address next.

A Simulation Preorder on TMs
Do all universal TMs satisfy a version of Observation 1, as Hennie's universal TM does? To address this question, we first need to give a general definition of a universal TM U. In Section 4, we have intuitively thought of universal TMs as those that satisfy Equation (1). Note, however, that Hennie's universal TM does not satisfy that equation, but rather where ψ is another "simple function" that extracts T's final tape content from that of U. Namely, U does not exactly end with the same output as T, but with a certain unary encoding of its output, preceding by a a buffer region, a description of T, and three markers. This is necessary because the tape alphabets of T and U need not be identical. The map ψ implements the corresponding decoding. Note that Equation (2) cannot be used as a definition of the notion of universal TM, unless the map ψ is carefully restricted. In particular, if we only demand that ψ is computable, then the "identity machine" that simply outputs the input (i.e., that "does nothing") would count as universal: This is because we can define ψ to be the computable partial function ψ( p T , x ) := T(x). In this way, we can shift the full computation completely into the process of "reading the output". This is certainly not intended.
Thus, we will here use a TM definition which avoids the "output decoding" issue: Definition 1 (Turing machine (TM)). In the remainder of this paper, unless mentioned otherwise, a TM T is always assumed to conform to the following requirements. The TM has a set of internal states Q = {0, 1, 2, . . . , k − 1} with k ∈ N, where q 0 := 0 is the initial state and q f := k − 1 the final state. The TM has two bidirectional tapes (input and work tape), and one unidirectional tape (the output tape). The input tape is read-only, i.e., its content cannot be modified during the computation. The finite alphabet for all tapes is Σ = {0, 1, #}. The input is a finite binary string x ∈ {0, 1} * that is initially written on the cells 0, 1, . . . , (x) − 1 of the input tape. All other cells of all tapes are initially blank (#). All tape heads start in position zero. At each step of operation, the input and work tape heads can independently either move to the left or to the right. Furthermore, the machine may write a bit (0 or 1) at the current cell of the output tape and move its output tape head one position to the right (but not to the left), or it leaves the output tape as it is. If the machine halts, i.e., enters the distinguished internal state q f , then the TM's output, y, is the finite binary string that has so far been written onto the output tape. If this happens, then we write T(x) = y. This defines a partial function from the finite binary strings to the finite binary strings.
A configuration of a TM is a description of some internal state q ∈ Q, of the number |Q| of internal states, of some positions of the tape heads, and some finite information content of the tapes (all but finitely many cells are blank). The countable set of all possible configurations will be denoted by C.
By uni/bidirectional, we mean that the head can be moved in only one/both of the directions. The notions of input and output are perfectly clear for such a TM. Moreover, a TM of this kind resembles our idea of "John preparing breakfast" from Section 1; we can observe the machine creating its output bits one after the other. No output bit will ever be erased; the output is complete once the machine has halted. In some sense, the output tape resembles "John's subsequently observable actions", and the work tape resembles "John's brain".
We can now define a notion of universal TM in the following way.

Definition 2 (Universal TM).
A TM U is universal if it satisfies the following conditions. There exists a decidable prefix code {p T } T , where T labels the Turing machines, such that p T ∈ {0, 1} * is a computable description of the TM T; that is, there is an algorithm that extracts the set of internal states Q and the transition function δ from p T . Furthermore, in particular, U(p T x) is undefined if, and only if, T(x) is undefined (corresponding to the fact the the TM T does not halt on input x). Here, p T x denotes the binary string obtained from concatenating p T and x.
That is, a universal TM U takes the description of a TM T as input, and then imitates its output behavior on the rest of the input. Note that this definition is strictly stronger than the usual definition of a universal TM as used in algorithmic information theory [22,23]; there, it is only demanded that for every TM T there is some p T ∈ {0, 1} * , such that Equation (3) holds, but it is not explicitly demanded that a description of T can be reconstructed from p T . Decidability of the prefix code {p T } means that there is a computable function f : {0, 1} * → {0, 1} with f (s) = 1 if, and only if, s ∈ {p T }-i.e., there exists an algorithm that decides for every given string whether that string is a valid encoding of a TM or not. Do all universal TMs behave in a way that is similar to Hennie's, i.e., as described in Observation 1? To address this question, we will need a formal definition of a suitable set of "simple functions" that extract the configuration of the simulated TM from the configuration of the universal TM. Instead of trying to settle right away how this set S of simple functions should be defined, let us begin with some basic properties that are immediately clear given our goals. Every ϕ ∈ S is a function ϕ : C → C , where C := C ∪ {∅} is the set of TM configurations, supplemented by an additional element ∅ ∈ C which we can interpret as denoting "not a valid configuration". We demand that ϕ(∅) = ∅ for all ϕ ∈ S. Furthermore, we assume that S is closed under composition, i.e., if ϕ, ψ ∈ S then ϕ • ψ ∈ S, and that the identity map is in S. We also assume that the functions in S are computable and total. Now consider the sequence of configurations C U (p T x, t) for t = 0, 1, 2, . . .. The idea is that for some t , the universal TM U has just completed another simulated step of operation of T. If we denote the number of simulated time steps by t (such that t ≤ t ), then we would like our simple function ϕ to yield Otherwise, the right-hand side will simply yield ∅. On the one hand, this means that we obtain C T (x, t) = ϕ(C U (p T x, τ T (t))) exactly as in Observation 1, for some increasing set of integers t → τ T (t). On the other hand, if T halts on input x at time t H , this allows us to obtain the sequence via application of ϕ to each entry, discarding those where ϕ takes the value ∅. This motivates the following definition.

Definition 3 (Simulation preorder).
Let T and T be TMs. Suppose that, relative to our choice of simple functions S, there is some ϕ ∈ S such that for every input x ∈ {0, 1} * , the sequence of configurations C T (x, 0), C T (x, 1), . . . , C T (x, t H ), where t H is the halting time if T halts on input x, and ∞ otherwise, can be obtained by processing the sequence of configurations where t H is the halting time of T on input x, and ∞ otherwise, in the following way. One after the other, apply ϕ to the C T (x, •), and if the result is not ∅, then append the result to the list. In this case, we will say that T simulates T and write T S T .

Note that this implies that t H ≤ t H .
Since the identity function is in S, we have T S T for all TMs T. Furthermore, T S T and T S T implies T S T , since simple functions can be composed. This implies that S is a preorder on the TMs. The notion of a simulation preorder is well-known in the literature. However, all definitions that we are aware of, including Milner's seminal work [24], define a notion of simulation that is too strict for our purpose. To the best of our knowledge, these definitions postulate that some machine S simulates another machine T if there is an injection of T's states into those of S, such that each single state transition of T corresponds to a single state transition of S. These definitions are very natural for finite automata [25]; however, for TMs, we need a looser definition of simulation that allows S to simulate a single step of T within more than one time step.
When we compare the computation of T with its simulation by U, we have an additional prefix p T on the input, as explained above. The behavior sketched above will then be abbreviated by writing T S U(p T •). We use this notation for our first attempt to formalize our conjecture:

Conjecture (1st attempt). For every universal TM U, we have
At first sight this seems plausible: universal TMs operate by taking the description p T of any other TM T, and by then simulating T step by step. However, it is easy to see that this conjecture cannot literally hold true. Consider a Turing machine T 0 that operates as follows. On input x, it begins by computing the 2 (x) th prime number in binary on its work tape. After that, it halts unconditionally. This Turing machine T will output the empty string on every input, i.e., T 0 (x) = ε for all x ∈ {0, 1} * , and it will do so extremely inefficiently. In fact, let us consider an infinite sequence of modifications of this inefficient machine, labelled by T i . All the T i are identical to T 0 , but they have i additional internal states that are all irrelevant for all their computations. That is, the transition functions of all T i are that of T 0 , and if Q 0 = {0, 1, 2, . . . , k − 1} is the set of internal states of T 0 , then the set of internal states of T i is Q i := {0, 1, 2, . . . , k − 1, k, . . . , k − 1 + i}.
Consider now some standard textbook universal TM U, but modify it such that it does the following. In the very beginning, U will examine the p T -part of the input, and check whether p T is a description of any of the T i , i.e., whether p T = p T i for some i. If not, then U will proceed like the textbook machine; otherwise, it will refrain from simulating T i , and instead halt (and output ε) immediately and unconditionally.
In this case, there will be infinitely many counterexamples to Equation (4), namely all the T = T i will violate it.
Indeed, we have already formulated our Informal Conjecture in a more careful way; not all TMs T, but only those that lie in a large set T are conjectured to represent instances of computational sourcehood. Intuitively, T contains all TMs that operate neither in a trivial nor in an extremely inefficient way on all inputs. This leads us to the second attempt at formalization of our Information Conjecture:

Conjecture (2nd attempt). For every universal TM U, we have
where T is a large set of TMs yet to be formalized but intuitively described above. Moreover, if we denote the simple function that implements the simulation decoding of T by ϕ T , then the map p T → ϕ T is computable.
We have added another desideratum to the conjecture. Given T's description p T , a finite algorithm can actually determine an effective description of the simple function ϕ T which reads out T's simulated configuration from U's. We assume that this algorithm yields some valid ϕ T for all p T , but the result must only be correct for T ∈ T. This demand is very natural; not only would we like T's computation to be in principle determinable from U's, but it should generally be known how to actually do so.
If the set of simple functions S is closed under certain operations, we can equivalently demand that the decoding function is independent of T, i.e., "one simple function reads them all": Lemma 1. Suppose that the set of simple functions S has the following prefix closure property: for every decidable prefix code {p} labelling a subset of the simple functions {ϕ p } ⊆ S, the function ϕ : C → C , is also contained in S. Then we can without loss of generality assume that for every universal TM U, there is a unique simple function ϕ ∈ S that implements the simulation decoding for every TM T.
Next we will discuss how to concretely choose a suitable set of simple functions S.

How Not to Choose the Set of Simple Functions S
It is clear that every rigorous formulation of our conjecture must be false if the set of simple functions S is "too small". For example, suppose that we choose S = {id}, i.e., define only the identity function to be simple. In this case, However, this is certainly impossible (unless T = U and p T = ε): already at t = 0, the input tape contents of T and U differ (they hold the strings x and p T x, respectively), hence T and T have different configurations, and C T (x, 0) = C U (p T x, 0).
More generally, the following holds: If we define S to be minimal, i.e., to only contain the identity function (S = {id}), then That is, TMs formally only ever simulate machines that are exactly identical to themselves in all their state transitions. In particular, T S T becomes equivalent to T S T.
Note that the right-hand side is not the same as T = T ; for example, T = T i and T = T j for i = j from the family of inefficient TMs under Equation (4) will also satisfy it. However, TMs T and T that satisfy the right-hand side above are "identical for all practical purposes". A similar conclusion will follow if we choose the set S non-trivial but still too small; for our conjecture to be true, S must contain all possible ways in which universal computers can choose to encode the simulation in their own configuration. In particular, S must at least contain all "textbook simulation encodings", such as the one used by Hennie as described in Section 5.1.
On the other hand, suppose we define S to be the set of all total computable functions ϕ with ϕ(∅) = ∅. Then this will make our conjecture trivially true for many universal computers U, but it will in general fail to formalize a sensible notion of simulation, as we will now demonstrate.
For the sake of the argument, let us assume that there exists some universal TM V that intuitively violates our Informal Conjecture; it reproduces the outputs of all (or most) other TMs T in a counterintuitive way that is very different from step-by-step simulation. Let us construct another universal TM U with U(x) = V(x) for all x ∈ {0, 1} * -it will be a machine that we obtain by modifying V, and that also violates our Informal Conjecture. It is constructed in the following way. To obtain the required output functionality, U simulates V exactly step by step. In addition, U contains a counter on some unused portion of its work tape, i.e., a representation of a natural number τ that starts in zero and increases by one after every step of simulation of the TM V. Now we define a total computable function ϕ via the following algorithm: • Extract p T and x from the input tape and t from the work tape. • Simulate T on input x for t steps and return the configuration C T (x, t). Consequently, we obtain T S U(p T •) for all TMs T. However, by construction, U never actually performs any step-by-step simulation of any TM T (since V does not). We have thus shown the following undesirable feature of the maximal choice of S as the set of all total computable functions; if there exist universal TMs that violate our Informal Conjecture, then some of them will still satisfy T S U(p T •). Thus, ≺ S is not a reliable formalization of the notion of step-by-step simulation that our Informal Observation refers to.
To expose the problem further, consider the following special TM: Definition 4 (Clock Turing Machine). A clock Turing machine C is a TM that ignores its input and counts integer time steps t ∈ N on its work tape indefinitely.
We are not giving a formal construction of a clock TM, but it is not difficult to think of a concrete set of internal states and a transition function that implements the clock. For example, at each time step, the TM may simply write a fixed symbol (say, 1) in the currently active cell of the work tape and move the work tape head to the right. Since this can be completed in different ways (e.g., writing only zeros or ones, or alternating in ways that are determined by changes of the internal state), there are infinitely many clock TMs. Clock TMs C never halt, i.e., C(x) is undefined for every x ∈ {0, 1} * . The construction above shows the following: Lemma 3. Let C be a clock TM. If we define S to be maximal, i.e., equal to the set of all total computable functions ϕ with ϕ(∅) = ∅, then T S C for every TM T.
That is, the clock TM C will formally be considered to simulate all other TMs step by step.
Most total computable functions are intuitively extremely complex, so the maximal choice of S is obviously a very bad formalization of a "set of simple functions". However, the argument above rules out other, more intuitively sensible choices of S. For example, we may consider the set S of functions that have at most linear time complexity. A running time at least linear in the input length is required to read the input, and as we would like the functions in S to be simple, it is natural to demand that they shall not take significantly more time than this minimum. However, we will now argue that even such functions with linear running time can still be too powerful, as they also allow to apply the clock TM trick. Since we are considering functions on configurations, we have to be more specific about what we mean by linear time complexity. For our purpose, we will restrict our attention to the following specific choice of encoding of configurations and TMs M ϕ that compute ϕ ∈ S. The TM M ϕ is supposed to satisfy Definition 1, up to a convenient modification; instead of single input, work, and output tapes, M ϕ has two input tapes (I in and I out ), two output tapes (O in and O out ), and four work tapes (W in , W out , W, and W state ).
We use the convention that M ϕ receives the input configuration c ∈ C in the following way. The tapes and the corresponding head positions will exactly be copied onto the in-tapes. That is, I in contains the exact input tape content as described by c, and also its tape head will be placed at the current position specified by c; similarly for W in and O in . The internal state q ∈ Q described by c will be written via log 2 |Q| bits onto the tape W state .
When M ϕ has halted, the tapes I out , W out , and O out contain the respective tape contents and tape head positions of the target configuration c = ϕ(c), and the tape W state contains the description of the internal state of c . If the content of W state is not a syntactically correct description of any q ∈ Q, then the output configuration is taken to be ∅.
Given such ϕ, let us say it has linear time complexity or linear running time if the number of computation steps of M ϕ is in O(n), where n is the total size of the non-blank blocks on the initial configuration's input, work, and output tapes.
We will now show that even those functions are too powerful to represent a meaningful notion of simple functions. Consider, again, a clock TM C of Lemma 3. Given a TM T that is supposed to be simulated, we can construct a "simple" function ϕ T via some TM M ϕ T as follows. The TM M ϕ T has a set of internal states Q = Q T × Q , where the Q part is used to carry its functionally relevant internal state, while Q T carries the representation of an internal state of T. First, M ϕ T copies the input of T from I in to I out . Then M ϕ T sets the first component of its internal state equal to the starting state q 0 ∈ Q T of T. From that moment on, M ϕ T behaves exactly like T, with I out as its input tape, W out as its (initially blank) work tape, O out as its (initially blank) output tape, and Q T as state register; we assume that the transition function of M ϕ T contains the transition function of T and uses it for an exact step-by-step simulation of T. After every simulated time step, M ϕ T moves the head on W in to the left. When that head reaches a blank symbol, M ϕ T represents the first part of its internal state via log 2 |Q T | bits on the tape W state and halts.
The TM M ϕ T operates in linear time and maps configurations to configurations. If we apply M ϕ T to the clock TM C, then M ϕ T will simulate T for as many steps t as there are ones on C's work tape. This clearly produces the configuration C T (x, t) in linear time. Thus, ϕ T ∈ S, and we have shown the following: Lemma 4. Let S be the set of total computable functions (on the configurations) that run in linear time, in the sense explained above. Then we still have T S C for every TM T if C is any clock TM.
Can stricter time bounds give us a better choice of S? This seems unlikely, given that at least linear time is needed to even read the input configuration. So is there another way to define a set of simple functions S that gives us a non-trivial simulation preorder, but that leaves some chance for our conjecture (say, in its third formalization) to be true? Unfortunately, there is a strong counterargument to this hope, as we will now demonstrate.

An Encryption Counterexample to "Simplicity"
Let us now show that our conjecture cannot hold without substantial modification. Since a detailed formal proof of what follows seems very cumbersome, we will instead give an informal argument which we believe is sufficiently detailed to support our conclusion.
Consider some universal TM U of the textbook kind-similarly as Hennie's universal TM, U simulates every other TM T step by step. Let us construct a modification of U, denoted U , that has equivalent input-output behavior as U, i.e., U(x) = U (x) for all binary strings x. However, U will encrypt all the parts of T that are not relevant for the current simulation step. Then functions ϕ ∈ S that deserve the name "simple" will not be able to crack the encryption of U s representation of T.
To this end, consider some computable function that maps integers n ∈ N to bits a n ∈ {0, 1}. Let us choose a function that is very difficult to evaluate; for example, we may assume that it takes exponentially many time steps to compute a n . More specifically, the time hierarchy theorems [20] guarantee the existence of a decision problem that cannot be solved within time O(2 n ), but within time O(2 2n ), and we choose a n to be the answer to such a problem. For negative i, we will use the convention a i := a |i| . We will use this string of bits for encryption.
Like U, the TM U simulates all elements of T step by step. In particular, it contains the contents {w i } i∈Z on T's work tape cells somewhere in its memory. While simulating a single time step of T, the TM U will read the current tape cells, determine and write their new contents, and then move the simulated tape heads left or right. We construct U such that it replaces this one simulated step of operation of T by the following simulation steps (all tape cells are simulated tape cells): • It reads the symbol in the currently active work tape cell i (assumed unencrypted) and the other currently active tape cells and applies T's tabulated transition function δ to determine whether it has to move left or right on the tapes, and which symbol w i it has to write into the work tape cell (and similarly for the other tapes). • Then it computes, with a fixed program independent of any other tape content, the bits a i and a i+σ , where σ = −1 if it has to turn left on the work tape or σ = +1 if it has to turn right. • It determines w i , which is the blank symbol # if w i is blank, and which is w i ⊕ a i if w i is a bit (encryption). It writes w i into work tape cell i and reads w i+σ from work tape cell i + σ. It then determines w i+σ , which is the blank symbol # if w i+σ is blank, and w i+σ ⊕ a i+σ otherwise (decryption). The writing onto the input and output tape is performed without encryption, as determined by T's transition function δ.
• U erases all data that results from the computation of a i and a i+σ and of the sums of those with the work tape bits from other parts of its memory.
We assume that the TM U is constructed such that the only relevant difference after the encryption resp. decryption step to before is the value of the simulated work cell bit. In other words, U is supposed to "erase all the garbage" that it produced while computing a i , leaving only a simple encoding of the encrypted configuration of T. We also assume that U does not contain an explicit counter of the number of time steps that have passed since the start of the computation. Let s 1 , s 2 , s 3 , . . . label the times at which the TM U has completed simulating (as described above) the first, second, and third. . . step of computation of T. Now suppose that the current formalization of our conjecture (second attempt) is true, for some intuitively reasonable set of simple functions S. Then there is some ϕ ∈ S and an increasing sequence of times {τ t } t such that for all t, and such that ϕ (C U (p T x, s)) = ∅ for all s ∈ {τ t } t . A priori, the times τ t need not at all be related to the simulation times s t . For example, ϕ could act similarly as the function that we have used to prove Lemma 3; it could simply perform the simulation of T itself, without having to wait for U to have finished its simulation steps. Then we could have, for example, that τ t = t, but s t will grow exponentially with t. However, such functions ϕ are not of the form that we have in mind in any intuitive formulation of our conjecture. Let us, therefore, assume that the set of simple functions S does comply with out intuition to some extent; the simple functions shall not simulate T by themselves, but shall only read what has already been simulated by the universal TM U . Intuitively, the simulated configuration C T (x, t) is generated (in encrypted form) at time s t on U and not before. Thus, our assumption amounts to postulating that the times τ t must essentially be on or after the times s t when U has performed the tth step of simulation of T: Assumption 1. There is a possible choice of ϕ such that there exists at least one x, such that s t ≤ τ t < s t+1 for many different t.
Note that we are not assuming that this has to hold for all TMs T. We only need to assume that there exists at least one TM T within the "sufficiently diverse" set of TMs (as mentioned in the second attempt of formalization of our conjecture) that satisfies this assumption and the other two below.
In other words, for many t, the simple function ϕ has to read out C T (x, t) within the time interval [s t , s t+1 − 1]-this may not be true for all simple functions that read out T's configuration, but we assume that it is true for some ϕ . Now, via Equation (5), let us analyze what this means for such ϕ . Consider one of the "many different t" from Assumption 1. Then the simple function ϕ has to determine C T (x, t) from some C U (p T x, s), where s t ≤ s < s t+1 . What do these configurations of U look like? For s = s t , this configuration consists of a simple encoding of C T (x, t) * , by which we denote C T (x, t) with all work tape bits but one encrypted. This is basically it, by construction, U does not contain more information than that (except for, say, a constant set of instructions that allows U to compute any a i or to decode the transition function δ T from p T etc.).
Over the next time steps, for s t < s < s t+1 , the TM U computes a i and a i+σ and uses this to encode and to decode the currently and next active cell on T's simulated work tape. Over all these time steps, U will thus contain a simple encoding of T's configuration with all work tape bits but at most two encrypted-let us denote this by C T (x, t) * * -and some "rest". This "rest" contains, for example, intermediate results of the computation of a i and a i+σ , but it does not contain any information of substantial help in decrypting any of the other work tape bits. Schematically, we may thus write C U (p T x, s) = C T (x, t) * * , rest , and the above remarks motivate us to formulate the following Assumption 2. Computing C T (x, t) from C U (p T x, s) is essentially equivalent to computing it from C T (x, t) * * -in this sense, the "rest" can be ignored.
However, now, recalling Equation (5), we find that ϕ essentially has to map C T (x, t) * * onto C T (x, t)-it seems like this means that ϕ has to decrypt all but two of T's work tape bits, which is a Herculean task if the work tape contains many bits.
Or does it really have to? Note that there may be indirect ways of determining C T (x, t) from C T (x, t) * * without actually doing any decryption. For example, suppose that T = C is the clock TM from Definition 4. Then C T (x, t) has a sequence of t identical ones on its work tape (followed by blank tapes). This configuration can be determined by simply counting how many non-blank symbols are on the work tape of C T (x, t) * * , and then by replacing each bit by a one.
However, the clock TM is very special. In contrast, think of a TM T with the property that the configuration C T (x, t) differs, for a large set of values of t (and identical x), only in the content of the work tape bits. (For example, T could simply count integers in binary on the work tape for a very large number of time steps, without modifying other parts of its configuration.) Then, the only way to determine C T (x, t) from C T (x, t) * * would be by brute-force decryption.
Assumption 3. T writes many bits onto its work tape and has the property that C T (x, t) can, for many x and t, essentially only be determined by brute force decryption of C T (x, t) * * .
Then we obtain the following consequence. Observation 2. If the above informal argumentation can be made rigorous (including, in particular, the three assumptions), then our conjecture (in its second attempt of formalization) can only be correct if we allow the set of simple functions S to contain maps that are intuitively extremely complex.

From Simplicity to Preservation of Structure
Our goal was to find a formalization of the idea that all functionally relevant elements of T must typically be fully represented within U-a formulation that is non-trivial and has a chance to be true. However, it seems that we have tried to do so in the wrong way, demanding that T's configuration can be read from U's with some function that is simple to implement is doomed to fail-at least if we understand simplicity as small time complexity. On the one hand, Observation 2 suggests that S must necessarily contain very complex functions to break the encryption of some universal TMs. On the other hand, Lemma 4 shows that even very small time complexity already admits functions that "cheat" by performing the simulation themselves.
Note that putting a time bound on admissible read-out functions is similar to the strategy by Zwirn and Delahaye [11,12] to define "approximations" of Turing machines in their approach to construct a formal definition of computational irreducibility. The above shows that our approach to define computational sourcehood (and its typicality) needs a different strategy.
For a different perspective, consider again the example of the clock TM of Lemma 4. Why should we regard functions ϕ ∈ S that implement the simulation by themselves as "undesired" or "cheating"? Our previous attempt was to say that such ϕ are not simple in any meaningful sense of the word. However there is an alternative view, we can also say that such ϕ are not sufficiently structure-preserving.
To see this, let us contrast such "cheating" ϕ with typical read-out functions ψ for textbook universal TMs like Hennie's. Consider two configurations c, c ∈ C of a simulated TM T that are in some sense "pretty close to each other"-perhaps they differ only in a small number of bits on the work tape, but are otherwise identical. Consider some configuration c U ∈ C which describes the universal TM U simulating T in configuration c, i.e., ψ(c U ) = c. Then we will find another configuration c U close to c U which describes U simulating T in configuration c , i.e., ψ(c U ) = c ; intuitively, we only have modify a few bits of c U (those that represent the simulated bits differing between c and c ) to obtain c U from c U .
In contrast, the "cheating" ϕ for the clock TM C will not, in general, satisfy this property; there will be close-by configurations c = C T (x, t) and c = C T (x , t ) with c = ϕ(c C ), such that all configurations c C with c = ϕ(c C ) are very far away from c C . To see this, let T be a universal TM. For every input x ∈ {0, 1} * , denote by t H (x) T's halting time on input x (which is ∞ if it does not halt on that input). Furthermore, for those x with t H (x) < ∞, denote by N(x) the smallest i ∈ N, such that the ith output tape cell is blank at halting; in other words, this means that the TM halts with a block of N(x) non-blank bits on its output tape; for non-halting x, set N(x) := −1. Then N n := max x∈{0,1} n N(x) grows extremely fast-similarly to the busy beaver function [26], it must grow faster than every computable function, due to the undecidability of the halting problem. For every n, pick an arbitrary maximizing input x n , i.e., N(x n ) = N n and (x n ) = n. Then the configuration c n := C T (x n , t H (x n )) contains an extremely large (of size N n ) block of bits on its output tape. For every i ∈ [0, N n ], denote by c where c n,C := C C (x n , t H (x n )). Let us estimate the number of configurations c n,C that have distance at most k from c n,C , where k ∈ N \ {0}, i.e., the number of elements in the k-ball B k (c n,C ). We have not formally defined a distance measure on the configurations yet, and our argumentation will not be particularly sensitive to the choice of measure. Nonetheless, for concreteness, let us define D(C C (x, t), C C (x , t )) := D H (x,x ) + | (x) − (x )| + |t − t |, wherex andx denote the first m bits of x resp. x , where m := min{ (x), (x )}, and D H is the Hamming distance. (All other configurations will be mapped to ∅ by ϕ, hence we are not interested in them). Clearly, D(C C (x , t ), c n,C ) ≤ k implies |t − t H (x n )| ≤ k and (x ) ≤ (x) + k. There are (2k + 1) many choices of such t and 2 n+k many choices of such x . Since 2k + 1 < 2 2k , |B k (c n,C )| < 2 n+3k . Now let k n := 1 3 (log 2 N n − n) , which still grows faster in n then every computable function. By simple counting, there must be at least one i ∈ [0, N n ], such that ϕ(c) = c (i) n for everyc ∈ B k (c n,C ); there are simply not enough configurations in the k-ball to cover all c where k n grows extremely quickly in n. Hence, ϕ is not structure-preserving in the way explained above.
This motivates our final attempt of formalizing our conjecture: Conjecture (third and final attempt). For every universal TM U, we have T S U(p T •) for every TM T ∈ T, where S is a natural set of structure-preserving maps on TM configurations. By structure-preserving maps, as sketched above, we mean functions ϕ with the following property. If we have close-by configurations c and c , and another configuration c U with ϕ(c U ) = c, then there is another configuration c U close to c U with ϕ(c U ) = c . These functions are not necessarily assumed to be "easy to implement". It is not clear whether (and perhaps even unlikely that) the best definition of "close-by" is similar to the one used above, i.e., based on a distance measure between configurations that is essentially some modification of the Hamming distance. It may well be that it is more suitable to introduce a form of "functional similarity", perhaps a notion that is allowed to depend on the Turing machine under consideration. It is hence likely that higher-level mathematical tools, perhaps from category theory, are needed to substantiate this attempt. Whether the above attempt can be made rigorous in some such way will have to be seen in future work.

Conclusions
In this article, we have revisited the idea that computer science notions, such as computational irreducibility [10], can shed light on the relation between determinism and free agency [1]. We have addressed two issues with previous proposals of this kind: first, Wolfram's original proposal did not include a rigorous mathematical definition of computational irreducibility, and it is unclear whether later definitions, such as those by Zwirn and Delahaye [11,12], are well-suited to reason specifically about free agency. Second, as argued also by Bringsjord [15], the focus of Wolfram's (and Lloyd's [14]) approach on the question of temporal shortcuts allows us to reason about unpredictability as a phenomenon of free agency, but not directly about the question of whether agents' decisions are actually free.
Motivated by a simple thought experiment ("John the cook", cf. Figure 1), we have proposed a variant of computational irreducibility, termed computational sourcehood, that is intended to formalize an aspect of actual free agency more directly. We suggest that a process P can be regarded as the source of its outputs if attempts to reproduce them must typically involve a step-by-step simulation that contains replicas of the history of configurations of P. While this notion is closely related to computational irreducibility (in particular, it also implies that there are typically no shortcuts to simulating P), it makes a more general claim, by stipulating that even slow and inefficient simulations must typically contain "clones" of the process.
We have then taken up the challenge to give a rigorous mathematical formulation of this phenomenon and its conjectured typicality. This has led us to a question about universal Turing machines (TMs), defined by their ability to reproduce the input-output behavior of all other TMs T; is it true that all universal TMs work by essentially simulating T step by step, except for a small subset of TMs T for which they know shortcuts? While this question-and the conjecture of a positive answer to it-can easily be described in words, it turns out to be quite difficult to find a rigorous formulation that is non-trivial and has a chance to be true.
Our first idea of formalization was to say that U simulates T step by step if the temporal sequence of configurations of T can be read out from the sequence of configurations of U via some "simple function". We have shown that this is true for textbook constructions of universal TMs, such as Hennie's [18], but we have identified obstructions to proving that this must be true in general. On the one hand, we have sketched a universal TM that encrypts most of the simulated data, which shows that read-out functions cannot always be intuitively simple; on the other hand, we have shown via a "clock TM" that formally simple read-out functions can have unintended functionality (namely, perform the simulation themselves) that leads to a trivial notion of simulation.
These insights have led us to formulate a version of our conjecture that defines simulation not in terms of simple, but structure-preserving functions; close-by configurations of the simulated TM T should be represented by close-by configurations of the simulating TM U. While we were not able to suggest a rigorous definition of "close-by", we have shown that its simplest implementation leads to a notion of simulation that is not trivialized by the clock TM example. Whether this formulation of the conjecture can indeed be made rigorous in an interesting way will have to be seen in future work.
While we were not able to settle our conjecture, we think that its study might lead to interesting insights into the nature of universal computation, regardless of whether it turns out to be true and independently of its relation to free agency. We hope that our results and constructions can motivate further interesting inquiries into the relation of computation and freedom.