Hybrid Classical–Quantum Text Search Based on Hashing

Abstract

The paper considers the problem of finding a given substring in a text. It is known that the complexity of a classical search query in an unordered database is linear in the length of the text and a given substring. At the same time, Grover’s quantum search provides a quadratic speed-up in the complexity of the query and gives the correct result with a high probability. We propose a hybrid classical–quantum algorithm (hybrid random–quantum algorithm, to be more precise) that implements Grover’s search to find a given substring in a text. As expected, the algorithm works (a) with a high probability of obtaining the correct result and (b) with a quadratic query acceleration compared to the classical one. What is new is that our algorithm uses the uniform hash family functions technique. As a result, our algorithm is much more memory efficient (in terms of the number of qubits used) compared to previously known quantum algorithms.

1. Introduction

Quantum search algorithms and their generalizations [1,2,3,4,5] are part of a group of quantum algorithms that are of great interest in computer science.

The use of quantum computers can significantly reduce the computation time for models with a large number of weights, or those requiring an exponentially growing number of combinations. We presented several results in the field of quantum approaches to classification and information retrieval in the papers [6,7].

The task of finding occurrences of a given substring in a text is an important problem of information retrieval. It occurs in a wide range of applications, namely, in text editors, in search robots, spam filters, bioinformatics, etc. A large number of algorithms (deterministic and probabilistic) for solving the search problem have been developed over the past few decades. Quantum algorithms for solving the search problem have been developed in the last two decades.

1.1. Problem

Given a binary N length sequence

$$string=b_1\dots b_N$$

and a binary m length sequence w, $m<N$. Let $n=N+1-m$ denote the number of substrings of length m in the text string. It is required to find the index of the occurrence of the substring w in the text $string$. Namely, it is required to find an index k such that $w=b_k\dots b_{k+m-1}$, $0\le k\le n-1$.

1.2. Related Work

The known Knuth–Morris–Pratt’s [8] classical algorithm (1977) solves the problem in linear time $O(m+n)$.

In the early 2000s, a quantum algorithm [9] for searching for a given substring in a text was presented. It allows to obtain quadratic search speed-up. It returns one of the indices of the occurrence of the searched substring. The probability of obtaining the correct answer is strictly greater than 1/2. The query complexity (this measure of complexity is sometimes associated with time complexity) of an algorithm is $O(\sqrt{n}log\sqrt{\frac{n}{m}}logm+\sqrt{m}{log}^{2}m)$. The authors [9] do not estimate the memory complexity (number of used qubits) of their algorithm. Since the authors use m qubits to encode a single binary subword of length m, the [9] algorithm requires $O(logn+m)$ qubits.

1.3. Our Contribution

We present a quantum algorithm for finding a pattern in a string. The algorithm is based on Grover’s search algorithm and hashing technique. It is known that the hashing method can significantly save space and, as a rule, the time required for searching in databases. The results of the paper demonstrate the potential of a universal hashing method for building quantum search algorithms.

To simplify the presentation, and not to clutter the idea with technical details, consider the case when it is known in advance that the desired substring occurs in the text exactly once.

More precisely, we propose a hybrid random–quantum search algorithm $\mathcal{A}$ that searches a text for a substring and has the following characteristics:

• The $\mathcal{A}$ algorithm produces a result with a high probability of obtaining the correct answer.
• The $\mathcal{A}$ algorithm is based on Grover’s search. This search is presented in the paper as an auxiliary algorithm $\mathcal{A}1$ and requires $O\left(\sqrt{n}\right)$ query steps.
• The $\mathcal{A}$ algorithm exponentially saves (compared to the [9] algorithm) the number of qubits relative to the parameter m—the length of the substring. Namely, the algorithm requires $O(logn+logm)$ qubits for his work.

The main idea of the paper is the use of the hashing technique to save space complexity in quantum search. The $\mathcal{A}$ algorithm is based on a certain universal family of hash functions. The $\mathcal{A}2$ algorithm is a generalization of the result to a general universal hash family of functions.

The result of the work is organized as follows. In the next section (Section 2), we present the basic model of the quantum search algorithm, basic notation and definitions. In Section 3, we present the main result. We first present the auxiliary quantum procedure $\mathcal{A}1$. Next, we present a quantum search algorithm $\mathcal{A}$ based on the hashing technique. Theorem 1 is an analysis of the $\mathcal{A}$ algorithm. In Section 5, we present the $\mathcal{A}2$ algorithm, a generalization of the $\mathcal{A}$ algorithm.

The preliminary version of the article was published in Russian [10].

2. Preliminaries for Quantum Query Algorithm

We refer the reader to the [5,11] for an introduction to the basics of quantum query algorithms and the state of research in this area. Here, we define the query model of computations in a way that is convenient for us. We use the notation defined in detail in [6,7].

The operations applied to quantum s-qubit states $\left|\psi \right.〉\in {\left({\mathcal{H}}^2\right)}^{\otimes s}$ are mathematically expressed using unitary operators:

$$\left|{\psi }^{\prime }\right.〉=U\left|\psi \right.〉,$$

(1)

where U is a $2^s\times 2^s$ unitary matrix.

2.1. Query Model

For a finite sets X and Y let

