Quantum-effective exact multiple patterns matching algorithms for biological sequences

Significance of processing biological sequences

For processing the biological sequence databases, exact matches are always preferred with accurate matching outcomes. The nucleotide and amino acid patterns are used to locate within genome, protein and other biological sequences for different purposes (Jiang, Zhang & Zhang, 2013; Singh, 2015). The size of DNA or RNA alphabet set is $\left|\mathrm{\Sigma }\right|=4$, and coded adjacent triplet of nucleotide characters which forms amino acid with the set size $\left|\mathrm{\Sigma }\right|=20$. The biological sequence databases are excessively large, so multiple string patterns should be effectively processed. Multiple pattern matching aims to identify all locations of m patterns within the sequence databases in a single scan. The searching of DNA pattern within nucleotide sequence helps us to identify, compare and align the sequences as well as to analyze mutations (Faro & Lecroq, 2009; Tahir, Sardaraz & Ikram, 2017; Raja & Srinivasulu Reddy, 2019). However, different nucleotides can code to similar proteins, so protein databases are searched for similarity checks.

An exact multiple pattern matching has more practical applications in computational biology, such as sequence alignments, motif finding, read mapping in gene and genome, substring matching, proteogenomics mapping, overlap detection, codon matching, etc. Thus, the problem is intentionally assumed here to search for the exact occurrences of the patterns (Kalsi, Peltola & Tarhio, 2008; Charalampos, Panagiotis & Konstantinos, 2011; Rivals, Salmela & Tarhio, 2011). There exists an impact of processing large sequences through the efficient algorithm, hence quantum algorithms are made suitable to process biological sequence applications. We search for multiple patterns set $P=\left\{P_1,.,P_k,.,P_m\right\}$ with implicit consideration of processing singleton pattern set to find all t exact occurrence of single nucleotide patterns in gene and genome databases, or multiple nucleotide patterns to confirm the presence of amino acid within the peptide and protein sequences (Singh, 2015; Hakak & Kamsin, 2019). Later, in “proposed algorithmic applications to process biological sequences”, we define several applications of our quantum algorithms which are related to searching multiple patterns within the biological sequence databases. For a more comprehensive understanding to process the biological sequences, review these referenced articles (Sheik, Aggarwal & Anindya Poddar, 2004; Basel, 2006; Choo, 2006; Kalsi, Peltola & Tarhio, 2008; Fredriksson, 2009; Charalampos, Panagiotis & Konstantinos, 2011; Rivals, Salmela & Tarhio, 2011; Faro & Lecroq, 2013; Jiang, Zhang & Zhang, 2013; Singh, 2015; Zhang et al., 2015; Tahir, Sardaraz & Ikram, 2017; Hakak & Kamsin, 2019; Neamatollahi, 2020; Soni & Rasool, 2021; Soni & Malviya, 2021; Raja & Srinivasulu Reddy, 2019).

Motivation and contribution of work

The quantum machine can achieve computational speedups because of implicit parallelism. It needs O(1), i.e. constant execution step to realize an exponential number of operations (Nielsen & Chuang, 2010). We assume a problem of pattern matching as hard when the size of text database $N=2^n$ is excessively large as gigabytes (2³⁰), terabytes (2⁴⁰) or more (Kalsi, Peltola & Tarhio, 2008; Neamatollahi, 2020). So, instead of classical, the quantum pattern search takes reduced $O\left(\sqrt{N=2^n}\right)$ time (Menon & Chattopadhyay, 2021). An existing quantum pattern matching solution achieved speedups over classical complexities (Ramesh & Vinay, 2003; De Jesus, Aborot & Adorna, 2013; Aborot, 2017; Soni & Rasool, 2021); however, the benchmark methods are constrained to find a single pattern, and the quantum multiple pattern matching is found ineffective because of executing multiple search oracles in successive iterations and it includes multiplicative factor m (Soni & Malviya, 2021).

The optimal quantum design may execute multiple search oracle in parallel on QPU with single-core to remove completely such factor m, however, this is impractical to design. We seek exact solutions of pattern matching with more applicability in computational biology. Thus, the available quantum benchmark algorithms QPBE and QBCE are enhanced here, with the names, enhanced QMEM processing-based exact algorithm (EnQPBEA-MPM) and enhanced quantum-based combined exact algorithm (EnQBCEA-MPM) for multiple pattern matching. The design of algorithms is based on processing effectiveness of QPU having C quantum cores and each core shares the text T on QMEM. So, to find all the t exact occurrences of each pattern, the search time complexities of the proposed algorithms are $O\left(\left(m/C\right)\sqrt{N}\right)$ and $O\left(\left(m/C\right)\sqrt{t}\right)$.

Our motivation is to search for all exact occurrences of m patterns either by direct use of effective quantum processing framework over original text sequence database T in $O\left(\sqrt{N}\right)$ queries or by transforming approximate filtering outcome into exactness over reduced search space in $O\left(\sqrt{t}\right)$ queries. The algorithms are based inherently on Grover’s search operator (GSO). We use QMEM to explore the text of size $N=2^n$ such that, the entire text search space is accessed in parallel in Ο(1) time, but memory word access needs $O\left({\log }_{2}N\right)$ steps (Park & Petruccione, 2019; Matteo, 2020; Soni et al., 2020). A new quantum circuit of Ο(1) time is proposed for exact match between pattern P and substring of T of size M, whereas classical comparison takes Ο(M) time (Sena Oliveira, Benicio Melo de Sousa & Viana Ramos, 2007; De Jesus, Aborot & Adorna, 2013; Soni & Rasool, 2021). Thus, we initiate quantum-effective algorithms with a context of exponential increase in biological text size. The proposed work of this article is organized as per Fig. 1, and we derive our results by giving the proofs of Theorem 1 and Theorem 2 in the proposed methods section.

This article presents our main contribution as the effective quantum design of multiple patterns matching algorithms which are proved mathematically along with their simulations. We outline our work below to achieve objectives in a streamlined manner throughout this article:

• We realize the effective quantum processing framework by using QPU with C quantum cores which access quantum processing circuit of equivalent QMEM procedure. It achieves the quantum-based computational and processing speedups. We also proposed, a new constant time, quantum exact match (QEM) circuit which is utilized implicitly under GSO iterations.

• We justify our proposed quantum algorithms using complexities analysis, and specific quantum proving techniques such as probabilistic, truthness and correctness proofs.

• The future works of Soni & Rasool (2021) are presented here as enhanced solutions. Our proposed algorithms EnQPBEA-MPM and EnQBCEA-MPM are proved to search for all t exact occurrence of m patterns with effective time $O\left(\left(m/C\right)\sqrt{N}\right)$ and $O\left(\left(m/C\right)\sqrt{t}\right)$.

