Assembly Theory of Binary Messages

Abstract

Using assembly theory, we investigate the assembly pathways of binary strings (bitstrings) of length N formed by joining bits present in the assembly pool and the bitstrings that entered the pool as a result of previous joining operations. We show that the bitstring assembly index is bounded from below by the shortest addition chain for N, and we conjecture about the form of the upper bound. We define the degree of causation for the minimum assembly index and show that, for certain N values, it has regularities that can be used to determine the length of the shortest addition chain for N. We show that a bitstring with the smallest assembly index for N can be assembled via a binary program of a length equal to this index if the length of this bitstring is expressible as a product of Fibonacci numbers. Knowing that the problem of determining the assembly index is at least NP-complete, we conjecture that this problem is NP-complete, while the problem of creating the bitstring so that it would have a predetermined largest assembly index is NP-hard. The proof of this conjecture would imply P ≠ NP since every computable problem and every computable solution can be encoded as a finite bitstring. The lower bound on the bitstring assembly index implies a creative path and an optimization path of the evolution of information, where only the latter is available to Turing machines (artificial intelligence). Furthermore, the upper bound hints at the role of dissipative structures and collective, in particular human, intelligence in this evolution.

1. Introduction

Assembly theory (AT) [1,2,3,4,5,6,7] provides a distinctive complexity measure superior to established complexity measures used in information theory, such as Shannon entropy or Kolmogorov complexity [1,5]. AT does not alter the fundamental laws of physics [6]. Instead, it redefines objects on which these laws operate. In AT, objects are not considered sets of point particles (as in most physics) but instead are defined via the histories of their formation (assembly pathways) as an intrinsic property where, in general, there are multiple assembly pathways to create a given object.

AT explains and quantifies selection and evolution, capturing the amount of memory necessary to produce a given object [6] (this memory is the object [8]). This is because, the more complex a given object, the less likely an identical copy can be observed without the selection of some information-driven mechanism that generated that object. Formalizing assembly pathways as sequences of joining operations, AT begins with basic units (such as chemical bonds) and ends with a final object. This conceptual shift captures evidence of selection in objects [1,2,6].

The assembly index of an object corresponds to the smallest number of steps required to assemble this object, and—in general—it increases with the object’s size but decreases with symmetry, so large objects with repeating substructures may have a smaller assembly index than smaller objects with greater heterogeneity [1]. The copy number specifies the observed number of copies of an object. Only these two quantities describe the evolutionary concept of selection by showing how many alternatives were excluded to assemble a given object [6,8].

AT has been experimentally confirmed in the case of molecules and has been probed directly via experiments with high accuracy by means of spectroscopy techniques, including mass spectroscopy, IR, and NMR spectroscopy [6,7]. It is a versatile concept with applications in various domains. Beyond its application in the fields of biology and chemistry [7], its adaptability to different data structures, such as text, graphs, groups, music notations, image files, compression algorithms, human languages, memes, etc., showcases its potential in diverse fields [2].

In this study, we investigated the assembly pathways of binary strings (bitstrings) by joining individual bits present in the assembly pool and bitstrings that entered the pool as a result of previous joining operations.

A bit is the smallest amount and the quantum of information. Perceivable information about any object can be encoded via a bitstring [9,10], but this does not imply that a bitstring defines an object. Information that defines a chemical compound, a virus, a computer program, etc. can be encoded via a bitstring. However, a dissipative structure [11], such as a living biological cell (or its conglomerate, such as a human, for example) cannot be represented with a bitstring (even if its genome can). This information can only be perceived (so this is not object-defining information). Therefore, we use emphasis for the object in this paper since this term, understood as a collection of matter, is a misnomer in that it neglects (quantum) nonlocality [12]. Nonlocality is independent of the entanglement among particles [13], as well as quantum contextuality [14], and it increases as the number of particles [15] grows [16,17]. Furthermore, the ugly duckling theorem [9,10] asserts that every two objects we perceive are equally similar (or equally dissimilar).

Furthermore, a bitstring as such is neither dissipative nor creative. Its assembly process is what can be dissipative or creative. The perceivable universe is not big enough to contain the future; it is deterministic when going back in time and non-deterministic when going forward in time [18]. But we know  [2,11,19,20,21,22,23,24,25,26,27,28,29] that it has evolved to the present since the Big Bang. Evolution is about assembling a novel structure of information and optimizing its assembly process until it reaches the assembly index. Once the new information is assembled (via a dissipative structure operating far from thermodynamic equilibrium, including humans), it enters the realm of the 2nd law of thermodynamics, and nature seeks how to optimize its assembly pathway.

At first, the newly assembled structure of information is discovered via groping [19], and its assembly pathway does not attain its most economical or efficient form at once. For a certain period of time, its evolution gropes about within itself. The try-out follows the try-out, not being finally adopted. Then, finally, perfection comes within sight, and from that moment, the rhythm of change slows down [19]. The new information, having reached the limit of its potentialities, enters the phase of conquest. Stronger now than its less-perfected neighbours, the new information multiplies and consolidates. When the assembly index is reached, new information attains equilibrium, and its evolution terminates. It becomes stable.

Thanks to its characteristic additive power, living matter (unlike the matter of the physicists) finds itself ”ballasted” with complications and instability. It falls, or rather rises, towards forms that are more and more improbable. Without orthogenesis life would only have spread; with it there is an ascent of life that is invincible.

[19]

The paper is structured as follows. Section 2 introduces the basic concepts and definitions used in the paper. Section 3 shows that the bitstring assembly index is bounded from below and provides the form of this bound. Section 4 defines the degree of causation for the smallest assembly-index bitstrings. Section 5 shows that the bitstring assembly index is bounded from above, and we conjecture about the exact form of this bound. Section 6 introduces the concept of a binary assembling program and shows that, in general, the trivial assembling program assembles the smallest assembly index bitstrings. Section 7 discusses and concludes the findings of this study.

2. Preliminaries

For K subunits of an object, O, the assembly index, $a_O$, of this object is bounded [1] from below via

$$min\left(a_O\right) = {log}_2\left(K\right),$$

(1)

and from above via

$$max\left(a_O\right) = K-1.$$

(2)

The lower bound (1) represents the fact that the simplest way to increase the size of a subunit in a pathway is to take the largest subunit assembled so far and join it to itself [1], and in the case of the upper bound (2), subunits must be distinct so that they cannot be reused from the pool, decreasing the index.

Here, we consider bitstrings $C_k^{\left(N\right)}$ containing bits $\{1,0\}$, with $N_0$ zeros and $N_1$ ones, having a length of $N = N_0+N_1$. $N_1$ is called the binary Hamming weight or the bit summation of a bitstring. Bitstrings are our basic AT objects [2], and we consider the process of their formation within the AT framework. Where the bit value can be either 1 or 0, we write $\ast = \{1,0\}$, with $\ast$ being the same within the bitstring $C_k^{\left(N\right)}$. If we allow for the second possibility that can be the same as or different from $\ast$, we write $★ = \{1,0\}$. Thus, $C_k^{\left(2\right)} = [\ast ★]$, for example, is a placeholder for all four 2-bit strings.

In general, we consider bitstrings, $C_k^{\left(N\right)}$, to be messages transmitted through a communication channel between a source and a receiver, similar to the Claude Shannon approach [30] used in the derivation of binary information entropy

$$H\left(C_k^{\left(N\right)}\right) = -p_0{log}_2\left(p_0\right)-p_1{log}_2\left(p_1\right),$$

(3)

where

$$p_0 = \frac{N_0}{N}\mathrm{and}{p}_1 = \frac{N_1}{N}$$

(4)

are the ratios of occurrences of zeros and ones within the bitstring $C_k^{\left(N\right)}$, and the unit of entropy (3) is a bit.

Definition 1.

A bitstring assembly index, $a^{\left(N\right)}$, is the smallest number of steps, s, required to assemble a bitstring, $C_k^{\left(N\right)}$, of length N by joining two distinct bits contained in the initial assembly pool, $P = \{1,0\}$, and bitstrings assembled in previous steps that were added to the assembly pool. Therefore, the assembly index, $a^{\left(N\right)}\left(C_k\right)$, is a function of the bitstring $C_k^{\left(N\right)}$.

For example, the 8-bit string

$$C_k^{\left(8\right)} = \left[01010101\right]$$

(5)

can be assembled in at most seven steps:

1.

Join 0 with 1 to form $C_k^{\left(2\right)} = \left[01\right]$, adding $\left[01\right]$ to $P = \{1,0,01\}$;

2.

Join $C_k^{\left(2\right)} = \left[01\right]$ with 0 to form $C_k^{\left(3\right)} = \left[010\right]$, adding $\left[010\right]$ to $P = \{1,0,01,010\}$;

3.

…

7.

Join $C_k^{\left(7\right)} = \left[0101010\right]$ with 1 to form $C_k^{\left(8\right)} = \left[01010101\right]$

(i.e., not using the assembly pool P), in six, five, or four steps:

• Join 0 with 1 to form $C_k^{\left(2\right)} = \left[01\right]$, adding $\left[01\right]$ to P;
• Join $C_k^{\left(2\right)} = \left[01\right]$ with $\left[01\right]$ taken from P to form $C_k^{\left(4\right)} = \left[0101\right]$, adding $\left[0101\right]$ to P;
• Join $C_k^{\left(4\right)} = \left[0101\right]$ with $\left[01\right]$ taken from P to form $C_k^{\left(6\right)} = \left[010101\right]$, adding $\left[010101\right]$ to P;
• Join $C_k^{\left(6\right)} = \left[010101\right]$ with $\left[01\right]$ taken from P to form $C_k^{\left(8\right)} = \left[01010101\right]$

or at least three steps:

• Join 0 with 1 to form $C_k^{\left(2\right)} = \left[01\right]$, adding $\left[01\right]$ to P;
• Join $C_k^{\left(2\right)} = \left[01\right]$ with $\left[01\right]$ taken from P to form $C_k^{\left(4\right)} = \left[0101\right]$, adding $\left[0101\right]$ to P;
• Join $C_k^{\left(4\right)} = \left[0101\right]$ with $\left[0101\right]$ taken from P to form $C_k^{\left(8\right)} = \left[01010101\right]$.

Meanwhile, the 8-bit string

