DNA Bloom Filter enables anti-contamination and file version control for DNA-based data storage

Abstract

DNA storage is one of the most promising ways for future information storage due to its high data storage density, durable storage time and low maintenance cost. However, errors are inevitable during synthesizing, storing and sequencing. Currently, many error correction algorithms have been developed to ensure accurate information retrieval, but they will decrease storage density or increase computing complexity. Here, we apply the Bloom Filter, a space-efficient probabilistic data structure, to DNA storage to achieve the anti-error, or anti-contamination function. This method only needs the original correct DNA sequences (referred to as target sequences) to produce a corresponding data structure, which will filter out almost all the incorrect sequences (referred to as non-target sequences) during sequencing data analysis. Experimental results demonstrate the universal and efficient filtering capabilities of our method. Furthermore, we employ the Counting Bloom Filter to achieve the file version control function, which significantly reduces synthesis costs when modifying DNA-form files. To achieve cost-efficient file version control function, a modified system based on yin–yang codec is developed.

INTRODUCTION

With the rapid growth of information volume, current storage mediums are anticipated to fall short in meeting the demands of data preservation in the future. In comparison with common storage mediums such as tapes, hard disks and flash drives, DNA molecules are becoming a promising storage medium due to their exceptional data storage density, long-term data retention and low maintenance costs. In order to promote the development of DNA-based data storage, early efforts have primarily concentrated on the construction of algorithms including constrained codes and error-correcting codes [1–10], the optimization of bioinformatics methods [11, 12], the development of software packages [13–15], the design of storage functions [16–20] and the integration of automatic input/output devices [21–23].

Among the principal objectives in constructing algorithms is the tolerance of errors that occur during the production, preservation and observation of DNA molecules containing digital data. The manifestation of errors in DNA molecules is exceptionally intricate [24], including nucleotide-scale errors such as insertion, deletion and substitution, as well as sequence-scale errors like loss and break. Early efforts introduced error-correcting codes [25–27] and optimized downstream technologies including sequence clustering [11, 28] and multiple sequence alignment [29], to resist these errors to some extent. Nevertheless, real-world applications are anticipated to be more complicated, potentially diminishing the effectiveness of these efforts. For example, the risk of cross-contamination in experiments and external environments poses a threat, leading to the possibility of obtaining a DNA sequence in a batch that does not genuinely belong to it, which is regarded as a non-target DNA sequence. This expanded definition of errors necessitates leveraging a broader range of technologies from the field of computer engineering to address this intensified challenge of error resistance, referred to as anti-contamination.

Compared with conventional storage techniques, DNA-based data storage exhibits a unique feature: the molecular product derived from each DNA sequence encompasses multiple copies. Therefore, in addition to correcting errors in each retrieved DNA sequence, another potential strategy for resisting errors could be the filtration of incorrect DNA sequences, which holds a low computational complexity while obtaining target DNA sequences. Nowadays, filters are extensively employed in diverse computer engineering contexts, including spam detection [30] and webpage address duplication elimination [31]. Wu provided a striking usage scenario for the most classic and pragmatic one, called Bloom Filter (BF) [32]: A blacklist dataset comprises 10 billion blacklisted website addresses, with each address taking up a maximum of 64 bytes. Using no more than 30 gigabytes of storage space, the BF is capable of determining whether a given website address is present in the blacklist with an error rate of less than one in 10 000 [33]. Actually, the BF has also been applied in the field of bioinformatics [34], which uses the BF as a container to store the characters of each sequence and regard it as a vertex in a de Bruijn graph to achieve the storing of a pan-genome. Hence, we have grounds to elaborate that the BF holds the potential for application in DNA-based data storage.

Here, we employ numerical simulations, just like previous experiments [35, 36], to substantiate the feasibility of utilizing filters to address the anti-contamination issue and further construct a file version control system to demonstrate the application of filters in dynamic storage functionality [17, 37]. We introduced BF and provided relevant variants (detailed in Methods and Materials) to complete the corresponding feasibility verification. For the convenience of memory, we refer to this set of filters applied in DNA-based data storage as DNA Bloom Filter (DNA-BF). DNA-BF can achieve an accurate anti-contamination function, even if the proportion of target sequences is only four thousandths or even smaller. The anti-contamination function is robust and is not influenced by different file types, file sizes, file formats, matching coding schemes and filter parameter configurations. Furthermore, the file version control system based on the DNA-BF can achieve file modifications with only the need to re-synthesize the modified part of the files, which can greatly reduce the synthesis cost.