• For a single pattern search, the proposed algorithms EnQPBEA-MPM and EnQBCEA-MPM can simulate the QMEM processing based enhanced designs of QPBE & QBCE algorithms (Soni & Rasool, 2021).

• A factor $\left(m/C\right)$ is proved negligible for a small arbitrary constant value of m and constant value of C as the QPU with C quantum cores utilizing their own set of quantum registers for searching m $\left(m/C\right)$ is included explicitly in the time complexities for considering $\left(m\gg C\right)$ as the worst case.

• The quantum operations of proposed algorithms are proved equivalent to their quantum circuits. These circuits are the actual realization of quantum solutions. Quantum query, time and storage complexities of proposed algorithms justify their effectiveness.

• Based on several complexity analysis factors, we prove our proposed solutions as efficient to find exact patterns, and these remove the existing multiple pattern matching constraint (Soni & Malviya, 2021) as designs of QEMP and QAMP cannot exclude multiplicative factor m.

• Our proposed quantum algorithms are simulated for validation through the quantum exact simulation toolkit (QuEST). Also, we proposed a quantum circuit implementation of QMEM through algebraic normal form (ANF). The intentions are not to analyze the efficiency of the simulation due to classical machine restrictions; therefore, we do the hybrid implementation.

• We validate our results using QuEST simulation by assuming that t number of search solutions, either unique or multiple solution, are already known. To realize the case in which the value of t is unknown, we use quantum counting (QC) additionally to validate the search results of our proposed EnQPBEA-MPM and EnQBCEA-MPM algorithms.

• We suggest several applications of EnQPBEA-MPM and EnQBCEA-MPM for processing biological sequences. Such applicability of these algorithms is specified with respect to significant characteristics and performance restrictions.

The abbreviated names used throughout the text are available in Table A1 (Appendix A). The nomenclature used in this article is a prerequisite for further reading purpose, therefore refer to Table B1 (Appendix B). The individual correctness proofs of algorithms EnQPBEA-MPM and EnQBCEA-MPM are separately included in Appendix C and Appendix D. A correctness proof shows algorithmic trace steps which expands the applied quantum operations.

Prior work and the important findings

In classical findings, earlier exact multiple patterns matching solutions were proposed as the enhanced version of Knuth–Morris–Pratt (KMP) and Boyer–Moore (BM) algorithms. Both these multiple patterns matching solutions are available in Ο(mM) time for pattern pre-processing, and searching takes Ο(mN) (Zhang et al., 2015; Soni & Malviya, 2021). Based on these proposals, other existing algorithms are categorized for multiple pattern matching. There exist several multiple patterns matching methods, few are highlighted with their complexities. Aho–Corasick (AC) is the automata based prefix algorithm that works on KMP logic in $O\left(m+N\right)$ time complexity. Commentz–Walter (CW) as a suffix algorithm, extending BM with possible variants, takes Ο(m(NM)) time in worst case. Multiple Pattern Backward DAWG (BDM) and Backward Set Oracle Matching (BSOM) are the factor or substring search-based algorithms which run in $O\left(N\left({\log }_{\left|\mathrm{\Sigma }\right|}\left(mM\right)/M\right)\right)$ time (Charalampos, Panagiotis & Konstantinos, 2011; Faro & Lecroq, 2013). Instead, BSOM is a faster method; however, this needs extra space complexity of $O\left(mM\left|\mathrm{\Sigma }\right|\right)$ and verification through the AC algorithm. Wu–Manber (WM) is hashing based algorithm works for a large number of patterns search in $O\left(N\left(\lceil M/w\rceil \right)\right)$ time, where w is number of bits in word size. Shift-OR (SO), Shift-AND (SA), and Backward Non-Deterministic DAWG (BNDM) Matching methods perform bits operation through intrinsic parallelism to realize solutions for multiple patterns matching in $O\left(m\left(N{\log }_{\left|\mathrm{\Sigma }\right|}\left(w\right)/w\right)\right)$ average time complexity (Fredriksson, 2009; Hendrian et al., 2019). The performance of these algorithms is dependent on $\left|\mathrm{\Sigma }\right|$, size of text database $\left|T\right|=N$, number of patterns |P| = m and each pattern $P_k$ with varying length $M_k=\left[0\mathrm{t}\mathrm{o}{M}_k-1\right]$. We noted that the multiplicative factor m is somehow included in time complexities of the classical algorithms. Among all the algorithms, AC has significant applications in biological sequence processing. However, AC requires large memory to store the automata, and hence it is constrained to process large patterns set. This algorithm induces competitive results on the small-sized $\left|\mathrm{\Sigma }\right|$ and $\left|P\right|=m$ with each pattern $P_k$ of short length $M_k$ (Fredriksson, 2009; Charalampos, Panagiotis & Konstantinos, 2011; Faro & Lecroq, 2013; Zhang et al., 2015; Hendrian et al., 2019; Soni & Malviya, 2021).

There exist few solutions for quantum pattern matching with the advantage of using amplitude amplification of Grover’s search (GSO). This method finds search results over N-sized text in $O\left(\sqrt{N}\right)$ steps with high probability, and it is better than the classical linear search time Ο(N) (Lanzogorta & Uhlmann, 2008; Zhou et al., 2013; Coles, 2020). Few single and multiple patterns matching schemes are available in the quantum. Single pattern matching was initiated by Ramesh–Vinay (RV) through the quantum deterministic sampling method; however, the suggested solution needs $O\left(\sqrt{M}+\sqrt{N}\right)$ time by including the pre-processing and searching (Ramesh & Vinay, 2003; Montanaro, 2017; Menon & Chattopadhyay, 2021). The method quantum approximate pattern matching (QAPM) filters the text for searching a pattern over reduced indices, and it needs $O\left(t+\sqrt{t}\right)$ (Aborot, 2017). A basic solution of quantum exact pattern matching (QEPM) finds exact leftmost occurrence of the pattern in $O\left(\sqrt{N}\right)$ time (De Jesus, Aborot & Adorna, 2013). The $\sqrt{t}$ time search is relatively better than $\sqrt{N}$ solution; however, QAPM finds approximate pattern match, and QEPM is constrained to search single pattern occurrence (De Jesus, Aborot & Adorna, 2013; Aborot, 2017).

