The DNA genetic code is based on the monomer nucleotides { T , C , A , G } . From the point of view of information, this set is, in fact, a 4-symbol alphabet, and it is representable by 2 bits in a binary number system (Nemzer, 2017). One possible mapping to represent genetic code in binary format is { T ↔ 00 , C ↔ 01 , A ↔ 10 , G ↔ 11 } . This mapping is used in the .2bit file format, 2bit, to encode DNA sequences is used in the current work.

In dealing with comparisons and searching, a technique used in genomics to analyze DNA data breaks down DNA sequences in fragments of k-lenght of monomers (Langmead, 2016). These fragments are named according to the number of monomers in the fragment. If the number of monomers k is 1, the k-mer is called a 1-mer. If the number of monomers k is 2, the k-mer is called a 2-mer, and so forth. Examples of 2-mer DNA fragments are CA and GC.

While the concepts in quantum mechanics have been around for about a century (Born, 1926), it was in the 1980s that those concepts were theorized as options in the computer science disciplines (Benioff, 1982). Applying these quantum mechanics principles to computing is now known as quantum computing (Steane, 1998). Over the years, quantum computing has evolved from a theoretical hypothesis into a tangible reality. In the contemporary landscape of technological advancement, the theoretical underpinnings of quantum computing have transformed into practical methodologies that allow us to execute techniques reliant on quantum principles for complex computations.

The basic unit of information in quantum computing is the qubit (Schumacher, 1995). While a binary bit can only be in a state of 0 or 1, the qubit has the property that it can be in a combined state of | 0 〉 or | 1 〉 (read ket 0 or ket 1). This property is called superposition. The wave function in Equation 1 expresses the general qubit state, | ψ 〉 . The qubit state notation is taken from the Dirac bra-ket notation (Dirac, 1939). | ψ 〉 = α | 0 〉 + β | 1 〉 , w h e r e | 0 〉 = 1 0 , a n d 1 = 0 1 (1)

One fundamental difference between a binary computer and a quantum computer is that measuring the binary bit state does not alter its state, whereas in quantum computing, measuring a qubit collapses it into a pure state | 0 〉 or | 1 〉 . The probability that a qubit will collapse into a | 0 〉 or | 1 〉 is given by Equation 2 where α and β are complex numbers capturing the amplitudes of the state in Equation 1. | α | 2 + | β | 2 = 1 (2)

Qubits perform calculations using quantum gates or operators to manipulate the qubit states. One such gate is the Pauli-X gate, represented by thesymbol (Nielsen and Chuang, 2000). This gate has the property of flipping the qubit state. If the qubit is in a | 0 〉 state the new state becomes | 1 〉 and vice versa. The transformation matrix in Equation 3 defines the Pauli-X gate. (3)

Thegate is a unitary operator; it is reversible. It is also applied to only one qubit. Other gates may be applied to a set of qubits. For instance, the CNOT gate defined in Equation 4 is one of the gates used to entangle two qubits (Hughes et al., 2021). The first is the control qubit; the other is the target qubit. With this gate, the qubits are set to interact between them. (4)

With both superposition and entanglement, qubit interference may be leveraged to perform computation. Since the qubit status is based on the quantum wave function, when two different qubits are entangled and subject to operators, their amplitudes will interact constructively or destructively. This phenomenon allows for computations beyond the capability of binary computing.

Since the conception of the quantum computing concept, human ingenuity has been at work to explore the potential of this new computing paradigm. Quantum computing may increase cybersecurity (Bova et al., 2021), or break widely used cybersecurity technologies such as public key cryptography (Mavroeidis et al., 2018). It also may be used to speed up searching for a marked item in unstructured data through a quantum search. Since quantum computing has a promising outlook, companies worldwide are interested in facilitating quantum computing for research and commercial use through Quantum Software Stacks (QSS) (Wang et al., 2021). Google provides Cirq, Rigetti PyQuil, and IBM provides the Qiskit. The current work was researched, developed, and executed using IBM’s Qiskit QSS.

The IBM Quantum Platform, formerly known as the IBM Quantum Experience (Cross, 2018), is an open platform intended to ease the work of designing, developing, and running quantum circuits. Anyone interested may create these circuits through the Quantum Composer (Lehka et al., 2022), a cloud-based visual development environment. They also may be written in OpenQASM (Cross et al., 2017), an assembly-like computer language. Another familiar option is to write the quantum circuits using Python programming with the Qiskit (Qiskit contributors, 2023), modules installed. Qiskit allows for different quantum system backends to be used, both simulators and actual quantum processors with limited access. In addition, educational materials, such as the Qiskit Textbook (various authors, 2023), demonstrate tools available to create quantum algorithms. In this book, the coined quantum walk search algorithm (Wanzambi and Andersson, 2021), is implemented to search for a marked node in a tesseract, a hypercube with four dimensions as shown in Figure 1. This tesseract is built within the QuantumCircuit instance pointed by the circuit variable with the following Python code:

# Shift operator function for 4d-hypercube

  def shift_operator(circuit) :

    for i in range (0,4) :

     circuit.x(4)

      if i % 2 == 0 :

       circuit.x(5)

     circuit.ccx(4,5,i)

This qubit arrangement allows us to represent the 2 4 vertices in the hypercube with only four qubits. This is, in fact, an exponential information density.