$$g:X\to Y$$

be a discrete function. A quantum query algorithm $\mathcal{A}$ computing the function g begins in a quantum state $|{\psi }_{start}\rangle$ and applies a sequence of operators

$${\mathcal{O}}_X,\mathcal{U},\dots ,{\mathcal{O}}_X,\mathcal{U},$$

The operator ${\mathcal{O}}_X$ depends on the input X. The quantum community calls the ${\mathcal{O}}_X$ operator an “oracle”. Application of the oracle is called the query of the algorithm $\mathcal{A}$ to the initial data X. The operator $\mathcal{U}$ does not depend on X.

The algorithm computes the value $g\left(\sigma \right)$ of the discrete function g for $\sigma \in X$ if the initial state $|{\psi }_{start}\rangle$ goes to the final state

$$\left|\psi \left(g\right(\sigma \left)\right)\right.〉=\mathcal{U}{\mathcal{O}}_{\sigma }\cdots \mathcal{U}{\mathcal{O}}_{\sigma }\left|{\psi }_{start}\right.〉,$$

in the process of computing on the input value $\sigma$. The final state allows extracting the value of $g\left(\sigma \right)$ as a result of measuring the state of $\left|\psi \left(g\right(\sigma \left)\right)\right.〉$.

2.2. Search in an Unordered Database

Quantum search algorithm in an unordered database of n elements, in which there is exactly one element of interest to us (Grover’s algorithm), is a special case of a group of query algorithms. The following algorithm scheme underlies many generalizations:

• Initialize a quantum system of $O(logn)$ qubits into a $\left|{\psi }_{start}\right.〉$ state containing information about the database. The $\left|{\psi }_{start}\right.〉$ state is constructed so that each of the $2^{O(logn)}$ basis quantum states represents the required information about n database elements.
• The following $O\left(\sqrt{n}\right)$ “macro” steps are performed on the $\left|{\psi }_{start}\right.〉$ state:
  • The oracle ${\mathcal{O}}_X$ is used. It recognizes the basis state of interest to us and multiplies its amplitude by −1.
  • The operator $\mathcal{U}$ performs the inversion by the average value over all amplitudes.

“Macro” Step 2 describes the key operation of quantum search. Each such step increases the amplitude of the basis state that represents the desired information. The number $O\left(\sqrt{n}\right)$ of such steps maximizes the amplitude, and the probability of extracting the required information from the resulting state $\left|{\psi }_{final}\right.〉$ becomes close to 1.

2.3. Basic Operations of Qubits for Quantum Search

The potential advantages of quantum algorithms, on which the results of this work are based, lie in the possibility of implementing quantum operators of dimension $2^s\times 2^s$ by basic operations based on a small number of order $O\left(s\right)$ qubits and in a small number of quantum computing steps (not a complex scheme implemented by basic elements).

The main operations are $I,X,Z,H$:

• I—identity operator.

  $$I=\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right).$$
• X—is a NOT operator. It changes the state of the qubit from $\left|0\right.〉$ to $\left|1\right.〉$, and vice versa:

  $$\begin{array}{c}X=\left(\begin{array}{cc}0& 1\\ 1& 0\end{array}\right).\hfill \end{array}$$

  (2)
• Z—amplitude sign reversal operator:

  $$\begin{array}{c}Z=\left(\begin{array}{cc}1& 0\\ 0& -1\end{array}\right).\hfill \end{array}$$

  (3)
• H—Hadamard operator:

  $$\begin{array}{c}H=\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right).\hfill \end{array}$$

  (4)

2.4. Characteristics of the $\mathcal{A}$ Algorithm

The characteristics of a quantum query algorithm are the used memory, the number of queries to the analyzed data, and the probability of an error.

• Size complexity (memory complexity). The number $S\left(\mathcal{A}\right)$ of used qubits is a measure of the memory complexity of the quantum algorithm $\mathcal{A}$.
  We denote by $S^{\mathcal{A}}(string,w)$ the number of qubits used by the $\mathcal{A}$ algorithm to solve the problem of finding the substring w in the $string$.
  Through $S^{\mathcal{A}}(n,m)$, we denote the maximum among the numbers $S^{\mathcal{A}}(string,w)$ over all $string$ and w with parameters $N=\left|string\right|,m=\left|w\right|,n=N-m+1$.
• Query complexity. The number $Q\left(\mathcal{A}\right)$ of queries (number of the oracle applications) is a “query” measure of the complexity of the quantum algorithm $\mathcal{A}$. Note that in [11], one request to the oracle is testing one variable (one bit). Accordingly, in our work, one request to the oracle is implemented in the process of testing the entire string w (hash values of w).
  We denote by $Q^{\mathcal{A}}(string,w)$ the number of applications by the algorithm $\mathcal{A}$ of the oracle operator.
  Through $Q^{\mathcal{A}}(n,m)$, we denote the maximum among the numbers $Q^{\mathcal{A}}(string,w)$ over all $string$ and w with parameters $N=\left|string\right|,m=\left|w\right|,n=N-m+1$.