Recent advancements of these algorithms are presented by extending the logic of QEPM or combining the methods of QEPM and QAPM for effective exact matching design. A suggested QMEM processing based exact (QPBE) algorithm is efficient to process large text sequences and this also overcomes the constraint of QEPM method by finding all t exact occurrences of search pattern in $O\left(\sqrt{Nt}\right)$ time (Soni & Rasool, 2021). However, the quantum-based combined exact (QBCE) algorithm replaces approximations of the QAPM method with exact matches. This also reduces implicit quantum circuit depth to explore the text during pattern search with logarithmic factors. The desired search time of all t exact occurrence of search pattern is $O\left(\sqrt{t}\right)$ (Soni & Rasool, 2021). Both these extended solutions are remarkable; however, no attempt has been made yet to design QPBE and QBCE algorithms to process multiple patterns, which are highly expected in biological sequence processing. As well as, the design of QBCE is not available under the specific processing of QMEM (Soni & Rasool, 2021). For quantum multiple pattern matching, initial solutions were suggested as an extension to QEPM and QAPM methods. Soni & Malviya (2021) suggested multiple pattern algorithms, renamed here as quantum exact multiple pattern (QEMP) algorithm to search for either the single occurrence or all t occurrence of m patterns within time complexities range $O\left(m\sqrt{N}\right)$ and $O\left(m\sqrt{Nt}\right)$. Rather, renamed quantum approximate multiple pattern (QAMP) search for solution with suggested $O\left(m\left(t+\sqrt{t}\right)\right)$ time. Such algorithms search for the equal and unequal sized patterns in successive iterations, and this includes multiplicative factor m in time complexities. Thus, search solution for multiple pattern algorithms is not effective (Soni & Malviya, 2021).

We are providing the brief description of algorithms QEPM & QAPM, QPBE & QBCE, and QEMP & QAMP from the next subsection onward. As per the reviewed analysis of algorithms, the qubits estimations and algorithmic complexities analysis are also included separately.

Quantum exact pattern matching (QEPM) and quantum approximate pattern matching (QAPM) algorithms

The QEPM method is based on the design of an oracle that performs parallel matching under the quantum superposition by aligning comparison window between pattern and text substring to search for a leftmost exact occurrence of pattern. In $O\left(\sqrt{N}\right)$ queries, oracle inverts the leftmost index to report pattern match solution with high probability. The algorithm uses GSO and assures $O\left(\sqrt{N}{\log }_{2}N\right)$ search time complexity. Table 1 shows that the method is constrained to find a single $\left(t=1\right)$ occurrence of pattern, and qubits estimation is the same as quantum search algorithm (De Jesus, Aborot & Adorna, 2013). The algorithm QAPM applies hamming distance (HD) method for approximate text filtering and matching. It cannot find accurate results as HD is an error model and allow replacement at unit cost. A pattern is reported when $HD\le Threshold$ (pre-computed). A QAPM needs more storage as it uses a large number of quantum registers with excessive qubits requirement (Aborot, 2017); see Table 1. However, this searches all occurrences with $O\left(\sqrt{t}\right)$ queries. Additional indices may filter using HD, and this increases the size of filtered text, and even HD based verification generates search results with approximation. A filtering needs $O\left(t{\log }_{2}N\right)$ time to find all t filtered indices, then verification matches the $t^{\prime }$ approximate occurrences of pattern through registers comparison, and $\sqrt{t}$ calls of GSO, in the $O\left(\sqrt{t{t}^{\prime }}{\log }_{2}N\right)$ and $O\left(t{\log }_{2}N\right)$ time (Aborot, 2017).

QMEM processing based exact (QPBE) and quantum-based combined exact (QBCE) pattern matching algorithms

The recently proposed algorithms, QPBE and QBCE, are efficient to process the large text sequences. These also overcome the constraints of QEPM and QAPM methods (Soni & Rasool, 2021). The QPBE design is realized efficiently under the superposition of text indices on a quantum memory, and it finds all t exact occurrences of search pattern in $O\left(\sqrt{Nt}\right)$ time. However, the QBCE algorithm replaces pattern matching approximations with exact matches. It also reduces implicit quantum circuit depth to explore the text during pattern search with the logarithmic factor. A search time for all $t^{\prime }$ exact occurrences over the reduced text of size t is $O\left(\sqrt{t{t}^{\prime }}\right)$. Both these methods were proposed with significant aspects to process the specific biological sequences. A query remains the same as existing methods, rather the best & worst time complexity of QPBE is $O\left(\sqrt{Nt}{\log }_{2}N\right)$ & $O\left(N{\log }_{2}N\right)$, and QBCE time complexity is ranging between $O\left(\sqrt{t{t}^{\prime }}{\log }_{2}t\right)$ and $O\left(t{\log }_{2}t\right)$ time. The search oracle for an exact pattern match is found efficient. As we reviewed, the storage complexity of QPBE is same as the existing QEPM algorithm. The QBCE remarkably reduces the storage while comparing with the excessive qubits requirement of pattern verification used in the existing QAPM method. All the required complexity analysis detail of these algorithms are included in Table 2 for quick reference (Soni & Rasool, 2021).

Quantum exact multiple pattern (QEMP) and quantum approximate multiple pattern (QAMP) matching algorithms

There are varieties of solutions proposed for the first time on quantum multiple pattern matching. However, the design of such algorithms is based on the execution of search oracle in successive iterations. So for different pattern sizes, it is iteratively called for finding all t occurrence of each pattern $P_k$. Due to this direct possible design, Table 3 shows that a multiplicative factor (m) is included in the complexities of algorithms (Soni & Malviya, 2021). The authors categorized multiple patterns matching methods as exact and approximate with quantum memory processing based design. Search complexity of suggested QEMP algorithm to find t occurrence of each $P_k$ ranges between $O\left(\left(m\right)\left(\sqrt{Nt}{\log }_{2}N\right)\right)$ and $O\left(\left(m\right)\left(N{\log }_{2}N\right)\right)$. In contrast, the QAMP method uses approximate filtering in $O\left(m\left(t{\log }_{2}N\right)\right)$ time to find t filtered indices for each $P_k$. Further, the iterative search time for each $P_k$ to search all $t^{\prime }$ occurrences of reduced text of size t, ranges between $O\left(m\left(\sqrt{t{t}^{\prime }}{\log }_{2}N\right)\right)$ and $O\left(m\left(t{\log }_{2}N\right)\right)$. Both these methods are not increasing storage complexity because of iterative executions; and reasonably, the multiplicative factor m is included. Still, there exist high qubits requirement in the QAMP algorithm (see Table 3). The time of quantum memory $O\left(N{\log }_{2}N\right)$ is considered explicitly due to no such physical availability. These algorithms were suggested to process biological sequences. For the detailed design and analysis of these methods, refer to Soni & Malviya (2021).

Quantum operational framework used in the algorithmic design