The coined quantum walk search is a search algorithm targeted at unstructured databases. This search algorithm employs a quantum version of classical random walks executed on Markov chains (Shenvi et al., 2003; Boettcher et al., 2015). In the quantum version of the random walk, the walker evaluates several paths on the graph simultaneously through the superposition of states of the coin operator. The shift operator then takes the step influenced by the coin state. The phase estimation serves as the state evaluation tool to determine if a state is the search target. The coin is a set of qubits used to evaluate the walker’s next step. The coined quantum walk search demonstrated in the Qiskit textbook in chapter 3.10 uses 11 qubits. Four are used as the theta qubits for phase estimation, four for the tesseract nodes, two for the Grover’s coin, and one as an auxiliary (ancilla) qubit.

The coined quantum walk search stands out as a particularly promising paradigm. It holds the potential to transcend its theoretical origins and address an extensive array of problems, spanning an impressive spectrum of applications. Among these applications are solutions to combinatorial (Bova et al., 2021), problems where the search space is all the combinations of a finite set of symbols. DNA pattern matching belongs to this type of problem. In bioinformatics, DNA pattern matching and prediction plays such an important role that brilliant minds have designed practical algorithms to leverage traditional computing (Rahate and Chandak, 2018; Neamatollahi et al., 2020); and even advanced deep learning model techniques such as the Convolution Autoencoder (Guo et al., 2024). Poising our attention towards quantum computing, the quantum hypercube, with its exponential information density, also enables the prospect to execute the coined quantum walk search for a marked state.

The current work researches a technique to encode DNA information to input it to a quantum computer and provide a target k-mer in the quantum hypercube search space for a coined quantum walk search algorithm to find. The coined quantum walk search is executed with each of the 16 possible combinations as a starting node. In addition, the 11-qubit quantum register is tested with all the possible initialization states. Each initialization state is executed with each of the 16 possible target nodes. The results generated are analyzed to provide insights into the effects of initializing the 11-qubit quantum register on the execution of the coined quantum walk search. The information is useful for peeking into the possibilities of leveraging the quantum hypercube as a k-mer graph to perform DNA pattern matching.

The IBM Quantum Software Platform facilitates the use of a quantum computer through the use of Python modules. These modules implement potent methods to build up and execute quantum circuits. The two packages used for the experiments in this research are the q i s k i t = = 0.39 . 0 and q i s k i t _ i b m _ p r o v i d e r = = 0.2 . 0 . Specifying these packages to be installed through the pip package manager also installs other packages as dependencies. Another advantage of using the Qiskit framework is that the circuits created will run as long as a compatible backend is available.

When using the Qiskit QSS, a QuantumCircuit instance is initialized to a 0 state by default. However, the Qiskit QuantumCircuit Python class allows for each qubit in instances of n-qubits to be initialized to a target state of 0 or 1 by passing a string of n-length of 0’s and 1’s as a parameter. The right-most character is applied to the first qubit from top to bottom, following a right-to-left and top-to-bottom order. This simplified initialization method is more familiar to classical programmers since this initialization string is, in fact, a binary string. For an 11-qubit circuit, an initialization string may take the form “01001100010”. When the method to initialize a quantum circuit object is called, the circuit is modified by addinggates to rotate the qubits from a 0 state to a 1 state to achieve the desired circuit state.

The corresponding Python code with the modules installed and imported into the program is:

...

from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister, ClassicalRegister

...

circuit.initialize( “ 01001100010 ” , circuit.qubits)

...

After calling the circuit. initialize method, the circuit is modified to set the quantum register into the specified state before executing the circuit. Thus, applying “01001100010” as the circuit initialization string to the coined quantum walk modifies the beginning of the circuit as illustrated in Figure 2.

The   and   symbols in Figure 2 are not quantum gates. These two symbols illustrate how the quantum circuit is initialized to a desired tesseract node and what that node “0110” represents in a .2bit mapping for DNA sequences. Notice that the encoding is mapped from left to right to stay consistent with the Qiskit QuantumCircuit initialization string pattern.

After the initialization method is called, the coined quantum walk implementation presented in the Qiskit Textbook is used to find the marked node in a hypercube with 4-bit vertices. These 4 bits represent two-letter DNA patterns, also called 2-mer substrings. This way, the hypercube in Figure 1 becomes the hypercube in Figure 3.

The coined quantum walk implementation has three parts: A set of Hadamard gates applied to the node and coin qubits to set them into a superposition state; the phase oracle, where the target state is marked; and the phase estimation. The phase oracle and the phase estimation sections may be repeated as many times as desired. The last step is measuring the states of the tesseract nodes, which collapses the quantum circuit into a binary state. Figure 4 illustrates the complete quantum walk search algorithm. The entire circuit was implemented and executed using the Python programming language.

The mark section in the QuantumCircuit object, circuit, is implemented with the Python snippet:

# Mark the target pattern within the circuit

def mark(self, circuit, target):

   for i in range ( len (target) - 1, - 1, - 1 ) :

      if ‘0’ == target [ i ]:

       circuit.x( len (target) - 1 - i)

  circuit.h(3)

  circuit.mct( [ 0,1,2 ] , 3)

  circuit.h(3)

   for i in range (0, ( len (target)):

      if ‘0’ == target [ i ]:

      circuit.x ( len (target) - 1 - i)

To cover all the 32768 possible input-mark, the circuit illustrated in Figure 4 was executed through a Python program. This Python program ran each execution with 1024 shots. The reader can find this Python program in the Supplementary Materials section.

The data used in this study and its original program are available in GitHub at: https://github.com/dti-data/quantum-k-mer-graph.