RESULTS

Overview of DNA-BF

DNA BF for anti-contamination function is performed with a general BF, consisting of an array and several hash functions. It indirectly stores elements using several hash functions for each element, mapping the positions of the array to 1, without any processing for the positions where hash collisions occur. It is a fast, low memory-cost data structure to detect whether an element exists in a set at the cost of some accuracy, resulting in a certain false positive rate (⁠|$r_{fp}$|⁠), which is shown in Figure S2.

DNA BF for file version control function is performed with a variant structure of the general BF, called Counting Bloom Filter (CBF). The difference between it and the general one is that when storing elements, each position of the array records the number of hash functions mapping to it, which let it support the deletion operation of elements. The deletion operation is to subtract 1 from the values of the positions that the hash functions of elements to be deleted map, without affecting the detection of other elements (Figure S3).

For clarification, the notations used in this paper is listed in the following Table 1.

Anti-contamination by DNA-BF

The anti-contamination function includes two rounds of screening for sequencing data. The first round is to filter out most of the non-target sequences through the BF generated using the library of target sequences. As in real cases, considering the low error rates of synthesis and sequencing technologies [38], as well as randomly occurring mutation or contamination, the molecular copy number of non-target sequences should be much smaller than that of target ones. Therefore, it is expected to be a significant difference of the coverage numbers (the number of each sequence reads after sequencing) between non-target sequences and target ones. The second round of screening take advantage of this coverage difference to further filter the false positive sequences. The complete process of the anti-contamination method is illustrated in Figure 1.

Effectiveness of anti-contamination function

To verify the effectiveness of BF, we conduct experiments using two DNA sequence libraries with an identical size (same index length, data payload length and quantity): one consists of sequences encoded by yin–yang codec (YYC) (YYC library) for a readable digital file, and another consists of purely random generated sequences (random library). The detailed sequence features of random library is shown in Figure S4. To better match the reality, the molecular copy number of sequences in the libraries follows a normal distribution according to high-throughput DNA synthesis technologies [39–42]. Before filtering by BF, random errors according to real DNA synthesis and sequencing error rates were introduced to the library (see Methods) [36]. For clarity, only the number of sequence type is counted, which means that even if the simulated coverage of the same sequence is large, it is only counted as one sequence.

As shown in Figure 2A and Figure 2B, without the implementation of any error correction algorithm or error sequence filtering strategy, it is evident that the proportion of non-target sequences is much higher than that of the target sequences. In contrast, after BF is used for filtering, all target sequences and a small number of non-target sequences are obtained as shown in Figure 2C and Figure 2D, the proportion of target sequences increases from a few tenths of a percent to over 75%. Meanwhile, with coverage number of all the sequences increasing, the proportion of non-target sequences increases rapidly. A speculated reason would be that with the coverage number increasing, more false positive sequences will be detected according to the pre-set |$r_{fp}$| (Figure S4). As target sequences are all obtained from coverage number of 20 or 22 (Figure S6) and remains, the proportion of non-target sequences increases. These demonstrate that BF can effectively filter out most of the non-target sequences, and its degree of anti-contamination is related to the parameter-setting of itself and the number of non-target sequence types in simulation.

As mentioned earlier, it is expected that there is a gap between the coverage of target sequences and non-target sequences. Figure 2E illustrates that the significant difference in coverage between target and non-target sequences emerges when the sequencing depth reaches 30, and it expands as the sequencing depth increases. Figure 2F demonstrates the remained non-target sequences can be further removed by the significant coverage difference between the numbers of target sequences and non-target sequences. With the sequencing depth increases, this difference increases, which is more conducive to separating target sequences from non-target sequences.

The same experiment is also performed on sequences encoded by DNA Fountain [5] (DNA Fountain library), the result shows a similar anti-contamination ability (Figure S7) and robustness (Figure S8). This implies that the anti-contamination function of DNA-BF is not limited by the bit-to-base encoding method.

Robustness of anti-contamination function

To evaluate the robustness of the anti-contamination function and explore the potential factors that may affect the effectiveness of BF, we conducted the in silico experiments from different perspectives, including pre-set |$r_{fp}$|⁠, file size, file type and file format. The pre-set |$r_{fp}$| is an internal factor of BF itself, which directly determines the proportion of false positive sequences. File size affects the total number of original target sequences. Different file type means different byte-frequency distributions [14]. Different file format means significantly different presentation visible under the same type file, as illustrated in Figure S9.