Quantum algorithms based on superposition can perform exponential operations in parallel. The quantum behavior realizes qubit presence as $|0⟩$ and $|1⟩$ at same time. A $|\psi ⟩$ is a column vector, represents superposition, and $⟨\psi |$ is a row vector; usually, Bra-Ket notation $⟨\psi |\psi ⟩$ is inner product. An n qubits quantum register $|q_i⟩$ $\left(q_i\in {\left\{0,1\right\}}^n\right)$ spans the tensor product of $2^n$ dimension as Hilbert space. So, the computational basis is formed as $|{\psi }_n⟩={\alpha }_0|0⟩+\dots +{\alpha }_{\mathrm{i}}|\mathrm{i}⟩+\dots +{\alpha }_{2^{\mathrm{n}}-1}|2^{\mathrm{n}}-1⟩$ to realize superposition under n dimensional vector space with complex probability amplitudes. Quantum registers can entangle with each other. A measurement collapses superposition into classical states $|i⟩$ between $|0⟩$ to $|2^n-1⟩$ with probability ${\left|{\alpha }_i\right|}^2$ such that ${\sum }_{i\in {\left\{0,1\right\}}^2}{\left|{\alpha }_{\mathrm{i}}\right|}^2=1$. To visualize such n qubits superposition with the required dimensions, refer to these article for the Bloch sphere model (Choo, 2006; Lanzogorta & Uhlmann, 2008; Nielsen & Chuang, 2010; Coles, 2020; Soni & Rasool, 2020).

Qubits remain in a pure state (vectors), but a quantum gate operator transforms n qubits into $2^n\times 2^n$ sized mixed state (density matrix). The outer product of vectors is obtained as $|\psi ⟩⟨\psi |$ because quantum unitary gate U applies certain operations within superposition to transform the quantum state. A $U^{†}$ is a conjugate transpose of U that performs the reverse quantum operation, such that $U{U}^{†}=I$ holds. Quantum logic operations such as [H] creates superposition, $Pauli$ matrices $\left[X,Y,Z\right]$ obtains any rotation on Bloch sphere, $\left[R_x\left(\theta \right),R_y\left(\theta \right),R_z\left(\theta \right)\right]$ applies rotation with angle $\theta$ as unitary operation. Some required controlled operations are $\left[C^{n}NOTor{C}^{n}X\right]$ which flips the target qubit and $\left[C^{n}Z\right]$ flips the phase of target, when n control qubits are set to 1. The unitary operators encode to perform specific operations under quantum superposition. Refer to Table B1 (Appendix B) for symbols and used unitary operators throughout this article, and for more comprehensive understanding of quantum operations, refer to the following articles (Lanzogorta & Uhlmann, 2008; Nielsen & Chuang, 2010; Coles, 2020; Soni & Rasool, 2021; Soni & Malviya, 2021).

Methodology and framework used for quantum algorithm analysis

Our analysis framework for the quantum algorithm is oriented toward quantum-based proof methods. So, we categorized the proofs with their specialized point of interest with their additive use in the quantum algorithmic analysis. We provide the precise description of them as:

• Quantum Complexity Proof: The proposed algorithms are justified by using the following complexities analysis. Query complexity shows the number of superposition based oracle calls. Time complexity states the processing time of quantum gates involved in quantum circuits with logarithmic factors. Circuit complexity defines the composition of the quantum circuit with depth. Storage complexity estimates required qubits with ancilla.

• Quantum Probabilistic Proof: The proposed algorithms are also proved based on computational theory to identify the quantum complexity class as either the exact quantum polynomial (EQP) with $Pr=1$ or bounded error quantum polynomial (BQP) complexity with Pr = ∈. The probabilistic proof is used to identify results based on probabilities to be used later in lemmas and theorems.

• Quantum Truthness Proof: We prove the algorithms mathematically using Lemma proofs to derive primarily partial results, and then used Theorem proofs to justify the computational complexities result based on rigorous logic and reasoning.

• Quantum Correctness Proof: We proved the proposed algorithms for their correctness on the basis of quantum algorithmic trace steps which expands quantum operations applied under superposition to show quantum state transformations.

(The above-mentioned proofs are categorized on the basis of the following references Lanzogorta & Uhlmann, 2008; Nielsen & Chuang, 2010; Faro & Lecroq, 2013; Zhou et al., 2015; Broda, 2016; Giri & Korepin, 2017; Grassi, Plasencia & Schrottenloher, 2018; Coles, 2020; Soni & Rasool, 2021; Soni & Malviya, 2021).

Quantum effective processing framework for algorithm design

We generalized a framework for the ordered design of algorithms with (1) processing advantage of quantum memory; (2) proposed efficient quantum exact match (QEM) circuit; and (3) Grover’s search to generate high probable results. The remarks of framework are specified in Table 4.

Processing advantage of quantum memory (QMEM)

First, for the compatibility of QPU based computation, both text and pattern are required to encode as quantum data. This facilitates the processing of large biological sequences under quantum superposition. So, QMEM of size $|T_{2^n\times w}{⟩}_{\mathrm{Q}\mathrm{M}\mathrm{E}\mathrm{M}}$ is used to realize superposition with $N=2^n$ memory words each with size w qubits. The QMEM needs address register $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$ of size ${\log }_{2}N=n$ qubits to refer all text indices $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$ in superposition, and data corresponding to entangled addresses is accessed by data register $|T_{\left[i\right]}{⟩}_{\mathrm{Q}\mathrm{D}}$ of size ${\log }_2\left|\mathrm{\Sigma }\right|=w$ qubits (Giovannetti, Lloyd & Maccone, 2008; Nielsen & Chuang, 2010; Metodi, 2011; Lin et al., 2013; Fu et al., 2016; Britt, 2017).

The design of QMEM is realized using bucket brigade architecture that enables data access in $O\left({\log }_{2}N\right)$ steps, as among $O\left(N=2^n\right)$ qutrit, $O\left({\log }_2{2}^n\right)$ quantum switch remains active. This design is effective, as classical memory (CRAM) needs all $O\left(N=2^n\right)$ switches active for word access. So, QMEM gains exponential speedup as $\left(2^n/{\log }_2{2}^n\right)$ over CRAM. A text is shared on memory, and each $c^{th}$ core $QCor{e}_c$ can access it in owned superposition. A QPU with C cores uses their registers set, and such parallelism minimizes processing time as negligible. Figure 2 shows the architecture of QPU with C cores working on shared QMEM with the design of the quantum memory circuit. A QMEM is realized using $U_{\mathrm{Q}\mathrm{M}\mathrm{E}\mathrm{M}}$ of Eq. (1) in support of Eqs. (2)–(4) (Giovannetti, Lloyd & Maccone, 2008; Nielsen & Chuang, 2010; Metodi, 2011; Lin et al., 2013; Fu et al., 2016; Britt, 2017; Brandl, 2017; Park & Petruccione, 2019; Matteo, 2020; Soni et al., 2020).

(1) $$\text{QMEM Transformation}\leftarrow \left(U_{\mathrm{Q}\mathrm{M}\mathrm{E}\mathrm{M}}\leftarrow \left({U^{†}}_{\mathrm{S}\mathrm{w}\mathrm{a}\mathrm{p}}\left(U_{\mathrm{L}\mathrm{o}\mathrm{a}\mathrm{d}}\left(U_{\mathrm{S}\mathrm{w}\mathrm{a}\mathrm{p}}\right)\right)\right)\right)$$