$$C_l^{\left(8\right)} = \left[00010111\right]$$

(6)

can be assembled in at least six steps:

• Join 0 with 1 to form $C_l^{\left(2\right)} = \left[01\right]$, adding $\left[01\right]$ to P;
• Join $C_l^{\left(2\right)} = \left[01\right]$ with $\left[01\right]$ taken from P to form $C_l^{\left(4\right)} = \left[0101\right]$, adding $\left[0101\right]$ to P;
• Join 0 with 0 adding $\left[00\right]$ to P;
• Join $C_l^{\left(4\right)} = \left[0101\right]$ with $\left[00\right]$ taken from P to form $C_l^{\left(6\right)} = \left[000101\right]$, adding $\left[000101\right]$ to P;
• Join $C_l^{\left(6\right)} = \left[000101\right]$ with 1 to form $C_l^{\left(7\right)} = \left[0001011\right]$, adding $\left[0001011\right]$ to P;
• Join $C_l^{\left(7\right)} = \left[0001011\right]$ with 1 to form $C_l^{\left(8\right)} = \left[00010111\right]$

as only the doublet $\left[01\right]$ can be reused from the pool. Therefore, bitstrings (5) and (6), despite having the same length, $N = 8$, Hamming weight, $N_1 = 4$, and Shannon entropy (3), have respective assembly indices $a^{\left(8\right)}\left(C_k\right) = 3$ and $a^{\left(8\right)}\left(C_l\right) = 6$ that represent the lengths of their shortest assembly pathways, which, in turn, ensures that their assembly pools, P, are distinct sets for a given assembly pathway.

Table 1. Distribution of the assembly indices for $N = 4$.

		${\mathit{N}}_1$
${\mathit{a}}^{\mathbf{\left(}\mathbf{4}\mathbf{\right)}}\mathbf{\left(}\mathit{C}\mathbf{\right)}$	$|{\mathit{a}}^{\mathbf{\left(}\mathbf{4}\mathbf{\right)}}\mathbf{\left(}\mathit{C}\mathbf{\right)}|$	0	1	2	3	4
2	4	1		2		1
3	12		4	4	4
16		1	4	$|B^{\left(4\right)}| = 6$	4	1

and

Table A5. Distribution of the assembly indices for $N = 5$.

		${\mathit{N}}_1$
${\mathit{a}}^{\left(\mathbf{5}\right)}\left(\mathit{C}\right)$	$|{\mathit{a}}^{\left(\mathbf{5}\right)}\left(\mathit{C}\right)|$	0	1	2	3	4	5
3	18	1	3	5	5	3	1
4	14		2	5	5	2
32		1	5	10	10	5	1

,

Table A6. Distribution of the assembly indices for $N = 6$.

		${\mathit{N}}_1$
${\mathit{a}}^{\left(\mathbf{6}\right)}\left(\mathit{C}\right)$	$|{\mathit{a}}^{\left(\mathbf{6}\right)}\left(\mathit{C}\right)|$	0	1	2	3	4	5	6
3	10	1		3	2	3		1
4	44		6	10	12	10	6
5	10			2	6	2
64		1	6	15	20	15	6	1

,

Table A7. Distribution of the assembly indices for $N = 7$.

		${\mathit{N}}_1$
${\mathit{a}}^{\left(\mathbf{7}\right)}\left(\mathit{C}\right)$	$|{\mathit{a}}^{\left(\mathbf{7}\right)}\left(\mathit{C}\right)|$	0	1	2	3	4	5	6	7
4	50	1	5	7	12	12	7	5	1
5	74		2	14	21	21	14	2
6	4				2	2
128		1	7	21	35	35	21	7	1

,

Table A8. Distribution of the assembly indices for $N = 8$.

		${\mathit{N}}_1$
${\mathit{a}}^{\left(\mathbf{8}\right)}\left(\mathit{C}\right)$	$|{\mathit{a}}^{\left(\mathbf{8}\right)}\left(\mathit{C}\right)|$	0	1	2	3	4	5	6	7	8
3	4	1				2				1
4	38			9	8	4	8	9
5	132		8	17	22	40	22	17	8
6	82			2	26	24	26	2
256		1	8	28	56	70	56	28	8	1

, Table A8,

Table A9. Distribution of the assembly indices for $N = 9$.

		${\mathit{N}}_1$
${\mathit{a}}^{\left(\mathbf{9}\right)}\left(\mathit{C}\right)$	$|{\mathit{a}}^{\left(\mathbf{9}\right)}\left(\mathit{C}\right)|$	0	1	2	3	4	5	6	7	8	9
4	24	1	3		3	5	5	3		3	1
5	184		4	17	35	36	36	35	17	4
6	248		2	19	42	61	61	42	19	2
7	56				4	24	24	4
512		1	9	36	84	126	126	84	36	9	1

,

Table A10. Distribution of the assembly indices for $N = 10$.

		${\mathit{N}}_1$
${\mathit{a}}^{\left(\mathbf{10}\right)}\left(\mathit{C}\right)$	$|{\mathit{a}}^{\left(\mathbf{10}\right)}\left(\mathit{C}\right)|$	0	1	2	3	4	5	6	7	8	9	10
4	20	1		3		5	2	5		3		1
5	198		8	22	20	33	32	33	20	22	8
6	502		2	18	68	108	110	108	68	18	2
7	288			2	32	62	96	62	32	2
8	16					2	12	2
1024		1	10	45	120	210	252	210	120	45	10

,

Table A11. Distribution of the assembly indices for $N = 11$.

		${\mathit{N}}_1$
${\mathit{a}}^{\left(\mathbf{11}\right)}\left(\mathit{C}\right)$	$|{\mathit{a}}^{\left(\mathbf{11}\right)}\left(\mathit{C}\right)|$	0	1	2	3	4	5	6	7	8	9	10	11
5	184	1	7	14	23	18	29	29	18	23	14	7	1
6	686		4	32	69	104	134	134	104	69	32	4
7	970			9	69	178	229	229	178	69	9
8	208				4	30	70	70	30	4
2048		1	11	55	165	330	462	462	330	165	55	11

and

Table A12. Distribution of the assembly indices for $N = 12$.

		${\mathit{N}}_1$
${\mathit{a}}^{\left(\mathbf{12}\right)}\left(\mathit{C}\right)$	$|{\mathit{a}}^{\left(\mathbf{12}\right)}\left(\mathit{C}\right)|$	0	1	2	3	4	5	6	7	8	9	10	11	12
4	10	1				3		2		3				1
5	94			13	4	10	12	16	12	10	4	13
6	1034		12	42	94	141	130	196	130	141	94	42	12
7	1688			11	106	196	354	354	354	196	106	11
8	1180				16	143	282	298	282	143	16
9	90					2	14	58	14	2
4096		1	12	66	220	495	792	924	792	495	220	66	12	1

(Appendix C) show the distributions of the assembly indices among $2^N$ bitstrings for $4\le N\le 12$, taking into account their Hamming weights, $N_1$. The sums of columns are rows of Pascal’s triangle (OEIS A007318).

The following definition is commonly known, but we provide it here for clarity.

Definition 2.

A bitstring, $B_k^{\left(N\right)}$, is a balanced string if its Hamming weight $N_1 = ⌊N/2⌋$ or $N_1 = ⌈N/2⌉$.

Without a loss of generality, we assume that, if N is odd, $N_1<N_0$ (e.g., for $N = 5$, $N_1 = 2$, and $N_0 = 3$). However, our results are equivalently applicable if we assume the opposite (i.e., a larger number of ones for an odd N). The number $|B^{\left(N\right)}|$ of balanced bitstrings among all $2^N$ bitstrings is as follows

$$\begin{array}{cc}\hfill |B^{\left(N\right)}|& = \left(\genfrac{}{}{0pt}{}{N}{⌊N/2⌋}\right) = \left(\genfrac{}{}{0pt}{}{N}{⌈N/2⌉}\right)\approx \sqrt{\frac{2}{\pi N}}{2}^N,\hfill \end{array}$$

(7)

where “$⌊x⌋$” is the floor function that yields the greatest integer less than or equal to x, and “$⌈x⌉$” is the ceiling function that yields the least integer greater than or equal to x. This is the OEIS A001405 sequence, the maximal number of subsets of an N-set, such that no one contains another, as asserted via Sperner’s theorem, and approximated using Stirling’s approximation for a large N. Balanced and even-length bitstrings, $B_k^{\left(N\right)}$, have natural binary entropies, (3) $H\left(B_k^{\left(N\right)}\right) = \{0,1\}$. Conversely, non-balanced and/or odd-length bitstrings, $C_k^{\left(N\right)}$, have binary entropies, $0<H\left(C_k^{\left(N\right)}\right)<1$.

Theorem 1.

An $N = 4$-bit string is the shortest string with more than one bitstring assembly index.

Proof. 

The proof is trivial. For $N = 1$, the assembly index $a^{\left(1\right)}\left(C\right) = 0$, as all basis objects have a pathway assembly index of 0 [2] (they are not assembled). $N = 2$ provides four available bitstrings with $a^{\left(2\right)}\left(C\right) = 1$. $N = 3$ provides eight available bitstrings with $a^{\left(3\right)}\left(C\right) = 2$. Only $N = 4$ provides sixteen bitstrings that include four stings with $a^{\left(4\right)}\left(C\right) = 2$ and twelve bitstrings with $a^{\left(4\right)}\left(C\right) = 3$ including $|B^{\left(4\right)}| = 6$ balanced bitstrings, as shown in Table 1 and

Table 2. $|B^{\left(4\right)}| = 6$ balanced bitstrings $B_k^{\left(4\right)}$.

k	${\mathit{B}}_{\mathit{k}}^{\mathbf{\left(}\mathbf{4}\mathbf{\right)}}$				${\mathit{a}}^{\mathbf{\left(}\mathbf{4}\mathbf{\right)}}\mathbf{\left(}{\mathit{B}}_{\mathit{k}}\mathbf{\right)}$
1	(0	1)	(0	1)	2
2	(1	0)	(1	0)	2
3	0	1	1	0	3
4	1	1	0	0	3
5	1	0	0	1	3
6	0	0	1	1	3