It would be much easier to differentiate target sequence for DNA-BF if the coverage gap is large enough. As shown in Figure 3, we use the difference between minimum coverage of target sequences (⁠|$\boldsymbol{M}^{\mathrm{t}}$|⁠) and maximum coverage of non-target sequences (⁠|$\boldsymbol{M}^{\mathrm{nt}}$|⁠) to evaluate differential efficacy between the target sequences and the non-target sequences. This evaluation metric remains relatively stable across the above-mentioned four perspectives. This implies that the coverage difference can be used to filter out all the non-target sequences in conjunction with BF, showing a robust performance.

File version control by DNA-BF

Since the efficiency and reliability of the anti-contamination feature is proved in the previous section, it would be practical to apply BF technology to more intricate functions within DNA storage, e.g. file version control function. First of all, we developed a file version control system codec based on YYC. It can generate DNA sequence libraries of the updated version of the files by only translating the modified parts, while leaving other parts unchanged. Based on this file version control codec, complete DNA sequence libraries of each version of files are obtained by combining the modified and unchanged parts. In addition, as shown in Figure 4A,these sequence libraries are used to generate their corresponding CBF for record. During the storage process, sequences from all different versions are stored together in one DNA pool. Then, as shown in Figure 4B, based on the corresponding CBF, it becomes feasible to retrieve all DNA sequences belonging to a specific version even if the library consist DNA sequences belonging to other versions. By the deletable operation of CBF, false positive sequences are further identified for accurate file recovery.

CBF in file version control system

In the file version control system, the DNA sequences of requested version are regarded as the target sequences, while the sequences of other versions and error sequences are regarded as the non-target sequences. The type number of these three kind of sequences in each version is displayed in Table S3. As shown in Figure 5A, it can be seen that the coverage of error sequences is significantly lower than that of target sequences, whereas the coverage of sequences from other versions is within the range of coverage of target sequences, which may lead to troubles for file recovery if general BF is used only. It is not surprising because that each version of DNA files shares similar sequence coverage number for consistency, leads to the high coverage number of part of the false positive sequences. According to probability theory, the overlap among the coverage of DNA sequences in different versions will intensify with the modified sequences of different versions or the number of versions increase. As shown in Table S1, after filtering by general BF and the anti-contamination strategy, only less than 5% of the target sequences can be obtained. It suggests that general BF could not be used for robust file version control.

In contrast, CBF can improve the situation remarkably. As Table S2 shows, the percentage of obtained target sequences increase to more than 96% without further operation. However, there will be still 3–4% of the sequences not belonging to the requested version sequences obtained by the CBF, making it challenging to decode the corresponding information. Therefore, we propose a strategy to fully eliminate false positive sequences, which relies on the deletion operation of the CBF, making it accurately obtain the target sequences for requested version (Figure 4B). In Figure 5B, the results before and after deletion operation are presented for each version, demonstrating a 100% recovery of requested version without obtaining non-target sequences.

Robustness evaluation of file version control system

As shown in the previous results, the method based on CBF can eliminate all the non-target sequences. However, it does carry the risk of removing target sequences, or false negative removals as the number of non-target sequences increases, caused by a hash-collision-like effect [43, 44]. The calculation of the false negative rate (⁠|$r_{tfn}$|⁠) can be seen in |$r_{tfn}$| in Table 1. To improve the data recovery accuracy and minimize |$r_{tfn}$|⁠, we conduct an analysis of factors that impact its |$r_{tfn}$| from both internal and external perspectives.

Array size (length of the array) and hash size (number of hash functions) are two major factors that can affect the |$r_{fp}$| of CBF when the elements in the library remain unchanged. Increasing the array size results in a decrease in the |$r_{fp}$|⁠, while increasing the hash size leads to a preliminary decrease in the |$r_{fp}$| followed by an increase. As shown in Figure 6A, with |$r_{fp}$| or |$r_{tfp}$|increasing, the |$r_{tfn}$| increases rapidly and reaches close to 1 when the |$r_{fp}$| or |$r_{fp}$| is approximately 0.1. When the |$r_{fp}$| is small, such as 0.001, and the number of elements is 100 000, no target sequences will be eliminated by mistake.