(2) $$U_{\mathrm{S}\mathrm{w}\mathrm{a}\mathrm{p}}\left(|0⟩|\mathrm{w}\mathrm{a}\mathrm{i}\mathrm{t}⟩\right)=|f⟩|\mathrm{l}\mathrm{e}\mathrm{f}\mathrm{t}⟩\mathrm{o}\mathrm{r}{U}_{\mathrm{S}\mathrm{w}\mathrm{a}\mathrm{p}}\left(|1⟩|\mathrm{w}\mathrm{a}\mathrm{i}\mathrm{t}⟩\right)=|f⟩|\mathrm{r}\mathrm{i}\mathrm{g}\mathrm{h}\mathrm{t}⟩$$

(3) $$U_{\mathrm{L}\mathrm{o}\mathrm{a}\mathrm{d}}\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\otimes |T_{\left[w\right]}{⟩}_{\mathrm{Q}\mathrm{D}}\right)=U_{\mathrm{L}\mathrm{o}\mathrm{a}\mathrm{d}}\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\otimes |T_{[w\oplus i]}{⟩}_{\mathrm{Q}\mathrm{D}}\right)=|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\otimes |T_{\left[i\right]}{⟩}_{\mathrm{Q}\mathrm{D}}$$

(4) $${U^{†}}_{\mathrm{S}\mathrm{w}\mathrm{a}\mathrm{p}}\left(|f⟩|\mathrm{l}\mathrm{e}\mathrm{f}\mathrm{t}⟩\right)=|0⟩|\mathrm{w}\mathrm{a}\mathrm{i}\mathrm{t}⟩\mathrm{o}\mathrm{r}{U^{†}}_{\mathrm{S}\mathrm{w}\mathrm{a}\mathrm{p}}\left(|f⟩|\mathrm{r}\mathrm{i}\mathrm{g}\mathrm{h}\mathrm{t}⟩\right)=|1⟩|\mathrm{w}\mathrm{a}\mathrm{i}\mathrm{t}⟩$$

A unitary $U_{\mathrm{Q}\mathrm{M}\mathrm{E}\mathrm{M}}$ makes the data available in parallel for each $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$ index. It prepares the $|{\mathrm{q}\mathrm{u}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{s}}_{N-1}⟩$ switches in $|{\mathrm{w}\mathrm{a}\mathrm{i}\mathrm{t}}_{N-1}⟩$ state and realizes the superposition of entire memory. As per target index $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$, the qutrit are transformed from $|\mathrm{w}\mathrm{a}\mathrm{i}\mathrm{t}⟩$ to $|\mathrm{l}\mathrm{e}\mathrm{f}\mathrm{t}⟩$ or $|\mathrm{r}\mathrm{i}\mathrm{g}\mathrm{h}\mathrm{t}⟩$ state using $U_{\mathrm{S}\mathrm{w}\mathrm{a}\mathrm{p}}$ of Eq. (2) under fiduciary qubit $|f⟩$ that fixes switch state. Among $|{\mathrm{q}\mathrm{u}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{s}}_{N-1}⟩$ only the $|{\mathrm{q}\mathrm{u}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{t}\mathrm{s}}_{{\log }_{2}N}⟩$ remains active during the memory call [14]. We perform the data loading using $U_{\mathrm{L}\mathrm{o}\mathrm{a}\mathrm{d}}$ of Eq. (3). It activates bus qubits to trace a path of active qutrit switches, copies the cell data, and traces back over same qutrit to load copied data into $|T_{\left[i\right]}{⟩}_{\mathrm{Q}\mathrm{D}}$, and meanwhile, qutrit are transformed to $|\mathrm{w}\mathrm{a}\mathrm{i}\mathrm{t}⟩$ state by reverse unitary ${U^{†}}_{\mathrm{S}\mathrm{w}\mathrm{a}\mathrm{p}}$ of Eq. (4) (Giovannetti, Lloyd & Maccone, 2008; Nielsen & Chuang, 2010). A QMEM needs $O\left({\log }_{2}N\right)$ steps; and a memory call enables the bus qubits equal to the word size to access data in parallel, so for $w=M\times {\log }_2\left|\mathrm{\Sigma }\right|$ qubits, the ${\log }_{2}N$ switch remains active until the word transfer is not completed. Therefore, with word transfer, the QMEM needs $O\left(M\times {\log }_{2}N\right)$ steps with the negligible factor M (Nielsen & Chuang, 2010; Soni et al., 2020; Soni & Rasool, 2021; Soni & Malviya, 2021).

Proposed efficient quantum exact match (QEM) circuit

Second, we propose quantum-exact match (QEM) circuit through unitary $U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}$ to perform parallel match between pattern $|P_{\left[0\mathrm{t}\mathrm{o}M-1\right]}{⟩}_{\mathrm{D}\mathrm{R}}$ and retrieved substring in register $|T_{\left[w\right]}{⟩}_{\mathrm{Q}\mathrm{D}}$ of size $w=M\times {\log }_2\left|\mathrm{\Sigma }\right|$ qubits. We seek an exact match on behalf of each index $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$ in superposition on QMEM. This circuit compares the qubits of size ${\log }_2\left|\mathrm{\Sigma }\right|$ for each symbol contained in $|P{⟩}_{\mathrm{D}\mathrm{R}}$. So, for M length pattern, all ${\log }_2\left|\mathrm{\Sigma }\right|$ sized qubits are analyzed in $O\left(1\right)$ time. We specified the QEM operation in Eq. (5), and relevant circuit is shown in Fig. 3 with depth 2 i.e. $O\left(1\right)$ (Sena Oliveira, Benicio Melo de Sousa & Viana Ramos, 2007; De Jesus, Aborot & Adorna, 2013; Soni & Rasool, 2021; Soni & Malviya, 2021).

(5) $$\text{QEM Operation}\leftarrow \left(U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}:f\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\right)=\{\begin{array}{c}\begin{array}{c}0,\mathrm{i}\mathrm{f}\end{array}|T_{[i\mathrm{t}\mathrm{o}i+M-1]}{⟩}_{\mathrm{Q}\mathrm{D}}\ne |P_{\left[0\mathrm{t}\mathrm{o}M-1\right]}{⟩}_{\mathrm{D}\mathrm{R}}\\ \begin{array}{c}1,\mathrm{i}\mathrm{f}\end{array}|T_{[i\mathrm{t}\mathrm{o}i+M-1]}{⟩}_{\mathrm{Q}\mathrm{D}}=|P_{\left[0\mathrm{t}\mathrm{o}M-1\right]}{⟩}_{\mathrm{D}\mathrm{R}}\end{array}\right)$$

