Noisy Tree Data Structures and Quantum Applications

Abstract

We suggest a new technique for developing noisy tree data structures. We call it a “walking tree”. As applications of the technique we present a noisy Self-Balanced Binary Search Tree (we use a Red–Black tree as an implementation) and a noisy segment tree. The asymptotic complexity of the main operations for the tree data structures does not change compared to the case without noise. We apply the data structures in quantum algorithms for several problems on strings like the string-sorting problem and auto-complete problem. For both problems, we obtain quantum speed-up. Moreover, for the string-sorting problem, we show a quantum lower bound.

1. Introduction

Tree data structures are well-known and used in different algorithms. At the same time, when we construct algorithms with random behavior like randomized and quantum algorithms, we should consider error probability. We suggest a general method for updating a tree data structure in the noisy case. We call it Walking tree. For a tree of height h, we consider an operation for processing all nodes from a root to a target node. Suppose the running time of the operation is $O(h·T)$, where T is running time required to process a node. Then, if navigation by the tree can have an error, our technique allows us to carry it out with $O(log(1/\epsilon )+h·T)$ running time, where $\epsilon$ is the error probability for the whole operation. Note that the standard way to handle probabilistic navigation is the success probability boosting (repetition of the noisy action) with $O(h·log(1/\epsilon )+h·T)$ complexity.

Our technique is based on results for the noisy Binary search algorithm [1]. The authors of that paper present an idea based on the random walk algorithm for a balanced binary tree that can be constructed for the binary search algorithm. We generalize the idea for a tree with any structure that allows us to apply the method to a wide class of tree data structures. Different algorithms for noisy search, especially a noisy tree, and graph processing and search were considered in [2,3,4,5,6,7,8]. We apply our technique to two tree data structures. The first one is the Red–Black tree [9], which is an implementation of a self-balanced binary search tree [9]. If the key comparing procedure has a bounded error, then our noisy self-balanced binary search tree allows us to conduct add, remove, and search operations in $O(log(N/\epsilon \left)\right)$ running time, where $\epsilon$ is the error probability for a whole operation and N is the number of nodes in the tree. In the case of $\epsilon =1/Poly\left(N\right)$, we have $O(logN)$ running time and the noisy key comparing procedure does not affect running time (asymptotically). At the same time, if we use the success probability boosting technique, then the running time is $O\left({(logN)}^2\right)$. The second one is the Segment tree [10,11]. If the indexes comparing procedure has a bounded error, then our noisy segment tree allows us to conduct update and request operations in $O(log(N/\epsilon \left)\right)$ running time, where $\epsilon$ is the error probability for a whole operation and N is the number of leaves. In the case of $\epsilon =1/Poly\left(N\right)$, we have $O(logN)$ running time. So, we obtain a similar advantage. We use these data structures in the context of quantum computation [12] which is one of the hot topics in the last decades. There are many problems where we can obtain a quantum speed-up. Some of them can be found here [13,14], including graph problems [15,16,17,18,19,20,21] and string processing problems  [22,23,24,25,26,27,28]. Quantum algorithms have randomized behavior, so it is important to use noisy data structures for this model. We use the quantum query model [29] as the main computational model for the quantum algorithms. We apply the walking tree method for the following problems.

The first one is the string-sorting problem. We want to sort n strings of a length l in lexicographical order. However, quantum algorithms cannot sort arbitrary comparable objects faster than $\Omega (nlogn)$[30,31]. At the same time, some results improve the hidden constant [32,33]. Other researchers investigated the space-bounded case [34]. The situation with sorting strings is a little bit different. We know that the classical Radix sort algorithm has $O\left(nl\right)$ running time [9] for a finite-size alphabet. That is faster than sorting algorithms for arbitrary comparable objects. Here, the lower bound for classical (randomized or deterministic) algorithms is $\Omega \left(nl\right)$. In the quantum case, faster algorithms with $O(n(logn)·\sqrt{l})=\tilde{O}\left(n\sqrt{l}\right)$ running time are known [35,36]. Here, $\tilde{O}$ does not consider log factors. In this paper, we suggest a simpler implementation based on a noisy red–black tree.

The second one is the Auto-Complete Problem. We have two kinds of queries: adding a string s to the dictionary $\mathcal{S}$ and querying the most frequent completion of a string t from the dictionary. We call s a completion of t if t is a prefix of s. Assume that L is the total sum of all lengths of strings from all queries. We solve the problem using quantum string comparing algorithm [35,36,37,38,39] and noisy Red–Black tree. The running time of the quantum algorithm is $O(\sqrt{nL}logn)$. The lower bound for quantum running time is $\Omega \left(\sqrt{L}\right)$. At the same time, the best classical algorithm based on trie (prefix tree) [40,41,42,43] has $O\left(L\right)$ running time. That is also the classical (deterministic or randomized) lower bound $\Omega \left(L\right)$. So, we obtain quantum speed-up if most of the strings have $\Omega \left({(logn)}^2\right)$ length.

2. Preliminaries

In the paper, we use the following notation.

• $logN$ means ${log}_{2}N$ that is a logarithm with base 2.
• $Poly\left(N\right)$ means a polynomial dependent on N. Formally, $Poly\left(N\right)={\sum }_{i=0}^{\alpha }{a}_i{N}^i$ for some constants $\alpha$ and $a_0,\dots a_{\alpha }$.
• $O\left(f\right(N\left)\right)$ means big-O notation, upper bound. Formally, $g\left(N\right)=O\left(f\right(N\left)\right)$ if ${lim}_{N\to \infty }g\left(N\right)/f\left(N\right)\le \mathcal{C}$ for some $\mathcal{C}=const$.
• $\tilde{O}\left(f\left(N\right)\right)$ means big-O notation with ignoring log factor. Formally, $g\left(N\right)=\tilde{O}\left(f\left(N\right)\right)$ if ${lim}_{N\to \infty }g\left(N\right)/f\left(N\right)\le \mathcal{L}$ for some $\mathcal{L}=Poly(logN)$.
• $\Omega \left(f\right(N\left)\right)$ means big-Omega notation, lower bound. Formally, $g\left(N\right)=\Omega \left(f\right(N\left)\right)$ if ${lim}_{N\to \infty }g\left(N\right)/f\left(N\right)>\mathcal{C}$ for some $\mathcal{C}=const$.

In the paper, for two strings s and t, the notation $s<t$ means s precedes t in the lexicographical order. Let $\left|s\right|$ be the length of a string s.

2.1. Graph Theory

Let us consider a rooted tree G. Let $\mathcal{V}\left(G\right)$ be the set of nodes (vertices), and $\mathcal{E}\left(G\right)$ be the set of edges. Let one fixed node be the root of the tree. Assume, a procedure GetTheRoot(G) returns it. A path P is a sequence of nodes $(v_1,\dots ,v_k)$ that are connected by edges, i.e., $(v_i,v_{i+1})\in E$ for $i\in \{1,\dots ,k-1\}$. Note, that there are no duplicates among $v_1,\dots ,v_k$. Here, k is the length of the path. We use $v\in P$ notation if there is j such that $v_j=v$. The notation is reasonable because there are no duplicates in a path. Because G is a tree, the path between any two nodes u and v is unique. The distance $dist(v,u)$ between two nodes v and u is the length of the path between them. The height of v is the distance between it and the root that is $dist(root,v)$. Let $h\left(G\right)={max}_{v\in \mathcal{V}\left(G\right)}dist(root,v)$ be the tree’s height. For a node v, Parent(v) is a parent node, where $dist(root,$ Parent(v) $\left)\right)+1=dist(root,v)$ and Parent(v)$v)\in \mathcal{E}(G)$; a set of children is Children(v)$=\{u:$ Parent(u) $=v\}$.