In addition, |$r_{tfn}$| is also controlled by the number of non-target sequences in the environment, which indirectly affects the number of false positive sequences. Figure S10 shows that simulated sequencing depth and total error rate further influence the number of the non-target sequences in the environment in the same pattern, which implies that these two factors could have the same effect on |$r_{tfn}$|⁠. Hence, the study combines experimental data obtained from varying simulated sequencing depths and total error rates to investigate the correlation between the |$r_{tfn}$| and the quantity of non-target sequences present in the environment. As shown in Figure 6B, |$r_{tfn}$| increases as the number of the non-target sequences in the environment increases. With the same number of non-target sequences changing, the growth of the |$r_{tfn}$| is slower as the |$r_{fp}$| decreases.

Both internal and external factors ultimately influence |$r_{tfn}$| by influencing the number of false positive sequences detected by CBF. The number of false positive sequences affects the negative integers in the non-positive array. The larger the quantity or values of negative integers in the non-positive array, the greater the likelihood that target sequences will be erroneously identified as false positive sequences and subsequently eliminated. Therefore, in order to eliminate all the false positive sequences while avoiding losing target sequences, it is suggested to set a low |$r_{fp}$| for the CBF, reduce the simulated sequencing depth or total error rate.

DISCUSSION

This study pioneers the application of filtering technology in DNA-based data storage, which provides a practical and precise method to potentially replace the conventional error correction or anti-contamination processes. This approach significantly reduces the steps and time required for information retrieval. To address the complexities of various error types and the growing need for advanced storage functionalities, we have extended the conceptual framework of sequence classification in DNA-based data storage. The new category of ‘non-target DNA sequences’ includes both erroneous DNA sequences and other DNA sequences that are extraneous to the current batch. By employing the classical BF architecture, we have improved the differentiation between target and non-target sequences by leveraging their differential proportion in the whole library. This approach enables us to identify and eliminate non-target DNA sequences with pinpoint accuracy while preserving the expected ones. In addition, if additional error correction or clustering is necessary in a specific data analysis, for example, some target sequences have been lost, the anti-contamination function based on DNA-BF can be used as a preprocessing tool to filter sequencing data to reduce their computation complexity or memory consumption. Actually, no matter whether the coding and decoding method has its own error correction code or needs additional error correction strategy to correct the sequences, our anti-contamination function can improve the accuracy to some extent. Furthermore, by expanding the analysis of sequence properties, we have developed a highly robust file version control system. This system, based on a variation of the traditional BF data structure, called CBF, provides a cost-effective solution for information retention and editing, thus enhancing the reliability and versatility of DNA-based data storage.

The anti-contamination function based on the DNA-BF shows strong accuracy and has no restrictions on the coding schemes of sequences generation. And it is robust as the coverage difference is not affected by the parameter setting of a BF and the characteristics of the file. The file version control system based on the DNA-BF can accurately extract a specific version of the files from a mixed library of multiple versions of the files under appropriate settings. Thus, this study provides new insights into the field of DNA-based data storage research and demonstrates the integration of established information technology into the intricate processes of DNA-based data storage.

In the near future, there is a requirement for a further comprehensive investigation into the implementation of filtering technology within the field of DNA-based data storage. For example, the criteria for determining the coverage threshold are still unclear. Although the file version control system can eliminate non-target sequences by utilizing CBF in normal conditions, the false negative rate may increase prominently if the amount of non-target sequences reaches a certain level. The memory space consumption of the DNA-BF is lower than that of the original files, nevertheless, it still requires traditional storage media to a certain extent. In addition, loss of the DAN-BF incurs the risk of losing the actual data [45, 46]. One potential solution is to convert the BF itself into a separate DNA pool for storage. Moreover, to ensure the accuracy of the DNA-BF itself in case of degradation, contamination, sabotage, etc., it may be necessary to have more backups of DNA sequences, higher physical redundancy, or additional error-correcting codes.

METHODS AND MATERIALS

Sequencing data generation

Target sequences generation

YYC was used to convert binary sequences of actual files into DNA sequences. The payload length of each DNA sequence is 120 nt, and the index length is 20 nt.

For files of different versions, a file version control system codec based on YYC was used to transform binary sequences into DNA sequences. The payload length of each DNA sequence is 120 nt, the prime index length is 20 nt, and the minor index length is 14 nt with 4 nt reserved for marking. A detailed illustration of the sequence design can be seen in Figure S11.

For the anti-contamination function experiments, an article in PDF format is used as the default real source file, and 100 000 target sequences are randomly selected. In the file size experiment, a PDF file consisting of four articles is utilized. For the file type experiments, all sequences encoded from each file type are included. The original version of the file in the file version control system experiments contains 84 940 target sequences.

Synthesizing and sequencing simulation