The comparison between $|P_{\left[0\mathrm{t}\mathrm{o}M-1\right]}{⟩}_{\mathrm{D}\mathrm{R}}$ and $|T_{[i\mathrm{t}\mathrm{o}i+M-1]}{⟩}_{\mathrm{Q}\mathrm{D}}$ is performed by unitary $U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}$ in an explored superposition of QMEM with text indices $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$. So, entire $w=M\times {\log }_2\left|\mathrm{\Sigma }\right|$ qubits sized substring is compared in parallel with constant time. This circuit is designed with $3\times M\times {\log }_2\left|\mathrm{\Sigma }\right|=C^{2}NOT$ gates which are arranged at level zero (for M sized text substring and pattern, and M additional ancilla). At level one, we used $M=C^{{\log }_2\left|\mathrm{\Sigma }\right|+1}NOT$ gates to check for equality as either $|0⟩==|0⟩$ or $|1⟩==|1⟩$ between aligned qubits of size ${\log }_2\left|\mathrm{\Sigma }\right|$ for each character of P. Last level is designed with single $C^{M+1}NOT$ gate that flips a target qubit $|q_{Comp}⟩$ to indicate the quantum-based exact match. So, the depth of quantum circuit is $O\left(1\right)$. The qubits requirement of the proposed circuit is $\left(3\times M\times {\log }_2\left|\mathrm{\Sigma }\right|\right)$ + $M$ + $1$ and we estimate asymptotic complexity with $O\left(M\times {\log }_2\left|\mathrm{\Sigma }\right|\right)$. Thus, this quantum-exact match (QEM) circuit is efficient.

Grover’s search operator (GSO) to generate high probable results

Third, Grover’s method is optimal to search for pattern in $O\left(\sqrt{N}\right)$ steps over N size text. It uses amplitude amplification that repeats for $\pi /4\sqrt{N}$ times, each iteration applies reflection operations for transforming target index to high amplified amplitude under superposition state, and thus to obtain high probable search results (Nielsen & Chuang, 2010; Chakrabarty, Khan & Singh, 2017). So, $O\left(\sqrt{N}\right)$ steps assure to eventually result in the desired state with significantly large amplitude. A method is shown in Fig. 4 and it’s next to next figure. No more iterations than $\sqrt{N}$ is recommended, as this succeeds with a solution on the sine function principle. It gradually increases as per the increase in function argument, but later this starts decreasing. However, this search mechanism is the only way to achieve a quadratic speedup (Lanzogorta & Uhlmann, 2008; Zhou et al., 2013; Coles, 2020).

The GSO operation is defined as Eq. (6) with sub-unitary specified in Eqs. (7) and (8). A search oracle $O\leftarrow \left(U_{\mathrm{M}\mathrm{a}\mathrm{r}\mathrm{k}}\left(U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}\right)\right)$ marks the target index location of the pattern when $U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}$ of Eq. (5) is succeeded for the exact match through Boolean oracle. Further, phase inversion is applied by phase oracle using $U_{\mathrm{M}\mathrm{a}\mathrm{r}\mathrm{k}}\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\otimes |q⟩\right)$ of Eq. (7) to reflect the target index amplitude as $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}|-⟩$ $\to$ ${\left(-1\right)}^{f\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\right)}$ $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$ $|-⟩$. Another reflection operator diffusion $D\leftarrow \left(U_{\mathrm{D}\mathrm{i}\mathrm{f}\mathrm{f}}\left(O\right)\right)$, defined in Eq. (8), inverts all amplitudes around the mean, such that the amplitude of solution increases and the others decrease. In actual, this method amplifies the search index amplitude in each iteration (Lanzogorta & Uhlmann, 2008; Zhou et al., 2013; Broda, 2016; Giri & Korepin, 2017; Figgatt et al., 2017; Coles, 2020). The GSO operational description is provided in correctness proof of proposed algorithms.

(6) $$\text{GSO Opeartion}\leftarrow \left(D\leftarrow U_{\mathrm{D}\mathrm{i}\mathrm{f}\mathrm{f}}\left(O\leftarrow \left(U_{\mathrm{M}\mathrm{a}\mathrm{r}\mathrm{k}}\left(U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}\right)\right)\right)\right)$$

(7) $$\begin{array}{r}O\leftarrow U_{\mathrm{M}\mathrm{a}\mathrm{r}\mathrm{k}}\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\otimes |q⟩\right)=\left(I-2|T_i{⟩}_{\mathrm{Q}\mathrm{A}}⟨T_i{|}_{\mathrm{Q}\mathrm{A}}\right)\otimes \left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\otimes |q⟩\right)\\ =\{\begin{array}{c}\begin{array}{c}|T_i{⟩}_{\mathrm{Q}\mathrm{A}},f\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\right)=0\end{array}\\ -\begin{array}{c}|T_i{⟩}_{\mathrm{Q}\mathrm{A}},f\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\right)=1\end{array}\end{array}\end{array}$$

(8) $$D\leftarrow U_{\mathrm{D}\mathrm{i}\mathrm{f}\mathrm{f}}\left(O\right)=D\left(\left(2|{\psi }_n⟩⟨{\psi }_n|-I\right)\left(O\right)\right)=D\left(H^{\otimes n}\left(2|0⟩⟨0|-I\right)H^{\otimes n}\left(O\right)\right)$$

A GSO works under superposition state $|{\psi }_n⟩$ by making an angle $\left(\pi /2-\theta \right)$ and transforms the solution state by applying each time $2\theta$ rotations. So, for r rotations, $\left(r\times 2\theta =\pi /2-\theta \right)$ then $\left(r=\pi /4\theta -1/2\right)$. In superposition of N elements, the amplitude for each of t solutions are $\sqrt{t/N}$, so $\theta =\sqrt{t/N}$. On $U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}$ success $Pr\left[\text{GSO outputs}|T_i{⟩}_{\mathrm{Q}\mathrm{A}}iff\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\right)==1\right]=t/N$. So, put this phase $\theta$ in r we get $\left(r=\pi /4\sqrt{N/t}-1/2\right)\approx \pi /4\sqrt{N/t}\cong O\left(\sqrt{N/t}\right)$ step. For geometric proof, refer (Nielsen & Chuang, 2010; Broda, 2016; Chakrabarty, Khan & Singh, 2017; Coles, 2020; Soni & Rasool, 2021; Soni & Malviya, 2021). The $1\le t\le N$ solutions are searched in $\sqrt{N/t}$ query and $O\left(\sqrt{N/t}{\log }_{2}N\right)$ time with $Pr\left[\text{GSO outputs}|T_i{⟩}_{\mathrm{Q}\mathrm{A}}iff\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\right)==1\right]\ge t/N$.