2.2. Quantum Query Model

In Section 6 we suggest quantum algorithms as applications for our data structures. We have only one quantum subroutine, and the rest part of the algorithm is classical. One of the most popular computation models for quantum algorithms is the query model. We use the standard form of the quantum query model. Let $f:D\to \{0,1\},D\subseteq {\{0,1\}}^M$ be an M variable function. We wish to compute on an input $x\in D$. We are given oracle access to the input x, i.e., it is implemented by a specific unitary transformation that is usually defined as $|i⟩|z⟩|w⟩\to |i⟩|z+x_i(mod2)⟩|w⟩$ where the $|i⟩$ register indicates the index of the variable we are querying, $|z⟩$ is the output register, and $|w⟩$ is some auxiliary work-space. The operation is implemented by the CNOT gate. An algorithm in the query model consists of alternating applications of arbitrary unitaries independent of the input and the query unitary, and measurement in the end. The smallest number of queries for an algorithm that outputs $f\left(x\right)$ with probability $\ge \frac{2}{3}$ on all x is called the quantum query complexity of the function f, and  $Q\left(f\right)$ notation is used for it. We use the term running time instead of query complexity to remove confusion with “query” in the definition of problems in Section 6. In the paper, we use modifications of Grover’s search algorithm [44,45] as quantum subroutines. For these subroutines, the time complexity is more than the query complexity for additional log factor [46,47]. Note that in the general case, we can consider a function f with non-Boolean arguments. It can be simulated by a Boolean-argument-function case using a binary representation of arguments.

The modification of Grover’s search algorithm [48] in the case of a known number of solutions can be used in our problems. We refer the readers to [12,29] for more details on quantum computing.

3. Main Technique: A Walking Tree

In this section, we present a rooted tree that we call a walking tree. It is a utility data structure for noisy computation for the main data structure. Here we use it for the following data structures: (i) Binary Search Tree. We assume that elements comparing procedures can have errors. (ii) Segment Tree. We assume that the indexes (borders of segments) comparing procedure can have errors.

Note that the walking tree is a general technique, and it can be used for other tree data structures. Let us present the general idea of the tree. The technique is motivated by [1]. Assume that G is a rooted tree. We are interested in moving from the root to a specific (target) node operation. Assume that we have the following procedures:

• GetTheRoot(G) returns the root node of the tree G.
• SelectChild(v) returns the child of the node $v\in \mathcal{V}\left(G\right)$ that should be reached from the node v. We assume that there is only one child that should be reached from a node.
• IsItTheTarget(v) returns $True$ if the node $v\in \mathcal{V}\left(G\right)$ is the last node that should be visited in the operation; and returns $False$ otherwise.
• ProcessANode(V) processes the node $v\in \mathcal{V}\left(G\right)$ in the required way.
• IsANodeCorrect(V) returns $True$ if the node $v\in \mathcal{V}\left(G\right)$ should be visited during the the operation; and returns $False$ if the node is visited because of an error.

Assume that the operation has the following form (Algorithm 1).

Algorithm 1 An operation on the tree G

$v\leftarrow$ GetTheRoot(G) ProcessANode(v) while IsItTheTarget(v) = False do     $v\leftarrow$ SelectChild(v)     ProcessANode(v) end while

Let us consider the operation such that “navigation” procedures (that are SelectChild, IsANodeCorrect, and  IsItTheTarget) can return an answer with an error p, where $p<0.5-\delta$, where $0<\delta \le 0.5$. We assume that error events are independent. We need to isolate p from $0.5$. We cannot be sure that the algorithm works if $p\to 0.5$. That is why we use $p<0.5-\delta$ statement. Our goal is to conduct the operation with an error $\epsilon$. Note that in the general case, $\epsilon$ can be non-constant and depend on the number of tree nodes. Let $h=h\left(G\right)$ be the height of the tree. The standard technique is boosting success probability. On each step, we repeat SelectChild procedure $O(log(h/\epsilon \left)\right)$ times and choose the most frequent answer. In that case, the error probability of the operation is at most $\epsilon$, and the running time of the operation is $O(hlog(h/\epsilon )+h·T)$, where T is complexity of ProcessANode procedure. Our goal is to have $O(h+log(h/\epsilon )+h·T)=O(log(h/\epsilon )+h·T)$ running time.

Let us construct a rooted tree W by G such that the set of nodes of W has a one-to-one correspondence to the nodes of G and the same with sets of edges. We call W a walking tree. Let ${\lambda }_W:\mathcal{V}\left(W\right)\leftrightarrow \mathcal{V}\left(G\right)$ and ${\lambda }_G:\mathcal{V}\left(G\right)\leftrightarrow \mathcal{V}\left(W\right)$ be bijections between these two sets. For simplicity, we define procedures for W similar to the procedures for G. Suppose $u\in \mathcal{V}\left(W\right)$, then GetTheRoot(W) = ${\lambda }_G$(GetTheRoot(G)); SelectChild(u)  = ${\lambda }_G$(SelectChild$\left({\lambda }_W\left(u\right)\right));$ IsItTheTarget(u) = IsItTheTarget$\left({\lambda }_W\left(u\right)\right);$ IsANodeCorrect(u) = $\left({\lambda }_W\left(u\right)\right).$ Note that the navigation procedures are noisy (have an error). We reduce the error probability to $0.1$ by constant number of repetitions (using the boosting success probability technique). Additionally, we associate a counter $c\left(u\right)$ with a node $u\in \mathcal{V}\left(W\right)$ that is a non-negative integer number. Initially, values of counters are 0 for all nodes, i.e., $c\left(u\right)=0$ for each $u\in \mathcal{V}\left(W\right)$.

We invoke a random walk by the walking tree W. The walk starts from the root node GetTheRoot(W). Let us discuss processing $u\in \mathcal{V}\left(W\right)$. Firstly, we check the counter’s value $c\left(u\right)$. If $c\left(u\right)=0$, then we carry out steps from 1.1 to 1.3.

Step 1.1. We check the correctness of current node using IsANodeCorrect(u) procedure. If the result is $True$, then we go to Step 1.2. If the result is $False$, then we are here because of an error, and we go up by changing $u\leftarrow$Parent(u). If the node u is the root, then we stay in u.

Step 1.2. We check whether the current node is target using IsItTheTarget(u) procedure. If it is $True$, then we increase the counter $c\left(u\right)\leftarrow 1$. If it is $False$, then we go to Step 1.3.

Step 1.3. We go to the children $u\leftarrow$SelectChild(u).

If $c\left(u\right)>0$, then we carry out Step 2.1. We can say that the counter $c\left(u\right)$ is a measure of confidence that u is the target node. If $c\left(u\right)=0$, then we should continue walking. If $c\left(u\right)>0$, then we think that u is the target node. If a bigger value of $c\left(u\right)$ means we are more confident that it is the target node.

Step 2.1. If IsItTheTarget(u) = True, then we increase the counter $c\left(u\right)\leftarrow c\left(u\right)+1$. Otherwise, we decrease the counter $c\left(u\right)\leftarrow c\left(u\right)-1$. So, we become more or less confident in the fact that the node u is the target.