. For example, to assemble the bitstring $B_1 = \left[0101\right]$, we need to assemble the bitstring $\left[01\right]$ and reuse it. Therefore, $a^{\left(N\right)}\left(C_k\right) = N-1$ for $0<N<4$, $\forall k = \{1,2,\dots ,2^N\}$ and $\underset{k}{min}\left(\left\{a^{\left(N\right)}\left(C_k\right)\right\}\right)<N-1$ for $N\ge 4$, where $\left\{a^{\left(N\right)}\left(C_k\right)\right\}$ denotes a set of assembly indices of all $2^N$ bitstrings.    □

Interestingly, Theorem 1 strengthens the meaning of $N = 4$ as the minimum information capacity that provides a minimum thermodynamic black hole entropy [31,32,33]. There is no disorder or uncertainty in an object that can be assembled in the same number of steps, $s<3$.

The following definition, taking into account the cyclic order of bitstrings, is also provided for the sake of clarity.

Definition 3.

A bitstring, $R_k^{\left(N\right)}$, is a ringed bitstring if a ring formed with this string by joining its beginning with its end is unique among the rings formed from the other ringed strings, $R_l^{\left(N\right)},l\ne k$.

There are at least two and at most N forms of a ringed bitstring, $R_k^{\left(N\right)}$, that differ in the position of the starting bit. For example, for $|B^{\left(4\right)}| = 6$ balanced bitstrings, shown in Table 2, two augmented strings with $a^{\left(4\right)} = 2$ correspond to each other if we change the starting bit:

$$\begin{array}{cc}\hfill & [\dots 1 | 0101 | 0101 | 01\dots ] = \hfill \\ \hfill & [\dots 10 | 1010 | 1010 | 1\dots ].\hfill \end{array}$$

(8)

Similarly, four augmented bitstrings with $a^{\left(4\right)} = 3$ correspond to each other

$$\begin{array}{cc}\hfill & [\dots | 0110 | 0110 | 011\dots ] = \hfill \\ \hfill & [\dots 0 | 1100 | 1100 | 11\dots ] = \hfill \\ \hfill & [\dots 01 | 1001 | 1001 | 1\dots ] = \hfill \\ \hfill & [\dots 011 | 0011 | 0011 | \dots ],\hfill \end{array}$$

(9)

after a change in the position of the starting bit. Thus, there are only two balanced, ringed bitstrings $E_k^{\left(4\right)}$. The number of ringed bitstrings $|R_k^{\left(N\right)}|$ among all $2^N$ bitstrings is given via the OEIS sequence A000031. In general (for $N\ge 3$), the number, $|R_k^{\left(N\right)}|$, of ringed bitstrings is much lower than the number, $|B_k^{\left(N\right)}|$, of balanced bitstrings.

By neglecting the notion of the beginning and end of a string, we focus on its length and content. In Yoda’s language,

“complete, no matter where it begins. A message is”.

The numbers of the balanced $|B_k^{\left(N\right)}|$, ringed $|R_k^{\left(N\right)}|$, and balanced, ringed $|E_k^{\left(N\right)}|$ bitstrings are shown in

Table 3. Bitstring length: N; number of all bitstrings: $2^N$; number of balanced bitstrings: $B_k^{\left(N\right)}$; number of ringed bitstrings: $R_k^{\left(N\right)}$; and number of balanced, ringed bitstrings: $E_k^{\left(N\right)}$.

$\mathit{N}$	${\mathbf{2}}^{\mathit{N}}$	$|{\mathit{B}}_{\mathit{k}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}|$	$|{\mathit{R}}_{\mathit{k}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}|$	$|{\mathit{E}}_{\mathit{k}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}|$	$|{\mathit{B}}_{\mathit{k}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}|/|{\mathit{E}}_{\mathit{k}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}|$
1	2	1	2	1	1
2	4	2	3	1	2
3	8	3	4	1	3
4	16	6	6	2	3
5	32	10	8	2	5
6	64	20	14	4	5
7	128	35	20	5	7
8	256	70	36	10	7
9	512	126	60	14	9
10	1024	252	108	26	$9.6923\dots$
11	2048	462	188	42	11
12	4096	924	352	80	11.55
13	8192	1716	632	132	13
14	16,384	3432	1182	246	$13.9512\dots$
15	32,768	6435	2192	429	15

and Figure 1. $|E_k^{\left(N\right)}|$ is close to OEIS A000014 sequence up to the eleventh term and its formula remains to be researched.

We note that, in general, the starting bit is relevant for the assembly index. Thus, different forms of a ringed bitstring may have different assembly indices. For example, for $N = 7$ balanced bitstrings, $B_{34}$ and $B_{35}$, shown in

Table A15. $|B^{\left(7\right)}| = 35$ balanced bitstrings.

k	${\mathit{B}}_{\mathit{k}}^{\mathbf{\left(}\mathbf{7}\mathbf{\right)}}$							${\mathit{a}}^{\mathbf{\left(}\mathbf{7}\mathbf{\right)}}\mathbf{\left(}{\mathit{B}}_{\mathit{k}}\mathbf{\right)}$
1	0	(0	1)	(0	1)	(0	1)	4
2	(0	1)	(0	1)	(0	1)	0	4
3	(1	0)	(1	0)	(1	0)	0	4
4	(0	1)	(0	1)	0	(0	1)	4
5	(1	0)	(1	0)	0	(1	0)	4
6	(0	1)	0	(0	1)	(0	1)	4
7	(1	0)	0	(1	0)	(1	0)	4
8	(1	0	0)	(1	0	0)	1	4
9	(1	0	0)	1	(1	0	0)	4
10	1	(1	0	0)	(1	0	0)	4
11	(0	0	1)	1	(0	0	1)	4
12	(0	0	1)	(0	0	1)	1	4
13	1	(0	0)	(0	0)	1	1	5
14	1	0	0	(0	1)	(0	1)	5
15	(1	0)	0	0	1	(1	0)	5
16	(1	0)	(1	0)	0	0	1	5
17	(1	0)	1	(1	0)	0	0	5
18	1	1	(0	0)	(0	0)	1	5
19	1	(1	0)	(1	0)	0	0	5
20	1	1	1	(0	0)	(0	0)	5
21	(0	1)	(0	1)	1	0	0	5
22	(0	1)	1	0	0	(0	1)	5
23	(0	1)	1	0	(0	1)	0	5
24	(0	1)	1	(0	1)	0	0	5
25	(0	1)	0	(0	1)	1	0	5
26	0	(0	1)	(0	1)	1	0	5
27	0	(0	1)	1	(0	1)	0	5
28	(0	0)	1	1	1	(0	0)	5
29	(0	1)	0	0	(0	1)	1	5
30	(0	0)	(0	0)	1	1	1	5
31	0	0	(0	1)	(0	1)	1	5
32	0	0	(0	1)	1	(0	1)	5
33	1	(1	0)	0	0	(1	0)	5
34	0	0	0	1	1	1	0	6
35	0	1	1	1	0	0	0	6

, have $a^{\left(7\right)} = 6$. However, these bitstrings are not ringed since they correspond to each other and to the balanced bitstrings $B_{13}$, $B_{18}$, $B_{20}$, $B_{28}$, and $B_{30}$ with $a^{\left(7\right)} = 5$. They all have the same triplet of adjoining ones.

Definition 4.

The assembly index of a ringed bitstring, $R_k^{\left(N\right)}$, is the smallest assembly index among all forms of this string.

Thus, if different forms of a ringed bitstring have different assembly indices, we assign the smallest assembly index to this string. In other words, we assume that the smallest number of steps

$$a^{\left(N\right)}\left(R_k\right) = \underset{l}{min}\left(\left\{a^{\left(N\right)}{\left(R_k\right)}_l\right\}\right),{\left(R_k\right)}_l\in R_k,$$

(10)

where ${\left(R_k\right)}_l$ denotes a particular $l\mathrm{th}$ form of a ringed bitstring, $R_k$, is the bitstring assembly index of this ringed string (cf., e.g., strings (19) and (20)). We assume that, if an object that can be represented with a ringed bitstring can be assembled in fewer steps, this procedure will be preferred in nature.

The distribution of the assembly indices of the balanced, ringed bitstrings, $E_k$, is shown in

Table 4. Distribution of assembly indices among balanced, ringed bitstrings, $E^{\left(N\right)}$, for $4\le N\le 11$.

$\mathit{N}$	$|{\mathit{E}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}|$	${\mathit{a}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}} = \mathbf{2}$	${\mathit{a}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}} = \mathbf{3}$	${\mathit{a}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}} = \mathbf{4}$	${\mathit{a}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}} = \mathbf{5}$	${\mathit{a}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}} = \mathbf{6}$	${\mathit{a}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}} = \mathit{7}$	${\mathit{a}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}} = \mathbf{8}$
4	2	1	1
5	2		1	1
6	4		1	2	1
7	5			2	3
8	10		1	1	6	2
9	14			1	4	7	2
10	26			1	6	9	10
11	42				2	14	20	6

.

3. Minimum Bitstring Assembly Index

In the following, we derive the tight lower bound of the set of different bitstring assembly indices.

Theorem 2

(Tight lower bound of the bitstring assembly index). The smallest bitstring assembly index, $a^{\left(N\right)}\left(C_{\mathit{min}}\right)$, as a function of N corresponds to the shortest addition chain for N (OEIS A003313).

Proof. 

Bitstrings, $C_{\min }$, for which $a^{\left(N\right)}\left(C_{\min }\right) = \underset{k}{min}\left(\left\{a^{\left(N\right)}\left(C_k\right)\right\}\right)$, $\forall k = \{1,2,\dots ,2^N\}$ can be formed in subsequent steps, s, by joining the longest bitstring assembled so far with itself until $N = 2^s$ is reached [1]. Therefore, if $N = 2^s$, then $\underset{k}{min}\left(\left\{a_{\left(2^s\right)}\left(C_k\right)\right\}\right) = s = {log}_2\left(N\right)$. Only four bitstrings

$$C_{{\min }_1}^{\left(2^s\right)} = [00\dots ],C_{{\min }_2}^{\left(2^s\right)} = [11\dots ],C_{{\min }_3}^{\left(2^s\right)} = [0101\dots ],\mathrm{and}{C}_{{\min }_4}^{\left(2^s\right)} = [1010\dots ]$$

(11)

have such an assembly index in this case.