As reviewed, analysis of quantum effective processing framework is specified in Table 4. The QMEM makes searching outcomes available in parallel with $O\left(1\right)$ step. The unitary $U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}$ of $O\left(1\right)$ time is used in GSO as implicit operation and it is simulated on QMEM design. The GSO can find number of pattern occurrences $t=t_{\mathrm{f}\mathrm{e}\mathrm{w}}$ (multiple solution), where $t_{few}$ denotes few pattern occurrences ( $t_{\mathrm{f}\mathrm{e}\mathrm{w}}\ll N$), using $O\left(\sqrt{N/t}\right)$ queries and $O\left(\sqrt{N/t}{\log }_{2}N\right)$ time. As $H^{\otimes n}$ operations run in parallel, each with $O\left(1\right)$ time, so asymptotic complexity is considered as $O\left(\sqrt{N/t}\right)$ with respect to negligible multiplicative factor $\left({\log }_{2}N\right)$ (Brassard et al., 2002; Lomont, 2003; Ablayev et al., 2020). If it is known that the $t=0$ (no solution), then GSO returns a random element uniformly in $O\left(\sqrt{N}\right)$ time. In case, $t=1$ (unique solution), search result can be obtained in $O\left(\sqrt{N}\right)$ time with high probability.

To report t search solution, GSO needs $t\times \sqrt{N/t}=\sqrt{t}\times \sqrt{t}\times \sqrt{N/t}=\sqrt{Nt}$ queries and $O\left(\sqrt{Nt}{\log }_{2}N\right)$ time. However, all solutions $t=1\mathrm{o}\mathrm{r}{t}_{\mathrm{f}\mathrm{e}\mathrm{w}}$ are possible in $O\left(\sqrt{N}\right)$ and when $t=N$ (all are search solution), the search time is $O\left(N\right)$ i.e. same as the classical. For $t=1$ case, GSO can obtain the result with high probability after $\sqrt{N}$ iterations, however, more $\sqrt{N}$ iterations can again generate uniform probability. This may happen repeatedly in each successive $\sqrt{N}$ iterations. Therefore, only $O\left(\sqrt{N}\right)$ iterations are needed to obtain high probable search solution. We prefer the quantum search to find the few pattern occurrences. The consideration of $t=N$ is found rare for a biological text, and hence this can be ignored (Nielsen & Chuang, 2010; Broda, 2016; Chakrabarty, Khan & Singh, 2017; Soni & Rasool, 2021; Soni & Malviya, 2021).

To our knowledge, the quantum search assumes that the number of search solutions t (either unique or multiple solution) are already known. Therefore, number of GSO iterations can be determined in advance and after $\pi /4\left(\sqrt{N/t}\right)$ iterations the search results are found with certainty and high probability. However, the GSO can overshoot if the t number of search solutions are unknown/not known in advance. In that case, with the unknown number of GSO iterations, the probability of success would be vanishingly small (Boyer et al., 1998; Brassard et al., 2002; Lomont, 2003; Younes, 2008; Song, 2017; Ablayev et al., 2020).

To deal with the unknown number of search solutions, one of the methods was proposed by Boyer et al. (1998) and restated in Younes (2008); Song (2017) and Ablayev et al. (2020) as the modified Grover’s search that runs GSO several times in successive iterations. The modified algorithm of Boyer et al. (1998) repeats GSO by taking the value of t in an exponential increase. On $j^{th}$ repetition, $\pi /4\left(\sqrt{N/2^j}\right)$ iterations are performed. The repetitions are here summing to $O\left(\sqrt{N}\right)$ times. Either of these iterations may find the search results with a sufficient high probability. In each of these repetition, the GSO operations are still bounded by $\pi /4\left(\sqrt{N}\right)$ iterations. It is equivalent to $O\left(N\right)$ time classical complexity, so not used in practical implementation (Boyer et al., 1998).

Quantum counting (QC) is an alternative approach that can satisfactorily handle the problem of unknown number of search solutions (Brassard et al., 2002; Lomont, 2003; Song, 2017). A QC is quantum amplitude estimation (QAE) method that can estimate t number of search solutions either based on approximation or based on exactness. It helps to decide the required number of GSO iterations. The QAE technique is defined in Brassard et al. (2002) and Fang Song (2017), and it is used for estimating $t=\left|\left\{|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\in N|f\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\right)==1\right\}\right|$ as the possible count to find the number of search solutions. These authors (Boyer et al., 1998; Brassard et al., 2002; Lomont, 2003) suggested to run quantum counting algorithm initially, and then to proceed with actual number of GSO iterations. Quantum counting results can be obtained with quadratic speedup in $O\left(\sqrt{N}\right)$ time. Therefore, we observed it as an efficient method when the number of search solutions are unknown, and hence it prevents overshooting of Grover’s. Later, in theoretical results and complexity analysis section, we analyze the exact and approximate quantum counting methods, and these are implemented to simulate our algorithms.

A circuit of QMEM needs $C^{n+1}NOT$ to mark $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$ address, and to store $w=M\times {\log }_2\left|\mathrm{\Sigma }\right|$ in $|T_{\left[w\right]}{⟩}_{QD}$ we use $M\times {\log }_2\left|\mathrm{\Sigma }\right|=CNOT$. This memory is exponentially faster than the CRAM circuit. However, its access depends on the depth of the bifurcation tree i.e. $O\left({\log }_{2}N\right)$ time. Quantum search works with QMEM by applying $H^{\otimes n}\left(|T_i{⟩}_{\mathrm{Q}\mathrm{A}}\right)$ and $XH\left(|q⟩\right)$ and then $U_{\mathrm{C}\mathrm{o}\mathrm{m}\mathrm{p}}$ checks for exact match followed by amplification. On a successful match, qubit $|q⟩$ is flipped by $C^{n+1}NOT$ gate, then $U_{\mathrm{M}\mathrm{a}\mathrm{r}\mathrm{k}}$ flips the phase of index $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$ by $C^{n}Z$ gate. Diffusion performs the amplification through the set of quantum operators $\left\{\left\{H^{\otimes n}{X}^{\otimes n}\right\}{C}^{n}Z\left\{H^{\otimes n}{X}^{\otimes n}\right\}\right\}$. At the last, perform measurement at index $|T_i{⟩}_{\mathrm{Q}\mathrm{A}}$. In addition, we included qubits requirement for QMEM and GSO. Quantum gates and the circuit requirement of the framework is shown in Table 4. However, our remark states that quantum search over text T of size N takes $n+2M{\log }_2\left|\mathrm{\Sigma }\right|+1$ qubits (Lanzogorta & Uhlmann, 2008; Nielsen & Chuang, 2010; Zhou et al., 2013; Broda, 2016; Chakrabarty, Khan & Singh, 2017; Giri & Korepin, 2017; Figgatt et al., 2017; Coles, 2020; Soni & Rasool, 2021; Soni & Malviya, 2021). Further, n is replaced by tq qubits for the search which is performed over the reduced size filtered text. A QMEM is efficiently simulated using algebraic normal form (ANF) for the hybrid realization of quantum operations (Bogdanova et al., 2018; Malviya & Tiwari, 2020; Hao et al., 2020; Malviya & Tiwari, 2021).