• Error probability. We denote by $E{r}^{\mathcal{A}}(string,w)$ the probability of the following event. The algorithm $\mathcal{A}$, as a result of solving the problem of finding the substring w in the text $string$, gives the number k of the position in the text $string$ such that $w_k\ne w$.
  Through $E{r}^{\mathcal{A}}(n,m)$, we denote the maximum among the numbers $E{r}^{\mathcal{A}}(string,w)$ over all $string$ and w with parameters $N=\left|string\right|,m=\left|w\right|,n=N-m+1$.

3. Algorithms for Finding the Index of Occurrence of a Substring in the Text

In this section, we present a hybrid classical–quantum algorithm (more precisely, a hybrid random–quantum algorithm) $\mathcal{A}$ for finding a substring w of length m in a binary text

$$string=b_1\dots b_N.$$

We consider the simplest version of the problem: we assume that the required substring w is guaranteed to occur exactly once in the text $string$.

The problem is reduced to a problem of finding word w in the vocabulary as follows. Let $n=N+1-m$. To simplify presentation, we assume below that the number n (the number of substrings in the $string$) is a power of 2. Denote by $V(string,m)$ a sequence composed of all substrings of length m of the $string$

$$V(string,m)=\{w_0,\dots ,w_{n-1}\},$$

where $w_k=b_{k+1}\dots b_{k+m}$ for $0\le k\le n-1$. We will call $V(string,m)$ a vocabulary.

Now, the problem of finding the word w in $string$ is represented as the problem of finding an index k such that $w=w_k$ for the vocabulary $V(string,m)$.

3.1. Auxiliary Quantum Procedure $\mathcal{A}1$ (Algorithm 1)

The quantum part of the algorithm is the following auxiliary quantum procedure $\mathcal{A}1$. Procedure $\mathcal{A}1$ starts with an initial quantum state $\left|string\right.〉$ (quantum vocabulary) constructed from the vocabulary V using the pre-procedure $\mathcal{P}$.

Pre-procedure $\mathcal{P}$ generates the initial state (quantum vocabulary) $\left|string\right.〉$ from vocabulary $V=\{v_0,\dots ,v_{n-1}\}$ composed of binary words of length $l\ge 1$. The $\left|string\right.〉$ state has the following structure:

$$\left|string\right.〉=\frac{1}{\sqrt{n}}\sum _{k=0}^{n-1}\left|k\right.〉\otimes \left|v_k\right.〉\otimes \left|1\right.〉.$$

• Description of the procedure $\mathcal{A}\mathbf{1}$

Algorithm 1 Auxiliary quantum procedure $\mathcal{A}1$

Input: Quantum state $\left|string\right.〉$. Binary word v. Output: The index k, which is interpreted as an index such that $v=v_k$. That is, $\mathcal{A}1(\left|string\right.〉,v)$ implements the mapping $$\mathcal{A}1:\left|string\right.〉,v⟼k.$$ The following two macro steps, described below in operator form, are applied to the state $\left|string\right.〉$$\frac{\pi }{4}\sqrt{n}$ times. In the literature, these two macro steps are often referred to as the “Grover iteration” [1]: The oracle ${\mathcal{O}}_{f_v}$ operation of changing the phase of the state representing information about $v_k$, for which $v_k=v$ is performed. For a binary sequence $v\in {\{0,1\}}^l$, define the Boolean function $f_v:{\{0,1\}}^l\to \{0,1\}$ by the condition $f_v\left(x\right)=1$ if and only if $x=v$. Let $\left|x\right.〉$ denote the basic state corresponding to the element x, which is one of $v_k$. In this case, $\left|x\right.〉$ is l—the qubit basis state. Oracle ${\mathcal{O}}_{f_v}$ performs the following three actions: Application of the H operator on the auxiliary ($logn+l+1$)-th qubit $\left|1\right.〉$: $$\left|x\right.〉\otimes \left|1\right.〉\stackrel{I^{\otimes logn+l}\otimes H}{\to }\left|x\right.〉\otimes \frac{1}{\sqrt{2}}(\left|0\right.〉-\left|1\right.〉)$$ Application of the operator $U_{f_v}$ on the last $l+1$ qubits: $$\begin{array}{cc}\hfill \left|x\right.〉\otimes \frac{1}{\sqrt{2}}(\left|0\right.〉-\left|1\right.〉)& \stackrel{I^{\otimes logn}\otimes U_{f_v}}{\to }\frac{1}{\sqrt{2}}\left|x\right.〉\otimes (\left|0\oplus f_v\left(x\right)\right.〉-\left|1\oplus f_v\left(x\right)\right.〉)=\hfill \\ \hfill & ={(-1)}^{f_v\left(x\right)}\left|x\right.〉\otimes \frac{1}{\sqrt{2}}(\left|0\right.〉-\left|1\right.〉)\hfill \end{array}$$ Application of the H operator on the auxiliary ($logn+l+1$)-th qubit $\left|1\right.〉$: $$\begin{array}{cc}\hfill {(-1)}^{f_v\left(x\right)}\left|x\right.〉\otimes \frac{1}{\sqrt{2}}(\left|0\right.〉-\left|1\right.〉)& \stackrel{I^{\otimes logn+l}\otimes H}{\to }{(-1)}^{f_v\left(x\right)}\left|x\right.〉\otimes \left|1\right.〉\hfill \end{array}$$ Note that the auxiliary qubit at the end restores its value (by repeated application of the Hadamard transformation) to the $\left|1\right.〉$ state: Inversion operation.$\mathcal{D}$ = 2$\mathcal{R}-I^{\otimes logn}$—operator applied on the first n qubits. The $\mathcal{R}$ operator is given in matrix form: $$\mathcal{R}=\frac{1}{logn}\left(\begin{array}{cccc}1& 1& \dots & 1\\ 1& 1& \dots & 1\\ ⋮& \dots & \ddots & ⋮\\ 1& 1& \dots & 1\end{array}\right)$$ Obtaining the result of computation (the output of the $\mathcal{A}1$). After running the macro steps above $\frac{\pi }{4}\sqrt{n}$ times, we measure the first $logn$ qubits in the computational basis. The resulting $logn$ bits are interpreted as a binary representation of the required index k.