An addition chain for $N\in \mathbb{N}$, having the shortest length $s\in \mathbb{N}$ (commonly denoted as $l\left(N\right)$), is defined as a sequence, $1 = b_0<b_1<\dots <b_s = N$, of integers such that, for each $j\ge 1$, $b_j = b_k+b_l$ for $l\le k<j$. The first step in creating an addition chain for N is always $b_1 = 1+1 = 2$, and this corresponds to assembling a doublet, $[\ast ★]$, from the initial assembly pool, P. Thus, the lower bound for s of the addition chain for N, $s\ge {log}_2\left(N\right)$ is achieved for $N = 2^s$. In our case, bitstrings (11) achieve this bound. The second step in creating an addition chain can be $b_2 = 1+1 = 2$ or $b_2 = 1+2 = 3$.

Thus, finding the shortest addition chain for N corresponds to finding an assembly index of a bitstring containing bits and/or doublets and/or triplets generated via these doublets for $N\ne 2^s$ since, due to Theorem 1, only they provide the same assembly indices $\{0,1,2\}$. Such strings correspond to linear molecules made of carbons (cf. supplementary material, S3.2 in [4]). □

The smallest assembly indices, $a_{\min }^{\left(N\right)}$, are shown in

Table 5. The lower bound on the bitstring assembly index (OEIS A003313).

N	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21
$a_{\min }^{\left(N\right)}$	0	1	2	2	3	3	4	3	4	4	5	4	5	5	5	4	5	5	6	5	6

for $1\le N\le 21$. Calculating the minimum length of the addition chain for N, as well as finding the shortest assembly pathway for a chemical molecule, has been shown to be at least as hard as NP-complete [4,34].

4. Degree of Causation for Minimum-Assembly-Index Bitstrings

Using the difference between the general AT lower bound (1) and the smallest bitstring assembly index (OEIS A003313), we can define the quantity

$$D_C\left(N\right):=2^{\left({log}_2\left(N\right)-a_{\min }^{\left(N\right)}\right)} = N{2}^{-a_{\min }^{\left(N\right)}},$$

(12)

capturing a degree of causation [6] of assembling the bitstrings of length N with the smallest assembly index, as shown in Figure 2. For $N = 2^s$, the degree of causation, $D_C\left(N\right) = 1$, as all four bitstrings (11), can be assembled along a single pathway only; their assembly is entirely causal. However, for $N\ne 2^s$, $D_C\left(N\right)<1$, since some bitstrings $C_{\min }^{\left(N\right)}$ can be assembled along different pathways. For example, there are two pathways for the bitstring $\left[001\right]$: (a) $\left[00\right]+1$ and (b) $0+\left[01\right]$, leaving different subunits (respectively, $\left[00\right]$ and $\left[01\right]$) in their assembly pools and resulting in lower values of $D_C\left(N\right)$.

Equation (12) naturally divides the set of natural numbers into sections, $2^s\le N<2^{s+1}$, and shows regularities that, for certain values of N, can be used to determine the smallest assembly index (i.e., the shortest addition chain for N) as $a_{\min }^{\left(N\right)} = {log}_2\left(N\right)-{log}_2\left(D_C\left(N\right)\right)$. For each $N = 2^s\iff a_{\min }^{\left(2^s\right)} = s$ and for each $\widehat{N}$ being the sum of two powers of 2 (OEIS A048645),

$$\widehat{N}:=2^s+1·2^l,l = 0,1,\dots ,s-1\iff a_{\min }^{\left(\widehat{N}\right)} = s+1,$$

(13)

while, for the remaining $\tilde{N}$ not being the sum of two powers of 2 (OEIS A072823),

$$2^s<\tilde{N}<2^{s+1},\tilde{N}\ne \widehat{N}\iff a_{\min }^{\left(\tilde{N}\right)} = s+k, k\ge 2,$$

(14)

where $k = 2$ for $\tilde{N} = \{7,11,13–15,19,21–23,25–28,\dots \}$, while some $\tilde{N}$s generate exceptions to this general rule (cf. OEIS A230528). For example, $k = 3$ for $\tilde{N}$ = {29, 31, 47, 53, 55, 57–59, 61–63, …}, $k = 4$ for $\tilde{N}$ = {127, 191, 235, 237, 239, 247, 251, 253, 254, …}, etc. The first exception, $k = 3$, is for ${\tilde{N}}_{13} = 29$. The first double exception, $k = 4$, is for ${\tilde{N}}_{63} = 127$. However, in particular, for 

$${\tilde{N}}_3 = 2^s+3·2^l,l = 0,1,\dots ,s-2\iff a_{\min }^{\left({\tilde{N}}_3\right)} = s+2,\mathrm{and}$$

(15)

$${\tilde{N}}_{7,s-3} = 2^s+7·2^{s-3} = \{15,30,60,\dots \},s\ge 3\iff a_{\min }^{\left({\tilde{N}}_{7,s-3}\right)} = s+2,$$

(16)

so the number of Ns within each section, not included in the set of general rules $2^s$, (13), (15), and (16), is $|N_{\mathrm{ngr}}| = |2^s-1-s-(s-1)-1| = |2^s-2s-1|$. Furthermore,

$$\begin{array}{c}\hfill \underset{s\to \infty }{lim}\left(min{D}_C\left(\widehat{N}\right)\right)=\underset{s\to \infty }{lim}\left(\frac{1}{2}\left(1+\frac{1}{2^s}\right)\right) = \frac{1}{2},\\ \hfill \underset{s\to \infty }{lim}\left(max{D}_C\left(\tilde{N}\right)\right)=D_C\left({\tilde{N}}_{7,s-3}\right) = \frac{15}{32}.\end{array}$$

(17)

The shortest addition chain-sequence-generating factors for $1\le s\le 5$ are listed in

Table 6. List of the shortest-addition chain-sequence-generating factors for $1\le s\le 5$.

s	$2^{\mathit{s}}$	The Shortest-Addition Chain-Sequence-Generating Factors
1	2	$1_1$
2	4	$1_2$	$3_1$
3	8	$1_3$	$3_2$	$5_1$	$7_1$
4	16	$1_4$	$3_3$	$5_2$	$7_2$	$9_1$	${11}_1$	${13}_1$	${15}_1$
5	32	$1_5$	$3_4$	$5_3$	$7_3$	$9_2$	${11}_2$	${13}_2$	${15}_2$	${17}_1$	${19}_1$	${21}_1$	${23}_1$	${25}_1$	${27}_1$	${29}_1$	${31}_1$

, where the subsequent odd numbers of the form $m_k$ generate sequences $N = 2^s+m_k·2^l$, where $l = 0,1,\cdots ,k-1$, while the $m_k$ numbers in red indicate that certain $\tilde{N}$s within the sequences they generate are exceptions to the general $a_{\min }^{\left(\tilde{N}\right)} = s+2$ rule.

For example, if $s = 4$, then $a_{\min }^{\left(16\right)} = 4$ and

$$\begin{array}{cc}\widehat{N} = 2^4+2^l = \{17,18,20,24\}\hfill & \iff a_{\min }^{\left(\widehat{N}\right)} = 4+1 = 5,\hfill \\ {\tilde{N}}_3 = 2^4+3·2^l = \{19,22,28\}\hfill & \iff a_{\min }^{\left({\tilde{N}}_3\right)} = 4+2 = 6,\hfill \\ {\tilde{N}}_5 = 2^4+5·2^l = \{21,26\}\hfill & \iff a_{\min }^{\left({\tilde{N}}_5\right)} = 4+2 = 6,\hfill \\ {\tilde{N}}_7 = 2^4+7·2^l = \{23,30\}\hfill & \iff a_{\min }^{\left({\tilde{N}}_7\right)} = 4+2 = 6,\hfill \\ {\tilde{N}}_9 = 2^4+9·2^l = 25\hfill & \iff a_{\min }^{\left({\tilde{N}}_9\right)} = 4+2 = 6,\hfill \\ {\tilde{N}}_{11} = 2^4+11·2^l = 27\hfill & \iff a_{\min }^{\left({\tilde{N}}_{11}\right)} = 4+2 = 6,\hfill \\ {\tilde{N}}_{13} = 2^4+13·2^l = 29\hfill & \iff a_{\min }^{\left({\tilde{N}}_{13}\right)} = 4+3 = 7,\hfill \\ {\tilde{N}}_{15} = 2^4+15·2^l = 31\hfill & \iff a_{\min }^{\left({\tilde{N}}_{15}\right)} = 4+3 = 7,\hfill \end{array}$$

(18)

where the last two values, $a_{\min }^{\left(\tilde{N}\right)}$, are higher than those given via the general rule. Based on the OEIS A003313 sequence for $N\le {10}^5$, we have determined the number of exceptions, that is $|N_{\mathrm{exc}}|$, such that $a_{\min }^{\left(N_{\mathrm{exc}}\right)}\ne \{s,s+1,s+2\}$ for $0\le s\le 15$, as shown in

Table 7. Number of exceptional $a_{\min }^{\left(N_{\mathrm{exc}}\right)}$ values $|N_{\mathrm{exc}}|$ and the number, $|N_{\mathrm{ngr}}|$, of $a_{\min }^{\left(N_{\mathrm{ngr}}\right)}$ not generated via general rules for $0\le s\le 15$.

s	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
$|N_{\mathrm{exc}}|$	0	0	0	0	2	9	30	80	193	432	925	1928	3953	8024	16,189	32,544
$2^s$	1	2	4	8	16	32	64	128	256	512	1024	2048	4096	8192	16,384	32,768
$|N_{\mathrm{ngr}}|$	0	0	0	1	7	21	51	113	239	493	1003	2025	4071	8165	16,355	32,737
$min\left(m_k\right)$					13	13	7	7	7	7	7	7	7	7	7	7

, where $min\left(m_k\right)$ is the minimal generating factor, $m_k$, shown in Table 6 that generates the exceptional $a_{\min }^{\left(N_{\mathrm{exc}}\right)}$. For all $s\ge 4$, $max\left(m_k\right) = 2^s-1$. The fact that $|N_{\mathrm{ngr}}|>|N_{\mathrm{exc}}|,\forall s\ge 3$ hints at the existence of general rules other than $2^s$, (13), (15), and (16).

