Quantum Algorithm for Lexicographically Minimal String Rotation

Lexicographically Minimal String Rotation (LMSR) is the problem of finding the lexicographically smallest string among all possible cyclic rotations of a given input string [Boo80]. It has been widely used in equality checking of graphs [CB80], polygons [IS89, Mae91], automata [Pup10] (and their minimizations [AZ08]) and chemical structures [Shi79], and in generating de Bruijn sequences [SWW16, DHS⁺18] (see also [GY03, vLWW01]). Booth [Boo80] first proposed an algorithm in linear time for LMSR based on the Knuth-Morris-Pratt string-matching algorithm [KMP77]. Shiloach [Shi81] later improved Booth’s algorithm in terms of performance. A more efficient algorithm was developed by Duval [Duv83] from a different point of view known as Lyndon Factorization. All these algorithms for LMSR are deterministic and have worst-case time complexity $\Theta(n)$. After that, several parallel algorithms for LMSR were developed. Apostolico, Iliopoulos and Paige [AIP87] found an $O(\log n)$ time CRCW PRAM (Concurrent Read Concurrent Write Parallel Random-Access Machine) algorithm for LMSR using $O(n)$ processors, which was then improved by Iliopoulos and Smyth [IS92] to use only $O(n/\log n)$ processors.

The LMSR of a string $s$ can also be computed by finding the lexicographically minimal suffix of $ss\$$, i.e. the concatenation of two occurrences of $s$ and an end-marker $\$$, where $\$$ is considered as a character lexicographically larger than every character in $s$. The minimal suffix of a string can be found in linear time with the help of data structures known as suffix trees [Wei73, AHU74, McC76] and suffix arrays [MM90, GBYS92, KSB06], and alternatively by some specific algorithms [Duv83, Cro92, Ryt03] based on Duval’s algorithm [Duv83] or the KMP algorithm [KMP77].

Although a large number of new quantum algorithms have been found for various problems (e.g., [Sho94, Gro96, BŠ06, Amb07, MSS07, HHL09, BS17]), only a few of them solve string problems.

Pattern matching is a fundamental problem in stringology, where we are tasked with determining whether a pattern $P$ of length $m$ occurs in a text $T$ of length $n$. In classical computing, it is considered to be closely related to LMSR. The Knuth-Morris-Pratt algorithm [KMP77] used in Booth’s algorithm [Boo80] for LMSR mentioned above is one of the first few algorithms for pattern matching, with time complexity $\Theta(n+m)$. Recently, several quantum algorithms have been developed for pattern matching; for example, Ramesh and Vinay [RV03] developed an $O\left(\sqrt{n}\log(n/m)\log m+\sqrt{m}\log^{2}m\right)$ quantum pattern matching algorithm based on a useful technique for parallel pattern matching, namely deterministic sampling [Vis90], and Montanaro [Mon17] proposed an average-case $O\left((n/m)^{d}2^{O\left(d^{3/2}\sqrt{\log m}\right)}\right)$ quantum algorithm for $d$-dimensional pattern matching. However, it seems that these quantum algorithms for pattern matching cannot be directly generalized to solve LMSR.

Additionally, quantum algorithms for reconstructing unknown strings with nonstandard queries have been proposed; for example, substring queries [CILG⁺12] and wildcard queries [AM14]. Recently, a quantum algorithm that approximates the edit distance within a constant factor was developed in [BEG⁺18]. Soon after, Le Gall and Seddighin [LGS22] studied quantum algorithms for several other string problems: longest common substring, longest palindrome substring, and Ulam distance.

A naive quantum algorithm for LMSR (see Definition 2.1 for its formal definition) is to find the LMSR of the string within $O(\sqrt{n})$ comparisons of rotations by quantum minimum finding [DH96, AK99] among all rotations. However, each comparison of two rotations in the lexicographical order costs $O(\sqrt{n})$ and is bounded-error. Combining the both, an $\tilde{O}(n)$ quantum algorithm for LMSR is obtained, which has no advantages compared to classical algorithms.

In this paper, however, we find a more efficient quantum algorithm for LMSR. Formally, we have:

