4 ms·
Next, I have told you about machine A but now I also give you a 50 Megabyte program (called "GENOME") that runs on machine A. Now you must write your emulator,
by btilly 16y ago
Next, I have told you about machine A but now I also give you a 50 Megabyte program (called "GENOME") that runs on machine A. Now you must write your emulator, encode GENOME for your emulator, and run it on B. We know you can do that since these are both Turing class machines. What we do not know is how many bits it will take to encode GENOME. It could be 50 Megabytes. Or it could be 50 Terabytes. You just can't tell without proving things about the specific details of machines A and B and your emulator.
If your emulator requires substantially different space to encode the raw description of the program than the original, then the emulator sucks. So if GENOME takes 50 MB to encode in one place, it should take 50 MB to encode in another. Certainly in any emulator written for real computers, it wouldn't take more than that.
But we're lacking the emulator. That's important because nobody knows how big or little that will be. The point that the biologist made boils down to saying that the emulator is an incredibly complex thing that has to encode an environment whose complexity is much, much more than that of the genome. So one flaw in that line of reasoning from Kurzweil is that we have no known upper limit on the size of the emulator itself. The biologist's argument basically comes down to, "The emulator itself needs to be much, much bigger than GENOME, and we have no idea how to write it."
(Note that I'm not arguing that Kurzweil is correct, but merely that your arguments against him were not correct.)
Yes. You are correctly observing that Omega is not really a constant - it is a class of constants. For machine A there is Omega_A. For machine B, Omega_B. That is why Chaitin lectures about Omega but only after several reminders that it's really "Omega_X for some specific machine X -- but I'm mostly just going to say Omega and let X be understood."
So, now, think that through with Kurzweil goggles on. In Kurzweil's world, a program of 50MB on one machine can't be 50TB on the next machine -- that's just silly, right? Well, if he were correct then, in general, Omega_A and Omega_B, for any machines A and B, would have to be somewhat close in value. We know that Omega_A and Omega_B don't have to be close (other than that they both come from the same (0,1) interval). By contradiction we conclude that we don't live in the world Kurzweil is describing.
Not so fast. As I pointed out, even if the emulator was just a ridiculously small 50 bytes, then Omega_A would tell us very little about Omega_B because only about 1 program in 10120 on machine B would be programs that are emulated from machine A. You know nothing about the halting probability of the rest, and so Omega_A says very little about Omega_B.
(Obviously that 50 bytes is ridiculously small. But in http://www.cs.auckland.ac.nz/~chaitin/lisp.html http://www.cs.auckland.ac.nz/~chaitin/lisp.html Chaitin has an interesting example of a Lisp variant that can run a theorem prover against itself with only 410 bytes of overhead. So with pairs of machines, you can get away with surprisingly little.)
- dasht 16y agoIf your emulator requires substantially different space to encode the raw description of the program than the original, then the emulator sucks. I can't try to help you any further. You have a conceptual bug in your understanding of the relevant math / CS. Last I'll say is that your emulator doesn't necessarily "suck" - it may be that it is the best that is theoretically possible and still result in exponential growth in emulated program size. And, you also don't seem to be following a relatively simple argument about Omega. It's interesting stuff and we started down this thread on an interesting foot... I only mean here to explicitly sign off and note that, in my opinion, you're just not getting a few basic things I'm not too sure how better to present to you (which is not to say I'm normally particularly good at explaining such things -- only that for whatever reason, in this case, it ain't working).
- btilly 16y agoI suggest that you come back and re-read the thread tomorrow. Hopefully you'll come to a different opinion. About the emulator, the length of the emulated program is the length of the emulator plus the length of the representation of the program. On standard machine architectures you can represent binary data directly with little overhead. (Somewhere you have to declare the length of the binary data, so there is some overhead.) If you're encoding binary data within a programming language you may have a constant factor of encoding overhead because of your need to avoid reserved characters, etc. This is typically a small constant factor. I'm aware of no practical examples where that overhead is exponential, or even super-linear. About Omega, I understand the argument that you're trying to make. Your argument is that if Omega_A and Omega_B are to vary, then some programs from A have to go to much longer programs on B. My point is that this is not true, all that is necessary is that the programs from A have to be lost in a much larger sea of valid programs in B. Given that the number of programs of length n varies exponentially in the size of n, there are enough programs that this will happen even if all programs in A go to programs that are just a fixed number of bytes larger in B. Therefore Omega_A tells you very little about Omega_B.
- dasht 16y agoOn standard machine architectures Yes, right there you are demonstrating a deep misunderstanding of what you are replying to or how it relates to Kurzweil's arguments. On Omega, you say: all that is necessary is that the programs from A have to be lost in a much larger sea of valid programs in B You left out that we're comparing sets of A and B programs of similar length -- the "sea" is not so large. Actually you kind of acknowledge this but then say bogus things about what it implies. You are confused or else just b.s.'ing on purpose. It's been fun. We're done, please.