3.2. Algorithm $\mathcal{A}$ (Algorithm 2)

The algorithm consists of two sequentially working parts:

• First part: preparing the initial state based on the dictionary $V(string,m)$.
• Second part: reading the search word w and searching for its occurrence in the vocabulary.

We emphasize that the algorithm $\mathcal{A}$ has two different input sets: $V(string,m)$ and w. These sets are fed to the first and second parts of the algorithm $\mathcal{A}$, respectively.

Notations:

• For a binary string w of length m, denote by $a\left(w\right)$ the number represented by w, $0\le a\left(w\right)\le 2^m-1$.
  Given a number $a\in \{0,\dots ,2^m-1\}$, denote by $bin\left(a\right)$ its binary representation of length m.
• For the vocabulary $V(string,m)$, let $V_p$ denote the following vocabulary:

  $$V_p=\{v\left(w_0\right),\dots ,v\left(w_{n-1}\right)\},$$

  where $v\left(w_k\right)=bin\left(r{\left(w_k\right)}_p\right)$ and $r{\left(w_k\right)}_p$ is the p-remainder of $a\left(w_k\right)$. That is, $a\left(w_k\right)=cp+r{\left(w_k\right)}_p$, where $c\ge 0$ and $r{\left(w_k\right)}_p\in \{0,\cdots ,p-1\}$.
• Denote by $P_d=\{p_1,\cdots ,p_d\}$ the set of first d primes.

• Description of the Algorithm $\mathcal{A}$

Algorithm 2 Algorithm $\mathcal{A}$

Input: For the first part: Vocabulary $V(string,m)$. For the second part: Binary word w of length m. Output: The index k, which is interpreted as an index such that $w=w_k$. That is, $\mathcal{A}$ implements the mapping $$\mathcal{A}:V(string,m),w⟼k.$$ The first part of the algorithm is to prepare the initial state from the vocabulary $V(string,m)$: First, the algorithm makes a classical random choice: a prime number p is uniformly and randomly selected from the set $P_d$ and the vocabulary $V_p$ $$V_p=\{v\left(w_0\right),\dots ,v\left(w_{n-1}\right)\}$$ prepared from the vocabulary $V(string,m)$. The second step consists of the preparation of quantum state $\left|string,p\right.〉$ composed of $V_p$ $$\left|string,p\right.〉=\frac{1}{\sqrt{n}}\sum _{k=0}^{n-1}\left|k\right.〉\otimes \left|v\left(w_k\right)\right.〉\otimes \left|1\right.〉.$$ The second part of the algorithm is to read the input word w and find k such that $w=w_k$: The algorithm reads the input word w and prepares $v\left(w\right)=bin\left(r{\left(w\right)}_p\right)$. The quantum stage of the algorithm $\mathcal{A}$: quantum procedure $\mathcal{A}1$ is applied with the input $\left|string,p\right.〉$ and word $v\left(w\right)$. $\mathcal{A}1$ implements the mapping $$\mathcal{A}1:(\left|string,p\right.〉,v\left(w\right))⟼k.$$ to the state $\left|string,p\right.〉$ and the search word $v\left(w\right)$. The number k is the result of measuring the first $logn$ qubits. The number k is declared as the required number of the word $w_k$ such that $w=w_k$.

3.3. Characteristics of the Algorithm $\mathcal{A}$

The following theorem describes the characteristics of the main part of the $\mathcal{A}$ algorithm (searching for the w).

Theorem 1. 

For a vocabulary $V=V(string,m)=\{w_0,\dots ,w_{n-1}\}$ of words of length m, for a word w of length m, algorithm $\mathcal{A}$ solves the problem of finding index k such that $w=w_k$ with the following characteristics.

For an arbitrary integer $c\ge 3$, for an integer $d=cnm$, it is true that

$$\begin{array}{cc}\hfill S^{\mathcal{A}}(n,m)& =O(logn+logm),\hfill \\ \hfill Q^{\mathcal{A}}(n,m)& =O\left(\sqrt{n}\right),\hfill \\ \hfill E{r}^{\mathcal{A}}(V,w)& \le \frac{1}{c}+\frac{1}{n}.\hfill \end{array}$$

The proof of Theorem 1 is given in the next section.

4. Proof of Theorem 1

