Let us clarify the terminology. By Genetic Algorithm (GA), we mean a collection or population of potential solutions to a particular task, which evolves as time progresses according to some fitness function,. The function is synonymous with learning function from our previous formulation. It evaluates the quality of as a solution to the task. Specifically, if our task or program is a function of, then the fitness function is nothing more than

Note that the population is not only our input set but also our output set in the Equation 1. Furthermore, the mapping is nothing but a collection of mutation operations to update the at iteration to iteration. That is,

Some common mutation operations of genetic algorithms are [3] :

1) Reproduction: selecting individuals within a population and copying them without alteration into the new population.

2) Crossover: produces new offspring from elements of two other parents.

3) Mutation: one of the central concepts of genetic algorithms. Mutation perturbs the population or its constituents in some way. This includes altering the elements of the population directly, or changing their placement in the population in some way such as swapping their indices.

4) Editing: a manner in which more complicated functionality can be reduced to simpler algebraic rules.

5) Adding/Deleting: the ability to add a new element to a population or remove an existing element from the population.

6) Encapsulating: the process of creating a new element that represents an aggregate of functionality from one or more other elements in the population.

Some consideration should be given to the statement

from [1] . For this equation to make sense, not only must the algebraic operation “” be meaningfully defined, but the gradient operator implies that is differentiable. The gradient operation makes sense only if the domain of is a Banach space. In this context, we cannot make such a claim. Thus Equation (4) becomes

where. Observe that although the mathematical formulation is different, the intent still holds. The “” operator communicates the number of permutations proportional to.

Since the information is retained in the population, and only improved through evolutionary perturbations, we consider this an example of Passive Computational Intelligence, (PCI). This stands in contrast to Active Computational Intelligence (ACI), where we are updating the mapping itself. Any combination of the two methods can be considered a form of Hybrid Computational Intelligence (HCI).

Recall the entropic considerations from [1] , where we specified that Computational intelligence is a process that locally minimizes and globally maximizes entropy.

Since the population is the output set, it is the entropy of the population that must be minimized by the intelligence process. Equivalently, we can say that as the amount of iterations becomes sufficiently large, the difference between and becomes increasingly negligible. In other words, assuming the subtraction operation is meaningfully defined, we have

This makes sense, for we expect that as time increases, the fitness of our solution reaches an optimum, so that eventually there is no need to update. In other words, our population becomes more consistent over time.

Of course, the typical considerations regarding genetic algorithms such the necessity of avoiding local optima, the proper choice of a fitness function, the complexity of the algorithm itself, among others, still hold [3] .

As for global entropy considerations, we must consider the role of the population in its realization under its program. As mentioned before, the total entropy of a system can be written as:

where represent each respective source of entropy. In particular, under the considerations of this section, we have

where and represent the entropy due to the population itself and the entropy from the program, respectively. To calculate the entropy, we used the Renyi entropy of order, where and defined as

where is the probability associated with state.

Let us consider the discussions of the previous sections in terms of code that is executable in the Turing sense. We will apply the formulations we have considered thus far and make improvements to refine the theory in this light.

Recall that a Turing machine is a hypothetical device that manipulates symbols on a tape, called a Turing tape, according to a set of rules. Despite its simplicity, the Turing machine analogy can be used to describe certain aspects of modern computers [4] , and more [5] .

The Turing tape has some important characteristics. The tape contents, called the alphabet, encode a given table of rules. Using these rules the machine manipulates the tape. It can write and read to and from the tape, change the configuration, or state of the machine, and move the tape back and forth [6] .

Typically, the instructions on the Turing tape consist of at least one instruction that tells the machine to begin computation, or a START instruction, and one to cease computation, called a STOP or HALT instruction [6] . Other instructions might include MOVE, COPY, etc., or even instructions that encode no operation at all. Such instructions are commonly called NOOP’s (NO Operation). The total number of instructions depends on the situation and the application at hand, but for the purposes of this paper, we will consider only tape of finite length for which the instruction set is also finite and contains at least the START and STOP instructions. In fact, for our purposes, the minimum amount of opcodes a program needs to run, or to be executable, are the START and STOP instructions.

Now, consider the set of all instructions available to a particular. To be consistent with our notation thus far, we will denote this set as, where

From this set, a particular sequence of instructions can be formed. Although many synonymous terms abound for this sequence of instructions, including a code segment, executable, or tape, we will refer to it simply as the code. We consider the execution or implementation to be the execution of the code on the Turing machine, which produces could produce another code segment, and change the machine state. Expressed in notation:

where and represent the set of all code and machine states, respectively. For the majority of this paper, it is the code that is of primary concern, and thus we can omit the machine state to simplify the notation when this context is understood:

Our fitness function is a measure the efficaciousness of the implementation of our program by some predefined standard.

