This is an old philosophical question, and I'm going to try tackling it from a computer science standpoint. So here is my model. Let's just have programs in some generic programming language, so the program itself is a string of text. All programs in this language also output some single string of text. Because both the program and output are the same data format, a program could potentially output it's own text. Such a program is called a quine.
If a program only consists of procedural commands and no control commands (so it performs the same operations in the same sequence regardless of the state of things), then it's impossible for a program to create any non-trivial quine (one which consist of commands which just print themselves or some variation on that trick, and that's just a lame tautology avoiding the argument). This is because using just procedural commands that are actually versatile it takes more characters to describe how to create itself than it does to just be itself as there is generally takes several characters to output a single one, so it's impossible with any finite string as it cannot have more characters than itself. The string output model for this seems rather silly as with only procedural commands being utilized all the program can actually do is a combination of absolutely nothing, defining variables that can't actually be used for anything so more absolutely nothing, and outputting with themselves. So it makes sense to just make a programming language which just outputs as it's only command...but then that's basically just the trivial quines. So let's slightly change out definition so instead of being abstract strings, it consists of symbols engraved in stone, and the procedural commands consist of directions for moving a stylus that engraves in stone. It would pretty obviously take multiple symbols to engrave a single one, and thus the previous statement holds. This second model also makes since in the context of physical reality. This is the basis for many philosophies about creation, the idea that creators must strictly be more complex than their creations, unless there is a creator of infinite complexity like God.
However,our understanding of physical reality as it appears that when something affects something else, it is also affected by said thing. This leads to the introduction of control commands, which instead of outputting something specific either output something based on some variable or input, or it changes the order in which procedure commands are run. Ultimately, any program using control commands is equivalent to a procedural program for a given input, as only the output matters, and each segment of output corresponds with a procedural command. However, the earlier restriction no longer applies as the original program is typically much shorter than the procedural version as a variable can represent several symbols using a single, and changing the order of commands makes it so that a command which is only written once can be executed multiple times. Not only is it now theoretically possible, but it's been done countless times. And hey, life reproduces, so clearly stuff can self-replicate in our world as well. And when it's possible to make a quine, making a more complex version is trivial, just change one symbol so it prints two copies of itself rather than one. Problem solved...
...except it isn't, as the question remains if a program twice as long is actually anymore more complex? Is the complexity of a string the same as it's length? Probably not, as one way of defining complexity is how easy it is to define something, otherwise it's just trivial that something could create something more complex than itself: a single character being repeated for number of times can typically be outputted by a shorter program (we'll use this example: SPE5 -> EEEEE), but it typically takes a longer program to be able to output THAT program (eg. SPSPPPEP5 -> SPE5), so should the program really be considered simpler than the output? So should the complexity be defined by the length of the shortest program the outputs a program, rather than by it's own length? But by that definition, even most short programs would be twice as complex as their length, and that doesn't seem right either. This is especially true considering that quins would always be less or equal complex than their length, so despite conceptually being more complex, they'd be assigned a lower complexity than most other programs their length. So maybe we can definite it as it's length OR the length of the program that generated it, whatever is smallest. This means that our double quine probably won't actually output anything more complex than themselves, as typically it's own complexity will be it's length by the first definition, while it's output would be the same value by the second. It's still possible however the double quine's output to be generated by, if it can be generated by a simpler program itself. But now basically all we did was deflect the complexity problem, as what basis is there to saying that the program the generates the double quine is the same complexity of the double quine, but the program it generates is more complex? Even if the double quine is more complex than it's generating program, than we come to the same question with the program that generated that, until by infinite descent we're sure to arrive at a deflection case. We could redefine complexity of a program as it's length or the COMPLEXITY of the program that generated it in order to remove an arbitrarily deflection case. But with this definition, the output would obviously never be of a greater complexity as if it would otherwise be larger, so it's really just begging the question. We could define it so it's complexity of the program that generated it + 1, but that automatically assumes something generated by something will be more complex than it. This method clearly isn't going to get us any clear answers as it can simply be defined to answer the question anyway you want it.
So let's try a different approach. Let's instead view programs and their output as natural numbers rather than strings, it's just a simple encryption. Now the entire scheme of the program can just be thought of a infinite sequence, or a function on natural numbers. The number could arbitrarily be defined as the complexity and then their obviously would programs that create more complex programs...except this is really just another phrasing of the previous problem, as the encryption causes the number to be larger if the string is longer. We need to find a fundamentally different way to define complexity. I'll do it as information. The encryption acts as a basic cap on the amount of information in a program, but a number is still just a number. You don't know anything about the effect of a program just from the number that is encrypted. So let's define the information about a program as the association of the program with it's output, an ordered pair (a,b). But this still doesn't tell us everything about it, as the output of the program is still represented as an encrypted number, when it is also actually a program. So we can replace it with an iterated ordered pair, (a,(b,c)), which is equivalent to an ordered triple (a,b,c). The same problem will apply ad infinitum, until the program is no longer really described by a number, but by an infinite sequence. Regardless of exactly how you define the information, it's clear the output of the program can't have MORE information as it's the same sequence, only with the first data point deleted. So that's my conclusion, it is technically impossible.
However, there are still some more technicalities to sort out. The actual programs still only have a finite amount of information in them, but the infinite sequence sometimes represents an infinite amount of information. This information doesn't come from the program, it comes from the scheme, which was previously represented by an infinite sequence and thus could easily have infinite information. You can kinda cheat with this problem by making an arbitrarily complex environment, but the information is all their in the environment. Some theologians argued that evolution occurred as the result of God designing the universe so that things would evolve. So the fundamental program is just a metaphysical one, something cannot have an infinite amount of information in it and cannot create something of greater complexity on it's own, but only through it's interactions with a universe which requires an infinite amount of information to perfectly define. And before you try to argue it a universe can actually be described in a finite amount of information, no, it really can't. First it needs to be determined if the universe is natural or supernatural. If it's supernatural, than any attempt at quantizing it's nature is futile, so it effectively has infinite information. If it's natural, then only the metaphysical and materialistic cases need to be tackled. In the metaphysical case, the laws of the universe could be described in words, but the words are only understood by people who speak the language, and thus just like with the supernatural case, still represents a failure to quantify anything, and there are infinite possibilities for how such world could be defined, it's still infinite information. With the materialist approach, the laws don't actually exist, they are just explanations people give for patterns they find in the jumble of matter. To define the universe is to explicitly define how each arrangement of matter relates to the subsequent arrangement of matter...which is equivalent to the previously mentioned sequence. If only a finite number of possible arrangements are possible in the universe are possible, than technically only a finite sequence is required, but it still contains all the information.
Well, at least this sums of the problem for deterministic universes. For non-deterministic ones, the computer science model doesn't work so well, and things get weird. First, if system is mostly determinist, but has some random parts, than it can be argued the random parts add more information into the system over time based on how exactly they roll. With this model it could be argued that program could output a more complex program with...but there still needs to be a scheme for how randomness works, so it's really more of the same thing. The other issue is that fact it's OBVIOUS that people can reproduce biologically and create people of equal complexity, so that clearly isn't a solution to the actual philosophical problem. One way of redefining it is a person could create another person by choice, and only through his own choices based on his own knowledge. This can't be modeled with the computer, as choice implies non-determinism, and you can't create something that is non-deterministic using a deterministic system. I got no answer to this.
01 Sep 2016, 1:26 am
Anyway, one question for if something can comprehend itself, is whether or not something needs to stand every aspect of it's current state. For example, say you know a dog is a mammal. But do you know that you know that the dog is a mammal? And do you know that you that you know...? These is related to the CS concept of pointers, and the logical idea of common knowledge. 