4.1. Space Complexity $S^{\mathcal{A}}(n,m)$

We start with the technical lemma we need below.

Lemma 1. 

For arbitrary $p\in P_d$, for $d=cnm$, for vocabulary

$$V_p=\{v\left(w_0\right),\dots ,v\left(w_{n-1}\right)\},$$

generated from vocabulary V and for a word $v\left(w\right)$ formed from the word w of length m, it is true that

$$\left|v\left(w\right)\right|=O(logn+logm),|v\left(w_k\right)|=O(logn+logm).$$

Proof. 

Due to the theorem condition, we select the set $P_d$ of the first d primes, where $d=cnm$. Due to Chebyshev’s theorem, there exist constants $0<a<A$ such that for all $d=1,2,\dots$, the d-th prime number $p_d$ satisfies the inequalities

$$adlnd<p_d<Adlnd.$$

The values of the constants defined by Chebyshev (see for example [12]) are

$$a=0.92129,A=1.10555$$

That is, for arbitrary $p\in P_d$ and $r\le p$, it is true that

$$bin\left(r\right)\le log(Adlnd)=O(logn+logm).$$

   □

To estimate the space complexity characteristic $S^{\mathcal{A}}(n,m)$, consider the quantum state $\left|string,p\right.〉$ formed on the basis of $V_p$

$$\left|string,p\right.〉=\frac{1}{\sqrt{n}}\sum _{k=0}^{n-1}\left|k\right.〉\otimes \left|v\left(w_k\right)\right.〉\otimes \left|1\right.〉.$$

First, $logn$ qubits are needed to encode $\left|k\right.〉$ basis states. Second, according to the Lemma 1, $O(logn+logm)$ qubits are needed to encode $\left|v\left(w_k\right)\right.〉$ basis states. Thus, we have $S^{\mathcal{A}}(n,m)=O(logn+logm)$.

4.2. The Query Complexity $Q^{\mathcal{A}}(n,m)$

The query complexity $Q^{\mathcal{A}}(n,m)$ of algorithm $\mathcal{A}$ is completely determined by the query complexity $Q^{\mathcal{A}1}(n,m)$ of the auxiliary procedure $\mathcal{A}1$ when $\mathcal{A}1$ takes as input the quantum state $\left|string,p\right.〉$. Recall that $\left|string,p\right.〉$ represents (quantumly) the vocabulary $V_p$ for $p\in P_d$, with d satisfying the condition of the theorem.

Property 1. 

Let $p\in P_d$ with $d=cnm$. Let $\left|string,p\right.〉$ be the quantum state generated by $V_p$, where $V_p$ itself is formed by the vocabulary $V(string,m)$. Let a word $v\left(w\right)$ be formed from w. Then, for the $\mathcal{A}1(\left|string,p\right.〉,v\left(w\right))$, the following is true

$$\begin{array}{cc}\hfill Q^{\mathcal{A}1}(n,m)& =O\left(\sqrt{n}\right)\hfill \end{array}$$

(5)

Proof. 

Let us consider the amplitude amplification procedure when the procedure $\mathcal{A}1$ is applied to the initial state $\left|string,p\right.〉$. Let us put $\left|strin{g}_0\right.〉=\left|string,p\right.〉$. Let us denote the following numbers by ${\alpha }_0$ and ${\beta }_0$: ${\alpha }_0$ is the initial amplitude for the required basic state $\left|k\right.〉\left|v\left(w_k\right)\right.〉\left|1\right.〉$ such that $v\left(w_k\right)=v\left(w\right)$, and ${\beta }_0$ are the amplitudes of all other basic states of the initial state $\left|strin{g}_0\right.〉$:

${\alpha }_0=1/\sqrt{n}={\beta }_0=1/\sqrt{n}$ and ${\alpha }_0^2+(n-1){\beta }_0^2=1$.

By virtue of the introduced notation, the state $\left|strin{g}_0\right.〉$ can be represented in the following form:

$$\left|strin{g}_0\right.〉={\alpha }_0\sum _{k:v\left(w_k\right)=v\left(w\right)}\left|k\right.〉\otimes \left|v\left(w_k\right)\right.〉\otimes \left|1\right.〉+{\beta }_0\sum _{k:v\left(w_k\right)\ne v\left(w\right)}\left|k\right.〉\otimes \left|v\left(w_k\right)\right.〉\otimes \left|1\right.〉.$$

After applying successively j times two macrosteps to the initial state $\left|strin{g}_0\right.〉$, we have the following:

(1) The operation of changing the phase of the state representing information about $w_k$, for which $v\left(w_k\right)=v\left(w\right)$ is performed;

(2) The inversion operations (called in the literature Grover’s iteration), the amplitudes of the $(j+1)$-th state of the $\left|strin{g}_{j+1}\right.〉$, will be expressed by formulas (see, for example, ref. [13] for a detailed technical justification for the effects of operators (1), and (2) on $\left|strin{g}_j\right.〉$ states):

$${\alpha }_{j+1}=\frac{n-2}{n}{\alpha }_j+\frac{2(n-1)}{n}{\beta }_j{\beta }_{j+1}=\frac{n-2}{n}{\beta }_j-\frac{2}{n}{\alpha }_j.$$