The walking process stops in s steps, where $s=O(h+log(1/\epsilon \left)\right)$. The stopping node u is the target one. After that, we carry out the operation with the original tree G. We store path in $Path=(v^1,\dots ,v^k)$, such that $v^k={\lambda }_W\left(u\right)$, $v^i$ = Parent$\left(v^{i+1}\right)$, and $v_1$ is the root node of G. Then, we process them using ProcessANode$\left(v^i\right)$ for i from 1 to k. Let a procedure OneStep(u) be one step of the walking process on the walking tree W. It accepts the current node u and returns the new node. The code representation of the procedure is in Algorithm 2.

Algorithm 2 One step of the walking process, OneStep(u). The input is $u\in \mathcal{V}\left(W\right)$ and the result is the node for the next step of the walking

if $c\left(u\right)=0$ then     if IsANodeCorrect(u) = False then                                         ▹ Step 1.1         if $u\ne$GetTheRoot(W) then            $u\leftarrow$Parent(u)         end if     else         if IsItTheTarget(u) = True then                                          ▹ Step 1.2            $c\left(u\right)\leftarrow 1$         else            $u\leftarrow$SelectChild(u)                                              ▹ Step 1.3         end if     end if else     if IsItTheTarget(u) = True then                                           ▹ Step 2.1         $c\left(u\right)\leftarrow c\left(u\right)+1$     else         $c\left(u\right)\leftarrow c\left(u\right)-1$     end if end if

The whole algorithm is presented in Algorithm 3.

Algorithm 3 The walking algorithm for $s=O(h+log(1/\epsilon \left)\right)$ steps

$u\leftarrow$ GetTheRoot(W) for$j\in \{1,\dots s\}$do     $u\leftarrow$ Onestep(u) end for $v\leftarrow {\lambda }_W\left(u\right)$, $Path=\left(v\right)$, $k=1$ while  $v\ne$ GetTheRoot(G) do     $v\leftarrow$ Parent(v)     $Path=v\circ Path$ ▹ Here ∘ means the concatenation of two sequences. The line adds the node to the beginning of the path sequence     $k\leftarrow k+1$                                        ▹ The length of the path sequence end while for$i\in \{1,\dots k\}$ do     ProcessANode$\left(v^i\right)$ end for

Let us discuss the algorithm and its properties. On each node, we have two options, we go in the direction of the target node or the opposite direction.

Assume that $c\left(u\right)=0$ of the current node u. If we are in a wrong branch, then the only correct direction is the parent node. If we are in the correct branch, then the only correct direction is the correct child node. All other directions are wrong. Assume that $c\left(u\right)>0$. If we are in the target node, then the only correct direction is increasing the counter, and the wrong direction is decreasing the counter. Otherwise, the only correct direction is decreasing the counter.

Choosing the direction is based on the results of at most three invocations of navigation procedures (SelectChild, IsANodeCorrect, and IsItTheTarget). Remember that we reach $0.1$ error probability using a constant number of repetitions. Due to the independence of error events, the total error probability of choosing a direction is at most $0.3$. So, the probability of moving in correct direction is at least $2/3$ and for a wrong direction it is at most $1/3$. Let us show that if $s=O(h+log(1/\epsilon \left)\right)$, then the error probability for an operation on G is $\epsilon$. Note that $\epsilon$ can be non-constant. In Corollarys 1 and 2, we have $\epsilon =1/Poly\left(\right|\mathcal{V}\left(G\right)\left|\right)$.

Theorem 1.

Given error probability $\epsilon \in (0,0.5)$, Algorithm 3 completes the same action as Algorithm 1 with a running time of $O(h+log(1/\epsilon \left)\right)$.

Proof. 

Let us consider the walking tree. We emulate the counter by replacing it with a nodes chain of length $s+1$. Formally, for a node $u\in \mathcal{V}\left(W\right)$ we add $s+1$ nodes $d_1^u,\dots ,d_{s+1}^u$ such that Parent$\left(d_1^u\right)=u$, Parent$\left(d_i^u\right)=d_{i-1}^u$ for $i\in \{2,\dots ,s+1\}$. The only child of $d_i^u$ is $d_{i+1}^u$ for $i\in \{1,\dots ,s\}$, and $d_{s+1}^u$ does not have children.

In that case, the increasing of $c\left(u\right)$ can be emulated by moving from $d_{c\left(u\right)}^u$ to $d_{c\left(u\right)+1}^u$. The decreasing can be emulated by moving from $d_{c\left(u\right)}^u$ to $d_{c\left(u\right)-1}^u$. We can assume that $d_0^u$ is the node u itself.

Let $u_{target}$ be the target node, i.e., IsItTheTarget$\left(u_{target}\right)=True$. Let us consider the distance L between the target node $d_{s+1}^{u_{target}}$ and the current node in the modified tree. The distance L is a random variable. Each step of the walk increases or decreases the distance L by 1. So, we can present $L=dist(root,d_{s+1}^{u_{target}})-Y$, where $root$ is the root node of W, $Y=(Y_1+\dots +Y_s)$, and $Y_i\in \{-1,+1\}$ are independent random variables that represent i-th step and show increasing or decreasing the distance. Let $Y_i=+1$ if we move in the correct direction, and $Y_i=-1$ if we move in the wrong direction. Note that the probability of moving to the correct direction ($Y_i=+1$) is at least $2/3$ and the probability of moving to the wrong direction ($Y_i=-1$) is at most $1/3$. From now on, without loss of generality, we assume that $\mathbf{Pr}[Y_i=+1]=2/3$ and $\mathbf{Pr}[Y_i=-1]=1/3$.

If $L\le s$, then we are in the $d_i^{u_{target}}$ node in the modified tree and in the $u_{target}$ node in the original walking tree W. Note that $dist(root,d_{s+1}^{u_{target}})\le h+s$, where $h=h\left(W\right)$ by the definition of the height of a tree. Therefore, $L\le s$ means $Y=Y_1+\dots +Y_s\ge h$. So, the probability of success of the operation is the probability of the $Y\ge h$ event, i.e., ${\mathbf{Pr}}_{success}=\mathbf{Pr}[Y\ge h]$.

Let $X_i=(Y_i+1)/2$ for $i\in \{1,\dots ,s\}$. We treat $X_1,\dots ,X_s$ as independent binary random variables. Let $X={\sum }_{i=1}^s{X}_i$. For such X and for any $0<\delta \le 1$, the following form of Chernoff bound [49] holds

$$\mathbf{Pr}[X<(1-\delta )\mathbf{E}\left[X\right]]\le exp(-\mathbf{E}\left[X\right]{\delta }^2/2).$$

(1)

Since $\mathbf{Pr}[X_i=1]=\mathbf{Pr}[Y_i=+1]=2/3$, we have $\mathbf{E}\left[X\right]=2s/3$ and the inequality (1) becomes

$$\mathbf{Pr}[X<2s·(1-\delta )/3]\le exp(-{\delta }^{2}s/3).$$

Substituting Y for X we, obtain

$$\mathbf{Pr}[Y<s·(4(1-\delta )/3-1)]\le exp(-{\delta }^{2}s/3).$$

From now on without loss of generality, we assume that $s=\lceil c·(h+log(1/\epsilon \left)\right)\rceil$ for some $c>0$. Let $\delta =\frac{1}{6}$ and $c\ge 108$.