In our experiment, we have set the molecular copy number of each DNA sequence to be synthesized as 1000. We assume that these molecular copy number follow a normal distribution with a standard deviation of 100. Additionally, the default total error rate of each base on a synthesized DNA sequence is 0.3%, which is referred to Song et. al. [12], consisting of a substitution rate of 0.15%, an insertion rate of 0.075% and a deletion rate of 0.075%.

After simulating the synthesis with error occurrence, all the DNA sequences will be randomly shuffled, and then a sequencing depth will be specified to obtain the final sequencing data.

Anti-contamination using DNA-BF

The BF has stored information in an array with some positions marked as 1 and other positions marked as 0. The initial BF is an array with every position marked as 0. When a DNA sequence is processed, it is transformed into one or several values. These values will correspond to the positions in the array, which are then marked as 1. The number of values generated for each DNA sequence depends on the hash size, which determines the number of rounds of hash functions that need to be performed.

For each target sequence, the input parameters for each round of the hash function include the base information of the DNA sequence and the index of the round of the current hash function. The index of the round of the current hash function is used as the initial value to calculate the hash value for the current hash function. Additionally, each base of the DNA sequence is sequentially transformed into its corresponding ASCII value, which is then incorporated into the calculation along with the value calculated from the previous base in the hash function calculation. The resulting calculated value for each hash function is used to map the corresponding position in the array of the BF to 1. By performing these steps for each hash function, the target sequence is stored in the BF.

Once all the target sequences are stored in the BF, a c3omplete BF is generated. To check whether a DNA sequence belongs to the target sequences, you just need to calculate the hash value for the same number of times as during the storage process, and then check if every hash value mapping position in the array of the BF is set to 1. As long as there is a value mapping position in the array of the BF that is not set to 1, it means that the DNA sequence does not belong to the target sequences.

By detecting the sequencing data through this BF, all the target sequences included in the sequencing data and a small part of non-target sequences will be obtained. Since the non-target sequences are randomly generated, their coverage is much smaller than that of target sequences. These residual non-target sequences can be easily removed by artificially setting a coverage threshold.

Finally, the |$r_{fp}$| is artificially set and its calculation can be seen in |$r_{fp}$| in Table 1. In the case of |$n$| is certain, giving a value of |$r_{fp}$| as the minimum value, |$l$| and |$k$| will be determined since this function is an increasing function. The default pre-set |$r_{fp}$| is 0.001.

File version control system using DNA-BF