We have:

$$\left|strin{g}_{j+1}\right.〉={\alpha }_{j+1}\sum _{k:v\left(w_k\right)=v\left(w\right)}\left|k\right.〉\otimes \left|v\left(w_k\right)\right.〉\otimes \left|1\right.〉+{\beta }_{j+1}\sum _{k:v\left(w_k\right)\ne v\left(w\right)}\left|k\right.〉\otimes \left|v\left(w_k\right)\right.〉\otimes \left|1\right.〉,$$

where (recall that we are considering the case when k for which $v\left(w_k\right)=v\left(w\right)$ is the only number):

$${\alpha }_{j+1}^2+(n-1){\beta }_{j+1}^2=1$$

Therefore, $\alpha$ and $\beta$ can be given as

$${\alpha }_j=sin\left(\right(2j+1\left)\theta \right),{\beta }_j=\frac{1}{\sqrt{n-1}}cos\left(\right(2j+1\left)\theta \right)$$

Further, ${\alpha }_r=1$ if $(2r+1)\theta =\pi /2$. Based on these considerations, the optimal number r of iterations of the search algorithm $r=(\pi -2\theta )/4\theta$ is determined.

Ref. [13] shows that the probability of obtaining an incorrect result does not exceed $1/n$ if you run $[\pi /\left(4\theta \right)]$ of Grover’s iterations in succession. If n is a sufficiently large number, then $\theta \approx sin\theta =1/\sqrt{n}$, then

$$r=\frac{\pi }{4}\sqrt{n}.$$

Since one call to the oracle in the algorithm is testing an entire substring, the final value is $Q^{\mathcal{A}1}(n,m)=O\left(\sqrt{n}\right)$.    □

4.3. The Error $E{r}^{\mathcal{A}}(V,w)$

The proof of the upper bound for the error probability $E{r}^{\mathcal{A}}(V,w)$ is based on the following considerations. For V and the desired word w, we split the set $P_d$ of primes into good $P_{good}$ and bad $P_{bad}$.

A prime number $p\in P$ will be considered good for the V and w if $r{\left(w\right)}_p\ne r{\left(w_j\right)}_p$ for all $w_j\in V$ such that $w\ne w_j$. That is, the vocabulary $V_p$ with $p\in P_{good}$ (the “good” vocabulary $V_p$) represents the vocabulary V “correctly”, and the vocabulary $V_p$ with $p\in P_{bad}$ (the “bad” vocabulary $V_p$) represents vocabulary V “wrongly”.

Then, the error probability $E{r}^{\mathcal{A}}(V,w)$ of the algorithm $\mathcal{A}$ can be estimated from above as follows:

$$\begin{array}{ccc}\hfill E{r}^{\mathcal{A}}(V,w)& \le & P{r}_{bad}+(1-P{r}_{bad})E{r}^{\mathcal{A}1}\hfill \\ & \le & P{r}_{bad}+E{r}^{\mathcal{A}1},\hfill \end{array}$$

(6)

where $P{r}_{bad}$ is the probability of choosing $p\in P_{bad}$, and $E{r}^{\mathcal{A}1}$ is the error of $\mathcal{A}1$ when “good” dictionary $V_p$ is chosen for procedure $\mathcal{A}1$.

Note that, if a bad p occurs, it is possible to obtain the correct result when applying the $\mathcal{A}1$ procedure. However, considering all continuations of the procedure $\mathcal{A}1$ as erroneous for bad p, we only increase the error probability.

In the remainder of the proof, we estimate the $P{r}_{bad}$ and $E{r}^{\mathcal{A}1}$ components of the sum (6).

Property 2. 

For $d=cnm$, the following is true

$$P{r}_{bad}\le \frac{1}{c}.$$

Proof. 

Observe that p is selected uniformly at random from $P_d$. So, $P{r}_{bad}=|P_{bad}|/|P_d|$. To estimate the $|P_{bad}|$, consider the following. For a pair of distinct numbers $a_1,a_2\in \{0,\cdots 2^m-1\}$, we denote by $P_{a_1,a_2}$, the set of primes $p\in P_d$ such that $a_1\equiv a_2(modp)$. For the vocabulary V and the desired sequence w, we have that

$$P_{bad}=\bigcup _{v\in V}{P}_{a\left(w\right),a\left(v\right)},$$

(7)

Note that for an arbitrary pair of distinct numbers $a_1,a_2\in \{0,\dots ,2^m-1\}$, the following is true

$$|P_{a_1,a_2}|\le m.$$

(8)

The idea of proving the inequality (8) is as follows. The number $a=|a_1-a_2|$ does not exceed $2^m$. Therefore, fewer than m different primes can divide a. For details of the proof (8), see Lemma 7.4 [14].

Finally, combining (7) and (8), we have that

$$P{r}_{bad}\le \frac{nm}{cnm}=\frac{1}{c}.$$

   □

Now let us estimate the second term of the sum (6). We estimate the $E{r}^{\mathcal{A}1}$ in the condition when we apply the procedure $\mathcal{A}1$ for the state $\left|string,p\right.〉$. The state $\left|string,p\right.〉$ represents (quantumly) the vocabulary