Furthermore, for $4\le s\le 6$, $|N_{\mathrm{exc}}| = 2^s-s^2+2$ and for $s\ge 7$, $|N_{\mathrm{exc}}| = 2^s-s^2+1$ (OEIS A024012). As shown in Figure 3a, for all s, $|N_{\mathrm{exc}}|$ asymptotically approaches $2^s$ available in a given section as $s\to \infty$. As shown in Figure 3b, for $s = 6$, the ratio $|N_{\mathrm{exc}}|/2^s$ has a deflection point, $|N_{\mathrm{exc}}|/2^6 = 15/32$.

Only living systems have been found to be capable of producing abundant molecules with an assembly index greater than an experimentally determined value of 15 steps [3,8]. The cut-off between 13 and 15 is sharp, which means that molecules made through random processes cannot have assembly indices exceeding 13 steps [3,8]. In particular, $N = 15$ is the length of the shortest addition chain for N, which is smaller than the number of multiplications to compute $N\mathrm{th}$ power using the Chandah-sutra method (OEIS A014701, OEIS A371894). Furthermore, the values of the sequence A014701 are larger than the shortest addition chain for $N\notin 2^2+2^l$. These values (OEIS A371894) are not given via Equation (15), but Equation (16) provides their subset. Their Hamming weight is at least four in binary representation. Furthermore, the exceptional $a_{\min }^{\left(N_{\mathrm{exc}}\right)}$ values bear similarity to the atomic numbers, Z, of chemical elements that violate the Aufbau rule [15], which correctly predicts the electron configurations of most elements. Only about twenty elements within $24\le Z\le 103$ (with only two non-doubleton sets of consecutive ones) violate the Aufbau rule.

5. Maximum Bitstring Assembly Index

In the following, we conjecture upon the form of the upper bound of the set of different bitstring assembly indices. In general, of all bitstrings, $C_k$, having a given assembly index, shown in Table 1 and Table A5, Table A6, Table A7, Table A8, Table A9, Table A10, Table A11 and Table A12 (Appendix C), most have $N_1 = ⌊N/2⌋$, though we have found a few exceptions, mostly for non-maximal assembly indices, namely for $a^{\left(8\right)} = 4$ ($4<8$) and for $a^{\left(8\right)} = 6$ ($24<26$), for $a^{\left(10\right)} = 4$ ($2<5$) and for $a^{\left(10\right)} = 5$ ($32<33$), and for $a^{\left(12\right)} = 4$ ($2<3$). These observations allow us to restrict the search space of possible bitstrings with the largest assembly indices to balanced bitstrings only: with the exception of $N = 8$, of all bitstrings, $C_k^{\left(N\right)}$, having a largest assembly index, most are balanced. We can further restrict the search space to ringed bitstrings (Definition 3). If a bitstring, $C_{\min }$, for which $a^{\left(N\right)}\left(C_{\min }\right) = \underset{k}{min}\left(\left\{a^{\left(N\right)}\left(C_k\right)\right\}\right)$ is constructed from repeating patterns, then a bitstring, $C_{\max }$, for which $a^{\left(N\right)}\left(C_{\max }\right) = \underset{k}{max}\left(\left\{a^{\left(N\right)}\left(C_k\right)\right\}\right)$ must be the most patternless. The bitstring assembly index must be bounded from above, and $a^{\left(N\right)}\left(C_{\max }\right)$ must be a monotonically nondecreasing function of N that can increase at most by one between N and $N+1$. Certain heuristic rules apply in our binary case. For example,

