Data Structures and Operations for Searching, Computing, and Indexing in DNA-Based Data Storage
Optimized data structures and functions for nucleic acid data storage enable efficient and cost-effective retrieval of large datasets by selectively accessing subsets within nucleic acid molecules, addressing the inefficiencies and errors of existing methods.
Patent Information
- Application Number
- JP2021566244
- Authority / Receiving Office
- JP · JP
- Patent Type
- Patents
- Current Assignee / Owner
- Priority Date
- 2019-08-22
- Filing Date
- 2020-05-11
- Publication Date
- 2024-11-19
- Estimated Expiration
- 2040-05-11
AI Technical Summary
Existing methods for storing and accessing data in nucleic acid molecules are error-prone, expensive, and inefficient, particularly when dealing with large datasets or infrequently accessed information, as they require de novo synthesis and sequential reading of entire molecular ensembles for basic operations like pattern queries and logical functions.
The use of optimized data structures and functions for nucleic acid-based data storage, including B-trees and triple stores, allows for efficient access and exploration of data by targeting specific subsets within nucleic acid molecules, utilizing counter arrays and Burrows-Wheeler transformations to perform high-speed operations like ranking and pattern searching without reading every molecule.
This approach enables cost-effective and time-efficient reading and accessing of nucleic acid data, allowing for parallel processing and reduced error rates by selectively targeting relevant data subsets, thus improving the efficiency and scalability of data retrieval.
Smart Images