$$V_p=\{v\left(w_0\right),\dots ,v\left(w_{n-1}\right)\},$$

for $p\in P_{good}$. That is, we are in the case where $V_p$ represents the vocabulary V “correctly”. This situation satisfies the condition of Grover’s search algorithm. So, immediately we have that

$$\begin{array}{cc}\hfill E{r}^{\mathcal{A}1}& \le \frac{1}{n}.\hfill \end{array}$$

(9)

Now, finally, the probability $E{r}^{\mathcal{A}}(string,w)$ is estimated based on (6) and Property 2 and (9) as follows:

$$\begin{array}{cc}\hfill E{r}^{\mathcal{A}}(string,w)& \le \frac{nm}{cnm}+\frac{1}{n}=\frac{1}{c}+\frac{1}{n}.\hfill \end{array}$$

Thus, we have that there are a few “bad variants” of processing the pair $string$ and w by the $\mathcal{A}$ algorithm — their share does not exceed $1/c$ of the total number of possible processings. In the “good case” of processing the pair $string$ and w, the probability of erroneous processing is bounded from above by the error probability of the procedure $\mathcal{A}1$, which is bounded by $1/n$.

5. Generalization

In this section, we present the $\mathcal{A}2$ algorithm, which is a generalization of the $\mathcal{A}$ algorithm in terms of a universal family of hash functions.

The concept of universal hashing is defined in [15] and has been discussed in sufficient detail in a number of papers, see, for example, [16,17]. The family $\mathcal{F}=\{f_1,\cdots ,f_d\}$ of ($m,l$)-functions $f:{\{0,1\}}^m\to {\{0,1\}}^l$ for $l<m$ is called a universal family of hash functions if for some $ϵ\in [0,1]$ and for an arbitrary pair $v,w\in {\{0,1\}}^m$

$$\frac{|F_{v,w}|}{\left|\mathcal{F}\right|}\le ϵ,$$

where $F_{w,v}=\{f\in \mathcal{F}:f\left(v\right)=f\left(w\right)\}$.

For our purposes, we extend the definition of the universal family of hash functions as follows.

Definition 1. 

A family $\mathcal{F}=\{f_1,\cdots ,f_d\}$ of ($m,l$)-functions

$$f:{\{0,1\}}^m\to {\{0,1\}}^l$$

for $n\ge 1$ and $ϵ\in [0,1]$ will be called a strongly $(n,ϵ)$-universal family of hash ($m,l$)-functions if for each n-subset $Set=\{v_1,\cdots ,v_n\}$ of the set ${\{0,1\}}^m$ and an arbitrary word $w\in {\{0,1\}}^m$,

$$\frac{|F_{Set,w}|}{\left|\mathcal{F}\right|}\le ϵ,$$

where $F_{Set,w}={\bigcup }_{v\in Set}{F}_{v,w}$.

Note that a strongly $(1,ϵ)$-universal family of hash functions is an $ϵ$-universal family of hash functions in the standard sense.

• Example of a strongly $(\mathit{n},\mathit{ϵ})$-universal family of hash functions

An example of a strongly $(n,ϵ)$-universal family of ($m,l$)-functions is the set

$$\mathcal{F}=\{f_1,\cdots ,f_d\}$$

of following functions. For $j\in \{1,\cdots ,d\}$, ($m,l$)-function $f_j:{\{0,1\}}^m\to {\{0,1\}}^l$ is determined by the j-th prime number $p_j$ as follows:

$$f_j\left(w\right)=bin\left(r{\left(w\right)}_{p_j}\right).$$

Here, $r{\left(w\right)}_{p_j}$ is the remainder r when $a\left(w\right)$ is divided by a prime $p_j$, and $bin\left(r{\left(w\right)}_{p_j}\right)$ is the binary presentation of the number $r{\left(w\right)}_{p_j}$. Clearly, we have that $l\le log{p}_d$.

The family $\mathcal{F}$ satisfies the following property.

Property 3. 

For $c\ge 3$ and $d=cnm$, the set $\mathcal{F}=\{f_1,\cdots ,f_d\}$ of ($m,O(log(nm\left)\right)$)-functions forms a family that is a strongly $(n,1/c)$-universal family of hash ($m,O(log(nm\left)\right)$)-functions.

Proof. 

For the proof, see the Property 2 above.    □

We now present the $\mathcal{A}2$ algorithm (Algorithm 3)—generalization of the $\mathcal{A}$ algorithm—in terms of a strongly $(n,ϵ)$-universal family of hash functions.

• Algorithm $\mathcal{A}\mathbf{2}$

The algorithm consists of two sequentially working parts:

• First part: preparing the initial state based on the dictionary $V(string,m)$.
• Second part: reading the search word w and searching for its occurrence in the dictionary.

We emphasize that the algorithm $\mathcal{A}$ has two different input sets: $V(string,m)$ and w. These sets are fed to the first and second parts of the algorithm $\mathcal{A}$, respectively.

Algorithm 3 Algorithm $\mathcal{A}2$

