Notes for the Lifebox, the Seashell, and the Soul - Rudy Rucker

More documents

Recommendations

Info

Notes for The Lifebox, the Seashell, and the Soul, by Rudy Rucker 2350 Programmable clones It becomes possible to grow a clone of yourself in a tank and program its brain with the contents of your lifebox file, creating a person very much like yourself. 3001 The alla The age of direct matter control arrives and we can change anything into anything. Matter is fully programmable. 3002 Space migration People use allas to live in asteroids 3003 3ox A new technology for identically copying an existing objects, including living beings 3150 Ooies Uvvies become internal organs, so that people are constantly in contact. Society truly becomes a hive. 3400 Colony people Some individuals 3ox or clone hundreds of copies of themselves, with the copies connected via ooie. 3400 Spacebug people Still more advanced bioengineering allows people to live in the hard vacuum of outer space. 3666 Teleportation Insight into fundamental physics gives people the ability to jump to arbitrarily distant space locations. 4050 People free to move in higher dimensions Travel to the other worlds beyond our space and time. Stepping Through an Argument for the Universal Unpredictability Lemma Let’s consider the universally computing CA Rule 110 and see what happens if we try to carry out Wolfram’s argument sketched on NKS, p. 742, that a universal computation is “computationally irreducible.” Specifically, let’s look at a computation C110 such that if rowcount is an integer measuring the number of number of rows to be computed and if input is an integer that codes up a start pattern then C110(rowcount, input) = output, means that output is an integer coding up the rowcount th row of a Rule 110 computation starting with the pattern coded by input. Normally, computing C110(rowcount, input) = output takes rowcount*input + n 2 individual cell-update steps or, if you prefer, rowcount row-updates. Now suppose we have a prediction algorithm called Predictor such that Predictor(rowcount, input) = output maps rowcount-input pairs into output rows just like C110 does. And suppose that Predictor computes this in some very small number of computational steps PredictorRuntime(rowcount, input). We might imagine that for sufficiently large rowcount and input, this runtime number might be on the order of the logarithms of the second two arguments, that is, we might expect that PredictorRuntime(rowcount, input) º log(rowcount)+log(input) Wolfram’s argument suggests that we now use the universality of Rule 110 to let it simulate the computation Predictor(rowcount, input). Simulating Predictor means that we have a string prog coding up the program of Predictor and that we can combine prog with a desired rowcount count and an arbitrary input to make a new argument called, say, progrowcount-input. We feed prog-rowcount-input into C110, and by computing some as yet unknown number of rows simulationrowcount, the computation of C110(simulationrowcount, prog-rowcount-input) will emulate Predictor(rowcount, input) by generating output, that is by producing the rowcount th row of Rule 110 starting with input. p. 96
Notes for The Lifebox, the Seashell, and the Soul, by Rudy Rucker The interesting question is whether simulationrowcount can be less than rowcount. If we are pessimists, then we might worry that the cost of having Rule 110 (and thus the computation C110) simulate a step of Predictor might be in fact arbitrarily large, subject to the current state of the computation in progress, so that simulationrowcount is very much larger than the modest size of PredictorRuntime(rowcount, input) would lead us to expect. If for instance we need to keep sending information back and forth through the computational space by means of “gliders,” then it could be that, the larger the computation gets, the slower it runs — this would be akin to having to take into account the limitations of the speed of light in the functioning of a very large electronic computer. But let’s give Wolfram a break here, let’s optimistically suppose that the way that Rule 110 emulates the computation of Predictor involves a fixed maximum cost of StepCost steps per computational step of Predictor. So then we would expect to have simulationrowcount = StepCost * PredictorRuntime(rowcount, input) º StepCost *(log(rowcount)+log(input)) The interesting situation of Rule 110 “outrunning” itself occurs if simulationrowcount < rowcount Wolfram seems to think that this situation would lead to a contradiction involving an infinite descending sequence of positive natural numbers derived from nesting the simulations. But if you analyze it closely, the descending chain will stop as soon as one crosses a cost-benefit condition whereby the overhead of simulation cost swamps the gain of successive levels of simulation. [There will be two overhead costs to take into account: (a) the constant StepCost multiplier already mentioned and (b) the cost of inputting larger and larger strings as the initial conditions so as to simulate more and more refined kinds of computations.] So my impression is that Wolfram’s briefly sketched argument doesn’t work. The Universal Unpredictability Lemma I’m interested in finding some support for the following statement. Universal Unpredictability Lemma. Most naturally occurring universal computations are unpredictable. As I mentioned before, by “unpredictable” I mean “not being emulable by a computation whose runtime is logarithmically faster.” Wolfram prefers the word irreducible for what I call unpredictable. Perhaps Turing’s Corollary that universal computations are runtime unbounded might be viewed as a kind of inspiration for what Wolfram would really like to be true: that a universal computation must be unpredictable. But the two properties have no direct connection that I can see. Wolfram offers the following very brief proof sketch of why a universal computation should be irreducible or unpredictable in the sense that there won’t be a computation that consistently predicts the universal system’s results faster than the system in question. [Wolfram omits to mention that he really means logarithmically faster, but he should, as it’s completely trivial get linear speedups of any computation simply by using more states.] “Consider trying to outrun the evolution of a universal system. Since such a system p. 97
Page 1 and 2:
Notes for The Lifebox, the Seashell
Page 3 and 4:
Page 5 and 6:
Page 7 and 8:
Page 9 and 10:
Page 11 and 12:
Page 13 and 14:
Page 15 and 16:
Page 17 and 18:
Page 19 and 20:
Page 21 and 22:
Page 23 and 24:
Page 25 and 26:
Page 27 and 28:
Page 29 and 30:
Page 31 and 32:
Page 33 and 34:
Page 35 and 36:
Page 37 and 38:
Page 39 and 40:
Page 41 and 42:
Page 43 and 44:
Page 45 and 46: Notes for The Lifebox, the Seashell
Page 95: Notes for The Lifebox, the Seashell
Page 141: Notes for The Lifebox, the Seashell
show all

Notes for the Lifebox, the Seashell, and the Soul - Rudy Rucker

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?