Computational irreducibility and compatibilism: towards a formalization
CComputational irreducibility and compatibilism: towards a formalization
Marius Krumm
1, 2 and Markus P. M ¨uller
1, 2, 3 Institute for Quantum Optics and Quantum Information,Austrian Academy of Sciences, Boltzmanngasse 3, A-1090 Vienna, Austria Vienna Center for Quantum Science and Technology (VCQ),Faculty of Physics, University of Vienna, Vienna, Austria Perimeter Institute for Theoretical Physics, 31 Caroline Street North, Waterloo, ON N2L 2Y5, Canada (Dated: January 27, 2021)If our actions are determined by the laws of nature, can we meaningfully claim to possess freewill? Compatibilists argue that the answer is yes, and that free will is compatible with completedeterminism. Previously, it has been suggested that the notion of computational irreducibility canshed light on this relation: it implies that there cannot in general be “shortcuts” to the decisions ofagents, explaining why deterministic agents often appear to have free will. In this paper, we introducea variant of computational irreducibility that intends to capture more accurately aspects of actual (asopposed to apparent) free will: computational sourcehood, i.e. the phenomenon that the successfulprediction of a process’ outputs must typically involve an almost-exact representation of the relevantfeatures of that process, regardless of the time it takes to arrive at the prediction. We conjecture thatmany processes have this property, and we study different possibilities for how to formalize thisconjecture in terms of universal Turing machines. While we are not able to settle the conjecture, wegive several results and constructions that shed light on the quest for its correct formulation.
I. INTRODUCTION
Do agents have some sort of control over their actionsthat deserves to be called “free will”? This question hasbeen discussed in various forms in the philosophical lit-erature over the last two millenia (see e.g. Ref. [1] for anintroduction). At first sight, the fact that human agentsare subject to the same laws of nature as stones andatoms seems to be in tension with an intuitive under-standing of free will: after all, when an agent has takena decision, they will fundamentally never have had the“freedom to do otherwise”. Moreover, one might be in-clined to think that it is not the agent, but rather thelaws of nature (or initial conditions) that represents the“source” of the agent’s actions. Due to quantum the-ory, we know that the fundamental laws of nature areprobabilistic rather than deterministic, but it has beenconvincingly argued [2–4] that decisions are not “free”simply because they are random. Accepting these argu-ments, we are hence led to the question: can free will becompatible with determinism?Among the various positions in the debate, compati-bilism [3, 5] amounts to the claim of a positive answerto this question. Compatibilists have argued against theincompatibility of free will with determinism in a vari-ety of ways: by rejecting the idea that the freedom to dootherwise is necessary for free will; by claiming that thefreedom to do otherwise is compatible with determin-ism; or by formulating ways in which sourcehood canbe ascribed to an agent even in a deterministic world(for an overview, see Ref. [6]).In a complementary development, there have beenproposals to analyze the relation between determinismand free will via theoretical computer science. After all,we do not live in an arbitrary deterministic (or proba-bilistic) world, but in a world that seems to comply with physical versions of the Church-Turing thesis [7, 8]. Thissuggests to treat decision-making systems (includingagents) and predictors as algorithms in some sense, andto contemplate aspects of free will with information-theoretic notions and methods.Two such approaches (described in more detail inSection II below) offer an explanation for why somephysical systems (in particular human agents) appear to have free will. One approach, computational ir-reducibility [9–12], demonstrates that the behavior ofmany physical systems cannot be predicted withoutsimulating every single step of their time evolution infull detail. Another approach, based on time complexityarguments [13], shows that it takes typically more timeto predict an agent’s actions than it takes the agent tocome to its decision by itself. In a nutshell, decision mak-ing systems do not in general admit shortcuts . However,as already noted by Bringsjord [14], this insight in itselfmay explain some of the phenomenology of free will, butit does not have much to say about whether agents are actually free.In this paper, we suggest to study a variant of com-putational irreducibility that is intended to formalize anaspect of actual free will more directly: a computationalnotion of sourcehood . In a nutshell, we ascribe compu-tational sourcehood to a process P if attempts to repro-duce its outputs can typically only succeed by runningan almost-exact step-by-step simulation that contains allfunctionally relevant aspects of P , regardless of the sim-ulation time. Thus, if we regard the collection of allrelevant abstract information-theoretic elements of P as(part of) an agent, then it is always this agent that is in-voked when P ’s behavior is generated, reproduced orpredicted. We conjecture that this kind of sourcehood isindeed “typical”, i.e. that it can be attributed to a largevariety of computational processes. a r X i v : . [ phy s i c s . h i s t - ph ] J a n Our article is organized as follows. In Section II,we give a brief summary of previous “no-shortcut”approaches to apparent free will: computational irre-ducibility and time complexity arguments. We intro-duce the idea of computational sourcehood and its dif-ference to computational irreducibility by means of athought experiment in Section III. Section IV containsthe technical results of this paper: successively im-proved attempts to formally define a version of ourmain conjecture (that computational sourcehood can beascribed to a large variety of processes), informed byseveral results and constructions. This boils down tofinding a suitable definition of a simulation preorder forTuring machines, in a way that is non-trivial but admitsto make a claim about the working of all universal Tur-ing machines. Finally, we conclude in Section V.
II. NO-SHORTCUT APPROACHES TO APPARENTFREE WILL
In this section, we briefly summarize two approachesintended to explain the phenomenology of free will us-ing a computational perspective. Both approaches havein common that they identify the huge effort necessaryto predict an agent’s decisions as an account of apparentfreedom. As we will see, the approaches differ in howthey expose the difficulty of agent predictions. Whilethe first approach (which is closely related to ours) fo-cuses on the non-existence of shortcuts and simplifica-tions in the prediction process, the second approach fo-cuses on computation time and uncomputability.
A. Computational irreducibility
One concept in computer science that has been sug-gested to shed new light on the relation between freewill and determinism is computational irreducibility , pro-posed by S. Wolfram [9].To explain this concept, let us consider the successof scientific predictions. Most physical systems are ex-tremely complex objects constructed from a vast num-ber of smaller parts. Nonetheless, often times the be-havior of crucial properties of such complex systems canbe described with a few equations. For example, in me-chanics, many of the considered physical systems are ex-tended objects. Such systems consist of countless atoms,which themselves are built from smaller particles. How-ever, as we know from our mechanics lectures, predict-ing the evolution of the mechanical properties of thesesystems often times does not require a simulation of allthe individual parts. E.g. in astronomy, the orbits ofgas planets can be well approximated via Kepler’s laws,without the need to consider all the gas molecules in-volved in the movement of the planet.These considerations teach us that the behavior ofsome important properties of complex physical systems can be predicted without having to predict all the piecesthat these systems are built from. This implies that thesepredictions are possible because the simulation allowsfor massive shortcuts and simplifications. Now, Wol-fram’s concept of computational irreducibility refers to theobservation that not all physical properties and complexsystems allow for such shortcuts and simplifications. Inother words, there exist physical questions that requirea near-perfect simulation of all the details involved to beanswered.In his book [9], Wolfram suggests the possibility thatagents, including humans, show behavior that is com-putationally irreducible, even if the agent is determinis-tic. In other words, answering some questions about thefuture of an agent might require full simulation of alldetails of the agent’s thought process and environment.Wolfram argues that this might be the origin of apparentfree will:“
And it is this, I believe, that is the ultimate origin of theapparent freedom of human will. For even though all thecomponents of our brains presumably follow definite laws, Istrongly suspect that their overall behavior corresponds to anirreducible computation whose outcome can never in effect befound by reasonable laws. ”This explanation of free will was critized by S.Bringsjord [14] as being “epistemologically correct”, but“metaphysically wrong”, in particular:“
If someone’s will is apparently free, it hardly follows thatthat will is in fact free. Nowhere in ANKS [his book] doesWolfram even intimate that he maintains that our decisionsare in fact free. ”We will reconsider this distinction, and the role ofcomputational notions in its analysis, in Section III,where we take it as an inspiration to introduce a modi-fied version of computational irreducibility.While Wolfram discusses the phenomenology and im-plications of computational irreducibility and providesexamples in terms of cellular automata, he does notgive an exact formalization of this notion in Ref. [9].Such a formal definition has been proposed via Tur-ing machines by H. Zwirn and J.-P. Delahaye [10, 11].In a nutshell, they call a function f : N → N com-putationally irreducible if all efficient Turing machinescomputing f ( n ) will essentially also have to compute f (1) , . . . , f ( n − . While this corresponds to a straight-forward implementation of the main properties of Wol-fram’s examples (in particular if f ( n ) encodes the n throw of a cellular automaton), it is not clear whether thisformulation is the most suitable one for the study of freewill. And since many choices of detail have to be madein the construction of the definition, it is not clear howmany functions actually satisfy it. B. Lloyd’s time complexity argument
Secondly, we consider S. Lloyd’s [13] idealization ofagents as Turing machines, more specifically as com-putable deciders. Such deciders are Turing machinesthat map a description of a decision problem to ayes/no-answer, or fail to come to a conclusion. Moreformally, a (computable) decider d is identified with aTuring machine that receives an input string k , and out-puts d ( k ) ∈ { , } or fails to halt, i.e. d ( k ) undefined.Lloyd considers a function f ( d, k ) that is supposed topredict the answers of all such deciders d for all inputs k . By adapting the proof of the halting problem, Lloydargues that such a function must be uncomputable:“ The unpredictability of the decision-making process doesnot arise from any lack of determinism — the Turing machinesinvolved could be deterministic, or could possess a probabilis-tic guessing module, or could be quantum mechanical. In allcases, the unpredictability arises because of uncomputability .”Nonetheless, as Lloyd points out, decisions in real en-vironments usually have to be made within a limitedamount of time. Therefore, he considers time limiteddeciders and argues that for such time limited decidersa program predicting all decisions is computable. How-ever:“
In summary, applying the Hartmanis-Stearns diagonal-ization procedure shows that any general method for answer-ing the question ‘Does decider d make a decision in time T , and what is that decision?’ must for some decisions takestrictly longer than T to come up with an answer. That is, anygeneral method for determining d ’s decision must sometimestake 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 fol-lowing conclusion about free will:“ Now we see why most people regard themselves as pos-sessing free will. Even if the world and their decision-makingprocess is completely mechanistic — even deterministic — nodecider can know in general what her decision will be withoutgoing through a process at least as involved as the decider’sown decision-making process. In particular, the decider her-self cannot know beforehand what her decision will be withouteffectively simulating the entire decision-making process. Butsimulating the decision-making process takes at least as muchas effort as the decision-making process itself. ” III. COMPUTATIONAL SOURCEHOOD
To set the stage, consider the following thought ex-periment. Suppose that John Smith is a very talented(and emotional) cook. Every morning, he decides whatkind of breakfast to prepare, but his repertoire of mealsis very large. On some mornings, he might rememberhis late Canadian wife and then prepare a particularomelette with cranberries and maple syrup. On othermornings, he might prepare a Pho soup in memory ofhis travels to Vietnam. The number of different break-fasts he might cook extends into the thousands.Suppose we would like to predict what John is go-ing to eat tomorrow morning. Furthermore, supposethat our prediction task is made particularly easy by as- suming that physics is perfectly deterministic, and, infact, computable and discrete at some microscopic scale.Since we know that John is going to spend the eveningand night in his apartment, we are going to build a hugemachine around his house: it scans the apartment to per-fect accuracy, and then simulates his apartment (includ-ing John’s brain and body) on an extremely powerfulcomputer. We would like our simulation to tell us John’schoice of breakfast well before dawn: it is certainly morefun to make a prediction before the predicted event hashappened.
FIG. 1. A universal computer (in the safe, on the right) repro-duces the outputs of another process, i.e. its observable actions(John preparing breakfast, on the left). Computational source-hood means that this prediction cannot typically be success-fully performed without representing all relevant elements(here: thoughts, emotions) of that process in the simulation.
However, we have read about computational irre-ducibility and are thus warned that the simulation has tobe really detailed in order to be successful. Furthermore,we know about Lloyd’s arguments [13], so we fear thatwe should prepare for our simulation to only finish af-ter
John has arrived at his decision of breakfast. Sincewe are not sure about the time τ that our simulation willtake, we take precaution: directly after scanning Johnand his apartment, before starting the simulation, weput the scan data and the computer into an immenselysecure safe. This leaves us two possibilities:• If τ is small enough such that the simulation fin-ishes before breakfast, then we can directly con-front John with our prediction success: “See, John?You have decided to prepare the Canadian omelette. Ha,this is exactly what our computer has predicted half anhour earlier, as several witnesses can testify — well be-fore you have thought about your late Canadian wife!” • If τ is large such that the simulation finishes af-ter breakfast, then we can invite John over to ourlaboratory and let him witness how we open thesafe and obtain the delayed prediction. “See, John?You think your emotions have decided to prepare theCanadian omelette, but what happened in the safe wasonly determined by your physical state and apartmentyesterday night. Your thoughts of your late wife thismorning had no impact on the decision whatsoever!” In the light of a successful (perhaps delayed) predictionof this kind, should we conclude that John does not havefree will? Arguably, regardless of what the correct an-swer to this question is, the answer should be the same inboth cases. The crux of the situation — that reproducingthe decision seems in principle possible without an ele-ment that John regards as a crucial part of his free will —is the same regardless of the value of τ . But this means thatquestions of efficiency — how fast the prediction can bemade — must be irrelevant for the problem of free willin this context.We argue that the relevant question is a different one.An important aspect of John’s belief to make a free, au-tonomous choice is that the particular class of emotionsand thoughts in his mind are in some meaningful sensethe source of the decision, the choice of breakfast. Thismotivates us to ask a specific question about the simu-lation in the safe: does the simulation contain correlates ofthese emotions and thoughts? In other words, did the sim-ulation — and does every successful simulation — alsohave to “think about John’s late wife” in some sense?If the answer is “no” and the simulation has cometo the decision by completely unrelated means — say, ei-ther by a drastic shortcut or by a completely differentmethod — then John may rightly be worried. On theother hand, a positive answer to this question opensup the possibility to ascribe John sourcehood for hisdecisions. As is standard for some compatibilist posi-tions [6], we can do so by interpreting these thoughtsand emotions as parts of John’s identity. In other words:if we identify
John the agent not with the matter insidethe apartment, but with the relevant abstract elementsof the processes in his brain, then this agent is the sourceof its decisions : the simulated process in the safe has sim-ply contained another representation of John.So will the computer contain correlates of John’sthoughts and emotions? Let us phrase this as a generalquestion about Turing machines (TMs). Think of Johnas a TM T , with the configuration of John’s apartmentand the content of his brain yesterday night as the input,and think of the computer in the safe as a universal TM U . John’s observable actions (in particular, his choice ofbreakfast) correspond to T ’s outputs, and U is able to re-produce these outputs exactly. Does this tell us anythingabout the way how U arrives at these outputs?Intuitively, universal TMs simulate other TMs T ex-actly and step by step; as we will explain below, this iscertainly true for all universal TMs that are describedin standard textbooks. Now, if this is true for the com-puter in the safe, then the answer to the above questionis positive: yes, the computer has reproduced copies of John’sthoughts and emotions. But is this so by necessity?Universal TMs U can be fed a description of anotherTM T together with some input x , and they use this tocompute the output of T on input x . It seems extremelyhard 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 ). So it is very natural to conjecture that all universalTMs perform step-by-step simulation for most machineswhose outputs they reproduce: Conjecture.
Suppose that a TM U is universalin the sense that it reproduces the outputs of anyother TM: that is, U ( p T , x ) = T ( x ) (1)for every TM T and every input x on which T halts,where T (cid:55)→ p T is an effective description of theTM T . Then, for “most” T , the universal TM U will generate its output U ( p T , x ) by means of someform of step-by-step simulation of T ’s computationon input x . In this sense, T is the “source” of itsoutputs (computational sourcehood).In other words, universal computers will typ-ically contain a complete image of the tempo-ral sequence of configurations of the computationwhose outputs they are supposed to reproduce.Proving a formal version of this conjecture would tellus that computational sourcehood is a generic phe-nomenon; as long as John can be viewed as a “typi-cal” TM (with an identification as an agent as sketchedabove), this would open up a computational justificationfor viewing him as the source of his actions. Regardlessof the problem of free will, it would give us interestinginsights into the properties of universal computers.Clearly, this notion of computational sourcehood isclosely related to computational irreducibility: both con-cepts claim that an exact representation is necessary forprediction. However, computational irreducibility fo-cuses more on the impossibility to speed up a compu-tation, whereas computational sourcehood claims moregenerally that every successful prediction of the resultsof a computation must involve an exact image of theoriginal, even slow ones. This implies in particular thatno essential speedups are possible, but it makes addi-tional claims about the structure of simulations, includ-ing those that take substantially longer time.Even the semi-formal version above shows that thevalidity of the conjecture may hinge on the details ofthe choice of quantifiers: for any given universal TM U ,there may be many T that have to be simulated step bystep, but this set of T ’s may depend on U . Hence, ifwe think of one particular T (such as John the cook), itmay satisfy the condition of computational sourcehoodfor many U , but perhaps not for all. Such “elbow room”seems crucial to have any chance for the conjecture tobe true, and it shows up in other related places too. AsLloyd [13] remarks: “ the uncomputability of the decision-making process means that you can predict what some de-ciders will decide all the time, and what all deciders will decidesome of the time, but you cannot predict all decisions all the time ”. Here, we may have a similarly involved interplaybetween U , T and x . That alone shows that the searchfor a valid formalization of this conjecture — which wewill take up in the next section — promises to be a quitenon-trivial task. IV. TOWARDS A RIGOROUS FORMULATION OF THECONJECTURE
This section assumes familiarity with some basic no-tions of computer science like Turing machines, pre-fix codes, and computability; for an introduction, seee.g. [16–19]. To fix some notation, we will denote theset of natural numbers by N = { , , , , . . . } (which in-cludes zero), and the set of finite binary strings by { , } ∗ = { ε, , , , , , , , . . . } , where ε is the empty string. The length of a string s ∈{ , } ∗ will be denoted (cid:96) ( s ) , with (cid:96) ( ε ) = 0 . In general,if Σ is any finite alphabet, the set of finite words over Σ will be denoted Σ ∗ . A. Textbook universal Turing machines satisfy theconjecture
It is a straightforward yet cumbersome exercise to for-mally construct a universal TM in a rigorous way. Wewill now sketch a construction given in the textbookby Hennie [16]; for another choice, see e.g. Hopcroft etal. [17].TMs come in different versions. What all definitionshave in common is a finite set Q of internal states ofthe machine, including an identified initial state q (andsometimes a final state q f (cid:54) = q ). Every TM has a finitenumber n of tapes , such that each tape has a numberof cells that is either indexed by the natural numbers N = { , , , . . . } (a “one-way infinite” tape) or by theintegers Z = { . . . , − , − , , , , . . . } (a “two-way infi-nite” tape). Every tape cell contains one symbol of a fi-nite 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 alongthat tape.Single steps of operation are determined by a (per-haps partial) transition function , which we may write as δ : ( q, (cid:126)σ ) (cid:55)→ ( q (cid:48) , (cid:126)σ (cid:48) , (cid:126)d ) . We interpret this as follows. At every time step, if theTM is in internal state q and reads the symbols (cid:126)σ =( σ , . . . , σ n ) on its n tapes, then it replaces the tape con-tents by (cid:126)σ (cid:48) = ( σ (cid:48) , . . . , σ (cid:48) n ) , transitions into the new inter-nal state q (cid:48) , and moves the head on tape i either to theleft (if d i = L ), to the right (if d i = R ), or not at all (if d i = N ). The initial state of the TM – in particular, the way thatthe input is supplied to the tapes – depends on the con-vention of choice, except that the initial internal state isalways assumed to be q . For our purpose, we assumethat all but a finite number of tape cells must initiallycarry the blank symbol , so that the input is finite inthis sense. If, at any time step, the TM reaches the state q f , then it “halts”, and the content of one or all of thetapes is – according to some choice of convention – in-terpreted as the TM’s output . Depending on the choiceof convention, there may also be other events that areinterpreted as “halting” (in particular, if the TM is notassumed to have a distinguished state q f ∈ Q ): for ex-ample, trying to turn left from cell of a one-way infinitetape, or having δ undefined on the current combinationof q and (cid:126)σ .Hennie [16] makes a particular choice of conventionfor defining TMs and for constructing a universal TM.He considers TMs that have a single ( n = 1 ) one-wayinfinite tape, no final state q f , and a finite alphabet Σ = { , , . . . , k } , where denotes the blank symbol. The setof internal states is denoted Q = { , , . . . , m } , where q := 0 is the initial state. The tape head direction can beeither left ( L = 0 ) or right ( R = 1 ), but the head cannotstay at its current position. The TM is assumed to haltif it either runs off the tape (to the left of cell ), or if itlands in a combination of internal state q and tape sym-bol σ such that δ ( q, σ ) is undefined. Hennie is not partic-ularly explicit in defining what the “input” or “output”of the TM computation shall be (some function of theinitial resp. final tape pattern): the choice of conventionfor how to do so can be adapted to the desired context.Values of the transition function like δ ( q, σ ) = ( q (cid:48) , σ (cid:48) , d ) are represented via quintuples ( q, σ, σ (cid:48) , d, q (cid:48) ) . Hence, every TM T can be represented as a finite list ofsuch quintuples. We will consider this list to be ordered,and by convention to start with a quintuple that beginswith the starting state q . We now obtain the first stepof Hennie’s construction of a universal TM: the choiceof description p T of a TM T . The description p T willbe a binary string, namely a unary representation of thequintuples that define T . This is best explained by oneof Hennie’s examples. Consider the TM described bythe quintuples ( q , , , R, g ) , ( q , , , R, q ) , ( q , , , R, q ) , ( q , , , L, q ) , ( q , , , R, q ) , ( q , , , L, q ) . Recalling that internal states and directions are also in-tegers, we get the equivalent (but less readable) form (0 , , , , , (1 , , , , , (1 , , , , , (2 , , , , , (3 , , , , , (3 , , , , . Denoting k consecutive ’s by k , the unary representa-tion of a quintuple is ( a, b, c, d, e ) (cid:55)→ a +1 b +1 c +1 d +1 e +1 , and we will describe a sequence of quintuples by con-catenating the descriptions of each quintuple, separatedby pairs of blank symbols (zeros). That is, our represen-tation of the example TM becomes . In addition to the description p T of the TM T , we alsohave to supply our universal TM U with the tape con-tent x of TM T . Formally, U ( p T , x ) = U ( (cid:104) p T , x (cid:105) ) , where (cid:104) p T , x (cid:105) is the initial tape content of U that by def-inition encodes the pair p T and x . Note that we cannotsimply define (cid:104) p T , x (cid:105) 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 gen-eral be different from the alphabet Σ T of T (potentiallycontaining fewer elements), so that x cannot in generalbe directly copied from T ’s tape to that of U .Hennie chooses the following construction. Given theinitial tape content x = x x x . . . of T (with x i ∈ Σ T ),consider the unary encoding x u := 1 x +1 x +1 x +1 . . . By construction, the TM U shall contain three distin-guished “marking symbols” A, B, C ∈ Σ U \{ , } . Then,the full encoding is defined as (cid:104) p T , x (cid:105) = A | Q T | + | Σ T | +2 Bp T Cx u . In summary, the cells between A and B represent a bufferregion that is large enough to contain a unary representa-tion of T ’s current internal state q and currently scannedtape symbol σ . The region between B and C containsthe description of T , and the rest of the tape contains adescription of T ’s initial tape content.In essence, the TM U is constructed to work as fol-lows. It copies the current description of T ’s internalstate q (which is what succeeds the B marker) and thecurrent description of T ’s scanned tape cell σ (succeed-ing the C marker) into the buffer region. Then U scansthe p T region to find the quintuple beginning with thecombination ( q, σ ) inscribed in the buffer region (if nosuch quintuple is found then U halts) and moves the B marker in front of that quintuple. Finally, U reads thedirection d ∈ { L, R } and new tape symbol description σ (cid:48) ∈ Σ T , updates T ’s tape description accordingly, andmoves the C marker either left or right (if it moves leftthen it checks whether this would imply that simulated T runs off the tape; if so U halts). Then it restarts thiscycle. For a more detailed description of U , see [16, Sec. 2.3].In principle, to define U , one would have to give the de-tailed definition of its transition function δ U (or, equiv-alently, its long list of defining quintuples). This wouldbe extremely cumbersome. Hence, what is done insteadis to argue that subroutines like “copying” or “search-ing” can be incorporated into the definition of U by ef-fectively using other TMs as “submachines”. This is ex-plained in [16, Sec. 2.1].More generally, in the rest of the paper, we will oftensimply describe in words how a TM is supposed to workon the contents of its tapes, and assume that this canin fact be implemented in the definition of the TM insome way. In addition to the possibility of checking thevalidity formally for each single case, such reasoning isstandardly justified via the Church-Turing thesis.To formulate in (semi-formal) detail how Hennie’sconstruction satisfies our conjecture, let us introduceone additional piece of notation. Given any TM T , in-put x , and time t ∈ N , denote by C T ( x, t ) the configuration of T after having computed for t stepson input x . With “configuration”, we mean a completedescription of the content of its tapes, of its internal state q , and of the location of its tape head(s). The (count-able) set of all possible configurations of TM T will bedenoted C T . The countable set of all configurations thatany Turing machine of this sort can hold is denoted C := (cid:83) T TM C T ; this is the set of all configurations wherethe control is in some integer state, the tape head pointssomewhere, and finitely many tape cells are filled by in-tegers (and the rest with blanks). This allows us to for-mulate the following observation. Observation 1.
Hennie’s universal TM U has the fol-lowing property. There exists a “simple” function ϕ : C U → C and, for every TM T , an increasing function τ T : N → N such that C T ( x, t ) = ϕ (cid:0) C U ( (cid:104) p T , x (cid:105) , τ T ( t )) (cid:1) . In other words, the time evolution of T on input x can“easily be read off” from the time evolution of U on in-puts p T and x , with a possible slowdown t (cid:55)→ τ T ( t ) .Moreover, the function τ T has a simple characteriza-tion in the following way. If we follow the step-by-stepevolution of U ( p T , x ) for times τ = 1 , , , . . . , then wecan directly observe whether τ = τ T ( t ) for some t ornot. Namely, if U has returned to the beginning of itssimulation cycle at time τ , then this is the case, and oth-erwise not. We can determine t by starting at t = 0 ,and by increasing t by one whenever U ’s computationrestarts its cycle. In most textbooks, emphasis is placed on the fact that thesimulation of T by U leads to a slowdown that is at mostpolynomial; in our notation, this means that the func-tion t (cid:55)→ τ t grows at most polynomially. However, forour purpose, this fact is not particularly relevant: as dis-cussed earlier, we are not interested in the time it takesto make a prediction, but in the information that is in-volved in generating the prediction.The function ϕ is essentially an extended “snapshotfunction” of the simulated TM [18]. It can easily be de-scribed 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, simplysearch for the marker C and count groups of ones; to de-termine the content of type cell i , count i groups of onesright of the left-most and translate the correspond-ing x i +1 into x i . This is a very “simple” function; yet, inwhat sense a general definition of “simple” should ap-ply to all universal computers is a non-trivial questionthat we will address next. B. A simulation preorder on TMs Do all universal TMs satisfy a version of Observa-tion 1, as Hennie’s universal TM does? To address thisquestion, we first need to give a general definition ofa universal TM U . In Section III, we have intuitivelythought of universal TMs as those that satisfy Eq. (1).Note however that Hennie’s universal TM does not sat-isfy that equation, but rather T ( x ) = ψ ( U ( p T , x )) , (2)where ψ is another “simple function” that extracts T ’sfinal tape content from that of U . Namely, U does notexactly end with the same output as T , but with a cer-tain unary encoding of its output, preceding by a a bufferregion, a description of T , and three markers. This isnecessary because the tape alphabets of T and U neednot be identical. The map ψ implements the correspond-ing decoding.Note that Eq. (2) cannot be used as a definition of thenotion of universal TM, unless the map ψ is carefully re-stricted. In particular, if we only demand that ψ is com-putable, then the “identity machine” that simply out-puts the input (i.e. that “does nothing”) would count asuniversal: U ( p T , x ) ≡ U ( (cid:104) p T , x (cid:105) ) := (cid:104) p T , x (cid:105) . This is because we can define ψ to be the computablepartial function ψ ( (cid:104) p T , x (cid:105) ) := T ( x ) . In this way, we canshift 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 avoidsthe “output decoding” issue: Definition 2 (Turing machine (TM)) . In the remain-der of this paper, unless mentioned otherwise, a TM T is always assumed to conform to the following re-quirements. The TM has a set of internal states Q = { , , , . . . , k − } with k ∈ N , where q := 0 isthe initial state and q f := k − the final state. TheTM has two bidirectional tapes (input and work tape),and one unidirectional tape (the output tape). The in-put tape is read-only, i.e. its content cannot be modi-fied during the computation. The finite alphabet for alltapes is Σ = { , , } . The input is a finite binarystring x ∈ { , } ∗ that is initially written on the cells , , . . . , (cid:96) ( x ) − of the input tape. All other cells ofall tapes are initially blank ( ). All tape heads start inposition zero. At each step of operation, the input andwork tape heads can independently either move to theleft or to the right. Furthermore, the machine may writea bit ( or ) at the current cell of the output tape andmove its output tape head one position to the right (butnot to the left), or it leaves the output tape as it is. Ifthe machine halts, i.e. enters the distinguished internalstate q f , then the TM’s output, y , is the finite binarystring that has so far been written onto the output tape.If this happens, then we write T ( x ) = y . This definesa partial function from the finite binary strings to thefinite binary strings.A configuration of a TM is a description of some in-ternal state q ∈ Q , of the number | Q | of internal states,of some positions of the tape heads, and some finite infor-mation content of the tapes (all but finitely many cellsare blank). The countable set of all possible configura-tions will be denoted by C . By uni/bidirectional , we mean that the head can bemoved in only one/both of the directions. The notionsof input and output are perfectly clear for such a TM.Moreover, a TM of this kind resembles our idea of “Johnpreparing breakfast” from Section I: we can observe themachine creating its output bits one after the other. Nooutput bit will ever be erased; the output is completeonce the machine has halted. In some sense, the out-put tape represents “John’s observable actions”, and thework tape represents “John’s brain”.We can now define the notion of a universal TM in thefollowing way. Definition 3 (Universal TM) . A TM U is universal if it satisfies the following conditions. There exists a de-cidable prefix code { p T } T , where T labels the Turingmachines, such that p T ∈ { , } ∗ is a computable de-scription of the TM T : that is, there is an algorithm thatextracts the set of internal states Q and the transitionfunction δ from p T . Furthermore, U ( p T x ) = T ( x ) for all x ∈ { , } ∗ ; (3) 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 binarystring 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 onthe rest of the input. Note that this definition is strictlystronger than the usual definition of a universal TM asused in algorithmic information theory [15, 20]: there,it is only demanded that for every TM T there is some p T ∈ { , } ∗ such that Eq. (3) holds, but it is not ex-plicitly demanded that a description of T can be recon-structed from p T . Decidability of the prefix code { p T } means that there is a computable function f : { , } ∗ →{ , } with f ( s ) = 1 if and only if s ∈ { p T } — i.e. thereexists an algorithm that decides for every given stringwhether that string is a valid encoding of a TM or not.Given our informal observation regarding Hennie’suniversal TM, we may now start with a first attempt atformalizing our conjecture. Let us begin by reconsider-ing the behavior of our informal observation in slightlydifferent notation. To be rigorous, we need to fix a set of“simple functions” that extract the configuration of thesimulated TM from the configuration of the universalTM. Let us defer the decision of how to define a “simplefunction” to later; let us simply assume that there is a set S of simple functions ϕ : C (cid:48) → C (cid:48) , where C (cid:48) := C ∪ {∅} isthe set of TM configurations, supplemented by an addi-tional element ∅ (cid:54)∈ C which denotes something like “nota valid configuration”. We demand that ϕ ( ∅ ) = ∅ for all ϕ ∈ S . Furthermore, we assume that S is closed undercomposition, i.e. if ϕ, ψ ∈ S then ϕ ◦ ψ ∈ S , and that theidentity map is in S . We also assume that the functionsin S are computable and total.Now consider the sequence of configurations C U ( p T x, t ) for t = 0 , , , . . . . The idea is that for some t (cid:48) , the universal TM U has just completed anothersimulated step of operation of T . If we denote thenumber of simulated time steps by t (such that t ≤ t (cid:48) ),then we want our simple function ϕ to yield C T ( x, t ) = ϕ ( C U ( p T x, t (cid:48) )) . Otherwise, the right-hand side will simply yield ∅ . Onthe one hand, this means that we obtain C T ( x, t ) = ϕ ( C U ( p T x, τ T ( t ))) exactly as in our informal observation. On the otherhand, if T halts on input x at time t H , this allows usto obtain the sequence C T ( x, , C T ( x, , . . . , C T ( x, t H ) by parsing the sequence C U ( p T x, , C U ( p T x, , . . . , C U ( p T x, t (cid:48) H ) via application of ϕ to each entry, discarding thosewhere ϕ takes the value ∅ . Definition 4 (Simulation preorder) . Let T and T (cid:48) be TMs. Suppose that, relative to our choice of simplefunctions S , there is some ϕ ∈ S such that for everyinput x ∈ { , } ∗ , the sequence of configurations C T ( x, , C T ( x, , . . . , 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 sequenceof configurations C T (cid:48) ( x, , C T (cid:48) ( x, , C T (cid:48) ( x, , . . . , C T (cid:48) ( x, t (cid:48) H ) , where t (cid:48) H is the halting time of T (cid:48) on input x , and ∞ otherwise, in the following way. One after the other,apply ϕ to the C T (cid:48) ( x, • ) , and if the result is not ∅ , thenappend the result to the list. In this case, we will saythat T (cid:48) simulates T and write T (cid:22) S T (cid:48) . Note that this implies that t H ≤ t (cid:48) H . Since the identity function is in S , we have T (cid:22) S T forall TMs T . Furthermore, T (cid:22) S T (cid:48) and T (cid:48) (cid:22) S T (cid:48)(cid:48) implies T (cid:22) S T (cid:48)(cid:48) , since simple functions can be composed. Thisimplies that (cid:22) S is a preorder on the TMs.The idea of defining a simulation preorder is not new.However, to the best of our knowledge, all existing def-initions, including Milner’s seminal work [21], define anotion of simulation that is too strict for our purpose.Namely, these definitions basically say that some ma-chine S simulates another machine T if there is an in-jection of T ’s states into those of S such that each singlestate transition of T corresponds to a single state tran-sition of S . These definitions are very natural for finiteautomata [22]. However, for TMs, we need a looser def-inition of simulation that allows S to simulate a singlestep of T within more than one time step.When we compare the computation of T with its sim-ulation by U , we have an additional prefix p T on theinput, as explained above. The behavior sketched abovewill then be abbreviated by writing T (cid:22) S U ( p T • ) . Weuse this notation for our first attempt to formalize ourconjecture: Conjecture (1st attempt).
For every universal TM U , we have T (cid:22) S U ( p T • ) for all TMs T. (4)This seems like a very natural conjecture: universal TMsoperate by taking the description p T of any other TM T ,and by then simulating T in a step-by-step manner.However, we will now see that this cannot quite betrue. Consider a Turing machine T that operates as fol-lows. On input x , it begins by computing the (cid:96) ( x ) thprime number in binary on its work tape. After that, ithalts unconditionally. This Turing machine T will out-put the empty string on every input, i.e. T ( x ) = ε forall x ∈ { , } ∗ , and it will do so extremely inefficiently.In fact, let us consider an infinite sequence of modifi-cations of this inefficient machine, labelled by T i . Allthe T i are identical to T , but they have i additional in-ternal states that are all irrelevant for all their computa-tions. That is, the transition functions of all T i are thatof T , and if Q = { , , , . . . , k − } is the set of inter-nal states of T , then the set of internal states of T i is Q i := { , , , . . . , k − , k, . . . , k − i } .Consider now any standard textbook universal TM U ,but modify it such that it does the following. In the verybeginning, U will examine the p T -part of the input, andcheck 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 proceedlike the textbook machine; otherwise, it will refrain fromsimulating T i , and instead halt (and output ε ) immedi-ately and unconditionally.In this case, there will be infinitely many counterex-amples to Eq. (4), namely all the T = T i will violate it.Let us therefore attempt a more modest version of ourconjecture: that our simulation claim is not valid for all TMs T , but for infinitely many : Conjecture (2nd attempt).
For every universal TM U , we have T (cid:22) S U ( p T • ) (5)for infinitely many TMs T .This is certainly a humble claim: intuitively, we wouldexpect that U can only “shortcut” a small class of TMs,like the T i , for which it is specifically designed to knowor find the shortcut. Thus, we might expect that Eq. (5)not only holds for infinitely many TMs, but in somesense for “most” TMs, or for “typical” TMs T .Yet, it seems formally very difficult to talk about “typ-ical” TMs, so sticking to the above formulation avoidsthe complication of having to do so. Moreover, there isanother reason to be careful. A violation of T (cid:22) S U ( p T • ) does not necessarily mean that U shortcuts T ; it can alsomean that U reproduces T ’s outputs in a completely different, surprising and contrived way that may takemuch longer time than naively simulating T . Perhaps itis possible to have a universal TM U that “disperses” orencrypts its simulation of many (or all!) other TMs T insuch a way that no simple function can ever read out thecurrent state of T ?To understand better whether and how this is possi-ble, we have to address a question that we have so farignored: how should we define our class of “simple”functions S ? We will turn to this question in the nextsection. For now, let us conclude with another smalladaptation of our conjecture. It would arguably be triv-ial if the simulation claim, Eq. (5), was only true for asingle TM T and for infinitely “almost identical” TMs– recall the TM T and its “almost identical” modifica-tions T i above. Instead, we want the simulation claimto be true for many “sufficiently diverse” TMs T . Forthe moment, let us leave open what this is supposed tomean in detail: Conjecture (3rd attempt).
For every universal TM U , we have T (cid:22) S U ( p T • ) for a “sufficiently diverse” (in particular, infinite)set of TMs T .Moreover, if we denote the simple function thatimplements the simulation decoding of T by ϕ T ,then the map p T (cid:55)→ ϕ T is computable.We have added another desideratum to the conjec-ture: that given T ’s description p T , a finite algorithm canactually determine an effective description of the sim-ple function ϕ T which reads out T ’s simulated config-uration from U ’s. We assume that this algorithm yieldssome valid ϕ T for all p T , but the result must only be cor-rect for those T for which Eq. (5) actually holds. Thisdemand is very natural: not only do we want that T ’scomputation can in principle be determined from U ’s,but that it can generally be known how to do so .If the set of simple functions S is closed under certainoperations, we can equivalently demand that the decod-ing function is independent of T : Lemma 5.
Suppose that the set of simple functions S has the following prefix closure property : for everydecidable prefix code { p } labelling a set of simple func-tions { ϕ p } ⊆ S , there is a simple function ϕ ∈ S whichimplements ϕ p if and only if the input tape starts with p . Then the final sentence in the above 3rd formaliza-tion attempt is equivalent to demanding that there isa unique simple function ϕ ∈ S that implements thesimulation decoding for every TM T . S as we willnow discuss. C. How not to choose the set of simple functions S It is clear that every rigorous formulation of our con-jecture 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 sim-ple. In this case, T (cid:22) S U ( p T • ) implies C T ( x, t ) = C U ( p T x, t ) for all x ∈ { , } ∗ and all t ∈ N . But 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 respec-tively), hence T and T (cid:48) have different configurations,and C T ( x, (cid:54) = C U ( p T x, .More generally, the following holds: Lemma 6.
If we define S to be minimal, i.e. to onlycontain the identity function ( S = { id } ), then T (cid:22) S T (cid:48) ⇔ C T ( x, t ) = C T (cid:48) ( x, t ) for all x, t. That is, TMs formally only ever simulate machines thatare exactly identical to themselves in all their state tran-sitions. In particular, T (cid:22) S T (cid:48) becomes equivalent to T (cid:48) (cid:22) S T . Note that the right-hand side is not the same as T = T (cid:48) : for example, T = T i and T (cid:48) = T j for i (cid:54) = j fromthe family of inefficient TMs above will also satisfy it.However, TMs T and T (cid:48) that satisfy the right-hand sideabove 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 betrue, S must contain all possible ways in which univer-sal computers can choose to encode the simulation intheir own configuration. In particular, S must at leastcontain all “textbook simulation encodings”, like theone used by Hennie as described in Subsection IV A.On the other hand, suppose we define S to be the setof all total computable functions ϕ with ϕ ( ∅ ) = ∅ . Thenthis will make our conjecture trivially true for many uni-versal computers U , but it will fail to express any in-tuitively meaningful notion of “simulation”, as we willnow demonstrateSuppose that there exists some universal TM V thatviolates every meaningful formalization of our mainconjecture: V simulates all TMs T in highly contrived,counterintuitive ways that cannot meaningfully be in-terpreted as “containing the T -configuration step bystep”. Let us construct another universal TM U with U ( x ) = V ( x ) for all x ∈ { , } ∗ . By construction, U simulates V exactly step by step. But in addition, U con-tains a counter on some unused portion of its work tape,i.e. a representation of a natural number τ that starts inzero and increases by one after every step of simulationof the TM V . (This makes U potentially quadraticallyslower than V , but this does not matter for our purpose.)For example, U could simulate V on the even cells of itswork tape, and provide the counter on the odd cells insome way. Now define a total computable function ϕ via the following algorithm:• By definition, the algorithm extracts p T and x fromthe input tape, and t from the work tape.• Then it simulates T on input x for t steps and com-putes and returns the configuration C T ( x, t ) .Consequently, we obtain T (cid:22) S U ( p T • ) for all TMs T . However, by construction, U never actually per-forms any step-by-step simulation of any TM T (since V doesn’t). Thus, the mathematical formalism ceases toexpress what it was constructed to express: a valid for-mal notion of step-by-step simulation.To elaborate this argument, consider the followingspecial TM: Definition 7 (Clock Turing Machine) . A clock Tur-ing machine C is a TM that ignores its input andcounts integer time steps t ∈ N on its work tape in-definitely. We are not giving a formal construction of a clock TM,but it is not difficult to think of a concrete set of inter-nal states and a transition function that implements theclock. For example, at each time step, the TM may sim-ply write a fixed symbol (say, ) in the currently activecell of the work tape and move the work tape head tothe right. Since this can be done in different ways (e.g.writing only zeros or ones, or alternating in ways thatare determined by changes of the internal state), thereare infinitely many clock TMs. Clock TMs C never halt,i.e. C ( x ) is undefined for every x ∈ { , } ∗ .The construction above shows the following: Lemma 8.
Let C be a clock TM. If we define S to bemaximal, i.e. equal to the set of all total computablefunctions ϕ with ϕ ( ∅ ) = ∅ , then T (cid:22) S C for all TMs T. That is, the clock TM C will formally be considered tosimulate all other TMs step by step. Most total computable functions are intuitively ex-tremely complex , so the maximal choice of S is obviously1a very bad formalization of a “set of simple functions”.However, the argument above rules out other, more in-tuitively meaningful choices of S . For example, we mayconsider the set S of functions that have at most lineartime complexity. A running time at least linear in theinput length is required to read the input, and as wewould like the functions in S to be simple, it is natu-ral to demand that they shall not take significantly moretime than this minimum.However, we will now argue that even such functionswith linear running time can still be too powerful, asthey also allow to apply the clock TM trick from before.Since we are considering functions on configurations,we have to be more specific about what we mean by lin-ear time complexity. For our purpose, we will restrictour attention to the following specific choice of encod-ing of configurations and TMs M ϕ that compute ϕ ∈ S .The TM M ϕ is supposed to satisfy Definition 2, up to aconvenient 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 five work tapes( W in , W out , W , and W state ).We use the convention that M ϕ receives the input con-figuration c ∈ C in the following way. The tapes andthe corresponding head positions will exactly be copiedonto the in-tapes. That is, I in contains the exact inputtape content as described by c , and also its tape head willbe placed at the current position specified by c ; similarlyfor W in and O in . The internal state q ∈ Q described by c will be written via (cid:100) log | Q |(cid:101) 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 posi-tions of the target configuration c (cid:48) = ϕ ( c ) , and the tape W state contains the description of the internal state of c (cid:48) .If the content of W state is not a syntactically correct de-scription of any q ∈ Q , then the output configuration istaken to be ∅ .Given such ϕ , let us say it has linear time complexity or linear running time if the number of computation stepsof 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 toopowerful to represent a meaningful notion of simplefunctions. Consider again a clock TM C of Lemma 8.Given a TM T that is supposed to be simulated, wecan 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 (cid:48) , where the Q (cid:48) part is used to carry its func-tionally relevant internal state, while Q T carries the rep-resentation of an internal state of T . First, M ϕ T copiesthe input of T from I in to I out . Then M ϕ T sets the firstcomponent of its internal state equal to the starting state q ∈ Q T of T . From that moment on, M ϕ T behaves ex-actly like T , with I out as its input tape, W out as its (ini-tially blank) work tape, O out as its (initially blank) out-put tape, and Q T as state register: we assume that thetransition function of M ϕ T contains the transition func- tion of T and uses it for an exact step-by-step simulationof T . After every simulated time step, M ϕ T moves thehead on W in to the left. When that head reaches a blanksymbol, M ϕ T represents the first part of its internal statevia (cid:100) log | Q T |(cid:101) bits on the tape W state and halts.The TM M ϕ T operates in linear time and maps config-urations to configurations. If we apply M ϕ T to the clockTM C , then M ϕ T will simulate T for as many steps t asthere are ones on C ’s work tape. This clearly producesthe configuration C T ( x, t ) in linear time. Thus, ϕ T ∈ S ,and we have shown the following: Lemma 9.
Let S be the set of total computable func-tions (on the configurations) that run in linear time , inthe sense explained above. Then we still have T (cid:22) S C for all TMs 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 isneeded to even read the input configuration. So is thereanother way to define a set of simple functions S thatgives us a nontrivial simulation preorder, but that leavessome chance for our conjecture (say, in its 3rd formaliza-tion) to be true? Unfortunately, there is a strong counter-argument to this hope, as we will now demonstrate. D. An encryption counterexample to “simplicity”
Let us now show that our conjecture cannot holdwithout substantial modification. Since a detailed for-mal proof of what follows seems very cumbersome, wewill instead give an informal argument which we be-lieve is sufficiently detailed to support our conclusion.Consider some universal TM U of the textbook kind— similarly as Hennie’s universal TM, U simulates ev-ery other TM T step by step. Let us construct a modifica-tion of U , denoted U (cid:48) , that has equivalent input-outputbehavior as U , i.e. U ( x ) = U (cid:48) ( x ) for all binary strings x .However, U (cid:48) will encrypt all the parts of T that are notrelevant for the current simulation step. Then functions ϕ ∈ S that deserve the name “simple” will not be ableto crack the encryption of U (cid:48) s representation of T .To this end, consider some computable function thatmaps integers n ∈ N to bits a n ∈ { , } . Let us choosea function that is very difficult to evaluate: For exam-ple, we may assume that it takes O (2 n ) time steps tocompute a n . More specifically, the time hierarchy the-orems [18] guarantee the existence of a decision prob-lem that cannot be solved within time O (2 n ) , but withintime O (2 n ) , and we choose a n to be the answer to sucha problem. For negative i , we will use the convention a i := a | i | . We will use this string of bits for encryption.2Like U , the TM U (cid:48) simulates all elements of T stepby step. In particular, it contains the contents { w i } i ∈ Z on T ’s work tape cells somewhere in its memory. Whilesimulating a single time step of T , the TM U will readthe current tape cells, determine and write their newcontents, and then move the simulated tape heads leftor right. We construct U (cid:48) such that it replaces this onesimulated step of operation of T by the following simu-lation steps (all tape cells are simulated tape cells):• It reads the symbol in the currently active worktape cell i (assumed unencrypted) and the othercurrently active tape cells and applies T ’s tabu-lated transition function δ to determine whetherit has to move left or right on the tapes, and whichsymbol w i it has to write into the work tape cell(and similarly for the other tapes).• Then it computes, with a fixed program indepen-dent of any other tape content, the bits a i and a i + σ ,where σ = − if it has to turn left on the work tapeor σ = +1 if it has to turn right.• It determines w (cid:48) i , which is the blank symbol if w i is blank, and which is w i ⊕ a i if w i is a bit (en-cryption). It writes w (cid:48) i into work tape cell i andreads w (cid:48) i + σ from work tape cell i + σ . It then deter-mines w i + σ , which is the blank symbol if w (cid:48) i + σ is blank, and w (cid:48) i + σ ⊕ a i + σ otherwise (decryption).The writing onto the input and output tape is per-formed without encryption, as determined by T ’stransition function δ .• U (cid:48) erases all data that results from the computa-tion of a i and a i + σ and of the sums of those withthe work tape bits from other parts of its memory.We assume that the TM U (cid:48) is constructed such that theonly relevant difference after the encryption resp. de-cryption step to before is the value of the simulatedwork cell bit. In other words, U (cid:48) is supposed to “eraseall the garbage” that it produced while computing a i ,leaving only a simple encoding of the encrypted con-figuration of T . We also assume that U (cid:48) does not containan explicit counter of the number of time steps that havepassed since the start of the computation.Let s , s , s , . . . label the times at which the TM U (cid:48) has completed simulating (as described above) the first,second, third . . . step of computation of T . Now supposethat the current formalization of our conjecture is true,for some intuitively reasonable set of simple functions S .Then there is some ϕ (cid:48) ∈ S and an increasing sequence oftimes { τ (cid:48) t } t such that ϕ (cid:48) ( C U (cid:48) ( p T x, τ (cid:48) t )) = C T ( x, t ) (6)for all t , and such that ϕ (cid:48) ( C U (cid:48) ( p T x, s )) = ∅ for all s (cid:54)∈{ τ (cid:48) t } t . A priori, the times τ (cid:48) t need not at all be relatedto the simulation times s t . For example, ϕ (cid:48) could actsimilarly as the function that we have used to prove Lemma 8: it could simply perform the simulation of T itself, without having to wait for U (cid:48) to have finished itssimulation steps. Then we could have, for example, that τ (cid:48) t = t , but s t will grow exponentially with t .However, such functions ϕ are not of the form that wehave in mind in any intuitive formulation of our conjec-ture. Let us therefore assume that the set of simple func-tions S does comply with out intuition to some extent: the simple functions shall not simulate T by themselves, butshall only read was has already been simulated by the uni-versal TM U (cid:48) . Intuitively, the simulated configuration C T ( x, t ) is generated (in encrypted form) at time s t on U (cid:48) and not before. Thus, our assumption amounts topostulating that the times τ (cid:48) t must essentially be on orafter the times s t when U (cid:48) has performed the t th step ofsimulation of T : Assumption 1.
There is a possible choice of ϕ (cid:48) suchthat there exists at least one x such that s t ≤ τ (cid:48) t < s t +1 for many different t .Note that we are not assuming that this has to holdfor all TMs T . We only need to assume that there existsat least one TM T within the “sufficiently diverse” set ofTMs (as mentioned in the 3rd attempt of formalizationof our conjecture) that satisfies this assumption and theother two below.In other words, for many t , the simple function ϕ (cid:48) hasto read out C T ( x, t ) within the time interval [ s t , s t +1 − — this may not be true for all simple functions that readout T ’s configuration, but we assume that it is true for some ϕ (cid:48) .Now, via Eq. (6), let us analyze what this means forsuch ϕ (cid:48) . Consider one of the “many different t ” fromAssumption 1. Then the simple function ϕ (cid:48) has to de-termine C T ( x, t ) from some C U (cid:48) ( p T x, s ) , where s t ≤ s
Computing C T ( x, t ) from C U (cid:48) ( p T x, s ) is essentially equivalent to computing it from C T ( x, t ) ∗∗ — in this sense, the “rest” can be ignored.But now, recalling Eq. (6), we find that ϕ (cid:48) essentiallyhas to map C T ( x, t ) ∗∗ onto C T ( x, t ) — it seems like thismeans that ϕ (cid:48) has to decrypt all but two of T ’s work tapebits, which is a Herculean task if the work tape containsmany bits.Or does it really have to? Note that there may be in-direct ways of determining C T ( x, t ) from C T ( x, t ) ∗∗ with-out actually doing any decryption. For example, sup-pose that T = C is the clock TM from Definition 7. Then C T ( x, t ) has a sequence of t identical ones on its worktape (followed by blank tapes). This configuration canbe determined by simply counting how many non-blanksymbols are on the work tape of C T ( x, t ) ∗∗ , and then byreplacing 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 iden-tical x ), only in the content of the work tape bits. (Forexample, T could simply count integers in binary on thework tape for a very large number of time steps, withoutmodifying other parts of its configuration.) Then, theonly way to determine C T ( x, t ) from C T ( x, t ) ∗∗ would beby 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 decryptionof C T ( x, t ) ∗∗ .Then we obtain the following consequence. Observation 10.
If the above informal argumentationcan be made rigorous (including in particular the threeassumptions), then our conjecture (in its 3rd attempt offormalization) can only be correct if we allow the set ofsimple functions S to contain maps that are intuitivelyextremely complex. E. 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 fullyrepresented within U — a formulation that is non-trivialand has a chance to be true. But it seems that we havetried to do so in the wrong way: demanding that T ’sconfiguration can be read from U ’s with some functionthat is simple to implement is doomed to fail — at least ifwe understand simplicity as small time complexity. Onthe one hand, the above observation shows that S mustnecessarily contain very complex functions to break theencryption of some universal TMs. On the other hand,Lemma 9 shows that even very small time complexityalready admits functions that “cheat” by performing thesimulation themselves. Note that putting a time bound on admissible read-out functions is similar to the strategy by Zwirn and De-lahaye [10, 11] to define “approximations” of Turing ma-chines in their approach to construct a formal definitionof computational irreducibility. The above shows thatour approach to define computational sourcehood (andits typicality) needs a different strategy.For a different perspective, consider again the exam-ple of the clock TM of Lemma 9. Why should we re-gard functions ϕ ∈ S that implement the simulation bythemselves as “undesired” or “cheating”? Our previ-ous attempt was to say that such ϕ are not simple in anymeaningful sense of the word. But there is an alterna-tive view: we can also say that such ϕ are not sufficientlystructure-preserving .To see this, let us contrast such “cheating” ϕ with typ-ical read-out functions ψ for textbook universal TMs likeHennie’s. Consider two configurations c, c (cid:48) ∈ C of a sim-ulated TM T that are in some sense “pretty close to eachother” — perhaps they differ only in a small numberof bits on the work tape, but are otherwise identical.Consider some configuration c U ∈ C which describesthe universal TM U simulating T in configuration c , i.e. ψ ( c U ) = c . Then we will find another configuration c (cid:48) U close to c U which describes U simulating T in configura-tion c (cid:48) , i.e. ψ ( c (cid:48) U ) = c (cid:48) : intuitively, we only have modifya few bits of c U (those that represent the simulated bitsdiffering between c and c (cid:48) ) to obtain c (cid:48) U from c U .In contrast, the “cheating” ϕ for the clock TM C willnot in general satisfy this property: there will be close-by configurations c = C T ( x, t ) and c (cid:48) = C T ( x (cid:48) , t (cid:48) ) with c = ϕ ( c C ) such that all configurations c (cid:48) C with c (cid:48) = ϕ ( c (cid:48) C ) are very far away from c C . To see this, let T be a univer-sal TM. For every input x ∈ { , } ∗ , denote by t H ( x ) T ’shalting time on input x (which is ∞ if it does not halt onthat input). Furthermore, for those x with t H ( x ) < ∞ ,denote by N ( x ) the smallest i ∈ N such that the i thoutput tape cell is blank at halting; in other words, thismeans that the TM halts with a block of N ( x ) non-blankbits on its output tape; for non-halting x , set N ( x ) := − .Then N n := max x ∈{ , } n N ( x ) grows extremely fast —similarly as the busy beaver function [23], it must growfaster than every computable function, due to the un-decidability of the halting problem. For every n , pickan arbitrary maximizing input x n , i.e. N ( x n ) = N n and (cid:96) ( 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 onits output tape. For every i ∈ [0 , N n ] , denote by c ( i ) n theconfiguration c n with the i th bit on the output tape in-verted. In other words, c n differs from every c ( i ) n in onlya single bit. Now, by definition of ϕ and of the clock TM, c n = ϕ ( C C ( x n , t H ( x n ))) = ϕ ( c n,C ) , where c n,C := C C ( x n , t H ( x n )) . Let us estimate the num-ber of configurations c (cid:48) n,C that have distance at most k from c n,C , where k ∈ N \ { } , i.e. the number of ele-ments in the k -ball B k ( c n,C ) . We have not formally de-fined a distance measure on the configurations yet, and4our argumentation will not be particularly sensitive tothe choice of measure. Nonetheless, for concreteness, letus define D ( C C ( x, t ) , C C ( x (cid:48) , t (cid:48) )) := D H (¯ x, ¯ x (cid:48) )+ | (cid:96) ( x ) − (cid:96) ( x (cid:48) ) | + | t − t (cid:48) | , where ¯ x and ¯ x (cid:48) denote the first m bits of x resp. x (cid:48) ,where m := min { (cid:96) ( x ) , (cid:96) ( x (cid:48) ) } , and D H is the Hammingdistance. (All other configurations will be mapped to ∅ by ϕ , hence we are not interested in them). Clearly, D ( C C ( x (cid:48) , t (cid:48) ) , c n,C ) ≤ k implies | t (cid:48) − t H ( x n ) | ≤ k and (cid:96) ( x (cid:48) ) ≤ (cid:96) ( x ) + k . There are (2 k + 1) many choices of such t (cid:48) and n + k many choices of such x (cid:48) . Since k + 1 < k , | B k ( c n,C ) | < n +3 k . Now let k n := (cid:98) (log N n − n ) (cid:99) , which still grows fasterin n then every computable function. By simple count-ing, there must be at least one i ∈ [0 , N n ] such that ϕ (˜ c ) (cid:54) = c ( i ) n for every ˜ c ∈ B k ( c n,C ) : there are sim-ply not enough configurations in the k -ball to cover all c ( i ) n . Hence for every n there exists some i such that D ( c n , c ( i ) n ) = 1 and c n = ϕ ( c n,C ) , but c ( i ) n = ϕ ( c ( i ) n,C ) ⇒ D ( c ( i ) n,C , c n,C ) > k n , where k n grows extremely quickly in n . Hence ϕ is notstructure-preserving in the way explained above.This motivates our final attempt of formalizing ourconjecture: Conjecture (4th and final attempt).
For every uni-versal TM U , we have T (cid:22) S U ( p T • ) for a sufficiently diverse (in particular, infinite) setof TMs T , where S is a natural set of structure-preserving maps on TM configurations.By structure-preserving maps, as sketched above, wemean functions ϕ with the following property. If wehave close-by configurations c and c (cid:48) , and another con-figuration c U with ϕ ( c U ) = c , then there is another con-figuration c (cid:48) U close to c U with ϕ ( c (cid:48) U ) = c (cid:48) . These functionsare not necessarily assumed to be “easy to implement”.It is not clear whether (and perhaps even unlikelythat) the best definition of “close-by” is similar to theone used above, i.e. based on a distance measure be-tween configurations that is essentially some modifica-tion of the Hamming distance. It may well be that it ismore suitable to introduce a form of “functional similar-ity”, perhaps a notion that is allowed to depend on theTuring machine under consideration. It is hence likelythat higher-level mathematical tools, perhaps from cat-egory theory, are needed to substantiate this attempt.Whether the above attempt can be made rigorous insome such way will have to be seen in future work. V. CONCLUSIONS
In this article, we have revisited the idea that com-puter science notions like computational irreducibil-ity [9] can shed light on the relation between determin-ism and free will [1]. We have addressed two issueswith previous proposals of this kind: first, Wolfram’soriginal proposal did not include a rigorous mathe-matical definition of computational irreducibility, andit is unclear whether later definitions, such as those byZwirn and Delahaye [10, 11], are well suited to reasonspecifically about free will. Second, as argued also byBringsjord [14], the focus of Wolfram’s (and Lloyd’s [13])approach on the question of temporal shortcuts allowsus to reason about unpredictability as a phenomenon offree will, but not directly about the question of whetheragents’ decisions are actually free.Based on a simple thought experiment (“John thecook”, cf. Figure 1), we have proposed a variant of com-putational irreducibility, termed computational source-hood , that is intended to formalize an aspect of actualfree will more directly. We suggest that a process P canbe regarded as the computational source of its behaviorif attempts to reproduce its input-output function musttypically involve a step-by-step simulation that containsreplicas of the history of configurations of P . While thisnotion is closely related to computational irreducibility(in particular, it also implies that there are typically noshortcuts to simulating P ), it makes a more detailed andgeneral claim, by stipulating that even slow simulationsmust typically contain “clones” of the process.We have then taken up the challenge to give a rigor-ous mathematical formulation of this phenomenon andits conjectured typicality. This has led us to a ques-tion about universal Turing machines (TMs), defined bytheir ability to reproduce the input-output behavior ofall other TMs T : is it true that all universal TMs work byessentially simulating T step by step, except for a small sub-set of TMs T for which they know shortcuts? While thisquestion – and the conjecture of a positive answer to it –can easily be described in words, it turns out to be quitedifficult to find a rigorous formulation that is non-trivialand has a chance to be true.Our first idea of formalization was to say that U sim-ulates T step by step if the temporal sequence of config-urations of T can be read out from the sequence of con-figurations of U via some “simple function”. We haveshown that this is true for textbook constructions of uni-versal TMs like Hennie’s [16], but we have identified ob-structions to proving that this must be true in general.On the one hand, we have given a universal TM thatencrypts most of the simulated data, which shows thatread-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 un-intended functionality (namely, perform the simulationthemselves) that leads to a trivial notion of simulation.These insight have led us to formulate a version of our5conjecture that defines simulation not in terms of sim-ple , but structure-preserving functions: close-by configu-rations of the simulated TM T should be represented byclose-by configurations of the simulating TM U . Whilewe were not able to suggest a rigorous definition of“close-by”, we have shown that its simplest implemen-tation leads to a notion of simulation that is not trivial-ized by the clock TM example. Whether this formula-tion of the conjecture can indeed be made rigorous in aninteresting way will have to be seen in future work.While we were not able to settle our conjecture, webelieve that its study can lead to interesting insightsinto the nature of universal computation, regardless ofwhether it turns out to be true. Our results and con-structions shed considerable light onto attempts to for-malize it, and we hope that they will open up new waysto think about the nature of free will and its relation tocomputation. ACKNOWLEDGMENTS
We are grateful to Andrew J. P. Garner for stimulat-ing discussions. This research was supported by grantnumber FQXi-RFP-1815 from the Foundational Ques-tions Institute and Fetzer Franklin Fund, a donor ad-vised fund of Silicon Valley Community Foundation.MK acknowledges the support of the Vienna DoctoralSchool in Physics (VDSP) and the Vienna Center forQuantum Science and Technology (VCQ). This researchwas supported in part by Perimeter Institute for Theo-retical Physics. Research at Perimeter Institute is sup-ported by the Government of Canada through the De-partment of Innovation, Science and Economic Devel-opment Canada and by the Province of Ontario throughthe Ministry of Research, Innovation and Science. [1] T. O’Connor and C. Franklin, “Free Will”, The StanfordEncyclopedia of Philosophy (Fall 2020 Edition), EdwardN. Zalta (ed.), URL = https://plato.stanford.edu/archives/fall2020/entries/freewill/ .[2] D. Dennett,
Elbow room: the varieties of free will worth want-ing , MIT Press, Cambridge, MA, 1984.[3] D. Dennett,
Freedom evolves , Penguin Books, New York,2003.[4] S. Pinker,
How the mind works , W. W. Norton & Company,New York, 1997.[5] J. M. Fischer and M. Ravizza,
Responsibility and Control:A Theory of Moral Responsibility , Cambridge UniversityPress, Cambridge, 1998.[6] M. McKenna and J. D. Coates, “Compatibilism”,The Stanford Encyclopedia of Philosophy (Fall2020 Edition), Edward N. Zalta (ed.), URL = https://plato.stanford.edu/archives/fall2020/entries/compatibilism/ .[7] R. Gandy,
Church’s thesis and principles for mechanisms , inJ. Barwise, H. Jerome Keisler, and K. Kunen (eds.),
TheKleene Symposium , North Holland Publishing, Amster-dam, 1980.[8] P. Arrighi and G. Dowek,
The physical Church-Turing thesisand the principles of quantum theory , Int. J. Found. Comput.S. (5), 1131–1145 (2012).[9] S. Wolfram, A New Kind of Science , Wolfram Research, Illi-nois, 2002.[10] H. Zwirn and J.-P. Delahaye,
Unpredictability and Compu-tational Irreducibility . In: Zenil H. (eds),
Irreducibility andComputational Equivalence. Emergence, Complexity and Com-putation , vol 2. Springer, Berlin, Heidelberg (2012).[11] H. Zwirn,
Computational Irreducibility and ComputationalAnalogy , Complex Systems (2) (2015). [12] H. Zenil, F. Soler-Toscano, and J. J. Joosten, Empirical En-counters with Computational Irreducibility and Unpredictabil-ity , Minds and Machines , 149–165 (2012).[13] S. Lloyd, A Turing test for free will , Phil. Trans. Roy. Soc. A , 3597–3610 (2012).[14] S. Bringsjord, Free will and a new kind of science . In: Ze-nil H. (eds),
Irreducibility and Computational Equivalence –10 years After Wolfram’s A New Kind of Science , Springer,Berlin, Heidelberg (2013).[15] M. Li and P. Vit´anyi,
An Introduction to Kolmogorov Com-plexity and Its Applications , 3rd edition, Springer, NewYork, 2008.[16] F. Hennie,
Introduction to Computability , Addison-WesleyPublishing Co., Reading, MA, 1977.[17] J. E. Hopcroft, R. Motwani, and J. D. Ullman,
Introductionto Automata Theory, Languages, and Computation , Addison-Wesley, 2nd edition, 2001.[18] S. Arora and B. Barak,
Computational Complexity: A Mod-ern Approach , Cambridge University Press, Cambridge,2009.[19] C. H. Papadimitriou,
Computational Complexity , Addison-Wesley, 1994.[20] M. Hutter,
Universal Artificial Intelligence – Sequential Deci-sions Based on Algorithmic Probability , Springer, 2005.[21] R. Milner,
An algebraic definition of simulation between pro-grams , Proc. 2nd Int. Joint. Conf. on Artificial Intelligence,British Comp. Soc., 1971.[22] D. Park,
Concurrency and Automata on Infinite Sequences , inP. Deussen (ed.),
Proceedings of the 5th GI-Conference, Karl-sruhe , Lecture Notes in Computer Science , Springer,1981.[23] T. Rad´o,
On non-computable functions , Bell System Techni-cal Journal41