In the following steps, we relax the inequality by obtaining less tight bounds for the target probability.

Firstly, we obtain a new lower bound

$$\begin{array}{cc}\hfill s·\left(4\right(1-\delta )/3-1)& =\lceil c·(h+log(1/\epsilon \left)\right)\rceil /9\ge c·(h+log(1/\epsilon \left)\right)/9\ge \hfill \\ \hfill & \ge c·h/9\ge 108·h/9>h,\hfill \end{array}$$

and hence

$$\mathbf{Pr}[Y<h]\le \mathbf{Pr}[Y<s·(4(1-\delta )/3-1\left)\right]$$

Secondly, we obtain a new upper bound

$$\begin{array}{cc}\hfill exp(-{\delta }^{2}s/3)& =exp(-\lceil c·(h+log(1/\epsilon ))\rceil /108)\le exp(-c/108·(h+log(1/\epsilon ))<\hfill \\ & <exp(-c/108·log\left({\epsilon }^{-1}\right))\le exp(-log\left({\epsilon }^{-1}\right))=\epsilon .\hfill \end{array}$$

Combining the two obtained bounds we have

$$\mathbf{Pr}[Y<h]\le \mathbf{Pr}[Y<(\frac{4}{3}(1-\delta )-1)s]\le exp(-{\delta }^{2}s/3)<\epsilon ,$$

and hence

$$\mathbf{Pr}[Y<h]<\epsilon .$$

Considering the probability of the opposite event we finally obtain

$${\mathbf{Pr}}_{success}=\mathbf{Pr}[Y\ge h]>1-\epsilon .$$

   □

In the next section, we show several applications of the technique.

4. Noisy Tree Data Structures

4.1. Noisy Binary Search Tree

Let us consider a Self-Balanced Search Tree [9]. It is a binary rooted tree G. Let $n=\left|\mathcal{V}\right(G\left)\right|$. We associate a comparable element $\alpha \left(v\right)$ with a node $v\in \mathcal{V}\left(G\right)$. (i) For a node $v\in \mathcal{V}\left(G\right)$, we have $\alpha \left(v^{\prime }\right)<\alpha \left(v\right)$ where $v^{\prime }$ is from the left sub-tree of v; and $\alpha \left(v^{\prime \prime }\right)>\alpha \left(v\right)$ where $v^{\prime \prime }$ is from the right sub-tree of v. (ii) The height of the tree $h\left(G\right)=O(logn)$.

As an implementation of Self-Balanced Search Tree, we use a Red–Black Tree [9,50]. It allows us to add and remove a node with a specific value with $O(logn)$ running time. Assume that the comparing procedure of two elements has an error p. Each operation (remove and add an element) has three steps: searching, carrying out the action (removing or adding), and re-balancing. Re-balancing does not invoke comparing operations, that is why it does not have an error. So, the only “noisy” procedure (which can have an error) is searching. Let us discuss it.

Let us associate $\beta \left(v\right)$ and $\gamma \left(v\right)$ with a node $v\in \mathcal{V}\left(G\right)$. That are left and right bounds for $\alpha \left(v\right)$ with respect to the ancestor nodes. Formally, $\beta \left(v\right)<min\{\alpha \left(v^{\prime }\right):v$ is an ancestor of $v^{\prime }\}$, $\gamma \left(v\right)>max\{\alpha \left(v^{\prime }\right):v$ is an ancestor of $v^{\prime }\}$. We can compute them as follows. If v is the root, then $\beta \left(v\right)=-\infty$, and $\gamma \left(v\right)=+\infty$. Here, $-\infty$ and $+\infty$ are constants that are a priori less and more than any $\alpha \left(v^{\prime }\right)$ for $v^{\prime }\in \mathcal{V}\left(G\right)$. Let v be a non-root node. If v is the left child of Parent(v), then $\beta \left(v\right)=\beta ($Parent(v)), $\gamma \left(v\right)=\alpha ($Parent(v)). If v is the right one, then $\beta \left(v\right)=\alpha ($Parent(v)), $\gamma \left(v\right)=\gamma ($Parent(v)). Assume that a comparing function for elements Compare(a,b) returns $-1$ if $a<b$; $+1$ if $a>b$; 0 if $a=b$. An error probability for the function is $p<0.5-\delta$ for some $0<\delta <0.5$. Let us present each of the required procedures for searching an object x operation. GetTheRoot(G) is for the root node of G. SelectChild(v) returns the left child of v if Compare$\left(\alpha \right(v),x)=-1$; and returns the right child if Compare$\left(\alpha \right(v),x)=+1$. IsItTheTarget(v) returns $True$ if Compare$\left(\alpha \right(v),x)=0$. ProcessANode(v) does nothing. IsANodeCorrect(v) returns $True$ if $\beta \left(v\right)<x<\gamma \left(v\right)$, formally, Compare$\left(\beta \right(v),x)=-1$ and Compare$(x,\gamma (v\left)\right)=-1$. The presented operations satisfy all requirements. Let us present the complexity result that directly follows from Theorem 1.

Theorem 2.

Suppose the comparing function for elements of Red–Black Tree has an error $p<0.5-\delta$ for some $0<\delta <0.5$. Then, using the walking tree, we can carry out searching, adding and removing operations with $O(log(n/\epsilon \left)\right)$ running time and an error probability ε.

Remind that it is important for the proof to isolate p from $0.5$. We cannot be sure that the algorithm works if $p\to 0.5$. If $\epsilon =1/Poly\left(n\right)$, then the “noisy” setting does not affect asymptotic complexity.

Corollary 1.

Suppose the comparing function for elements of the Red–Black Tree has an error $p<0.5-\delta$ for some $0<\delta <0.5$. Then, using the walking tree, we can carry out searching, adding, and removing operations with $O(logn)$ running time and an error probability $1/Poly\left(n\right)$.

4.2. Noisy Segment Tree

We consider a standard segment tree data structure [10,11] for an array $b=(b_1,\dots ,b_n)$ for some integer $n>0$. The segment tree is a full binary tree such that each node corresponds to a segment of the array b. If a node v corresponds to a segment $(b_{left},\dots ,b_{right})$, then we store a value $\alpha \left(v\right)$ that represents some information about the segment. Let us consider a function f such that $\alpha \left(v\right)=f(b_{left},\dots ,b_{right})$. A segment of a node is the union of segments that correspond to its two children. Typically, the children correspond to segments $(b_{left},\dots ,b_{mid})$ and $(b_{mid+1},\dots ,b_{right})$, for $mid=\lfloor (left+right)/2\rfloor$. We consider $\alpha \left(v\right)$ such that it can be computed by values of two children $\alpha \left(v_l\right)$ and $\alpha \left(v_r\right)$, where $v_l$ and $v_r$ are left and right children of v. Leaves correspond to single elements of the array b. As an example, we can consider integer values $b_i$ and sum $\alpha \left(v\right)=b_{left}+\dots +b_{right}$ as the value in a node v and a corresponding segment $(b_{left},\dots ,b_{right})$. The data structure allows us to invoke the following requests in $O(logn)$ running time.

• Update. Parameters are an index i and an element x ($1\le i\le n$). The procedure assigns $b_i\leftarrow x$. For this goal, we assign x for the leaf w that corresponds to the $b_i$ and update ancestors of w.
• Request. Parameters are two indexes i and j ($1\le i\le j\le n$), the procedure computes $f(b_i,\dots ,b_j)$.

The main part of both operations is the following. For the given root node and an index i, we should find the leaf node corresponding to $b_i$. The main step is the following. If we are in a node v with associated segment $(b_{left},\dots ,b_{right})$, then we compare i with a middle element $mid=\lfloor (left+right)/2\rfloor$ and choose the left or the right child. Assume that we have a comparing function for indexes Compare(a,b) that returns $-1$ if $a<b$; $+1$ if $a>b$; 0 if $a=b$. The comparing function returns the answer with an error $p<0.5-\delta$ for some $0<\delta <0.5$.

Let us present each of the required procedures for searching the leaf with index i in a segment tree G. GetTheRoot(G) returns the root node of the segment tree G. For $mid=\lfloor (left+right)/2\rfloor$, and the segment $(b_{left},\dots ,b_{right})$ associated with a node v, the function SelectChild(v) returns the left child of v if Compare $(mid,i)\le 0$; and returns the right child otherwise. IsItTheTarget(v) returns $True$ if $left=i=right$, formally, Compare$(left,i)=0$ and Compare$(right,i)=0$; and returns $False$ otherwise. Here the segment $(b_{left},\dots ,b_{right})$ is associated with v. ProcessANode(v) recomputes $\alpha \left(v\right)=f(b_{left},\dots ,b_{right})$ according to the values of $\alpha$ in the left and the right children. IsANodeCorrect(v) returns $True$ if $left\le i\le right$, formally, Compare$(left,i)\le 0$ and Compare$(x,right)\le 0$; and returns $False$ otherwise. Here, the segment $(b_{left},\dots ,b_{right})$ is associated with v. The presented operations satisfy all requirements. Let us present the complexity result that directly follows from Theorem 1.

Theorem 3.

Suppose, the comparing function for indexes of a segment tree is noisy and has an error $p<0.5-\delta$ for some $0<\delta <0.5$. Then, using the walking tree, we can conduct update and request operations with $O(log(n/\epsilon \left)\right)$ running time and an error probability ε.

If we take $\epsilon =1/Poly\left(n\right)$, then the “noisy” setting does not affect asymptotic complexity.

Corollary 2.

Suppose, the comparing function for indexes of a segment tree is noisy and has an error $p<0.5-\delta$ for some $0<\delta <0.5$. Then, using the walking tree, we can carry out update and request operations with $O(logn)$ running time and an error probability $1/Poly\left(n\right)$

We can apply the same ideas for the segment tree with range updates [11] (examples of applications can be found in [51,52]) or other modifications of the data structure. If we have access to the full segment tree, including leaves, then we can complete operations without the walking tree. We can use the noisy binary search algorithm [1] for searching the leaf that corresponds to the index i and then process all the ancestors of the leaf. At the same time, if we have only access to the root node or compressed case, then a noisy segment tree is more useful.

Theorem 3 and Corollary 2 are the direct application of the main technique and results from Theorem 1 to a specific data structure (segment tree). This is one of two applications that are presented in this paper.

Analysis, Discussion, Modifications for Noisy Segment Tree

There are different additional operations with a segment tree. One such example is the segment tree with range updates. In this modification, we can update the values $b_i$ for a range $i\in \{\ell ,\dots ,r\}$ by a value in one request. The reader can find more information in [11] and examples of applications in [51,52]. The main operation with a noisy comparing procedure is the same. So, we can still use the same idea for such modifications of the segment tree.

Remark 1.

If the segment tree is constructed for an array $b_1,\dots ,b_n$, then we can extend it to $b_1,\dots ,b_n,\dots ,b_k$, where $k=2^{\lceil {log}_{2}n\rceil }$ that is closest to n power of 2 and $b_{n+1},\dots ,b_k$ are neutral element for the function f. If we have a node v and two borders $left$ and $right$ of the segment associated with v, then we always can compute the segments for the left and the right children that are $b_{left},\dots ,b_{mid}$ and $b_{mid+1},\dots ,b_{right}$ for $mid=(left+right)/2$. Additionally, we can compute the segment for the parent that is $b_{left},\dots ,b_{pright}$, where $pright=2·right-left$ if the node is the left child of its parent. If the node is the right child of its parent, then the parent’s segment is $b_{pleft},\dots ,b_{right}$, where $pleft=2·left-right$. Therefore, we should not store the borders of a segment in a node, and we can compute them during the walk on the segment tree. Additionally, we should not construct the walking tree. We can keep it in mind and walk by the segment tree itself using only three variables: the $left$ and $right$ borders of the current segment and a counter if required.

If we have access to the full segment tree, including leaves, then we can conduct operations without the walking tree. We can use the noisy binary search algorithm [1] for searching the leaf that corresponds to the index i, and then process all the ancestors of the leaf. There are at least two useful scenarios for a noisy segment tree.

1. We have access only to the root and have no direct access to leaves.

2. The second one is the compressed segment tree. If initially, all elements of the array b are empty or neutral for the function f, then we can compress a subtree with one node with a label of a segment with empty elements. On each step, we do not store any subtree if it has only neutral elements. In that case, we store only a root of this tree and mark it as a subtree with neutral elements. It is reasonable if n is very big and storing the whole tree is very expensive. In that case, we can replace the noisy binary tree with the noisy self-balanced search tree from the previous section. The search tree stores the updated elements in leaves, and we can search the required index in this data structure. At the same time, the noisy segment tree uses much less memory with respect to Remark 1. That is why a noisy segment tree is more effective in this case too.

5. Quantum Sort Algorithm for Strings

As one of the interesting applications, we suggest applications from quantum computing [12,29]. Let us discuss the string-sorting problem as one of the applications.

Problem: There are n strings $s^0,\dots ,s^{n-1}$ of size l for some positive integers n and l. The problem is to find a permutation $(j_0,\dots ,j_{n-1})$ such that $s^{j_i}<s^{j_{i+1}}$, or $s^{j_i}=s^{j_{i+1}}$ and $j_i<j_{i+1}$ for each $i\in \{0,\dots ,n-2\}$. The Quantum sorting algorithm for strings was presented in [35,36]. The running time of the algorithm is $O(n\sqrt{l}logn)$. We can present the algorithm with the same complexity but in a simpler way. Assume that we have a noisy self-balanced binary search tree with strings as keys and a quantum string comparing procedure.

There is a quantum algorithm for comparing two strings quadratically faster than any classical counterparts. The algorithm is based on modifications [39,53] of Grover’s search algorithm [44,45]. The result is the following.

Lemma 1.

([36]). There is a quantum algorithm that compares two strings s and t of lengths $\left|s\right|$ and $\left|t\right|$ in the lexicographical order with $O\left(\sqrt{min\left(\right|s|,|t\left|\right)}\right)$ running time and error probability $0.1$.

We assume that the comparing procedure compares strings in lexicographical order, and if they are equal, then it compares indexes. In fact, we store indexes of the strings in nodes. We assume that if a node stores a key index i, then any node from the left subtree has a key index j such that $s^j<s^i$ or ($s^j=s^i$ and $j<i$); and any node from the right subtree has a key index $j^{\prime }$ such that $s^{j^{\prime }}>s^i$ or ($s^j=s^i$ and $j^{\prime }>i$). Initially, the tree is empty. Let $Add\left(i\right)$ be a function that adds a string $s^i$ to the tree. Let $GetMin$ be a function that returns the index of the minimal string s from the tree according to the comparing procedure. After returning the index, the function removes it from the tree. The algorithm is two for-loops. The first one is adding all strings one by one using $Add\left(i\right)$ for $i\in \{0,\dots ,n-1\}$. The second one is obtaining the index of minimal strings $GetMin$ for $i\in \{0,\dots ,n-1\}$. The code representation of the algorithm is in Appendix A. The second For-loop can be replaced by in-order traversal (dfs) of the tree for constructing the list. This approach has a smaller hidden constant in big-O. The full idea is presented in Appendix A for completeness.

Theorem 4.

The quantum running time for sorting n string of length l is $O(n\sqrt{l}logn)$ and $\Omega (n+\sqrt{nl})$.

The upper bound is complexity of the presented algorithm and algorithm from [36]. The proof of the lower bound is presented below.

For simplicity, we assume that strings are binary, i.e., $s^i\in {\{0,1\}}^l$, for $i\in \{0,\dots ,n-1\}$. Let us formally define the sorting function.

For positive integers $n,l$, let ${RADIX}_{n,l}:{\{0,1\}}^{nl}\to {\mathbb{S}}_n$ be a function that obtains n binary strings of length l as input and returns a permutation of n integers that is a result of sorting input strings. Here, ${\mathbb{S}}_n$ is a set of all permutations of integers from 0 to $n-1$. For $s^0,\dots ,s^{n-1}\in {\{0,1\}}^l$, we have ${RADIX}_{n,l}(s^0,\dots ,s^{n-1})=(j_0,\dots ,j_{n-1}),$ where $(j_0,\dots ,j_{n-1})\in {\mathbb{S}}_n$ is a permutation such that ${\sigma }_{j_i}<{\sigma }_{j_{i+1}}$ or (${\sigma }_{j_i}={\sigma }_{j_{i+1}}$ and $j_i<j_{i+1}$), for $i\in \{0,\dots ,n-2\}$.

Note that in the case of $l=1$, the function ${RADIX}_{n,1}$ can be used to compute the majority function. We use ${RADIX}_{n,1}$ to sort strings and the $n/2$-th string is a value of the majority function. Therefore, we expect that complexity of ${RADIX}_{n,1}$ should be $\Omega \left(n\right)$ [54]. In the case of $n=2$, the function ${RADIX}_{2,l}$ is similar to the OR function, so we expect that it requires $\Omega \left(\sqrt{l}\right)$ queries [54].

Note that in the case of $l=1$, the function ${RADIX}_{n,1}$ can be used to compute the majority function. We use ${RADIX}_{n,1}$ to sort strings and the $n/2$-th string is a value of the majority function. Therefore, we expect that complexity of ${RADIX}_{n,1}$ should be $\Omega \left(n\right)$. In the case of $n=2$, the function ${RADIX}_{2,l}$ is similar to the OR function, so we expect that it requires $\Omega \left(\sqrt{l}\right)$ queries.

Formally, we prove the following.

Lemma 2.

For positive integers $n,l$, let ${\mathrm{MAJ}}_n:{\{0,1\}}^n\to \{0,1\}$ be a majority function, and $\mathrm{SEARCH}{1}_l:{\{0,1\}}^l\to \{1,\dots ,l\}$ be a function that returns the minimal index of one in the input.

$$\begin{array}{cc}\hfill Q\left({RADIX}_{n,1}\right)& \ge Q\left({\mathrm{MAJ}}_n\right)\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill Q\left({RADIX}_{2,l}\right)& \ge Q\left({\mathrm{OR}}_l\right)\hfill \end{array}$$

(3)

Proof. 

Consider the input $x\in {\{0,1\}}^n$. Suppose that ${RADIX}_{n,1}\left(x\right)=\sigma =({\sigma }_1,\dots ,{\sigma }_n)$.

Then the proof of (2) follows from the fact that

$${\mathrm{MAJ}}_n\left(x\right)=x_{{\sigma }_{\lceil n/2\rceil }}.$$

Take an input $y\in {\{0,1\}}^l$. Let $y^{\prime }\in {\{0,1\}}^{2l}$ be a pair of words $\overrightarrow{0}=0\dots 0\in {\{0,1\}}^l$ and y. Now we see that

$${\mathrm{OR}}_l\left(y\right)=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{RADIX}_{2,l}\left(y^{\prime }\right)=\left(10\right),\hfill \\ 0,\hfill & \mathrm{if}{RADIX}_{2,l}\left(y^{\prime }\right)=\left(01\right).\hfill \end{array}\right.$$

and this completes the proof.    □

Note that [36] proves the lower bound of the form $Q\left({RADIX}_{n,l}\right)\ge \Omega \left(\sqrt{nl}\right)$. Combining their result with the Lemma 2, we get the following corollary.

Corollary 3.

The complexity of ${RADIX}_{n,l}$ is $Q\left({RADIX}_{n,l}\right)\ge \Omega (n+\sqrt{nl})$.

6. Auto-Complete Problem

In this section, we present the Auto-Complete Problem and a quantum algorithm that is another application of the Noisy Binary Search Tree.

Problem: Assume that we use some constant-size alphabet, for example, binary, ASCII, or Unicode. We work with a sequence of strings $\mathcal{S}=(s^{i_1},\dots ,s^{i_{\left|\mathcal{S}\right|}})$, where $\left|\mathcal{S}\right|$ is the length of the sequence; and $i_j$ are increasing indexes of strings. Here, the index $i_j$ is the index of the query for adding this string to $\mathcal{S}$. Initially, the sequence $\mathcal{S}$ is empty. Then, we have n queries of two types. The first type is adding a string s to the sequence $\mathcal{S}$. Let $\#\left(u\right)=\left|\right\{j:u=s^j,j\in \{i_1,\dots ,i_{\left|\mathcal{S}\right|}\}\left\}\right|$ be a number of occurrence (or “frequency”) of a string u among $\mathcal{S}$. The second type is querying the most frequent completion from $\mathcal{S}$ of a string t. Let us define it formally. If t is a prefix of $s^j$, then we say that $s^j$ is a completion of t. Let $D\left(t\right)=\{s^j:j\in \{i_1,\dots ,i_{\left|\mathcal{S}\right|}\},s^j$ is a completion of $t\}$ be the set of completions for t, and let $md\left(t\right)=max\{\#\left(s^r\right):r\in \{i_1,\dots ,i_{\left|\mathcal{S}\right|}\},s^r\in D\left(t\right)\}$ be the maximal “frequency” of strings from $D\left(t\right)$. The problem is to find the index $mi\left(t\right)=min\{r:r\in \{i_1,\dots ,i_{\left|\mathcal{S}\right|}\},s^r\in D\left(t\right),\#\left(s^r\right)=md\left(t\right)\}$.

We use a Self-Balanced Search tree for our solution. A node v of the tree stores 4-tuple $(i,c,j,jc)$, where i is an index of a string $s^i$ that is “stored” in the node, and $c=\#\left(s^i\right)$. The tree is a Search tree by this strings $s^i$ similar to storing strings in Section 5. For comparing strings, we use a quantum procedure from Lemma 1. Therefore, our tree is noisy. The index j is the index of the most “frequent” string in the sub-tree whose root is v, and $jc=\#\left(s^j\right)$. Formally, for any node $v^{\prime }$ from this sub-tree if $(i^{\prime },c^{\prime },j^{\prime },j{c}^{\prime })$ is associated with $v^{\prime }$, then $c^{\prime }<jc$ or ($c^{\prime }=jc$ and $i^{\prime }\ge j$).

Initially, the tree is empty. Let us discuss processing the first type of query. We want to add a string s to $\mathcal{S}$. We search a node v with associated $(i,c,j,jc)$ such that $s^i=s$. If we can find it, then we increase $c\leftarrow c+1$. It means j parameter of the node v or its ancestors can be updated. There are at most $O(logn)$ ancestors because the height of the tree is $O(logn)$. So, for each ancestor of v that associated with $(i^{\prime },c^{\prime },j^{\prime },j{c}^{\prime })$, if $j{c}^{\prime }<c$ or ($j{c}^{\prime }=c$ and $j^{\prime }>i$), then we update $j^{\prime }\leftarrow i$ and $jc\leftarrow c$.

If we cannot find the string s in $\mathcal{S}$, then we add a new node to the tree with associated 4-tuple $(r,1,r,1)$, where r is the index of the query. Note that if we re-balance nodes in the Red–Black tree, then we easily can recompute j and $jc$ elements of nodes.

Assume that we have a Search(s) procedure that returns a node v with associated $(i,c,j,jc)$ where $s=s^i$. If there is no such a node, then the procedure returns $NULL$. A procedure AddAString(r) adding a node $(r,1,r,1)$ to the tree. A procedure GetTheRoot returns the root of the search tree. The processing of the first type of query is presented in Algorithm 4.

Algorithm 4 Processing a query of the first type with an argument s and a query number r

$v\leftarrow$ Search(s) if $v\ne NULL$  then     $(i,c,j,jc)$ is associated with v     $c\leftarrow c+1$     if $jc<c$ or $(jc=c$ and $j\ge i)$ then         $jc\leftarrow c$         $j\leftarrow i$     end if     while $v\ne$ GetTheRoot do         $v\leftarrow$ Parent(v)         $(i^{\prime },c^{\prime },j^{\prime },j{c}^{\prime })$ is associated with v         if $j{c}^{\prime }<c$ or $(j{c}^{\prime }=c$ and $j^{\prime }\ge i)$ then            $j{c}^{\prime }\leftarrow c$            $j^{\prime }\leftarrow i$         end if     end while else     AddAString(r) end if

Let us discuss processing the second type of query. All strings $s^i$ that can be a completion for t belong to the set $C\left(t\right)=\{s^r:r\in \{i_1,\dots ,i_{\left|\mathcal{S}\right|}\},s^r\ge t$ and $s^r<t^{\prime }$}. Here, we can obtain $t^{\prime }$ from the string t by replacing the last symbol with the next symbol from the alphabet. Formally, if $t=(t_1,\dots ,t_{\left|t\right|-1},t_{\left|t\right|})$, then $t^{\prime }=(t_1,\dots ,t_{\left|t\right|-1},t_{\left|t\right|}^{\prime })$, where the symbol $t_{\left|t\right|}^{\prime }$ succeeds $t_{\left|t\right|}$ in the alphabet. We can say that $C\left(t\right)=D\left(t\right)$. The query processing consists of three steps.

Step 1. We search for a node $v_{Rt}$ such that t should be in the left sub-tree of v and $t^{\prime }$ should be in the right sub-tree of v. Formally, $\beta \left(v_{Rt}\right)\le t\le \alpha \left(v_{Rt}\right)$, and $\alpha \left(v_{Rt}\right)<t^{\prime }\le \gamma \left(v_{Rt}\right)$. For implementing this idea the procedure IsItTheTarget(v) checks the following condition:

$$\left(\mathrm{C}\mathrm{OMPARE}\left(\beta \right(v),t)\le 0\mathrm{and}\mathrm{C}\mathrm{OMPARE}(t,\alpha (v\left)\right)\le 0\right)$$

$$and$$

$$\left(\mathrm{C}\mathrm{OMPARE}(\alpha \left(v\right),t^{\prime })<0\mathrm{and}\mathrm{C}\mathrm{OMPARE}(t^{\prime },\gamma \left(v\right))\le 0\right).$$

The procedure SelectChild(v) returns the right child if $t>\alpha \left(v\right)$, i.e., 

$$\mathrm{C}\mathrm{OMPARE}(t,\alpha (v\left)\right)>0,$$

and returns the left child otherwise.

If we come to the null node, then there are no completions of t. If we find $v_{Rt}$, then we carry out the next two steps. In those two steps, we compute the index of the required string $j_{ans}$ and $j{c}_{ans}=\#\left(s^{j_{ans}}\right)$.

Step 2. Let us look to the left sub-tree with t. Let us find a node $v_L$ that contains an index $i_L$ of the minimal string $s^{i_L}\ge t$. For implementing this idea, the procedure IsItTheTarget(v) checks whether the current string is t. Formally, it checks Compare$\left(\alpha \right(v),t)=0$. Additionally, the procedure saves the node $v_L\leftarrow v$ if $\alpha \left(v\right)\ge t$, i.e., Compare$(t,\alpha (v\left)\right)\ge 0$. The procedure SelectChild(v) works as for searching t. It returns the right child if $t>\alpha \left(v\right)$, i.e., Compare$(t,\alpha (v\left)\right)>0$, and returns the left child otherwise. In the end, the target node is stored in $v_L$.

Then, we go up from this node. Let us consider a node v. If it is the right child of Parent(v), then it is bigger than the string from Parent(v) and the left child’s sub-tree, so we do nothing. If it is the left child of Parent(v), then it is less than the string from Parent(v) and all strings from the right child’s sub-tree, so we update $j_{ans}$ and $j{c}_{ans}$ by values from the parent node and the right child. Formally, if $(i_p,c_p,j_p,j{c}_p)$ for the Parent(v) node and $(i_r,c_r,j_r,j{c}_r)$ for the right child node, then we complete the following actions. If $c_p>j{c}_{ans}$ or ($c_p=j{c}_{ans}$ and $i_p<j_{ans}$), then $j_{ans}\leftarrow i_p$ and $j{c}_{ans}\leftarrow c_p$. If $j{c}_r>j{c}_{ans}$ or ($j{c}_r=j{c}_{ans}$ and $j_r<j_{ans}$), then $j_{ans}\leftarrow j_r$ and $j{c}_{ans}\leftarrow j{c}_r$. This idea is presented in Algorithm 5.

Algorithm 5 Obtaining the answer of Step 2 by $v_L$

$v\leftarrow v_L$  while  $v\ne$ Parent$\left(v_{Rt}\right)$  do     $parent\leftarrow$ Parent(v)     if v = LeftChild$\left(parent\right)$ then         $(i_p,c_p,j_p,j{c}_p)$ is associated with $parent$         if $c_p>j{c}_{ans}$ or ($c_p=j{c}_{ans}$ and $i_p<j_{ans}$) then            $j_{ans}\leftarrow i_p$            $j{c}_{ans}\leftarrow c_p$         end if         $(i_r,c_r,j_r,j{c}_r)$ is associated with RightChild$\left(parent\right)$         if RightChild$\left(parent\right)\ne NULL$ then            if ($c_r>j{c}_{ans}$ or ($c_r=j{c}_{ans}$ and $i_r<j_{ans}$)) then                $j_{ans}\leftarrow i_r$                $j{c}_{ans}\leftarrow c_r$            end if         end if     end if     $v\leftarrow parent$ end while

Step 3. Let us look to the right sub-tree with $t^{\prime }$. Let us find a node $v_R$ that contains an index $i_R$ of the maximal string $s^{i_R}<t^{\prime }$. Then, we go up from this node and carry out the symmetric actions as in Step 2.

Each of these three steps requires $O(logn)$ running time because each of them observes nodes of a single branch. The complexity of the quantum algorithm is presented in Theorem 5. Before presenting the theorem, let us present a lemma that helps us to prove quantum and classical lower bounds.

Lemma 3.

Auto-complete problem at least as hard as unstructured search 1 among $O\left(L\right)$ bits.

Proof. 

Assume that the alphabet is binary. For any other case, we just consider two letters from the alphabet. Assume that all strings from queries of the first type have length k.

Let $m=\lfloor (n-1)/2\rfloor$. Let us consider the following case. We have m queries of the first type of the next form: $s^i=(0,0,s_3^i,\dots ,s_k^i)$, Here, $s_j^i=0$ for all $i\in \{1,\dots ,m\}$ and $j\in \{3,\dots ,k\}$ except one bit. We have two cases.

The first case is the following. There is only one pair $(r,w)$ such that $r\in \{1,\dots ,m\}$, $w\in \{3,\dots ,k\}$, and $s_w^r=1$. In the second case, there is no such a pair.

Next m queries of the first type of the next form $(0,1,0,\dots ,0)$.

If $n-1$ is odd, then we add a query of the first type of the next form $(1,\dots ,1)$.

The last query of the second type of the form $t=\left(0\right)$.

If we have the first case, then $\#(0,1,0,\dots ,0)=m$, $\#(0,0,0,\dots ,0)=m-1$ and the answer is $(0,1,0,\dots ,0)$. If we have the second case, then $\#(0,1,0,\dots ,0)=m$, $\#(0,0,0,\dots ,0)=m$ and $(0,0,0,\dots ,0)$ has a smaller index. Therefore, the answer is $(0,0,0,\dots ,0)$.

Hence, the answer for the input is at least as hard as distinguishing between these two cases. At the same time, it requires searching 1 among $O\left(\right(k-3\left)m\right)=O\left(L\right)$ bits.    □

Based on the presented lemma and the discussed algorithm, we can present quantum lower and upper bounds for the problem in the next theorem.

Theorem 5.

The quantum algorithm with a noisy Self-Balanced Search tree for the Auto-Complete Problem has $O(\sqrt{nL}logn)$ running time and error probability $1/3$, where L is the sum of lengths of all queries. Additionally, the lower bound for quantum running time is $\Omega \left(\sqrt{L}\right)$.

Proof. 

Let us start with the upper bound. Let us consider the processing of the first type of query. Here we add a string s. Firstly, we find the target node with $O(\sqrt{\left|s\right|}logn)$ running time and $1/n^2$ error probability according to Corollary 1. Then, we consider at most $O(logn)$ ancestors for updating with $O(logn)$ running time and no error. So, processing the first type of query works with $O(\sqrt{\left|s\right|}logn)$ running time and $1/n^2$ error probability.

Let us consider the processing of the second type of query. Here we search for a completion for a string t. Searching nodes $v_{Rt}$, $v_L$ and $v_R$ works with $O(\sqrt{\left|t\right|}logn)$ running time and $1/n^2$ error probability according to Corollary 1. Then, we consider at most $O(logn)$ ancestors for updating with $O(logn)$ running time and no error. So, processing the second type of query works with $O(\sqrt{\left|t\right|}logn)$ running time and $3/n^2$ error probability.

Let $m_1,\dots ,m_n$ be the lengths of strings from queries. So, the total complexity is

$$O(\sqrt{m_1}logn+\cdots +\sqrt{m_n}logn)=O((\sqrt{m_1}+\cdots +\sqrt{m_n})logn)=$$

$$O(\sqrt{n(m_1+\cdots +m_n)}logn=O(\sqrt{nL}logn)$$

The last two equalities are due to Cauchy–Bunyakovsky–Schwarz inequality and $L=m_1+\cdots +m_n$.

The error probability of processing a query is at most $3/n^2$. Therefore, the error probability of processing n queries is at most $0.1$ due to all error events are independent.

Let us discuss the lower bound. It is known [55] that the quantum running time for the unstructured search among $O\left(L\right)$ variables is $\Omega \left(\sqrt{L}\right)$. So, due to Lemma 3 we obtain the required lower bound.    □

Let us consider the classical (deterministic or randomized) case. If we use the same Self-balanced search tree, then the running time is $O(Llogn)$. At the same time, if we use the Trie (prefix tree) data structure [40], then the complexity is $O\left(L\right)$.

We store all strings of $\mathcal{S}$ in the trie. For each terminal node, we store the “frequency” of the corresponding string. For each node v (even non-terminal) that corresponds to a string u as a path from the root to v, additionally to the regular information we store the index of the required completion for t and its frequency. When we process the first type of query, we update the frequency in the terminal node and update additional information in all ancestor nodes because they store all possible prefixes of the string. For processing the query of the second type, we just find the required node and take the answer in the additional information of the node.

We can show that it is also the lower bound for the classical case.

Lemma 4.

The classical running time for the Auto-Complete Problem is $\Theta \left(L\right)$, where L is the sum of the lengths of all queries.

Proof. 

Let us start with the upper bound. Similarly to the proof of Theorem 5, we can show that the running time of processing a query of both types is $O\left(\right|s\left|\right)$ or $O\left(\right|t\left|\right)$ depends on the type of a query. Let $m_1,\dots ,m_n$ be the lengths of strings from queries. So, the total complexity is $O(m_1+\cdots +m_n)=O\left(L\right)$.

Let us discuss the lower bound. It is known [55] that the classical running time for the unstructured search among $O\left(L\right)$ variables is $\Omega \left(L\right)$. So, due to Lemma 3 we obtain the required lower bound.    □

If $O\left(n\right)$ strings have a length that is at least $\Omega \left({\left({log}_{2}n\right)}^2\right)$, then we obtain a quantum speed-up.

7. Conclusions

We suggest the Walking tree technique for noisy tree data structures. We apply the technique to the Red–Black tree and the Segment tree. We show that the complexity of the main operations is asymptotically equal to the complexity of standard (not noisy) versions of the data structures. We use a noisy Red–Black tree for two problems: The string-sorting Problem and The auto-complete problem. The considered algorithms are quantum because they use the quantum string comparing algorithm as a subroutine. This subroutine demonstrates quadratic speed-up, but it has a non-zero error probability. For the string-sorting problem, we show lower and upper bounds that are the same up to a log factor. Note that lower bounds for $FS{T}_m$, $S{G}_n$, and $SG{N}_{n,l}$ functions may be of independent interest. For the auto-complete problem, we obtain quantum speed-up for the problems if ${(logn)}^2=o\left(l\right)$ where n is the number of queries and l is the size of an input string of a query. Future work can include applying the Walking tree technique to other tree data structures and obtaining the noisy version of them with good complexity of main operations. Also, it is interesting to find more applications for noisy data structures. We assume that quantum algorithms should be one of the fruitful fields for such applications. It is interesting to meet quantum lower and upper bounds for the considered problems.