• For $N = 7$, we cannot avoid two doublets (e.g., $2\times \left[00\right]$) within a ringed bitstring, $E_{28}^{\left(7\right)} = \left[0011100\right]$, and thus, $a^{\left(7\right)}\left(C_{\max }\right) = 5<6$;
• For $N = 8$, we cannot avoid two pairs of doublets (e.g., $2\times \left[00\right]$ and $2\times \left[11\right]$) within a ringed bitstring, $E_7^{\left(8\right)} = \left[00001111\right]$, and thus, $a^{\left(8\right)}\left(C_{\max }\right) = 5<6$;
• For $N = 12$, we cannot avoid three pairs of doublets (e.g., $2\times \left[00\right]$, $2\times \left[10\right]$, and $2\times \left[11\right]$) within a ringed bitstring, $E_k^{\left(12\right)} = \left[111000101100\right]$, and thus, $a^{\left(12\right)}\left(C_{\max }\right) = 8<9$;
• For $N = 14$, we cannot avoid two pairs of doublets and one doublet three times (e.g., $2\times \left[00\right]$, $2\times \left[11\right]$, and $3\times \left[01\right]$, and thus, $a^{\left(14\right)}\left(C_{\max }\right) = 9<10$;
• etc.

Table 8. Exemplary balanced bitstrings, $B_{\max }^{\left(N\right)}$, that have a largest assembly index. Conjectured form of the largest assembly index ($a_{\mathrm{conj}}^{\left(N\right)}$) and its factual values for ringed ($a_{\mathrm{rng}}^{\left(N\right)}$) and non-ringed ($a_{\mathrm{nrng}}^{\left(N\right)}$) bitstrings (red if below the conjectured value and green if above).

$\mathit{N}$	${\mathit{B}}_{\mathbf{max}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}$																				${\mathit{a}}_{\mathit{conj}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}$	${\mathit{a}}_{\mathit{rng}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}$	${\mathit{a}}_{\mathit{nrng}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}$
1	0																				0	0	0
2	1	0																			1	1	1
3	0	0	1																		2	2	2
4	0	0	1	1																	3	3	3
5	0	0	0	1	1																4	4	4
6	0	0	0	1	1	1															5	5	5
7	0	0	1	1	1	0	0														5	5	6
8	0	0	0	1	0	1	1	1													6	6	6
9	0	0	0	0	1	1	1	0	1												7	7	7
10	0	0	0	0	1	1	1	1	0	1											7	7	8
11	0	0	0	0	0	1	0	1	1	1	1										8	8	8
12	1	1	1	0	0	0	1	0	1	1	0	0									9	8	8
13	0	0	0	0	0	0	1	0	1	1	1	1	1								9	9	9
14	0	0	0	0	0	1	0	1	0	1	1	1	1	1							9	9	9
15	0	0	0	0	0	1	0	1	0	1	1	1	1	1	0						10	10	10
16	1	0	0	0	0	0	0	1	0	1	0	1	1	1	1	1					11	10	10
17	0	0	0	0	0	0	1	0	1	0	1	1	1	1	1	1	0				11	11	11
18	1	0	0	1	1	1	1	1	0	1	1	0	0	0	0	0	1	0			11	11	12
19	1	0	0	0	0	1	0	1	0	1	0	0	1	1	1	1	1	0	1		12	11	12
20	1	0	1	0	0	1	1	1	1	1	0	1	1	0	0	0	0	0	1	0	13	12	13

shows the exemplary balanced bitstrings, $B_{\max }$, having the largest assembly indices that we assembled (cf. also Appendix A). To determine the assembly index, $a^{\left(18\right)} = 11$, of the bitstring

$$E_k^{\left(18\right)} = \left[1\left(001\right)\left(11\right)\left(110\right)\left(110\right)\left(00\right)\left(001\right)0\right],$$

(19)

for example, we look for the longest patterns that appear at least twice within the string, and we look for the largest number of these patterns. Here, we find that the two triplets $\left[001\right]$ and $\left[110\right]$ appear twice in $E_k^{\left(18\right)}$ and are based on the doublets $\left[00\right]$ and $\left[11\right]$ also appearing in $E_k^{\left(18\right)}$. Thus, we start with the assembly pool $\{1,0,[00],[001],[11],[110\left]\right\}$ made in four steps and join the elements of the pool in the following seven steps to arrive at $a^{\left(18\right)}\left(E_k\right) = 11$. On the other hand, another form of this balanced, ringed string,

$$E_l^{\left(18\right)} = \left[\left(01\right)\left(11\right)\left(110\right)\left(110\right)00\left(001\right)\left(01\right)0\right],$$

(20)

has $a^{\left(18\right)}\left(E_l\right) = 12$.

These results allow us to formulate the following conjecture.

Conjecture 1

(Tight upper bound on a bitstring assembly index). With exceptions for small N, the largest bitstring assembly index $a^{\left(N\right)}\left(C_{\mathit{max}}\right)$ is given via a sequence formed by $\{+1,+1,k\times 0,+1,+1,k\times 0\}$ for $k\in {\mathbb{N}}_0$, where $+1$ denotes increasing $a^{\left(N\right)}\left(C_{\mathit{max}}\right)$ by one, and 0 denotes maintaining it at the same level, and $a^{\left(0\right)} = -1$.

However, at this moment, we cannot state whether this conjecture applies to ringed or non-ringed bitstrings. The assembly indices for $N<3$ are the same for a given N, whereas the assembly indices for $4\le N\le 10$ were discussed above and are calculated in Appendix C for balanced and balanced, ringed bitstrings.

The conjectured sequence is shown in Figure 4 and Figure 5, starting with $a^{\left(0\right)} = -1$ (we note in passing that $n = -1$ is a dimension of the void, the empty set ∅, or (−1)-simplex). Subsequent terms are given via $\{0,1,2,3,4,5,5,6,7,7,8,9,9,9,10,\dots \}$, which is periodic for $N = k(k+3)$ and defines plateaus of a constant bitstring assembly index at $a^{\left(N\right)}\left(C_{\max }\right) = 4k-3$, and $a^{\left(N\right)}\left(C_{\max }\right) = 4k-1$, $k\in \mathbb{N}$, $k>1$.

This sequence can be generated using the procedure given by Listing 1.

Listing 1. Matlab code to generate the conjectured bitstring assembly index upper bound.
step = 1;	% step flag
run = 1;	% run flag
flat = 0;	% flat~counter
Nk = 0;
aub = −1;	% the upper bound
while Nk < N
if step < 3
Nk = Nk + 1;	% next Nk
aub= aub + 1;	% increment the bound
else	% step==3
for k=1:flat
if flat > 0
Nk = Nk + 1;	% next Nk
end
end
run = run+1;	% increment run flag
if run > 2
run  = 1;	% reset run flag
flat = flat + 1;	% increment flat counter
end
end
step = step+1;	% increment step flag
if step > 3
step = 1;	% reset step flag
end
end

We note the similarity of this bound to the monotonically nondecreasing Shannon entropy of chemical elements, including observable ones [15]. Perhaps the exceptions in the sequence of Conjecture 1 vanish as N increases.

6. Binputation

So far, we have assembled bitstrings “manually”. Now, we shall automatize this process using other bitstrings as assembling programs.

Definition 5.

The binary assembling program $Q_B$ is a bitstring of length $s_Q$ that acts on the assembly pool P and outputs the assembled bitstrings, adding them to the pool.

Definition 6.

The trivial assembling program Q is a binary assembling program with consecutive bits denoting the following commands:

0 

$\iff$ take the last element from P, join it with itself, and output;

1 

$\iff$ take the last two elements from P, join them with each other, and output.

As the assembly pool P is a distinct set to which bitstrings are added in subsequent assembly steps, only these two commands apply to the initial assembly pool, $P = \{1,0\}$, containing only two bits, regardless of the starting command.

Theorem 3.

If a bitstring, $C_{\mathit{min}}^{\left(N\right)}$, can be assembled via an elegant trivial program of length $s_Q = a^{\left(N\right)}\left(C_{\mathit{min}}\right)$, then N is expressible as a product of Fibonacci numbers (OEIS A065108), and the length, $s_Q$, of any trivial program Q is not shorter than the assembly index of the string that this trivial assembling program assembles.

Proof. 

An elegant program is the shortest program that produces a given output [35,36]. Furthermore, no program, P, shorter than an elegant program, Q, can find this elegant program, Q [35]. If it could, it could also generate Q’s output. But if P is shorter than Q, then Q would not be elegant, which leads to a contradiction.

The $1\mathrm{st}$ bit of the trivial assembling program Q is irrelevant, as $Q = 0$ assembles $C_{{\min }_1}^{\left(2\right)} = \left[00\right]$ and $Q = 1$ assembles $C_{{\min }_4}^{\left(2\right)} = \left[10\right]$, so $Q = \ast$ assembles $C_{{\min }_{1,4}}^{\left(2\right)} = [\ast 0]$. Then, the programs $Q = \ast 0\dots 0$ assemble the $2^{s_Q}$-bit strings $C_{{\min }_{1,4}}^{\left(2^s\right)} = [\ast 0\ast 0\dots ]$ having the assembly index $a_{\min }^{\left(2^{s_Q}\right)} = s_Q$, while bitstrings $C_{{\min }_{2,3}}^{2^{s_Q}}$ with the smallest assembly index, $a_{\min }^{\left(2^{s_Q}\right)} = s_Q$, can be assembled with the same two programs starting with the reversed assembly pool $P = \{0,1\}$.

The remaining $2^{s_Q-1}-2$ programs will assemble some of the shorter bitstrings with the assembly index $a_{\min }^{\left(N\right)} = s_Q$. In general, all programs, Q, assemble bitstrings that have lengths expressible as a product of Fibonacci numbers (OEIS A065108), as shown in

Table A1. Lengths of the bitstrings assembled via trivial assembly programs, Qs (OEIS A065108).

${\mathit{a}}^{\mathbf{\left(}\mathit{N}\mathbf{\right)}}$	0	1	2	3	3, 4	4, 5	5, 6	6, 7
${\mathit{s}}_{\mathit{Q}}$		1	2	3	4	5	6	7
1	1	2	3	5	8 ${ }^{‡}$	13	21	$34 { }^{‡}$
		|	|	|	|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	42
		|	|	|	|	$\begin{array}{|c|}\hline 0\\ \hline\end{array}$	26	39
		|	|	|	|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	52
		|	|	|	$\begin{array}{|c|}\hline 0\\ \hline\end{array}$	$16 { }^{‡}$	$24 { }^{‡}$	$40 { }^{‡}$
		|	|	|		|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	$48 { }^{‡}$
		|	|	|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	$32 { }^{‡}$	$48 { }^{‡}$
		|	|	|			$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	$64 { }^{‡}$
		|	|	$\begin{array}{|c|}\hline 0\\ \hline\end{array}$	10	15	25	$40 { }^{‡}$
		|	|		|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	50
		|	|		|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	30	45
		|	|		|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	60
		|	|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	20	30	50
		|	|			|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	60
		|	|			$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	40	60
		|	|				$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	80
		|	$\begin{array}{|c|}\hline 0\\ \hline\end{array}$	6	9	15	24 ${ }^{†}$	39
		|		|	|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	$48 { }^{†}$
		|		|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	30	45
		|		|	|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	60
		|		|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	18	27	45
		|		|		|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	54
		|		|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	36	54
		|		|			$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	72
		|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	12	18	30	$48 { }^{†}$
		|			|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	60
		|			|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	36	54
		|			|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	72
		|			$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	24	36	60
		|				|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	72
		|				$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	48	72
		|					$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	96
		$\begin{array}{|c|}\hline 0\\ \hline\end{array}$	4	6	10	$16 { }^{†}$	26	42
			|	|	|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	52
			|	|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	$32 { }^{†}$	$48 { }^{†}$
			|	|	|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	$64 { }^{†}$
			|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	20	30	50
			|	|		|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	60
			|	|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	40	60
			|	|			$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	80
			|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	12	18	30	$48 { }^{†}$
			|		|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	60
			|		|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	36	54
			|		|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	72
			|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	24	36	60
			|			|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	72
			|			$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	48	72
			|				$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	96
			$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	8	12	20	$32 { }^{†}$	52
				|	|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	$64 { }^{†}$
				|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	40	60
				|	|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	80
				|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	24	36	60
				|		|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	72
				|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	48	72
				|			$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	96
				$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	16	24	40	$64 { }^{†}$
					|	|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	80
					|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	48	72
					|		$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	96
					$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	32	48	80
						|	$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	96
						$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	64	96
							$\begin{array}{|c|}\hline ★\\ \hline\end{array}$	128

^†. The program is not elegant. ^‡. The program is not elegant if $\ast = 0$ and the assembled bitstring is not $C_{\min }$ if $\ast = 1$. The boxed symbols denote program commands, not the bitstring lengths.

(Appendix B), wherein, out of $2^{s_Q-1}$ programs (cf. Table A1 and

Table A4. Six-bit programs assembling bitstrings with $a^{\left(N\right)} = \{5,6\}$.

Q	$\mathit{C} \mathbf{(}{\mathit{s}}_{\mathit{Q}} = 6\mathbf{)}$	N
$\ast 11111$	$0\ast 0\ast 00\ast 0\ast 00\ast 00\ast 0\ast 00\ast 0$	21
$\ast 11110$	$\ast 00\ast 00\ast 0\ast 00\ast 0\dots$	26
$\ast 1110$ ★	$0\ast 0\ast 00\ast 0\dots$	$24{ }^{‡},32{ }^{‡}$
$\ast 110★★$	$\ast 00\ast 0\dots$	$25,30,40$
$\ast 10★★★$	$0\ast 0\dots$	$24{ }^{†},\dots ,48$
$\ast 0★★★★$	$\ast 0\dots$	$26,32{ }^{†},\dots ,64$

^†. The program is not elegant. ^‡. The program is not elegant if $\ast = 0$ and the assembled bitstring is not $C_{\min }$ if $\ast = 1$.

), the following applies:

• $2^{s_Q-2}$ programs $Q = \ast 0★\dots$ assemble even-length, balanced bitstrings $B = [\ast 0\ast 0\dots ]$ having natural binary entropies (3) $H\left(C\right) = \{0,1\}$, including bitstrings $C_{{\min }_{1,4}}^{\left(2^{s_Q}\right)}$ (11);
• $2^{s_Q-3}$ programs $Q = \ast 10★\dots$ assemble $[0\ast 00\ast 0\dots ]$ bitstrings having lengths divisible by three and entropies $H\left(C\right)\approx \{0,0.9183\}$;
• $2^{s_Q-4}$ programs $Q = \ast 110★\dots$ assemble $[\ast 00\ast 0\ast 00\ast 0\dots ]$ bitstrings having lengths divisible by five and entropies $H\left(C\right)\approx \{0,0.9710\}$;
• $2^{s_Q-5}$ programs $Q = \ast 1110★\dots$ assemble $[0\ast 0\ast 00\ast 0\dots ]$ bitstrings having lengths divisible by eight, entropies $H\left(C\right)\approx \{0,0.9544\}$, and assembly indices $a^{\left(N\right)} = s_Q-1$ if $\ast = 1$;
• …;
• the program $Q = \ast 1\dots 0$ joins the two shortest bitstrings assembled in a previous step into a bitstring of a length that is twice the Fibonacci sequence (OEIS A055389);
• and finally, the program $Q = \ast 1\dots 1$ assembles the shortest bitstring that has a length belonging to the set of Fibonacci numbers.

Thus, for $\ast = 1$, binary assembling programs, Q, assemble subsequent $2^{s_Q-1} = 2^{s_Q-2}+2^{s_Q-3}+\dots +2^0+1$ Fibonacci words and their concatenations that have entropies (3) with ratios (4)

$$p_{1,m} = \frac{F_m}{F_{m+2}}\mathrm{and}{p}_{0,m} = \frac{F_{m+1}}{F_{m+2}},$$

(21)

where $m = \{1,2,\dots s_Q\}$, and F is the Fibonacci sequence starting from 1. Ratios (21) rapidly converge to

$$\underset{s_Q\to \infty }{lim}{p}_{0,m} = \phi -1\approx 0.618033989\mathrm{and}\underset{s_Q\to \infty }{lim}{p}_{1,m} = 2-\phi \approx 0.381966011$$

(22)

where $\phi$ is the golden ratio. Therefore, ${lim}_{s_Q\to \infty }{H}_m\approx 0.9594$ is the binary entropy of the Fibonacci word limit. The Fibonacci sequence can be expressed through the golden ratio, which corresponds to the smallest Pythagorean triple $\{-3,4,5\}$ [37,38].

However, for $s_Q\ge 4$, some of the programs are no longer elegant if $\ast = 0$ and some of the assembled bitstrings are not $C_{\min }$ if $\ast = 1$.

For $s_Q\ge 4$, $Q = 111100\dots$ assembles a bitstring

$$C_{\mathrm{non}\text{-}\min }^{\left(2^{s_Q-1}\right)} = [01010010\dots ]$$

(23)

with an assembly index, $a^{\left(2^{s_Q-1}\right)} = s_Q$, which is not the minimum for this length of the bitstring. For example, the 4-bit program $Q = \ast 111$ assembles the bitstring $C^{\left(8\right)} = [0\ast 0\ast 00\ast 0]$, but if $\ast = 0$, this string can be assembled via a shorter 3-bit program, $Q = \ast 00$, and if $\ast = 1$, this string does not have the smallest assembly index, $a^{\left(8\right)}\left(C_{\min }\right) = 3$, but $a^{\left(8\right)}\left(C_{\mathrm{non}\text{-}\min }\right) = 4$.

For $s_Q = \{4,7\}$ and $s_Q\ge 10$, and for the shortest bitstring assembled via the program Q, the program Q is not elegant for $\ast = 0$, and the shortest bitstring assembled via the program is not $C_{\min }$ for $\ast = 1$.

However, the length, $s_Q$, of any program, Q, is not shorter than the assembly index of the bitstring that this program assembles. □

The trivial assembly programs, Q, and the bitstrings they assemble are listed in

Table 9. Three-bit elegant programs assembling bitstrings with $a^{\left(N\right)} = 3$.

$\mathit{Q}$	$\mathit{C} \mathbf{(}\mathit{s} = \mathbf{1}\mathbf{)}$	$\mathit{C} \mathbf{(}\mathit{s} = \mathbf{2}\mathbf{)}$	$\mathit{C} \mathbf{(}{\mathit{s}}_{\mathit{Q}} = \mathbf{3}\mathbf{)}$	$\mathit{N}$
$\ast 11$	$\ast 0$	$0\ast 0$	$\ast 00\ast 0$	5
$\ast 10$	$\ast 0$	$0\ast 0$	$0\ast 00\ast 0$	6
$\ast 01$	$\ast 0$	$\ast 0\ast 0$	$\ast 0\ast 0\ast 0$	6
$\ast 00$	$\ast 0$	$\ast 0\ast 0$	$\ast 0\ast 0\ast 0\ast 0$	8

and

Table A2. Four-bit programs assembling bitstrings with $a^{\left(N\right)} = \{3,4\}$.

Q	$\mathit{C} \mathbf{(}\mathit{s} = 3\mathbf{)}$	$\mathit{C} \mathbf{(}{\mathit{s}}_{\mathit{Q}} = 4\mathbf{)}$	N
$\ast 111$	$\ast 00\ast 0$	$0\ast 0\ast 00\ast 0$	$8{ }^{‡}$
$\ast 110$	$\ast 00\ast 0$	$\ast 00\ast 0\dots$	10
$\ast 101$	$0\ast 0\dots$	$0\ast 0\dots$	9
$\ast 100$	$0\ast 0\dots$	$0\ast 0\dots$	12
$\ast 011$	$\ast 0\dots$	$\ast 0\dots$	10
$\ast 010$	$\ast 0\dots$	$\ast 0\dots$	12
$\ast 001$	$\ast 0\dots$	$\ast 0\dots$	12
$\ast 000$	$\ast 0\dots$	$\ast 0\dots$	16

^‡. The program is not elegant if $\ast = 0$ and the assembled bitstring is not $C_{\min }$ if $\ast = 1$.

,

Table A3. Five-bit programs assembling bitstrings with $a^{\left(N\right)} = \{4,5\}$.

Q	$\mathit{C} \mathbf{(}\mathit{s} = 4\mathbf{)}$	$\mathit{C} \mathbf{(}{\mathit{s}}_{\mathit{Q}} = 5\mathbf{)}$	N
$\ast 1111$	$0\ast 0\ast 00\ast 0$	$\ast 00\ast 00\ast 0\ast 00\ast 0$	13
$\ast 1110$	$0\ast 0\ast 00\ast 0$	$0\ast 0\ast 00\ast 0\dots$	$16{ }^{‡}$
$\ast 1101$	$\ast 00\ast 0\dots$	$\ast 00\ast 0\dots$	15
$\ast 1100$	$\ast 00\ast 0\dots$	$\ast 00\ast 0\dots$	20
$\ast 1011$	$0\ast 0\dots$	$0\ast 0\dots$	15
$\ast 1010$	$0\ast 0\dots$	$0\ast 0\dots$	18
$\ast 1001$	$0\ast 0\dots$	$0\ast 0\dots$	18
$\ast 1000$	$0\ast 0\dots$	$0\ast 0\dots$	24
$\ast 0111$	$\ast 0\dots$	$\ast 0\dots$	$16{ }^{†}$
$\ast 0110$	$\ast 0\dots$	$\ast 0\dots$	20
$\ast 0101$	$\ast 0\dots$	$\ast 0\dots$	18
$\ast 0100$	$\ast 0\dots$	$\ast 0\dots$	24
$\ast 0011$	$\ast 0\dots$	$\ast 0\dots$	20
$\ast 0010$	$\ast 0\dots$	$\ast 0\dots$	24
$\ast 0001$	$\ast 0\dots$	$\ast 0\dots$	24
$\ast 0000$	$\ast 0\dots$	$\ast 0\dots$	32

^†. The program is not elegant (the same bitstring can be assembled using the shorter 4-bit program $\ast 000$). ^‡. The program is not elegant if $\ast = 0$ and the assembled bitstring is not $C_{\min }$ if $\ast = 1$.

and Table A4 (Appendix B) for one version of the assembly pool and for $1\le s_Q\le 6$.

We note in passing that there are other mathematical results on bitstrings and the Fibonacci sequence. For example, it was shown [39] that having two concentric circles with radii $\{F_n,F_{n+2}\}$ and drawing two pairs of parallel lines orthogonal to each other and tangent to the inner circle, one obtains an octagon defined by the points of intersection of those lines with the outer circle, which comes very close to the regular octagon with $n\to \infty$. Furthermore, each of these octagons defines a Sturmian binary word (a cutting sequence for lines of irrational slope), except in the case of $n = 5$ [39].

Perhaps the smallest assembly index given via Theorem 2 and the bitstrings of Theorem 3 are related to the Collatz conjecture, as the lengths of the strings (11) for $N = 2^{2k}$ correspond to the numbers to which the Collatz conjecture converges, from $N = (2^{2k}-1)/3$, $k\in \mathbb{N}$ (OEIS A002450).

Theorem 3 is also related to Gödel’s incompleteness theorems and the halting problem. N cases of the halting problem correspond only to ${log}_2\left(N\right)$, not to N bits of information [40], and therefore, complexity is more fundamental to incompleteness than self-reference of Gödel’s sentence [41]. Any formal axiomatic system only enables provable theorems to be proved. If a theorem can be proved with an automatic theorem prover, the prover will halt after proving this theorem. Thus, proving a theorem equals halting. If we assume that the axioms of the trivial program given via Definition 6 define the formal axiomatic system, then the bitstrings that have lengths expressible as a product of Fibonacci numbers assembled through this program would represent provable theorems.

If we wanted to define a binary assembling program, $Q_B$, that would use specific bitstrings other than the last one or two bitstrings in the assembly pool, we would have to index the bitstrings in the pool. However, at the beginning of the assembly process, we cannot predict in advance how many bitstrings will enter the assembly pool. Thus, we do not know how many bits will be needed to encode the indices of the strings in the pool. Therefore, we state the following conjecture.

Conjecture 2.

There is no binary assembling program (Definition 5) that has a length shorter than the length of the bitstring that has the largest assembly index that could assemble this string.

Theorem 3 would be violated if, in Definition 6, we specified the command “0”, e.g., as “take the last element from the assembly pool, join it with itself, join with what you have already assembled (say at ’the right’), and output”. Then, the 2-bit program “00” would produce the 6-bit string $\left[000000\right]$ with the assembly index $a^{\left(6\right)} = 3$. However, such a one-step command would violate the axioms of assembly theory since it would perform two assembly steps in one program step. An elegant program to output the gigabyte bitstring of all zeros would take a few bits of code and would have a low Kolmogorov complexity [42]. However, such a bitstring would be outputted, not assembled. Furthermore, the length of such a program that outputs the bitstring $[0\dots ]$ would be shorter than the length of the program that outputs the string $[10\dots ]$, while in AT, the lengths of these programs must be the same if the strings have the same assembly indices. Definitions 5 and 6 and Theorem 3 are about binputation, about bitstrings assembling other bitstrings.

In particular, Theorem 3 confirms that the assembly index is related to the amount of physical memory required to store the information to direct the assembly of an object (a bitstring in our case) and set a directionality in time from the simple to the complex [8]: $s_Q$-bit long trivial assembling programs (i.e., with $s_Q$-bits of memory) can assemble $2^{s_Q}$-bit strings with minimal assembly indices, $s_Q$ and, for $s_Q\ge 4$, some shorter but more complex bitstrings with non-minimal assembly indices $s_Q$. The memory defines the object [8].

7. Discussion and Conclusions

Consider the SARS-CoV-2 genome sequence defined by 29,903 nucleobases $\{\mathrm{A},\mathrm{C},\mathrm{G},\mathrm{T}\}$, its initial version, MN908947 (Available online at https://www.ncbi.nlm.nih.gov/nuccore/MN908947, accessed on 16 May 2024), collected in December 2019 in Wuhan and its sample, OL351370 (Available online at https://www.ncbi.nlm.nih.gov/nuccore/OL351370, accessed on 16 May 2024), collected in Egypt nearly two years after the Wuhan outbreak, on 23 October 2021. In the MN version, the nucleobases are distributed as $|\mathrm{A}| = 8954$, $|\mathrm{C}| = 5492$, $|\mathrm{G}| = 5863$, and $|\mathrm{T}| = 9594$, and in the OL version, they are distributed as $|\mathrm{A}| = 8954$, $|\mathrm{C}| = 5470$, $|\mathrm{G}| = 5856$, and $|\mathrm{T}| = 9623$, following Chargaff’s parity rules with the same count of adenines. We can convert these sequences into bitstrings by assigning two bits per nucleobase. For such N = 59,806, not being the sum of two powers of 2, with the degree of causation [6] given via Equation (14), the assembly index is bounded by

$$21\le a^{(59,806)}\left(C_k\right)⪅975.$$

(24)

If a bitstring, $C^{\left(N\right)}$, were to encode four DNA/RNA nucleobases, then the smallest assembly index bitstrings (as well as the strings generated via trivial assembly programs, Q, according to Definition 6), would not encode all nucleobases. For example, the bitstring $C_{\min }^{\left(10\right)} = \left[1001010010\right]$ with $a_{\min }^{\left(10\right)} = 4$ and encoding A = 00, C = 01, G = 10, and T = 11, cannot encode T = 11. Therefore, we increase the lower bound (24), given via Theorem 2, by one. The upper bound (24) was estimated by finding the smallest $k = 244$ that satisfies $k(k+3)\ge N$ and using the relation $a^{\left(N\right)}\left(C_{\max }\right) = 4k-1$ of Conjecture 1. We do not know the actual assembly indices of the MN and OL sequences. Their determination is an NP-complete problem, as we conjecture. However, we note a relatively wide range of 954 assembly indices that nature provides for this genome sequence.

There are twelve possible assignments of two bits per nucleobase with twelve different Hamming weights

$$\begin{array}{cc}\hfill N_1\left(C_{MN}^{\left(\mathrm{59,806}\right)}\right)& = \left\{\mathrm{25,801},\mathrm{26,172},\mathrm{26,441},\mathrm{26,812},\mathrm{29,263},\mathrm{29,532},\mathrm{30,274},\mathrm{30,543},\mathrm{32,994},\mathrm{33,365},\mathrm{33,634},\mathrm{34,005}\right\},\hfill \\ \hfill N_1\left(C_{OL}^{\left(\mathrm{59,806}\right)}\right)& = \left\{\mathrm{25,750},\mathrm{26,136},\mathrm{26,419},\mathrm{26,805},\mathrm{29,234},\mathrm{29,517},\mathrm{30,289},\mathrm{30,572},\mathrm{33,001},\mathrm{33,387},33670,34056\right\},\hfill \end{array}$$

(25)

and six different Shannon entropies (3)

$$\begin{array}{cc}\hfill H\left(C_{MN}^{\left(\mathrm{59,806}\right)}\right)& = \{0.9864,0.9887,0.9903,0.9923,0.9997,0.99989\},\hfill \\ \hfill H\left(C_{OL}^{\left(\mathrm{59,806}\right)}\right)& = \{0.9860,0.9885,0.9902,0.9922,0.9996,0.99988\}.\hfill \end{array}$$

(26)

Hamming weights (25) show that all sequences are almost balanced ($N/2$ = 29,903). However, the later OL versions are less balanced, producing lower Shannon entropies (26) and showcasing the existence of an entopic force that governs genetic mutations [25].

The bounds of Theorem 2 and Conjecture 1 are shown in Table 5 and Table 8 and are illustrated in Figure 4 and Figure 5. No bitstring can be assembled in a smaller number of steps than is given by a lower bound of Theorem 2. However, some bitstrings cannot be assembled in a smaller number of steps than given by an upper bound.

We found it much easier to determine the assembly index of a given bitstring, $C_k^{\left(N\right)}$, than to assemble a bitstring so that it would have the largest assembly index. Similarly, a trivial bitstring with the smallest assembly index for N can have the form $C_{{\min }_{1-4}}^{\left(N\right)} = [\ast ★\dots ]$ (11) or the form of a Fibonacci word generated via the trivial assembling program (Definition 6). Therefore, we state the following conjecture.

Conjecture 3.

The problem of determining the assembly index of any bitstring, $C_k^{\left(N\right)}$, is NP-complete. The problem of assembling the bitstring so that it would have the largest assembly index for a large N is NP-hard. This corresponds to determining the largest assembly index value for a large N.

A proof of Conjecture 3 would also be the proof of the following known conjecture.

Conjecture 4.

$P\ne \mathit{NP}$.

Every computable problem and every computable solution can be encoded as a finite bitstring. Here, determining whether the assembly index of a given bitstring has its known maximal value corresponds to checking the solution to a problem for correctness, whereas assembling such a bitstring corresponds to solving the problem. Thus, AT would solve the P versus NP problem in theoretical computer science. There is ample pragmatic justification for adding $\mathrm{P}\ne \mathrm{NP}$ as a new axiom [40]; rather than attempting to prove this conjecture, mathematicians should accept that it may not be provable and simply accept it as an axiom [43].

The bounds on the bitstring assembly index given via Theorem 2 and Conjecture 1, and the general bounds (1), and (2) on the assembly index [1], are illustrated in Figure 6 (adopted from [1] and modified; not to scale). The lower bound on the bitstring assembly index implies two paths of the evolution of information:

• a creative path (slanting lines in Figure 6); and
• an optimization path (vertical lines in Figure 6),

since for some bitstrings, $C_m$, of length $N>3$, it admits the possible region of their assembly steps, $a_{\min }^{\left(N\right)}\left(C_m\right)<s\le N-1$. For $1\le N\le 3$, only the creative path is available, as there is nothing to optimize: $a^{(1\le N\le 3)} = N-1$. The 2nd path becomes available already at $N = 4$, where the suboptimal number of three steps used to assemble a bitstring, $\left[0101\right]$, can be optimized to $a_{\min }^{\left(4\right)} = 2$. The evolution becomes interesting for $N\ge 7$ ($N>7$ for ringed strings, cf. Table 8), due to an upper bound on the bitstring assembly index. For each ($N\ge 7$)-bit string, $C_m$, suboptimally assembled in $a^{(N\ge 7)}\left(C_m\right)<s\le N-1$ steps, the search space is recursively explored to optimize the number of steps until the assembly index, $a^{(N\ge 7)}\left(C_m\right)$, of this bitstring is reached, where $a_{\min }^{(N\ge 7)}\le a^{(N\ge 7)}\left(C_m\right)\le a_{\max }^{(N\ge 7)}$.

We conjecture that, in general, the assembly of a novel, nontrivial bitstring, $C_m^{(N+l)}$, for $l\in \mathbb{N}$, with a longer length, $N+l$, using the 1st path of evolution is NP-hard, requires access to noncomputability and, thus, is available only to dissipative structures, including living beings, such as humans. This path represents “true” creativity. However, once this new bitstring is assembled, it is unlikely that it will be assembled optimally in s steps corresponding to its assembly index. This implies the 2nd path of minimizing the number of steps, s, required to assemble this newly found, nontrivial bitstring, $C_m^{(N+l)}$, towards its assembly index, which is only NP-complete. The bitstring $C_m^{(N+l)}$ is reassembled in a simpler way, but such a reassembly is no longer creative. The 2nd path represents “generative creativity” available both to dissipative structures and to artificial intelligence.

To illustrate this process, consider two examples: one from biological evolution (the emergence of amphibians from fish) and another from technological evolution (the invention of an airplane). The fish began to evolve around 541 million years ago, forming a plethora of fish species and exploring the available search space, optimizing the fish assembly index and increasing the information capacity within the range delimited by the same upper bound fish plateau (cf. Conjecture 1). Around 400 million years ago, some species of fish began using areas with fluctuating water levels, where occasionally water was scarce. The next amphibian plateau of a larger assembly index was within sight. Proto-lungs developed by groping [19], allowing fish to obtain oxygen from the air instead of water. The breakthrough was made, and amphibians were formed, exploring the subsequent amphibian plateau and optimizing this evolutionary gain. Many inventions led to the first airplane: the invention of the airfoil (George Cayley), its use in gliders (Otto Lilienthal), a propeller, etc. Again, the search space was well explored, and the airplane plateau of a larger assembly index was close. Finally, it was the Wright brothers, bicycle retailers who realized the importance of combining roll and yaw control in their first suboptimal Wright Flyer foreplane configuration. Once it was shown that it could be done, other people began to optimize this invention, minimizing the number of steps required to recreate it.

AT captures the notion of intelligence, understood as a degree of ability to reach the same goal through different means (assembly pathways) [44], where a fundamental aspect of intelligence is collective behavior [45]. Once the search space is saturated, the fish collectively explore it to develop lungs, just as humans, starting at least in the nineteenth century, began to think collectively about heavier-than-air flying machines. We assume that only dissipative structures can assemble novel structures of information and define living beings as dissipative structures provided with choice (the ability to select [6]) and humans as living dissipative structures provided with an abstract, modality-independent language. As shown in Figure 6, we predict a limit on complexity or a maximum assembly index, $a_H$, achievable via non-human dissipative structures. These structures do not use an abstract, modality-independent language required for advanced human creativity. A human creative work also needs a certain minimum amount of information, $N_H$. We take it for granted that, presently, only Homo sapiens has a gift of creativity that exceeds $a_H$. Any creation is required to be shaped through the unique personality of its human creator(s) to such an extent that it is statistically one-time in nature [46]; it is an imprint of the author’s personality. Subsequent plateaus of $a_{\max }^{\left(N\right)}>a_H$ can also be thought of as scientific paradigms [47] that define the basic concepts and research practices in science.

Any structure of information assembled via a dissipative structure in s steps can belong to one of the four regions shown in Figure 6:

1.	$N<N_H$ and $a_{\max }^{\left(N\right)}<s<N-1$,	suboptimally assembled via dissipative structures
		(green region),
2.	$a_{\min }^{\left(N\right)}<s<max\left(a_{\max }^{\left(N\right)},a_H\right)$,	optimally assembled via dissipative structures,
3.	$N>N_H$ and $a_H<s<a_{\max }^{\left(N\right)}$,	optimally assembled via humans, and
4.	$N>N_H$ and $a_{\max }^{\left(N\right)}<s<N-1$,	suboptimally assembled via humans (red region).

We do not exclude the possibility that non-human dissipative structures are capable of suboptimally assembling structures C above $a_H$, provided that their assembly indices satisfy $a^{\left(N\right)}\left(C\right)<a_H$. Thus, the optimization path shown in the white rectangle in Figure 6 is available only to humans.

The results reported here can be applied in the fields of cryptography, data compression methods, stream ciphers, approximation algorithms [48,49], reinforcement learning algorithms [50], information-theoretically secure algorithms, etc. Another possible application of the results of this study could be molecular physics and crystallography. Overall, the results reported here support the AT, emergent dimensionality [12,15,22,23,24,26,27,28,38], and the second law of infodynamics [25,29], and they invite further research.