Different versions of the files are sourced from the scripts on different dates in the specified GitHub repository (https://github.com/iterative/dvc/tree/main/dvc.). All the files under this repository on June 1, 2023 are integrated into a txt file, and this file is treated as the original version file (version1). Other versions of the files are sourced from 2 June 2023 to 15 June 2023.

For each version of the files, we generate a Counting BF for it, which is similar to the generation of a BF. The key difference is that the mark of each position in the array is cumulative, which means the final CBF has stored information in an array with some positions marked as positive integers and other positions marked as 0. The DNA sequences generated from all versions of the files can be stored in one pool. When a specific version of the files is required, the corresponding CBF is used to detect the sequencing data. Then, employing the method of eliminating false positive sequences based on CBF, the false positive sequences from other versions can be effectively removed.

As the DNA sequences from different file versions have similar coverage, it becomes challenging to remove false positive DNA sequences belonging to different versions. This means that when obtaining one version of the files, there is a possibility of mixing files from other versions. To solve this problem, we propose using a CBF instead of a BF and developing a method to eliminate false positive sequences, ensuring the accuracy of a specific version of the files. This method aims to eliminate all the false positive sequences, but it may introduce a |$r_{tfn}$|⁠, which means there is a probability that some target sequences may also be eliminated. Fortunately, under suitable conditions, no target sequences will be mistakenly eliminated, or the number of target sequences to be eliminated will be significantly lower than the number of false positive sequences that will be detected if just using the BF.

Elimination of false positive information

Similar to the element deletion operation in the CBF, after obtaining the target sequences and false positive sequences through the CBF, the values in the array where these sequences hash mapping to are subtracted by 1, and then an array containing a lot of 0 and several negative integers will be got. Finally, based on this non-positive array, the sequences whose hash mapping positions in the array are all negative integers will be extracted and eliminated. In this way, most of the false positive sequences are successfully eliminated. The detailed pipeline is shown in the follow-up pseudo code.

Implementation of file version control system

As for the YYC, the pairing of binary sequences is random. This means that any modifications made to the input file would result in a complete alteration of the encoded DNA sequences for that file. This random pairing feature may deviate from our original intention of creating the file version control system, where only the modified parts should require new DNA sequences to be added to the pool in order to reduce the cost of synthesis. In addition to this, there is currently no strategy in place for allocating indexes to the modified DNA sequences. Therefore, we made adjustments for the YYC to achieve the file version control function in the DNA storage.

We introduce adjacent pairing of binary sequences, and set prime index and minor index to ensure the modified sequences have correct indexes to be allocated. We name the first index as prime index and remaining indexes as minor indexes. For example, when inserting a sequence between two existing sequences with only primary index 20 and 21 respectively, the inserted sequence will be allocated the index 20-1, which 20 is the prime index and 1 is the minor index. The length of the prime index is 20 nt and the length of the minor index is 14 nt with 4 nt for marking. The payload length is 120 nt if there is only prime index in a DNA sequence. To preserve the integrity of the encoding for DNA sequences before and after any modifications, it is crucial that the number of binary sequences within the modified part, preceding it, and succeeding it, were all even numbers. If the payload length of the last binary sequence exceeds the size of the actual binary stream, additional zeros must be appended to the front of the binary stream to satisfy the length of the final binary sequence. To distinguish these binary sequences with filled zeros from normal binary sequences, 15 zeros will be added after the indexes of the filled zeros binary sequences. Then, the next 7 bits are used to record the length of the binary stream. The binary stream is placed at the end of the binary sequences. If the remaining bits are not enough to store the binary stream, new binary sequences will be generated until all the binary streams have been allocated, and the number of the binary sequences within this part is an even number. So, more than 22 bits should be reserved to store binary stream in a binary sequence and the number of the minor indexes should not exceed 6.

Our system currently only supports encoding txt files. In addition to the normal parameters in YYC, such as coding rule and support base, our system also requires modification operations, modification files, match files for precise positioning operations and DNA sequence files of the last version.

FUNDING

This work was supported by the National Key Research and Development Program to Z.P. (no. 2020YFA0712100), the National Natural Science Foundation of China to Z.P. (no. 32101182), the Shenzhen Science, Technology and Innovation Commission grant no. SGDX20220530110802015 to Z.P. and Tip-top Scientific and Technical Innovative Youth Talents of Guangdong Special Support Program to Y.S. (no. 2019TQ05Y876).

AUTHOR CONTRIBUTIONS

Y.L., H.Z. and Z.P. proposed the concepts and designed the experiments; H.Z. and Y.L. completed the codes; Y.C. conducted the experiments and deployed the codes; Y.L. analyzed the results; Y.L. drafted the manuscript; H.Z., Y.C., Y.S. and Z.P. revised the manuscript; Z.P. supervised the study.

DATA AVAILABILITY

The real source files for encoding are in https://github.com/BGI-SynBio/DNA-BF/tree/main/files. The source code for realization of the functions is in https://github.com/BGI-SynBio/DNA-BF. The source code for the file version control system codec based on YYC is in https://github.com/BGI-SynBio/YYC-FileVersionControl.

Author Biographies

Yiming Li received her Master's degree in genetics from Central South University in 2022. She is currently a research assistant in BGI. Her research interests in bioinformatics and algorithms of DNA-based data storage.

Haoling Zhang received his BEng degree in software engineering from Chongqing University of Technology in 2018. Following this, he held the position of Senior Algorithm Engineer at BGI Research until early 2024. He is currently a MS/PhD student at King Abdullah University of Science and Technology. His research interests include DNA-based data storage, robust machine learning, and bioinformatics.

Yuxin Chen received his BSc degree in biological technology from South China University of Technology in 2016. He is currently an algorithm engineer in Beijing Genomics Institute. His research interests include DNA storage, data compression and bioinformatics.

Yue Shen received her PhD degree in molecular biology from the University of Edinhurgh. She currently serves as the Chief Scientist of Synthetic Biology in BGI-Research. She is one of the key members in the synthetic yeast consortium (Sc2.0). Her research focuses on the development of DNA synthesis technologies and instruments, Synthetic genomics and its downstream applications, and DNA-based data storage.

Zhi Ping received his PhD degree from Nanyang Technological University, Singapore. He is currently the faculty in School of Medicine, The Chinese University of Hong Kong, Shenzhen, and a Chief Scientist in BGI-Research. His research interest lies on DNA-based data storage, DNA synthesis, bioinformatics algorithms and structural biology.

References