Proposed method 1: enhanced QMEM processing based exact algorithm for multiple pattern matching (EnQPBEA-MPM)

This method searches for each pattern $P_k\in P$ in parallel using QPU with C cores accessing text T on shared QMEM, such that search time of all $t_k$ occurrence of $P_k$ overlaps. QEM circuit is applied under superposition of text on QMEM by each $QCor{e}_c$. Search results are instantly possible and would be effective for the biological sequencing because of no other processing overhead except the search time. Existing QPBE is enhanced efficiently by executing search oracles in parallel with the negligible time factor, and the existing iterative pattern search overhead of QEMP is also removed.

A pattern $P_k\in P$ is individually processed on $c^{th}$ core $QCor{e}_c$ where $\left(1\le c\le C\right)$, so $m/C$ patterns are searching in parallel within the text T of size N shared on QMEM. Each pattern $P_k$ is assumed with individual size $w=M_k\ast {\log }_2\left|\mathrm{\Sigma }\right|$ qubits, and it is stored in $|P_{\left[0\mathrm{t}\mathrm{o}{M}_k-1\right]}{⟩}_{DRk}$ as in separate data register. The text T realized on $|T_{2^n\times w}{⟩}_{\mathrm{Q}\mathrm{M}\mathrm{E}\mathrm{M}}$ is accessed in a superposition of addresses by $QCor{e}_c$ through address register $|T_i{⟩}_{QAk}$ $\left(i\in {\left\{0,1\right\}}^n\right)$. All the text substrings, each of length $M_k\ast {\log }_2\left|\mathrm{\Sigma }\right|$ are loaded in entangled register $|T_{\left[w\right]}{⟩}_{QDk}$ by applying QMEM transformation. A unitary $U_{\mathrm{L}\mathrm{o}\mathrm{a}\mathrm{d}}$ makes sure such data load in a coherent superposition of text addresses. Once these substrings are available in parallel, EnQPBEA applies the GSO operator, separately on $QCor{e}_c$ to ensure an exact match of each $P_k$ with QEM circuit realized using $U_{kComp}$. The Boolean oracle circuit succeeds by flipping target qubit of Fig. 3 to report exactness. When $c^{th}$ core $QCor{e}_c$ identifies exact match in superposition, the amplification operator $U_{\mathrm{D}\mathrm{i}\mathrm{f}\mathrm{f}}\left(U_{\mathrm{M}\mathrm{a}\mathrm{r}\mathrm{k}}\right)$ is then applied to increase the probability amplitude of identified indices $|T_i{⟩}_{QAk}$. The GSO operator repeats for $O\left(\sqrt{N}\right)$ time and then $QCor{e}_c$ applies the measurement to obtain search index $|T_i{⟩}_{QAk}$ with high probability.

The quantum state gets collapsed after each measurement, so its repetition ensures to report all $t_k$ index locations of $P_k\in P$ which are identified by $c^{th}$ quantum core $QCor{e}_c$. Each pattern occurrence is verified by same core as $|T_{[i\mathrm{t}\mathrm{o}i+M_k-1]}{⟩}_{QDk}==|P_{\left[0\mathrm{t}\mathrm{o}{M}_k-1\right]}{⟩}_{DRk}$. The pattern matching method of EnQPBEA-MPM is illustrated in Fig. 4. However, the steps are listed in the proposed algorithm, and the equivalent quantum circuit executing search oracles in parallel is shown in Fig. 5. In reference to Table 4 discussion, we state, that each core realizes $O\left(\sqrt{N/t_k}\right)$ iterations of GSO in parallel, and therefore, results in all desired pattern occurrence $t_k$ on behalf of pattern $P_k$. However, we require $O\left(\sqrt{N{t}_k}\right)$ queries to report all $t_k$ marked occurrences, and hence the pattern matching time is bounded to $O\left(\sqrt{N{t}_k}{\log }_{2}N\right)$ with negligible logarithmic factor. We clarify that EnQPBEA repeats GSO operation in parallel for $t_k$ times on each core $QCor{e}_c$ to search all $t_k$ indexes. So, we consider $t=t_k=max\left(t_1,.,t_k,.,t_m\right)$ as based on longest core processing to find maximum pattern occurrences. Therefore, the search complexity of parallel executions of EnQPBEA using QPU with C cores is $O\left(\left(m/C\right)\left(\sqrt{Nt}{\log }_{2}N\right)\right)$ time. In support of complexities, a correctness proof of EnQPBEA-MPM with quantum operations is specified in Appendix C. For mathematical proof, we define certain Lemma 1 as partial required proof, and based on that, we conclude the computational complexity and achieved speedup through the resulting proof of Theorem 1.

Lemma 1: A QPU having C quantum cores $\left(1\le c\le C\right)$ can access the text T of size N on shared QMEM. It loads all text substring equal to pattern length $P_k$ as $M_k\ast {\log }_2\left|\mathrm{\Sigma }\right|$ qubits in superposition by using $QCor{e}_c$ in parallel. Time needed for such parallel loading operations ranges between $O\left(\left(m/C\right)\left(M{\log }_{2}N\right)\right)$ and $O\left(\left(m/C\right)\left(MN{\log }_{2}N\right)\right)$.

Proof (Lemma 1): About earlier discussions of effective processing framework and Table 4, we use to prove this lemma. The $|T_{2^n\times w}{⟩}_{QMEM}$ as shared among C cores of QPU, makes sure that all $|T_i{⟩}_{QAk}$ addresses are available in parallel on each $QCor{e}_c$ & QMEM transformation loads $M_k\ast {\log }_2\left|\mathrm{\Sigma }\right|$ qubits in entangled register $|T_{\left[w\right]}{⟩}_{QDk}$. The entire memory access is available in constant time on each individual core, however, by considering M as $M=max\left(M_1,.,M_k,.,M_m\right)$ the memory circuit needs $O\left(M{\log }_{2}N\right)$ steps. So, the parallel time of QMEM access using QPU with C quantum cores is $O\left(\left(m/C\right)\left(M{\log }_{2}N\right)\right)$. As we know, that the quantum state is collapsed after each measurement, so to report all $t_k$ index of $P_k$ identified by $c^{th}$ quantum core $QCor{e}_c$, we need this access several times. By assuming $t=t_k=max\left(t_1,.,t_k,.,t_m\right)$ at any $QCor{e}_c$ for QMEM transformation, and at worst, if number of identified patterns are $t=N$ then each time, all parallel substring load will take $O\left(\left(m/C\right)\left(MN{\log }_{2}N\right)\right)$ time. We discussed earlier, that both these factors M and $\left(m/C\right)$ are negligible due to parallel load and parallel processing by achieving exponential speedup.