Figure 0007586839000011 
Figure 0007586839000012 
Figure 0007586839000013
Abstract
Description
[Technical field]
[0001] CROSS-REFERENCE TO RELATED APPLICATIONS This application claims priority to and the benefit of U.S. Provisional Patent Application No. 62 / 845,638, entitled "NUCLEIC ACID-BASED DATA STORAGE: SEARCH AND COMPUTE," filed May 9, 2019, U.S. Provisional Patent Application No. 62 / 860,117, entitled "DATA STRUCTURES FOR DNA STORAGE," filed June 11, 2019, and U.S. Provisional Patent Application No. 62 / 890,243, entitled "INDEX AND SEARCH OF INFORMATION STORED IN DNA," filed August 22, 2019. The entire contents of the above-referenced applications are incorporated herein by reference. [Background technology]
[0002] Nucleic acid digital data storage is a stable method for encoding and storing information for long periods of time, and data is stored at higher densities than magnetic tape or hard drive storage systems. In addition, digital data stored in nucleic acid molecules stored in low temperature and dry conditions can be retrieved after 60,000 years or more.
[0003] One method for accessing the digital data stored in nucleic acid molecules is to sequence the nucleic acid molecules.Therefore, nucleic acid digital data storage can be an ideal method for storing data that is not frequently accessed, but may have a large amount of information to be stored or stored for a long period of time.
[0004] Existing methods of storing data in nucleic acid molecules rely on encoding digital information (e.g., binary code) into a nucleic acid sequence base by base, so that the relationship between bases in the sequence is directly converted into digital information (e.g., binary code). However, such de novo nucleic acid synthesis base by base is error-prone and expensive. Furthermore, data stored via these existing nucleic acid digital data storage methods cannot perform certain functions when the data is encoded at single-base resolution without first converting the entire molecular ensemble into digital information. For example, such functions include basic tasks that are typically performed when data is stored to disk, such as logic functions, addition, subtraction, and query lookup, including whether a particular query pattern occurs in the data set, the number of occurrences, and the location of each occurrence. Summary of the Invention [Means for solving the problem]
[0005] The present disclosure is directed to enable the search and extraction of data stored in DNA by optimized data structures and functions.Therefore, systems and methods are provided herein that perform specific functions on data stored in nucleic acid molecules.The present disclosure encompasses at least the following areas of interest: (1) data structures that provide efficient access and search to information stored in nucleic acid molecules; (2) accurate and rapid reading of information stored in nucleic acid molecules; (3) targeted approach to access subsets of information stored in nucleic acid molecules; (4) ranking functions that determine the count of specific bit or symbol values in a set of information stored in nucleic acid molecules; (5) functions that include counting, locating and extracting the occurrence of unique patterns in messages of information stored in nucleic acid molecules; and (6) if-then-else operations that classify data stored in nucleic acid molecules.
[0006] While the systems and methods described herein can be used to read any nucleic acid sequence, the present disclosure is particularly advantageous when reading, accessing, and searching information stored in nucleic acid sequences written using a specific encoding method in identifier nucleic acid molecules (also referred to herein simply as "identifiers" or "identifier molecules"). The nucleic acid sequence of each identifier molecule corresponds to a particular symbol value (e.g., one or a series of bits when only two symbol values "0" and "1" are possible, or alternatively, three or more symbol values are possible), the position (e.g., rank or address) of that symbol, or both, in a symbol string (e.g., a bit stream or symbol stream). For example, the presence or absence of an identifier molecule can convey a bit value of 1 or 0, respectively (or vice versa). An identifier nucleic acid molecule comprises a combinatorial arrangement of component nucleic acid molecules (also referred to herein simply as "components" or "component molecules"). The component nucleic acid sequences are separated into unique sets (also referred to as layers). The identifier molecule is assembled by binding together (or otherwise assembling) multiple component molecules, each component molecule having a selected sequence from each layer. In some cases, the component molecules self-assemble to form the identifier molecule. The set of possible identifier sequences corresponds to the combination of the various possible combinations of the component sequences. For example, C component sequences are separated into M layers, where c i If represents the number of component sequences in each layer of the i-th layer, then the number of possible identifier sequences that can be formed is c1 × c2 × ... × c M As an example, an encoding scheme with 12 layers, each accommodating 10 component arrays, can be represented as 10 12 This can result in different unique identifier sequences. If each identifier sequence corresponds to one bit in the bitstream, then this encoding scheme can represent 1TB of data.
[0007] One method for improving the efficiency of reading information from DNA involves using a data structure to store and indicate the location of data blocks in a data string. For example, a large data string can be stored separately in two or more containers. To determine which container contains the information a user is trying to access, the system can access a B-tree or triple store structure that holds the location (e.g., container number or arrangement). This allows the user to conveniently access the information they are looking for, rather than reading the information in each container that contains the data string.
[0008] The data structures can also store data within nucleic acid molecules in configurations that allow for fast operations such as ranking bit / symbol values and searching for unique patterns within the data. For example, the system can access a counter array that represents a running count of occurrences of bit / symbol values in a data string. This allows the system to determine the rank of the bit / symbol values without reading every single nucleic acid molecule within the system. The data can be transformed via a Burrows-Wheeler transformation or into a suffix array to store the data in a format suitable for compression that allows for efficient searching for unique patterns within the data without having to read each individual nucleic acid molecule or sequence.
[0009] In some embodiments, systems and methods are provided herein for storing digital information in a nucleic acid molecule by acquiring a plurality of blocks, each block including a symbol string and associated with a block ID. Such systems and methods provide advantages since the block ID can be used to facilitate searching for stored data by storing or implying information that characterizes the stored data or the associated nucleic acid molecule. In the systems and methods, the blocks are assigned to containers and mapped to a plurality of identifier nucleic acid sequences to be associated with the container, each identifier nucleic acid sequence including a component nucleic acid sequence, at least a portion of the component nucleic acid sequence is configured to bind to one or more probes. The systems and methods are further configured to construct individual identifier nucleic acid molecules of the plurality of identifier nucleic acid sequences, store the individual identifier molecules in the assigned container, and determine a physical address including the identity of the container and the plurality of identifier nucleic acid sequences associated with the container using the associated block ID.
[0010] For example, the block ID is an integer, a string, a triple, an attribute list, or a semantic annotation. In some implementations, the physical address is stored in a data structure designed to facilitate accessing the physical address using the associated block ID. The data structure can be one of a B-tree, a trie, or an array. At least a portion of the data structure can be stored in an index along with the digital information, the index can include a second plurality of identifier nucleic acid sequences associated with the second container. The index can be a B-tree or trie data structure having nodes, each corresponding to a distinct plurality of identifier nucleic acid sequences of the second plurality of identifier nucleic acid sequences. The distinct identifiers comprising the first node can be accessed, followed by reading values associated with those identifiers, and these steps can be repeated for subsequent nodes, and the block ID can be used to determine the identity of the distinct plurality of identifiers comprising subsequent nodes with respect to the value of the first node. The first node can be the root node of the B-tree or trie, and the process can continue until the value of the leaf node is read to indicate whether a block exists for the block ID and what the corresponding physical address is. A block ID may be a symbol string, with each node in the B-tree or trie data structure corresponding to a possible prefix of the symbol string. The leaf node itself may represent a physical address associated with the block ID that matches the symbol string specified by the leaf node.
[0011] In some implementations, the data structure is an array, and each element of the array corresponds to a separate plurality of identifier nucleic acid sequences of the second plurality of identifier nucleic acid sequences. Each element of the array can correspond to a block ID or can store a physical address of the associated block ID. In some implementations, the physical address is configured uniquely for the block ID, such that the block ID maps to a physical address without the need to store the physical address in an additional data structure. The block ID can map to a plurality of component nucleic acid sequences shared by all identifier nucleic acid sequences of the plurality of identifier nucleic acid sequences associated with the physical address. In some implementations, the plurality of identifier nucleic acid sequences associated with a block includes contiguously ordered identifier nucleic acid sequences, such that the plurality of identifier nucleic acid sequences are assigned to a corresponding physical address by an identifier range that includes the identity of the first and last identifier nucleic acid molecule in the identifier range. The first and last identifier nucleic acid sequences in the identifier range can be represented by integers.
[0012] In some implementations, the block ID is the position in the symbol string represented by the corresponding block of the parent symbol string. The parent symbol string can be represented by a data structure for counting or locating occurrences of a pattern in another symbol string. Suitable data structures include the Burrows-Wheeler transform, a suffix array, a suffix tree, and an inverted index. If the data structure is an array, each element of the array can contain separate identifiers corresponding to the block ID. Each element of the array can store the physical address of the associated block ID.
[0013] In some implementations, the physical address is accessed from a pool of identifiers including the second plurality of identifier sequences using a series of probes. The data structure can be stored in a magnetic storage device, an optical storage device, a flash memory device, or a cloud storage. The series of probes can be used to access the identifiers associated with the blocks. The probes can be PCR primers or affinity tagged oligonucleotides, using PCR or affinity pull-down assays for accessing, respectively.
[0014] In some embodiments, systems and methods are provided herein for obtaining a rank of a particular bit or symbol value at a particular position in a bit string or symbol string from digital information stored in a pool of nucleic acid molecules, each bit or symbol having a value and a position. The systems and methods involve obtaining a first pool of identifier nucleic acid molecules representing the bit string or symbol string, the pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules being configured to bind to one or more probes, and obtaining a second pool of identifier nucleic acid molecules representing a counter symbol string derived from the bit string or symbol string, each counter symbol representing a running count of a particular bit or symbol value within all w bits or symbols of the bit string or symbol string. The system and method further involves obtaining a first count by accessing a second pool with a second series of probes to target identifier nucleic acid molecules in the second pool that represent corresponding counter symbols indicating a running count of a particular bit or symbol value for at least either (1) all blocks of w bits or symbols preceding the particular position, or (2) all blocks of w bits or symbols preceding the particular position, including the block of w bits or symbols that includes the particular position. A second count is obtained by accessing the first pool with the first series of probes to target one or more distinct identifier nucleic acid molecules in the first pool that represent (1) bits or symbols preceding or including the particular position that were not counted in the first count, or (2) bits or symbols that were counted in the first count but not preceding or including the particular position. From the first count and the second count, a rank of the particular bit or symbol value at the particular position in the string is obtained.
[0015] One advantage of the rank function described herein is that it does not need to read the entire string.Instead, the rank function uses selective access operation to read the subset of nucleic acid molecules that provide unique counts.In this way, the rank operation described herein is performed more time-efficiently and cost-effectively compared to brute force operation that requires the complete reading of all stored nucleic acid molecules.
[0016] The identifier can be formed by physically assembling M selected component nucleic acid molecules, each of the M selected component nucleic acid molecules selected from a set of distinct component nucleic acid molecules separated into M different layers.
[0017] In some implementations, when the first count represents all blocks of w bits preceding a particular bit, the first series of probes in the second count target one or more distinct identifier nucleic acid molecules in the first pool that represent bits not counted in the first count that precede or include the particular bit, and the rank of the particular bit in the bit string is obtained by summing the first and second counts. In some implementations, when the first count in the first count represents all blocks of w bits preceding a particular bit, including a block of w bits that includes the particular bit, the first series of probes target one or more distinct identifier nucleic acid molecules in the first pool that represent bits counted in the first count but that do not precede or include the particular bit, and the rank of the particular bit in the bit string is obtained by subtracting the second count from the first count.
[0018] In some implementations, the first pool is the second pool, or the first pool and the second pool are separate. The first and second counts can be obtained by reading the targeted identifier molecules from the second and first pools, respectively. For the first count, a counter symbol value corresponding to the targeted identifier can be read or determined. A block of w bits or symbols in the string can be mapped to a block of contiguously ordered identifier nucleic acid molecules in the first pool. For example, the presence or absence of an identifier molecule in the first pool does not directly correlate to a particular value in the string. A fixed length substring (word) of the string can be mapped to a codeword that includes a fixed number of unique identifier nucleic acid molecules from a fixed number of possible unique identifier nucleic acid molecules. Additional information stored in the identifier can be used to detect and correct errors in writing, accessing, and reading the identifier.
[0019] Each counter symbol can be represented by a string of b counter bits. In some implementations, the string has a length of n bits or symbols, where b is an upper limit of log2(n+1). The counter symbol string can include an upper limit of n divided by w counter symbols, and is represented by a counter bit string having a length corresponding to b multiplied by the upper limit of n divided by w. In some implementations, if a particular bit or symbol is within the first block of w bits or symbols, the running count preceding the first block of w bits is 0. The value of w can be set to the value of b or 1. For example, the first count is obtained by targeting identifier nucleic acid molecules in the second pool that represent counter symbols corresponding to the block of w bits or symbols that includes the particular bit or symbol, and the rank is equal to the first count. In this example, there is no need to obtain a final second count.
[0020] In some implementations, if a particular bit is not in the first block of w bits or symbols, the counter symbols of all blocks of w bits or symbols preceding the particular bit or symbol represent the number of bits or symbols in the string that have a particular value within a position range of 0 to w*B(x)-1, where 0 is the first position of the string, x corresponds to the position of the particular bit or symbol in the string, and B(x) is the lower bound of x divided by w. For example, the targeted identifier nucleic acid molecules in the second pool for the first count are within a range defined by positions b*B(x) and b*(B(x)+1)-1, where position 0 corresponds to the first position in the string. The second count can correspond to the number of bits or symbols in the string that have a particular value within a position range w*B(x)~x, where x corresponds to the position of the particular bit or symbol in the string, position 0 is the first position, and B(x) is the lower bound of x divided by w.
[0021] In some implementations where the string is a bit string, the identifier nucleic acid molecules in the first pool represent the bit string, such that the presence of the identifier represents a bit value of "1" at the bit position. The bit string can represent a symbol string, and a rank is obtained for a particular symbol in the symbol string.
[0022] In some implementations where the string is a symbol string, the presence of a corresponding identifier nucleic acid molecule in the first pool indicates a first symbol value, and the absence of a corresponding identifier nucleic acid molecule in the first pool indicates a second symbol value. The symbol value can be selected from a set of symbol values (e.g., an alphabet), and the counter symbol string indicates a running count of the number of symbols having a particular symbol value. The symbol string can represent a bit string. For example, each symbol in the string corresponds to a fixed number of bits. In some implementations, different second pools of identifier nucleic acid molecules represent different counter symbol strings that count the number of instances of a unique symbol value, and each different counter symbol string counts the instances of a corresponding unique symbol value.
[0023] In some embodiments, systems and methods are provided herein for fetching digital information from a pool of nucleic acid molecules. The systems and methods involve obtaining a first pool of identifier nucleic acid molecules, the pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules being configured to bind to one or more probes, the identifier nucleic acid molecules representing symbol strings, and thus a symbol value being indicated by the presence or absence of a corresponding identifier nucleic acid molecule in the first pool. The first pool is accessed by a first series of probes to create a second pool having a subset of identifier nucleic acid molecules from the first pool, each of the first series of probes targeting at least one of the component nucleic acid molecules. The sequences of the subset of identifier nucleic acid molecules from the second pool are read, and the sequences are used to obtain at least a subset of the symbols in the symbol string.
[0024] Each identifier nucleic acid molecule includes a separate component nucleic acid molecule having a component nucleic acid sequence from each of the M layers, each layer including a set of component nucleic acid sequences. The M layers can be logically ordered, and the component nucleic acid sequences of each layer can be logically ordered. In some implementations, the identifier nucleic acid molecule corresponds to the logically ordered identifier nucleic acid sequences by sorting the identifier nucleic acid sequences by the corresponding component nucleic acid sequences in a first layer, subdividing the identifier nucleic acid sequences by the corresponding component nucleic acid sequences in a second layer, and repeating the subdivision process for each of the remaining M-2 layers. Each identifier sequence can include a series of component nucleic acid sequences represented as a path in a query tree, where the query tree starts at a root node, branches across M instances with one instance in each layer, and terminates at a leaf node, each leaf node representing an identifier nucleic acid sequence. Thus, the first series of probes can correspond to a partial or full path from the root node in the query tree. A full path can correspond to a root-to-leaf path that includes M probes, such that the set of probes targets a single identifier nucleic acid molecule, and a partial path can correspond to fewer than M probes, such that the set of probes targets multiple populations of identifier nucleic acid molecules with different sequences. The multiple populations of identifier nucleic acid molecules with different sequences can correspond to different component nucleic acid molecules in at least the Mth layer.
[0025] In some implementations, the first pool is accessed by a plurality of series of probes. For example, the system and method performs splitting the first pool into at least two replicate pools and performing the steps of the method on each of the replicate pools with each of the series of probes. The first pool can be replicated (e.g., via PCR) before splitting into at least two replicate pools. In some implementations, the first pool of identifier nucleic acid molecules with a subseries of probes is accessed to create an intermediate pool of identifier nucleic acid molecules. The intermediate pool with a subsequent subseries of probes can be accessed to form a second intermediate pool of identifier nucleic acid molecules or a second pool of identifier nucleic acid molecules. The at least two intermediate pools can be combined to form another intermediate pool or a second pool. The probes can be PCR primers (in the case of access via PCR) or affinity tagged oligonucleotides (in the case of access via affinity pull-down assay).
[0026] In some aspects, systems and methods are provided herein for obtaining a count of a particular bit pattern of length p in a message comprising a bit string of length n. The systems and methods obtain a first pool of identifier nucleic acid molecules representing a bit string L, the bit string L being the last column of a Burrows-Wheeler transformation matrix of the message, the first pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecule being configured to bind to one or more probes. A second pool of identifier nucleic acid molecules representing a counter symbol string derived from the bit string L is obtained, each counter symbol being represented by a string of b counter bits indicating a running count of the number of bits for all w bits in the bit string L having a unique bit value "1". A series of probes are used to access identifier nucleic acid molecules from the second pool representing counter symbols for a total number of occurrences of the bit value "1" in the bit string L. The identifier nucleic acid molecules accessed from the second pool are read to count the total number of occurrences of the bit value "1" in the bit string L. The total number of occurrences of each bit value is for reconstructing the first column F of the Burrows-Wheeler transform matrix for the message. A first position h and a last position z, inclusive, that define a range of pth bit values in the first column F are determined. A first series of probes is used to access identifier nucleic acid molecules from the first pool and the second pool to determine the rank r of the pth bit value of the pattern at position h-1 in L. h-1 , where i=1. Using a second set of probes, access identifier nucleic acid molecules from the first pool and the second pool to calculate the rank r of the pi-th bit value of the pattern at position z in L. z Calculate.
[0027] r h-1 is z , then the count of occurrences of the pattern in the message is set to 0. Otherwise, r h-1 isz , then h is the (r)th bit of the (pi)th bit value in F. h-1 +1), z is set to the index of the rth instance of the (pi)th bit value in F. z p is set to the index of the instance of p. A loop counter i is incremented by 1 and the accessing and indexing steps are repeated multiple times until i=p-1. The count of occurrences of the pattern in the message is counted as z-h+1. At least one advantage provided by the present technique is that a search can be performed across a large data set without reading every single bit in the data set; instead, the present disclosure logically locates occurrences of the pattern via selective access and rank operations. Another advantage provided herein is that the access and rank operations can be performed in parallel on the first and second pools to minimize execution time and increase throughput.
[0028] The first pool can be the same as the second pool or can be separate from the second pool. In some implementations, a third pool of identifier nucleic acid molecules is obtained that represents a suffix array derived from a Burrows-Wheeler transform of the message, where each element of the suffix array is represented by a bit string of at least log2(n) bits that indicates the location of the corresponding element of L in the message. The system and method can further locate the occurrence of the pattern in the message by accessing identifier nucleic acid molecules in the third pool that correspond to elements in the suffix array at locations between h and z that include the final values for h and z when the count is greater than 0. In some implementations, a fourth pool of identifier nucleic acid molecules that represent the message is obtained. The system and method can further extract the context of the first location of the pattern by accessing identifier nucleic acid molecules in the fourth pool that correspond to a neighborhood of the first location and locations surrounding the first location.
[0029] In some implementations, the presence of a corresponding identifier nucleic acid molecule in the first pool indicates a bit value of 1, and the absence of a corresponding identifier nucleic acid molecule in the first pool indicates a bit value of 0. b can be equal to an upper limit of log2(n+1). The counter symbol string can include an upper limit of n divided by w counter symbols and is represented by a counter bit string having a length corresponding to b multiplied by the upper limit of n divided by w. A running count of any bit value preceding the first block of w bits in L is 0. w can be set to the value of b or 1. The system and method can map blocks of bits in the bit string L to blocks of contiguously ordered identifier nucleic acid molecules in the first pool. Fixed length substrings of the bit string L can be mapped to code words represented by a fixed number of unique identifier nucleic acid molecules selected from a fixed size set of unique identifier nucleic acid molecules. Additional information can be used to detect and correct errors in writing, accessing, and reading identifier nucleic acid molecules from the first and second pools, and the additional information can be stored in the identifier.
[0030] In some aspects, systems and methods are provided herein for obtaining a count of a particular bit pattern of length p in a message. The systems and methods obtain a first pool of identifier nucleic acid molecules representing a bit string L, where the bit string L is the last column of a Burrows-Wheeler transformation matrix of the message, the first pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecule being configured to bind to one or more probes. A second pool of identifier nucleic acid molecules is obtained representing a counter symbol string derived from the bit string L, which represents a running count of the number of bits having a unique bit value. The count of a particular bit pattern in the message is obtained by selectively accessing identifier nucleic acid molecules from the first pool and the second pool. At least one advantage provided by this technique is that a search can be performed across a large data set without reading every single bit in the data set; instead, the technique involves logically locating occurrences of a pattern via selective access. Another advantage provided herein is that access operations can be performed in parallel on the first and second pools to minimize execution time and increase throughput.
[0031] In some aspects, a symbol string of length p sProvided herein are systems and methods for obtaining a count of a particular symbol pattern of L, where each symbol is selected from a set of r symbol values. The systems and methods obtain a first pool of identifier nucleic acid molecules representing a symbol string L that is a last column of a Burrows-Wheeler transformation matrix for a message, the first pool having a powder, liquid, or solid form, and each identifier nucleic acid molecule in the first pool comprises a component nucleic acid molecule, at least a portion of the component nucleic acid molecule configured to bind to one or more probes. The systems and methods further obtain r second pools of identifier nucleic acid molecules, each of the r second pools representing a counter symbol string C derived from L. v where v=1, 2, ..., r corresponds to the corresponding symbol value R v represents a running count of the number of symbols in L having length p s At least one advantage provided by this technique is that a search can be performed across a large data set without reading every single bit in the data set, instead the technique logically locates occurrences of the pattern through selective access. Another advantage provided herein is that the access operations can be performed in parallel on the first and second pools to minimize execution time and increase throughput.
[0032] In some implementations, the technique involves reconstructing the first column F of the Burrows-Wheeler transformation matrix. Using a series of probes, each corresponding symbol value in L, R v From the last counter symbol in each of the r second pools, which represents the total number of occurrences of vThe total number of occurrences of can be used to reconstruct F. A range of positions in F having the pth symbol value in the pattern can be determined. In some implementations, the approach includes using a series of probes to access identifier nucleic acid molecules from the first pool and the corresponding second pool to determine a first rank of corresponding symbol values in L at positions immediately preceding the range and a second rank of corresponding symbol values in L at positions at the ends of the range, and using the first and second ranks to update the range to a range of positions in F having an instance of the corresponding symbol preceding the subsequent symbol in the pattern.
[0033] In some implementations, the first rank r h-1 is the value of each preceding symbol in the pattern at position h-1 in L, and the second rank r z is the value of each preceding symbol in the pattern at position z in L. A count of occurrences of the pattern in the message can be determined based on the final values of the first and second ranks. For example, the count is the difference between the final values of the first and second ranks. If the first and second ranks are determined to be equal, the count can be set to 0.
[0034] In some implementations, the approach includes obtaining a pool of identifier nucleic acid molecules, the SA pool, representing a suffix array SA derived from a Burrows-Wheeler transform of the message, where each element of SA is represented by a bit string of at least log2(n) bits indicating the position of the corresponding element of L in the message. The method and system can locate an occurrence of a pattern in the message by accessing an identifier nucleic acid molecule in the SA pool that corresponds to an element of SA at a position given by a final range of positions in F, assuming the count is greater than 0. The approach can include obtaining a message pool of identifiers representing the message, allowing extraction of a context of a first location of the pattern by accessing identifier nucleic acid molecules in the message pool that correspond to said first location and a neighborhood of positions surrounding the first location.
[0035] In some implementations, the first pool of identifier nucleic acid molecules is one of r first pools, each of the r first pools being a bit string L v where v=1, 2, ..., r, and so L v The elements of are symbolic values R v For elements of L that match L, the bit value is "1" and otherwise the bit value is "0", or vice versa. For example, v The first pool corresponds to the symbol value R in the pattern. v is used to determine the first and second ranks of
[0036] In some aspects, systems and methods are provided herein that operate on digital information stored in nucleic acid molecules. The systems and methods obtain a first pool of identifier nucleic acid molecules, the pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool includes a component nucleic acid molecule, at least a portion of the component nucleic acid molecule is configured to bind to one or more probes, and the identifier nucleic acid molecule represents an input symbol string. An if-then-else operation is performed on the identifier nucleic acid molecules in the first pool, the if-then-else operation targets at least one of the component nucleic acid molecules with a probe, creating an intermediate pool having a subset of identifier nucleic acid molecules from the first pool. The if-then-else operation is repeated, with the intermediate pool replacing the first pool in all subsequent steps until a final pool of identifier nucleic acid molecules representing at least a portion of the output symbol string is created.
[0037] Using this technique, it is possible to write conditional programs. For example, each "if" operation tests for the presence or absence of one or more identifiers and proceeds to the "then" or "else" branch depending on their presence. The operation can contain multiple conditions and corresponding branches. An output can be produced from every branch of the operation. This technique allows parallel operation of all identifiers in multiple identifier libraries (e.g., at the terabit scale). For example, if a library encodes billions of data objects, a complex function that examines each object and produces an output can be designed as a DNA-based program and run on the library in parallel.
[0038] The present disclosure includes a strategy of shifting, copying, and moving bits to rearrange the identifier library into multiple input identifier libraries for the execution of a desired program. Physically, each if-then-else operation can be performed in a reaction that converts one input library into two output libraries, and multiplexed across all identifiers in those libraries. The output library of one operation can be directed to the input library of another operation, for example by fluid communication. Unlike conventional hardware that is limited by RAM and processing power, the DNA platform described herein is capable of executing programs simultaneously and with low power across a large number of input data objects.
[0039] The identifier can include a separate component from each of the M layers, with each layer including a set of components. The probe can be a PCR primer or an affinity tagged oligonucleotide, whereby the access is performed via PCR or affinity pull-down assay, respectively. In some implementations, the if-then-else operation includes accessing the identifier nucleic acid molecule in a pool that includes the unique component nucleic acid molecule. The operation can include splitting or replicating (e.g., via PCR) at least one of the first pool, the intermediate pool, or the final pool into at least two replicate pools, and combining the at least two intermediate pools to form a new intermediate pool or a second pool, or both. Two or more if-then-else operations can be performed in parallel on one or more pools.
[0040] In some embodiments, provided herein is a system configured to perform any of the methods described herein. The system can be a printer finisher system configured to dispense DNA components to individual locations (e.g., reaction compartments) on a substrate, dispense reagents that provide optimal conditions for the binding reaction, and pool all of the DNA identifiers that comprise the library. The system can store and manipulate nucleic acid molecules in containers (e.g., via automated liquid handling). The system can dispense probes into the compartments or containers to access a subset of the nucleic acid molecules. The system can be configured to aliquot and replicate the pool of nucleic acid molecules.
[0041] In some aspects, provided herein is a composition comprising a nucleic acid molecule representing digital information according to any of the methods described herein. The composition comprises an identifier nucleic acid molecule comprising a component nucleic acid molecule. The identifier nucleic acid molecules can be collected into a pool and mapped to digital information. For example, the presence of the identifier indicates a particular bit or symbol value in a symbol string, and the absence of the identifier indicates a different bit or symbol value in the symbol string.
[0042] The above and other features of the present disclosure, including the nature of the disclosure and various advantages thereof, will become more apparent from the consideration of the following detailed description taken in conjunction with the accompanying drawings. [Brief description of the drawings]
[0043] [Figure 1] FIG. 1 is a schematic diagram outlining a process for encoding, writing, accessing, querying, reading, and decoding digital information stored in nucleic acid sequences.
[0044] [Diagram 2]2A and 2B are schematic diagrams illustrating exemplary methods of using objects or identifiers (e.g., nucleic acid molecules) to encode digital data referred to as "data-at-addresses," where FIG. 2A illustrates combining a rank object (or address object) with a byte value object (or data object) to create an identifier, and FIG. 2B illustrates an implementation of the data-at-address method in which the rank objects and byte value objects are themselves combinatorial concatenations of other objects.
[0045] [Diagram 3] 3A and 3B are schematic diagrams illustrating exemplary methods for encoding digital information using objects or identifiers (e.g., nucleic acid sequences), where FIG. 3A illustrates encoding digital information using a rank object as an identifier and FIG. 3B illustrates an implementation of the encoding method in which the address object is itself a combinatorial concatenation of other objects.
[0046] [Figure 4] FIG. 4 shows a logarithmic space contour plot of the relationship between the combinatorial space of possible identifiers (C, x-axis) and the average number of identifiers (k, y-axis) that can be constructed to store information of a given size (contour).
[0047] [Diagram 5] FIG. 5 is a schematic diagram outlining a method for writing information into a nucleic acid sequence (eg, deoxyribonucleic acid).
[0048] [Figure 6] 6A and 6B are diagrams illustrating an exemplary method, referred to as the "product method," for constructing identifiers (e.g., nucleic acid molecules) by combinatorially assembling separate components (e.g., nucleic acid sequences); FIG. 6A shows the architecture of an identifier constructed using the product method, and FIG. 6B shows an example of the combinatorial space of identifiers that can be constructed using the product method.
[0049] [Figure 7] FIG. 7 is a schematic diagram illustrating the use of overlap extension polymerase chain reaction to construct identifiers (eg, nucleic acid molecules) from components (eg, nucleic acid sequences).
[0050] [Figure 8] FIG. 8 is a schematic diagram illustrating the use of cohesive end joining to construct an identifier (eg, a nucleic acid molecule) from a component (eg, a nucleic acid sequence).
[0051] [Figure 9] FIG. 9 is a schematic diagram illustrating the use of recombinase assembly to construct identifiers (eg, nucleic acid molecules) from components (eg, nucleic acid sequences).
[0052] [Figure 10A] 10A and 10B are diagrams demonstrating template-directed binding, where FIG. 10A is a schematic diagram illustrating the use of template-directed binding to construct identifiers (e.g., nucleic acid molecules) from components (e.g., nucleic acid sequences) and FIG. 10B shows a histogram of copy numbers (abundance) of 256 distinct nucleic acid sequences each assembled combinatorially from six nucleic acid sequences (e.g., components) in one pooled template-directed binding reaction. [Figure 10B] 10A and 10B are diagrams demonstrating template-directed binding, where FIG. 10A is a schematic diagram illustrating the use of template-directed binding to construct identifiers (e.g., nucleic acid molecules) from components (e.g., nucleic acid sequences) and FIG. 10B shows a histogram of copy numbers (abundance) of 256 distinct nucleic acid sequences each assembled combinatorially from six nucleic acid sequences (e.g., components) in one pooled template-directed binding reaction.
[0053] [Figure 11] FIG. 11 is a diagram of dispensing a solution into a compartment by means of an identifier trie.
[0054] [Figure 12]FIG. 12 is a system diagram of an operating system organized by layers.
[0055] [Figure 13] FIG. 13 is a system diagram of a layered product constructor with three layers and an ingredient library of eight ingredients.
[0056] [Figure 14] FIG. 14 is a system diagram of archive calculation.
[0057] [Figure 15] FIG. 15 is a flow diagram of the storage of a block of data into a container.
[0058] [Figure 16] FIG. 16 is a diagram showing the Burrows-Wheeler transform of a string.
[0059] [Figure 17] FIG. 17 shows a suffix array for the Burrows-Wheeler matrix.
[0060] [Figure 18] FIG. 18 is a diagrammatic example of the Burrows-Wheeler transform stored in a nucleic acid.
[0061] [Figure 19] FIG. 19 is a diagrammatic example of a counter array stored in a nucleic acid.
[0062] [Figure 20] FIG. 20 is an example diagram of a query tree.
[0063] [Figure 21] FIG. 21 is a diagram illustrating an example of decomposition of contiguous ranges of identifiers in a binary tree.
[0064] [Figure 22]FIG. 22 is a diagrammatic example of the transformation of a query tree into a query oriented acyclic graph.
[0065] [Figure 23] FIG. 23 is a diagrammatic example of performing the rank operation on a binary string.
[0066] [Figure 24] FIG. 24 is a flow diagram for the implementation of the rank operation.
[0067] [Diagram 25] FIG. 25 is a flow diagram for performing a fetch operation.
[0068] [Figure 26] FIG. 26 is a flow diagram for performing a count operation on a binary string.
[0069] [Figure 27] FIG. 27 is a flow diagram for a count operation on a binary string.
[0070] [Figure 28] FIG. 28 is a flow diagram for the execution of the steps of the method of FIG.
[0071] [Figure 29] FIG. 29 is a flow diagram for performing a count operation on an arbitrary string.
[0072] [Diagram 30] FIG. 30 is a flow diagram for LF mapping.
[0073] [Diagram 31] FIG. 31 is a flow diagram for the reconstruction of a string from the Burrows-Wheeler transform.
[0074] [Diagram 32] FIG. 32 is a flow diagram for the counting operation.
[0075] [Diagram 33] FIG. 33 is a flow diagram for an if-then-else operation. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0076] In order to provide a general understanding of the assemblies and methods described herein, certain exemplary implementations are described. Although the implementations and features described herein are specifically described with respect to data storage in identifier nucleic acid molecules composed of component nucleic acid molecules, it will be understood that all aspects and other features outlined below can be combined with each other in any suitable manner and can also be adapted and applied to other forms of DNA-based data storage.
[0077] Base-by-base synthesis of nucleic acids to encode digital information can be expensive and time-consuming, as it generally requires de novo base-by-base synthesis (e.g., phosphoramidite synthesis) of a separate nucleic acid sequence for every new information storage request. The present disclosure relates to systems and methods that do not rely on base-by-base or de novo synthesis, but instead encode digital information into multiple identifiers or nucleic acid sequences that include combinatorial arrangements of components (or component nucleic acid sequences). In this way, the systems and methods of the present disclosure improve the efficiency and commercial viability of digital information storage.
[0078] This disclosure describes methods that allow for the creation of a first set of distinct nucleic acid sequences (or components) for a first information storage request, and then reusing the same nucleic acid sequences (or components) for subsequent information storage requests. These approaches significantly reduce the cost of DNA-based information storage by reducing the role of de novo synthesis of nucleic acid sequences in the process of encoding and writing information to DNA.
[0079] Furthermore, unlike base-by-base synthesis implementations such as phosphoramidite chemistry or template-free polymerase-based nucleic acid extension, which use cyclic delivery of each base to each extended nucleic acid, the disclosed systems and methods for writing information to DNA using identifier structures from components are highly parallelizable processes and do not necessarily use cyclic nucleic acid extension. Thus, the present disclosure increases the speed at which digital information can be written to DNA when compared to other methods. Various systems and methods for writing digital information to nucleic acid molecules are described in U.S. Pat. No. 10,650,312, filed Dec. 21, 2017, entitled "NUCLEIC ACID-BASED DATA STORAGE," which describes encoding of digital information in DNA; U.S. patent application Ser. No. 16 / 461,774, filed May 16, 2019, and published as U.S. Patent Application Publication No. 2019 / 0362814, entitled "SYSTEMS FOR NUCLEIC ACID-BASED DATA STORAGE," which describes encoding methods for DNA-based data storage; U.S. patent application Ser. No. 16 / 414,758, filed May 16, 2019, entitled "COMPOSITIONS AND METHODS FOR NUCLEIC ACID-BASED DATA STORAGE," which describes encoding methods for DNA-based data storage; and U.S. patent application Ser. No. 16 / 414,758, filed May 16, 2019, entitled "COMPOSITIONS AND METHODS FOR NUCLEIC ACID-BASED DATA STORAGE," which describes encoding methods for DNA-based data storage; and U.S. patent application Ser. No. 16 / 414,758, filed May 5, 2019, entitled "SYSTEMS AND METHODS FOR STORING AND READING No. 16 / 532,077, entitled "NUCLEIC ACID-BASED DATA WITH ERROR PROTECTION," which describes data structures for DNA encoding and error protection and correction.
[0080] The following description begins with an overview of various systems and methods for encoding data in nucleic acid molecules, and then describes various writing and storage systems configured to print and store nucleic acid molecules encoding digital data, as described in connection with Figures 1-10. The disclosure then describes various encoding methods in connection with Figures 11-14. The disclosure relates to improvements in the methods for writing and reading digital information in nucleic acid molecules that are described in the above-referenced patent applications. In particular, the use of data structures to represent digital information can improve the efficiency of reading information from DNA by defining unique properties of the digital information and organizing those properties to facilitate access in DNA.
[0081] As an example, a large data string is separated into two or more substrings, each substring is stored in a separate pool of nucleic acid molecules, and the pool is placed into its own container. One way to determine which container contains the desired information is to access a data structure (such as, for example, a B-tree or trie structure) that identifies the location (e.g., container number or arrangement). By using the data structure to reference which containers are relevant, a user can access only the containers that contain the desired information, rather than reading the information in each container one by one and then determining whether the information is relevant. This improves the efficiency of accessing relevant information in data strings in nucleic acid molecules.
[0082] As an extension of the above example, the relevant information that a user wishes to access can be represented or computable from only a subset of the nucleic acid molecules in a pool of containers. In this case, the present disclosure provides a method to access only a unique subset of the relevant molecules without having to access all of the information stored in the entire pool of nucleic acid molecules. Doing so should increase efficiency and reduce costs. One method to access only a desired subset of the nucleic acid molecules in a pool is to reference a data structure (such as, for example, a B-tree or trie structure) that stores information that can be used to target a unique subset of the nucleic acid molecules in the pool. Examples of specific data structures that can be used to access and search for unique subsets of nucleic acid molecules in a pool (or across different pools in different containers) are described in connection with Figures 15-19. Additionally, the present disclosure relates to systems and methods that rely on data structures to efficiently perform certain operations on data stored in nucleic acid molecules, such as search, locate, and extract functions. In particular, exemplary systems and methods that rely on one or more data structures to access unique data portions stored in nucleic acid molecules and perform operations such as reading, accessing, and ranking are described in connection with Figures 20-25, and systems and methods that rely on one or more data structures to access unique data portions stored in nucleic acid molecules and perform operations such as searching, locating, and extracting unique patterns or queries from data stored in nucleic acid molecules are described in connection with Figures 26-32. Finally, logical if-then-else operations are described in connection with Figure 33.
[0083] In general, the present disclosure encodes data (represented by a string of 1 or 0 bits, or a symbol string, where each symbol is selected from a set of three or more symbol values) into a set of identifier nucleic acid sequences (or identifier sequences), with each unique identifier sequence having a corresponding bit or symbol in the string. The identifier sequence encodes the position of the bit or symbol in the string, its value, or both the position and value. One way to implement the systems and methods of the present disclosure is to create each identifier nucleic acid molecule (or identifier molecule) represented by an identifier sequence by combining pre-made DNA component molecules (represented by component sequences) in an ordered manner based on defined layers, as discussed in connection with FIGS. 1-11. Specifically, component sequences in different layers are combinatorially combined across layers (e.g., one component sequence is selected for each layer) and concatenated (e.g., joined) to form an identifier sequence that is one-to-one mapped to each symbol or bit in the string.
[0084] Generally, the component nucleic acid sequences are configured to bind to one or more probes that can be used to select for all identifiers that contain said sequence. For example, the component can include a target sequence of 20 bases, and the probe can include a complementary 20-base oligonucleotide to bind to the target sequence. As described in this disclosure, the composition of the identifier nucleic acid sequence from components that can each bind to a unique probe provides beneficial features for accessing and operating on the stored data. Although the methods of generating identifiers presented herein are specifically configured to generate identifiers that contain components, it should be understood that such identifier nucleic acid molecules can also be formed by multiple alternative methods. For example, an identifier nucleic acid sequence can be created that includes five components, each of which is 20 bases long, using de novo synthesis to generate a nucleic acid sequence 100 bases in length. If all combinations of bases are available for synthesis, up to four components can be generated. 20 The possible sequences can be obtained.
[0085] As used herein, the term "symbol" generally refers to a representation of a unit of digital information. Digital information can be divided or converted into symbol strings. In one example, a symbol can be a bit, and a bit can have a value of "0" or "1."
[0086] As used herein, the terms "distinct" or "unique" generally refer to an entity that is distinguishable from other entities in a group. For example, a distinct or unique nucleic acid sequence can be a nucleic acid sequence that does not have the same sequence as any other nucleic acid sequence. A distinct or unique nucleic acid molecule does not have the same sequence as any other nucleic acid molecule. A distinct or unique nucleic acid sequence or molecule can share regions of similarity with another nucleic acid sequence or molecule.
[0087] As used herein, the term "component" generally refers to a nucleic acid sequence or a nucleic acid molecule. A component can comprise a separate nucleic acid sequence. A component can be linked or assembled with one or more other components to produce other nucleic acid sequences or molecules.
[0088] As used herein, the term "stratum" generally refers to a group or pool of components. Each stratum can contain a distinct set of components, such that the components in one stratum are different from the components in another stratum. Components from one or more stratums can be assembled to generate one or more identifiers.
[0089] As used herein, the term "identifier" generally refers to a nucleic acid molecule or sequence that represents the position and value of a bit string within a larger bit string. More generally, an identifier can refer to any entity that represents or corresponds to a symbol within a symbol string. In some implementations, an identifier can include one or more concatenated components.
[0090] As used herein, the term "combinatorial space" generally refers to the set of all possible distinct identifiers that can be generated from a starting set of entities, such as components, and a set of allowable rules for how to modify those entities to form identifiers. The size of the combinatorial space of identifiers created by assembling or linking components can depend on the number of layers of components, the number of components in each layer, and the particular assembly method used to generate the identifiers.
[0091] As used herein, the term "identifier rank" generally refers to a relationship that defines the ordering of identifiers within a set.
[0092] As used herein, the term "identifier library" generally refers to a collection of identifiers that correspond to symbols in a symbol string representing digital information. In some implementations, the absence of a given identifier in an identifier library can indicate a symbol value at a particular location. One or more identifier libraries can be combined into pools, groups, or sets of identifiers. Each identifier library can include a unique barcode that identifies the identifier library.
[0093] As used herein, the term "probe" generally refers to an agent that binds to a target sequence on an identifier nucleic acid molecule. The target sequence can be a portion of the moiety. The probe can include a sequence that matches or is complementary to its target sequence. The probe can further be used to separate all identifier nucleic acid molecules that contain said target sequence. For example, the probe can be a primer in a PCR reaction that amplifies all identifier nucleic acid molecules that contain the target sequence. Alternatively, the probe can contain an affinity tagged oligonucleotide molecule that can be used to select all identifier nucleic acid molecules that have a sequence that corresponds to said oligonucleotide.
[0094] As used herein, the term "nucleic acid" generally refers to deoxyribonucleic acid (DNA), ribonucleic acid (RNA), or variants thereof. Nucleic acids may include one or more subunits selected from adenosine (A), cytosine (C), guanine (G), thymine (T), and uracil (U), or variants thereof. Nucleosides may include A, C, G, T, or U, or variants thereof. Nucleosides may include subunits that can be incorporated into a growing nucleic acid chain. Such subunits may be unique to one of the more complementary A, C, G, T, or U, or may be A, C, G, T, or U, or other subunits that may be complementary to a purine (i.e., A or G, or variants thereof) or pyrimidine (i.e., C, T, or U, or variants thereof). In some instances, nucleic acids may be single-stranded or double-stranded, and in some cases, nucleic acids are circular.
[0095] As used herein, the term "nucleic acid molecule" or "nucleic acid sequence" generally refers to a polymeric form of nucleosides or polynucleosides, deoxyribonucleosides (DNA) or ribonucleosides (RNA), which may have various lengths, or analogs thereof. The term "nucleic acid sequence" refers to an alphabetic representation of a polynucleoside that defines the order of the nucleosides, and the term "nucleic acid molecule" refers to the physical instance of the polynucleoside itself. This alphabetic representation can be entered into a database in a computer having a central processing unit and can be used to map the nucleic acid sequence or nucleic acid molecule to symbols or bits to encode digital information. A nucleic acid sequence or oligonucleotide can include one or more non-standard nucleosides, nucleoside analogs, and / or modified nucleosides.
[0096] As used herein, "oligonucleotide" generally refers to a single-stranded nucleic acid sequence, typically composed of a specific sequence of the four nucleoside bases adenine (A), cytosine (C), guanine (G), and thymine (T), or, when the polynucleoside is RNA, uracil (U).
[0097] Examples of modified nucleosides include, but are not limited to, diaminopurine, 5-fluorouracil, 5-bromouracil, 5-chlorouracil, 5-iodouracil, hypoxanthine, xanthine, 4-acetylcytosine, 5-(carboxyhydroxymethyl)uracil, 5-carboxymethylaminomethyl-2-thiourazine, 5-carboxymethylaminomethyluracil, dihydrouracil, beta-D-galactosylqueosine, inosine, N6-isopentenyladenine, 1-methylguanine, 1-methylinosine, 2,2-dimethylguanine, 2-methyladenine, 2-methylguanine, 3-methylcytosine, 5-methylcytosine, N6-adenine, 7-methylguanine, 5-methylcytosine, N6-adenine, 5-methylguan ... uracil-5-oxyacetic acid (v), 5-methyl-2-thiouracil, 3-(3-amino-3-N-2-carboxypropyl)uracil, (acp3)w, 2,6-diaminopurine, and the like. Nucleic acid molecules can also be modified at the base moiety (e.g., one or more atoms typically available to form hydrogen bonds with a complementary nucleoside and / or one or more atoms typically not capable of forming hydrogen bonds with a complementary nucleoside), the sugar moiety, or the phosphate backbone. Nucleic acid molecules can also contain amine-modifying groups, such as aminoallyl-dUTP (aa-dUTP) and aminohexylacrylamide-dCTP (aha-dCTP), to allow for covalent attachment of amine-reactive moieties, such as N-hydroxysuccinimide ester (NHS).
[0098] As used herein, the term "primer" generally refers to a strand of nucleic acid that serves as an initiation point for nucleic acid synthesis, such as in polymerase chain reaction (PCR). In one example, during replication of a DNA sample, an enzyme that catalyzes the replication initiates replication at the 3' end of a primer attached to the DNA sample and copies the reverse strand.
[0099] As used herein, the term "polymerase" or "polymerase enzyme" generally refers to an enzyme capable of catalyzing a polymerase reaction. Examples of polymerases include, but are not limited to, nucleic acid polymerases. Polymerases can be naturally occurring or synthetic. An exemplary polymerase is Φ29 polymerase or a derivative thereof. In some cases, transcriptases or ligases (i.e., enzymes that catalyze the formation of bonds) are used in conjunction with or as an alternative to polymerases to construct new nucleic acid sequences. Examples of polymerases include DNA polymerase, RNA polymerase, thermostable polymerase, wild-type polymerase, modified polymerase, E. coli DNA polymerase I, T7 DNA polymerase, bacteriophage T4 DNA polymerases include Φ29 (phi29) DNA polymerase, Taq polymerase, Tth polymerase, Tli polymerase, Pfu polymerase, Pwo polymerase, VENT polymerase, DEEPVENT polymerase, Ex-Taq polymerase, LA-Taw polymerase, Sso polymerase, Poc polymerase, Pab polymerase, Mth polymerase, ES4 polymerase, Tru polymerase, Tac polymerase, Tne polymerase, Tma polymerase, Tca polymerase, Tih polymerase, Tfi polymerase, Platinum Taq polymerase, Tbr polymerase, Tfl polymerase, Pfutubo polymerase, Pyrobest polymerase, KOD polymerase, Bst polymerase, Sac polymerase, Klenow fragment polymerase with 3' to 5' exonuclease activity, and mutants, modified products, and derivatives thereof.
[0100] Digital information, such as computer data in the form of binary code, can include symbol sequences or strings. Binary code can encode or represent, for example, text or computer processor instructions using a binary system having two binary symbols, typically 0 and 1, called bits. Digital information can be represented in the form of non-binary code, which can include sequences of non-binary symbols. Each encoded symbol can be reassigned to a unique bit string (or "byte"), and the unique bit string or byte can be arranged into a string of bytes or byte streams. The bit value for a given bit can be one of two symbols (e.g., 0 or 1). A byte can include a string of N bits, for a total of 2 N For example, a byte containing 8 bits can have a total of 2 8 Or 256 possible unique byte values can be produced, with each of the 256 bytes corresponding to one of the 256 possible distinct symbols, characters, or instructions that can be encoded by the byte. Raw data (e.g., text files and computer instructions) can be represented as a string of bytes or a byte stream. Zip files or compressed data files containing raw data can also be stored in a byte stream, and these files can be stored in a compressed format as a byte stream and then decompressed back to raw data before being read by a computer.
[0101] It should be understood that the terms "index" and "position" are used interchangeably in this disclosure, and that both terms are used to refer to a unique element or entity of an ordered group, such as a list or a string. For example, an index or position can be used to specify an element in an array, vector, string, or data structure. The index / position notation uses a numbering scheme to assign a nominal number to each entry / entity. Examples of this disclosure often use a first index / position 0 as a zero-based numbering, as is known in the art. The first position of an array / string (also called the zeroth position) is denoted by 0 for the purposes of calculations involving unique positions. A set of length n should have a numbering scheme of 0, 1, ..., n-1. It should be understood that other numbering schemes can also be used in the systems and methods described herein. For example, the numbering scheme can start with 1 and continue to n for a set of length n.
[0102] This disclosure describes methods related to the figures of this application. It should be understood that these methods include a calculation step and are configured to be performed on DNA. Using the methods and systems of this disclosure, computer data or information can be encoded with multiple identifiers, each of which can represent one or more bits of the original information. In some examples, the methods and systems of this disclosure encode data or information using identifiers, each of which represents two bits of the original information.
[0103] Encoding and Writing Information into Nucleic Acid Sequences
[0104] The following discussion, in conjunction with Figures 1-10, provides an overview of various systems and methods for encoding data in nucleic acid molecules and describes various writing and storage systems configured to print and store the encoded nucleic acid molecules.
[0105] FIG. 1 illustrates a schematic process for encoding information into a nucleic acid sequence, writing information into a nucleic acid sequence, reading information written into a nucleic acid sequence, and decoding the read information according to an exemplary implementation. Digital information or data is represented as one or more symbol strings. In one example, the symbols are bits, with each bit having a value of "0" or "1". Each symbol can be mapped or encoded into an object (e.g., an identifier) that represents that symbol, and thus each symbol is represented by a separate identifier. The separate identifiers can be one or more nucleic acid molecules having unique nucleic acid sequences constructed from component nucleic acid sequences (which may be referred to herein as components). To write digital information into a nucleic acid sequence, the process generates an "identifier library," which can be physically generated by physically constructing identifiers corresponding to each symbol of the digital information. To read digital information from the identifier library, the process accesses all or a subset of the identifiers in the identifier library by sequencing and identifying the identifiers. The identified identifiers are then associated with the corresponding symbols to decode the original digital data. In general, the approach allows access to all or any portion of the digital information at one time.
[0106] In one example, a method for encoding and reading information using the approach of FIG. 1 includes receiving a bitstream and mapping each 1-bit (a bit having a bit value of "1") in the bitstream to a distinct nucleic acid identifier using an identifier rank or nucleic acid index. The process then builds an identifier library as a pool of nucleic acid molecules that includes copies of identifiers corresponding to a bit value of 1 (excluding identifiers with a bit value of 0). In other words, the identifier library includes multiple copies of each identifier that represents a 1-bit at a unique position or rank in the bitstream, each identifier associated with multiple instances of identifier molecules in the pool that share a unique sequence that represents a unique position or rank in the bitstream, and identifiers that represent a 0-bit in the bitstream are excluded from the pool. To read the digital data from the pool of nucleic acid molecules, molecular biology methods (e.g., sequencing, hybridization, PCR, etc.) can be used to determine which identifiers are represented in the identifier library. For identifiers present in the identifier library, the corresponding identifier rank (and thus the bit position in the bitstream) is determined and a bit value of "1" is assigned to that location. For any identifier not present in the identifier library, the corresponding identifier rank (and thus the bit position in the bitstream) is determined and a bit value of "0" is assigned in its place. In this manner, the pool of nucleic acid molecules can be decoded to determine the original encoded bitstream.
[0107] The above described approach involves encoding a string of N distinct bits, with an equal number N of unique nucleic acid sequences as possible identifiers. This approach to encoding information can use de novo synthesis of an identifier (e.g., a nucleic acid molecule) for each new item of information (another string of N bits) to be stored. In other cases, the cost of synthesizing a new identifier (a number equal to or less than N) for each new item of information to be stored can be reduced to a one-time de novo synthesis and subsequent maintenance of all N possible identifiers. In this way, encoding a new item of information (e.g., a bit string of length N or less) involves mechanically selecting and mixing together pre-synthesized (or pre-fabricated) identifiers to form an identifier library. In other cases, the costs of (1) de novo synthesis of up to N identifiers for each new item of information to be stored, or (2) maintenance and selection from N possible identifiers for each new item of information to be stored, or both, can be reduced by synthesizing and maintaining a number of nucleic acid sequences (smaller than N, and in some cases much smaller than N) and then modifying these sequences by enzymatic reactions to generate up to N identifiers for each new item of information to be stored. For example, the nucleic acid sequences synthesized and maintained can correspond to unique portions that make up the N identifiers, such as moieties.
[0108] Identifiers can be reasonably designed and selected to facilitate read, write, access, copy, and delete operations. Identifiers can be designed and selected to minimize write errors, mutations, degradation, and read errors.
[0109] As a specific example, the set of available identifier sequences can include 15 layers, 14 of which each accommodate six unique DNA component sequences. The 15th layer can be a multiplexed layer that includes 28 DNA component sequences (rather than six), which also incorporate these DNA component sequences. Thus, each identifier can accommodate 15 components (one component per layer) across the entire length of the identifier nucleic acid molecule. During the writing process, the component molecules are assembled together in reaction compartments to form the identifier molecule. In some implementations, multiple components from only the "multiplexed layer" are combined into the same reaction compartment.
[0110] As another example, to write 1 terabyte in 86,400 seconds (24 hours), it would take approximately 8 x 10 11 10 identifier molecules (assuming 10 bits of information are encoded per identifier), or approximately 5×10 10 10 droplet reaction compartments may be required. Each reaction can assemble 14 identifiers from a possible set of 28 identifiers. 14 components (one from each of the 14 layers, each layer has 6 possible components) specify the "bases" of the identifiers to assemble. The remaining 14 components of the 28 possible components from the multiplexing layer specify which 14 identifiers (out of the 28 possibilities) are assembled. Thus, each reaction compartment may require 28 DNA components, plus ligase or other reaction mix.
[0111] The methods described herein can be carried out using a writing system, as described below. The writing system can be a printer-finisher system, such as that described in U.S. Patent Application Serial No. 16 / 414,752, entitled "Printer-Finisher System for Data Storage in DNA," filed May 16, 2019, which is incorporated herein by reference. The writer system can dispense DNA components to individual locations (e.g., reaction compartments) on a substrate, dispense a binding master mix, provide optimal conditions for the binding reactions, and pool all of the DNA identifiers that comprise the library.
[0112] The writing systems described herein are capable of performing high-throughput parallelized printing of conjugation reactions to construct identifiers. The reactions can be performed in picoliter (pL)-scale droplets printed onto a flexible sheet (also called a webbing or substrate) moving over a roller. As described in the above-referenced applications, the writing systems can incorporate technologies such as digital inkjet printing and web handling using suitable off-the-shelf print heads, drivers, and machine infrastructure. In some implementations, the systems and methods described herein include optimization of factors such as web speed, print head dispense speed, droplet size, and conjugation chemistry to achieve storage capacity and writing throughput. To this end, to ensure data tolerance to potential chemistry and hardware errors, the systems and methods described herein include configurations for encoding data and developing printing instructions, including specifications on how to compartmentalize DNA component sequences into layers and how many identifier molecules to construct in each printing reaction. For example, such configurations can include a computer system that communicates with the writing system and tracks its performance.
[0113] 2A and 2B illustrate an exemplary method, called "data-at-address," of encoding digital data into objects or identifiers (e.g., nucleic acid molecules) according to an exemplary implementation. FIG. 2A illustrates encoding a bit stream into an identifier library, where each identifier is constructed by concatenating or assembling a single component that specifies an identifier rank into a single component that specifies a byte value. In general, the data-at-address method uses identifiers to modularly encode information by including two objects, one object being a "byte value object" (or "data object") that identifies a byte value, and one object being a "rank object" (or "address object") that identifies an identifier rank (or the relative position of the byte in the original bit stream). FIG. 2B illustrates an example of the data-at-address method, where each rank object can be combinatorially constructed from a set of components, and each byte value object can be combinatorially constructed from a set of components. Such a combinatorial structure of rank and byte value objects allows more information to be written into the identifier than if the objects were made from only a single component (e.g., FIG. 2A).
[0114] 3A and 3B show schematic diagrams of another exemplary method of encoding digital information into an object or identifier (e.g., a nucleic acid sequence) according to an exemplary implementation. FIG. 3A shows encoding a bit stream into an identifier library, where the identifier is constructed from a single component that specifies an identifier rank corresponding to a position in the bit stream. The presence of an identifier at a particular rank (or address) specifies a bit value of "1" and the absence of an identifier at a particular rank (or address) specifies a bit value of "0". This type of encoding can use identifiers that only encode the rank (relative position of the bit in the original bit stream) and the presence or absence of those identifiers in the identifier library can be used to encode bit values of "1" or "0", respectively. Reading and decoding the information can include identifying identifiers that are present in the identifier library and assigning a bit value of "1" to the corresponding rank and a bit value of "0" otherwise. In this example, the presence of an identifier encodes a 1 bit and the absence of an identifier encodes a 0 bit, but it will be understood that the presence of an identifier can also encode a 0 bit and the absence of an identifier can encode a 1 bit without departing from the scope of this disclosure.
[0115] FIG. 3B is similar to FIG. 3A, but in the exemplary encoding method of FIG. 3B, each identifier is combinatorially constructed from a set of components such that each possible combinatorial structure specifies a rank. Such combinatorial structures allow more information to be written into the identifier than if the identifier were made from only a single component (e.g., FIG. 3A). For example, as depicted in FIG. 3B, a component set of five distinct components is used to represent ten addresses corresponding to a bit string of length N=10. The five distinct components are combinatorially assembled to generate ten distinct identifiers, each identifier including two of the five components. Each of the ten distinct identifiers has a rank (or address) corresponding to the position of the bit in the bit stream. The identifier library can include a subset of those ten possible identifiers that correspond to the positions of bit values "1" in a bit stream of length 10, and can exclude a subset of those ten possible identifiers that correspond to the positions of bit values "0".
[0116] FIG. 4 shows a contour plot according to an exemplary implementation in logarithmic space of the relationship between the combinatorial space of possible identifiers (C, x-axis) and the average number of identifiers (k, y-axis) physically constructed to store information of a given original size in bits (D, contour) using the encoding method shown in FIG. 3A and FIG. 3B. The graph assumes that the original information of size D is recoded into a string of C bits (C can be larger than D), with a specified number k of bits having the bit value "1". Furthermore, the graph assumes that the encoding of the information to nucleic acid is performed on the recoded bit string, with identifiers constructed for positions with a bit value of "1" and no identifiers constructed for positions with a bit value of "0". According to this assumption, the combinatorial space of possible identifiers has size C to identify all positions in the recoded bit string, and the number of identifiers used to encode a bit string of size D is such that D=log2(Cchoosek), where Cchoosek is the number of ways to choose k unordered results from C possibilities. Thus, as the combinatorial space of possible identifiers increases beyond the size (in bits) of a given item of information, the number of physically constructed identifiers required to store the given information decreases.
[0117] FIG. 5 shows a schematic method of writing information to a nucleic acid sequence according to an exemplary implementation. According to an exemplary implementation, the information is converted into a symbol string and encoded into a plurality of identifier sequences before being written to the nucleic acid molecule. In one example, writing information to a nucleic acid molecule includes setting up various chemical reactions to create identifier molecules for combination into a pool. Specifically, reactions are set up by depositing inputs (e.g., nucleic acids, components, templates, enzymes, or chemical reagents, etc.) into compartments (also referred to herein as containers, e.g., wells, tubes, locations on a surface, chambers in a microfluidic device, or droplets in an emulsion, etc.). Reactions can be set up in a single compartment at a time, or in multiple compartments for parallel processing. Reactions can include unique process steps, such as programmed temperature incubation or cycling, can be selectively or universally removed (e.g., deleted), selectively or universally interrupted, consolidated, and purified to collect the resulting identifier molecules into a pool, or any suitable combination thereof. Identifiers from multiple identifier libraries can be collected in the same pool, or each of the different identifier libraries can be collected in a separate individual pool. In some examples, each identifier includes a unique barcode or tag to identify the corresponding identifier library to which it belongs. In some examples, the barcode includes metadata representing the encoded information. In addition to the identifier molecule representing the encoded information itself, supplemental nucleic acids or additional identifiers can also be included in the identifier pool with the identifier library. For example, the supplemental nucleic acids or additional identifiers can represent metadata for the encoded information, or can serve to obscure or hide the encoded information.
[0118] The identifier rank (e.g., nucleic acid index) is based on an ordering of the identifiers. The method can include a lookup table with all the identifiers and the corresponding ranks. The method can also include a lookup table with a function for determining the ranking of all the components that make up the identifier and the ordering of every identifier including combinations of those components. Such a method can be called lexicographical ordering and can be similar to the way words in a dictionary are ordered alphabetically. For example, each identifier in the combinatorial space can include a fixed number of N components, each component coming from a distinct stratum in the set of N strata and one of a set of multiple possible components in said stratum. Each component has coordinates (j,X j ), where j is the layer label and X j is the label of the component in the layer. For the above scheme with N layers, j is an element of the set {1, 2, ..., N}, and X j is the set {1,2,...,M j}, where M j is the number of components in layer j. We can define a logical order for these layers. We can also define a logical order for each component in each layer. We can use this labeling to define, by a function or algorithm, a logical ordering for all possible identifiers in the combination space. For example, we can sort the identifiers first according to the order of the components in layer 1, then later according to the order of the components in layer 2, and so on.
[0119] In a data-at-address encoding method, the identifier rank (encoded by the identifier rank object) may be used to determine the location of a byte (encoded by the identifier byte value object) in the bitstream. In an alternative method, the identifier rank for an existing identifier (encoded by the entire identifier itself) may be used to determine the location of a bit value "1" in the bitstream. Systems and methods describing various ways of determining a particular rank or using the rank of one or more identifiers are described in conjunction with Figures 23-29.
[0120] A key can assign separate bytes or pieces of information to a unique subset of identifiers (e.g., nucleic acid molecules) in a sample. For example, in a simple form, the key can assign each bit in a byte to a unique nucleic acid sequence that specifies the position of the bit, and then the presence or absence of that nucleic acid sequence in the sample can specify a bit value of 1 or 0, respectively. Other types of keys can be used without departing from the scope of this disclosure. Reading the encoded information from the nucleic acid samples can include any number of molecular biology techniques, including sequencing, hybridization, or PCR. In some implementations, reading the encoded dataset can include reconstructing a portion of the dataset or reconstructing the entire encoded dataset from each nucleic acid sample. When the sequences are read, a nucleic acid index is determined along with the presence or absence of a unique nucleic acid sequence, and the nucleic acid samples can be decoded into a bit stream (e.g., each string is multiple bits, one byte, multiple bytes, or a byte string).
[0121] In some implementations, identifiers are constructed by combinatorially assembling component nucleic acid sequences. For example, information can be encoded by deriving a set of nucleic acid molecules (e.g., identifiers) from a defined group of molecules (e.g., combinatorial space). Each possible identifier for a defined group of molecules can be an assembly of nucleic acid sequences (e.g., components) from a set of prefabricated components that can be separated into layers. Each individual identifier can be constructed by concatenating one component from all layers in a fixed order. For example, if there are M layers and each layer can have n components, then the maximum C=n M You can construct up to 2 unique identifiers. C Different items of information or C bits can be encoded and stored. For example, the storage of 1 megabit of information takes 1×10 6 distinct identifiers or size C = 1 x 10 6 In this example, the identifier can be assembled from various components organized in different ways. The assembly can be made from M=2 prefabricated layers, each with n=1×10 3 Alternatively, the assembly can be made of M=3 layers, each layer containing n=1×10 2 components. In some implementations, the assembly can be made from M=2, M=3, M=4, M=5, or more layers. As this example shows, using a larger number of layers to encode the same amount of information can allow for a smaller total number of components. Using fewer components overall can be advantageous in terms of writing costs.
[0122] In one example, there are two sets of unique nucleic acid sequences or layers, X and Y, each nucleic acid sequence having x and y components (e.g., nucleic acid sequences), respectively. Each nucleic acid sequence from X can be assembled into each nucleic acid sequence from Y. The total number of nucleic acid sequences maintained in the two sets is the sum of x and y, while the total number of nucleic acid molecules, and therefore possible identifiers, that can be generated is the product of x and y. If sequences from X can be assembled into sequences of Y in any order, many more nucleic acid sequences (e.g., identifiers) can be generated. For example, if the assembly order is programmable, the number of nucleic acid sequences (e.g., identifiers) generated can be twice the product of x and y. This set of all possible nucleic acid sequences that can be generated can be referred to as XY. The order of the assembled units of the unique nucleic acid sequences in XY can be controlled using nucleic acids with distinct 5' and 3' ends, and restriction digestion, ligation, polymerase chain reaction (PCR), and sequencing can be performed on the distinct 5' and 3' ends of the sequences. Thus, all units and necessary reagents can be deposited simultaneously in the reaction compartment, and the distinct 5' and 3' ends of each unit allow the units (e.g., components) to self-assemble into a desired unique nucleic acid molecule, with the order of the assembled units controlled by the design of the ends. Such an approach can reduce the total number of nucleic acid sequences (e.g., components) used to encode N distinct bits by encoding information in the combination and order of the assembled products. For example, to encode 100 bits of information, two layers of 10 distinct nucleic acid molecules (e.g., components) can be assembled in a fixed order to encode 10 distinct bits of information. 2 Or 100 distinct nucleic acid molecules (e.g., identifiers) can be created, or one layer of 5 distinct nucleic acid molecules (e.g., components) and another layer of 10 distinct nucleic acid molecules (e.g., components) can be assembled in any order to create 100 distinct nucleic acid molecules (e.g., identifiers).
[0123] The nucleic acid sequences (e.g., components) in each layer can include a central unique (or distinct) sequence or barcode, a common hybridization region at one end, and another common hybridization region at the other end. The barcode can accommodate a sufficient number of nucleosides to uniquely identify all sequences in the layer. For example, typically there are four possible nucleosides for each base position in the barcode. Thus, a three base barcode can be a four base barcode. 3 =64 nucleic acid sequences can be uniquely identified. Barcodes can be designed to be randomly generated. Alternatively, barcodes can be designed to avoid sequences that may cause complications in the chemistry of the identifier or sequencing structure. In addition, barcodes can be designed to have a minimum Hamming distance from other barcodes, thereby reducing the possibility that mutations or reading errors in base resolution may interfere with proper identification of the barcode. Barcode regions can also be designed to bind probes such as primers for PCR, CRISPR-Cas guide RNAs, or affinity tagged oligonucleotides (e.g., biotinylated oligonucleotides).
[0124] The hybridization regions at one end of the nucleic acid sequences (e.g., components) may be different within each layer, but the hybridization regions can be the same for each member within a layer. Adjacent layers have complementary hybridization regions for their components and can therefore interact with each other. For example, any component from layer X can be attached to any component from layer Y because they can have complementary hybridization regions. The hybridization region at the opposite end can serve the same purpose as the hybridization region at the first end. For example, any component from layer Y can be attached to any component of layer X at one end and to any component of layer Z at the opposite end. Thus, all components and necessary reagents for forming the multiple identifiers can be deposited simultaneously within the reaction compartment, and the hybridization regions on each component allow the components to self-assemble into the desired unique identifier molecule, since the order of the assembled components is controlled by the design of the hybridization regions.
[0125] 6A and 6B show an exemplary method, called the "product method," for constructing an identifier (e.g., a nucleic acid molecule) by combinatorially assembling separate components (e.g., nucleic acid sequences) from each layer in a fixed order according to an exemplary implementation. FIG. 6A shows the architecture of an identifier constructed using the product method. An identifier can be constructed by combining a single component from each layer in a fixed order. For M layers with N components each, N M There are 10 possible identifiers. Figure 6B shows an example of a combinatorial space of identifiers that can be constructed using the product method. In one example, the combinatorial space can be generated from three layers, each layer containing three separate components. These components can be combined such that one component from each layer can be combined in a fixed order. The entire combinatorial space for this assembly method can contain 27 possible identifiers.
[0126] 7-10 show chemical methods for implementing the product method (see FIG. 6). The methods depicted in FIGS. 7-10, along with any other methods for assembling two or more separate components in a fixed order, can be used to create any one or more identifiers, for example, in an identifier library. These methods are described in U.S. Patent No. 10,650,312, entitled "NUCLEIC ACID-BASED DATA STORAGE," filed December 21, 2017, which is incorporated by reference in its entirety. At any point during the methods or systems disclosed herein, identifiers can be constructed using any of the implementation methods described in FIGS. 7-10. In some cases, all or a portion of the combinatorial space of possible identifiers can be constructed before digital information is encoded or written, where the writing process can involve mechanically selecting and pooling identifiers (that encode the information) from an existing set. In other cases, identifiers can be constructed after one or more steps of the data encoding or writing process have occurred (i.e., when the information is written).
[0127] Enzymatic reactions can be used to assemble components from different layers or sets. Assembly can occur in a one-pot reaction because components (e.g., nucleic acid sequences) from each layer have unique hybridization or attachment regions to components from adjacent layers. For example, a nucleic acid sequence (e.g., component) X1 from layer X, a nucleic acid sequence Y1 from layer Y, and a nucleic acid sequence Z1 from layer Z can form an assembled nucleic acid molecule (e.g., identifier) X1Y1Z1. Additionally, by including multiple nucleic acid sequences from each layer, multiple nucleic acid molecules (e.g., identifiers) can be assembled in one reaction. The one reaction can involve self-assembly of components into identifiers.
[0128] According to an exemplary implementation, the identifiers can be constructed according to a product scheme using overlap extension polymerase chain reaction (OEPCR), as shown in Figure 7. Each component in each layer can include a double-stranded or single-stranded (as shown) nucleic acid sequence with a common hybridization region at the sequence end, which can be homologous and / or complementary to the common hybridization region at the sequence end of the component from the adjacent layer. Thus, all components and necessary reagents for forming the multiple identifiers can be deposited simultaneously in the reaction compartment, and the hybridization regions on each component allow the components to self-assemble into the desired unique identifier molecule, as the order of the assembled components is controlled by the design of the hybridization regions.
[0129] According to an exemplary implementation, identifiers can be assembled according to a product scheme using sticky end joining, as shown in Figure 8. Separate identifiers can be assembled using three layers, each containing double-stranded components (e.g., double-stranded DNA (dsDNA)) with a single-stranded 3' overhang. Sticky ends for sticky end joining can be generated by treating the components of each layer with a restriction endonuclease. In some implementations, components of multiple layers can be generated from one "parent" set of components.
[0130] According to an exemplary implementation, an identifier can be assembled according to a product scheme using site-specific recombination, as shown in Figure 9. An identifier can be constructed by assembling components from three different layers. Components in layer X (or layer 1) can include double-stranded molecules with attBx recombinase sites on one side of the molecule, and components from layer Y (or layer 2) can include attP x Recombinase site and attB on the other side y The components in layer Z (or layer 3) can include a double-stranded molecule with a recombinase site, and the components in layer Z (or layer 3) can include an attP yThe attB and attP sites in a pair, indicated by subscripts, can include recombinase sites. The attB and attP sites in a pair are capable of recombining in the presence of the corresponding recombinase enzyme. One component from each layer can be combined such that one component from layer X is associated with one component from layer Y, and one component from layer Y is associated with one component from layer Z. Thus, all components and necessary reagents to form multiple identifiers can be simultaneously deposited in the reaction compartment, and the recombinase sites on each component allow the components to self-assemble into the desired unique identifier molecule, with the order of the assembled components controlled by the design of the recombinase sites.
[0131] According to an exemplary implementation, identifiers can be constructed according to a product scheme using template-directed ligation (TDL), as shown in FIG. 10A. Template-directed ligation utilizes single-stranded nucleic acid sequences, called "templates" or "staples," to facilitate ordered ligation of components to form identifiers. The templates simultaneously hybridize to components from adjacent layers, holding the components adjacent to each other (3' end to 5' end) while ligase joins the components. Thus, all components and necessary reagents for forming multiple identifiers can be simultaneously deposited in a reaction compartment, and the hybridization regions on each component allow the components to self-assemble into the desired unique identifier molecule, as the order of assembled components is controlled by the template design.
[0132] FIG. 10B shows a histogram of copy numbers (abundances) of 256 distinct nucleic acid sequences assembled by each 6-layer TDL according to an exemplary implementation. The edge layers (first and last layers) each had one component, and each of the interior layers (the remaining four layers) had four components. Each edge layer component was 28 bases with a 10-base hybridization region. Each interior layer component was 30 bases with a 10-base common hybridization region at the 5' end, a 10-base variable (barcode) region, and a 10-base common hybridization region at the 3' end. Each of the three template strands was 20 bases in length. All 256 distinct sequences were assembled in a multiplexed manner by one reaction containing all components and templates, T4 polynucleoside kinase (to phosphorylate the components), and T4 ligase, ATP, and other appropriate reaction reagents. The reaction was incubated at 37 degrees for 30 minutes and then at room temperature for 1 hour. Sequencing adaptors were added to the reaction products by PCR, and the products were sequenced by an Illumina MiSeq instrument. The relative copy numbers of each separate assembled sequence from a total of 192910 assembled sequence reads are shown. Other implementations of this method can use double-stranded components, which are first melted to form single-stranded variants that can be annealed to staples. Other implementations or derivatives of this method (i.e., TDL) can also be used to construct a combinatorial space of identifiers that are more complex than those that can be achieved with the product method. A variety of other chemical implementations, including Golden Gate Assembly, Gibson Assembly, and Ligase Circular Reaction Assembly, can also be used to construct identifiers according to the product method.
[0133] Data structures and data blocks for efficient data storage in nucleic acid sequences - Patents.com
[0134] This section discusses systems and methods for efficiently encoding data in DNA, which are related to Figures 11-19. In particular, specific data structures and control schemes are described. A data structure includes a format for organizing, managing, and / or storing data that allows efficient access to and modification of the stored data. More precisely, a data structure includes a set of data values, the relationships between them, and functions or operations that can be applied to the data. Exemplary data structures and encoding schemes are described in U.S. Patent Application Serial No. 16 / 532,077, filed August 5, 2019, entitled "SYSTEMS AND METHODS FOR STORING AND READING NUCLEIC ACID-BASED DATA WITH ERROR PROTECTION," which is incorporated herein by reference in its entirety. By encoding DNA with these structures or schemes, the stored data can be more easily accessed or manipulated.
[0135] As discussed above, a string can be encoded as a library of identifiers that represent a single bit in the string or the position of a symbol in a symbol string. However, an extra layer of transformation can also be employed by using "codewords" and "codebooks." A "codeword" is a set of n bits in an ordered library of identifiers. c A group of n consecutive identifiers c k out of available identifiers c Encode a symbol (e.g., any alphabet) by setting only k identifiers. c The value of is called the "weight" of the codeword. A "codebook" is the set of all possible codewords. For example, the systems and methods described herein may use a codebook that encodes 6 bits of data in all adjacent groups of 8 identifiers. In this example, the codebook encodes each possible string of 6 bits as n c = k out of 8 identifiers c= 4 unique subsets (there are 8choose4 = 70 such subsets, so it is possible to store at most floor(log2(70)) = 6 bits of data). These combinations of identifiers are called codewords, and the data they encode are called words. Adjacent words in the data can be stored in adjacent codewords, in logically ordered identifiers. Codewords can be represented by symbols as bit strings, where every bit position corresponds to an ordered identifier, with a bit value of "0" representing the absence of the corresponding identifier in the codeword and a bit value of "1" representing the presence of the corresponding identifier in the codeword. Codebooks can be "low weight" or "high weight", e.g. a low weight codebook can set 2 out of 25 identifiers, a high weight codebook can set 178 out of 357 identifiers, etc. High weight codebooks can allow for denser data storage (i.e., more bits stored per library), while low weight codebooks can allow for better implementation of error correction schemes and more robust encoders.
[0136] FIG. 11 shows a diagram of encoding strings in an identifier library by dispensing solutions into reaction compartments according to identifier sequences constructed from a trie data structure according to an exemplary implementation. A trie is an ordered tree data structure, where each layer / level of the trie represents a layer of identifiers, and each edge of each trie layer represents a component in the corresponding identifier layer. The last layer of the trie can represent a multiplexing layer of identifiers. Symbol strings 1100 represent a set of code words stored in a DNA identifier nucleic acid molecule. Code words are symbol strings that represent unique symbol strings from a source alphabet called source words. The codes map source words to code words in a process known as encoding. Droplets 1104 are dispensed into individual reaction compartments (e.g., compartment 1106). The symbol strings 1100 are encoded by constructing identifiers represented by trie paths that connect the root of the tree (not shown) to the leaves of the last (multiplexing) layer 1102 that point to the symbol value "1".
[0137] In general, the weight of a codeword includes the number of bits having a value of "1" relative to the number of bits in the codeword. As shown in FIG. 11 and described further below in particular with reference to FIG. 15, the "weight" of a codeword is uniformly distributed across the codeword because the symbol string 1100 is divided such that each string (e.g., substring) of five bits is encoded in a reaction compartment and has exactly three "1" values (out of five), and therefore each compartment receives three components from the multiplex layer to form three identifiers. For example, reaction compartment 1106 is configured to accommodate identifiers having a unique combination of components from the base layer (e.g., components that comprise the path of the trie up to the multiplex layer, components 7, B, D, ...) and components 0, 2, and 4 from the multiplex layer, each corresponding to the position of the symbol string "10101" as shown in the multiplex layer. For each "1" value, an identifier molecule (including components that comprise the path leading to that symbol position) corresponding to that symbol position is deposited into the reaction compartment.
[0138] As described above, the output from the symbol string writing process is a library of encoded DNA (identifiers) that may require long-term storage and infrequent access. The generated pool of encoded DNA contains a large number (e.g., hundreds of thousands) of molecules of each identifier sequence. For grams, the total amount of material generated can be in microgram quantities. The pool can be amplified by PCR to ensure that there is enough material for redundancy, storage, and access. After amplification, the pool can be assigned to multiple containers and stored in different locations. The pool can be stored in various nucleic acid storage and storage systems. For example, DNA can be stored in Eppendorf tubes in a freezer, frozen in liquid nitrogen, or stored in Tris-EDTA. The shelf life of the DNA is evaluated by reading the material subjected to accelerated stability conditions such as different temperatures. The systems and methods described herein can include an automated sample management system that allows both long-term storage and random access of the stored DNA.
[0139] In some implementations, an operating system (OS) can orchestrate writing, reading, discoverable querying, or any combination of these, of an archive that is scalable up to exabyte size. The OS can be configured to represent the storage medium as a set of fixed-size "blocks." Each block is a contiguous sequence of identifiers in a single identifier library stored in a single pool of identifiers. However, blocks can also be mirrored in several pools for fault tolerance. The OS can be responsible for organizing, allocating, and writing the blocks. A "block index" is a hierarchical data structure that maps "block IDs" to physical addresses (composed of containers and identifiers), which are logical addresses, barcodes, or tags assigned to each block. The physical addresses contain the information needed to access their corresponding blocks. Specifically, in some implementations, the OS enables reading and writing of semantically annotated and indexed trees of blocks via codecs optimized for the read / write platforms described above. The OS includes a transformation stack that can include an ingest API, as well as modules for organizing and formatting data for long-term but granular data querying and discovery. These aspects of the OS can be broadly adapted to any writing, reading, or access method. Other aspects of the OS can also be designed to specifically optimize how information is written, accessed, and read. These include modules for data compression and error protection, as well as modules for organizing and sending data to the writing system described above. Data written to DNA molecules by the above methods is readable by any sequencer, although specific reading methods are described below. The OS can also include automated software and workflows that mediate the handling of DNA-based information between writers and readers, for example, by allocating DNA to a system of storage containers capable of accommodating exabytes of information, accessing DNA from such a system, and refilling DNA into such a system.
[0140] In some implementations, all blocks have a fixed, uniform size. In the case of multiple blocks, each with an associated block ID, the block IDs can be ordered, for example, by having ordered values or representations. The ordering of the block IDs can be configured to implicitly indicate the physical addresses of each block with an ordered block ID. The physical addresses can be ordered such that each block is located at an ordered physical address that corresponds to its ordered block ID. For example, a first block ID can have a value or representation "0" and a second block ID can have a value or representation "1". The first block ID indicates that the corresponding first block is in a first address space and the second block ID indicates that the corresponding second block is in a second address space.
[0141] For example, one may choose to partition the combinatorial space of identifiers into contiguous blocks of codewords of fixed size c. In this way, the range in which an identifier encodes the gth instance of a block may be inferred as the range encoding codeword instances (g-1)*c+1 to g*c. These particular identifiers can then be easily accessed by chemical access programs that retrieve only identifiers that share a common, designated set of components. These access programs work by selectively targeting identifiers with said designated set of components with probes, for example by primers and PCR or affinity tagged oligonucleotides and affinity pull-down assays, and subsequently amplifying or selecting. The probes can be applied to a series of selection reactions, each reaction targeting an individual component. The output from one reaction can be used as input to another reaction. Since the identifiers can be logically ordered by components, and further the blocks can be represented by contiguous ranges of these ordered identifiers, identifiers that contain blocks are more likely to share common components than they are different. This reduces the complexity of the access programs required to retrieve these identifiers. Complexity reduction can be further improved if blocks are assigned ranges of identifiers that exclusively share a common set of components.
[0142] In some implementations, a primary symbol string is stored across multiple blocks by splitting the primary string into multiple substrings. The symbol string stored in each block is one substring of symbols taken from the primary symbol string. The substrings make up the primary string in an ordered manner. Thus, the blocks storing each substring may have block IDs ordered according to the position or order of the corresponding substring in the primary string. For example, the primary string may be split into five substrings and stored across five blocks, each with a block ID value between 1 and 5 (i.e., the first of the five substrings is stored in the block with block ID "1").
[0143] 12 illustrates a layered organization of OS-managed capabilities according to an exemplary implementation organized into functional layers, some of which involve data blocks and / or data structures. Each layer utilizes services provided by the layer, as summarized in the following list. The seven layers translate into six deployment areas with the following designs and structures: (1) Codec: An encoder / decoder pipeline with writer-specific optimizations (2) Chemical interface: converting bit operations into chemical operations (3) Automation Interface: Interface and translator to automation devices (4) Block Abstraction: Support for block-based interfaces and core data structures (5) Search and Index: An infrastructure for semantic annotation and indexing (6) Archive Application: An archive application that demonstrates the OS Benefits of the encoding schemes and OS described herein include the ability to select encoding schemes that are optimized for write speed, write cost, read cost, or access cost; the ability to optimize the mapping of index data to blocks to minimize the decoded footprint; the ability to natively manipulate information at all scales from large blocks to single bit-and-model data structures; and tight integration with current archiving standards and practices that enable the storage, querying, and reasoning about data and relationships.
[0144] A codec acts as an encoder / decoder for information. Proper operation of the codec is crucial, since the layers above require the codec and the layers below cannot be meaningfully tested without it. The codec is responsible for taking the source bitstream and converting it into a form suitable for writing using chemical methods. The source bitstream is divided into packets, all packets being of a fixed size. Packets can be processed independently and can act as units for parallel processing. Packets consist of one or more blocks. A block is the smallest unit for allocation in the archive, and the combinatorial space of the archive is divided into a series of contiguous bitstrings called blocks. The fixed layer is responsible for computing the block hash using a standard cryptographic hashing algorithm, and this hash is contained within the parent block. When a block is decrypted, its integrity can be checked by recomputing its hash and checking it over the parent block.
[0145] In some implementations, the codec performs or adjusts the encoding according to a data structure such as a B-tree structure or a trie structure, including the exemplary encoding scheme shown in FIG.
[0146] FIG. 13 is a system diagram of a Layered Cartesian Product Combinatorial Constructor (LCPCC) for designing and ordering identifiers according to an exemplary implementation. The product constructor has three layers (M=3) and a component library of eight component sequences (C=8). A combinatorial partition scheme is shown with a component sequence of {3,3,2} per layer, meaning that there are three components in the first layer, three components in the second layer, and two components in the third layer. The space of all possible identifier sequences forms the combinatorial space. The total number of combination objects that can be constructed from the component library can be called the span of the combinatorial scheme, which determines the length of the bitstream that can be written to a single pool of identifiers. The span of this particular scheme is 3×3×2 or 18. In general, any combinatorial partition scheme can be used, with C components separated into M layers, where the i-th layer is C i components, C i The sum of the M values of is C, and C i The product of the M values of is the span of the combinatorial space that defines the number of possible identifier sequences and thus the length of the writable bitstream. Combinatorial objects are lexicographically ordered in the combinatorial space by extending the ranking of the component sequences to the identifiers constructed from them. This ordering information is implicit in the identifier and can be used to identify its position in the combinatorial space and to identify the position of the symbol encoded by the identifier in the source symbol stream. For example, LCPCC can be used to encode a binary alphabet and define the symbol encoded by the constructed identifier to be a "1". A "0" symbol can be represented by not constructing a corresponding identifier. A source bitstream can be encoded by constructing a distinctive set of identifiers (i.e., an identifier library) that is unique to that bitstream.
[0147] Figure 14 shows a system diagram of an archive operation for mapping data blocks and using data structures according to an exemplary implementation. The archive (CAR) is partitioned into boot, ontology, index, and content regions. The boot partition can be written using a standard encoding scheme that can be decoded without external metadata, and can store parameters, keys, and addresses required to read other partitions. The OS abstracts the storage medium as a group of fixed-size blocks, as described above.
[0148] Each block may contain a contiguous array of identifiers in a single identifier library stored as a single identifier pool, and may be mirrored in several identifier pools for fault tolerance. In general, the OS is responsible for organizing, allocating, and writing blocks. When the block layer receives source bitstream packets, the block index separates and assigns packets to blocks in the archive. The boot partition contains the block index, a hierarchical data structure that maps block IDs to physical addresses (composed of containers and identifiers). The block index keeps track of free / used blocks and allocates blocks to new packets.
[0149] Each block ID may be a logical address and may be translated into a physical address in the molecular archive. This is accomplished by traversing the block index as shown in FIG. 14. Each node in the data structure (e.g., an address node) may contain an array of child block identifier ranges similar to a B-tree data structure (e.g., as described below in connection with FIG. 15). Each range points to the next block on the path to the block of interest. In this way, the system maintains a tree of address nodes that ends with a leaf node that references a block in the molecular archive that contains the actual data. In other words, a leaf node stores a block ID that identifies the physical address of the block, and may further store a hash of the block. An internal node may also contain a hash, such as a concatenation of the hashes of its child nodes, thus forming a hash tree. As shown in FIG. 14, a physical address of a block may include a location code, a container code, as well as an identifier range, where the identifier range is defined by a start and end identifier that references multiple identifiers that encode related information. In general, it is possible to decompose a block ID into two or more physical addresses to allow for fault tolerance. In this case, the information stored in the block ID may be distributed across two or more different containers or two or more different identifier ranges.
[0150] Each high-level operation on a block of bits depends on and results in multiple physical operations that rely on chemical methods or physical steps. To coordinate those chemical or physical processes, two types of software tools can be used. First, an optimization tool converts the block operations into an optimized set of physical operations. Then, a conversion tool converts the physical operations into a detailed behavioral program to be executed by a technician or an automated device, which can include designing and implementing translators between the operations of the block of bits and the physical and chemical operations.
[0151] The systems and methods described herein provide for archival preservation and target discovery and querying. The key to this disclosure is to affect data blocks and data structures to perform specific target access operations, which do not require the decryption of the majority of the archive. Instead, the systems and methods of this disclosure allow selective and incremental discovery, querying, and reading of target content while minimizing the need to compute join operations and other structures on the archive. The main metric to be minimized is the total number of bits that are decoded to satisfy the query sequence.
[0152] FIG. 15 shows a flow diagram 1500 outlining steps for storing blocks of data associated with block identifications (IDs) in a container according to an example implementation. At step 1502, a number of blocks are obtained. Each block includes a symbol string and is associated with a block ID. The block ID can be any identifying characteristic or symbol associated with a particular block. For example, the block ID can be a semantic annotation in the form of a triple. In some implementations, the block ID is an integer, a string, a position, a triple, a list of attributes, or a semantic annotation. For example, the first X symbol of a symbol string contained within a block can indicate a numeric ID for that block.
[0153] In step 1504, a block (one of the blocks received in step 1502) is assigned to a container. A container can be a physical location such as a bin, tube, or other physical storage medium in which nucleic acid molecules can be stored. A container can be bound to a single block or multiple blocks. For example, one container can be associated with B information blocks. In some implementations, a container can contain multiple sub-containers.
[0154] In step 1506, the block is mapped to an identifier array to be associated with the container. These identifiers include an identifier range or a plurality of different identifiers of an identifier range. The identifier range is specified by a component array that includes identifiers that encompass the range. In some implementations, each individual identifier is associated with a separate integer, and thus an identifier range can be specified by two integers. Each identifier array of the plurality of identifier arrays corresponds to an individual symbol in the symbol string stored in the block. Each identifier array includes a corresponding plurality of component arrays. Each of these component arrays includes a separate nucleic acid sequence.
[0155] In step 1508, individual identifiers for the plurality of identifier sequences are constructed. For example, a set of Q identifier sequences is associated with a particular container. A subset V of the Q identifier sequences can be physically constructed to represent information in a block, as described in various methods above. In step 1510, the identifiers constructed in step 1508 are stored in an assigned container. For example, the assigned container now holds a number V of identifiers representing information stored in a block. Identification information for the container and the plurality of identifier nucleic acid sequences associated with the container is configured to be determined using the associated block ID. In some implementations, the identification information is stored in a data structure designed to facilitate access to the identification information for each container using the associated block ID. For example, the data structure is one of a B-tree, a trie, or an array. In some implementations, at least a portion of the data structure is stored in an index with the digital information. The index includes a second plurality of identifier sequences associated with a second container. In some implementations, the index is stored in a magnetic storage device, an optical storage device, a flash memory device, or a cloud storage.
[0156] In some implementations, the index includes a B-tree data structure. In this case, each node of the B-tree can include a distinct plurality of identifiers (i.e., different from the set of identifiers constructed in step 1508) of the second plurality of identifiers array. The process involves searching the B-tree to determine the identity of the distinct plurality of identifiers. Specifically, searching for a particular block ID in the B-tree involves selecting a distinct plurality of identifiers that includes a first node and reading the value of the first node. The steps of selecting identifiers and reading the value of the node can be repeated for subsequent nodes. The identity of the distinct plurality of identifiers that includes the subsequent nodes is determined by the block ID associated with the value of the first node. In one example, the first node is a root node of the B-tree, and the process of selecting and reading nodes continues until the value of a leaf node of the B-tree is read. The value of the leaf node is configured to communicate whether a block exists for the block ID. If the block ID exists, the identity of the container that includes the block (e.g., the identifier range) and the identity of the plurality of identifier nucleic acid sequences can be communicated to a user or system.
[0157] In some implementations, the index is a trie data structure. In this case, each node of the trie can include a separate plurality of identifiers of the second plurality of identifier arrays. In some implementations, the block IDs are symbol strings, and each node in the trie corresponds to a possible prefix of the symbol string. If there is a path through the trie for a particular block ID, the physical address of the corresponding block (composed of a container and one or more identifier ranges) can be specified by a leaf node of the path. Each intermediate node of the trie can be represented by a separate plurality of identifiers and can contain information about how many daughter nodes it has, which symbols those daughter nodes represent, and the physical addresses of those daughter nodes (composed of container identification information and one or more identifier ranges). In that way, similar to a B-tree, the access and read operations described herein can be used to navigate the trie in DNA. The method 1500 can further include accessing the physical address from a pool of identifiers that includes the second plurality of identifier arrays and using a sequence of probes from such pool.
[0158] In some implementations, the data structure is an array, where each element of the array includes a separate plurality of identifiers of the second plurality of identifier arrays, and each element in the array can correspond to a block ID and can contain a physical address (including a container identification and an identifier range) for that block ID.
[0159] The physical address can be configured to be specific to the block ID, such that the block ID is mapped to the physical address without storing the physical address in an additional data structure. For example, the block ID is mapped to a plurality of component sequences shared by all identifier sequences of the plurality of identifier sequences associated with the physical address. The plurality of identifier sequences associated with the block can include contiguously ordered identifier nucleic acid sequences (e.g., as described in connection with FIG. 13), and thus the plurality of identifier sequences are specified in the corresponding physical address by an identifier range that includes the identity of the first and last identifiers of the range. The first and last identifiers can be represented by integers. A series of probes can be used to access the plurality of identifiers (e.g., those associated with the block), and the series of probes can be consecutive. The probes can be PCR primers, and thus the access is performed via PCR, or the probes can be affinity-tagged oligonucleotides, and thus the access is performed via affinity pull-down assay.
[0160] In implementations where the block ID is a position, the position may be a position within a symbol string represented by a corresponding block of a parent symbol string. The parent string includes a data structure for counting or locating occurrences of a pattern in another symbol string, for example. As discussed below, the data structure may be a Burrows-Wheeler Transform (BWT), a suffix array, a suffix tree, or an inverted index.
[0161] Data structures can be stored in blocks to aid in determining, locating, and counting pattern occurrences in data using a suffix tree based approach. In a suffix tree, blocks are constructed to represent nodes of the suffix tree. A suffix tree is a trie, where every path from a root node to a leaf represents a suffix of a symbol string S. The edges of the trie represent the substrings of symbols that comprise each path. A suffix tree can be represented in an identifier nucleic acid library, where every block corresponds to a node in the suffix tree and contains information about its daughter nodes. For example, the information about the daughter nodes includes the substrings of symbols that include the edges that lead to each daughter node, and the physical addresses of the blocks that contain those daughter nodes. The root node can be a predefined block, such as the first block. Querying for membership, count, or location of a pattern involves following a path along the suffix tree by accessing an identifier of the block corresponding to the root node, decoding the information contained therein, determining the physical address of the next block based on the information contained therein and the query pattern, and continuing the process until there are no downstream blocks (or nodes) that satisfy the corresponding query or until a lead node is reached. In the former case, no query pattern is present in the string S. In the latter case, blocks corresponding to leaf nodes can be configured to contain the count or location of the query pattern.
[0162] Data structures can be stored in blocks to aid in determining, locating, and counting pattern occurrences in data using techniques based on inverted indexes. In an inverted index, there can be a block for each possible substring of fixed length in a symbol alphabet that includes a symbol string S. Each block can contain information about the starting location of the corresponding substring in S. The block ID can correspond to the substring or the location of the sorted substring, so that the physical address of the block corresponding to the substring can be ascertained without additional information. A query pattern can be mapped to a substring of the inverted index that contains it, and the block can be accessed and decoded. The location information contained therein can be used to determine the count and location of the query pattern in S. An inverted index need not be limited to fixed-length substrings. For example, an inverted index can also be used to represent the location of words within a document or across multiple documents.
[0163] A data structure can be stored in the block to aid in determining, locating, and counting pattern occurrences in the data using an approach based on a full-text index in a microspace (FM index). The FM index is a substring index based on the Burrows-Wheeler transform (BWT) and is similar to a suffix array. The FM index is a data structure that allows for compression of the input data or text while also allowing fast substring queries. The structure of the FM index is described in more detail below. The FM index can be used to efficiently find the number of occurrences of a pattern in the compressed data / text, as well as to locate the position of each occurrence. Thus, in some implementations, the symbol strings stored in the block are part of a data structure intended to accommodate locating, counting, and / or determining the membership of any symbol substring in a second symbol string, which may be larger than the first string. The data structure may be an FM index, a counter array, a Burrows-Wheeler transform, or a suffix array, each of which are discussed in further detail below with reference to Figures 16-19. In some implementations, the data structures are stored in a separate set of one or more containers, e.g., separate from the container in which the second string is stored.
[0164] As mentioned above, the data structure may include a BWT, which transforms a string S into a transformation of the string bw(S). The transformation has certain properties that aid in searching for the string S (see discussion below in conjunction with Figures 26-32). In general, the BWT may be thought of as a permutation or lossless transformation of input symbols / bits that are ordered in the transform in a manner that is suitable for compression over a method that can be more easily implemented on the untransformed string S. The BWT includes a pair of transforms: a forward transform that rearranges the symbols of the input string S to form bw(S), and a reverse transform that reconstructs the original string S from the BWT bw(S).
[0165] In general, an input string S=s with length n 1、 s 2、 ..., s n For S, the symbols of S are selected from an ordered alphabet Σ (e.g., the English alphabet, the set of positive integers, the set of arbitrary letters or symbols, or a combination of these). The forward transform proceeds on this input string S as follows: A string s$ is constructed, where $ is a special symbol that does not occur in the ordered alphabet Σ and is assumed to be smaller than every other symbol in the alphabet according to its global ordering. For example, for the English alphabet, the global ordering should be $, A, B, C, ... X, Y, Z. Conceptually, a matrix M of size (n+1)×(n+1) contains rows that are all of the circular left shifts of the string s$. The matrix M can be called the rotation matrix of s. A left shift of a string involves moving the first symbol of the string to the end of the string and shifting all other symbols to the left by one position. This left shift is repeated until all possible circular left shifts of s$ are included in M (see the left side of FIG. 16). The matrix M does not need to be explicitly constructed during the Burrows-Wheeler transformation. The rows of M are then sorted lexicographically according to the order defined in the alphabet Σ, reading the rows from left to right, considering $ to be first in the order. The last sorted matrix M' contains the first row of $s (see the right side of Figure 16), since $ is smaller than any symbol in Σ and occurs only once in the string. The last column of the matrix M' corresponds to the column L that contains $, and the Burrows-Wheeler transformation bw(s) is equal to (L',r), where L' is the string obtained by reading the last column of M' and omitting the symbol $, and r is the position of the symbol $ in the last column.
[0166] FIG. 16 illustrates an illustration of the BWT for string S=“abracadabra” according to an exemplary implementation. An unsorted 12×12 matrix M is shown on the left with each circular left shift of S, resulting in 12 rows for the 11 symbols in S and the additional symbol $. The right side of FIG. 16 illustrates a sorted form of the 12×12 matrix M′, with the first row corresponding to the string “$abracadabra” starting with $, since $ is defined to be the first of the order of all symbols in S, and the remainder of the string is sorted according to the order of the English alphabet. The five rows starting with the symbol a (because the letter a appears five times in the word “abracadabra”) are sorted alphabetically according to the subsequent symbols (e.g., the second, third, fourth, and fifth symbols). This process of transforming the matrix M to derive M′ can be referred to as suffix sorting or right sorting.
[0167] Reading the first column of the sorted matrix M', denoted by F, gives the string "$aaaaabbcdr", which is the sorted sequence of all symbols in S. The same string but without the first character $ is denoted as F' or "aaaaabbcdr". The output string L' is obtained by reading the last column L ("ard$rcaaaabb") and excluding the symbol $, thus L' is equal to "ardrcaaaabb". The position of the single occurrence of the symbol $ in the last column is denoted as r=3. The output string L' has a locally homogeneous property, which is particularly useful in a compression setting. Specifically, the locally homogeneous property is evident from the last six symbols of the last column L in Figure 16 forming a highly repetitive string "aaaabb", which can be significantly compressed via compression methods. This property of local homogeneity is unique to the BWT, since the strings are sorted alphabetically according to their right context (i.e., suffixes).
[0168] Herein, a suffix array (SA) may be used. A suffix array sa[0,n-1] constructed for a string of symbols of length n stores the position of the i-th suffix of s in lexicographical order in sa[i]. The suffix position sa[i] may be encoded with a number of bits equal to log2(n), and the suffix array sa may be binary serialized. This serialization involves concatenating each bit representation of the suffix positions in the suffix array or storing each bit representation in an identifier in a separate container.
[0169] FIG. 17 illustrates an example suffix array for string S=“abracadabra” according to an example implementation, compared to a BWT of the same string. The first column of FIG. 17 shows all suffixes of string S$, which is input string S appended with symbol $, where symbol $ is defined to be the first in the overall order of symbols. Each suffix is obtained by taking, for each position in string S$, the symbol at that position and all subsequent symbols. The corresponding suffix position, the starting position of each suffix in S$, is in the second column of FIG. 17. For example, the first suffix in the top row has suffix position 0, and thus has the entire string S$ or “abracadabra$”. The second suffix in the top row has suffix position 1, and thus has the portion of string S$ that begins after the first position, or “bracadabra$”. The remaining suffixes are determined similarly.
[0170] Just as the BWT involves lexicographically sorting rows, the suffixes from the first column of FIG. 17 are lexicographically sorted according to alphabetical order and listed in the third column of FIG. 17, with the corresponding suffix positions listed in the fourth column of FIG. 17. Here, the symbol $ is defined to be first in lexicographical order, so the suffix "$" is always in the first row of the sorted suffix array. The list of sorted suffix positions in column 4 can be made into a physically stored suffix array.
[0171] The last two columns of FIG. 17 show the sorted rotation matrix M′ and the corresponding last column L for the same input string as depicted in FIG. 16 is transformed to the BWT. The sorted suffixes in the third column correspond to the rows of the matrix M′, and for each row of the matrix M′, the corresponding sorted suffix is the set of symbols up to and including the symbol $. Every symbol L[i] in the last column L for the i-th row corresponds to the symbol of the input string s that precedes the suffix position sa[i] in the same row (i.e., the i-th row) of FIG. 17. However, if the suffix is a whole string (i.e., sa[i]=0), $ is used as the preceding symbol. In this way, sorting the suffixes for SA can be equivalent to sorting the rows of M for the BWT. The relationship between each structure is formalized by the following equation: [ka] This relationship shows that there exists a bijective correspondence between the rows of the rotation matrix M' and the suffixes of the string s. Given the suffix array of the string s, it takes linear time to derive the string L for the BWT.
[0172] 18 and 19 depict an example experiment implementing the data structures described herein according to an exemplary implementation. The example experiment was performed using a component library size of 378 components, which are subdivided among eight levels as shown by the following partitioning scheme (3,3,3,3,3,3,3,3,3,357). The fanout for a trie corresponding to this library requires a value c=3 for the first seven levels, then a value c=357 for the last level. A total of 780,759 unique identifiers can be encoded by this component library (i.e., 3 7x 357 = 780,759). In some implementations, not all such identifiers are used to encode the symbols of the indexed string s, for example due to technical constraints on writing such identifiers and designing error correction codes to make the methodology feasible and robust. It will be understood that the examples depicted in Figures 18 and 19 are shown for illustrative purposes only, and that the present disclosure is applicable to component libraries of any size for any number of levels. In this disclosure, the term "container" often refers to a physical compartment, but it will be understood that the containers described in connection with Figures 18 and 19 refer to sets of nucleic acid molecules that are not necessarily physically compartmentalized in separate compartments.
[0173] FIG. 18 illustrates an exemplary representation of the encoding of the Burrows-Wheeler transform of a string according to an exemplary implementation. In this example, a container refers to a group of identifiers that share the same length 7-component prefix and are differentiated according to the last component of the 357 possible components partitioned into the last layer. Identifiers that share the same 7 "base" level are constructed in parallel within a single container, for example, by multiplexing the identifiers in a single self-assembly reaction. 3 7 There are = 2,187 containers, each of which can accommodate 357 unique identifiers according to the 357 components available in the last layer for identifier construction. When the 7-base levels are constructed in parallel, these can be replicated to an amount equal to the number of identifiers with distinct components in the last layer.
[0174] A low-weight codebook can be implemented that uses only 350 identifiers per container from the 357 available identifiers. In general, the low-weight codebook can use any suitable number of identifiers per container, as long as the number of identifiers per container is less than a threshold value. The codebook partitions the 350 identifiers into blocks of 25 identifiers, resulting in 14 blocks per container. Each block can correspond to a codeword. Each container can be partitioned into 12 data codewords that code several bits of information, as well as two error detection and correction (EDAC) codewords that implement an error correction code. If each codeword sets two identifiers from the 25 available identifiers, the 300 possible codeword configurations (25choose2) allow the encoding of one byte (8 bits) and therefore 96 source bits per container with error correction. For a set of 2,187 containers, 26,244 bytes of information can be encoded, with 4,374 bytes used for error correction.
[0175] 2 13 Consider a binary string s of size n equal to n = 8,192 bits (1 kilobyte), the Burrows-Wheeler transform can be used to encode string s. The length of the BWT of string s (i.e., BWT(s)) is the same as the length of string s, specifically n = 2 in this example. 13Using the teaching algorithm, we can construct the BWT of s. According to the low-weight codebook, each container encodes 12 bytes or 96 bits of information (1 byte or 8 bits for each data codeword). The BWT of s, BWT(s), with length 8,192 bits, is serialized in 86 containers (the upper limit of 8,192 bits divided by 96 bits per container). Blocks of size w=96 bits can be defined such that each container encodes a block of BWT(s). In addition, we can encode a counter array that stores a running count of a particular symbol value per block (96 bits) of BWT(s).
[0176] 19 illustrates an example representation for encoding the counter array derived from the Burrows-Wheeler transform of FIG. 18 according to an example implementation. The counter array is a 2-bit integer number with a length equal to the number of symbols in the BWT(s). 13 The container is then divided into blocks or counters of set length b=13 bits, which is sufficient to store floor(96 / 13)=7 counters with 12 codewords and an additional 2 edac codewords. In this example, each block of the counter array is divided into blocks of the BWT of s, the BWT s This relationship can be formalized to define a counter array as c[0,floor((n-1) / w)], where c has length floor((n-1) / w)+1, such that c[i] (the ith block of a given block or counter, c) corresponds to a block in the BWT s Store the number of 1s in [0, i × w-1]. Therefore, c[0] (the first block of c) is equal to 0. A given counter c[i] is stored in the container at location floor(i / 7) and the BWT before the i-th container. s Count the number of 1's (bit value 1) that occur within the portion of
[0177] BWT s is of length n=213 For a given counter, c[i], represented by 13 bits, is stored in a container denoted floor(i / 7), counting from 0 to 0. The 86 containers are then used to calculate the transformation of s, the BWT. s Thus, a total of 86 counters form the array c. The total of 86 counters are stored across 13 containers (the upper limit of 86 counters divided by 7 counters per container). Figure 19 illustrates this example distribution.
[0178] As described above for the counter array, the suffix position of the suffix array for the same string s can be encoded in 13 bits (log2(n) bits). The suffix array is binary serialized by storing seven suffix positions per container. For the same example above, a given suffix position sa[i] is located in container floor(i / 7), counting containers from 0. The suffix array requires ceiling(n / 7) containers, which is equal to ceiling(8,192 / 7) containers, or 1,171 containers.
[0179] The data structures described above are stored in a total of 1,270 containers (86 for the BWT + 13 for the counter array + 1,171 for the suffix array). The use of these containers is a subset of the 2,187 available containers according to the component library used in this example. The overall target library is the BWT library L. BWT , Counter Library L C , and the suffix library L SAIn some implementations, this subdivision is merely logical or implicit, so that accesses to these libraries can be made in parallel. In the case of parallel access, queries to each library can be combined.
[0180] In the above example, rank1(x), i.e., BWT s Obtaining the total number of occurrences of bit value "1" up to and including bit position x of the BWT s Calculate the block at that bit position, i.e., block position z=floor(x / w), where w=96 is the BWT s Second, the block size of L BWT read the block by accessing the container at container position z of the block and decode the data encoded therein to obtain a first count n of the number of bit values "1" up to and including position x; BWT Third, since there are seven counters per container, L C 2. Read the corresponding counter z in the counter array at container location floor(z / 7) of the bit position x, decode the data therein, and obtain a second count n of the number of bit values “1” up to the block containing bit position x. C Finally, calculate the sum of the first and second counts (rank1(x)=n BWT +n C ) This method can be extended to compute the rank for 0 because rank0(x)=x-rank1(x)+1.
[0181] In this example, the ith block of the counter array counts a particular symbol value up to the ith block of the BWT, but it should be understood that in other embodiments, the ith block of the counter array can count a particular symbol value up to and including the ith block of the BWT. Cshould correspond to a counter at position z-1, not at position z. Alternatively, these steps can be configured to count the total number of bit values "1" across block z, and then subtract the number of bit values "1" occurring after position x in block z. In general, the mapping of BWT blocks to counter blocks f(z) can be defined without affecting the efficiency of the method. It should also be appreciated that the identifiers belonging to the containers used in this example are configured to be efficiently accessible by a set of probes each binding to a component (since the identifiers of each container share an exclusive set of seven components in common). It should also be appreciated that the information contained within the containers is configured to be correctable to a certain tolerance, due to the two associated edac codewords per container. In general, the counter array and the BWT s It is possible to define different mappings to identifiers.
[0182] Efficient reading and access operations for data stored in nucleic acid sequences - Patents.com
[0183] Identifiers can be accessed and read to reveal the encoded information, and the read and access operations are described in relation to Figures 20-22. Given a library L of identifiers, a read operation Read(L) can be performed to completely read the set of identifiers contained in L, and an access operation Access(L,Q) can be performed to select identifiers from L by specifying an appropriate query expression Q. Reading a library L refers to the process of obtaining a random subset of identifiers from L, where each identifier has a plurality (or copy number). A DNA sequencer can be used to perform this process. The DNA sequencing read method is defined by two parameters: the maximum size of the subset of L that the sequencing operation can sample and report in a single run, called the read count, and the maximum length of the identifiers that can be read, called the read length, independent of the size of L. The number of times a unique identifier is sampled by the read process is called the copy count or coverage of that identifier in that unique process run. It should be understood that in this disclosure, the terms "access" and "query" are both used for the process of targeting a subset of nucleic acid molecules, data, or information from the set. These terms can be used interchangeably herein.
[0184] R max Considering the technology with the largest random read throughput of identifiers, the function ≦f(R max , δ) is |L|≦f(R max , δ) if and only if there is a negligible probability of failure ≤ 1 / |L| δ f can be defined such that a library L can be read completely with a multiplicity of identifiers. In other words, the library L has duplicate identifier molecules with the same identifier sequence, and thus f denotes the number of distinct identifiers that can be comfortably read with negligible failure probability. As an example, current technology provides a random read number R max ≒25×10 6and corresponds to a read length of 150 nucleosides. max A reasonable estimate of δ is 10 -6 25×10 to ensure a smaller failure probability 4 It is.
[0185] For smaller libraries, a non-random reading process is performed whereby the presence or absence of each possible identifier is determined by a hybridization assay, e.g., DNA microarray, CRISPR-based probe, or PCR. This non-random reading method can be faster and cheaper than DNA sequencing, for example, when reading libraries of size 1,000 or less identifiers.
[0186] When identifiers are constructed from components corresponding to different layers, it is possible to access identifiers with components specific to a particular level or layer. The query expression is constructed by match-component operators, formalized as a regular expression constructed by logical AND and OR in the form of a directed acyclic graph (DAG), a set of tree structures called query trees, which are arranged in the form of an access program. The DAG specifies the order in which chemical reactions are performed in the various containers that house the identifiers. For example, a query in the combinatorial space of identifiers in FIG. 13 can be specified as such as all identifiers with components matching (0 or 2) as well as 5 and 6. Such an expression, when arranged as an access program, should access identifiers 4 and 16 in the library defined by this combinatorial space. The access program can be three reactions performed in series. In the first reaction, a probe is used to select identifiers with components 0 or 2 (e.g., by multiplex PCR). The second reaction takes the output nucleic acid from the first reaction and uses a probe to select identifiers with component 5. Finally, the third reaction takes the output nucleic acid from the second reaction and uses a probe to select identifiers with component 6.
[0187] To access a subset of L, use selector(i,c i ') divides the set of identifiers in L into the components C i A subset c of the entire set i ' to identifiers that have the i-th component that is a member of c i ' performs a logical OR of the match for a particular i-th component. Selectors s and t can be constructed together to obtain a selector that restricts L to identifiers that match both s and t, thus obtaining a logical AND. The logical AND is applied to successive levels and has specificity to library L, but performs the selection over one or more subpaths in a trie T(L), such as the tries of Figures 11 and 13. As discussed above, the access involves, for example, PCR or affinity tagging. When identifiers are constructed from components corresponding to different layers, it is possible to access identifiers with components specific to a specific level. The query expression is constructed by match-component operators, formalized as a regular expression constructed by logical ANDs and ORs, in the form of a set of tree structures called directed acyclic graphs (DAGs), query trees, which are arranged in the form of an access program. The DAG specifies the order in which chemical reactions are performed in the various containers that house the identifiers.
[0188] A set of m selectors is called a left selector or 5' selector when all m selector levels are distinct and point to the first m levels of the trie T(L). A set of selectors σ is called an accessor when σ contains at least one left selector that accesses π or fewer levels of T(L), where π is a parameter of the chemical method, such as PCR, used in the access operation. In the case of PCR, the value of π can be 2 because two components are targeted in the reaction by targeting one component by each of two PCR primers. The accessors are combined to form a query tree Q, which is a subtree of T(L).
[0189] Figure 20 shows an example of a query tree 2000 executed over a trie T(L) according to an exemplary implementation. The trie T(L) enumerates a combinatorial space of nine identifiers represented by nine bottom nodes of the trie. As depicted in Figure 20, each identifier has two components: one component from layer 1 and one component from layer 2. Query Q is executed over T(L) to select five identifiers: three identifiers within group 2002a and two identifiers within group 2002b. Instead of parsing five paths to reach the five identifiers, query Q is associated with a reduced set of paths. Specifically, query Q is associated with a set of only three paths: one partial path and two full paths.
[0190] A partial path is a downward path within T(L) that starts from the root (the single topmost node within the trie) and connects to one of the internal nodes (one of the three nodes within the middle level of T(L) in Figure 20). The partial path has length < M and uses multiple layers to define an identifier of library L. The partial path within Q involves only two nodes, and thus, to specify the partial path, one accessor of π = 2 components is sufficient. As depicted in Figure 20, the partial path selects three identifiers within group 2002a.
[0191] A full path is a downward path from the root to a leaf within T(L) that extends from the root to a leaf (one of the bottom nodes within the trie, representing a unique identifier array). The full path has length < M. Each of the two full paths involves three nodes, and thus, to specify each full path, two accessors are sufficient: one accessor of π = 2 components and one accessor of 1 component. The two full paths in Figure 20 share the root node and another node at the first level, and thus, the two full paths can be decomposed into an accessor of size π = 2 (going from the root to the other node) and two separate selectors for two separate leaves located at the end of each full path.
[0192] In other words, when a query tree Q is executed to access a subset of identifiers in L, a full path selects only one leaf (a leaf that is reached by a full path) and a partial path selects multiple leaves (leaves that can be reached by full path extensions of the partial path). There is a bijection (one-to-one pairing) between the leaves of T(L) and the identifiers in L, so that execution of Q on L selects the identifiers represented by the leaves of T(L) that are reachable by the query tree Q. Q denotes the subset of L selected by Q. In the example of FIG. 20, the query tree Q selects five identifiers of L, and thus Q contains five identifiers represented by groups 2002a and 2002b.
[0193] Since Q can fetch more identifiers than are physically possible with the access method, the query tree is not necessarily implemented by only one chemical reaction. For example, a given Q can have f(R max ,δ) more identifiers to select, or Q has a depth greater than π=2, which requires many accessor executions. These problems can be addressed by access programs, i.e. DAGs, where nodes are parts of query trees, and edges indicate connected nodes and thus inputs / outputs between query trees.
[0194] Let any subset S of identifiers in L be a corresponding query tree Q S For each leaf x in S that corresponds to an identifier, S Q is a tree represented by the full paths leading to any x in T(L). S A node in has all of its children (nodes following the branch from the parent node) in Q. S If the node belongs to Q, S If the leaf is full, it is marked as full. S Then, Q SThe process is completed by pruning all children of all nodes from T(L) and repeating this step until no further pruning is possible. The remaining nodes form a connected subtree of T(L), which is the smallest subtree that selects exactly the identifiers of S. The number of nodes that compose this subtree indicates the size of the subtree, which is upper bounded by |S|×M nodes, since the largest instance of a suitable subtree for S contains distinct full paths of length M for all leaves x corresponding to each identifier in S. As an example of pruning, the query tree Q in FIG. 20 has a partial path that terminates in what is considered to be a pruned full node whose children are pruned, since all three identifiers in 2002a are part of subset S.
[0195] In some implementations, S forms a (y-x+1) identifier contiguous range R=[id[x],id[y]] in L. R is transformed into the corresponding contiguous range of the leaves of T(L), Q S The above steps are applied to generate . An example of this implementation according to an exemplary implementation is shown in FIG. 21, which shows a diagrammatic example of the decomposition of a contiguous range R of identifiers (represented by leaves) in a set of full paths and partial paths in a binary tree T(L). The leftmost and rightmost paths are the two full paths leading to the leftmost and rightmost identifiers id[x] and id[y], respectively. The open circle nodes indicate entire subtrees descending from two nodes per level, assuming the tree is binary. The "fan-out" (i.e., number of components) of the nodes at each level is denoted by c, which is equal to 2 in the example of FIG. 21. R is a contiguous range Q of at most 2(c-1) paths for (M-1) levels. S is selected by, and therefore Q R consists of at most 2(M-1)(c-1) queried paths, and therefore selectors. The number of paths is based on a factor (c-1) rather than c, because if there are c partial paths at level i that originate from the same parent node, then these partial paths can be reduced or compressed into shorter partial paths that end at a shared parent node at a higher level but span the same subrange.
[0196] In a general query tree Q, if the accessed identifiers are ordered by the corresponding leaves of T(L), then the identifiers are in the range <(s1,t1),...,(s n ,t n )>, where each (s i ,t i ) is a nonempty, disjoint, maximal contiguous subsequence of the identifiers / leaves.
[0197] A suitable query tree Q S Q is a set of identifiers that (i) satisfies the queried subset S, (ii) is feasible according to the adopted reading technique with certain restrictions, and (iii) the reading cost is minimized. In some implementations, it may be useful to read more identifiers than required, and thus Q S will arrive at some false positive identifiers that are not in S, but can be discarded in a post-processing step via automatic or manual inspection. S The case that minimizes the execution time for the query tree is when the total number of leaves covered by the current query tree is f(R max This can be accomplished by pruning the tree Q, level by level, starting from the deepest level, until the number of unique identifiers that can be read in a single execution of a given read method is smaller than f(R,δ), the maximum number of unique identifiers that can be read in a single execution of the given read method. The case with the smallest number of nodes can be achieved by a greedy solution in which every node u is assigned a priority prio(u), which measures the gain induced by removing a node's children from the current query tree, expressed as a function of the number of its children (to be removed) in Q and the number of extra leaves included by removing those children. The greedy solution is then calculated as the number of leaves included by the pruned query tree that is smaller than the overall number of leaves included by the pruned query tree, f(R,δ). max It continues by removing nodes from Q according to priority until Q is greater than δ ( , δ ).
[0198] As mentioned above, for example, if the set of identifiers to be read is f(R max,δ) or when sequencing the entire set of identifiers would result in inordinate costs. An access program P can be used to overcome problems related to the feasibility of a given query. An access program P is a directed acyclic graph (DAG) where (i) each node is an access or read operation, (ii) each induced edge represents an input / output between two nodes (possibly amplifying the concentration of identifiers present in the target library), (iii) the input to the root of the DAG is the original identifier library L, and (iv) the output of the DAG consists of a (possibly disjoint) subset of library L as large as the number of its terminal nodes. The feasibility of P is evaluated by assuming that whenever a read operation is performed, the size of the pool of identifiers input to the read is greater than or equal to f(R max , δ). Feasibility depends on the cardinality of the identifiers in the containers used to execute the query tree, which must be at least a fixed value m c In some implementations, to meet the cardinality requirement, the identifiers in the target library L can be approximated by a constant m r In some implementations, in the execution of a query tree consisting of l long downward paths (from root to nodes / leaves), the library L is partitioned (partitioned by sample volume) into aliquots in l separate containers (e.g., wells in a well plate, test tubes). In each aliquot, the minimum concentration m of each identifier is c can still be satisfied. Aliquoting involves pipetting from one container to l containers, but can also be performed automatically by automated liquid handling machinery. The execution of l long independent paths through a trie T(L) of library L requires m c m × l copies guaranteed r Then, l aliquot operations are performed to partition the identifiers into l separate containers, each of which contains approximately m c copies of each of the l tubes. Then, the l accessors are executed individually and / or in parallel for l long downward passes over these l tubes.
[0199] In implementations where the paths of the query tree are relatively short, they can be run in parallel on the same container, which requires only one or a few reactions. In implementations where some paths are long and share some of the same subpaths, some reactions can be merged in the same container to reduce the number of aliquots l required. Merging of reactions relates to symmetries that exist in the structure of the query tree, and therefore the access program can be configured to detect possible merges in the query tree.
[0200] FIG. 22 shows an example of this merging process in a query tree Q 2200 applied to a trie T(3), where letters A-I indicate accessors and branches that do not lead to nodes are paths in the full trie 2200 that do not exist in the query tree 2200 according to the exemplary implementation. In the example of FIG. 22, the query tree 2200 contains six full paths: ADG, ADH, AFG, CDG, CDH, and CFG. Every node specifies a chemical reaction with a selector or accessor that labels the node, and reactions are run from the incoming reaction (previous node) across identifiers. Based on the size and structure of the query tree 2200, a total of 12 selectors are used overall, and at most six reactions per level (one reaction per child node) are required.
[0201] Query DAG 2202 on the right side of Figure 22 is the result of merging shared suffixes in query tree 2200. Query DAG 2202 merges suffix FG shared between AFG and CFG, suffix DG shared between ADG and CDG, and suffix DH shared between ADH and CDH. The resulting query DAG 2202 is implemented with six accessors and no more than two reactions per level. The number of aliquots at a node depends on its fanout, so query DAG 2202 is implemented with no more than two aliquot operations, at most two containers per level, and therefore at most two replication operations per level.
[0202] In general, an access program is implemented using a query tree consisting of l downward paths (selectors). In some implementations, the query tree is shallow, meaning that the paths have length p≦π, where π is as defined above depending on the reading technique, and one reaction is then sufficient to execute the query tree. The query tree consists of the logical OR of the paths, i.e., the results of the selectors, so that the selectors can be applied in parallel on the same container. In some implementations, the query tree has some paths longer than π, which must be executed by ANDing distinct (p / π) accessors in the execution. However, these limitations can be overcome in implementations where the query tree includes one or more iterations performed on the corresponding downward paths. The form of the iteration is as described above in connection with FIG. 21, where the iteration is a suffix shared between two or more paths in the query tree corresponding to the access operation. When two paths share a suffix s, such as the suffix of DG in the two paths ADG and CDG in 2200 of FIG. 21, these paths share the last array of |s| selectors, and thus the sets of identifiers selected by the two paths can be merged into the same container. This process is carried out by creating a query tree Q such as 2200. S Query DAG D like 2202 S where the transformation is S It involves breaking equal suffixes of paths in D S The nodes in are labeled by accessors (selectors with a long π), and each node indicates a reaction that is performed by applying the corresponding accessor across the identifiers merged in the container along the subpath. The number of reactions to be performed in parallel by the access program is D S is equal to the number of nodes at each level.
[0203] In some implementations, an access program has a query tree that is the logical OR of its constituent paths, and a query path length of p≦L is executed by combining its constituent (p / π) accessors in a logical AND. The access program involves the execution of r paths of length p, which can each be decomposed level-wise in an array of (p / π) sets of at most r accessors (one accessor per path). Each such set is executed via one reaction operation in the container. This implementation overestimates the material cost of the access program, for example, when paths share some prefixes (and can therefore be executed together), or when merging parts of paths reduces the number of aliquot and replicate operations (and therefore the number of parallel reactions). The execution time of an access program specified by a query tree Q with m leaves is proportional to its depth divided by π (1 / π) × depth(Q). The access program proceeds by executing one reaction per π levels of the query tree Q, which can possibly involve executing many accessors across separate containers. The execution time compensates for the time required for duplication and aliquoting. In some implementations, the query tree Q is reduced by keeping nodes at levels that are multiples of π and reducing π-component subpaths to form meta-components of length π that are considered to be single symbols. At every π levels, π paths are explored, and the resulting reduced trie has depth L / π and c π A node has a fanout of f where its input from a parent node is replicated f times. In an implementation where a query is executed according to a query DAG D derived from a tree Q, the execution time is approximated by (1 / π) × depth(D) plus the replication time, which is pre-determined based on the nodes of D taking into account the fanout of each node. According to the definition of a query DAG discussed above, this execution time can be smaller than the execution time for Q because depth(D) = depth(Q) and |D|≦|Q|.
[0204] Assuming that an accessor is formed by π components, the setup time of an access program is proportional to the size of Q divided by π. The setup time is bounded by the smaller of either the size |Q| or the sum of the lengths of the m individual paths divided by π (1 / π) × m × depth(Q). Q S The query DAG corresponding to S is used instead of Q to specify the set time.
[0205] The read and access operations discussed herein form the basis for performing other operations on a DNA-based storage system.
[0206] Rank and fetch operations for data stored in nucleic acid sequences
[0207] 23 and 24 depict an example method of performing a rank operation according to an example implementation to determine a count of symbol or bit values for a range of a data string up to and including a particular position in the string. The rank operation includes multiple access and read operations as described above. Similarly, a fetch operation can be performed to retrieve a subset of a symbol string. As discussed above, aspects of the disclosure relate to the storage, indexing, and searching of binary strings. A string S of binary bits of length n is stored in a pool L of identifiers constructed by M components selected in a set of size c. S For example, the size of a combinatorial library L, |L[M]|, can be expressed by an identifier nucleic acid molecule via c L ≧n, and the number of layers M is therefore set equal to log c n. A string S is encoded as a pool of identifiers, so that if a bit S[x] at position x in S has bit value 1, then the identifier id[x] at position x is L S In some implementations, this means that only identifiers in L that correspond to bit values of 1 are constructed and subsequently pooled, and identifiers in L that correspond to bit values of 0 are not constructed.
[0208] The present disclosure includes systems and methods for performing a rank operation, rank(x), which for binary strings returns a count of the number of ones in a prefix string S[0,x] (the portion of bit string S preceding and including position x). For non-binary strings, the rank operation returns a count of the number of symbols having unique symbol values in the prefix string. Although some of the examples described herein relate to binary strings, it will be understood that the present disclosure also applies to rank operations on symbol strings having more than two possible symbol values.
[0209] In some implementations, b is the number of bits required to encode an integer n that indicates the length of a binary bit string S. The number of bits b is estimated by log2(n+1). The string S is divided into blocks of size b, and the block that contains position x in the string S can be denoted by B(x). Counting from 0 at one end of the string S, the ordered index B(x) is equal to floor(x / b). Calculating the rank can be decomposed into two steps: (i) counting the number of 1's in S[0,b×B(x)−1] (the number of 1's in the block preceding the block B(x) that contains x), and (ii) counting the number of 1's in S[b×B(x),x] (the number of 1's in the block B(x) up to and including x). These steps can be done in any order. The counts from both steps are then summed to determine the rank at position x. In some implementations, operation rank(x) is implemented via an access program consisting of two access operations and two read operations that can be executed in parallel, since each pair of access and read operations is applied to a separate target library, with a separate target library corresponding to each step (i) and (ii).
[0210] Although some of the examples described herein concern the above two steps, the present disclosure also includes other methods of determining rank that reach comparable results. For example, in some implementations, the above two steps are slightly modified. Specifically, the calculation of rank can be decomposed into two distinct steps: (i) counting the number of 1's in S[0,(b+1)×B(x)−1] (the number of 1's in blocks that include block B(x) preceding block B(x) that contains x), and (ii) counting the number of 1's in S[x+1,(b+1)×B(x)] (the number of 1's in blocks B(x) that were included in step (i) but only after x). The rank of position x is then obtained by subtracting the count from step (ii) from the count in step (i) to remove the number of 1's that were double-counted in steps (i) and (ii). More generally, the string S can be divided into blocks of size w, where w need not be the same as b. In some implementations, operation rank(x) is implemented via an access program consisting of two access operations and two read operations that can be executed in parallel, since each pair of access and read operations is applied to a separate target library, with a separate target library corresponding to each step (i) and (ii).
[0211] 23 illustrates an example for the calculation of rank(22) in a binary string S of n=30 bits stored using identifiers according to the methods described herein according to an exemplary implementation. Thus, this operation determines the number of bit values 1 in S at positions up to and including position x=22. In this example, the target library L S contains 13 identifiers corresponding to the 13 bits in S that are set to the value 1. The identifiers are each made up of three components, which correspond to the three levels in each trie in Figure 23. Thus, the trie T above the string S in Figure 23 S "3" consists of 13 leaves (corresponding to the 13 identifiers for bits of 1), 3 levels above these leaves, and a fanout of c = 4. Only paths leading to existing leaves (identifiers corresponding to bit value 1) are drawn.
[0212] The first query tree in Figure 23 corresponds to step (ii) of the rank operation discussed above. In this example, the block size b is equal to log(n+1)=5, and the block containing position 22 is B(22)=4. The query tree Q R Q (shown as a thicker line in the tree) spans the range R[20,22] from position 20 to position 22. R consists of three full paths that select three leaves at positions 20, 21, and 22, which correspond to bit values 1, 1, and 0, respectively. Only two of these values are equal to 1, and therefore the identifiers id
[20] and id
[21] at positions 20 and 21, respectively, are retrieved. R The count for x = 22 corresponds to the number of ones in B(22) up to and including position x = 22, according to step (ii) above. S =2.
[0213] Next, the remaining ones in the block preceding B(22) can be determined according to step (i) of the rank operation. This step is performed by referencing a binary counter string C, which encodes ceiling(n / b)=6 counters of b=5 bits each. C is stored using an identifier according to the methods described herein, and can therefore be accessed and read in the same way as S. Each 5-bit counter in C counts the number of ones in the prefix of S that precedes each counter. S is copied under C for reference. The first 5-bit counter of C is equal to 0 in binary, since there is no prefix of S preceding the first counter. The second 5-bit counter is "00011", which is equal to 3 in binary, since it follows the first block of S, which contains three ones. The bits of C are then sorted into a query tree Q that is applied to C. C The vertical dotted lines separate the Q bits, which correspond to the c=4 fanout of C. C selects identifiers in the range C[20,24] that correspond to the counters of 1-bit numbers in the prefix S[0,19] of B(22). Q Cconsists of one partial path ending at node u, and one full path spanning the bit in position 24. The identifier id
[24] at position 24 does not exist because the corresponding bit is set to 0, so the full query path retrieves nothing. The partial path ending at node u retrieves two identifiers id
[22] and id
[23] at positions 22 and 23, respectively. The bits of counter C[20,24] read "00110", which encodes the integer value 6, corresponding to the number of ones in the prefix S[0,19] of B(22). This query tree Q C The count for B(22) corresponds to the number of 1s in S up to B(22), according to step (i) above. C = 6. Execution of this exemplary rank operation through the access program is S +n C =2+6=8, which is the correct number of 1 bits in S[0,22].
[0214] As described above and illustrated by the example of FIG. 23, the calculation of rank can be decomposed into two steps: (i) counting the number of ones in S[0, b×B(x)−1] (the number of ones in the blocks preceding the block B(x) containing x), and (ii) adding the number of ones in S[b×B(x), x] (the number of ones in the blocks B(x) up to and including x). This operation is formalized for a bit string S of length n and is performed according to the following stages: Stage 1 involves calculating the number of ones n1 (C) in the prefix S[0, b×B(x)−1] of the block B(x). The prefix refers to the bit preceding a particular bit or block. The first target library L CLet denote the binary string C[1,b×B(n)], which is the counter string for string S. The counter string C is defined such that C[ib,(i+1)b-1] stores the binary representation in b bits of the value rank(ib-1) of S, where i=1, ...B(n)-1. C has length ≦n (less than or equal to the length of S). C(0) is not stored, since by definition it is equal to 0. Step 1 begins with the construction of a range R, which corresponds to the counter in C that encodes the rank of S up to the block B(x) that contains the specified position x. C = (id[b×B(x)],id[b×(B(x)+1)-1]) in the first library L C A query tree Q that fetches identifiers for C Q C is approximately log c It has a depth of n and a size of about cL, i.e., the depth multiplied by the fanout, where the size is independent of the block size b. Then, step 1 calculates Y=access(L C ,R C )(Range R C L in C accessing the identifier of R) and then read(Y). C This involves creating an access program that reads the bits that make up a substring of C bounded by Y, where Y is the subset of identifiers obtained via the access operation. This access program is executable according to the criteria discussed above because the read operation is performed over a range of at most b identifiers, where b is approximately log(n), which is approximately equal to f(R max , δ). The identifier retrieved by the access program is R C Phase 1 concludes by setting n1(C) to the integer value encoded by the b-bit binary substring with only those positions set to 1.
[0215] Step 2 involves calculating the number of ones n1(R) in S[b×B(x),x], where the substring of S corresponds to the block B(x) that contains the position x. S represents a binary string S, such that an identifier is physically present if and only if the bit value at the corresponding position in S is equal to 1, i.e., id[x] exists if and only if S[x]=1. Step 1 is to find a range R S = (id[b × B(x)],id[x]) in the second library L S A query tree Q that fetches identifiers for R Q R is approximately log c It has a depth of n and a size of about cL, i.e., the depth multiplied by the fanout. Then, step 1 is S ,R S )(Range R S L in S accessing the identifier of X), and then read(X). S The method involves creating an access program that reads the bits that make up a substring of S bounded by X, where X is a subset of the identifiers obtained via the access operation. The identifiers retrieved by the access program are S Stage 2 concludes by setting n1(R) equal to the number of identifiers extracted. The rank operation completes by returning the value n1(C)+n1(R) from stages 1 and 2, respectively, where rank is the number of 1 bits in S ranging from 0 to position x.
[0216] FIG. 24 illustrates a flow diagram 2400 for performing a rank operation on a bit string according to an exemplary implementation. The method of flow diagram 2400 may use the method described above with respect to FIG. 23 as well as the schematic case according to steps 1 and 2. In step 2402, a first pool of identifiers representing bit strings, such as S above, is obtained. In step 2404, a second pool of identifiers representing counter symbol strings, such as C above, is obtained. In step 2406, a first count is obtained by accessing the second pool using a second series of probes, which may be consecutive, to target identifiers indicating a running count of bits of a particular value. Targeted identifiers representing counter symbols indicating a running count of the number of bits of a given value are obtained for either (1) all blocks of w bits preceding the particular bit, or (2) all blocks of w bits preceding the particular bit, including the block of w bits that includes the particular bit. In step 2408, a second count is obtained by accessing the first pool using a first series of probes, which may be consecutive, to target identifiers. The targeted identifier (1) represents bits that precede or include the particular bit and that were not counted in step 2406, or (2) represents bits that were counted in step 2406 but that do not precede or include the particular bit. In step 2410, a rank of the particular bit in the bit string is obtained from the first count and the second count (e.g., by determining the sum or difference of the counts).
[0217] Each bit in the bit string has a bit value and a bit position. Each pool can have a solid, liquid, or solid form and is formed by forming a plurality of identifier nucleic acid molecules. Each identifier corresponds to a respective bit position and is formed by physically assembling M selected component nucleic acid molecules. Each of the M selected components is selected from a set of distinct component nucleic acid molecules separated into M distinct layers. The identifiers can be collected in a first pool to represent a bit string, such that a bit value is indicated by the presence or absence of a corresponding identifier in the first pool. Similarly, a second pool of identifiers is formed by collecting identifiers each representing a bit in the counter string. In some implementations, the first pool is the same as the second pool, while in other implementations, the first pool and the second pool are separate.
[0218] In some implementations, the physical presence of the corresponding identifier in the first pool indicates a bit value of 1, and the physical absence of the corresponding identifier indicates a bit value of 0. Each counter symbol can be represented by a string of b counter bits, where b can be determined by an upper bound of the function log2(n+1), where n is the length of the bit string. Each string of b counter bits can represent a running count of the number of bits for all w bits in the bit string that have a unique value, e.g., 1 or 0. A counter symbol string can include an upper bound of n divided by w counter symbols and is represented by a string of counter bits having length n. In some implementations, an initial counter symbol has a value of 0, which is represented by a string of b counter bits that all have a value of 0. If a particular bit is in the first block of w bits, then the running count preceding the first block of w bits is 0.
[0219] The first and second counts are obtained by reading the targeted identifiers from each inquiry according to the read operations described herein. For example, the first count is obtained by reading a counter symbol value corresponding to the targeted identifiers at 2406, or the second count is obtained by reading the targeted identifiers at 2408. In some implementations, the first index of each string is set equal to 0. The counter symbol used to obtain the first counts at step 2408 can correspond to the number of bits in the bit string that have a value of 1 in the range 0 to w×B(x)−1, where x corresponds to the position of a particular bit in the bit string and B(x) is the lower bound of x divided by w. At least b identifiers can be targeted from the second pool, and the targeted at least b identifiers can be in the range b×B(x) to b×(B(x)+1)−1.
[0220] In some implementations, the second count corresponds to the number of bits in the bit string that have a value of 1 in the range w×B(x)~x, where x corresponds to the position of the particular bit in the bit string and B(x) is the lower bound of x divided by w. At step 2408, the first count can be obtained by targeting queried identifiers from the second pool that represent counter symbols corresponding to a block of w bits that includes the particular bit, and at step 2412, the second count is obtained by targeting and counting unique identifiers targeted at 2410 that represent bits counted at 2408 but that do not precede or include the particular bit. Thus, at 2414, a rank is obtained by subtracting the second count from the first count.
[0221] In some implementations, the counter string block size w may be set equal to the bit string block size b. Alternatively, the counter string block size w may be set to 1. The first count in 2408 may be obtained by targeting the identifier queried in 2406 in the second pool that represents the counter symbol corresponding to the block of w bits that includes the particular bit, and is equal in rank to the first count. Thus, steps 2412 and 2414 may be omitted from the method.
[0222] In some implementations, the first pool of identifier nucleic acids represents a transformation of a bit string, so the presence or absence of an identifier does not directly correlate with any bit value in the bit string, but a block of contiguously ordered identifiers, called a codeword, can be transformed into a block of bits in the bit string. A codeword comprises the presence of a fixed number of unique identifier nucleic acid molecules from a fixed number of possible unique identifier nucleic acid molecules. Additional information can be used to detect and correct errors in writing, accessing, and reading identifier nucleic acid molecules from the first and second pools. The additional information is stored in the identifiers of the first and second pools.
[0223] In some implementations, the first count in 2406 represents all blocks of w bits preceding the particular bit, and the first series of probes in 2408 targets one or more distinct identifier nucleic acid molecules in the first pool representing bits not counted in 2406 that precede or include the particular bit, and a rank of the particular bit in the bit string is obtained by summing the first and second counts in 2410. In other implementations, the first count in 2406 represents all blocks of w bits including the block of w bits preceding and including the particular bit, and the first series of probes targets one or more distinct identifier nucleic acid molecules in the first pool representing bits counted in 2406 but not preceding or including the particular bit, and a rank of the particular bit in the bit string is obtained by subtracting the second count from the first count in 2410.
[0224] In some implementations, the size of the binary blocks to be read in S is adjusted. Increasing the block size reduces the number of counters in C and therefore reduces the length of C. For example, by setting w as the length of the binary blocks in S, the length of C becomes approximately (n / w)log(n), where w is the amount of bits fetched from read(X) in stage 2. In the above decomposition, the size of C was chosen to be less than or equal to the size n of S by setting w approximately equal to log(n).
[0225] It should be appreciated that while the rank operation described by method 2400 focuses on binary bit strings, method 2400 can also be applied to symbol strings. In some implementations, the bit string represents a symbol string and the rank is obtained for a particular symbol in the symbol string. The symbols in the symbol string are selected from a set of symbol values, and the counter symbol string at 2404 indicates a running count of the number of symbols having a particular symbol value. In some implementations, a plurality of second pools of identifiers are obtained at 2404, each second pool representing a different string of counter symbols that counts the number of instances of a unique symbol value, and each different string of counter symbols counts the instances corresponding to a unique symbol value.
[0226] In the above example of FIG. 23, any binary rank operation can alternatively be performed by counting the number of 0 bits in S, which is denoted by rank0(x). rank0(x) can be calculated as rank0(x)=x-rank1(x)+1. A rank operation can also be performed on a symbol string selected from a set of symbol values to obtain a rank for a particular symbol in the symbol string. For example, a counter symbol string indicates a running count of the number of symbols having a unique symbol value. In step 2404, different identifier pools represent different strings of counter symbols that count the number of instances of a unique symbol value, with each different string of counter symbols counting the instances of a corresponding unique symbol value.
[0227] In some implementations, even when the rank operation is performed on a large bit string (e.g., a large input message), the number of identifiers that must be read to perform a given rank operation is very small. For example, ranking a particular bit in a terabit-sized message involves reading only 40-100 identifiers, depending on the configuration. This small amount of identifiers allows the reading to be performed by low-throughput hybridization methods such as DNA microarrays or PCR (e.g., qPCR or digital PCR) rather than using higher-throughput methods such as DNA sequencing, which have higher associated costs.
[0228] Another operation that can be performed on the DNA-based storage system described herein is the fetch operation, for example by extending the above process of retrieving one entry from the counter array C to handle integer arrays. Consider an array of n integers, each of b bits, the array can be converted to a binary string by serializing the n integers in a representation of fixed size b. The converted binary string is represented as A[0,nb-1], since serialization results in a binary string of length n×b. A is the number of entries in the identifier pool L encoded by the method described herein. A A fetch operation is represented by, where each identifier is physically constructed if it corresponds to a bit value of 1 in A (i.e., id[x] if and only if A[x]=1). A fetch operation is defined as fetch(x,y) returning an integer that occurs in the range [x,y], and is represented by a binary string of length b starting at a position determined by the range and the string length (i.e., position i×b for i=x,...,y). A fetch operation is represented by L which represents a subarray of A bounded by a first position xb and a last position (y+1)b-1. A The fetch operation is performed by an access program that consists of one access operation and one read operation.
[0229] The access program for a fetch operation can be executed as follows: A represents the binary string A described above. As described above, the range R bounded by the first position xb and the last position (y+1)b-1 A (i.e., R A = (id[x×b],id[(y+1)b-1])) A is created. Range R A contains exactly all the bits of A that represent the integers in the input array (a non-serialized integer array) that occur in the range x to y (i.e., [x,y]). A A substring of A bounded by log is accessed and the identifier contained within that substring is read by the reading method described herein. c Approximately log equal to nb c has depth A and log c Approximately log equal to nb c It has size A and range R A has size equal to (y-x+1)×b bits. Identifiers retrieved by the accessing program can be used to reconstruct the y-x+1 integers stored at locations in the range [x,y] of the input integer array. This fetch operation can be performed in execution time of approximately (yx).
[0230] FIG. 25 illustrates a flow diagram for performing a fetch operation on a symbol string according to an exemplary implementation. The methods and logic described above can be used in this method of FIG. 25 to perform a fetch operation. Step 2502 involves obtaining a first pool of identifiers representing the symbol string. Step 2504 involves accessing the first pool with a first set of probes to create a second pool with a subset of identifiers from the first pool, each probe targeting a component of the identifiers of the first pool. Step 2506 involves reading an array of the subset of identifiers in the second pool. Step 2508 involves using the read array to obtain a subset of the symbol string.
[0231] In the symbol string, each symbol has a symbol value and a symbol position. In some implementations, step 2502 involves forming a plurality of identifier nucleic acid molecules, each identifier corresponding to a respective symbol position, formed by physically assembling M selected component nucleic acid molecules. Each of the M selected components is selected from a set of distinct components separated into M different layers. The components in each layer may be logically ordered as described in connection with FIG. 13. The identifiers may be collected into a pool to represent the symbol string, and thus the symbol value is indicated by the presence or absence of a corresponding identifier in the pool.
[0232] In some implementations, in step 2504, the first series of probes are contiguous and correspond to a partial or full path downward in the query tree representing M layers of components. A full path downward corresponds to a path from root to leaf that includes M probes, such that the series of M probes in the series targets a single identifier. A partial path downward corresponds to fewer than M probes, such that the series of probes in the series targets multiple populations of identifiers with different sequences. The multiple populations of identifiers with different sequences can correspond to different components in at least the Mth layer.
[0233] In some implementations, querying the first pool in step 2504 involves capturing a first component nucleic acid molecule in a first layer in the first pool using a first probe of the first contiguous series of probes, separating the first pool into at least two pools in separate compartments, and capturing the component nucleic acid molecule in a second layer in the at least two pools using an additional probe. The first contiguous series of probes can be designed to capture a desired portion of the symbol string comprising the subset. The desired portion can closely correspond to the subset obtained in step 2504.
[0234] In some implementations, the first pool obtained in step 2502 is split into at least two replicate pools, and steps 2504-2508 are performed on each of the replicate pools. The first pool can be replicated (e.g., via PCR) before being split into at least two replicate pools. The probes of step 2504 can be PCR primers, and the accessing is performed by PCR. Alternatively, the probes of step 2504 can be affinity-tagged oligonucleotides, and the accessing is performed by affinity pull-down assay. In some implementations, the method 2500 further includes accessing the first pool of identifiers by a subseries of probes to create an intermediate pool of identifiers. The intermediate pool can be split into at least two replicate pools. The first intermediate pool can be accessed by a subsequent subseries of probes to form a second intermediate pool or a second pool. The at least two intermediate pools can be combined to form another intermediate pool.
[0235] In some implementations, the fetch operation uses hybridization-based techniques such as DNA microarrays or PCR (e.g., qPCR or digital PCR) for reading the identifiers. For example, if the targeted identifiers are low in quantity, it may be more cost-effective to use low-throughput methods, whereas DNA sequencing may be used for high-throughput reading when a large subset of identifiers are to be read.
[0236] Searching for patterns in data stored in nucleic acid molecules
[0237] As mentioned above, another operation that can be performed on a DNA-based platform is the count and rank operations that rely on the BWT of strings. The basis of the count operation is the use of two rank operations that can be performed in parallel, since each rank operation requires different parts of the BWT and counter array, or these parts overlap, and their execution can be structured to reuse the results of the operations. A search method that introduces the BWT, counter array, and rank operation is described below.
[0238] The data structures can be implemented in the systems described herein to perform a count operation to count the number of occurrences of a pattern P in a string. This count operation is described in relation to Figures 26-30. The basis of the count operation is the use of two rank operations that can be executed in parallel, since each rank operation requires different portions of the BWT and counter array, or these portions overlap, and their execution can be structured to reuse the results of the operations. The retrieval of pattern occurrences is not necessarily performed via a binary search, although the systems described herein can use search methods that introduce the BWT, counter array, and rank operations. These operations / data structures can be stored in a compressed form, while still allowing retrieval of entries.
[0239] The counting operation may be performed by obtaining a first pool of identifiers representing a bit string L, e.g., the last column of the Burrows-Wheeler transform matrix of the message. Each identifier may be assembled by the methods described herein and individually bound to one or more probes. A second pool of identifiers representing a counter symbol string derived from the bit string L is obtained, which represents a running count of the number of bits having unique bit values. A count of a particular bit pattern in the message is obtained by selectively accessing identifiers from the first and second pools. A series of probes are used to access identifiers from the first and second pools. The running count may be used to reconstruct the first column F of the BWT matrix, e.g., by using the LF mapping described below.
[0240] FIG. 26 illustrates a flow diagram for a counting operation method 2600 for counting the number of occurrences of a particular pattern P in a binary bit string S, which may be, for example, a message or other form of information, according to an exemplary implementation. The BWT L of S is stored via representation by an identifier in a first pool. Step 2602 involves obtaining a first pool of identifiers representing the BWT L. At step 2604, a second pool of identifiers is obtained, the identifiers in the second pool representing counter symbol strings derived from L. At step 2606, the identifiers in the second pool are accessed using a method described herein to retrieve identifiers representing counter symbols indicative of the total number of occurrences of bit value 1 in L. Step 2608 involves reading counter symbol values from the retrieved identifiers to count the total number of occurrences of each bit value in L (e.g., the total number of 1s or 0s for the binary string). At step 2610, a first column F of a Burrows-Wheeler matrix is constructed using the totals counted at step 2608. Step 2612 involves determining the index of the range in the first column F that indicates all occurrences of the last symbol in the pattern P (i.e., the pth symbol for a pattern of length p). Step 2614 involves accessing identifiers from the first and second pools to calculate ranks at the first and last indexes h and z of the range, which are determined for the value of the symbol preceding the range's symbol in the pattern P (i.e., the (pi)th symbol in P, where the loop counter i is initially equal to 1). In step 2616, the rank at each index is used to calculate a new index of the range in the first column F at which the value of the preceding symbol (the (pi)th symbol) occurs. In decision block 2618, the rank r h-1 and r zto check whether they are equal. If the ranks are determined to be equal (Y), method 2600 proceeds to step 2620 and outputs a count of 0 indicating there are no occurrences of pattern P in string S. If the ranks are not equal (N), method 2600 proceeds to decision block 2621 where i is checked to see if it is equal to p-1 (indicating the end of the pattern). If i is equal to p-1 (Y), method 2600 proceeds to step 2622 where it is determined that the count of pattern P is z-h+1. If i is not equal to p-1 (N), method 2600 proceeds to step 2623 where loop counter i is incremented by 1 and the process returns to step 2614 and repeats steps 2614-2618 at least one more time. Steps 2612-2616 are repeated until the first symbol of P is reached and a count is output in step 2622, or until there are no occurrences of pattern P in string S and a count of 0 is output in step 2620.
[0241] Each bit in the bit string has a bit value and a bit position. Each counter symbol can be stored in a counter symbol string, which is a serialized counter array. Each counter symbol can be represented by a string of b counter bits that indicates a running count of the number of bits for all w bits in the bit string L that have a unique bit value, e.g., "1". Step 2612 can involve determining a first position h and a last position z that define a range in F of occurrences of the pth bit value of pattern P, where the range includes h and z. Step 2614 determines the rank r of the pith bit value of pattern P at position h-1 in string L. h-1 where loop counter i is initially 1. Step 2614 computes the rank r of the pi-th bit value of pattern P at position z in string L. z This may further involve calculating r h-1 is zIf h is equal to the rth occurrence of the pattern in the message, then the count of occurrences of the pattern in the message may be set to 0. Step 2616 determines h as the rth occurrence of the pattern in F of the pith bit value. h-1 +1), and set z to the index of the rth instance in F of the (pi)th bit value. z where the new h and z define the new range. After h and z have been recomputed, the loop counter i may be incremented by 1 and steps 2614-2616 are repeated until i=p-1. The iterations of steps 2614-2616 may be performed serially or the iterations may be performed in parallel reactions, for example using the query tree optimization methods described above.
[0242] Each pool can have a solid, liquid, or solid form and can be formed by forming a plurality of identifier nucleic acid molecules. Each identifier can correspond to a respective bit position and can be formed by physically assembling M selected component nucleic acid molecules. Each of the M selected components can be selected from a set of separate component nucleic acid molecules separated into M distinct layers. The identifiers can be collected in a first pool to represent a bit string, such that a bit value is indicated by the presence or absence of a corresponding identifier in the first pool. Similarly, a second pool of identifiers can be formed by collecting identifiers each representing a bit in a counter string. In some implementations, the first pool is the same as the second pool, and in other implementations, the first pool and the second pool are separate.
[0243] In some implementations, the physical presence of the corresponding identifier in the first pool indicates a bit value of 1, and the physical absence of the corresponding identifier indicates a bit value of 0. Each counter symbol can be represented by a string of b counter bits, where b can be determined by an upper bound of the function log2(n+1), where n is the length of the bit string. Each string of b counter bits can represent a running count of the number of bits for all w bits in the bit string that have a unique value, e.g., a 1 or a 0. A counter symbol string can include an upper bound of n divided by w counter symbols and can be represented by a string of counter bits having a length corresponding to b multiplied by the upper bound of n divided by w. In some implementations, an initial counter symbol has a value of 0, which is represented by a string of b counter bits all having a value of 0. In some implementations, a counter string block size w can be set equal to a bit string block size b. The counter string block size w can be set to 1. In some implementations, step 2602 is omitted from method 2600.
[0244] In some implementations, the first pool of identifiers represents a transformation of a string L representing a codeword corresponding to a block of contiguously ordered identifiers transformed into a block of bits in L. The presence or absence of an identifier in the first pool does not directly correlate with any bit value in the bit string. The codeword may correspond to a fixed number of unique identifiers from a fixed number of possible unique identifiers. Additional information may be stored. For example, additional information may be stored for use in detecting and correcting errors in writing, accessing, and reading identifiers from the first and second pools. The additional information may be stored in identifiers in the first or second pools.
[0245] For a length 1 pattern, such as simply bit values 1 or 0, steps 2614-2618 may be omitted. For a length 2 pattern, such as "01" or "11", step 2618 may be omitted since no repetition is required. The method may further involve stopping the method if it is determined that the range in the first column F is not present, and the count is returned as 0. If the range is not present, then no symbols of pattern P are present in the string and thus the occurrences of P are 0.
[0246] In some implementations, a third pool of identifiers is obtained, the identifiers in the third pool representing a suffix array SA derived from the BWT. Each element of SA may be represented by a bit string of at least log2(n) bits indicating the index of the corresponding element of L. The method 2600 may further involve locating occurrences of the pattern by accessing identifiers in the third pool that correspond to elements of the suffix array between h and z, including the final values h and z of the range index, assuming the count is greater than 0. These indexes may be the indexes of the last range when the count of occurrences is returned. These steps may be performed as a fetch operation.
[0247] In some implementations, the method 2600 further involves obtaining a fourth pool of identifiers representing a bit string S, which may be, for example, a message. The context of the first location of the pattern P can be extracted by accessing identifiers in the fourth pool that correspond to the first location and adjacent locations surrounding the first location.
[0248] As an alternative to the counting method described in connection with FIG. 26, FIG. 27 shows a flow diagram illustrating a method 2700 for a counting operation to count occurrences of a binary pattern P in a string s according to an exemplary implementation. The pattern P has a length p of bits, and the string s has a length n of bits. The method 2700 first involves a decision block conditional on checking whether the last symbol P[p-1] of the pattern P is equal to 0 at 2702. If the last symbol is equal to 0 (Y), then at step 2704, a first index h is set equal to 0 (e.g., the first position in the first column of the Burrows-Wheeler matrix) and a last index z is set equal to #0 (the number of 0's in the string s) minus 1. In this case, the first and last indexes h and z may each delimit a range of suffixes starting from 0. If the last symbol of P is not equal to 0 (N), then in step 2705, the first index is set equal to #0 and the last index is set equal to n-1. In this case, the first and last indexes may each delimit a range of suffixes starting from 1.
[0249] The method 2700 further involves setting a loop counter i equal to p-2 at step 2706. This loop counter may enable the method 2700 to scan backwards through P until there is an occurrence (i.e., when the first index is less than or equal to the last index). At 2708, a decision block is performed that is conditional on the first index being less than or equal to the last index and the loop counter i being greater than or equal to 0. If the condition at decision block 2708 is not met (N), then at block 2710, it is determined that the output count is equal to z-h+1. If the condition at decision block 2708 is met (Y), then at step 2711, the Burrows-Wheeler transform (BWT) of the string s is performed. s ), the index preceding the first index h (the first index minus 1) on h-1 is executed. sAt the position equal to the last index z on the z is executed.
[0250] In step 2712, another decision block is executed conditional on the i-th symbol of the pattern P being equal to 0. If the condition is met (Y), then in step 2714, the first index h is calculated by multiplying the first rank r by the current first index. h-1 The final index z is recalculated to be equal to the current final index minus one less than the final rank r z In step 2714, the new first index h is recalculated to be equal to one less than the BWT s The new final index z can be calculated as the difference between the current first index and the rank for the symbol value 0, and the new final index z is .... s The current last index above can be calculated as the difference between the current last index and the rank for symbol value 0. If the condition in decision block 2712 is not met (N), meaning that the i-th value of pattern P is 1, then in step 2715 the first index h is calculated as the difference between the number of 0s in s and the first rank r h-1 The final index z is recomputed to be equal to the sum of the number of zeros in s and the final rank r z In step 2716, the loop counter is decremented by one and the method returns to decision block 2708. If the condition of block 2708 is still satisfied, steps 2711-2716 are repeated.
[0251] Method 2700 specially performs a rank operation on one bit, hence the notation rank1, in step 2711. This is slightly different from how method 2600 performs the rank operation, where the rank is determined for the preceding bit value in pattern P. However, both methods yield the same result, because the rank, rank1(x), of position x for bit value 1 can be easily converted to the rank, rank0(x), of position x for bit value 0 by the following equation: rank0(x)=x-rank1(x)+1 Equation 2 rank1(x)=x-rank0(x)+1 Equation 3 Therefore, step 2711 can alternatively be implemented for rank0.
[0252] Step 2711 of method 2700 of Figure 27 involves performing two rank operations. This step is described in further detail in Figure 28 as method 2711 of performing two rank operations in parallel via two access operations and two read operations according to an exemplary implementation. Method 2711 of Figure 28 is performed repeatedly according to decision block 2708 of method 2700. Method 2711 uses certain parameters from the exemplary encoding schemes described in connection with Figures 18 and 19, although it should be understood that other encoding schemes having alternative parameters may be applied to these methods.
[0253] Step 2802 of method 2711 involves setting a parameter x equal to one less than the current first index (from algorithm 1). first BWT It further involves setting q equal to the lower bound (the largest integer less than) of x divided by 96 (the number of bits encoded in each container), where q first BWT is BWT s The specific container is the BWT s Stores the xth bit of the parameter r first BWTis set equal to x and a coefficient (residue) of 96, where the parameter indicates the offset of the xth bit within the container. Similar parameters are calculated for the counter array c. first C q first BWT is set equal to the lower bound of q divided by 7 (the number of counters per container), where q first C is the qth first BWT This is a container in the library that stores c, which contains a counter for r first C indicates the offset of the counter within that container. first BWT and is set equal to a factor of seven.
[0254] Step 2804 of method 2711 includes setting a parameter y equal to the last index (from algorithm 1), and last BWT , r last BWT , q last C , and r last C Step 2804 involves setting the same BWT and counter array parameters as in step 2802 for a parameter y denoted by s A query Q that identifies the container that contains the xth bit of and the container that contains the counter of 1s before that container. first,BWT and Q first,C These queries identify containers, so the queries are q first BWT and q in the seventh digit of base 3 first C Step 2806 may be two paths with components representing q first BWT and q first C A specialized query Q last,BWT and Q last,CStep 2808 involves creating the BWT s Q first,BWT and Q last,BWT The first access operation (logical OR) of Q first,C and Q last,C In some implementations, the joint queries can be four passes of seven components each, with π equal to two (e.g., for PCR), so these access operations each retrieve at most two containers (or one container if they are equal) and require 16 accessors (the upper limit of seven divided by the technical limit for reads, π, multiplied by four). Step 2810 involves merging sets of identifiers selected by the access operations and reading these sets. In some implementations, these identifiers are contained within four or fewer containers, each of which contains 28 or fewer identifiers, so that they total at most 4×28=112.
[0255] Step 2812 is a step of first BWT So, Q first,BWT A leading path of length 7 components equal to r first BWT This involves counting the number of identifiers that have a final component smaller than or equal to the parameter n. last BWT Q last,BWT A leading path of length 7 components equal to r last BWT Step 2814 sets the parameter n equal to the number of identifiers that have a last component less than or equal to the firs t C ,q first C The rth identifier in the container that stores identifiers having a leading path of length 7 components equal to first C The parameter n is set to the corresponding value. lastC In step 9, the output, the first rank RF, is set to n first BWT and n first C Another output, the last rank RL, is set equal to the sum of last BWT and n last C is set equal to the sum of
[0256] For retrieving occurrences present in a suffix array sa[0,n-1] built on the suffixes of a string s in a range R bounded by a first and last index, the fetch operation can be performed by specifying a path of length 7 components to the library storing the suffix arrays as many as the containers that house those occurrences. In the example encoding scheme, all containers contain 7 suffix positions, so the fetch operation can be performed by paths of length 2+(last index-first index+1) / 7 or less. These paths can identify contiguous ranges of the containers, and therefore can share components. A superquery can be performed to retrieve more identifiers than are needed, delaying the filtering of identifiers to a post-processing computation stage. The smallest integer z is 3 elements larger than (last index-first index+1). z A size S(z) equal to π×7 can be defined, where z is equal to 0, 1, ..., 7. The range R can be contained by at most two ranges of size S(z), which can be defined by two subpath queries of (7-z) components. A superquery can be performed with a number of accessors equal to an upper bound of (7-z) / π, possibly with one duplication operation, to obtain a superset of pattern occurrences (by a multiplicative factor of 3 for more than 7 occurrences). A read operation can then be performed on the union of identifiers coming from the two queries.
[0257] Thus far, the counting operation has been described with examples using binary strings, but the counting operation can also be implemented on DNA storing arbitrary strings. A string s drawn from an arbitrary alphabet served as the basis for the Burrows-Wheeler transform and suffix array shown in FIG. 16 and FIG. 17. By utilizing the string BWT(s) and additional data structures, the present disclosure provides for searching for patterns drawn from an arbitrary alphabet. FIG. 29 shows a flow diagram for a method 2900 of performing a counting operation on an arbitrary symbol string according to an exemplary implementation. Step 2902 involves obtaining a first pool of identifiers, where the identifiers represent the Burrows-Wheeler transform L (the last column of the BWT matrix) of the symbol string(s), where each symbol in the symbol string is derived from a set of symbol values. Step 2904 involves obtaining a second pool of identifiers, where each second pool represents a counter symbol string derived from the BWT(s)L, and represents a running count of the number of symbols in L having a particular symbol value. Step 2906 involves obtaining a count of a particular symbol pattern in the symbol string by selectively accessing identifiers from the first and second pool sets. Following method 2900, the method described in Figures 26-28 for binary strings can be applied to each pair of pools representing a bit string and a corresponding counter string.
[0258] For example, step 2906 may involve reconstructing a first column F of a Burrows-Wheeler transformation matrix for s. A series of probes may be used to access an identifier from the last counter symbol of each of the second pools that represents the total number of occurrences of each corresponding symbol value in L. This total number of occurrences of each corresponding symbol value may be used to reconstruct F. Knowing F, 2906 may further involve determining a range of positions in F that have the last (pth) symbol value in a pattern having length p. The range of positions in F is defined by a first position h and a last position z, inclusive of h and z.
[0259] Step 2906 may further include, for each preceding symbol in the pattern after the pth symbol, using a series of probes to determine a first rank of corresponding symbol values in L at a position immediately preceding the range and a second rank of corresponding symbol values in L at a terminal position of the range to access identifier nucleic acid molecules from the first pool and the corresponding second pool, and updating the range using the first and second ranks to a range of positions in F having an instance of the corresponding symbol preceding the subsequent symbol in the pattern. h-1 is the value of each preceding symbol in the pattern at position h-1 in L, and the second rank r z is the value of each preceding symbol in the pattern at position z in L. Updating the range is the (r h-1 +1) and setting h to the location of the rth instance of each preceding symbol value in the pattern in F. z The count of occurrences of the pattern may be set based on the final values of the first and second ranks or the first and last indexes. For example, the count is the difference between the final values of the first and second ranks. If, for the pth symbol or any preceding symbol, the first and second ranks are equal to each other, the count is set to 0.
[0260] A symbol string L can be converted into r bit strings of length equal to the length of L, where r represents the number of symbol values in the set of symbol values. v For v = 1, 2, ..., r, we denote all occurrences of v For bit string L v For example, given a symbol string S = "BABBO", we can create a bit string S A =01000, S B = 10110, and S O = 00001. The total number of 1's in all bit strings is equal to the length of the original symbol string. In some implementations, there are r first pools, each of which is a bit string L v Corresponding to L v The first pool, which corresponds to v A first and second rank of the can be determined.
[0261] A counter symbol can be derived from each bit string such that each counter symbol is represented by a string of b counter bits that indicates a running count of the number of bits for all w bits in the corresponding bit string that have a distinctive bit value (e.g., 1). In some implementations, the value of w is set equal to the value of b. In other implementations, w is set to a value of 1.
[0262] Each pool can have a solid, liquid, or solid form and can be formed by forming a plurality of identifier nucleic acid molecules. Each identifier can correspond to a respective bit position and can be formed by physically assembling M selected component nucleic acid molecules. Each of the M selected components can be selected from a set of separate component nucleic acid molecules separated into M distinct layers. The identifiers can be collected in a first pool to represent a bit string, such that a bit value is indicated by the presence or absence of a corresponding identifier in the first pool. Similarly, a second pool of identifiers can be formed by collecting identifiers each representing a bit in a counter string. In some implementations, the first pool is the same as the second pool, and in other implementations, the first pool and the second pool are separate.
[0263] The pool of identifiers is determined by the presence or absence of identifiers. v For v = 1, 2, ..., r, we define a block of contiguous ordered identifiers, called codewords, as v The codeword may be configured to be converted into a block of bits in a fixed number of possible unique identifiers. The codeword may correspond to a fixed number of unique identifiers from a fixed number of possible unique identifiers. Additional information may be stored. For example, additional information may be stored for use in detecting and correcting errors in writing, accessing, and reading identifiers from the first and second pools. The additional information may be stored in identifiers of the first or second pools.
[0264] In some implementations, the method 2900 further involves obtaining a pool of identifiers representing a suffix array SA derived from the BWT. Each element of SA may be represented by a bit string of at least log2(n) bits indicating the index of the corresponding element of L. The method 2900 may further involve locating an occurrence of the pattern by accessing an identifier in the pool representing the suffix array, assuming the count is greater than 0. These steps may be performed as a fetch operation. In some implementations, the method 2900 involves obtaining a pool of identifiers representing any string, which may be, for example, a message. The context of the first location of the pattern P may be extracted by accessing identifiers in a fourth pool corresponding to the first location and adjacent locations surrounding the first location.
[0265] Consider a string s of symbols of length n drawn from an arbitrary alphabet Σ of size |Σ|. The string "abracadabra$" shown in Figures 16 and 17 is an example of such an arbitrary string. In the method described above in connection with Figure 29, the search for a pattern P of length p in string s is performed using a rough rank function that counts the occurrences of the symbol σ in the string prefix s[0,x] (the subset of string s from a first index to index x). σ We discussed how the implementation of the (x) operation relies on counting the symbols in the prefix of the BWT of s. This method counts as many ranks as there are symbols in the pattern being searched. σ We need to perform the operation because we have a binary string S with a bit value of "1" σ rank1(x) σ (x) where s has the symbol σ.
[0266] The following experimental example shows a smaller rank σThe aim is to perform the computations and to utilize techniques that work with low-weight codebooks. This implementation exploits the grouping of symbols in the search for the pattern P, effectively expanding the alphabet and reducing the number of repetitions.
[0267] In this example, the string S k [0:n-1] is defined as follows: k is an integer parameter starting from 1 and bounded on the upper limit by the string length n, and the macro symbol S k [i] is the substring occupying the last k symbols of the i-th row in the matrix containing the BWT. k can be stored in n x k bytes. In this example, using the input string "abracadabra$", the following substrings are obtained: S 1 is the BWT of s, i.e., BWT(s), since the last k=1 symbols of a row in the BWT matrix are exactly the last column L, i.e., BWT(s). S 2 is equivalent to "ra br ad a$ br ac da $a ra ca ab ab" since the last k=2 symbols are taken from each row. Spaces are included for readability, and each group of 2 symbols is considered to be a unique "macro symbol". Thus, the macro symbol S 2 [3] is "a$" and S 2 S consists of n=12 macro symbols, each with two characters, for a total of 24 bytes. 3 is equivalent to "bra abr cad ra$ abr rac ada a$a bra aca dab $ab" since the last k=3 symbols are taken from each row. S 3 consists of 12 macro symbols with 3 characters each, totaling 36 bytes. These strings can be built repeatedly for each k up to n.
[0268] S k This string is not necessarily constructed explicitly, but can also be derived as follows: [ka] teeth, [ka] S k [i][1], which means that S k This means that for every macro symbol in S, only the first symbol of the macro symbol, and therefore the symbol that is a distance k from the last column L in the BWT matrix, is kept. k The i-th macro symbol in [i] is the i-th (single) symbol of all strings. [ka] The reduced space occupancy is obtained by concatenating each S k stores only n symbols, which is less than the k × n symbols stored by [ka] is given by:
[0269] For pattern searching, S k rank over strings α arithmetic must be performed, where α is a macro symbol of length k symbols. The coding strategy is [ka] This approach can be implemented for a single symbol of the string, mimicking the example above for the symbol string "BABBO". [ka] The strings are partitioned into blocks of b containers each (in the experimental example, each container encodes 12 bytes, and therefore 12 symbols of s). α k teeth, [ka] The number of occurrences of all macro symbols α up to the kth block in S is kept constant by a counter c α k This feature can make it possible not to have to store an additional counter array C with the number of occurrences. Per block, there can be at most |Σ| k There can be counters.
[0270] In some implementations, not all substrings α of length k occur in s, and therefore c α k It is not necessary to store the string s in a s-ary format. One can keep track of substrings that are present or not and store only the corresponding data structures in DNA via the encoding scheme described herein, or by a hybrid storage scheme that incorporates both the DNA-based data storage described herein and the internal memory of a computer. The hybrid storage scheme can perform a remapping between existing (macro)symbols in the string s and integers in the range [0,...]. A real alphabet [ka] can denote the symbols appearing in s (suitably encoded by successive integers). For any k, n or |Σ| k Less than or equal to the minimum of the real alphabet [ka] There can be symbols. This remapping can be performed by a hash table (e.g., Cuckoo hashing) maintained in internal memory or within the compressed solution based on a rank data structure.
[0271] As an example, consider a pattern P equal to "dab" in the string "abracadabra". For macro symbols of length 1 and 2, the data structure described above is introduced and the search on P is divided into two steps operating backwards on P: first a search for "ab" and second a search for "d". Starting first with the first index equal to 0 and finally with the last index equal to 11, the lines with the prefix ab are determined. This first step is done by searching the string S 2 , as well as over this string, an operation rank equal to 0. ab (first-1) and rank equal to 2 ab These rank operations involve performing (last) on a string S 2 and its counter array c ab 2 This can be done with two parallel access operations and two parallel read operations over s. The number of strings in s that are smaller than "ab" is 2, so the new value for the index is first=2+rank ab (first-1)=2 and last=2+rank ab (last)-1=3. As can be seen in FIG. 16, there are two rows with the prefix ab, occurring in rows 2 and 3 of the BWT matrix. The second step involves determining the rows with the prefix "dab" and thus the "prepend" symbol "d" to "ab". This step is performed by S 1 Then, over this string, we perform the operation rank d (first-1)=0 and rank d This is done by doing (last)=1. The number of strings in s that are smaller than "d" is 9, so the new value for the index is first=9+rank d (first-1)=9 and last=9+rank d(last)-1=9. The new indexes are equivalent, so the process can be stopped and the count of occurrences of P can be reset to 1. In this example, two iterations / steps are performed to search for P, rather than the three that would be required if the search was performed one symbol at a time. A similar search operation is described in relation to FIG. 32 for a schematic case.
[0272] BWT, counter arrays, suffix arrays, and access and read methods are implemented to count occurrences of patterns in strings. In some implementations, the strings themselves can be stored in DNA and accessed at the locations of specific patterns. When searching methods are used to discover the locations of patterns in strings, those locations and surrounding neighborhoods can be accessed and later read in the pool of identifiers representing the strings. This process can be useful, for example, to gather the context in which a particular string pattern occurs.
[0273] Identifier libraries can be replicated and aliquoted into separate containers, so that multiple pattern searches can be run simultaneously in parallel. For example, 10, 100, 1000, or more pattern searches can be run in parallel. By labeling identifiers belonging to different searches with DNA sequencers and unique barcodes, the rank and fetch operations of different searches can be multiplexed at the read point.
[0274] Above, it was discussed that the BWT can include a forward transform and an inverse transform. The above example shows that each row of the sorted circular shift matrix M' for the BWT accommodates a permutation of the input string S (i.e., string S$) appended with the symbol $. Similarly, each column of M' accommodates a permutation of S$. In particular, the first column F for the example string "abracadabra" is "aaaaabbcdr" sorted alphabetically, which represents the best compressible transformation of the original input string. F is not transposable, and therefore the last column L is used as the BWT for reversibility and compressibility.
[0275] Every row i of M' is circularly shifted leftwards, and the suffix S[k i ,n-1], the special symbol $, and the prefix S[1,k i −1], it can be decomposed into three parts. For example, in FIG. 16, row 2 of M' has the prefix "abra", followed by $, and has the suffix "abracad". A first property of a BWT matrix is that, except for row i representing S$, the symbol in the last column L[i] precedes the symbol in the first column F[i] in string S, so F[i]=S[1] and L[i]=$. This property is a consequence of the property that every row of M and M' is a left circular shift of S$, so that by taking the first and last symbols of each row, across string S, the first symbol (in F) is located immediately after the last symbol (in L). A second property of a BWT matrix is that every occurrence of the same symbol c in L maintains the same relative order as in F. This property means that the kth occurrence of symbol c in L corresponds to the kth occurrence of symbol c in F. A method called "LF mapping" can exploit these properties to reconstruct S from its BWT(s)=(L',r). The LF mapping can be represented as an array of size n. The i-th entry LF[i] of the array is equal to j if and only if the symbol L[i] maps to the symbol F[j]. If L[i] is the k-th occurrence of the symbol c in L, then F[LF[i]] is the k-th occurrence of c in F.
[0276] 30 illustrates a method 3000 for constructing an LF mapping from a column L according to an example implementation. At step 3002, the method 3000 constructs an auxiliary vector V of size |Σ|+1. A Define V A L can be indexed by symbols or integers. In step 3004, first in the loop, for each symbol c in L, the number of its occurrences n c In step 3006, V A [c]=n c Then, in step 3010, in the second of the loop, these symbol-by-symbol occurrences are made into a cumulative sum, so that in step 3012, a new V A Let [c] store the total number of occurrences in L of symbols less than c, i.e., V A [c]=Σ x<c n x This step is done in step 3008 by employing two auxiliary variables, so that the overall workspace remains approximately the size of n. A [c] gives the first position in F where symbol c occurs. Thus, before the end of the loop begins, V A Let [c] be the landing position in F of the first c in L (the LF mapping for the first occurrence of every alphabet symbol is known). Finally, at the end of the loop, in step 3014, we scan the column L and whenever we encounter a symbol L[i]=c, in step 3016 we set LF[i]=V A Set [c]. This condition is true when c is satisfied for the first time, then V A [c] is incremented so that the next occurrence of c in L is mapped to the next position in F (considering the proximity in F of all rows starting with that symbol). Thus the algorithm is: LF[i]=Σ x<c n x +k invariant, then the k occurrences of c in L are processed. In step 3018, the output of the final LF (LF mapping array) is generated.
[0277] Considering the LF mapping and fundamental properties described above, S can be reconstructed backwards, starting from the transformed output BWT(s)=(L',r). A method 3100 for reconstruction of a string S according to an exemplary implementation is shown in FIG. 31. In step 3102, L is reconstructed from BWT(s) by inserting $ at position r of L'. In step 3104, the LF mapping of L is determined. Step 3104 can be performed via the method 3000 of FIG. 30. In step 3106, auxiliary variables k and i (loop counters) are set. The variable k is initially set to 0, the loop counter i is initially set to n-1, and the last position of the length is L, F, and s. In decision block 3108, the method 3100 checks whether the loop counter i is greater than or equal to 0. If the condition is met (Y), the iteration continues via step 3110. Step 3110 involves picking the last symbol of S, i.e. S[n-1], which can be identified in L[0], assuming that the first row of M' is $S. The method then proceeds by moving one symbol to the left in S at a time, introducing the two properties mentioned above, the second property allowing to map the current symbol occurring in L (initially L[0]) to its corresponding copy in F, and then the first property allowing to find the symbol preceding that copy in F by taking the symbol at the end of the same row (i.e. the one in L). This double step goes back in L, allowing for a leftward movement of one symbol in s. The string can be reconstructed by repeating this process to the beginning of S. If the condition of decision block 3108 is no longer met (N), the method 3100 ends in step 3111, where the original string s is now fully constructed.
[0278] For an example, see FIG. 16. In FIG. 16, L[0]=S[n-1]=“a” and the loop of method 3100 is executed (repeating steps 3108 and 3110). LF[0] refers to the first row starting with “a”, i.e. row 1. Thus, a copy of “a” is LF mapped to F[1] (actually, F[1]=“a”) and the preceding symbol in S is L[1]=“r”. These two basic steps are repeated until the entire string S is reconstructed. Continuing with the running example above, L[1]=“r” is LF mapped to the symbol in F at position LF[1]=10 (actually, F
[10] =r). L[1] and F
[10] are the first occurrence of the symbol “r” in both columns L and F, respectively. The algorithm then obtains the symbol L
[10] =“b” as the preceding symbol of “r” in S. These steps are then repeated for each remaining preceding symbol of the string S.
[0279] As described above about the bijective correspondence between the rows of the rotation matrix M and the suffixes of the string S, as well as the relationship between the last column L and the suffix array built on S, these relationships are central to the design of the FM index discussed above. The FM index allows for efficient substring searches and space occupancy of the size of the string size approximately n. Thus, three basic search operations underlie the design of such indexing searches: count(P) returns the range [first, last] of rows in M that have a prefix of the string P, where the value (last-first+1) compensates for the number of pattern occurrences; locate(P) returns a list of all positions in the string S where P occurs, where the list is sorted or unsorted; and extract(i,j) returns the substring S[i,j] by accessing its compressed representation in the FM index. For example, in FIG. 17, for pattern P=“ab”, indexes first=2 and last=3 return a total of two pattern occurrences. These two rows correspond to the suffixes S[0,1] and S[7,:] and have the prefix of the pattern P.
[0280] As discussed above in connection with Figures 26-29, retrieval of rows first and last is not performed via a binary search, but rather uses a search method that introduces additional data structures that efficiently correspond to a column L, an array C (which counts the number of occurrences in s of all symbols in C[c] that are less than c), and a count rank(c,k) that reports the number of occurrences of symbol c in a string prefix L[0,k-1]. All data structures L, C, and rank can be stored in a compressed state and still efficiently retrieve their entries, i.e., accesses L[i] or C[c], or respond with rank(c,k).
[0281] FIG. 32 illustrates a method 3200 configured to implement count(P) using the above ensemble according to an exemplary implementation. Step 3202 involves setting a loop counter i equal to p-1, which indicates the last position in the pattern P. A variable symbol c is set equal to the last symbol in P, as denoted by P[p-1]. In step 3204, a first index h is set equal to a counter entry for the variable symbol c, as denoted by C[c], where C is a counter array derived from the Burrows-Wheeler transform of the symbol string. A last index z is set equal to one less than the counter entry at position c+1. The first and last indexes h and z bound the range of values in the first column F of the matrix M' derived from the BWT. A decision block 3206 checks whether the first index h is less than the last index z and whether the loop counter i is greater than or equal to one. If both conditions are met (Y), then in step 3208, the variable symbol c is set to the previous symbol of pattern P. A new first index h is set equal to the counter entry for c plus the rank of the BWT calculated at position h-1 for symbol value c. A new last index z is set equal to one less the counter entry for c plus the rank of the BWT calculated at position z for symbol value c. The loop counter i is decremented by one and the method returns to step 3204.
[0282] Each iteration step 3204-3208 of the method 3200 holds the following invariants: At the i-th stage, parameter "h" refers to the first row of the sorted rotation matrix M' with prefix P[i,p-1], and parameter "z" refers to the last row of M' with prefix P[i,p-1]. Initially, the invariants are true by construction, and for the first column F, F[C[c]] is the first row of M' starting from c, and F[C[c+1]-1] is the last row of M' starting from c. Referring again to the example of P="ab" for FIG. 17, the initial conditions are C[b]=6 and C[b+1]=C[c]=8, and [6,7] is the range of rows with prefix b before the backward search begins.
[0283] In each subsequent iteration, method 3200 discovers a range [h,z] of lines having the prefix P[i,p-1]. The method then involves determining a new range [h,z] of lines having the prefix P[i-1,p-1]=P[i-1]P[i,p-1] by proceeding as follows. First, by introducing a suitably queried function rank, the first and last occurrences of symbol c=P[i-1] within substring L[h,z] are determined. Specifically, rank(c,h-1) counts how many occurrences of c precede position h within L, and rank(c,z) counts how many occurrences of c precede position z within L. These values are then used to calculate the LF mapping of those first / last occurrences of c. The equivalent LF[i]=C[L[i]]+rank(L[i],i) exists. This equivalence means that, on the condition that the data structure implementing rank(c,k) is densely stored, the calculation of the LF mapping can be performed efficiently and concisely. Referring again to Figure 17, as described above, consider the range [6,7] of lines within M' having pattern P="ab" and prefix P[2]="b". Next, choosing the aforementioned pattern symbol P[1]="a", since L[0,h-1] contains one occurrence of "a" and L[0,z] contains three occurrences of "a", algorithm 5 calculates rank("a",5)=1 and rank("a",7)=3. Thus, the algorithm calculates the new range as h=C["a"]+rank("a",5)=1+1=2, z=C["a"]+rank("a",7)-1=1+3-1=3, which is the adjacent range of lines having the prefix pattern P="ab". After the last step (i.e., i=0), first and last delimit the boundaries of the lines of M' that contain all suffixes having the prefix P. If z<h, the pattern P does not occur in S.
[0284] In the following, we describe an implementation of locating pattern occurrences via the procedure locate(P). For a fixed parameter μ, we sample rows i of M′ that correspond to suffixes starting at positions of the form pos(i)=jμ, for j=0, 1, 2, .... For each such pair<i,pos(i)> are explicitly stored in a data structure L that corresponds to membership queries in constant time (on row components). Then, given a row index r, if r in L is a sampled row, the value pos(r) can be derived immediately, otherwise the algorithm relies on j=LF for t=1, 2, ..., by the time j becomes a sampled row and is found in L. t (r), where pos(r) = pos(j) + t. The sampling strategy ensures that a row in L is found in at most μ iterations, and that occ occurrences of pattern P can be located in the rank data structure via approximately (μ × occ) queries.
[0285] Note that count(P) can be adapted to implement the last elementary operation extract(i,j) that is addressed by the FM index. Let r be a row of M' with suffix S[j,n-1], and assume that the value of r is known. The algorithm sets S[j] = F[r], then s[j-1-t] = L[LF, for t = 0, 1, ..., ji-1. t We begin the cycle of setting [r]]. The idea behind this cycle is that we iteratively calculate the LF mapping of the current symbol (implemented via the rank data structure), thus jumping backwards in S starting from S[j-1]. After ji-1 steps, the process stops when S[i] is reached. This approach is similar to that obtained with the BWT transposition, the difference being that the array LF is not explicitly available, but relies on its entries being generated step by step via rank operations. This approach still guarantees constant time access to the LF array, but a compact spatial storage if a compression approach on the ranks is adopted.
[0286] In addition to the chemical methods for accessing, reading, ranking, and searching described above, chemical methods for performing "if-then-else" operations are also described herein. An "if-then-else" operation is an instruction, expression, or construct that performs a different calculation or action depending on whether a specified Boolean condition evaluates to true or false. This operation can be used to write conditional programs. Each "if" operation tests the presence or absence of one or more identifiers and, depending on their presence or absence, proceeds to a "then" or "else" branch. The operation can include multiple conditions and corresponding branches. An output can be produced from all branches of the operation. This approach allows all of the identifiers in multiple identifier libraries (e.g., terabit scale) to be computed in parallel. For example, if the library encodes billions of data objects, a complex function that examines each object and produces an output can be designed as a DNA-based program and executed in parallel on the library.
[0287] The approach to bit shifting, copying, and moving allows a single identifier library to be rearranged into multiple input identifier libraries for the execution of a desired program. Physically, each if-then-else operation can be performed in a reaction with one input library and two output libraries, and multiplexed across all identifiers in those libraries. By fluid communication, the output library of one operation can be directed to the input library of another operation. Although the execution of each operation in DNA can be slow compared to conventional hardware, unlike conventional hardware limited by RAM and processing power, the DNA platform described herein is capable of executing programs simultaneously and at low power across a large number of input data objects.
[0288] 33 shows a flow diagram illustrating a method 3300 of performing one or more if-then-else operations on a pool of identifiers. Step 3302 of the method 3300 involves obtaining a first pool of identifiers that represent one or more input symbol strings. Step 3304 involves performing an if-then-else operation on the identifiers to create an intermediate pool having a subset of identifiers from the first pool of identifiers. Step 3306 involves repeating one or more if-then-else operations on the intermediate pool, creating a new intermediate pool after each if-then-else operation until a final pool of identifiers is generated, the final pool representing the output symbol string.
[0289] The pool has a powder, liquid, or solid form. Each identifier in the pool of identifiers is a nucleic acid molecule that includes a component nucleic acid molecule. At least a portion of the component nucleic acid molecules can be individually bound to one or more probes, such as PCR primers or affinity tagged oligonucleotides. Each identifier can include a component that is separate from each of the M layers, where each layer includes a set of components.
[0290] The if-then-else operations of steps 3304 and 3306 target at least one component of the identifier with a probe. The operations can involve accessing the identifier in a pool that includes unique components. For example, the probe is a PCR primer and the identifier is accessed via PCR. As another example, the probe is an affinity tagged oligonucleotide and the identifier is accessed via an affinity pull-down assay. Multiple if-then-else operations can be performed in parallel on one or more pools. For example, two operations are performed in parallel in two identifier pools.
[0291] The method 3300 may further involve splitting at least one of the first pool, the intermediate pool, or the final pool into at least two replicate pools. This splitting may allow for parallelized if-then-else operations. To ensure sufficient concentration of identifiers, the pools may be replicated, e.g., using PCR, prior to splitting. Two or more pools (e.g., intermediate pools) may be combined to form a new pool of identifiers (e.g., a new intermediate pool or second pool).
[0292] As another application, a search for bit strings of length n can be performed across the unstructured data in DNA with a runtime equivalent to just one instance of a comparator circuit (approximately log(n)). An equivalent search performed on conventional hardware would further compensate for the cost and time of moving the data to RAM. Further to this application, consider searching a large data set for any possible pattern after the data is encoded, as is common with large stored data sets. For example, the patterns could all be photos of a person of interest from a large data warehouse of images. After the archive is written, one can consider functions capable of discovering desired patterns in the data. Such functions can be constructed, for example, using machine learning algorithms. These pattern discovery functions have Boolean circuit expressions and can be implemented in DNA using if-then-else operations. The operations can be applied to all data objects of the data set simultaneously according to the learned model, and objects matching the pattern of interest can be identified. Performing the same operations in conventional hardware would be expensive and slow due to limited RAM and processor availability. As the learning algorithms improve, updates can be applied to the stored data set to discover new information of interest. Another exemplary application is in space-time signal processing, where a convolution function (which underlies digital signal processing functions such as the Fourier transform) may be applied to stored data over multiple small windows in time or space when searching for particular patterns. As another example, a hash function may be applied to objects in a large data set for security (e.g., authentication) or integrity (e.g., security inspection) applications.
[0293] If the input data describes a set of objects, the input data can be uniquely encoded in an identifier library, such that each identifier represents a possible object in the set. In this encoding, chemical methods for "AND", "OR", and "NOT" operations between two identifier libraries implement the set operations of "INTERSECTION", "UNION", and "COMPLEMENT" defined in the art with constant runtime. Chemical methods for performing set inclusion (determining whether one set is a subset of another set) and equivalents can also be performed on the DNA platform. These operations and relations can be used together to perform any function in set algebra.
[0294] The DNA platform may also include support for machine learning (ML). ML conceptual indexing utilizes high-dimensional vectors to organize and annotate data. The system described herein provides uniquely efficient storage and querying for such data, fully enabling the ability of ML models to capture relevant concepts and relationships within the data. Operations on DNA, such as permutation and summation, can be implemented as vector operations, as known in the art, to efficiently discover, store, and query conceptual relationships. The identifier library can be used as a platform to build intelligent memories that integrate the inherent storage and structure of the storage medium. A DNA-based storage system is uniquely responsive to algorithms and data structures for the platform. Long-lived, ultra-low-power memory banks can be configured to continually organize data into conceptual structures, enabling semantically rich queries and inferences.
[0295] The above is merely illustrative of the principles of the present disclosure, and the apparatus and method may be implemented in other implementations than those described, which are presented for purposes of illustration and not limitation. Variations and modifications will occur to those skilled in the art upon reading this disclosure. The disclosed features may be implemented in any combination and subcombination (including multiple dependent combinations and subcombinations) with one or more other features described herein. The various features described or illustrated above, including any components thereof, may be combined or integrated in other systems. Furthermore, certain features may be omitted or not implemented.
[0296] Examples of changes, substitutions, and modifications would be ascertainable by one skilled in the art and could be made without departing from the scope of the information disclosed herein. All references cited herein are incorporated by reference in their entirety and constitute a part of this application. The present invention provides, for example, the following: (Item 1) 1. A method for obtaining a rank of a particular bit in a bit string from digital information stored in a pool of nucleic acid molecules, each bit having a bit value and a bit position, the method comprising: (a) obtaining a first pool of identifier nucleic acid molecules representing the bit string, the pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules configured to bind to one or more probes; (b) obtaining a second pool of identifier nucleic acid molecules representing counter symbol strings derived from the bit string, the second pool being represented by a string of b counter bits, each counter symbol indicating a running count of the number of bits for all w bits in the bit string having a unique bit value; (c) obtaining a first count by accessing the second pool of (b) with a second series of probes to target at least the identifier nucleic acid molecules in the second pool that represent corresponding counter symbols indicative of the running count of the number of bits of a given value for either (1) all blocks of w bits preceding the particular bit, or (2) all blocks of w bits preceding the particular bit, including the block of w bits that includes the particular bit; (d) obtaining a second count by accessing the first pool of (a) with a first series of probes to target one or more distinct identifier nucleic acid molecules in the first pool that represent bits not counted in (c) that precede or include the particular bit, or bits that were counted in (c) but do not precede or include the particular bit; (e) obtaining the rank of the particular bit in the bit string from the first count and the second count; and The method includes: (Item 2) 2. The method of claim 1, wherein the identifier nucleic acid molecules in the first pool represent the bit string such that the presence of an identifier represents the bit value "1" at a bit position. (Item 3) 3. The method of any of items 1 and 2, wherein when the first count in (c) represents all blocks of w bits preceding the particular bit, the first set of probes in (d) targets one or more distinct identifier nucleic acid molecules in the first pool representing bits not counted in (c) that precede or include the particular bit, and the rank of the particular bit in the bit string is obtained by summing the first and second counts in (e). (Item 4) 3. The method of any of items 1 and 2, wherein when the first count of (c) represents all blocks of w bits including the block of w bits preceding and including the particular bit, the first series of probes targets one or more distinct identifier nucleic acid molecules in the first pool that represent bits counted in (c) but that do not precede or include the particular bit, and the rank of the particular bit in the bit string is obtained by subtracting the second count of (e) from the first count. (Item 5) 5. The method according to any one of items 1 to 4, wherein the first count is obtained by reading counter symbol values corresponding to the targeted identifier nucleic acid molecules of (c). (Item 6) 6. The method of any of items 1 to 5, wherein the second count is obtained by reading the targeted identifier nucleic acid molecules from (d). (Item 7) The method according to any of items 1 to 6, wherein the first pool of (a) is the second pool of (b). (Item 8) 7. The method according to any one of items 1 to 6, wherein the first pool of (a) is separate from the second pool of (b). (Item 9) 9. The method according to any of items 1 to 8, wherein the presence of a corresponding identifier nucleic acid molecule in the first pool indicates the bit value 1, and the absence of a corresponding identifier nucleic acid molecule in the first pool indicates the bit value 0. (Item 10) The bit string has length n and b is log 2 The method according to any one of items 1 to 9, wherein the upper limit of (n+1) is (n+1). (Item 11) Item 11. The method of item 10, wherein the counter symbol string is represented by a counter bit string including an upper limit of n divided by w counter symbols and having a length corresponding to b multiplied by the upper limit of n divided by w. (Item 12) 12. The method of any of items 1 to 11, wherein if the particular bit is within the first block of w bits, then the running count preceding the first block of w bits is 0. (Item 13) 13. The method according to any of items 1 to 12, wherein if the particular bit is not within the first block of w bits, then the counter symbols of all blocks of w bits preceding the particular bit represent the number of bits in the bit string having value 1 within a position range from 0 to w*B(x)-1, where 0 is the first position of the bit string, x corresponds to the position of the particular bit in the bit string, and B(x) is the lower bound of x divided by w. (Item 14) Item 14. The method of item 13, wherein the targeted identifier nucleic acid molecules in the second pool of (c) are within the range defined by positions b*B(x) and b*(B(x)+1)-1, and a position of 0 corresponds to the first position in the bit string. (Item 15) 15. The method of any of items 1 to 14, wherein the second count corresponds to the number of bits in the bit string that have a value of 1 within the range of positions w*B(x) to x, where x corresponds to the position of the particular bit in the bit string, position 0 being the first position, and B(x) being the lower bound of x divided by w. (Item 16) 16. The method according to any of items 1 to 15, wherein w is set to the value of b. (Item 17) 16. The method according to any of items 1 to 15, wherein w is set to a value of 1. (Item 18) 20. The method of claim 17, wherein the first count is obtained by targeting an identifier nucleic acid molecule of (c) that represents the counter symbol corresponding to the block of w bits that includes the particular bit, and the rank is equal to the first count. (Item 19) Item 19. The method of item 18, wherein step (d) is not performed. (Item 20) 20. The method of any of items 1 to 19, wherein blocks of bits in the bit string are mapped to blocks of contiguously ordered identifier nucleic acid molecules in the first pool of identifier nucleic acid molecules. (Item 21) 21. The method of claim 20, wherein the presence or absence of an identifier nucleic acid molecule in the first pool does not directly correlate with any bit value in the bit string. (Item 22) 22. The method of any of items 20 and 21, wherein fixed length substrings (words) of the bit string are mapped to codewords that contain a fixed number of unique identifier nucleic acid molecules from a fixed number of possible unique identifier nucleic acid molecules. (Item 23) 23. The method of any of items 1 to 22, further comprising detecting and correcting errors in writing, accessing, and reading identifier nucleic acid molecules from the first and second pools using additional information. (Item 24) 24. The method of claim 23, wherein the additional information is stored in the identifier nucleic acid molecules of the first and second pools. (Item 25) 25. The method according to any of items 1 to 24, wherein the bit string represents a symbol string and the rank is obtained for a particular symbol within the symbol string. (Item 26) 26. The method of claim 25, wherein the symbols in the symbol string are selected from a set of symbol values, and the counter symbol string in (b) indicates a running count of the number of symbols having the particular symbol value. (Item 27) 27. The method of any of items 25 and 26, wherein the different second pools of identifier nucleic acid molecules of (b) represent different counter symbol strings that count the number of instances of a unique symbol value, each different counter symbol string counting the number of instances of a corresponding unique symbol value. (Item 28) 28. The method of any of items 1 to 27, further comprising forming an identifier nucleic acid molecule by physically assembling M selected component nucleic acid molecules, each of said M selected component nucleic acid molecules being selected from a set of distinct component nucleic acid molecules separated into M distinct layers. (Item 29) 1. A method for fetching digital information from a pool of nucleic acid molecules, comprising: (a) obtaining a first pool of identifier nucleic acid molecules, the pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules configured to bind to one or more probes, the identifier nucleic acid molecules representing symbol strings, such that the symbol value is indicated by the presence or absence of the corresponding identifier nucleic acid molecule in the first pool; (b) accessing the first pool with a first set of probes, each of the first set of probes targeting at least one of the component nucleic acid molecules to create a second pool having a subset of identifier nucleic acid molecules from the first pool; (c) sequencing a subset of the identifier nucleic acid molecules from the second pool; and (d) using the array to obtain at least a subset of the symbols in the symbol string from (a); The method includes: (Item 30) 30. The method of claim 29, wherein each identifier nucleic acid molecule comprises a separate component nucleic acid molecule having a component nucleic acid sequence from each of the M layers, each layer comprising a set of said component nucleic acid sequences. (Item 31) Item 31. The method of item 30, wherein the M layers are logically ordered. (Item 32) 32. The method of claim 31, wherein the component nucleic acid sequences of each layer are logically ordered. (Item 33) 33. The method of claim 32, wherein the identifier nucleic acid molecules correspond to logically ordered identifier nucleic acid sequences by grouping the identifier nucleic acid sequences by corresponding component nucleic acid sequences in a first stratum, subdividing the identifier nucleic acid sequences by corresponding component nucleic acid sequences in a second stratum, and repeating the subdivision process for each of the remaining M-2 stratum. (Item 34) 34. The method of claim 33, wherein each identifier sequence comprises a series of component nucleic acid sequences represented as a path in a query tree, the query tree starting at a root node, branching across M instances with one instance at each layer, and terminating at leaf nodes, each leaf node representing an identifier nucleic acid sequence. (Item 35) Item 35. The method of item 34, wherein the first series of probes corresponds to a partial or full path from the root node in the query tree. (Item 36) 36. The method of claim 35, wherein the full path corresponds to a root-to-leaf path comprising M probes, such that the set of probes targets a single identifier nucleic acid molecule. (Item 37) 37. The method of claim 36, wherein the partial paths correspond to fewer than M probes, such that the set of probes targets multiple populations of identifier nucleic acid molecules having different sequences. (Item 38) 38. The method of claim 37, wherein the plurality of populations of identifier nucleic acid molecules having different sequences correspond to different component nucleic acid molecules in at least the M stratum. (Item 39) 39. The method according to any of items 29 to 38, wherein the first pool is accessed by a plurality of sets of probes. (Item 40) 40. The method of claim 39, further comprising splitting the first pool of (a) into at least two replicate pools, wherein (b), (c), and (d) are performed on each of the replicate pools having each of the sets of probes. (Item 41) 41. The method of claim 40, further comprising replicating the first pool prior to dividing the first pool into at least two replicate pools. (Item 42) 42. The method of claim 41, further comprising accessing the first pool of identifier nucleic acid molecules with a subseries of probes to create an intermediate pool of identifier nucleic acid molecules. (Item 43) 43. The method of claim 42, further comprising splitting the intermediate pool of identifier nucleic acids into at least two replicate pools. (Item 44) 44. The method of claim 43, further comprising replicating the intermediate pool prior to dividing the intermediate pool into at least two replicate pools. (Item 45) 45. The method of any of items 39 to 44, further comprising accessing the first intermediate pool of identifier nucleic acid molecules with a subsequent subseries of probes to form a second intermediate pool of identifier nucleic acid molecules or a second pool of identifier nucleic acid molecules. (Item 46) 46. The method of any of items 39 to 45, further comprising combining at least two intermediate pools of identifier nucleic acid molecules to form another intermediate pool of identifier nucleic acid molecules or a second pool of identifier nucleic acid molecules. (Item 47) 45. The method according to any of items 41 and 44, wherein the replication is carried out by polymerase chain reaction (PCR). (Item 48) 48. The method according to any of items 29 to 47, wherein the probe is a PCR primer and the accessing is carried out by polymerase chain reaction. (Item 49) 48. The method according to any of items 29 to 47, wherein the probe is an affinity-tagged oligonucleotide and the accessing is performed by an affinity pull-down assay. (Item 50) 1. A method for obtaining a count of a particular bit pattern of length p in a message containing a bit string of length n, comprising the steps of: (a) obtaining a first pool of identifier nucleic acid molecules representing a bit string L, the bit string L being a last column of a Burrows-Wheeler transformation matrix for the message, the first pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules configured to bind to one or more probes; (b) obtaining a second pool of identifier nucleic acid molecules representing counter symbol strings derived from the bit string L, where each counter symbol is represented by a string of b counter bits indicating a running count of the number of bits for all w bits in the bit string L having a unique bit value "1"; (c) using a series of probes to access the identifier nucleic acid molecules from the second pool that represent the counter symbols for a total number of occurrences of a bit value "1" in the bit string L; (d) reading the accessed identifier nucleic acid molecules of (c) to count the total number of occurrences of bit value "1" in the bit string L; (e) reconstructing a first column F of the Burrows-Wheeler transform matrix for the message using the total number of occurrences of each bit value from (d); (f) determining a first position h and a last position z, inclusive, that define a range of bit values for the pth bit in the first sequence F; (g) using a first set of probes to access the identifier nucleic acid molecules from the first pool and the second pool to identify the rank r of the (pi) bit values of the patterns at position h-1 in L; h-1 where i=1, and (h) using a second set of probes to access the identifier nucleic acid molecules from the first pool and the second pool to determine the rank r of the (pi) bit values of the patterns at position z in L. z Calculating (i)r h-1 is z setting the count of occurrences of the pattern in the message as 0 if (j) No, r h-1 is z If it is not equal to (j1) h is the (r)th bit of the (pi) in F h-1 +1) to the index of the instance, (j2) z is the rth bit of the (pi) in F z Set it to the index of the instance of (j3) Increment i by 1, (j4) repeating steps (g), (h), (i), (j), (j1), (j2), and (j3) multiple times until i=p-1; (j5) calculating the count of occurrences of the pattern in the message as z-h+1. (Item 51) 51. The method of claim 50, wherein the first pool of (a) is the second pool of (b). (Item 52) 51. The method of claim 50, wherein the first pool of (a) is separate from the second pool of (b). (Item 53) 53. The method according to any of items 50 to 52, wherein the presence of a corresponding identifier nucleic acid molecule in the first pool indicates the bit value 1, and the absence of a corresponding identifier nucleic acid molecule in the first pool indicates the bit value 0. (Item 54) b is log 2 54. The method according to any one of items 50 to 53, wherein the upper limit of (n+1). (Item 55) 55. The method of claim 54, wherein the counter symbol string is represented by a counter bit string including an upper limit of n divided by w counter symbols and having a length corresponding to b multiplied by the upper limit of n divided by w. (Item 56) 56. A method according to any of items 50 to 55, wherein the running count of every bit value preceding the first block of w bits in L is zero. (Item 57) 57. The method according to any of items 50 to 56, wherein w is set to the value of b. (Item 58) 58. The method according to any of items 50 to 57, wherein w is set to a value of 1. (Item 59) 59. The method of any of items 50 to 58, further comprising mapping blocks of bits in the bit string L to blocks of contiguously ordered identifier nucleic acid molecules in the first pool. (Item 60) 60. The method of claim 59, wherein fixed length substrings of the bit string L are mapped to codewords represented by a fixed number of unique identifier nucleic acid molecules selected from a fixed size set of unique identifier nucleic acid molecules. (Item 61) 61. The method of any of items 50 to 60, wherein additional information is used to detect and correct errors in writing, accessing and reading identifier nucleic acid molecules from the first and second pools. (Item 62) 62. The method of claim 61, wherein the additional information is stored in the identifier nucleic acid molecules of the first and second pools. (Item 63) obtaining a third pool of identifier nucleic acid molecules representing a suffix array SA derived from a Burrows-Wheeler transformation of the message, wherein each element of SA is at least log 2 63. The method according to any of items 50 to 62, represented by a bit string of (n) bits. (Item 64) Item 64. The method of item 63, further comprising locating the occurrence of the pattern in the message by accessing the identifier nucleic acid molecule in the third pool that corresponds to an element in the suffix array at a position between h and z that includes the final values for h and z when the count is greater than 0. (Item 65) 65. The method of claim 64, further comprising obtaining a fourth pool of identifier nucleic acid molecules representing the message. (Item 66) Item 66. The method of item 65, further comprising extracting a context of the first location of the pattern by accessing the identifier nucleic acid molecules in the fourth pool that correspond to a vicinity of the first location and locations surrounding the first location. (Item 67) 1. A method for obtaining a count of a particular bit pattern of length p in a message containing a bit string of length n, comprising the steps of: (a) obtaining a first pool of identifier nucleic acid molecules representing a bit string L, the bit string L being a last column of a Burrows-Wheeler transformation matrix for the message, the first pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules configured to bind to one or more probes; (b) obtaining a second pool of identifier nucleic acid molecules representing a counter symbol string derived from said bit string L, the counter symbol string representing a running count of the number of bits having a unique bit value; (c) obtaining the count of the particular bit pattern in the message by selectively accessing identifier nucleic acid molecules from the first pool and the second pool; The method includes: (Item 68) Item 68. The method of item 67, wherein step (c) further comprises reconstructing a first column F of the Burrows-Wheeler transformation matrix. (Item 69) Item 69. The method of item 68, wherein step (c) comprises using a series of probes to access the identifier nucleic acid molecules from the second pool that represent the counter symbols for a total number of occurrences of the unique bit value in the bit string L, and reconstructing F using the total number of occurrences of the unique bit value. (Item 70) 70. The method of any of items 68 and 69, wherein step (c) further comprises determining a range of positions in F having a pth bit value in the pattern. (Item 71) Item 71. The method of item 70, wherein the range of positions in F is defined by a first position h and a last position z, inclusive of h and z. (Item 72) Step (c) comprises, for each preceding bit in the pattern after the pth bit: accessing the identifier nucleic acid molecules from the first pool and the second pool using a series of probes to determine a first rank of the corresponding bit values in L at a position immediately preceding the range and a second rank of the corresponding bit values in L at a terminal position of the range; and updating the range using the first rank and the second rank to a range of positions in F having an instance of the corresponding bit that precedes a subsequent bit in the pattern. (Item 73) Item 73. The method of item 72, wherein the first rank is the value of the respective preceding bit in the pattern at position h-1 in L, and the second rank is the value of the respective preceding bit in the pattern at position z in L. (Item 74) Item 74. The method of item 73, wherein updating the range includes setting h to the position of one instance of the respective preceding bit value in the pattern in F based on the first rank. (Item 75) 75. The method of any of items 73 and 74, wherein updating the range includes setting z to the position of one instance of the respective preceding bit value in the pattern in F based on the second rank. (Item 76) 76. A method according to any of items 72 to 75, wherein step (c) further comprises setting the count of occurrences of the pattern within the message based on the final values of the first and second ranks. (Item 77) Item 77. The method of item 76, wherein the count of occurrences is the difference between the final values of the first and second ranks. (Item 78) Item 77. The method of item 76, wherein if the first and second ranks are equal to each other for the pth bit or any preceding bit, then the count of occurrences is set to 0. (Item 79) Length n s The symbol string of length p in the message s 11. A method of obtaining a count of a particular symbol pattern of r symbols, each symbol being selected from a set of r symbol values, the method comprising: (a) obtaining a first pool of identifier nucleic acid molecules representing a symbol string L that is a last column of a Burrows-Wheeler transformation matrix for the message, the first pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules configured to bind to one or more probes; (b) obtaining a second pool of r identifier nucleic acid molecules, each of the identifier nucleic acid molecules comprising a counter symbol string C derived from L; v where v=1, 2, ..., r and the corresponding symbolic value R v obtaining a second pool of r representing a running count of the number of symbols in L having (c) selectively accessing identifier nucleic acid molecules from the first pool and the r second pools to identify identifier nucleic acid molecules of length p s and obtaining the count of a particular symbol pattern of. (Item 80) 80. The method of claim 79, wherein step (c) further comprises reconstructing a first column F of the Burrows-Wheeler transformation matrix. (Item 81) Step (c) uses a series of probes to find each corresponding symbol value R in L. v accessing the identifier nucleic acid molecule from the last counter symbol in each of the r second pools, which represents a total number of occurrences ofv and reconstructing F using said total number of occurrences of (Item 82) 82. A method according to any of items 80 and 81, wherein step (c) further comprises determining a range of positions in F having a pth symbol value in the pattern. (Item 83) 83. The method of claim 82, wherein the range of positions in F is defined by a first position h and a last position z, inclusive of h and z. (Item 84) Step (c) comprises, for each preceding symbol in the pattern after the pth symbol: accessing the identifier nucleic acid molecules from the first pool and the corresponding second pool using a series of probes to determine a first rank of the corresponding symbol values within L at a position immediately preceding the range and a second rank of the corresponding symbol values within L at a terminal position of the range; updating the range using the first rank and the second rank to a range of locations in F having an instance of the corresponding symbol that precedes a subsequent symbol in the pattern; 84. The method according to any one of items 82 and 83, further comprising: (Item 85) The first rank r h-1 is the respective preceding symbol value in the pattern at position h-1 in L, and the second rank r z Item 85. The method of item 84, wherein L is the respective preceding symbol value in the pattern at position z in L. (Item 86) Updating the range means dividing h by the (r h-1 Item 86. The method of item 85, comprising setting the position of the instance of the first digit (+1). (Item 87) Updating the range may involve dividing z by the rth range of each preceding symbol value in the pattern in F. z 87. The method of any of items 85 and 86, comprising setting an index of an instance of (Item 88) 88. A method according to any of items 84 to 87, wherein step (c) further comprises setting the count of occurrences of the pattern within the message based on the final values of the first and second ranks. (Item 89) Item 89. The method of item 88, wherein the count of occurrences is the difference between the final values of the first and second ranks. (Item 90) Item 89. The method of item 88, wherein if the first and second ranks are equal to each other for the pth symbol or any preceding symbol, the count of occurrences is set to 0. (Item 91) The first pool of identifier nucleic acid molecules is one of r first pools, each of the r first pools being represented by a bit string L v where v=1, 2, ..., r, and so L v The elements of the symbol value R v 91. The method according to any of items 79 to 90, wherein for elements of L that match L have a bit value "1" and otherwise a bit value "0", or vice versa. (Item 92) L v The first pool corresponds to the symbol value R v Item 92. The method of item 91, wherein the first and second ranks are determined using the method of item 91. (Item 93) obtaining an SA pool, which is a pool of identifier nucleic acid molecules representing a suffix array SA derived from the Burrows-Wheeler transformation of the message, wherein each element of SA is at least log 2 93. The method according to any of items 79 to 92, represented by a bit string of (n) bits. (Item 94) Item 94. The method of item 93, further comprising locating the occurrence of the pattern in the message by accessing an identifier nucleic acid molecule in the SA pool that corresponds to an element of the SA at a position given by a final range of positions in F, assuming that the count is greater than 0. (Item 95) 95. The method of claim 94, further comprising obtaining a message pool of identifier nucleic acid molecules representing the message. (Item 96) Item 96. The method of item 95, further comprising extracting a context of the first location of the pattern by accessing the identifier nucleic acid molecules in the message pool that correspond to a first location and a neighborhood of locations surrounding the first location. (Item 97) Step (c) (c.1) determining a first location h and a last location z, inclusive, that define a range of the p symbol values in the first sequence F; (c.2) using a series of probes to access the identifier nucleic acid molecules from the first pool and the second pool, and determining a rank r of the (pi)th symbol value of the pattern at position h-1 in L; h-1 where i=1, and (c.3) accessing the identifier nucleic acid molecules from the first pool and the second pool using a series of probes and determining a rank r of the symbol value of the (pi) of the pattern at position z in L; z Calculating (c.4)r h-1 is z setting the count of occurrences of the pattern in the message as 0 if (c.5) No, r h-1 is z If it is not equal to (c.5.A) h is the (r h-1 +1) to the index of the instance, (c.5.B) z is the rth symbol value of (pi) in F z Set it to the index of the instance of (c.5.C) Increment i by 1; (c.5.D) Repeat steps (c.2), (c.3), (c.4), (c.5), (c.5.A), (c.5.B), and (c.5.C) multiple times until i=p-1; (c.5.E) calculating said count of occurrences of said pattern in said message as z-h+1; The method according to any one of items 79 to 96, comprising: (Item 98) Item 98. The method of item 97, wherein the first pool and the second pool of (c.2) correspond to the (pi) symbol values of the pattern. (Item 99) 99. The method of any of items 97 and 98, wherein the first pool and the second pool of (c.3) correspond to the (pi) symbol values of the pattern. (Item 100) 1. A method for storing digital information in a nucleic acid molecule, comprising: Obtaining a plurality of blocks, each block including a symbol string and associated with a block ID; allocating a block of the plurality of blocks to a container; mapping the blocks to a plurality of identifier nucleic acid sequences associated with the container, each identifier nucleic acid sequence comprising a component nucleic acid sequence, at least a portion of the component nucleic acid sequences configured to bind to one or more probes; constructing individual identifier nucleic acid molecules of said plurality of identifier nucleic acid sequences; storing said individual identifier nucleic acid molecules in said assigned containers; wherein a physical address including an identity of the container and the plurality of identifier nucleic acid sequences associated with the container is determined using the associated block ID. (Item 101) Item 101. The method of item 100, wherein the block ID is an integer, a string, a triple, an attribute list, or a semantic annotation. (Item 102) 102. The method of any of items 100 and 101, wherein the physical address is stored in a data structure designed to facilitate accessing the physical address using the associated block ID. (Item 103) Item 3. The method according to any of items 100 to 102, wherein the data structure is one of a B-tree, a trie, or an array. (Item 104) 14. The method of any of items 102 and 103, wherein at least a portion of the data structure is stored in an index together with the digital information. (Item 105) 15. The method of claim 104, wherein the index comprises a second plurality of identifier nucleic acid sequences associated with a second container. (Item 106) Item 106. The method of item 105, wherein the index comprises a B-tree data structure, each node of the B-tree comprising a distinct plurality of identifier nucleic acid molecules of the second plurality of identifier nucleic acid sequences. (Item 107) searching for the block ID in the B-tree; accessing the distinct plurality of identifier nucleic acid molecules comprising a first node; reading a value of the first node; Repeating the process of steps (i) and (ii) for subsequent nodes; Item 107. The method of item 106, comprising: wherein the identity of the distinct plurality of identifier nucleic acid molecules that comprises the subsequent node is determined by the block ID associated with the value of the first node. (Item 108) Item 108. The method of item 107, wherein the first node is a root node of the B-tree, and the process of steps (i) and (ii) continues until a value of a leaf node of the B-tree is read, the value of the leaf node being configured to communicate whether a block exists for the block ID and, if the block ID exists, to communicate the physical address of the block. (Item 109) Item 106. The method of item 105, wherein the index comprises a trie data structure, each node of the trie comprising a distinct plurality of identifier nucleic acid molecules of the second plurality of identifier nucleic acid sequences. (Item 110) Item 109. The method of item 109, wherein the block ID is a symbol string and each node in the trie data structure corresponds to a possible prefix of the symbol string. (Item 111) Item 111. The method of item 110, wherein a leaf node of the trie data structure represents the physical address associated with the block ID that matches the symbol string specified by the trie data structure in the leaf node. (Item 112) 105. The method of claim 104, wherein the data structure is an array, and each element of the array comprises a distinct plurality of identifier nucleic acid molecules of the second plurality of identifier nucleic acid sequences. (Item 113) Item 113. The method of item 112, wherein each element in the array corresponds to a block ID. (Item 114) Item 114. The method of item 113, wherein each element of the array stores the physical address of the associated block ID. (Item 115) 115. The method of any of items 104 to 114, further comprising accessing physical addresses from a pool of identifier nucleic acid molecules comprising the second plurality of identifier nucleic acid sequences using a set of probes. (Item 116) Item 103. The method of item 102, wherein the data structure is stored in a magnetic storage device, an optical storage device, a flash memory device, or cloud storage. (Item 117) Item 102. The method of item 101, wherein the physical address is configured to be specific to the block ID such that the block ID can be mapped to the physical address without storing the physical address in an additional data structure. (Item 118) Item 118. The method of item 117, wherein the block ID is mapped to a plurality of component nucleic acid sequences shared by all identifier nucleic acid sequences of the plurality of identifier nucleic acid sequences associated with the physical address. (Item 119) 19. The method according to any of items 100 to 118, wherein the plurality of identifier nucleic acid sequences associated with a block comprises contiguously ordered identifier nucleic acid sequences, such that the plurality of identifier nucleic acid sequences are assigned to corresponding physical addresses by an identifier range that includes the identity of the first and last identifier nucleic acid molecules in the identifier range. (Item 120) Item 120. The method of item 119, wherein the first and last identifier nucleic acid sequences in the identifier range are represented by integers. (Item 121) 121. The method of any of items 100 to 120, further comprising accessing a plurality of nucleic acid molecules associated with the block by using a series of probes. (Item 122) 122. The method according to any of items 115 and 121, wherein the probe is a PCR primer and the accessing is carried out by polymerase chain reaction. (Item 123) 122. The method according to any of items 112 and 121, wherein the probe is an affinity-tagged oligonucleotide and the accessing is performed by an affinity pull-down assay. (Item 124) The method according to any one of items 100 to 123, wherein the block ID is a position. (Item 125) Item 125. The method of any of items 124, wherein the location is the location of the symbol string represented by the corresponding block of a parent symbol string. (Item 126) Item 126. The method of item 125, wherein the parent symbol string includes a data structure for counting or locating the occurrences of a pattern in another symbol string. (Item 127) Item 127. The method of item 126, wherein the data structure is one of a counter array, a column of a Burrows-Wheeler transform (BWT) matrix, a suffix array, a suffix tree, or an inverted index. (Item 128) 1. A method for computing digital information stored in a nucleic acid molecule, comprising: obtaining a first pool of identifier nucleic acid molecules, the pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules configured to bind to one or more probes, the identifier nucleic acid molecules representing an input symbol string; performing an if-then-else operation on the identifier nucleic acid molecules in the first pool, the if-then-else operation targeting at least one of the component nucleic acid molecules with a probe to create an intermediate pool having a subset of identifier nucleic acid molecules from the first pool; Repeating step (b); wherein in every subsequent step, said intermediate pool replaces said first pool until a final pool of identifier nucleic acid molecules representing at least a portion of an output symbol string is created. (Item 129) 130. The method of claim 128, wherein each identifier nucleic acid molecule in the first pool comprises a distinct component nucleic acid molecule from each of M strata, each strata comprising a set of component nucleic acid molecules. (Item 130) 130. The method of any of items 128 and 129, wherein the if-then-else operation comprises accessing the identifier nucleic acid molecule in a pool containing unique component nucleic acid molecules. (Item 131) 131. The method according to any of items 130, wherein the probe is a PCR primer and the accessing is carried out by polymerase chain reaction. (Item 132) 131. The method according to item 130, wherein the probe is an affinity-tagged oligonucleotide and the accessing is performed by an affinity pull-down assay. (Item 133) 133. The method according to any of items 128 to 132, wherein two or more if-then-else operations are performed in parallel on one or more pools of identifier nucleic acid molecules. (Item 134) 134. The method of any one of items 128 to 133, further comprising splitting at least one of the first pool, the intermediate pool, or the final pool into at least two replicate pools. (Item 135) Item 135. The method of item 134, further comprising replicating the at least one of the first pool, the intermediate pool, or the final pool prior to splitting. (Item 136) 136. The method of claim 135, wherein the replication is carried out by polymerase chain reaction (PCR). (Item 137) 137. The method of any of items 128 to 136, further comprising combining at least two intermediate pools of identifier nucleic acid molecules to form a new intermediate pool of identifier nucleic acid molecules or a second pool of identifier nucleic acid molecules. (Item 138) 1. A method for obtaining a rank for a particular symbol value at a particular position in a symbol string from digital information stored in a pool of nucleic acid molecules, each symbol having a symbol value and a symbol position, the method comprising: (a) obtaining a first pool of identifier nucleic acid molecules representing the symbol string, the pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules configured to bind to one or more probes; (b) obtaining a second pool of identifier nucleic acid molecules representing counter symbol strings derived from the symbol string, each counter symbol representing a running count of the particular symbol value within all w symbols of the symbol string; (c) obtaining a first count by accessing the second pool of (b) with a second set of probes to target at least the identifier nucleic acid molecules in the second pool that represent corresponding counter symbols indicative of the running count of the particular symbol values for either (1) all blocks of w symbols preceding the particular location, or (2) all blocks of w symbols preceding the particular location, including the block of w symbols that includes the particular location; (d) obtaining a second count by accessing the first pool of (a) with a first set of probes to target one or more distinct identifier nucleic acid molecules in the first pool that represent symbols that (1) precede or include the specific position and that are not counted in (c), or (2) that are counted in (c) but do not precede or include the specific position; (e) obtaining the rank of the particular symbol value at the particular position within the symbol string from the first count and the second count; and The method includes: (Item 139) Item 139. The method of item 138, wherein the identifier nucleic acid molecules in the first pool represent bit strings mapped to the symbol strings such that the presence of an identifier nucleic acid molecule represents a particular symbol value at the symbol position. (Item 140) 139. The method of any of items 138 and 139, wherein when the first count in (c) represents all blocks of w symbols preceding the particular position, the first set of probes in (d) targets one or more distinct identifier nucleic acid molecules in the first pool representing symbols not counted in (c) that precede or include the particular position, and the rank of the particular symbol value at the particular position in the symbol string is obtained by summing the first and second counts in (e). (Item 141) 139. The method of any of items 138 and 139, wherein the first count in (c) represents all blocks of w symbols preceding the particular position, including the block of w symbols that includes the particular position, and the first set of probes targets one or more distinct identifier nucleic acid molecules in the first pool that represent the symbols counted in (c) but that do not precede or include the particular position, and the rank of the particular symbol value at the particular position in the symbol string is obtained in (e) by subtracting the second count from the first count. (Item 142) 142. The method of any of items 138 to 141, wherein the first count is obtained by reading counter symbol values corresponding to the targeted identifier nucleic acid molecules of (c). (Item 143) 143. The method of any of items 138 to 142, wherein the second count is obtained by reading the targeted identifier nucleic acid molecules from (d). (Item 144) 144. The method according to any of items 138 to 143, wherein the first pool of (a) is the second pool of (b). (Item 145) 144. The method of any of items 138 to 143, wherein the first pool of (a) is separate from the second pool of (b...
Claims
1. 1. A method for obtaining a rank for a particular symbol value at a particular position in a symbol string from digital information stored in a pool of nucleic acid molecules, each symbol having a symbol value and a symbol position, the method comprising: (a) obtaining a first pool of identifier nucleic acid molecules representing the symbol string, the pool having a powder, liquid, or solid form, each identifier nucleic acid molecule in the first pool comprising a component nucleic acid molecule, at least a portion of the component nucleic acid molecules configured to bind to one or more probes; (b) obtaining a second pool of identifier nucleic acid molecules representing a counter symbol string derived from the symbol string, each counter symbol representing a running count of the particular symbol value within all w symbols of the symbol string; (c) obtaining a first count by accessing the second pool of (b) with a second series of probes to target at least the identifier nucleic acid molecules in the second pool that represent corresponding counter symbols indicative of the running count of the particular symbol values for either (1) all blocks of w symbols preceding the particular location, or (2) all blocks of w symbols preceding the particular location, including the block of w symbols that includes the particular location; (d) obtaining a second count by accessing the first pool of (a) with a first set of probes to target one or more distinct identifier nucleic acid molecules in the first pool that (1) represent symbols preceding or including the specific position and not counted in (c), or (2) represent symbols counted in (c) but not preceding or including the specific position; (e) obtaining the rank of the particular symbol value at the particular position within the symbol string from the first count and the second count; and The method includes:
2. 2. The method of claim 1 , wherein the identifier nucleic acid molecules in the first pool represent bit strings that are mapped to the symbol strings such that the presence of an identifier nucleic acid molecule represents a particular symbol value at the symbol position.
3. 2. The method of claim 1, wherein when the first count in (c) represents all blocks of w symbols preceding the particular position, the first set of probes in (d) targets one or more distinct identifier nucleic acid molecules in the first pool representing symbols not counted in (c) that precede or include the particular position, and the rank of the particular symbol value at the particular position in the symbol string is obtained by summing the first and second counts in (e).
4. 2. The method of claim 1, wherein the first series of probes targets one or more distinct identifier nucleic acid molecules in the first pool that represent symbols counted in (c) but that do not precede or include the particular position, when the first count in (c) represents all blocks of w symbols preceding the particular position, including the block of w symbols that includes the particular position, and the rank of the particular symbol value at the particular position in the symbol string is obtained by subtracting the second count in (e) from the first count.
5. 2. The method of claim 1, wherein the first count is obtained by reading counter symbol values corresponding to the targeted identifier nucleic acid molecules of (c).
6. 2. The method of claim 1 , wherein the second count is obtained by reading the targeted identifier nucleic acid molecules from (d).
7. 2. The method of claim 1 , wherein the first pool of (a) is the second pool of (b).
8. 2. The method of claim 1, wherein the first pool of (a) is separate from the second pool of (b).
9. 2. The method of claim 1, wherein the presence of a corresponding identifier nucleic acid molecule in the first pool indicates a first symbol value and the absence of a corresponding identifier nucleic acid molecule in the first pool indicates a second symbol value.
10. The symbol string has a length n and the counter symbol is represented by b bits, where b is log 2 10. The method of claim 9, wherein n is an upper limit of (n+1).
11. 11. The method of claim 10, wherein the counter symbol string includes an upper limit of n divided by w counter symbols and is represented by a counter bit string having a length corresponding to b multiplied by the upper limit of n divided by w.
12. 2. The method of claim 1, wherein if the particular location is within a first block of w symbols, then the running count preceding the first block of w symbols is zero.
13. 13. The method of claim 12, wherein if the particular position is not within the first block of w symbols, then the counter symbols of all blocks of w symbols preceding the particular position represent the number of occurrences of the particular symbol value within a position range of 0 to w*B(x)-1 of the symbol string, where 0 is the first position of the symbol string, x corresponds to the particular position within the symbol string, and B(x) is a lower bound of x divided by w.
14. 14. The method of claim 13, wherein the targeted identifier nucleic acid molecules in the second pool of (c) are within the range defined by positions b*B(x) and b*(B(x)+1)-1, with position 0 corresponding to the first position in the symbol string.
15. 2. The method of claim 1 , wherein the second count corresponds to a number of occurrences of the particular symbol value within the position range of w*B(x) to x of the symbol string, where x corresponds to the particular position within the symbol string, position 0 is the first position, and B(x) is a lower bound of x divided by w.
16. 2. The method of claim 1, wherein w is set such that the length in bits representing the w symbols of the symbol string is equal to the length in bits b representing the counter symbol.
17. The method of claim 1 , wherein w is set to a value of one.
18. 18. The method of claim 17, wherein the first count is obtained by targeting identifier nucleic acid molecules of (c) that represent the counter symbol corresponding to the block of w symbols that includes the particular position, and the rank is equal to the first count.
19. 20. The method of claim 18, wherein step (d) is not performed.
20. 2. The method of claim 1, wherein a block of w symbols in the symbol string is mapped to a block of contiguous ordered identifier nucleic acid molecules in the first pool of identifier nucleic acid molecules.
21. 21. The method of claim 20, wherein the symbols in the symbol string are bits, and each bit is mapped to an identifier nucleic acid molecule such that the presence or absence of the identifier in the first pool of identifier nucleic acid molecules indicates a value of the bit.
22. 22. The method of claim 21, wherein fixed length substrings of the symbol string are mapped to codewords that contain a fixed number of unique identifier nucleic acid molecules from a fixed number of possible unique identifier nucleic acid molecules.
23. 10. The method of claim 1, further comprising using additional information to detect and correct errors in writing, accessing, and reading identifier nucleic acid molecules from the first and second pools.
24. 24. The method of claim 23, wherein the additional information is stored in the identifier nucleic acid molecules of the first and second pools.
25. The method of claim 1 , wherein the symbol string represents a bit string.
26. 26. The method of claim 25, wherein each symbol of the symbol string corresponds to a fixed number of bits.
27. 26. The method of claim 25, wherein the different second pools of identifier nucleic acid molecules of (b) represent different counter symbol strings that count the number of instances of a unique symbol value, each different counter symbol string counting the number of instances of a corresponding unique symbol value.
28. 2. The method of claim 1, wherein the identifier nucleic acid molecule is formed by physically assembling M selected component nucleic acid molecules, each of said M selected component nucleic acid molecules being selected from a set of distinct component nucleic acid molecules separated into M distinct layers.
Citation Information
Patent Citations
Character string retrieval system and method
JP2009244996A
Nucleic acid-based data storage
US20180137418A1
The use of nucleotide sequences as carrier of information
WO2004009844A1