In the top-level design of this algorithm, we are required to find the minimal value of a function, which is given by a bounded-error quantum oracle. To resolve this issue, we develop an efficient error reduction for nested quantum algorithms (see Section 1.4.1 for an outline). With this framework of nested quantum algorithms, we are able to solve problems in nested structures efficiently. The high level illustrations of the algorithm for the worst and average cases are given in Section 1.4.2 and Section 1.4.3, respectively. A detailed description of the algorithm is presented in Section 5.

We assume access to a quantum-read/classical-write random access memory (QRAM) and define time complexity as the number of elementary two-qubit quantum gates, input queries and QRAM operations (see Section 2.2.2 for more details). Our quantum algorithm uses only $O(\log^{2}n)$ classical bits in QRAM and $O(\log n)$ “actual” qubits in the quantum computation. Thus, the time complexity of our quantum algorithms in this paper is just an $O\lparen\log n\rparen$ factor bigger than their query complexity (in both worst and average cases).

In order to show a separation between classical and quantum algorithms for LMSR, we settle the classical and quantum lower bounds for LMSR in both the worst and average cases. Let $R(\operatorname{LMSR})$ and $R^{\mathit{unif}}(\operatorname{LMSR})$ be the worst-case and average-case (classical) randomized query complexities for LMSR, and let $Q(\operatorname{LMSR})$ and $Q^{\mathit{unif}}(\operatorname{LMSR})$ be their quantum counterparts. Then we have:

Theorem 1.2 is proved in Section 6. Our main proof technique is to reduce a total Boolean function to LMSR and to find a lower bound of that Boolean function based on the notion of block sensitivity. The key observation is that the block sensitivity of that Boolean function is related to the string sensitivity of input (Lemma 6.3, and see Section 1.4.3 for more discussions).

The results of Theorems 1.1 and 1.2 can be summarized as Table 1.

Note that

Therefore, our quantum algorithm is asymptotically optimal in the average case up to a logarithmic factor. Moreover, a quantum separation from (classical) randomized computation in both the worst-case and average-case query complexities is achieved:

1. 1.

   Worst case: $Q(\operatorname{LMSR})=O\left(n^{3/4}\right)$ but $R(\operatorname{LMSR})=\Omega(n)$; and

2. 2.

   Average case: $Q^{\mathit{unif}}(\operatorname{LMSR})=O\left(\sqrt{n}\log n\right)$ but $R^{\mathit{unif}}(\operatorname{LMSR})=\Omega(n/\log n)$.

In other words, our quantum algorithm is faster than any classical randomized algorithms both in the worst case and the average case.

As an application, we show that our algorithm can be used in identifying benzenoids [Baš16] and minimizing disjoint-cycle automata [AZ08] (see Section 7). The quantum speedups for these problems are illustrated in Table 2.

Our results presented in the above subsection are achieved by introducing the following three new ideas:

We recall some basic definitions about strings and quantum query algorithms, and formally define the LMSR problem in Section 2. An efficient error reduction for nested quantum algorithms is developed in Section 3. An improved quantum algorithm for pattern matching based on the new error reduction technique (given in Section 3) is proposed in Section 4. The quantum algorithm for LMSR is proposed in Section 5. The classical and quantum lower bounds for LMSR are given in Section 6. The applications are discussed in Section 7.

For any positive number $n$, let $[n]=\{0,1,2,\dots,n-1\}$. Let $\Sigma$ be a finite alphabet with a total order $<$. A string $s\in\Sigma^{n}$ of length $n$ is a function $s:[n]\to\Sigma$. The empty string is denoted $\epsilon$. We use $s[i]$ to denote the $i$-th character of $s$. In case of $i\notin\mathbb{Z}\setminus[n]$, we define $s[i]\equiv s[i\bmod n]$. If $l\leq r$, $s[l\dots r]=s[l]s[l+1]\dots s[r]$ stands for the substring consisting of the $l$-th to the $r$-th character of $s$, and if $l>r$, we define $s[l\dots r]=\epsilon$. A prefix of $s$ is a string of the form $s[0\dots i]$ for $i\in[n]\cup\{-1\}$. The period of a string $s\in\Sigma^{n}$ is the minimal positive integer $d$ such that $s[i]=s[i+d]$ for every $0\leq i<n-d$. String $s$ is called periodic if its period $\leq n/2$, and $s$ is aperiodic if it is not periodic.

