Let's take the genome (DNA) as a program + data, and the phenome (the organism) as an output (and assume the mother is in adequate health, and development proceeds normally.) Then the number of different possible phenomes is limited to the number of different genomes (it could be fewer, if there are non-significant regions of the genome, because then more than one genomes could produce the same phenome. That is, the function G->P is not necessarily injective.)
While this doesn't directly describe the complexity of a phenome, the argument is that the complexity of a thing is no greater than the means of defining it, and that any additional complexity in the resulting thing must contain redundancies (perhaps very hidden) that can be eliminated. A simple case is a program to print hello 1000 times. The program is short, and though the output is long, it contains redundancies. What about from chaotic systems and fractals, or 'normal' numbers like pi, where great complexity arises from simple rules? The argument is that this is merely apparent complexity, and in reality contains great redundancy. Big output changes from small input changes doesn't disprove this; consider changing 1000 to 2000 in the above. While a particular sequence of pi digits, or a particular fractal frame, might seem complex, there is also the input to consider of the specification of that part (eg which digits) also takes information.
---
Here's the theoretical flaw: considering a genome as a program, what if the entire program isn't really listed in the genome, but it calls library functions? Obviously, it becomes much shorter, but we're not measuring the library code, so it's cheating. Or, what if the program is written in a highlevel language rather than a lowlevel one (like assembly) - this is equivalent, if you consider the syntax of the language as causing in function calls. Clearly, we still have the same mapping of program->results, and the number of different results is still limited, but those results are much more complex than the program; they programs don't represent the complexity of the output.
How does this apply to the development of a phenome from a genome? Does anything add information, like standard libraries? One might say that the mother is like a standard library - but little information seems to be input in this way (consider development of a chicken egg); and fundamentally, the mother is also a phenome that can be specified by the very genome in question: it's self-hosting.
Does protein folding add information? It is very complex, but is that just how it operates (the way that the implementation runs), or does it also add information to the output? Remarks on this seem to say only that it's complex and unknown and therefore hard to simulate. I'm talking about whether the complexity of action adds information to the output. If so, how much complexity? Is it significant, comparable to a standard library, or is it more like a trivial macro?
I don't know how much information is added to the phenome by protein folding; this is a question for the biologists. I think addressing it squaring in these terms would defuse much of the emotion in the discussion. But I'll guess:
If we assume protein folding is dictated by quite a long sequence (ie. it's not a context of one, like G->down, U->up, A->left, C->right, but a function of say 100s of bases -- and of course the fold direction is not always 90 degrees), then there is scope for an (almost) arbitrarily complex function, from sequence->fold. The complexity is limited by the input (number of bases involved) and output (the actual fold).
If we then assume that the shape of the protein is the crucial thing for its interaction with raw materials and other proteins (eg. as an enzyme), then complexity of protein folding does directly translate into complexity of results - even at this, the finest-grain level of operation.
Although protein folding potentially adds complexity, I find it hard to imagine that it would add information comparable to a standard library, such as, say 50 bases specifying an eye or a liver (which a standard library might do, like Python's SimpleHttpServer). That would be miraculous, if the laws of physics were so favourable to the particular needs of organisms (like a programming language that is customized to a particular application, as modern libraries contain code for TCP/IP and HTTP.) I find it easy to believe that it's more like the variation in syntax between (say) lisp, java and assembly.
So, I don't think protein folding adds much complexity to the result; it's more like a general purpose programming language than a set of specialized library functions (I think this question is the crucial issue in the debate.)
---
To conclude, I think the complexity of the genome does estimate the complexity of the phenome: I agree with Kurzeil that the brain is (roughly) as complex as the sections of the genome necessary for its development.