Input: For the first part: Vocabulary $V(string,m)=\{w_0,\cdots ,w_{n-1}\}$ composed of binary words of length m from the $string$. For the second part: Binary word w of length m. Output: The index k, which is interpreted as an index such that $w=w_k$. The first part of the algorithm (preparing the initial state): The first stage of the algorithm—classical: The function f is chosen equiprobably from the set $\mathcal{F}$. Second stage (preparation of the quantum state): For the function $f\in \mathcal{F}$ and vocabulary $V(string,m)$, the algorithm forms vocabulary $$V_f=\{f\left(w_0\right)\dots ,f\left(w_{n-1}\right)\}.$$ Then, based on $V_f$, the following quantum state is generated: $$\left|string,f\right.〉=\frac{1}{\sqrt{n}}\sum _{k=0}^{n-1}\left|k\right.〉\otimes \left|f\left(w_k\right)\right.〉\otimes \left|1\right.〉.$$ The second part of the algorithm (searching for the $\mathit{w}$): The third stage (quantum) of the algorithm $\mathcal{A}2$: quantum procedure $\mathcal{A}1$ is applied with the input $\left|string,f\right.〉$ and word $f\left(w\right)$. $\mathcal{A}1$ implements the mapping $$\mathcal{A}1:(\left|string,f\right.〉,f\left(w\right))⟼k.$$ to the state $\left|string,f\right.〉$ and the search word $f\left(w\right)$. The number k is the result of measuring the first $logn$ qubits. The number k is declared as the required number of the word $w_k$ such that $w=w_k$.

Now, we have the following statement—a generalization of Theorem 1 for the $\mathcal{A}2$ algorithm based on $\mathcal{F}=\{f_1,\dots ,f_d\}$ strongly $(n,ϵ)$-universal family of ($m,l$)-functions.

Theorem 2. 

For a vocabulary $V=V(string,m)=\{w_0,\dots ,w_{n-1}\}$ of n words of length m, for a word w of length m algorithm, $\mathcal{A}2$ solves the problem of finding an index k such that $w=w_k$, with the following characteristics

$$\begin{array}{cc}\hfill S^{\mathcal{A}2}(n,m)& =O(logn+l),\hfill \\ \hfill Q^{\mathcal{A}2}(n,m)& =O\left(\sqrt{n}\right),\hfill \\ \hfill E{r}^{\mathcal{A}2}(string,w))& \le ϵ+\frac{1}{n}.\hfill \end{array}$$

Proof. 

The proof of Theorem 2 repeats, word for word, the proof of Theorem 1 with only one amendment: it is based on the general family of $\mathcal{F}$ strongly $(n,ϵ)$-universal ($m,l$)-functions instead of hash functions of a specific family from Property 3. □

• Comment

Note that such generalization (algorithm $\mathcal{A}2$) works effectively when the length l of hashes is small. As the algorithm $\mathcal{A}$ shows, such algorithms exist—for the algorithm $\mathcal{A}$, the parameter $l=O(log(nm\left)\right)$, see Property 3. This provides an upper bound

$$S^{\mathcal{A}}=O(logn+logm).$$

6. Conclusions

The paper presents a hybrid classical–quantum algorithm $\mathcal{A}$ and its generalization—the quantum algorithm $\mathcal{A}2$ for finding the occurrence of the word w in the text $string$. The problem naturally reduces to searching for a word in the vocabulary $V\left(string\right)$ formed from $string$.

The quantum part of algorithms $\mathcal{A}$ and $\mathcal{A}2$ is presented by the auxiliary quantum procedure $\mathcal{A}1$. The quantum procedure $\mathcal{A}1$ is essentially Grover’s quantum search algorithm. Here, we use the original conditions for applying Grover’s algorithm, namely, we consider that in the text $string$, there is (necessarily) a unique occurrence of the word w. It must be said that the calculation of query complexity depends on the direct implementation of the algorithm. In this work, we consider the oracle as an appeal to the whole substring, not to its individual bits.

The main declared result in saving the number of qubits used is achieved in the $\mathcal{A}$ and $\mathcal{A}2$ algorithms. The $\mathcal{A}$ and $\mathcal{A}2$ algorithms use hash family techniques to save quantum space. The $\mathcal{A}$ algorithm is based on a specific family of hash functions. This specific family of hash functions is known as Freivald fingerprints (see, for example, the book [14], chapter 7 for more information). The $\mathcal{A}2$ algorithm is the generalization of the $\mathcal{A}$ for an arbitrary strongly $(n,ϵ)$-universal family of hash functions.

It is important to note that in this paper, as well as in the cited paper [9], the algorithms are applied to the quantum state (initial state), which is prepared in advance based on the analyzed text $string$ (on the vocabulary $V\left(string\right)$ that is formed from the $string$). The preparation of the initial state requires preliminary work, but this work is not taken into account in the algorithms. Note that the problem of preparing the initial state, as a special problem, is beginning to be discussed in the community dealing with quantum information search. In particular, the authors of [18] drew attention to the problem of the complexity of preparing the initial state.

Finally, once again, we note that in this paper, we considered the case when it is known in advance that the desired substring occurs in the text exactly once. The problem can be expanded if the number of occurrences is greater than one and is known in advance, and also if the number of occurrences of the substring is not known in advance. An estimate of the time and space complexity of Grover’s search algorithm in these cases is described in [13].