Not true! Worst case scenario, one machine can emulate the other machine, running that input. Therefore an upper bound on one machine can be used to derive an upper bound on the other. These upper bounds are not perfect, but they are indicative.
Indicative is good enough for the argument that Kurzweil is attempting. His argument has other flaws, but this is not one of them.
That is why, for example, when Chaitin lectures about Omega he is always mumbling "relative to some choice of turing machine" (at least initially, until it is then understood to apply throughout the talk).
Not so fast. Omega is the probability of a randomly chosen machine halting. Suppose that an upper bound on machine A predicted that for machine B within just 50 bytes of data. Then all of the programs of length n on machine A get translated on machine B to a list of programs that is 2400 times bigger, and the rest have unknown behavior. In this case Omega for machine A says very, very little about Omega for machine B.
Therefore "indicative" is very much not good enough for what Gregory Chaitin is talking about.
"If you wish to create a brain in 50 MB of code, you must first implement the universe"?
It is, of course, conceivable that the brain contains some kind of computational processes that can be implemented/emulated much more quickly on a biochemical substrate than in doped semiconductors — some kind of quantum computation or something. However, all the evidence we have at the moment points in the opposite direction, and there's no particular reason to believe that the universe is designed to give biochemical systems such an advantage.
The CPU may be physical, but software on it runs on the abstraction which is the CPU's instruction set. The underlying physical nature of the processor is irrelevant.
He was talking about having one machine emulate another - I was pointing out that that means your i7 emulating all of physics.
Very nice try. (I mean that sincerely.) However, you must also have a proof about the complexity of the emulation and the encoding of programs to emulate. Without that proof - which basically means you are no longer talking about two arbitrary machines but rather about two which are deeply related - the mere possibility of emulation tells you nothing other than that one machine is of equal or greater computational power than the other.
[Edit: in context - sure, our fancy big super computer from IBM can emulate the zygote (let's say) but.. what's that gonna take? Trillions of lines of code? 10 lines?]
And, maybe I need another cup of coffee but I am actually having trouble parsing the syntax of your comment about Omega.
If we're talking about Turing machines, all of the machines are of equal computational power, and are also able to emulate each other.
If we're talking about real machines, the take away is that moving from one machine to the other doesn't require much code, but does require that the other machine be powerful enough. Thus leading to Ray Kurzweil's argument that the real challenge is getting a powerful enough machine, and not in the amount of code needed to run on that machine. (He further argues that Moore's law will provide us with that machine.)
And, maybe I need another cup of coffee but I am actually having trouble parsing the syntax of your comment about Omega.
Basically I was saying that if you offer some facility to translate programs from machine A to machine B, only a very small portion of the programs on machine B will turn out to be programs that were translated from machine A. Therefore the probability of programs halting on machine A tells us nothing about what the majority of programs on machine B are likely to do, and therefore tells us very little about the probability of a random program on machine B halting.
Does that make more sense?
We aren't necessarily talking about Turing machines but let's suppose that we are. We're talking about machines powerful enough to compute anything that any Turing machine can compute. You are correct that any one of these machines can emulate any of the others.
What's relevant to Kurzweil's argument is two-fold:
If I tell you about Turing-class machine A and give you Turing-class machine B, we know right away that you can write an A emulator that runs on B. We know that because they are both Turing class. What we don't know is how big that emulator program is. It might take a trillion lines of code just to write the emulator.
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.
Kurzweil makes an argument analogous to "Hey, GENOME only takes 50MB on machine A. There's no way it takes 50TB on machine B. Information theory at work, man! Use your head!" Problem is, "information theory" says no such thing. Actually, it says "If that's all we've been told, hell it could easily take 50TB on machine B. It could take 5 bytes. Who knows? There's not enough said about machines A and B or the program GENOME to tell!"
Basically I was saying that if you offer some facility to translate programs from machine A to machine B, only a very small portion of the programs on machine B will turn out to be programs that were translated from machine A. Therefore the probability of programs halting on machine A tells us nothing about what the majority of programs on machine B are likely to do, and therefore tells us very little about the probability of a random program on machine B halting.
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.
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 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.)
The complexity of a Turing machine is a function of the number of states that it can encode, in programming languages we call that 'expressiveness'. You can write a smaller program in a language that is more expressive. A Turing machine that allows more states is going to require a shorter tape (fewer cells) to do its work but will be more complex.
The argument I think that Kurzweil makes with his 50 MB figure is that once you take out all the redundancy you've taken out the expressiveness factor. Whatever emulator you use to interpret that 50 MB you'll end up with some 3D structure (if you simulate the embryology properly) that will resemble a brain.
The part where the analogy goes wrong according to me is by postulating a machine that this stuff should run on. The 'emulator' is nothing but the endless repetition of ribosomes threading RNA in order to produce more polypeptide chains which then fold up in order to become proteins.
Your 'emulator' in this case is a physics program, and not even a very complicated one, albeit with an absolutely astronomical data set for any size organism.
In order to avoid having to deal with that data set we try to achieve a higher level model of what the brain does, instead of trying to model what it is.
But that does not change the fact that the principle of the emulator (a 'mere' matter of programming) and the code that governs the construction are what gives rise to the brain and through there to intelligence.
So the upper bound of the problem in terms of complexity is the 50 M + whatever you need in terms of physics to (theoretically) run the simulation of the single fertilized ovum from start to finish, or as much as you need to verify that you have indeed succeeded in your simulation goal.
It can't get more complex than that, even if the generated structure is orders of magnitude more complex at first glance than the input data + the program. Think of it as 'output'. Thought is not the output of that program. Thought is the state changes within the produced (or simulated) brain.
The organic soup and all the proteins arising from it are the nuts and bolts the machinery is made of. That doesn't mean that we can't make similar machinery without those particular nuts and bolts.
I hope that all makes sense.
For instance http://www.nature.com/nature/journal/v441/n7092/full/nature0... has an example of RNA-based inheritance that is not in the genome. Also http://en.wikipedia.org/wiki/Genomic_imprinting shows that what genes you have and what genes you express are two different stories entirely.
That said, the effort of transcribing the 50 MB of genomic information into the final program is simply not a problem. And if we wanted to transcribe a much larger genome, the additional effort for that is again bounded.
This is all, of course, ignoring the excellent point that one would never want to actually do this given how slow this emulator would have to be. If we create AI in the next few decades, I can guarantee that it won't be a physics emulation of a human brain.
When you argue that a simple (just a few rules of physics) emulator could, in principle, do the job -- quite right. Unfortunately for your point, Kurzweil is making a much, much stronger claim. For, surely, you agree that that physics emulation isn't going to result in a practical program in 20 years, yes?
The way you are using "upper bound of the problem in terms of complexity" there... I could use your same logic to argue that the design of a brain can be encoded in exactly 1 bit.
The design of a brain, by your logic, contains 1 bit of information. (In particular, that 50 MB of compressed genome data? I'll give you a better compression algorithm for this purpose and it will, indeed, compress a particular human genome down to 1 bit.)
Since all Turing complete machines are functionally equivalent I don't think it is quite that irrelevant.
if the brain can be simulated by any Turing machine at all it figures that a 2-d tape Turing machine can do the same thing.
The question then becomes how big is the total information content of both Turing machine + tape.
The rules of physics are Turing complete, we use them to build computers with and nature uses them to build the physical universe, including computers and brains.
Kurzweil is not making such a strong claim at all I think, he merely argues that there must be some upper boundary to the starting configuration from which you should be able to arrive at a working brain.
And much as I would like to I can't find fault with that other than that the embryotic development is chaotic in nature and that a very small change in input conditions can easily produce nothing of interest on the output side.
The conclusion that we can draw from that is that the brain (and in fact probably every cell in our bodies) must contain a great deal of machinery to make sure that the process stays on track and does not veer off in to chaos and unpredictable outcomes. For the most part, it works, most of the fetuses carried to term are able to think.
> For, surely, you agree that that physics emulation isn't going to result in a practical program in 20 years, yes?
Some people claim even shorter times than that (which I think is highly irresponsible):
http://www.dailymail.co.uk/health/article-1201724/Artificial...
Personally I would put the time required for such a project in the multiple decades, probably 50 years at a minimum, maybe much more assuming that it can be done and that there is no quantum component (as proposed by Penrose, rather weakly) to intelligence.
As for your 1 bit description, you are not taking in to account the information content of the guts of the compression algorithm, and you'd find that algo+compressed data would work out to a nearly constant amount of information.
That 50MB has been created in a way that the size of the algorithm required to compress it and decompress it is relatively small compared to the size of the data.
As soon as you start embedding codebooks inside your algorithm the size of the data will go down but the size of the algorithm goes up correspondingly. Also the algorithm loses its universal character, it's ability to encode multiple data sets with roughly equal characteristics in terms of information content in to roughly equally sized output.
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).
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.
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.
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.
In this case "similar" was "differs by a constant". Thanks to exponential growth, even if said constant is something small like 50 bytes, the pool of programs on machine B would be 2^400 times as big as the pool of programs on machine A. That's about a factor of 10^120.
If you think that a factor 2582249878086908589655919172003011874329705792829223512830659356540647622016841194629645353280137831435903171972747493376 difference is "not so large", then you've got a very different impression of what "large" means than most people do.
Anyways now I think we're going around in circles. Unless you make a point of some substance in your next reply, I'm not going to bother replying. And no, insults do not count as points.
Well, you know, part of the other half of the "source code" in the genome explains how to build a zygote. It doesn't explain how to build a universe, but there's no particular reason to believe that the universe is designed to make zygotes easy to build.
The encoding scheme isn't particularly problematic; it's a constant factor on the efficiency, and a small additive increment to the source code.
It is just there, in that last step, that Kurzweil invokes a fallacy. In general, if you have two different kinds of machines, and you want to program each to compute the same result -- upper bounds on the program size on machine tell you nothing about the the upper bounds on the other machine.
Right on, upper bounds on program size do not directly translate from one machine to another. So we can't set a hard bound, and we always need to speak about information content relative to a given machine - too few people have noticed this.
However, science doesn't give up when hard bounds prove impossible. There's always statistics to fall back on.
And statistically speaking, we can absolutely translate information content claims across machine boundaries if we're careful, as long as we have no reason to believe that the machine in question is somehow "special".
A priori, knowing nothing else about machines A or B, we would expect that if we observe an upper complexity bound on an algorithm relative to machine A, there's better than a 50/50 shot that the same upper complexity bound will also hold relative to machine B (it's greater than 50% because it's almost certain that our observation did not pick out the best theoretical upper complexity bound).
As good Bayesians, exactly how this all translates into a best estimate for the bound relative to machine B depends on a lot of stuff (all our prior distributions - in fact, in cases like this talking about upper bounds is silly, it's far better to talk about the distribution of upper bounds, but I digress).
But it's simply wrong not to adjust your complexity estimates relative to machine B in some manner based on an observation of machine A, unless you know something special about machine A that differentiates it from all machines in such a way that it's well-suited to express the algorithm under consideration.
So I ask you this: do you know a fact about "zygote machines" that makes them much better suited to constructing intelligence algorithms than most other machines? Do you have some reason to suspect that their dynamics are more likely to lead to intelligent computations than, for instance, normal computers?
Because otherwise, Kurzweil is a hell of a lot closer to the "right" estimate than you are.
(Edit) FWIW, I posted a more detailed argument elsewhere in this thread (http://news.ycombinator.com/item?id=1621053) that more carefully boils Myers' claim down to just about the same question I asked you.
So, we agree that Kurzweil's "information theory" snobbery is wrong. His real argument is "C'mon... look, the genome's small. Under a microscope the brain looks like it has many parts but very regularly arranged. How hard can it be? Trillions of lines? Please!"
That's not an information theory argument. That's a vague, hand-wave argument to an underspecified but compelling-sounding conclusion. "Reverse engineer the brain." "Build something similar." WTF could possibly happen that would prove him wrong? How exactly could Kurzweil's "predictions" here be falsified?
Put another way, if he changed his rebuttal to Meyers to be "I made no substantive argument or claim. Myers responded as if I had. Therefore Myers has erred." -- I could accept that. It then does raise the question of why Kurzweil was not more explicit about making no substantive argument or claim but that's a separate matter. It's moot because Kurzweil isn't making that rebuttal.
To your statistical argument, which is quite interesting...
I think the meat of your case is here:
So I ask you this: do you know a fact about "zygote machines" that makes them much better suited to constructing intelligence algorithms than most other machines?
Rather than quibble over what "intelligence algorithms" mean I am going to pretend you said "human brains or things very similar to such".
The answer is "Yes, I know quite a few facts that strongly support the hypothesis that human zygotes are, among the machine-like entities in the world, uniquely well suited to building human brains -- and very difficult to replace by any substantially different kind of machine."
At this point I would basically just repeat Myers' argument, perhaps adding in more specific but randomly selected details.
If you want to rescue Kurzweil by leaving the abstract "information theory" b.s. he offered and looking at the specifics -- then we've gone full circle. Kurzweil doesn't understand the brain.
Now there is an exception to all this. A different way of looking at it. I think that if you scrape off layers of hype and clouds of obfuscation, Kurzweil will consider himself to be proved correct if, in say 20 years, -- and just for example:
You can buy a box that has at least stereo video inputs and that, using an artificial neural net, does exquisitely accurate facial recognition. Or that can look at visualization of architectural CAD drawings -- millions of variations per hour -- and select a few with a high percentage chance of being pleasing to most people. Or that, in combination with the tactile-feedback neural net, can manipulate agonizingly capable microscopic tools for very delicate surgeries or for building nanotech or ...
I think it's f'ing obvious that (unless civilization fails - not out of the question) we have all that in 20 years and maybe sooner. I think that was f'ing obvious about 30 years ago, and to some, pretty clear even before that.
I don't think those devices count, in any reasonable way, as "reverse engineering the brain" but I guess they count as "reverse engineering a few select aspects of useful computational tricks that brains do in real time, quite efficiently".
I don't think those inevitable advances offer much support to Kurzweil's "exponential" technology - they are straight up incremental, boringly predictable advances. I don't think they're a real challenge to ordinary human predictive powers: we've seen this stuff coming for decades. Don't even get me started on how "the singularity" is dangerous, meaningless, new-age clap-trap.
But, Kurzweil dresses up such banal observations to make it sound like, any day now, massive machine mega-brains will take over the world. Hopefully they'll love us and kindly upload our consciousness and.....
So it is, to repeat my original point, with some delight that I take on Kurzweil's "information theory" sniping at Meyers.
I think this pretty well illuminates the source of our "disagreement" (and resolves it), apart from this we're on the same page about the details, I think.
To me, there's a very big difference between what I would qualify as successful AGI (artificial general intelligence) and "human brains or things very similar to such", in that successful AGI could work very differently from a human brain (and IMO, probably will, if/when we ever get there) and still qualify as a bulls-eye hit.
Taking that as our (relatively wide) target, I don't think protein folding and all that fun stuff adds much information.
However, if our target is narrower, simulating a brain or something close to that, then I agree, the details of biology do shift the estimates considerably.
Looking over one of Kurzweil's actual statements:
It is true that the information in the genome goes through a complex route to create a brain, but the information in the genome constrains the amount of information in the brain prior to the brain’s interaction with its environment.
...it appears that you're right, he's talking more about creating an actual brain than creating some algorithm that solves the same problem (possibly in a different way). Mea culpa: I unwittingly altered his argument before defending it, so I've really been arguing about what he should have said rather than what he actually said.
Not all is lost, though: the fact that his claim can be fixed up so that it's got some actual teeth is still worth noting, and I think Myers criticism is a bit too broad (he essentially claims that you can't say anything useful based on the length of a DNA string, which is not true). I think the real lesson here is that if we want to use DNA length as a proxy for information content, we need to be exquisitely careful about what "information content" means relative to the systems we're discussing, and nail down exactly what systems those are and how we're defining our problem.
It may not add information at all, just as the physical structure of a transistor does not add much information to what a computer can or can not do. In a computer the 'smarts' however are not even embedded in the connections (like what's being posited is the case for the brain), but in the software. Software is state, and software is, to all intents an purposes as good as invisible, unless you find a way to do a dump of what sits inside a running brain.
And then you still have to reverse engineer the computer that that software was running on in order to be able to resume.
Myers DNA length argument is easily disproved by reducing to extremes, if DNA length would be an irrelevant item then you could encode a brain with an arbitrarily short length of DNA, the fact that it takes up as much as it does proves that it is from an information processing perspective not a simple structure. So length is relevant, maybe not the whole story, but definitely a factor.
Part of me wonders if we are going to find one day that the genome does not just contain proteins but also contains the 'boot strap' state required to power up a brain after its initial configuration is complete.
That's highly speculative but there is a lot more data in the genome than what seems to be used and nature never was that inefficient, even if there are many things that could be improved on with the function oriented hindsight that we have.
But the methods are as far as I understand well understood and it is more of an optimization problem than something unsolved.
Edit: or did you mean 'solved' in an analytical way?
EDIT: I endorse all of ewjordan's other replies too. There's no need for me here.
The simple fact of not having seen something is totally baseless as evidence to whether or not that something is possible.
Question: this does mean he can say something like "there exists at least one machine that can do it in 50MB" which gives us a signpost for the size of the problem, no? Why does it follow that any other machine would have to take the same approach to hit the same order of magnitude?
As for the last, it may be obvious to you, but I don't think it's obvious to everyone. Part of Kurzweil's mission is getting that message out to more people. The controversial part is that once we have those efficient neural networks, we're that much closer to making devices that approximate, at least, what we experience as "thinking." I don't know that anyone here can say for sure whether he's right or wrong -- we'll have to wait 30 years and see.
If not, then the size of the genome is irrelevant -- a nontrivial amount of information could potentially be being passed on by the gestation process itself, and that may indeed involve trillions of lines of code.
If you assuming that there exist machines with properties which cannot in any way, shape or form be emulated by digital computers, then you are declaring that the Church-Turing Thesis is a priori false.
But the complexity of the zygote derives mostly from that 50MB of genome data, so Kurzweil's main point remains the same: the genome gives a rough estimate as to the maximum complexity of the human brain, which in this case includes the mechanism needed to build the brain.
Wait.. does it? I'm rather tempted to think you are right, but here is my worry. I know that the data in the genome encodes proteins that are able to function through their interactions and feed-backs yadda yadda, so as to perform the following tasks: growing a cell, splitting a cell, altering cell structure/function. But notice that "creating a cell" wasn't on that list.
The genome needs some minimally functional, pre-existing cell to be working in. That is something that the genome probably doesn't have the needed complexity to build "from scratch" as it were; it never has to do that job. So that pre-existing structure has some complexity, right? How does that compare to the 50MB?
Uh.. no. There's at least 650 Million years worth of initializing the process memory and other threads into which the zygote is fork / exec'ed.
What "state" that makes sense of the human genome is stored in, say, symbiotic bacteria that we host?
Does that make sense to you?
In fairness, I'll also explain why Kurzweil's main thesis appears to be unassailably correct - albeit mainly because, in the end, he makes only quite weak and uncontroversial claims.
(For biological criticisms of Kurzweil, see "knowtheory"'s comment.)
Kurzweil seeks to establish an upper bound on a quantity he calls "the amount of information in the brain prior to the brain’s interaction with its environment."
He is not terribly precise about how that quantity is to be defined. He does tell us that his upper bound will show that the "design" of the brain isn't very complicated and that it will not require "trillions of lines of code to create a comparable system".
To establish his "amount of information" upper bound he looks at the number of "bits" in a complete human genome. A human genome contains about three billion base pairs. Each base pair position can have one of four possible values (e.g., contains two bits of information). Thus he comes up 6 billion bits overall, around 715 Megabytes (he says 800), and he points out that genomes are far from random and asserts that the whole thing can be compressed down to, perhaps, 50 Megabytes.
Apparently we are to believe that the amount of "code" needed to build a system "comparable" to the brain can not possibly be "trillions of lines" because the genome does it in less than 50 megabytes.
A zygote, in other words is a machine. It runs the code in the DNA. The code tells how to build a brain. Our simulator will be some kind of programmable system. We'll supply it with code. The code will tell it how to make or simulate a brain-like thing. If a zygote does it with a mere 50MB of code, our machine will as well.
It is just there, in that last step, that Kurzweil invokes a fallacy. In general, if you have two different kinds of machines, and you want to program each to compute the same result -- upper bounds on the program size on machine tell you nothing about the the upper bounds on the other machine.
That is why, for example, when Chaitin lectures about Omega he is always mumbling "relative to some choice of turing machine" (at least initially, until it is then understood to apply throughout the talk).
If all you know is that the zygote machine and our simulator machine are two machines - program size on the zygote tells you nothing about program size on the simulator.
There is, in other words, no abstract quantity that describes "the complexity of the design of the brain". Information theory does not recognize any such concept. There is no such thing as the irreducible complexity of a program other than relative to a particular machine.
The upper bound from the zygote could actually translate to our simulation machine if we agree that the simulator will operate on principles essentially the same as the zygote. Alas, Kurzweil says the opposite: "I did not present studying the genome as even part of the strategy for reverse-engineering the brain. [....] It is not a proposed strategy for accomplishing reverse-engineering [....]"
Kurzweil has to give up either the relevancy of the size of the genome, or his denial that we'll build a machine that operates on similar principles to a zygote (or on principles that can be proved computationally similar to a zygote). Either way, he should not be looking down at Myers' understanding of information theory.
All of that said, if you strip out his hype his only substantial claims seem to be that we'll build hardware that can run neural network software very efficiently (perhaps in real time for brain-scale networks) and that we'll get clues about useful network topologies from looking at brains.
That, my friends, is a perfect message for a "futurist" to deliver to a dazzled audience because, well, to many of us it is what you call "very old, somewhat boringly obvious news".