Let $s\in\Sigma^{n}$ and $t\in\Sigma^{m}$. The concatenation of $s$ and $t$ is string $st=s[0]s[1]\dots s[n-1]t[0]t[1]\dots t[m-1]$. We write $s=t$ if $n=m$ and $s[i]=t[i]$ for every $i\in[n]$. We say that $s$ is smaller than $t$ in the lexicographical order, denoted $s<t$, if either $s$ is a prefix of $t$ but $s\neq t$, or there exists an index $0\leq k<\min\{n,m\}$ such that $s[i]=t[i]$ for $i\in[k]$ and $s[k]<t[k]$. For convenience, we write $s\leq t$ if $s<t$ or $s=t$.

The LMSR problem has been well-studied in the literature [CB80, Boo80, Shi81, Duv83, Jeu93, CR94, CHL07], and several linear time (classical) algorithms for LMSR are known, namely Booth’s, Shiloach’s and Duval’s Algorithms:

Our computational model is the quantum query model [Amb04, BdW02]. The goal is to compute an $n$-variable function $f(x)=f(x_{0},x_{1},\dots,x_{n-1})$, where $x_{0},x_{1},\dots,x_{n-1}$ are input variables. For example, the LMSR problem can be viewed as function $f(x)=\operatorname{LMSR}(x_{0},x_{1},\dots x_{n-1})$, where $x_{0}x_{1}x_{2}\dots x_{n-1}$ denotes the string of element $x_{0},x_{1},\dots,x_{n-1}$. The input variables $x_{i}$ can be accessed by queries to a quantum oracle $O_{x}$ (which is a quantum unitary operator) defined by $O_{x}\lvert i,j\rangle=\lvert i,j\oplus x_{i}\rangle$, where $\oplus$ is the bitwise exclusive-OR operation. A quantum algorithm $A$ with $T$ queries is described by a sequence of quantum unitary operators

The intermediate operators $U_{0},U_{1},\dots,U_{T}$ can be arbitrary quantum unitary operators that are determined independent of $O_{x}$. The computation is performed in a Hilbert space $\mathcal{H}=\mathcal{H}_{o}\otimes\mathcal{H}_{w}$, where $\mathcal{H}_{o}$ is the output space and $\mathcal{H}_{w}$ is the work space. The computation starts from basis state $\lvert 0\rangle_{o}\lvert 0\rangle_{w}$, and then we apply $U_{0},O_{x},U_{1},O_{x},\dots,O_{x},U_{T}$ on it in that order. The result state is

Measuring the output space, the outcome is then defined as the output $A(x)$ of algorithm $A$ on input $x$. More precisely, $\Pr[A(x)=y]=\lVert M_{y}\lvert\psi\rangle\rVert^{2}$, where $M_{y}=\lvert y\rangle_{o}\langle y\rvert$. Furthermore, $A$ is said to be a bounded-error quantum algorithm that computes $f$, if $\Pr[A(x)=f(x)]\geq 2/3$ for every $x$.

To deal with average-case complexity, following the setting used in [AdW99], we assume that after each $U_{j}$, a dedicated flag-qubit will be measured on the computational basis (and this measurement may change the quantum state). The measurement outcome indicates whether the algorithm is ready to halt and return its output. If the outcome is $1$, then we measure the output space with the outcome as the output, and then stop the algorithm; otherwise, the algorithm continues with the next query $O_{x}$ and $U_{j+1}$. Let $T_{A}(x)$ denote the expected number of queries that $A$ uses on input $x$. Note that $T_{A}(x)$ only depends on the algorithm $A$ and its given input $x$ (which is fixed rather than from some distribution).