We are still free to think of the intelligence mapping as a perturbation mapping. The only difference is the physical interpretation of the term “population”. This case concerns machine code instructions. As with genetic algorithms, perturbing code may advance or impede the fitness of the program. In fact, it may even destroy the ability to execute at all, if one either the START or STOP operations are removed.

A final note should be made as to the entropic considerations of the Turing Machine. In this light, we must take into account all the workings of the machine and thus we may now express the entropy as

where is the entropy incurred by the Turing Machine, which includes its state.

We can apply set theoretic formalisms in the usual sense. For example, consider a code and an instruction,. Then the notation communicates the fact that is an instruction in. Further, set theoretic operations follow naturally. Let,. In the case of the union operation, we have

which is a set containing the two programs and. Similarly, with the intersection operation, we have

or the set of all contiguous code segments that are contained by both and. Note that this code segment need not be executable. Also, if it is of particular utility in the program it may be degenerate in that it may appear multiple times throughout the code.

For set inclusion, we say that

Proper containment evolves naturally if.

The differences between code and real numbers or sets in conventional mathematics make it at first difficult to form a distance metric on them. Still, some have been explored such as the Levenshtein distance [7] , Damerau-Levenshtein distance [8] , Hamming distance [9] , and the Jaro-Winkler distance [10] .

Given a metric, we can form an open ball [11] , or neighborhood centered at some code consisting of all programs such that for some real number,. In other words

We can utilize the developments above to relax the definition of set inclusion with respect to the metric,. Specifically, define

Of course, similar considerations can be extended to proper containment. Such code segments that lie suitably close to each other with respect to will be referred to as polymorphic with respect to.

Our discussion in Section 3.2 has many applications and is of great importance especially to society as of the past five years. We can draw examples in real estate, financial markets, and population growth. Indeed this mathematics may be used to identify sustainable growth, or bubbles, periods of extraordinary inflationary growth followed by abject collapse.

For example, consider the well-studied behavior exhibited in the growth of bacterial colonies. There is an initial lag phase as the RNA of the bacteria start to copy, followed by an explosion of exponential growth called the growth phase, followed by a brief period of stability before the bacteria exhaust their resources resulting in an expedient decay.

Thus far, we have been considering only predefined programs. But a well-known concept from nature concerns when external code is injected into a host program, or otherwise hijacks the computational resources of the system [12] . One key characteristic of viruses is their ability to proliferate. Consider ν such that

If the viral code, is executable, we will call the virus―executable. If the viral code also can reproduce, that is, we will call this quality―reproductive. Finally, it is often the case that viral code is not reproductive or executable. Its task is to merely copy or install some payload [13] , here denoted by. In this case,

Viral code most often is pernicious, though this is not necessarily the case. For example, up to 8% of the human genome derives from retroviruses [14] . To determine the nature of the effect of the virus, we look at the change in fitness before and after its influence.

The influence of viral code on program fitness falls into three categories. Consider, , and, ,. In other words, code in the presence of a virus, from the otherwise pristine. The three cases are, , and. These cases are of enough significance that they deserve their own nomenclature. We will refer to these cases as commensalistic, symbiotic, and parasitic, respectively, out of consistency with their counterparts from biological sciences.

One final case to be considered is when a program or multiple programs can contribute to produce aggregate programs of greater complexity. In such a case, the program, when executed, would not only alter machine state and produce code but will also contain a product code segment, and product code machine state,

Introduce the program

Of course, we could nest this process and define

with from 24 denoted as, we could write

where the superscript indicates the level of nesting of the program.

Just as we discussed programs producing multiple progeny, we can also let them produce multiple product code. We will denote each copy with a subscript. Thus the above becomes

To determine the total entropy, simply sum over all product code.

This time we see that the entropy of the code varies exponentially with product and copy code.

A major focus for future work is the application of this research to computational molecular biology. Hence, we chose to implement the instruction set that nature has chosen for genetics in the following experiments.

For the base instruction alphabet, we will choose that of RNA [15] . This instruction set is composed of the “bits” Adenine (A), Uracil (U), Guanine (G), and Thymine (T). Each instruction can be represented as three of these quaternary bits, for a total of 64 possible outcomes. We have chosen this quaternary codon formulation to be the basis of our tape.

In both experiments, the choice of operational codes, or opcodes, are taken directly from these 64 quaternary bit codons. The choice to represent an opcode by a particular codon is completely arbitrary. All codons appear with the same probability in experiment, with the exception of the STOP opcode, as we will see in Section 4.2.

We present two instructions sets, and two different experiments. In the first experiment, we determine how many iterations our genetic algorithm takes to produce code that is executable, and code that reproduces itself. In the second experiment, we compare the amount of reproductions of code with the total entropy incurred by the simulation.

For the first experiment we constructed a robust instruction set consisting of the following:

1) START (AAA): Commences program execution.

2) STOP (AUA, ATC, ATG): Halts program execution. Observe that there are three STOP codons, but only one START codon. This mirrors the amount of codons in RNA and DNA observed in nature [16] .

3) BUILD_FR (CUC): Copies to product code, starting from the next respective instruction to that which comes before the BUILD_TO (GCG) instruction.

4) COND (UUC, UUA, GAA): Sets an internal variable in the Turing machine state called a flag. A flag can be thought of as an internal Boolean variable. Every time one of the COND opcodes is encountered the sign of the flag is switched, that is COND = ¬COND.

5) IF (AAU): Only executes the following instruction if the COND flag has been set.

6) COPY_ALL (AAG): Copies the entire tape to progeny.

7) COPY_FR (CCC): Copies to progeny code (as in [Section reference]), starting from the next respective instruction to that which comes before the COPY_TO (GGG) instruction.

8) JUMP_FAR_FR, (CUU) and JUMP_NEAR_FR, (AGA): both require a JUMP_TO, (CAC, GUG) instruction. The JUMP family of instructions is designed to continue program execution at the index of the JUMP_TO instruction. The former will find the JUMP_TO address that is farthest away, while the JUMP_NEAR finds the closest JUMP_TO instructions. If there is no multiplicity in the JUMP_TO instruction, then JUMP_FAR_FR, (CUU) and JUMP_NEAR_FR will produce the same result.

9) REM_FR, (GCU) and REM_TO, (UAA): Removes all code in between these instructions.

Although the code of the previous section was robust, it was redundant. For example, the functionality of the code to copy itself to progeny should be a desirable trait of the code itself, not just an opcode that accomplishes the task in one step. Further, the remove operations can be handled via mutation operations (albeit far less efficiently) in the genetic algorithm itself.

Note that in Experiment 1, most operations have a partner or conjugate opcode. The necessity of conjugate pairs of instructions follows from the fact that two pieces of information are required to complete the instruction, as shown below:

[instruction]......[instruction dual].

We will call such instructions dual. By using the concept of addressing we can mitigate the necessity for a predefined conjugate opcode. Instead of conjugate opcodes, the instruction immediately following the dual can be thought of as an argument. The machine uses this address (unless the address is represents opcode) as a manner of locating the conjugate to the dual and thus reducing the instruction set. Specifically:

[instruction ][address]... ...[address].

Under these considerations (and omitting the ability to build to a product), we have need for only six instructions: START, STOP, IF, COND, COPY, and JUMP. The first four instructions are exactly the same as in Experiment 1. The COPY instruction concatenates section of the tape to progeny, and the JUMP instruction continues program execution at a specified address. These final two are conjugates, the duals of which are handled via the addressing method entailed above. Notice although the lexicon is different, they have the same functionality as their respective counterparts in the first instruction set.

The goal of the first instruction set was to produce code that was executable, and code that could reproduce. A GA perturbed the code randomly. That is, no fitness function was used in the perturbation of the code strings. Each epoch of the simulation terminated once an executable or reproducible code was discovered. For each experiment, a maximum of 1,000,000 computational iterations were allowed.

The results of the first experiment using the first instruction set are shown in Table 1. The results of the first experiment using the second instruction set are summarized in Table 2. Observe that the number iterations in the first instruction set was much less than that of the second, which is likely due to the disparity in robustness between the two. Also note how wildly the results vary especially in terms of the reproductive capabilities of the second instruction set as demonstrated by the large standard deviation in results.

Upon answering the basic questions like the amount of computational iterations necessary to produce executable and reproductive code, the next experiment focused on the total entropy incurred by a given code segment and its offspring. Here, recall that we are considering the entropy produced by not only a given tape, but its progeny as well. We will continue with the alphabets of Experiment 1 and 2, respectively.

We bounded the total computational iterations per experimental run at 1,000,000. The maximum progeny allowed was 50. Mutations were applied by the GA according to a fitness function that evaluated the quality of the code with respect to its Renyi Entropy (of order).

The results are summarized in Table 3. Observe that the entropy and the amount of reproductions appear to be correlated as demonstrated by the r-values in Table 3 and in the correlation maps in Figure 1. Note that some programs appear to have achieved reproductive qualities without substantially increasing entropy but the converse is not true.

Although the actual data summarized in Table 3 was one of the primary goals of this experiment, the operational characteristics of the code itself were also of interest. The graphics in Figure 2 represent some interesting code behaviors. In the graphs below, a number in the following represented each opcode in the following manner: START = 0, COPY = 1, JUMP = 2, IF = 3, COND = 4, STOP = 5. With these numeric values we can visualize program behavior graphically.

Although a myriad of behaviors were observed, in Figure 2 we have selected some graphs of the different behaviors. Of specific interest were the non-terminating programs. Each of these selections also exhibited reproductive capabilities. Observe that although towards the beginning of program execution, a variety of instructions were executed, eventually the programs under consideration converged to some sort of periodic behavior to which we will refer as asymptotic periodicity.

The graphs selected not only demonstrated asymptotic periodicity but also reproduced continuously in the sense that the progeny produced reached the maximum allowable threshold.