Let us start from an $O\left(\sqrt{n}\right)$ quantum algorithm to search on bounded-error inputs [HMdW03]. The search problem is described by a function $f(x_{0},x_{1},\dots,x_{n-1})$ that finds an index $j\in[n]$ (if exists) such that $x_{j}=1$, where $x_{i}\in\{0,1\}$ for all $i\in[n]$. It was first shown by Grover [Gro96] that the search problem can be solved by an $O\left(\sqrt{n}\right)$ quantum algorithm, which was found after the discovery of the $\Omega\lparen\sqrt{n}\rparen$ lower bound [BBBV97] (see also [BBHT98, Zal99]).

We now turn to consider the minimum-finding problem. Given $x_{0},x_{1},\dots,x_{n-1}$, the problem is to find an index $j\in[n]$ such that $x_{j}$ is the minimal element. Let $\text{cmp}(i,j)$ be the comparator to determine whether $x_{i}<x_{j}$:

The comparison oracle $U_{\text{cmp}}$ simulating cmp is defined by

We measure the query complexity by counting the number of queries to this oracle $U_{\text{cmp}}$. A quantum algorithm was proposed by Dürr and Høyer [DH96] and Ahuja and Kapoor [AK99] for finding the minimum:

We also note that a generalized minimum-finding was developed in [vAGGdW17], which only needs to prepare a superposition over the search space (rather than make queries to individual elements of the search space).

In this subsection, we develop a tool needed in our quantum algorithm for LMSR as an application of the above two subsections. It solves the problem of finding the first solution (i.e. leftmost solution, or solution with the minimal index rather than an arbitrary solution) and thus can be seen as a generalization of quantum searching, but the solution is based on quantum minimum finding.

Formally, the query oracle $U_{x}$ of $x_{0},x_{1},\dots,x_{n-1}$ is given. The searching-first problem is to find the minimal index $j\in[n]$ such that $x_{j}=1$ or report that no solution exists. This problem can be solved by minimum-finding with the comparator

which immediately yields an $O(\sqrt{n})$ solution if the query oracle $U_{x}$ is exact.

In the case that the query oracle $U_{x}$ is bounded-error, a bounded-error comparison oracle $U_{\text{cmp}}$ corresponding to cmp can be implemented with a constant number of queries to $U_{x}$. Therefore, the results in Lemma 3.4 and Lemma 3.5 also hold for the searching-first problem. For convenience in the following discussions, we write $\textbf{SearchFirst}(U_{x})$ and $\textbf{SearchFirst}(U_{x},\varepsilon)$ to denote the algorithm for the searching-first problem based on the two algorithm $\textbf{Minimum}(U_{\text{cmp}})$ and $\textbf{Minimum}(U_{\text{cmp}},\varepsilon)$, respectively. Symmetrically, we have $\textbf{SearchLast}(U_{x})$ and $\textbf{SearchLast}(U_{x},\varepsilon)$ for searching the last solution.

Recently, an $O(\sqrt{n})$ quantum algorithm for searching the first was proposed in [KKM⁺20]. Their approach is quite different from our presented above. It is specifically designed for this particular problem, but our approach is based on a more general framework of quantum minimum finding.

We believe that the techniques presented in this section can be applied in solving other problems. For this reason, we present a description of them in a general framework of nested quantum algorithm in Appendix B.

Suppose there are two strings $s,t\in\Sigma^{n}$ of length $n$ over a finite alphabet $\Sigma=[\alpha]$. Let $U_{s}$ and $U_{t}$ be their query oracles, respectively. That is,

In order to compare the two strings in the lexicographical order, we need to find the leftmost index $k\in[n]$ that $s[k]\neq t[k]$. If no such $k$ exists, then $s=t$. To this end, we construct the oracle

using $1$ query to each of $U_{s}$ and $U_{t}$. A straightforward algorithm for lexicographical comparison based on the searching-first problem is described in Algorithm 3.

Deterministic sampling [Vis90] is a useful technique for pattern matching in pattern analysis. In this subsection, we provide a quantum solution to deterministic sampling in the form of a nested quantum algorithm.

For our purpose, we extend the definition of deterministic samples to the periodic case. The following is a generalised definition of deterministic samples.