July 10, 2026
Local Computation Algorithms (LCAs), introduced by Rubinfeld, Tamir, Vardi, and Xie (2011), are a special type of sublinear algorithms that, given probing access to a possibly massive input, are required to provide query access to a consistent solution, without maintaining a state between different queries. In this paper, we try to understand LCA through the lens of complexity classifications, described by the following question: Given a target complexity function \(f(n)\), is there a problem whose local computation complexity is \(f(n)\), up to polylogarithmic factors?
We restrict our focus to Locally Checkable Labeling (LCL) problems, which can be seen as constant-degree constraint satisfaction problems. Possible complexity classes of this problem family have been extensively studied in various distributed computation models, including the \(\mathsf{VOLUME}\) model proposed by Rosenbaum and Suomela (2020), which is an invariant of local computation algorithms with additional locality requirements.
In this paper, we provide new LCL complexity constructions in the \(\mathsf{VOLUME}\) model, and generalize the results to LCAs. Specifically, we show that there are LCLs whose probe complexities in the \(\mathsf{VOLUME}\) and LCA models are \(\Theta(\log^k n)\) and \(\tilde{\Theta}(n^{p/q})\) for any positive integer \(k \ge 1\) and rational \(p/q \in (0,1]\). Our approach, completely different from the approach to a similar result in the distributed \(\mathsf{LOCAL}\) model by Balliu et al. (2018), is to stack instances of complexity \(\Theta(\log n)\) and \(\tilde{\Theta}(n^{1/k})\) in the \(\mathsf{VOLUME}\) model constructed by Rosenbaum and Suomela (2020).
Local computation algorithms (LCAs), proposed in [1], [2], are a special type of sublinear algorithms typically applied to graph problems involving multiple output bits. An LCA is expected to find only a small part of the solution each time, specified by queries, through a small number of probes that give the algorithm access to the input and adjacency list of a vertex in the graph. Following most of the LCA literature, in this paper, the input graph has a constant maximum degree, so it is the same up to a constant factor for a probe to return the complete adjacency list of a vertex as to return one entry of the adjacency list.
The main challenge in designing a local computation algorithm is consistency: when there are multiple feasible solutions to the instance, multiple queries to different parts of the solution should provide consistent local solutions that point to a single globally feasible solution without maintaining state across queries. For graph coloring, for example, a query may ask for the color of one vertex, and the answers to multiple queries must together form a single feasible coloring. To make this possible, if an LCA needs randomness, the same randomness must be shared across queries.
The motivation behind LCA is to provide an efficient and parallelizable way to gain access to a small part of a large solution to a massive problem. This shares the spirit with distributed computing and property testing. See [3] for a survey on common methods in LCA and its connection to property testing and various distributed models. LCAs have also been connected to several other fields of theoretical computer science, including online algorithms [4], graph sparsification [5], distributed optimization [6], coding theory [2], [7], and algorithmic game theory [8]. However, most existing literature on LCA takes an algorithm-designer perspective, seeking the optimal probe complexity of concrete problems. In this paper, we ask the question the other way around: Given a target complexity \(f(n)\), is there a problem whose probe complexity is exactly or roughly \(f(n)\) up to a polylogarithmic factor?
This question becomes meaningless if we take arbitrary problems into consideration. For example, one can take a problem with \(\Theta(n)\) probe complexity and add a promise to the input instance that each connected component only has size \(f(n)\), likely leading to a problem of probe complexity \(\Theta(f(n))\). Another candidate with probe complexity \(\Theta(f(n))\) is to give each vertex \(v\) a radius \(r_v \le \log_\Delta f(n)\) and let each vertex collect the exact number of vertices within distance \(r_v\) from \(v\). From the examples above, it is essential to select a suitable family of problems that excludes trivial issues, while also striving to include a large class of meaningful problems.
Our approach, as is standard in distributed graph algorithms, is to restrict ourselves to the family of locally checkable labeling (LCL) problems. To talk about LCL, we should first define the graph family these problems are defined on. In this paper, we will analyze LCLs on the family of all bounded-degree graphs and the family of all bounded-degree trees. We cannot make additional promise about the input structure, so the first example above does not fall into our consideration.
In a typical LCL setting, each vertex in a constant-degree graph receives its unique ID and possibly an input label from a constant number of possible inputs, and each vertex should provide an output label from a constant number of choices. Furthermore, the feasibility of a solution is locally checkable. This means that each vertex can check whether its local constraint is satisfied with information from a constant-hop neighborhood, and a global solution satisfies the requirement of the problem if all vertices are locally satisfied. One may also think of LCLs as CSPs on constant-degree constraint graphs. The second example given above is not an LCL because its label sets or checkability radius are not constant. At the same time, LCLs still include classic problems, such as graph coloring and maximal independent set.
Since the work by Naor and Stockmeyer [9], the possible complexity of LCLs has been extensively studied in the context of distributed graph algorithms [10]–[15]. There is now a substantial understanding of LCL complexities in the \(\mathsf{LOCAL}\) model on bounded-degree graphs (see [16] for the almost-complete complexity spectrum), trees [17]–[21], and other special types of graphs [22]–[25]. This research paradigm has also extended to other models and settings [20], [26]–[28], among which the \(\mathsf{VOLUME}\) model proposed by Rosenbaum and Suomela [29] has a close connection to local computation algorithms.
The \(\mathsf{VOLUME}\) model is motivated to provide a more fine-grained resource analysis compared to other common distributed models such as \(\mathsf{LOCAL}\) and \(\mathsf{CONGEST}\). This model shares a similar spirit with LCA, using probes to measure the cost of an algorithm, but they are different in two aspects:
First, any time in the execution of a \(\mathsf{VOLUME}\) algorithm, the set of vertices probed by the algorithm should always be a connected component that includes the current vertex being queried. In other words, \(\mathsf{VOLUME}\) algorithms cannot perform a far probe with low cost.
Another difference lies in the randomness: As mentioned above, in local computation algorithms, different queries share the single random string \(r\), and the algorithm can freely access each bit of \(r\). In the \(\mathsf{VOLUME}\) model, different queries still share the same randomness, but the algorithm only has restricted access to it. Specifically, each vertex \(v\) in the graph has an independent random string \(r_v\) that jointly constitutes \(r\), and for a query, the algorithm can access \(r_v\) only after it probes \(v\).
In these two dimensions, the \(\mathsf{VOLUME}\) model more closely resembles common distributed models in which information only propagates through network channels abstracted as edges in the graph, and the algorithm needs to use additional resources to get information from vertices far away.
In this paper, we consider LCLs with probe complexity \(\Omega(\log n)\) in both the LCA and \(\mathsf{VOLUME}\) models for randomized algorithms only. To the best of the author’s knowledge, no prior work addresses the LCL complexity classification for LCAs. Several existing papers have studied randomized \(\mathsf{VOLUME}\) complexities of LCLs [21], [29], [30]. See 1 for an illustration of the status of the randomized \(\mathsf{VOLUME}\) complexity landscape for bounded-degree graphs before our work. We note here that [29] also includes results for the deterministic \(\mathsf{VOLUME}\) model, but current knowledge on this model is largely limited by the fact that it is unknown whether there is either a gap theorem or an explicit LCL construction between \(\Omega(\log^\star n)\) and \(o(n)\) for the deterministic \(\mathsf{VOLUME}\) model.
Before our work, one can construct LCLs with randomized \(\mathsf{VOLUME}\) complexity \(\Theta(1)\), \(\Theta(\log^\star n)\), \(\Theta(\log n)\), and \(\tilde{\Theta}(n^{1/k})\) for any positive integer \(k\), where \(\tilde{\Theta}\) ignores polylogarithmic factors. The constructions for \(\Theta(1)\) and \(\Theta(\log^\star n)\) complexity come from constructions in the \(\mathsf{LOCAL}\) model, while other constructions are given in [29]. It turns out that all LCL constructions in 1 have the same complexity in the \(\mathsf{VOLUME}\) model when we restrict the instance to bounded-degree trees. Two gap theorems in the randomized \(\mathsf{VOLUME}\) model, \(\omega(1) - o(\log^\star n)\) gap and \(\omega(\log^\star n) - o(\sqrt{\log n})\) gap, are given in [21] and [30] respectively. Unfortunately, these constructions and gap theorems do not directly transfer to LCAs.
At the same time, there are still regions where we do not know either a separation theorem or an LCL construction. It is explicitly asked in [29] whether more randomized \(\mathsf{VOLUME}\) complexities exist in the polylogarithmic regime, and whether the set of possible complexities in the polynomial regime is “dense”, meaning that for any two reals \(0 < a < b \le 1\), there is a problem with complexity \(\Omega(n^a)\) and \(o(n^b)\).
In this paper, we provide affirmative answers to both questions, and extend the constructions and analysis further to the LCA setting and bounded-degree trees, as stated in 1 and 2. Adding our results gives the new complexity landscape for the \(\mathsf{VOLUME}\) model shown in 2.
Theorem 1. For each positive integer \(k\), there exists an LCL whose randomized LCA and \(\mathsf{VOLUME}\) complexities are both \(\Theta(\log^k n)\) for both bounded-degree graphs and trees.
Theorem 2. For each \(x \in \mathbb{Q} \cap (0,1]\), there exists an LCL whose randomized LCA and \(\mathsf{VOLUME}\) complexities are both \(\tilde{\Theta}(n^x)\) for both bounded-degree graphs and trees.
It is worth noting the difference between our results in the LCA and \(\mathsf{VOLUME}\) model and similar results in the \(\mathsf{LOCAL}\) model. In the \(\mathsf{LOCAL}\) model proposed by Linial [31], the complexity is measured by the number of communication rounds, equivalently, the radius of the neighborhood that determines the output for each vertex.
For bounded-degree trees, it is shown in [19], [32] that no LCL has complexity in the range \(\omega(\log n)-n^{o(1)}\) or the range \(\omega(n^{1/(k+1)})-o(n^{1/k})\) for any integer \(k \ge 1\). Our results indicate that the complexity landscape of LCLs in bounded-degree trees is more complex for the \(\mathsf{VOLUME}\) model and LCAs compared to the \(\mathsf{LOCAL}\) model in polylogarithmic and polynomial regimes. This is consistent with the intuition that probe complexity looks like a more fine-grained complexity measure compared to distance complexity.
Yet this intuition does not hold for general graphs, as it is shown in [33], [34] that, for bounded-degree graphs, the possible LCL complexity for the \(\mathsf{LOCAL}\) model is dense in the interval ranging from \(\log n\) to \(n\). More specifically, for any positive rational \(r/s \le 1\) and \(p/q \ge 1\), one can construct LCLs with distance complexity \(\Theta(\log^{p/q}n)\), \(2^{\Theta(\log^{r/s}n)}\) and \(\Theta(n^{r/s})\). Our result exhibits a similar density in the polynomial regime, but the techniques are completely different. The constructions in [33], [34] use a set of carefully crafted constraints to encode the execution of special Turing machines into the instance. Instead, our constructions use the constructions in [29] with \(\mathsf{VOLUME}\) complexity \(\Theta(\log n)\) and \(\tilde{\Theta}(n^{1/k})\) and provide a way to stack multiple instances of these problems to create more complexity classes. We will briefly discuss how the stacking works in 2.
In 2, we provide an overview of our approach. In 3, we define basic notations and also models and problems of our interest. In 4 and 5, we provide the LCL construction and analysis in the polylogarithmic complexity setting and the polynomial complexity setting, respectively. Finally, in 6, we discuss several aspects of our paper at a higher level and provide some future directions.
In the polylogarithmic regime, we use the \(\mathsf{LeafColoring}\) LCL constructed in [29] with \(\mathsf{VOLUME}\) complexity \(\Theta(\log n)\), and stack its instances for \(k\) levels to provide an LCL whose \(\mathsf{VOLUME}\) and LCA complexities are \(\Theta(\log^k n)\) for any positive integer \(k\). We first review the \(\mathsf{LeafColoring}\) construction and then show how the stacking works. Finally, we briefly demonstrate how to generalize the lower bound analysis from \(\mathsf{VOLUME}\) to LCAs.
The main idea behind the \(\mathsf{LeafColoring}\) LCL is that, on all possible rooted trees of size \(n\) where each vertex has out-degree zero or two, the root needs \(\Omega(\log n)\) steps to reach a leaf, while a random walk takes \(O(\log n)\) steps from the root to a leaf with high probability for any such tree.
To make sure that any \(\mathsf{VOLUME}\) algorithm working on the output label for the root must discover a path from the root to a leaf, we impose the following constraints: Each leaf is given a red-blue color as an input and required to output the same color as its input, while each internal vertex needs to output a color appearing as the output color of one of the two children. These locally checkable constraints together require the root to output the input color of one of the leaves, and if an algorithm does not probe any leaf, it cannot distinguish between cases where all leaves are red and all leaves are blue.
Finally, to generalize the construction to all bounded-degree trees and graphs, one needs to rule out graphs not following a rooted tree of out-degree zero or two without an explicit promise on the input structure. To address this issue, Rosenbaum and Suomela [29] design a special set of input labels for each vertex and constraints called binary tree labeling. The binary tree labeling is a part of the LCL. If a vertex does not satisfy the locally checkable constraints for the binary tree labeling, we will output a special \(\perp\) label for this vertex and remove it from the rest of the computation. For vertices satisfying all constraints for the binary tree labeling, we can show that the induced subgraph will be almost a rooted forest of out-degree zero or two, and we require these vertices to solve the coloring problem. We will use the same approach in 4 5 to generalize our construction to all bounded-degree trees and graphs. For ease of understanding, in this section, we can just assume that all vertices pass the binary tree labeling check.
First, we slightly generalize the \(\mathsf{LeafColoring}\) construction by using the following set of constraints: Instead of the red/blue color, we give for each vertex an input bit \(b_{\mathrm{in}}(v)\), and each vertex needs to output two symbols. The first symbol \(d(v) \in \{\mathsf{L}, \mathsf{R}\}\) indicates the path from each vertex to a leaf. Define \(\mathrm{child}(v,d(v))\) to be the left child of \(v\) when \(d(v) = \mathsf{L}\) and the right child of \(v\) when \(d(v) = \mathsf{R}\), then the path from some vertex \(u\) will be \(p_0 = u, p_1 = \operatorname{child}(p_0, d(p_0)), p_2 = \operatorname{child}(p_1, d(p_1)), \cdots,\) all the way down to a leaf \(w\) where \(d(w)\) should be a placeholder \(\perp\). The second output symbol \(b_{\mathrm{out}}(v)\) is to ensure that the algorithm probes all vertices along the path, and we add the constraint that \(b_{\mathrm{out}}(u) = \oplus_{i \ge 0} b_{\mathrm{in}}(p_i)\) for each vertex \(u\). This constraint involves \(\Omega(\log n)\) labels, so it is not local, but we notice that we can use the locally checkable constraint \(b_{\mathrm{out}}(v) = b_{\mathrm{out}}(p_1) \oplus b_{\mathrm{in}}(v)\) on each internal vertex \(v\) in the instance to jointly make sure that \(b_{\mathrm{out}}(u)\) equals the xor of input bits along the path.
We denote the previous LCL as \(\Pi_\mathsf{PTL}^1\), where \(\mathrm{PTL}\) abbreviates “path to leaf”. Compared to \(\mathsf{LeafColoring}\), the benefit of \(\Pi_\mathsf{PTL}^1\) is that the output of the root is always related to \(\Theta(\log n)\) input bits rather than a single input color on some leaf. As a result, we would expect that any randomized LCA would also need \(\Omega(\log n)\) probes.
We will now demonstrate the way to stack \(\Pi_\mathsf{PTL}^1\) instances. Consider, for each vertex \(v\) in a \(\Pi_\mathsf{PTL}^1\) instance of size \(m\) called the base instance, we give it a “twisted” input bit \(b_{\mathrm{in}}'(v)\) and additionally attach a fresh \(\Pi_\mathsf{PTL}^1\) instance of size \(m\). Different vertices receive disjoint instances, so the final instance includes \((m+1)\) independent \(\Pi_\mathsf{PTL}^1\) instances where one of them is the base instance. For a vertex in the base instance, the actual input bit \(b_{\mathrm{in}}(v)\) will be the xor of the twisted input bit \(b'_{\mathrm{in}}(v)\) and the output bit of the root of the attached instance. The \(\Pi_\mathsf{PTL}^1\) constraints for each of the \((m+1)\) instances are the same as before.
Now, to get the output bit for the root of the base instance, apart from \(\Theta(\log m)\) input bits along the path, the algorithm needs to additionally get the root output label for \(\Theta(\log m)\) independent attached instances. This suggests that the LCL should provide a \(\Theta(\log^2 m)\) probe complexity construction. The total instance size will blow up by a polynomial factor, but it does not affect the complexity since we are in the polylogarithmic regime. We call this problem \(\Pi_\mathsf{PTL}^2\), and we can recursively do the attachment to define \(\Pi_\mathsf{PTL}^k\) for any positive integer \(k\).
The \(\Theta(\log^2 n)\) \(\mathsf{VOLUME}\) and LCA upper bound for \(\Pi_\mathsf{PTL}^2\) follows by generalizing the random-walk algorithm in [29]. For the lower bound, one may first approach it using uniform random bits for \(b_{\mathrm{in}}\), hoping that the output bit at the root of the base instance is then the xor sum of \(\Theta(\log^2 n)\) uniform random bits. The issue is that the algorithm can choose \(d(v)\) based on the input bits. For example, an algorithm may use a few probes to find a \(d(v)\) assignment adaptively such that the correct \(b_{\mathrm{out}}\) value at the root is zero with high probability.
To resolve this issue, we construct a special distribution over the instances, so that each instance \(I\) in the support is associated with a bit \(b_I \in\{0,1\}\), and no matter how the output label \(d\) is chosen for each vertex, the output bit at the root of the base instance in a globally correct solution will always be \(b_I\). This removes the effect of \(d\) outputs, and we can use an induction argument to show that, conditioned on the input bit of any set of \(o(\log^2 n)\) vertices, the probability that the associated instance bit \(b_I\) equals \(1\) will be exactly \(1/2\). This, along with Yao’s minimax principle, proves the lower bound.
In the polynomial regime, we utilize the \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) LCL constructed in [29] with \(\mathsf{VOLUME}\) complexity \(\tilde{\Theta}(n^{1/k})\) for any positive integer \(k\), and stack its instances in a nontrivial way to provide an LCL of randomized LCA and \(\mathsf{VOLUME}\) complexities \(\tilde{\Theta}(n^{p/q})\) for any positive rational \(0<p/q \le 1\). We first review the \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) construction and then show how the stacking works. Finally, we demonstrate the difficulties in the upper and lower bound analysis.
Our presentation of the \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) LCL will be different from previous works [29], [32], and the purpose is to show that \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) is constructed by stacking path two-coloring instances in a different way compared to the stacking in the polylogarithmic regime. This allows us to integrate two different stacking strategies to provide new complexity classes.
The \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) construction is parameterized by levels of stacking. To start with, let us consider the construction with two levels, leading to an LCL with \(\tilde{\Theta}(n^{1/2})\) probe complexity in the \(\mathsf{VOLUME}\) model. In the construction, we have a directed top path of length \(\ell\), denoted by \(v_1,v_2,\dots,v_\ell\), with each vertex \(v_i\) in the top path possibly having a directed bottom path \(P_i\) attached. The total number of vertices in the top path and all bottom paths is \(n\). See 3 (a) for an illustration.
The constraints of the \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) LCL will guarantee the following: The algorithm needs to either visit all vertices in the top path to get the output for \(v_1\), or visit all vertices in one of the bottom paths to get the output of the head of the bottom path. This immediately implies \(\Omega(n^{1/2})\) lower bound from the instance where \(\ell = \Theta(\sqrt{n})\) and \(|P_i| = \Theta(\sqrt n)\) for each \(1 \le i \le \ell\). The matching upper bound requires additional work when bottom paths have varying lengths, and we will discuss this after introducing our LCL construction.
Figure 3: An \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance with a top path of length four and attached bottom paths of lengths three, one, two, and zero from head to tail, respectively. Solid left-to-right arrows denote path connections, and dotted downward arrows denote attachments. (a) shows the input color for each vertex: all vertices in the top path have red input color, and all vertices in the bottom path have blue input color. (b)(c)(d)(e)(f) are possible output colorings for (a) that violate constraints 1,2,3,4,5 in \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\), respectively..
Now we show how to craft the constraints to generate the effect described above. First, we follow the narrative of [29] and add a variant of two-coloring constraints for each top and bottom path: Each vertex receives a red/blue input color, and the tail of a path must output its input color. Other vertices should output a color that is the same as their out-neighbors along the path. These constraints together require the head of a path to output the input color of the tail.
At the same time, we want an algorithm to be able to escape from the top path or some bottom paths when they are too long; otherwise, the complexity will be a clear \(\Theta(n)\). We introduce two additional colors for each vertex: color \(\mathsf{D}\) for decline, and color \(\mathsf{X}\) for exempt. These two colors will be used when the algorithm thinks a path is too long. To make sure that an algorithm cannot abuse these colors, we add the following constraints to \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\):
A vertex in any bottom path cannot be colored \(\mathsf{X}\);
A vertex in the top path cannot be colored \(\mathsf{D}\);
If a top vertex is colored \(\mathsf{X}\), then either no bottom path is attached to it, or the head of its attached bottom path is not \(\mathsf{D}\);
If a vertex is not colored \(\mathsf{D}\), then its descendant in the directed path is not colored \(\mathsf{D}\).
After removing vertices with colors \(\mathsf{D}\) and \(\mathsf{X}\), the set of directed paths follows the two-coloring constraints.
The first two constraints prevent the colorings in 3 (b) and (c) that color all vertices with \(\mathsf{X}\) or color all vertices with \(\mathsf{D}\). The third constraint prevents the coloring in 3 (d): if an algorithm tries to escape from the top path by putting an \(\mathsf{X}\) color on some top-level vertex \(v_i\), then the algorithm is required not to color the head of \(P_i\) with \(\mathsf{D}\) if it exists. With this in mind, constraint 4 then says that, if some vertex is not colored \(\mathsf{D}\), so is its out-neighbor. This constraint propagates from the head of \(P_i\) along the directed edges, and finally implies that any vertex in \(P_i\) should not be colored \(\mathsf{D}\) or \(\mathsf{X}\). Finally, we need to color the path following the two-coloring constraints to satisfy constraint 5, so the head of \(P_i\) must travel along the path to fetch the input color of the tail.
The previous argument holds only when the top path uses color \(\mathsf{X}\), but if it does not use \(\mathsf{X}\), it cannot use \(\mathsf{D}\) either from constraint 2, so according to constraint 5, the head of the top path needs to travel along the top path to fetch the input color on the tail. This gives the guarantee that we want: The algorithm needs to either visit all vertices in the top path to get the output for \(v_1\), or visit all vertices in one of the bottom paths to get the output of the head of the bottom path.
To generalize the result to larger \(k\), instead of a bottom path, one can attach an \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance to each vertex in the top path. Following a similar argument, the algorithm is required to either solve the two-coloring along the top path or solve one of the attached \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instances. For instance, if we replace the bottom path with a two-level \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance, we will end up with a three-level \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance. In this case, when the top path has length \(\ell\), the complexity will be \(\tilde{\Theta}(\min(\ell, (n/\ell)^{1/2}))\), and the final complexity is \(\tilde{\Theta}(n^{1/3})\) attained by \(\ell = \Theta(n^{1/3})\).
As in the polylogarithmic setting, [29] additionally constructs an input labeling called colored tree labeling to generalize the LCL to general bounded-degree trees and graphs. We follow the same approach in 9 10.
From the previous review, we can see how the stacking strategy in \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) differs from that in \(\Pi_\mathsf{PTL}^k\): In the \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) stacking, an algorithm only needs to solve one instance among all attached instances along the path, whereas in \(\Pi_\mathsf{PTL}^k\), the algorithm is required to solve all attached instances for each vertex along the path.
Same as the approach in the polylogarithmic setting, before the stacking, we first change the input and output format of \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) to make sure that the output bit on the head of the top path \(v_1\) must depend on inputs on \(n^{\Omega(1)}\) vertices. We provide an additional input bit \(b_{\mathrm{in}}(v)\) for each vertex in the instance, and we require any vertex with color other than \(\mathsf{D}\) to output a bit \(b_{\mathrm{out}}(v)\) which is the xor of \(b_{\mathrm{in}}(w)\) for all vertices \(w\) in the following path starting from \(v\): Suppose currently we are at some vertex \(u\) with color other than \(\mathsf{D}\).
If \(u\) is of output color \(\mathsf{X}\), go to the head of its attached bottom path. If it has no bottom path attached, stop.
If \(u\) is of output color red or blue, go to its out-neighbor in the directed path. If it is the tail, stop.
According to constraints 3 and 4, this path will never visit vertices of color \(\mathsf{D}\). At the same time, the length of this path from \(v_1\) will be \(\Omega(n^{1/2})\) for the \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) construction above, since the path either never visits vertices of color \(\mathsf{X}\) and visits all vertices in the top path, or visits some vertex with color \(\mathsf{X}\) and visits all vertices of the attached bottom path. With the input \(b_{\mathrm{in}}(v)\), we can remove the two-coloring constraint and the red/blue color input without changing the complexity. In 5 we will identify \(\mathsf{R}\) and \(\mathsf{B}\) as a single color \(\mathsf{U}\).
Now we try to stack \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instances. A possible first approach, similar to the stacking in the polylogarithmic setting, is to attach a \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance, say of complexity \(\tilde{\Theta}(m^{1/3})\), to every vertex in a base \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance of complexity \(\tilde{\Theta}(m^{1/2})\) of size \(m\), and hope that it generates an LCL of probe complexity \(\Theta(m^{1/2 + 1/3}) = \Theta(m^{5/6})\). Unfortunately, since the instance has size blown up to \(n = m^2\) when each attached instance has size \(m\), this is not true. By balancing the size of the base instance and attached instances, it turns out that the complexity is still \(\tilde{\Theta}(m^{1/2})\).
Our approach is to deploy a more fine-grained stacking strategy, stacking different \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instances for different levels. Next, we will give one concrete example to show this idea. In the example, there will be a base instance, which is a two-level \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance, to which other instances are attached. Instead of attaching an instance for each vertex in the base instance, we only attach one instance, specifically a fresh two-level \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance, for each vertex in the top path of the base instance. Vertices in the bottom path of the base instances have no instance attached. See 4 for an illustration. As the construction in the polylogarithmic regime, the input bit on the vertices of the top path in the base instance will be a twisted one \(b'_{\mathrm{in}}(v)\), and the algorithm needs to recover the actual input bit \(b_{\mathrm{in}}(v)\) by xoring \(b'_{\mathrm{in}}(v)\) and the output bit of the root of the attached instance, namely the head of the top path.
Denote \(\ell\) as the length of the top path in the base instance, and we assume that the algorithm knows the size of the attached two-level \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instances, denoted as \(s_1,s_2,\dots,s_\ell\), and also \(|P_i|\) for \(1 \le i \le \ell\). Consider two possibilities for the output:
If the top path in the base instance has no color \(\mathsf{X}\), then apart from \(\ell\) input bits, the algorithm is required to solve \(\ell\) two-level \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instances. The total number of probes will be \(\tilde{\Theta}(\sum \sqrt{s_i})\). By Jensen’s inequality, an adversary that wants to maximize the probe complexity will make \(s_i\) roughly equal, leading to \(\tilde{\Theta}(\ell (n/\ell)^{1/2})\) probe complexity;
Otherwise, the algorithm is required to solve one of the bottom paths in the base instance. The algorithm can choose the shortest one to solve, and an adversary will make the bottom paths of equal length, leading to \(\Theta(n/\ell)\) probe complexity.
Finally, an algorithm can choose one of the above two choices, so an adversary will take \(\ell\) to maximize \(\tilde{\Theta}(\min(\ell (n/\ell)^{1/2}, n/\ell))\). The maximum value is \(\tilde{\Theta}(n^{2/3})\) taken by \(\ell = \Theta(n^{1/3})\), and we would expect that the complexity of such an LCL is \(\tilde{\Theta}(n^{2/3})\).
For the general case, we can replace the bottom path in the base instance with an instance of complexity \(\tilde{\Theta}(n^q)\), and replace the attached two-level \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instance with an instance of complexity \(\tilde{\Theta}(n^p)\) for \(p < q\). Then, following the above analysis, the best algorithm would use \(\tilde{\Theta}(\min(\ell (n/\ell)^p, (n/\ell)^q))\) probes, and an adversary maximizing the probe complexity will take \(\ell = n^{(q-p)/(1+q-p)}\), leading to complexity \(\tilde{\Theta}(n^{q/(1+q-p)})\). This suffices to generate all rational powers, as we will show in 10.
The lower bound analysis for the polynomial setting is much closer to the preceding discussion. We can follow the adversarial choice in the argument above to generate the underlying graph for the lower bound instances. There is still the issue where an algorithm can choose output colors after reading several input bits to be in favor of the output distribution for the root, yet we can use the same approach as in the polylogarithmic setting: we construct the distribution where each instance in the distribution has a definite output bit at the root, no matter how the underlying coloring is chosen. And then we use an induction to prove that for any vertex set of size \(o(n^{q/(1+q-p)})\), revealing the input bits on those vertices does not provide any advantage to predict the output bit at the root.
The main obstacle for the upper bound proof is to remove the assumption that the algorithm knows the size of each attached instance and bottom path. To see why this is the case, we first provide a sketch of the matching \(\tilde{O}(n^{1/2})\) upper bound algorithm for two-level \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\): For each vertex \(v_i\) in the top path, consider the sub-path \(v_i,v_{i+1},\dots,v_{i+\lceil 2\sqrt{n}\rceil}\). When \(i+\lceil 2\sqrt{n}\rceil > \ell\), we can just color it with the input color at the tail of the top path with \(O(\sqrt{n})\) probes. For the other case, at least half of the vertices in the sub-path have a bottom path of length at most \(\sqrt{n}\) attached. In the algorithm, each vertex in the top path uses its local randomness to add itself to a sample set \(S\) with probability \(\Theta(\log n / \sqrt{n})\). Define \(S_i = \{v_i,v_{i+1},\dots,v_{i+\lceil 2\sqrt{n}\rceil}\} \cap S\). By Chernoff bound, with high probability, \(|S_i| = O(\log n)\) and some vertex in \(S_i\) has a bottom path of length at most \(\sqrt{n}\) attached. The algorithm finds the first vertex in \(S_i\) that has an attached bottom path of length at most \(\sqrt{n}\), which can be tested within \(\tilde{O}(\sqrt{n})\) probes, and colors it with \(\mathsf{X}\), generating the output accordingly. This uses \(\tilde{O}(\sqrt{n})\) probes and concludes the algorithm.
Returning to the \(\tilde{\Theta}(n^{2/3})\) example above, for the bottom paths in the base instance, we can use a similar approach with an alternate parameter: Each vertex in the top path of the base instance inspects \(2n^{1/3}\) descendants, and if this does not hit the tail, use the sample set \(S\) to find a vertex with an attached bottom path of length at most \(n^{2/3}\). For the general case where the bottom paths are replaced by instances of complexity \(\tilde{\Theta}(n^q)\), we will run the algorithm for attached instances with a maximum possible size parameter set to \(n^{1/(1+q-p)}\), and we require the algorithm to fail within \(\tilde{\Theta}(n^{q/(1+q-p)})\) probes when the actual instance size is larger than the maximum possible size.
For the attached \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) instances, things become more complicated since the algorithm described for \(\tilde{\Theta}(n^{1/2})\) upper bound depends heavily on knowing the instance size. We use a standard binary lifting to guess the size of each instance, and this introduces an additional problem: To get the output for each vertex in the attached instance, each query will start an independent binary lifting guessing procedure, and different vertices may become satisfied and stop at different size guesses, raising potential inconsistency issues. To resolve this issue, we will give an additional size parameter to the algorithm, called the ideal size of the instance, and most of the algorithm’s decisions will rely on the ideal size parameter rather than the size guess in the binary lifting. This maximizes consistency between independent queries and allows us to make additional changes to the algorithm to provide full consistency within the desired probe complexity budget.
In this section, we provide basic definitions and formally define models and problems of interest.
In this paper, we denote a graph as \(G = (V, E)\), where \(V\) is the vertex set and \(E\) is the edge set. We will normally use \(n\) to denote the number of vertices in a graph. Unless explicitly stated, all graphs are undirected without self-loops and parallel edges. For each vertex \(v \in V\), we denote its degree by \(\deg_G(v)\), its neighborhood by \(\Gamma_G(v)\), and its \(r\)-hop neighborhood, defined as the set of vertices with distance at most \(r\) to \(v\), as \(\Gamma^r_G(v)\). For a vertex set \(V' \subseteq V\), define the induced subgraph of \(V'\) in \(G\) as \(G[V'] = (V', \{(u,v) \in E: u, v \in V'\})\).
For all graph problems we will consider in the rest of the paper, we assume that each vertex \(v \in V\) is given a unique identifier from the range \(\{1,2,\dots,n^\alpha\}\) for some arbitrary fixed \(\alpha \geq 1\), and all vertices have degree at most \(\Delta\) for some fixed constant \(\Delta \in \mathbb{N}\). Additionally, we assume that the input graph is equipped with a port ordering. This means that, for each vertex \(v\) and incident edge \((v, w)\), there is an associated number \(p(v, w) \in \{1,2,\dots,\deg(v)\}\), the port number of \((v, w)\) for \(v\), such that \(p\) is a bijection between edges incident to \(v\) and \(\{1,2,\dots,\deg(v)\}\). Notice that \(p(v,w)\) and \(p(w,v)\) may not be equal.
Here, we give the formal definition of a locally checkable labeling problem.
Definition 1 (Locally Checkable Labeling). For a fixed \(\Delta\), a locally checkable labeling (LCL) problem \(\Pi\) is a graph problem that can be specified by a tuple \((\Sigma_{\mathrm{in}},\Sigma_{\mathrm{out}},r,C)\) such that
\(\Sigma_{\mathrm{in}}\) and \(\Sigma_{\mathrm{out}}\) are finite sets of labels;
\(r\) is an arbitrary positive integer, called the checkability radius* of \(\Pi\);*
\(C\) is the set of allowed local configurations, denoted by a finite set of tuples \((H = (V^H,E^H),x,\varphi_{\mathrm{in}}, \varphi_{\mathrm{out}})\), where:
\(H\) is a graph of degree at most \(\Delta\), \(x\) is a vertex of \(H\), and each vertex has distance at most \(r\) from \(x\) in \(H\);
\(\varphi_{\mathrm{in}}\) is a function from \(V^H\) to \(\Sigma_{\mathrm{in}}\), and \(\varphi_{\mathrm{out}}\) is a function from \(V^H\) to \(\Sigma_{\mathrm{out}}\).
An instance* of an LCL \(\Pi(\Sigma_{\mathrm{in}}, \Sigma_{\mathrm{out}}, r, C)\) is a graph \(G=(V,E)\) with \(n\) vertices and maximum degree \(\Delta\), and additionally an input labeling \(\phi_{\mathrm{in}}: V \to\Sigma_{\mathrm{in}}\). The graph \(G\) may not be connected. A solution to the instance \((G, \phi_{\mathrm{in}})\) is an output labeling \(\phi_{\mathrm{out}}: V \to \Sigma_{\mathrm{out}}\) such that for every vertex \(v \in V\), there exists \((H=(V^H,E^H), x, \varphi_{\mathrm{in}}, \varphi_{\mathrm{out}}) \in C\) and a bijection \(f\) between \(\Gamma_G^r(v)\) and \(V^H\) with all the following properties:*
\(f\) specifies a graph isomorphism between \(G[\Gamma_G^r(v)]\) and \(H\);
\(\forall u \in \Gamma_G^r(v)\), \(\phi_{\mathrm{in}}(u) = \varphi_{\mathrm{in}}(f(u))\) and \(\phi_{\mathrm{out}}(u) = \varphi_{\mathrm{out}}(f(u))\).
In the rest of the paper, instead of specifying the set of allowed local configurations \(C\) for an LCL explicitly, we will demonstrate a \(\mathsf{LOCAL}\) algorithm \(\mathcal{A}\) that collects the information for the \(r\)-hop neighborhood, including the graph structure, input labels, output labels and port numbers, but excluding the unique ID on each vertex, and checks whether the output labeling satisfies the local constraints for the LCL. This implicitly defines \(C\) as the set of local configurations that pass the check in \(\mathcal{A}\).
In the following, we formally define the models we consider in this paper, the randomized LCA and \(\mathsf{VOLUME}\) model.
Definition 2 (Randomized LCA). A randomized local computation algorithm (LCA) \(\mathcal{A}\) for an LCL is given access to a deterministic graph oracle \(\mathcal{O}^G\) for the input graph \(G\) and input labeling \(\phi_{\mathrm{in}}\), a tape \(r\) of random bits shared across queries, and local read-write computation memory independent across queries. When given a query vertex \(v\), \(\mathcal{A}\) must assign an output label for \(v\) using \(r\), \(\mathcal{O}^G\), and the knowledge of the size \(n\) of graph \(G\). The algorithm can access \(\mathcal{O}^G\) by giving the unique identifier of a vertex \(u\), and \(\mathcal{O}^G(u)\) will return the input label \(\phi_{\mathrm{in}}(u)\) along with its adjacency list and port number labeling in \(G\). The algorithm is said to solve* an LCL \(\Pi\) if for any instance \((G, \phi_{\mathrm{in}})\) of \(\Pi\), with probability at least \(1-1/n\) over the random tape \(r\), the algorithm generates an output label assignment to each vertex that forms a solution to the instance.*
Definition 3 (Randomized \(\mathsf{VOLUME}\)). A randomized \(\mathsf{VOLUME}\) algorithm \(\mathcal{A}\) for an LCL is given access to a deterministic graph oracle \(\mathcal{O}^G\) for the input graph \(G\), input labeling \(\phi_{\mathrm{in}}\), and an independent random string \(r_v\) for each vertex \(v\). The random strings are shared across queries. The algorithm is also equipped with local read-write computation memory independent across queries. When given a query vertex \(v\), \(\mathcal{A}\) must assign an output label for \(v\) using \(\mathcal{O}^G\) and the knowledge of the size \(n\) of graph \(G\). The algorithm can access \(\mathcal{O}^G\) by giving the unique identifier of a vertex \(u\), and \(\mathcal{O}^G(u)\) will return the input label \(\phi_{\mathrm{in}}(u)\), the random string \(r_u\), along with its adjacency list and port number labeling in \(G\), only when the following holds:
The algorithm is said to solve* an LCL \(\Pi\) if for any instance \((G, \phi_{\mathrm{in}})\) of \(\Pi\), with probability at least \(1-1/n\) with respect to the local randomness \(r_v\) for each vertex \(v\), the algorithm generates an output labeling assignment to each vertex that forms a solution to the instance.*
The complexities of randomized LCA and \(\mathsf{VOLUME}\) algorithms can be measured in several different ways. In this paper, we will use only the probe complexity, the maximum number of oracle accesses an algorithm uses to provide the output label for a single query, to measure an LCA or \(\mathsf{VOLUME}\) algorithm. One reason is that it simplifies the analysis and enables us to focus on the effect of limited knowledge on the input graph in the algorithm design. Furthermore, it turns out that all algorithms given in this paper can also be implemented with time and space complexities roughly a factor of \(O(\log n)\) larger than the probe complexities.
From the definition, we can see that a \(\mathsf{VOLUME}\) algorithm is always an LCA, formalized by the following observation, but it is not the case in the reverse. It is still open whether \(\mathsf{VOLUME}\) models and LCA are equivalent up to polynomial factors; see 6.2 for a related discussion.
If a randomized \(\mathsf{VOLUME}\) algorithm solves an LCL \(\Pi\) with probe complexity \(f(n)\) for some function \(f\), then there is a randomized LCA that solves \(\Pi\) with probe complexity \(O(f(n))\).
Proof. Let \(\mathcal{A}\) be the randomized \(\mathsf{VOLUME}\) algorithm. We construct an LCA \(\mathcal{B}\) that simulates \(\mathcal{A}\) on the same query vertex. The LCA uses its shared random tape to generate the local random strings used by the \(\mathsf{VOLUME}\) algorithm: for each vertex identifier \(u\), reserve an infinite subsequence of bits on the shared tape for \(r_u\). Since vertex identifiers come from a polynomial range in \(n\), this reservation can be fixed in advance as a deterministic function of the identifier to make sure that the randomness is independent for every vertex.
During the simulation, whenever \(\mathcal{A}\) probes a vertex \(u\), the LCA probes the same vertex through its graph oracle and additionally reads the block of random bits assigned to \(u\). The \(\mathsf{VOLUME}\) access rule only restricts which probes \(\mathcal{A}\) is allowed to make; an LCA can make all of these probes as well. Therefore, the transcript of \(\mathcal{B}\) has the same distribution as the transcript of \(\mathcal{A}\) on every query and every instance. In particular, the output labels form a feasible solution with the same success probability. The number of graph-oracle probes is exactly the number of probes made by \(\mathcal{A}\), so the probe complexity is \(O(f(n))\). ◻
The algorithms described in the rest of this paper will be Las Vegas, with a guarantee of success, and the number of probes will vary with randomness. However, the randomized \(\mathsf{VOLUME}\) model and randomized LCA are stated in Monte Carlo form, with a fixed probe budget and a small probability of failure. One can change the algorithm to Monte Carlo by running the algorithm with a fixed probing budget and output arbitrarily when the algorithm uses up its budget.
In this section, we construct LCLs \(\Pi_\mathsf{PTL}^k\) whose randomized probe complexities in both the LCA and \(\mathsf{VOLUME}\) models are \(\Theta(\log^k n)\) for every positive integer \(k\). Here, \(\mathsf{PTL}\) is an abbreviation of “path to leaf”.
Before defining the LCL, we first define an input labeling called “multi-level binary tree labeling” in 4 and define its associated local constraints in 5. The purpose of this input labeling is to “escape” from the case where the input graph is irregular: As we will show in 1, all vertices satisfying the local constraints for the multi-level binary tree labeling, along with their outgoing edges, form a pseudo-forest in which each vertex has out-degree zero or two.
Definition 4 (Multi-level binary tree labeling). Let \(G=(V,E)\) be a graph of maximum degree at most \(\Delta\), and let \(\mathcal{P}=[\Delta]\cup\{\perp\}\), where \(\perp\) is a special placeholder symbol. For a given positive integer \(k\), a level-\(k\) binary tree labeling* consists of a height labeling \(h\colon V\to[k]\) and the following four labels for each \(v\in V\): A parent \(\mathrm{P}(v)\in\mathcal{P}\), a left child \(\mathrm{LC}(v)\in\mathcal{P}\), a right child \(\mathrm{RC}(v)\in\mathcal{P}\), and a new-instance child \(\mathrm{NC}(v)\in\mathcal{P}\).*
To make the set of possible inputs at each vertex constant, \(\mathrm{P}(v),\mathrm{LC}(v),\mathrm{RC}(v)\), and \(\mathrm{NC}(v)\) are given by the port number rather than the corresponding vertex ID in 4. However, to keep notation light, in the rest of this paper, we will abuse the notation a bit and use \(\mathrm{P}(v), \mathrm{LC}(v),\mathrm{RC}(v),\mathrm{NC}(v)\) to also denote the corresponding neighbors reached through that port. If a port is \(\perp\), then the corresponding vertex reached through that port is defined as \(\perp\).
Definition 5. For a level-\(k\) binary tree labeling of \(G\), a vertex \(v\) is called consistent* if all the following conditions hold, and otherwise it is called inconsistent:*
The non-\(\perp\) ports among \(\mathrm{P}(v),\mathrm{LC}(v),\mathrm{RC}(v),\mathrm{NC}(v)\) are pairwise distinct.
For \(w\in\{\mathrm{LC}(v),\mathrm{RC}(v),\mathrm{NC}(v)\} \backslash \{\perp\}\), \(\mathrm{P}(w) = v\).
Either both \(\mathrm{LC}(v)\) and \(\mathrm{RC}(v)\) are \(\perp\), or neither of them is \(\perp\).
For \(w\in\{\mathrm{LC}(v),\mathrm{RC}(v)\} \backslash \{\perp\}\), \(h(w)=h(v)\).
If \(\mathrm{NC}(v)\ne\perp\), then \(h(\mathrm{NC}(v))=h(v)-1\). In particular, if \(h(v)=1\), then \(\mathrm{NC}(v)=\perp\).
We further use condition 3 to differentiate between consistent vertices: A consistent vertex is internal* if \(\mathrm{LC}(v),\mathrm{RC}(v)\ne\perp\), and is a leaf if \(\mathrm{LC}(v)=\mathrm{RC}(v)=\perp\). For a consistent internal vertex \(v\), define \(\operatorname{child}(v,\mathsf{L})=\mathrm{LC}(v)\) and \(\operatorname{child}(v,\mathsf{R})=\mathrm{RC}(v)\).*
Lemma 1. For a graph \(G\) and a level-\(k\) binary tree labeling, define a directed graph \(G' = (V,E')\), where \((u \to v) \in E'\) when \(u\) is a consistent internal vertex and \(v \in \{\mathrm{LC}(u), \mathrm{RC}(u)\}\). Then, each vertex in \(G'\) has in-degree at most one and out-degree either zero or two. As a result, \(G'\) is a pseudo-forest where each weak component has at most one directed cycle.
Proof. For each vertex \(v\), from constraint 2 of 5, its only possible in-degree in \(G'\) is from \(\mathrm{P}(v)\) if \(\mathrm{P}(v) \ne \perp\). From constraint 3 of 5, each consistent internal vertex in \(G'\) has out-degree two, while inconsistent vertices and consistent leaves have no out-neighbor. This concludes the statement. ◻
With 4 5, we are ready to describe the LCL \(\Pi_\mathsf{PTL}^k\).
Definition 6 (\(\Pi_\mathsf{PTL}^k\)). The problem \(\Pi_\mathsf{PTL}^k\) is defined in the following way:
Input: A graph \(G\), a level-\(k\) binary tree labeling, and \(b_{\mathrm{in}}(v)\in\{0,1\}\) for each \(v\in V\).
Output: \(d(v)\in\{\mathsf{L},\mathsf{R},\perp\}\) and \(b_{\mathrm{out}}(v)\in\{0,1\}\) for each \(v\in V\).
Constraint: For each vertex \(v\in V\), if \(v\) is inconsistent, then \((d(v),b_{\mathrm{out}}(v))=(\perp,0)\); Otherwise, \(d(v) \in \{\mathsf{L},\mathsf{R}\}\) for internal vertices \(v\), \(d(v) = \perp\) for leaves, and we have the following equation for \(b_{\mathrm{out}}(v)\): \[b_{\mathrm{out}}(v)=b_{\mathrm{in}}(v)\oplus b'(v) \oplus b''(v).\label{eq:log-lcl-def}\qquad{(1)}\] Here \[\begin{gather} b'(v)= \begin{cases} 0, & \mathrm{NC}(v)=\perp\\ b_{\mathrm{out}}(\mathrm{NC}(v)), & \mathrm{NC}(v)\ne\perp \end{cases}\label{eq:log-b39-def} \\ b''(v)= \begin{cases} 0, & \mathrm{LC}(v)=\mathrm{RC}(v) =\perp\\ b_{\mathrm{out}}(\operatorname{child}(v,d(v))), & \mathrm{otherwise} \end{cases}\label{eq:log-b3939-def} \end{gather}\] {#eq: sublabel=eq:eq:log-b39-def,eq:eq:log-b3939-def}
Lemma 2. \(\Pi_\mathsf{PTL}^k\) is an LCL.
Proof. From the definition, since the maximum degree \(\Delta\) and the parameter \(k\) are constant, we know that the set of possible input and output labels has a constant size. Now we show that there is a \(\mathsf{LOCAL}\) algorithm of radius one to check whether the local constraint is satisfied for each vertex. The consistency conditions in 5 inspect only \(v\), its incident ports, and the labels of its neighbors. As a result, we can determine whether the current vertex is consistent, internal, or a leaf using input labels from the one-hop neighborhood. After that, constraints for the output label only involve the one-hop neighborhood. Hence, every constraint is checkable in radius one. ◻
In the rest of the section, we prove the following upper and lower bound results, which together imply 1.
Lemma 3. There is a randomized \(\mathsf{VOLUME}\) algorithm that solves \(\Pi_\mathsf{PTL}^k\) in all bounded-degree graphs using \(O(\log^k n)\) probes.
Lemma 4. Any randomized LCA that solves \(\Pi_\mathsf{PTL}^k\) uses \(\Omega(\log^k n)\) probes even when we restrict the instance to bounded-degree trees.
Proof of 1. From [obs:vol-weaker-than-lca], the upper bound result 3 can be generalized from \(\mathsf{VOLUME}\) to LCA, while the lower bound result 4 can be generalized from LCA to \(\mathsf{VOLUME}\). As a consequence, in both models, we have a \(\Theta(\log^k n)\) randomized algorithm for \(\Pi_\mathsf{PTL}^k\) on bounded-degree graphs and a matching lower bound for bounded-degree trees. ◻
In this part, we prove 3, providing a randomized \(\mathsf{VOLUME}\) algorithm for \(\Pi_\mathsf{PTL}^k\) on bounded-degree graphs with probe complexity \(O(\log^k n)\).
To begin with, we provide an equivalent formulation of the constraints in \(\Pi_\mathsf{PTL}^k\). Arbitrarily fix \(d(v)\) for each consistent internal vertex \(v\). For some consistent vertex \(u\), apply \(u \leftarrow \operatorname{child}(u, d(u))\) multiple times to generate a path, until either reaching a leaf, an inconsistent vertex, or returning to where it starts. The path is always a path in the graph \(G'\) defined in 1, so according to 1, the procedure terminates in finite steps no matter how the \(d\) output label is assigned. This procedure generates either a path from \(u\) to some vertex \(w\), or a simple cycle passing \(u\). We will demonstrate the way to get rid of cycles, so let us focus on the other case. Applying ?? for each vertex along the path, we can conclude that the value of \(b_{\mathrm{out}}(u)\) is the xor of all \(b_{\mathrm{in}}\) values along the path and all \(b_{\mathrm{out}}\) values of the new-instance children along the path.
According to constraints 4 and 5 in 5, all vertices along the path have the same height, while their new-instance children have height \(h(v)-1\). If \(d(v)\) is assigned in such a way that the path is of length \(O(\log n)\), then one can recurse on all \(O(\log n)\) new-instance children to get their \(b_{\mathrm{out}}\) value, and the recursion decreases the vertex height by one. This means that, when all possible paths generated by the procedure above have length \(O(\log n)\), we get a \(\mathsf{VOLUME}\) algorithm with probe complexity \(O(\log^k n)\).
This is exactly the strategy of our randomized \(\mathsf{VOLUME}\) algorithm given in 6, where the output pair \((d,z)\) of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolvePTL}}}\nolimits\else\textrm{\mathrm{\small SolvePTL}}\fi^k(v)\) will be the final value of \((d(v), b_{\mathrm{out}}(v))\). We assume that each vertex has a uniform random direction \(\rho(v)\in\{\mathsf{L},\mathsf{R}\}\), and recall that in the \(\mathsf{VOLUME}\) model, the local random direction \(\rho(v)\) is fixed for each vertex \(v\) and shared across queries.
The algorithm first assigns \((\perp, 0)\) for inconsistent vertices. For other vertices, it calls \(\ifmmode\mathop{\text{\normalfont\mathrm{\small WalkToLeaf}}}\nolimits\else\textrm{\mathrm{\small WalkToLeaf}}\fi(v)\), described in 5, to find the path from \(v\) to either an inconsistent vertex or a leaf using only \(\mathrm{LC}\) and \(\mathrm{RC}\) ports. The following observation is straightforward from the algorithm description.
For any consistent vertex \(v\), the path \(\pi_v\) generated by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small WalkToLeaf}}}\nolimits\else\textrm{\mathrm{\small WalkToLeaf}}\fi(v)\) is a path in the graph \(G'\) defined in 1.
5 treats the randomness \(\rho(v)\) as the initial assignment for \(d(v)\) and traces the path \(\pi_v\) by following \(\rho\). If the path ends at a vertex for which the termination condition holds, then we assign \(d(v)\) with \(\rho(v)\) in 6. For the other case when \(\rho\) directs \(v\) into a cycle, corresponding to the branch in line [line:alg-log-walk-in-cycle], 5 will abandon all visited vertices and use the direction other than \(\rho(v)\) to restart a walk. The other direction is guaranteed to arrive at a leaf or an inconsistent vertex, as otherwise we can find some vertex with in-degree two in the graph \(G'\) defined in 1. In this case, we assign \(d(v)\) to that other direction. After getting the path \(\pi_v\), 6 assigns \(b_{\mathrm{out}}(v)\) by what we have discussed above: gathers all \(b_{\mathrm{in}}\) values in \(\pi_v\), and gets all \(b_{\mathrm{out}}\) values by recursion.
We first show that 5 behaves correctly within \(O(\log n)\) probes with high probability, which leads to the \(O(\log^k n)\) probe complexity of 6.
Lemma 5. For each consistent vertex \(v \in G\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small WalkToLeaf}}}\nolimits\else\textrm{\mathrm{\small WalkToLeaf}}\fi(v)\) generates a path \(\pi_v\) from \(v\) to a leaf or an inconsistent vertex within \(O(\log n)\) probes with probability \(1-1/n^3\). As a result, \(|\pi_v| = O(\log n)\) with probability \(1-1/n^3\).
Proof. By [obs:alg-log-walk-in-G39], all vertices visited by 5 lie on a directed walk in the graph \(G'\) from 1. We first record a simple consequence of the in-degree bound in 1. Fix a vertex \(s\) and expose a walk that starts at \(s\) and, whenever it is at a consistent internal vertex, follows an independently chosen random direction in \(\{\mathsf{L},\mathsf{R}\}\). Before the walk reaches a leaf, reaches an inconsistent vertex, or returns to \(s\), two different direction sequences of length \(t\) must end at two different vertices. Indeed, if two such prefixes first meet at a vertex other than \(s\), then that vertex has two distinct in-neighbors in \(G'\), contradicting 1. Hence, for \(t\) steps, the number of direction sequences that keep the walk “alive”, meaning that all vertices traveled by the walk are consistent internal vertices, is at most \(n\), and the probability that this happens is at most \(n2^{-t}\).
Choose a sufficiently large constant \(C\). Applying the previous bound with \(t=C\log n\) shows that the walk followed by 5 lasts more than \(C\log n\) steps with probability at most \(1/(2n^3)\) before the walk arrives at a leaf, arrives at an inconsistent vertex, or finds a cycle and triggers the branch in line [line:alg-log-walk-in-cycle]. If this walk reaches a leaf or an inconsistent vertex, the algorithm stops. Otherwise, the first walk has returned to \(v\), so it has found the unique directed cycle through \(v\). The algorithm then restarts from \(v\) using the other child of \(v\) as the first step. By 1, this second walk cannot return to \(v\): the predecessor of \(v\) on the first cycle already accounts for the only possible in-neighbor of \(v\) in \(G'\). It also cannot enter a directed cycle not containing \(v\), because entering such a cycle from outside would give the entry vertex two distinct in-neighbors in \(G'\). Therefore, the second walk must end at a leaf or an inconsistent vertex.
The same counting argument, now with the first direction fixed and all later directions random, shows that this second walk has length more than \(C\log n\) with probability at most \(1/(2n^3)\) after increasing \(C\) if necessary. By a union bound, with probability at least \(1-1/n^3\), both walks considered by the algorithm have length \(O(\log n)\). The algorithm probes only the vertices on these walks, up to a constant number of additional oracle accesses needed to check consistency and read the relevant ports. Thus 5 uses \(O(\log n)\) probes and returns a path \(\pi_v\) of length \(O(\log n)\) with probability at least \(1-1/n^3\). ◻
Corollary 1. For each \(v \in G\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolvePTL}}}\nolimits\else\textrm{\mathrm{\small SolvePTL}}\fi^k(v)\) probes \(O(\log^k n)\) vertices with probability \(1-1/n^2\).
Proof. From 5 and union bound over all vertices, with probability \(1-1/n^2\), for any consistent vertex \(v\) in the instance, 5 generates a path \(\pi_v\) of length at most \(C \log n\) using at most \(C \log n\) probes for some constant \(C\). In the following, we assume that the event happens.
Let \(T(n,h^\star)\) be the maximum possible number of probes for 6 to generate \((d(v), b_{\mathrm{out}}(v))\) for a consistent vertex \(v\) with \(h(v) = h^\star\) in an \(n\)-vertex instance. For the base case \(T(n,1)\), from constraint 5 in 5, none of the vertices in \(\pi_v\) have a new-instance child, so there is no recursion. In conclusion, the number of probes in 6 is bounded by \(C \log n\).
For \(h^\star \ge 2\), apart from the call to 5, 6 recurses on \(\mathrm{NC}(u)\) for each \(u \in \pi_v\). Constraints 4 and 5 of 5 tell us that all vertices in \(\pi_v\) have height \(h^\star\), while all their new-instance children have height \(h^\star - 1\). As a consequence, we have the following recurrence: \[T(n,h^\star)\le C\log n\cdot T(n,h^\star - 1)+C\log n,\label{eq:log-recurse}\tag{1}\] with \(T(n,1)\le C\log n\). As \(C\) is constant with respect to \(n\), solving 1 gives \(T(n,h^\star)=O(\log^{h^\star} n)\). Finally, since the maximum height of a vertex is \(k\) in \(\Pi_\mathsf{PTL}^k\), the probe complexity of 6 is \(O(\log^k n)\). ◻
Now we show that 6 assigns labels satisfying all constraints in \(\Pi_\mathsf{PTL}^k\).
Lemma 6. If \(\pi_v = (v,w,p_1,p_2,\dots,p_\ell)\) is the output of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small WalkToLeaf}}}\nolimits\else\textrm{\mathrm{\small WalkToLeaf}}\fi(v)\) for a consistent internal vertex \(v\) for some \(\ell \ge 0\) and \(w\) is consistent, then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small WalkToLeaf}}}\nolimits\else\textrm{\mathrm{\small WalkToLeaf}}\fi(w)\) outputs \(\pi_w = (w, p_1,p_2,\dots, p_\ell)\).
Proof. Let \(a\) be the first direction taken by \(\pi_v\), so \(w=\operatorname{child}(v,a)\). After this first step, 5 follows the random direction \(\rho(u)\) at every subsequent consistent internal vertex \(u\) on \(\pi_v\). This is true whether the first direction is \(a=\rho(v)\) or the algorithm first discovers a cycle through \(v\) and then restarts with the direction \(a\ne\rho(v)\).
If \(w\) is a leaf, then running 5 on \(w\) immediately returns \((w)\), which is the desired suffix. Otherwise, \(w\) is a consistent internal vertex. Running 5 from \(w\) starts by following \(\rho(w)\), and then follows the same random directions as the run from \(v\) did after reaching \(w\) due to shared randomness across queries. Thus, the two executions trace the same directed walk unless the execution from \(w\) returns to \(w\) and triggers the branch in line [line:alg-log-walk-in-cycle]. This cannot happen along the suffix of \(\pi_v\): if some later vertex on the suffix pointed back to \(w\), then \(w\) would have two distinct in-neighbors in \(G'\), namely \(v\) and that later vertex, contradicting 1. Hence, the execution from \(w\) will never enter the branch in line [line:alg-log-walk-in-cycle], and it stops exactly at the same terminal leaf or inconsistent vertex as the execution from \(v\). Therefore its output is \(\pi_w=(w,p_1,p_2,\dots,p_\ell)\). ◻
Lemma 7. \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolvePTL}}}\nolimits\else\textrm{\mathrm{\small SolvePTL}}\fi^k\) generates labels satisfying all constraints in \(\Pi_\mathsf{PTL}^k\).
Proof. We distinguish the different types of vertices to prove the statement. Recall the definition of \(b'\) and \(b''\) in ?? ?? .
For inconsistent vertices, the algorithm assigns \((\perp, 0)\) to it, satisfying the constraint.
For a leaf \(v\), \(d(v)\) is assigned \(\perp\), \(b''(v) = 0\) and \(\pi_v = (v)\). 6 collects \(b_{\mathrm{in}}(v)\) and also \(b_{\mathrm{out}}(\mathrm{NC}(v))\) when \(\mathrm{NC}(v)\) exists, so \(b_{\mathrm{out}}(v) = b_{\mathrm{in}}(v) \oplus b'(v)\), which is ?? with \(b''(v) = 0\).
For an internal vertex \(v\), define \(w = \operatorname{child}(v,d(v))\). When \(w\) is inconsistent, we know that \(\pi_v= (v,w)\), and \((d(w), b_{\mathrm{out}}(w)) = (\perp, 0)\), meaning that \(b''(v) = 0\) and \(b_{\mathrm{out}}(v) = b_{\mathrm{in}}(v) \oplus b'(v)\); Otherwise, from 6, \(\pi_w\) is a suffix of \(\pi_v\). Compare the processes of computing the output bit between \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolvePTL}}}\nolimits\else\textrm{\mathrm{\small SolvePTL}}\fi^k(v)\) and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolvePTL}}}\nolimits\else\textrm{\mathrm{\small SolvePTL}}\fi^k(w)\), the only difference is that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolvePTL}}}\nolimits\else\textrm{\mathrm{\small SolvePTL}}\fi^k(v)\) additionally collects \(b_{\mathrm{in}}(v)\) and \(b_{\mathrm{out}}(\mathrm{NC}(v))\) if \(\mathrm{NC}(v)\) exists. As a result, \(b_{\mathrm{out}}(v) = b_{\mathrm{out}}(w) \oplus b_{\mathrm{in}}(v) \oplus b'(v)\), which is exactly ?? .
◻
Proof of 3. The Las Vegas algorithm given by 6 can be converted to the required Monte Carlo guarantee by [rem:las-vegas-to-monte-carlo]. The algorithm succeeds with high probability within \(O(\log^k n)\) probes according to 1 7. ◻
In this part, we prove the lower bound for \(\Pi_\mathsf{PTL}^k\) for LCAs via the following lemma.
Lemma 8. For any positive integer \(k\) and for every sufficiently large \(n\), there is a set \(\mathcal{S}_{k,n}\) of \(\Pi_\mathsf{PTL}^k\) instances of size at most \(n\) with the following properties:
(i) All instances in \(\mathcal{S}_{k, n}\) have the same underlying graph and binary tree labeling, in which the graph is a tree, every vertex is consistent, and there is a unique root vertex \(x\) with \(h(x) = k\) and \(\mathrm{P}(x) = \perp\);
(ii) For any instance \(I\) in \(\mathcal{S}_{k,n}\), there exists \(b_I \in \{0,1\}\) such that any solution satisfying all \(\Pi_\mathsf{PTL}^k\) constraints for \(I\) must have \(b_{\mathrm{out}}(x) = b_I\). Define \(\mathcal{S}_{k,n}^B\) as the subset of \(\mathcal{S}_{k,n}\) with \(b_I = B\);
(iii) For any set \(V_0\) of vertices of size \(o(\log^k n)\), there exists a bijection \(f_{V_0}\) between \(\mathcal{S}_{k,n}^0\) and \(\mathcal{S}_{k,n}^1\), where for each \(I \in \mathcal{S}_{k,n}\) and \(u \in V_0\), \(b_{\mathrm{in}}(u)\) is the same between \(I\) and \(f_{V_0}(I)\).
We first show how 8 implies 4.
Proof of 4. Suppose for contradiction that there is a randomized LCA that solves \(\Pi_\mathsf{PTL}^k\) with \(o(\log^k n)\) probes and succeeds in every instance over bounded-degree trees of size at most \(n\) with probability larger than \(1/2\). According to Yao’s minimax principle, for any distribution \(\mathcal{D}\) over such instances, there is a deterministic LCA \(\mathcal{A}\) with the same probe complexity that succeeds with probability larger than \(1/2\) over \(\mathcal{D}\).
Now set \(\mathcal{D}\) to be the uniform distribution over \(\mathcal{S}_{k,n}\). For any instance \(I \in \mathcal{S}_{k,n}\), define \(V_0\) as the set of vertices probed by \(\mathcal{A}(x)\), we have \(|V_0| = o(\log^k n)\). According to condition (iii) in 8, there exists \(I'\) with \(b_I \ne b_I'\), but all inputs in \(V_0\) are the same across two instances. As \(\mathcal{A}\) is a deterministic algorithm, the transcript of \(\mathcal{A}(x)\) on \(I\) and \(I'\) will be exactly the same, so \(\mathcal{A}\) will label \(x\) the same in both instances, and one of the two solutions must be wrong according to condition (ii). Since they have the same probability weight in \(\mathcal{D}\), \(\mathcal{A}\) cannot succeed with probability larger than \(1/2\), a contradiction. ◻
To construct the set of instances, we first provide the construction for the underlying graph and binary tree labeling. The construction consists of \(k\) layers of perfect binary trees.
Definition 7. For a positive integer sequence \((a_1,a_2,\dots,a_\ell)\), define the graph \(G_{(a_1,a_2,\dots,a_\ell)}\) along with its binary tree labeling recursively in the following way:
For the base case, \(G_{(1)}\) consists of only one root vertex \(x\) with \(h(x) = 1\).
\(G_{(a_1,a_2,\dots,a_\ell)}\) consists of a vertex \(x\) with \(h(x) = \ell\) and the following ports for \(x\):
If \(\ell \ne 1\), attach the graph and labeling \(G_{(a_2,\dots,a_\ell)}\) to \(\mathrm{NC}(x)\), otherwise \(\mathrm{NC}(x) = \perp\);
If \(a_1 \ne 1\), attach two independent copies of \(G_{(a_1-1,a_2,\dots,a_\ell)}\) to \(\mathrm{LC}(x)\) and \(\mathrm{RC}(x)\) respectively, otherwise \(\mathrm{LC}(x) = \mathrm{RC}(x) = \perp\).
For “attaching a graph to a port”, we mean creating a copy of the graph and making the port point to the root of the graph. Finally, we set up \(\mathrm{P}\) ports to make every vertex consistent. It is easy to check that there is a unique way to do so.
The following observation can be proved by a standard induction argument.
\(G_{(a_1,\dots,a_\ell)}\) satisfies the following property:
\(G_{(a_1,\dots,a_\ell)}\) is a tree with \(\Theta(\prod_{i=1}^\ell 2^{a_i})\) vertices and maximum degree 4;
With respect to the binary tree labeling, all vertices in the graph are consistent;
The maximum height in the binary tree labeling is \(\ell\).
Now we construct sets \(\mathcal{S}^0_{(a_1,a_2,\dots,a_\ell)}\) and \(\mathcal{S}^1_{(a_1,a_2,\dots,a_\ell)}\) of \(\Pi_\mathsf{PTL}^\ell\) instances for each sequence \(\{a_1,\dots,a_\ell\}\), in which all instances have \(G_{\{a_1,\dots,a_\ell\}}\) as the underlying graph and binary tree labeling. The only difference between these instances lies in \(b_{\mathrm{in}}\) inputs for each vertex, and we construct the inputs also recursively, in the following way:
For the base case, \(\mathcal{S}_{(1)}^B\) contains the only instance with \(b_{\mathrm{in}}(x) = B\) for \(B \in \{0,1\}\);
For the general case, \(\mathcal{S}_{(a_1,a_2,\dots,a_\ell)}^B\) contains all instances that can be generated by the following procedure:
If \(\ell \ne 1\), \(\mathrm{NC}(x)\) has a copy of \(G_{(a_2,\dots,a_\ell)}\) attached. Arbitrarily pick \(b' \in \{0,1\}\) and a \(b_{\mathrm{in}}\) assignment in \(\mathcal{S}_{(a_2,\dots,a_\ell)}^{b'}\) to assign \(b_{\mathrm{in}}\) values for the subtree rooted at \(\mathrm{NC}(x)\). If \(\ell = 1\), set \(b'\) to be zero.
If \(a_1 \ne 1\), \(\mathrm{LC}(x)\) and \(\mathrm{RC}(x)\) both have a copy of \(G_{(a_1-1,a_2,\dots,a_\ell)}\) attached. Arbitrarily pick \(b'' \in \{0,1\}\) and two \(b_{\mathrm{in}}\) assignments in \(\mathcal{S}_{(a_1-1,a_2,\dots,a_\ell)}^{b''}\) to assign \(b_{\mathrm{in}}\) values for the subtrees rooted at \(\mathrm{LC}(x)\) and \(\mathrm{RC}(x)\), respectively. Notice that two copies use the same bit \(b''\) but possibly different \(b_{\mathrm{in}}\) assignments. If \(a_1 = 1\), set \(b''\) to be zero.
Finally, assign \(b_{\mathrm{in}}(x)\) with \(B \oplus b' \oplus b''\).
Finally, \(\mathcal{S}_{\{a_1,\dots,a_\ell\}}\) is the union of \(\mathcal{S}^0_{(a_1,a_2,\dots,a_\ell)}\) and \(\mathcal{S}^1_{(a_1,a_2,\dots,a_\ell)}\).
Lemma 9. For any positive integer sequence \((a_1,a_2,\dots,a_\ell)\), the sets \(\mathcal{S}^0_{(a_1,a_2,\dots,a_\ell)}\) and \(\mathcal{S}^1_{(a_1,a_2,\dots,a_\ell)}\) satisfy the following:
(i) All instances in \(\mathcal{S}_{(a_1,a_2,\dots,a_\ell)}\) have the same underlying graph and binary tree labeling, in which the graph is a tree, every vertex is consistent, and there is a unique root vertex \(x\) with \(h(x) = \ell\) and \(\mathrm{P}(x) = \perp\);
(ii) For \(B\in \{0,1\}\) and any instance \(I\) in \(\mathcal{S}_{(a_1,a_2,\dots,a_\ell)}^B\), any solution satisfying all \(\Pi_\mathsf{PTL}^\ell\) constraints for \(I\) satisfies \(b_{\mathrm{out}}(x) = B\);
(iii) For any set \(V_0\) of vertices of size less than \(\prod_{i=1}^\ell a_i\), there exists a bijection \(f_{V_0}\) between \(\mathcal{S}_{(a_1,a_2,\dots,a_\ell)}^0\) and \(\mathcal{S}_{(a_1,a_2,\dots,a_\ell)}^1\), where for each \(I \in \mathcal{S}_{(a_1,a_2,\dots,a_\ell)}\) and \(u \in V_0\), \(b_{\mathrm{in}}(u)\) is the same between \(I\) and \(f_{V_0}(I)\).
Proof. We prove the lemma by induction on \(\sum_{i=1}^\ell a_i\). In the base case, the sequence is \((1)\), and condition (i) is trivial. The graph consists only of the root \(x\), and \(\mathcal{S}_{(1)}^B\) fixes \(b_{\mathrm{in}}(x)=B\). Hence every legal solution has \(b_{\mathrm{out}}(x)=B\) by ?? , proving condition (ii). Finally, in condition (iii), the set \(V_0\) is required to have size less than one, so \(V_0=\emptyset\), and the bijection between \(\mathcal{S}_{(1)}^0\) and \(\mathcal{S}_{(1)}^1\) is trivial.
Now consider a sequence \(A=\{a_1,\dots,a_\ell\}\) with \(\sum_{i=1}^\ell a_i>1\), and let \(x\) be the root of \(G_A\). Condition (i) follows from the construction of \(G_A\) and [obs:log-lower-bound-construction-property].
To prove condition (ii), fix \(B\in\{0,1\}\) and an instance \(I\in\mathcal{S}_A^B\). Let \(b'\) and \(b''\) be the auxiliary bits used to assign \(b_{\mathrm{in}}\) inputs for \(I\). If \(\mathrm{NC}(x)\ne\perp\), the \(b_{\mathrm{in}}\) input is assigned according to some instance in \(\mathcal{S}_{(a_2,\dots,a_\ell)}^{b'}\), so by the induction hypothesis applied to the subtree rooted at \(\mathrm{NC}(x)\), every solution of \(I\) has \(b_{\mathrm{out}}(\mathrm{NC}(x))=b'\). This means that the \(b'(x)\) value defined in ?? always equals the auxiliary bit \(b'\). When \(\ell = 1\), we also have \(b'(x) = 0 = b'\).
Similarly, if \(x\) is internal and \(w=\operatorname{child}(x,d(x))\), then \(w\) is the root of either the left or right copy of \(G_{(a_1-1,a_2,\dots,a_\ell)}\), and both copies have \(b_{\mathrm{in}}\) input generated from some instance in \(\mathcal{S}_{(a_1-1,a_2,\dots,a_\ell)}^{b''}\). By induction, every solution of \(I\) has \(b_{\mathrm{out}}(w)=b''\), so the \(b''(x)\) value in ?? always equals to \(b''\), too. When \(a_1 = 1\), we also have \(b''(x) = 0 = b''\).
In sum, we have \(b'(x) = b'\) and \(b''(x) = b''\). Since \(b_{\mathrm{in}}(x) = B \oplus b' \oplus b''\), ?? gives \(b_{\mathrm{out}}(x) = B\), implying (ii).
For condition (iii), fix a set \(V_0\) of size less than \(\prod_{i=1}^\ell a_i\). If \(x\notin V_0\), the bijection \(f_{V_0}\) can simply flip \(b_{\mathrm{in}}(x)\), so we suppose \(x\in V_0\). Let \(V_{\mathrm{NC}}\) be the intersection of \(V_0\) with the subtree rooted at \(\mathrm{NC}(x)\) when it exists, and \(V_{\mathrm{NC}} = \varnothing\) if \(\mathrm{NC}(x) = \perp\). Similarly define \(V_{\mathrm{LC}}\) and \(V_{\mathrm{RC}}\).
If \(\ell>1\) and \(|V_{\mathrm{NC}}|<\prod_{i=2}^\ell a_i\), applying the induction hypothesis to the subtree rooted at \(\mathrm{NC}(x)\), there is a bijection \(f_{\mathrm{NC}}\) between \(\mathcal{S}_{\{a_2,a_3,\dots,a_\ell\}}^0\) and \(\mathcal{S}_{\{a_2,a_3,\dots,a_\ell\}}^1\) that preserves the input for vertices in \(V_{\mathrm{NC}}\). Now we define the bijection \(f_{V_0}\) in the following way: For each instance \(I\), we apply the bijection \(f_{\mathrm{NC}}\) to the subtree rooted at \(\mathrm{NC}(x)\), and keep other inputs unchanged. From the induction hypothesis, \(f_{V_0}\) is a map that preserves inputs among \(V_0\). Finally, following ?? , applying \(f_{V_0}\) changes \(b'(x)\), while \(b''(x)\) and \(b_{\mathrm{in}}(x)\) are unchanged, so \(b_{\mathrm{out}}(x)\) is flipped, showing that \(f_{V_0}\) is a bijection between \(\mathcal{S}_A^0\) and \(\mathcal{S}_A^1\).
Consider the remaining case, where either \(\ell=1\), or \(|V_\mathrm{NC}| \ge \prod_{i=2}^\ell a_i\). Since \(x\in V_0\) and \(|V_0|<a_1\prod_{i=2}^\ell a_i\), we have \[|V_{\mathrm{LC}} \cup V_{\mathrm{RC}}| = |V_0 \backslash (\{x\} \cup V_{\mathrm{NC}})| = |V_0| - 1 - |V_{\mathrm{NC}}| < \prod_{i=1}^\ell a_i - 1 - \prod_{i=2}^\ell a_i < (a_1 - 1) \prod_{i=2}^\ell a_i.\] Apply the induction hypothesis to the subtrees rooted at \(\mathrm{LC}(x)\) and \(\mathrm{RC}(x)\), we know there are bijections \(f_\mathrm{LC}, f_\mathrm{RC}\) between \(\mathcal{S}_{(a_1-1,a_2,\dots,a_\ell)}^0\) and \(\mathcal{S}_{(a_1-1,a_2,\dots,a_\ell)}^1\) which preserve the input among \(V_{\mathrm{LC}}\) and \(V_{\mathrm{RC}}\), respectively. For the bijection \(f_{V_0}\) between \(\mathcal{S}_A^0\) and \(\mathcal{S}_A^1\), we apply \(f_{\mathrm{LC}}\) to the subtree rooted at \(\mathrm{LC}(x)\), apply \(f_{\mathrm{RC}}\) to the subtree rooted at \(\mathrm{RC}(x)\), and keep other inputs unchanged. From the induction hypothesis, \(f_{V_0}\) preserves inputs among \(V_0\). Finally, from ?? , applying \(f_{V_0}\) changes \(b''(x)\) regardless of the choice of \(d(x)\), while \(b'(x)\) and \(b_{\mathrm{in}}(x)\) remain unchanged, so \(b_{\mathrm{out}}(x)\) is flipped, showing that \(f_{V_0}\) is a bijection between \(\mathcal{S}_A^0\) and \(\mathcal{S}_A^1\). ◻
Proof of 8. Recall that \(k\) is a constant. Let \(q = \Theta(\log n)\) and set \(\mathcal{S}_{k,n}\) to be \(\mathcal{S}_{\{q,q,\dots,q\}}\) where the sequence has length \(k\). According to [obs:log-lower-bound-construction-property], the graph has size \(\Theta(2^{qk}) = n^{\Theta(1)}\), and the size is less than \(n\) when the constant on \(q\) is small enough. We have \(q^k=\Theta(\log^k n)\) and all three conditions in 8 follow from 9. ◻
In this section, we provide LCL constructions whose randomized \(\mathsf{VOLUME}\) and LCA complexity is \(\tilde{\Theta}(n^x)\) for any \(x \in \mathbb{Q} \cap (0,1]\).
In this section, our construction is parameterized by an ordered binary tree \(T\). For an ordered binary tree, we mean that the tree is rooted, and we distinguish the left and right children of a vertex. In the following, we provide basic notations around ordered binary trees.
Define the root of an ordered binary tree \(T\) as \(r_T\) and the subtree of a vertex \(v \in T\) as \(T_v\). For each vertex \(v\), the left child of a vertex \(v \in T\) is denoted as \(\mathrm{LC}_T(v)\), while the right child is denoted as \(\mathrm{RC}_T(v)\). When the vertex does not have a left child, denote \(\mathrm{LC}_T(v) = \perp\), and similarly for the right child. The parent of the vertex \(v\) is denoted as \(\mathrm{P}_T(v)\), while \(\mathrm{P}_T(r_T)\) is defined as \(\perp\). For notation simplicity, we define \(\mathrm{LC}_T(\perp) = \mathrm{RC}_T(\perp) = \mathrm{P}_T(\perp) = \perp\).
To avoid confusion between \(\mathrm{LC}_T, \mathrm{RC}_T\) and \(\mathrm{P}_T\) notation in an ordered binary tree and \(\mathrm{LC}, \mathrm{RC}, \mathrm{P}\) ports in the LCL (See 4 and 9), we will never omit subscript \(T\) on any notation related to ordered binary trees, such as \(\mathrm{LC}_T, \mathrm{RC}_T, \mathrm{P}_T\) and \(r_T\).
Define \(T_L\) and \(T_R\) as the left and right subtrees of \(r_T\) in \(T\). Denote the unique ordered binary tree with no vertex as \(\perp\), and the unique ordered binary tree with only one vertex as \(\bullet\). We define \(r_\perp = \perp\).
Now we introduce an important definition in this section, the value of an ordered binary tree.
Definition 8 (Value). The value* of an ordered binary tree \(T\) is defined recursively as follow: \[\operatorname{val}(T) = \begin{cases} 0, & T = \perp \\ 1, & T = \bullet, \\ \frac{\operatorname{val}(T_R)}{1 + \operatorname{val}(T_R) - \operatorname{val}(T_L)}, & \text{Otherwise}. \end{cases} \label{eq:value-recurrence}\tag{2}\] *
We say an ordered binary tree \(T\) is good, if for every vertex \(v \in T\) that is not a leaf, its left subtree has a value strictly smaller than that of its right subtree. In the following, we will only focus on good ordered binary trees. The following observation can be easily proved via induction.
\(\operatorname{val}(T)\) is always a rational value in \((0,1]\) for any nonempty good ordered binary tree \(T\).
The main theorem we will prove in this section is the following. This theorem, along with 10, concludes 2.
Theorem 3. For every good ordered binary tree \(T\) that is not \(\perp\), there exists an LCL whose \(\mathsf{VOLUME}\) and LCA complexity is \(\tilde{\Theta} \left(n^{\operatorname{val}(T)}\right)\).
Lemma 10. For any rational \(x \in \mathbb{Q}\cap(0,1]\), there exists a good ordered binary tree \(T\) with \(\operatorname{val}(T) = x\).
Proof. We induct on \(c\) to prove the following claim: For all \(0 \le a \le b \le c\), there is a good ordered binary tree \(T\) with value \(a/b\). If \(a = 0\), then we can set \(T = \perp\), and we can set \(T = \bullet\) when \(a = b\), so the base case \(c=1\) is proved.
Now we assume the induction hypothesis holds for \(c-1\) and consider the statement for \(c\). We only need to consider cases where \(b=c\) and \(a \in [1,b-1]\). Let \(p=(a-1)/(b-1)\) and \(q=a/(b-1)\). We have \(0\le p < q\le 1\), and both \(p\) and \(q\) have denominators strictly smaller than \(c\). By induction hypothesis, there are two good ordered binary trees \(T_L\), \(T_R\) whose values are \(p\) and \(q\) respectively. Now we consider the tree \(T\) where the left subtree of the root is \(T_L\) while the right subtree is \(T_R\). According to 2 , \[\operatorname{val}(T) = \frac{q}{1+q-p} = \frac{\frac{a}{b-1}}{1+\frac{a}{b-1}-\frac{a-1}{b-1}} = \frac{\frac{a}{b-1}}{\frac{b}{b-1}} = \frac{a}{b}.\] It is easy to check that \(T\) is good, and this concludes the induction. ◻
Proof of 2. For every rational \(x\in(0,1]\), choose the good ordered binary tree \(T\) with \(\operatorname{val}(T)=x\), whose existence is guaranteed by 10, and apply 3 to generate an LCL with complexity in the LCA and \(\mathsf{VOLUME}\) model \(\tilde{\Theta}(n^{\operatorname{val}(T)}) = \tilde{\Theta}(n^{x})\). ◻
In the rest of this section, we fix a good ordered binary tree \(T\). \(T\) does not grow with the size of the LCL instance we will construct, so the size of \(T\) is considered a constant.
Similar to 4 5 in the polylogarithmic setting, we will first provide a set of input labels called \(T\)-labeling and the associated local constraints to rule out irregularities in the instance.
Definition 9 (\(T\)-labeling). Let \(G\) be a graph of maximum degree at most \(\Delta\), and \(\mathcal{P}=[\Delta]\cup\{\perp\}\). For a given ordered binary tree \(T\), a \(T\)-labeling* consists of a type labeling \(t\colon V(G)\to V(T) \cup \{\perp\}\) and the following four labels for each \(v\in V(G)\): a parent \(\mathrm{P}(v)\in\mathcal{P}\), a left child \(\mathrm{LC}(v)\in\mathcal{P}\), a right child \(\mathrm{RC}(v)\in\mathcal{P}\), and a direct child \(\mathrm{DC}(v)\in\mathcal{P}\). We call \(t(v)\) the type of \(v\).*
Same as [rem:log-child-port-notation], we will abuse the notation and use \(\mathrm{P}(v), \mathrm{LC}(v), \mathrm{RC}(v)\) and \(\mathrm{DC}(v)\) to also denote the vertex reached from the corresponding port.
Definition 10. For a \(T\)-labeling, a vertex \(v\) is consistent* if all the following constraints hold; otherwise, it is inconsistent:*
The non-\(\perp\) ports among \(\mathrm{P}(v),\mathrm{LC}(v),\mathrm{RC}(v)\), and \(\mathrm{DC}(v)\) are pairwise distinct.
For \(w\in\{\mathrm{LC}(v),\mathrm{RC}(v),\mathrm{DC}(v)\} \backslash \{\perp\}\), \(\mathrm{P}(w) = v\).
If \(\mathrm{P}(v)\ne \perp\), then \(v\in\{\mathrm{LC}(\mathrm{P}(v)),\mathrm{RC}(\mathrm{P}(v)),\mathrm{DC}(\mathrm{P}(v))\}\).
If \(\mathrm{LC}(v) \ne \perp\), \(t(\mathrm{LC}(v)) = \mathrm{LC}_T(t(v))\). Specifically, \(t(\mathrm{LC}(v)) = \perp\) when \(\mathrm{LC}_T(t(v)) = \perp\).
If \(\mathrm{RC}(v) \ne \perp\), \(t(\mathrm{RC}(v)) = \mathrm{RC}_T(t(v))\). Specifically, \(t(\mathrm{RC}(v)) = \perp\) when \(\mathrm{RC}_T(t(v)) = \perp\).
If \(\mathrm{DC}(v) \ne \perp\), \(t(\mathrm{DC}(v)) = t(v)\).
With 9 10, we are ready to define our LCL \(\Pi_{\mathsf{HC}}^T\), where \(\mathsf{HC}\) is an abbreviation of \(\mathsf{HierarchicalColoring}\). The name comes from the LCL \(\mathsf{Hierarchical\;2\frac{1}{2}\;Coloring}\) introduced in previous works [29], [32].
Definition 11 (\(\Pi_{\mathsf{HC}}^T\)). The problem \(\Pi_{\mathsf{HC}}^T\) is defined in the following way:
Input: A graph \(G\), a \(T\)-labeling and a bit \(b_{\mathrm{in}}(v)\in\{0,1\}\) for each \(v\in V(G)\).
Output: A color \(c_{\mathrm{out}}(v)\in\{\mathsf{D},\mathsf{X},\mathsf{U},\mathsf{Cyc},\perp\}\) and \(b_{\mathrm{out}}(v)\in\{0,1\}\) for each \(v\in V(G)\).
Constraint on \(c_{\mathrm{out}}(v)\): If \(v\) is inconsistent, then \(c_{\mathrm{out}}(v)=\perp\). Otherwise, \(c_{\mathrm{out}}(v) \ne \perp\) and the coloring should follow the following constraints:
If \(c_{\mathrm{out}}(v)=\mathsf{Cyc}\), then \(\mathrm{DC}(v) \ne \perp\) and \(c_{\mathrm{out}}(\mathrm{DC}(v)) = \mathsf{Cyc}\).
If \(c_{\mathrm{out}}(v) = \mathsf{U}\), then \(\mathrm{DC}(v)=\perp\) or \(c_{\mathrm{out}}(\mathrm{DC}(v)) \in \{\mathsf{X}, \mathsf{U},\perp\}\).
If \(c_{\mathrm{out}}(v)=\mathsf{X}\), then all* of the following hold:*
\(t(v) = \perp\) or \(t(v)\) is not a leaf in \(T\).
\(\mathrm{RC}(v) = \perp\) or \(c_{\mathrm{out}}(\mathrm{RC}(v))\ne\mathsf{D}\).
If \(c_{\mathrm{out}}(v)=\mathsf{D}\), then \(t(v) \ne r_T\);
If \(c_{\mathrm{out}}(v) \in \{\mathsf{X}, \mathsf{U}\}\), then \(\mathrm{LC}(v) = \perp\) or \(c_{\mathrm{out}}(\mathrm{LC}(v)) \ne \mathsf{D}\).
Constraint on \(b_{\mathrm{out}}(v)\): If \(c_{\mathrm{out}}(v)\in\{\mathsf{Cyc},\mathsf{D},\perp\}\) or \(t(v) = \perp\), then \(b_{\mathrm{out}}(v)=0\). Otherwise, we have the following equation: \[b_{\mathrm{out}}(v)=b_{\mathrm{in}}(v)\oplus b'(v)\oplus b''(v),\label{eq:poly-lcl-def}\qquad{(2)}\] where \[\begin{gather} b'(v) = \begin{cases} 0, & c_{\mathrm{out}}(v) = \mathsf{U}\text{ and }\mathrm{DC}(v)=\perp,\\ b_{\mathrm{out}}(\mathrm{DC}(v)), & c_{\mathrm{out}}(v) = \mathsf{U}\text{ and }\mathrm{DC}(v)\ne\perp,\\ 0, & c_{\mathrm{out}}(v)=\mathsf{X}\text{ and }\mathrm{RC}(v)=\perp,\\ b_{\mathrm{out}}(\mathrm{RC}(v)), & c_{\mathrm{out}}(v)=\mathsf{X}\text{ and }\mathrm{RC}(v)\ne\perp, \end{cases}\label{eq:poly-b39-def}\\ b''(v) = \begin{cases} 0, & \mathrm{LC}(v)=\perp,\\ b_{\mathrm{out}}(\mathrm{LC}(v)), & \mathrm{LC}(v)\ne\perp. \end{cases}\label{eq:poly-b3939-def} \end{gather}\] {#eq: sublabel=eq:eq:poly-b39-def,eq:eq:poly-b3939-def}
For readers familiar with previous works [29], [32], the \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) LCL introduced in these papers is a special case of \(\Pi_{\mathsf{HC}}^T\), where all vertices in \(T\) only have a right child, a new output color \(\mathsf{Cyc}\) is introduced, and colors \(\mathsf{R}\) and \(\mathsf{B}\) are identified to a single color \(\mathsf{U}\). Left and right children in \(\mathsf{Hierarchical}\text{-}\mathsf{THC}\) correspond to \(\mathrm{DC}\) and \(\mathrm{RC}\) ports in \(\Pi_{\mathsf{HC}}^T\). The extra color \(\mathsf{Cyc}\) is to avoid the possibility that none of the vertices in a cycle want to output \(\mathsf{X}\), and there may be no consistent solution for \(b_{\mathrm{out}}\) along the cycle.
\(\Pi_{\mathsf{HC}}^T\) is an LCL.
Proof. As \(|T|\) is a constant, the set of possible input and output labels has a constant size. Now we show that there is a \(\mathsf{LOCAL}\) algorithm of radius one to check whether the local constraint is satisfied for each vertex. The consistency conditions in 10 inspect only \(v\), its incident ports, and the labels of its neighbors. As a result, we can determine whether a vertex is consistent within one round. After that, constraints for the output label only involve the one-hop neighborhood. Hence, every constraint is checkable in radius one. ◻
In the rest of this section, we will show the following two lemmas, jointly proving 3.
Lemma 11. There is a randomized \(\mathsf{VOLUME}\) algorithm that solves \(\Pi_{\mathsf{HC}}^T\) over bounded-degree graphs using \(\tilde{O}(n^{\operatorname{val}(T)})\) probes.
Lemma 12. Any randomized LCA that solves \(\Pi_{\mathsf{HC}}^T\) uses \(\Omega(n^{\operatorname{val}(T)})\) probes even when we restrict the instance to bounded-degree trees.
Proof of 3. From [obs:vol-weaker-than-lca], the upper bound result 11 can be generalized from \(\mathsf{VOLUME}\) to LCA, while the lower bound result 12 can be generalized from LCA to \(\mathsf{VOLUME}\). As a consequence, in both models, we have a \(\tilde{O} (n^{\operatorname{val}(T)})\) randomized algorithm for \(\Pi_{\mathsf{HC}}^T\) over bounded-degree graphs and a matching lower bound for bounded-degree trees up to a polylogarithmic factor. ◻
Throughout the rest of this section, fix a good ordered binary tree \(T\). Set \(p = \operatorname{val}(T_L)\) and \(q = \operatorname{val}(T_R)\), and furthermore \[\alpha=\operatorname{val}(T)=\frac{q}{1+q-p}, \qquad \beta=\frac{q-p}{1+q-p}.\] We have the following equalities: \[\begin{gather} \beta+p(1-\beta)=q(1-\beta)=\alpha \tag{3} \\ (p-1)(1-\beta) = \frac{p-1}{1+q-p} = \frac{q-(1+q-p)}{1+q-p} = \alpha - 1. \tag{4} \end{gather}\]
As we see in 2, \(\Pi_{\mathsf{HC}}^T\) instances are formed by paths (corresponding to \(\mathrm{DC}\) paths and cycles in which all vertices have type \(r_T\)) and some attached \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\) instances. We formalize this structure by the definition of a sub-instance.
Definition 12 (Sub-instance). For a \(\Pi_{\mathsf{HC}}^T\) instance \(I\), define a graph \(G_I = (V_I, E_I)\) where \(V_I\) contains all consistent vertices with type other than \(r_T\) and \(\perp\) in \(I\), and \(E_I = \{(u,\mathrm{P}(u)) \mid u, \mathrm{P}(u) \in V_I\}\). A connected component of \(G_I\) induces an instance, which we call a sub-instance in \(I\). A sub-instance is a \(\Pi_{\mathsf{HC}}^{T_L} (\Pi_{\mathsf{HC}}^{T_R})\) sub-instance if all vertices in the sub-instance have type in \(T_L (T_R)\).
For each consistent vertex \(u\) of type \(r_T\), \(\mathrm{LC}(u)\) and \(\mathrm{RC}(u)\) will be in a \(\Pi_{\mathsf{HC}}^{T_L}\) and a \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance when these two vertices are consistent. We will call the two sub-instances the \(\Pi_{\mathsf{HC}}^{T_L}(\Pi_{\mathsf{HC}}^{T_R})\) instance attached to \(u\).
Lemma 13. Every vertex \(v\) in a \(\Pi_{\mathsf{HC}}^T\) instance \(I\) falls in exactly one of the categories: an inconsistent vertex, a consistent vertex of type \(\perp\), a consistent vertex of type \(r_T\), a vertex in some \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instance, or a vertex in some \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance.
Proof. If \(v\) is inconsistent, or if \(v\) is consistent with \(t(v)=\perp\) or \(t(v)=r_T\), then \(v\) falls into exactly one of the first three categories. It remains to consider a consistent vertex \(v\) with \(t(v)\notin\{\perp,r_T\}\). Since \(T\) is an ordered binary tree, \(t(v)\) belongs to exactly one of \(T_L\) and \(T_R\). The vertex \(v\) is therefore included in \(V_I\) and lies in a unique connected component of \(G_I\).
We now show that this component cannot contain types from both \(T_L\) and \(T_R\). Consider an edge \(\{x,y\}\) of \(G_I\). By the definition of \(G_I\), \(x\) and \(y\) are consistent vertices, so up to swapping \(x\) and \(y\), we have \(y=\mathrm{P}(x)\) and \(x\in\{\mathrm{LC}(y),\mathrm{RC}(y),\mathrm{DC}(y)\}\). If \(x=\mathrm{DC}(y)\), then \(t(x)=t(y)\). If \(x=\mathrm{LC}(y)\) or \(x=\mathrm{RC}(y)\), then \(t(x)\) is a child of \(t(y)\) in \(T\). In all cases, as \(x,y\in V_I\), the two types lie in the same one of the two subtrees \(T_L\) and \(T_R\). Hence every connected component of \(G_I\) is contained entirely in one side, and \(v\) belongs to exactly one \(\Pi_{\mathsf{HC}}^{T_L}\) or \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance. ◻
In the rest of this section, a randomized \(\mathsf{VOLUME}\) algorithm \(\mathcal{A}\) for \(\Pi_{\mathsf{HC}}^T\) will receive three inputs \((u, N_1, N_2)\), where \(u\) is the queried vertex, and \(N_1, N_2\) are positive size parameters with \(N_1\le N_2\). The algorithm \(\mathcal{A}\) will be used to solve both an \(\Pi_{\mathsf{HC}}^T\) instance, in which \(N_1 = N_2 = n\), and a \(\Pi_{\mathsf{HC}}^T\) sub-instance inside a larger \(\Pi_{\mathsf{HC}}^{T'}\) instance, in which \(N_1\) and \(N_2\) give clues about the size of the current sub-instance.
\(N_1\) denotes the ideal size of the \(\Pi_{\mathsf{HC}}^T\) sub-instance, and this parameter is to ensure the correct probe complexity and consistency. Most decisions in the algorithm that are related to the size of the instance, such as the probability of each vertex entering the sample set in 9, will use \(N_1\) as the size parameter.
\(N_2\) is the maximum possible size of the \(\Pi_{\mathsf{HC}}^T\) sub-instance. When the algorithm has a high confidence that the current sub-instance is even larger than \(N_2\), then it could use \((\mathsf{D}, 0)\) to label the current vertex being queried. Otherwise, the algorithm should make the best effort to use a label other than \((\mathsf{D}, 0)\).
Within the algorithm, we will utilize binary lifting to estimate the correct size of the sub-instance, with the estimation denoted as \(N\). The actual size of the sub-instance is generally unknown to the algorithm, and we denote it as \(n^\star\). \(n\) denotes the size of the whole instance, which is known to the algorithm. One may think of the algorithm as solving a \(\Pi_{\mathsf{HC}}^T\) sub-instance of unknown size \(n^\star\) inside a large instance of known size \(n\). Additionally, the algorithm \(\mathcal{A}\) may execute the algorithm for \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\) to deal with the \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instances of the current instance \(I\).
The following definition provides the guarantee for the algorithm in this section.
Definition 13 (Strong Algorithm). Fix a \(\Pi_{\mathsf{HC}}^T\) instance \(I\) with \(n^\star\) vertices, a randomized \(\mathsf{VOLUME}\) algorithm \(\mathcal{A}\), a randomness setup \(\mathcal{R} = \{r_v\}_{v \in I}\), and \(n \ge n^\star\). For a vertex \(u\in I\) and positive integers \(N_1\le N_2\), define \(a_{u,N_1,N_2}\) as the output of \(\mathcal{A}(u,N_1,N_2)\) using \(\mathcal{R}\) as the randomness, and define \(b_{u,N_1,N_2}\) as the number of probes used by \(\mathcal{A}(u,N_1,N_2)\). \(\mathcal{A}\) knows the value of \(n\) but does not know \(n^\star\).
The algorithm \(\mathcal{A}\) is called strong* if for all \(\Pi_{\mathsf{HC}}^T\) instances \(I\) of size \(n^\star\), \(n \ge n^\star\) and \(1 \le N_1 \le n\), with probability \(1-n^\star/n^2\) over \(\mathcal{R}\) all the following conditions hold:*
(i) (Stability over \(N_2\)) For every vertex \(u\in I\), there exists \(N_2^\star(u,N_1)\ge N_1\) such that \[a_{u,N_1,N_2} = \begin{cases} (\mathsf{D},0), & N_2<N_2^\star(u,N_1), \\ a_{u,N_1,N_2^\star(u,N_1)}, & N_2\ge N_2^\star(u,N_1). \end{cases}\]
(ii) (Correctness for small \(N_2\)) For all \(N_2\ge N_1\), all constraints in \(\Pi_{\mathsf{HC}}^T\) are satisfied by the output labeling given by \(a_{v,N_1,N_2}\), except constraints of type 4 for \(c_{\mathrm{out}}\) (vertices of label \((\mathsf{D}, 0)\) should not have type \(r_T\)).
(iii) (Correctness for large \(N_2\)) For every \(N_2\ge \max(N_1,n^\star)\) and every consistent vertex \(u\in I\) with \(t(u)=r_T\), \(a_{u,N_1,N_2}\ne(\mathsf{D},0)\).
(iv) (Probe complexity) For every \(N_2\ge N_1\), \[\max_{u \in I} b_{u,N_1,N_2} = \begin{cases} O(1), & T = \perp, \\ O(N_2N_1^{\alpha-1}\log^{d_T}n), & T \ne \perp. \end{cases} \label{eq:poly-strong-algo-complexity-universal}\qquad{(3)}\] In addition, when \(T \ne \perp\), then for every consistent vertex \(u\in I\) with \(t(u)=r_T\), \[b_{u,N_1,N_2} = O(\max(N_1,n^\star)N_1^{\alpha-1}\log^{d_T}n). \label{eq:poly-strong-algo-complexity-root}\qquad{(4)}\] Here \(d_T\) is the depth of the good ordered binary tree \(T\) defined as the number of edges in the longest path in \(T\) from \(r_T\) to some vertex in the tree.
We explain here the intuition of the four requirements in 13.
(i) Condition (i) says that an algorithm can label a vertex \(u\) with output label \((\mathsf{D}, 0)\) when \(N_2\) is smaller than the actual size \(n^\star\). However, once \(N_2\) is large enough for the algorithm to make a decision, increasing \(N_2\) will not change the output. Notice that we allow the algorithm to always output \((\mathsf{D}, 0)\) no matter how large \(N_2\) is.
(ii) Condition (ii) says that even if \(N_2\) is too small compared to \(n^\star\), the output labels satisfy all constraints in \(\Pi_{\mathsf{HC}}^T\) except that some vertices with type \(r_T\) may output \((\mathsf{D}, 0)\).
(iii) Condition (iii) says that once \(N_2\) is at least \(n^\star\), every root-type vertex is not labeled \((\mathsf{D}, 0)\) with high probability. Combining condition (ii), the output labeling in the sub-instance satisfies all \(\Pi_{\mathsf{HC}}^T\) constraints with probability \(1-n^\star/n^2\).
(iv) Condition (iv) contains two complexity guarantees, ?? ?? . ?? applies to the case where \(n^\star \gg N_2\): in this case, we require the algorithm to produce the output of every vertex in the instance with a probe complexity depending on \(N_2\) rather than \(n^\star\). \(N_1\) roughly measures the proportion of vertices that the algorithm is going to shave. When \(N_1 = N_2 = n^\star\) and \(T \ne \perp\), since \(d_T\) is a constant, we have that with high probability \(b_{u, n^\star, n^\star} = \tilde{O}\left((n^\star)^{1+\alpha - 1}\right) = \tilde{O}((n^\star)^\alpha)\), which is the desired complexity for \(\Pi_{\mathsf{HC}}^T\). ?? handles the case where \(n^\star \ll N_2\). In this case, we require the algorithm to produce a labeling for root-type vertices faster than the bound claimed by ?? .
We will show the following claim in the rest of this section, and it immediately implies 11.
Theorem 4. For every good ordered binary tree \(T\), there is a strong randomized \(\mathsf{VOLUME}\) algorithm for \(\Pi_{\mathsf{HC}}^T\).
Proof of 11. Apply 4 with \(N_1=N_2=n^\star=n\). By conditions (ii) and (iii) of 13, the output labeling \(\{a_{u,n,n}\}_{u \in I}\) satisfies \(\Pi_{\mathsf{HC}}^T\) with probability at least \(1-1/n\). By condition (iv), the probe complexity is \(\tilde{O}(n^{\operatorname{val}(T)})\) with probability \(1 - 1/n\). Finally, we can use [rem:las-vegas-to-monte-carlo] to translate this algorithm from Las Vegas to Monte Carlo. ◻
We build the algorithm for 4 inductively, and a strong algorithm for \(\Pi_{\mathsf{HC}}^T\) will use strong algorithms for \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\). We first handle the base cases \(T=\perp\) and \(T=\bullet\).
Lemma 14. There is a strong deterministic \(\mathsf{VOLUME}\) algorithm for \(\Pi_{\mathsf{HC}}^\perp\).
Proof. The algorithm checks whether the queried vertex \(u\) is consistent using 10. If \(u\) is inconsistent, it is labeled \((\perp,0)\); otherwise it is labeled \((\mathsf{X},0)\). The output is not \((\mathsf{D}, 0)\) and is independent of the parameter \(N_2\), so condition (i) of 13 is satisfied.
Since \(T=\perp\), every consistent vertex has type \(\perp\). Thus \(\mathsf{X}\) is allowed by item 3(a) in the \(c_{\mathrm{out}}\) constraint, and item 3(b) is always satisfied since output color \(\mathsf{D}\) does not appear in the instance. This shows that all vertices satisfy the \(\Pi_{\mathsf{HC}}^T\) constraints on \(c_{\mathrm{out}}\). The constraint on \(b_{\mathrm{out}}\) enforces every vertex \(u\) in the instance to have \(b_{\mathrm{out}}(u)=0\). This means that conditions (ii) and (iii) hold. Finally, the probe complexity is \(O(1)\), satisfying condition (iv). ◻
Lemma 15. There is a strong deterministic \(\mathsf{VOLUME}\) algorithm for \(\Pi_{\mathsf{HC}}^\bullet\).
Proof. The algorithm first performs the same consistency and type-\(\perp\) checks as in 14. Thus inconsistent vertices output \((\perp,0)\), type-\(\perp\) consistent vertices output \((\mathsf{X},0)\), and constraints on these vertices are satisfied. Now suppose \(u\) is consistent and \(t(u)=r_T\), then colors \(\mathsf{X}\) and \(\mathsf{D}\) are both prohibited at \(u\). With the input parameter \(N_2\), the algorithm follows the \(\mathrm{DC}\) path from \(u\) (i.e. the path \(u, \mathrm{DC}(u), \mathrm{DC}(\mathrm{DC}(u)) \dots\)) for \(N_2\) steps and outputs the first applicable label below:
If the walk revisits \(u\), \(u\) is labeled \((\mathsf{Cyc},0)\).
If the walk reaches a consistent vertex \(w\) such that \(\mathrm{DC}(w)=\perp\) or \(\mathrm{DC}(w)\) is inconsistent, \(u\) is labeled \(\left(\mathsf{U},\bigoplus_{z\in P_{u,w}} b_{\mathrm{in}}(z)\right)\), where \(P_{u,w}\) is the \(\mathrm{DC}\) path from \(u\) to \(w\).
If neither event above is found within \(N_2\) steps, \(u\) is labeled \((\mathsf{D},0)\).
Now we check the conditions for strong algorithms. For a fixed \(N_1\), the threshold \(N_2^\star(u, N_1)\) is the smallest value \(N_2\) for which the walk from \(u\) sees one of the two terminating events, hence condition (i) holds.
Now we check conditions (ii) and (iii). Fix \(N_2\ge N_1\), and distinguish different possibilities for a vertex \(u\) in the instance. Inconsistent vertices and consistent type-\(\perp\) vertices have already been handled. Let \(u\) be a consistent vertex with \(t(u)=r_T\). If the algorithm outputs \((\mathsf{D},0)\), then the only possible violation is item 4 in the constraint on \(c_{\mathrm{out}}\), which is precisely the exception allowed in condition (ii).
Suppose the algorithm outputs \((\mathsf{Cyc},0)\) at \(u\). Then the \(\mathrm{DC}\) walk from \(u\) returns to \(u\) within \(N_2\) steps. For every vertex \(z\) on this directed cycle, the same walk starting from \(z\) also returns to \(z\) within \(N_2\) steps before encountering any terminating event, so \(z\) is also labeled \((\mathsf{Cyc},0)\). Hence item 1 in the constraint on \(c_{\mathrm{out}}\) is satisfied at \(u\), and the bit constraint is satisfied because vertices of color \(\mathsf{Cyc}\) have output bit zero.
Finally, suppose the algorithm outputs \(\left(\mathsf{U},\bigoplus_{z\in P_{u,w}}b_{\mathrm{in}}(z)\right)\) at \(u\), where \(w\) is the first consistent vertex on the \(\mathrm{DC}\) path from \(u\) such that \(\mathrm{DC}(w)=\perp\) or \(\mathrm{DC}(w)\) is inconsistent. If \(u=w\), then item 2 in the constraint on \(c_{\mathrm{out}}\) is immediate. Otherwise, the vertex \(\mathrm{DC}(u)\) reaches the same terminating vertex \(w\) within fewer steps, so it is also labeled \(\mathsf{U}\). Thus item 2 is satisfied at \(u\). Since \(T=\bullet\), vertices of type \(r_T\) have left and right children of type \(\perp\) whose output bit must be zero. As a result, ?? reduces to \[b_{\mathrm{out}}(u)=b_{\mathrm{in}}(u)\oplus b_{\mathrm{out}}(\mathrm{DC}(u)),\] with \(b_{\mathrm{out}}(\mathrm{DC}(u))=0\) when \(\mathrm{DC}(u)=\perp\) or \(\mathrm{DC}(u)\) is inconsistent. The bit given by the algorithm is exactly this recurrence expanded along the path from \(u\) to \(w\).
To prove condition (iii), let \(N_2\ge\max(N_1,n^\star)\) and \(u\) be a consistent vertex with \(t(u)=r_T\). Along the \(\mathrm{DC}\) walk from \(u\), the first repeated consistent vertex must be \(u\): if the first repeated vertex were \(z\ne u\), then \(z\) would have two different predecessors, contradicting the consistency definition in 10. Therefore, within at most \(n^\star\) steps, the walk either returns to \(u\) or reaches a vertex whose \(\mathrm{DC}\) port is \(\perp\) or points to an inconsistent vertex. Since \(N_2\ge n^\star\), the algorithm sees one of these terminating events and does not output \((\mathsf{D},0)\).
Finally, the walk uses \(O(\min(n^\star, N_2))\) probes for every vertex. This is \(O(N_2)\) for all vertices and \(O(\max(N_1,n^\star))\) for root-type vertices. Since \(\alpha = 1\) and \(d_T = 0\), condition (iv) holds. ◻
For the induction step, assume that there are strong \(\mathsf{VOLUME}\) algorithms \(\mathcal{A}_L\) and \(\mathcal{A}_R\) for \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\) respectively. We also assume that \(T\ne\bullet\), so \(r_T\) is not a leaf and the vertices of type \(r_T\) are not prohibited from using color \(\mathsf{X}\).
The description of the algorithm is given in 10. Before explaining the algorithm, we first explain its subroutines, 7 8 9. Inside the algorithm, we define \(\mathrm{DC}^j(u)\) as the \(j\)-th vertex in the \(\mathrm{DC}\) path starting from \(u\). Namely, \(\mathrm{DC}^0(u) = u\) and \(\mathrm{DC}^j(u) = \mathrm{DC}(\mathrm{DC}^{j-1}(u))\) for \(j \ge 1\).
The algorithm \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) described in 7 is a subroutine that handles edge cases and sub-instances. For inconsistent vertices or vertices of type \(\perp\), we label them in the same way as in the algorithm for \(\Pi_{\mathsf{HC}}^\perp\) described in 14. For consistent vertices \(u\) where \(t(u) \ne r_T\), according to 13, it lies in either a \(\Pi_{\mathsf{HC}}^{T_L}\) or a \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance. We use \(\mathcal{A}_L\) and \(\mathcal{A}_R\) to solve them. Notice that parameter \(N_2\) is different between \(\mathcal{A}_L\) and \(\mathcal{A}_R\) calls: \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instances will be solved in a best-effort basis, meaning that if the sub-instance size is larger than \(\lceil N N_1^{-\beta} \rceil\), it is allowed to label \((\mathsf{D}, 0)\); Instead, the maximum possible size for \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instances is a conservative value \(N\).
The algorithm \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) described in 8 is used when the algorithm plans to color the \(\mathrm{DC}\) path from \(u\) to \(\mathrm{DC}^{k-1}(u)\) with \(\mathsf{U}\) and color \(\mathrm{DC}^k(u)\) with \(\mathsf{U}\) or \(\mathsf{X}\). When we follow the coloring plan, expanding \(b_{\mathrm{out}}(u)\) using ?? along the path, we have that \[b_{\mathrm{out}}(u)=b'(\mathrm{DC}^k(u)) \oplus \left(\bigoplus_{j=0}^k \left(b_{\mathrm{in}}(\mathrm{DC}^j(u))\oplus b''(\mathrm{DC}^j(u))\right)\right),\] and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) tries to compute the term \(\left(\bigoplus_{j=0}^k \left(b_{\mathrm{in}}(\mathrm{DC}^j(u))\oplus b''(\mathrm{DC}^j(u))\right)\right)\). This requires \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) to get the output bit for \(\mathrm{LC}(\mathrm{DC}^j(u))\) for each \(0 \le j \le k\) if it exists. Each of these vertices is either handled directly by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) or lies in a \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instance, so we call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) with size parameters \((N_1, N)\) to get them.
To avoid wasting too many probes when the total size of the attached \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instances is much larger than \(N\), we set up a probe budget of size \(\tilde{\Theta}(NN_1^{\alpha-1})\). Once those calls use up the probe budget, we immediately stop this process and all recursions generated by it, returning \(\perp\) to indicate a failure. Another possibility of failure is when any \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) call returns \((\mathsf{D}, 0)\): in this case, we cannot execute the original coloring plan for the \(\mathrm{DC}\) path due to item 5 in the constraint on \(c_{\mathrm{out}}\) (a vertex of color \(\mathsf{X}\) or \(\mathsf{U}\) cannot have a left child of color \(\mathsf{D}\)). In this case, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) also returns \(\perp\).
The algorithm \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\) described in 9 travels along the \(\mathrm{DC}\) path from \(u\) for at most \(\lceil 2N_1^\beta \rceil\) steps. For each of the vertices traveled, we include it in a sample set \(S\) with probability \(\min(1,4 N_1^{-\beta} \log n)\). This sampling should be consistent across different \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\) calls with the same \(N_1\), meaning that for two calls \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u, N_1, N)\) and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(v, N_1, N')\) that both visit \(w\), \(w\) will be in both or neither of the sample sets. Apart from the sample set \(S\), like the algorithm in 15 for \(\Pi_{\mathsf{HC}}^\bullet\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\) produces a label \((c_0,b_0)\) for \(u\) when the walk returns itself or reaches a terminating vertex.
Finally, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) described in 10 first calls \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) to deal with edge cases and sub-instances. Vertices left are consistent vertices with type \(r_T\) due to 13. For each of them, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) uses binary lifting to guess \(n^\star\), the actual size of the current \(\Pi_{\mathsf{HC}}^T\) (sub-)instance, from \(N_1\) to \(2N_2\). For each guess \(p \in [0, \lceil \log_2 (N_2 / N_1) \rceil]\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) calls \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p)\) described in 11 to see whether the size guess \(N = 2^pN_1\) can generate for \(u\) an output label other than \((\mathsf{D}, 0)\). If none of them work, the algorithm then has a high confidence that \(N_2\) is actually much smaller than \(n^\star\). In this case, condition (ii) in the definition of a strong algorithm allows \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) to give output label \((\mathsf{D}, 0)\) for \(u\), and it outputs \((\mathsf{D}, 0)\). For the other case, if any of the \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\) calls succeeds, it gives the label from the first successful \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\) call to \(u\).
Each \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p)\) call tries to generate an output label other than \((\mathsf{D}, 0)\) for \(u\) with size guess \(N = 2^p N_1\). It first gets the sample set \(S_u\) and a backup label \((c_0,b_0)\) from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\). Notice that the set \(S_u\) does not carry a \(p\) subscript because, for fixed \(u\) and \(N_1\), the walk inspected by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\) and the sampling choices are independent of the size guess \(N=2^pN_1\). Indices in \(S_u\) are candidates for an output color \(\mathsf{X}\). To color a candidate \(\mathrm{DC}^j(u)\) with \(\mathsf{X}\), item 3(b) in \(c_{\mathrm{out}}\) constraints requires the algorithm to give an output label other than \((\mathsf{D}, 0)\) to \(\mathrm{RC}(\mathrm{DC}^j(u))\). \(\mathrm{RC}(\mathrm{DC}^j(u))\) is either handled directly by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) or lies in a \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance. As a result, for each \(j \in S_u\), we check whether \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(\mathrm{RC}(\mathrm{DC}^j(u)),N_1, N)\) returns an output label other than \((\mathsf{D}, 0)\). We collect all such indices to the set \(S_{u,p}'\) in line [line:alg-poly-try-check-X].
\(N\) may be too small, or we are simply unlucky, and \(S_{u,p}'\) may then be empty. In this case, we enter line [line:alg-poly-upper-bound-output-backup] and try to output the backup label if it is not \((\mathsf{D}, 0)\). If the backup label is also \((\mathsf{D}, 0)\), then we indicate a failure by returning \(\perp\).
If \(S_{u,p}'\) is not empty, we pick \(j^\star\) as the minimum in \(S_{u,p}'\), and plan to color \(w = \mathrm{DC}^{j^\star}(u)\) with \(\mathsf{X}\) and the path between \(\mathrm{P}(w)\) and \(u\) with \(\mathsf{U}\) when \(w \ne u\). For the case where \(w = u\), we use \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,0,N_1,N)\) to compute the contribution of \(b_{\mathrm{in}}(v)\) and \(b''(v)\) defined in ?? , denoted by \(B\).
When \(w \ne u\), to ensure local consistency, we need to make sure that \(w\), whose output label is generated by an independent query \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w, N_1, N_2)\), agrees with this plan, thinking that it is colored \(\mathsf{X}\). To address this issue, we will prove that if \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w, N_1, N_2)\) does not follow the coloring plan, then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w, N_1, N_2)\) must get a label from a smaller size guess. This is why in line [line:alg-poly-upper-bound-prev-success-block], we call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w, N_1, N/2)\) to see whether this is the case.
If the call does not return \((\mathsf{D}, 0)\), then we know the output label for \(w\); otherwise, we know that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w, N_1, N_2)\) will follow the same coloring plan and color \(w\) with \(\mathsf{X}\). In both cases, we will color the path between \(\mathrm{P}(w)\) and \(u\) with \(\mathsf{U}\) and use \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) to get their contributions to \(b_{\mathrm{out}}(u)\). When the \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call fails, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\) will return \(\perp\).
Throughout the analysis, we assume the \(\Pi_{\mathsf{HC}}^T\) instance \(I\) of size \(n^\star\), \(N_1\), and \(n \ge N_1\) are arbitrary but fixed. Define \(n_0\) as the number of consistent vertices of type \(r_T\), sequences \((I_{l,1},I_{l,2},\dots,I_{l,n_l})\) and \((I_{r,1},I_{r,2},\dots,I_{r,n_r})\) as the sequences of \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instances, and \((s_{l,1},s_{l,2},\dots,s_{l,n_l})\), \((s_{r,1},s_{r,2},\dots,s_{r,n_r})\) as their size sequences. According to 13, \(n^\star \ge n_0 + \sum_{i=1}^{n_l} s_{l,i} + \sum_{i=1}^{n_r} s_{r,i}.\)
We apply induction hypothesis for \(\mathcal{A}_L\) and \(\mathcal{A}_R\) to each \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance. This means that,
For each \(1 \le i \le n_l\), the output labeling given by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(\star, N_1, N_2)\) for \(I_{l,i}\), which is further the output labeling given by \(\mathcal{A}_L(\star, \lceil N_1^{1-\beta} \rceil, 2N_2)\), satisfies the four conditions given in 13 with probability \(1-s_{l,i}/n^2\);
For each \(1 \le i \le n_r\), the output labeling given by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(\star, N_1, N_2)\) for \(I_{r,i}\), which is further the output labeling given by \(\mathcal{A}_R(\star, \lceil N_1^{1-\beta} \rceil, \lceil 2N_2 N_1^{-\beta} \rceil)\), satisfies the four conditions given in 13 with probability \(1-s_{r,i}/n^2\);
We additionally require the following event to occur for every consistent vertex of type \(r_T\):
Lemma 16. For every consistent vertex \(u\) of type \(r_T\), the following event happens with probability \(1-1/n^2\): For every \(N \ge N_1\), if the call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u, N_1, N)\) never enters the if-block at line [line:alg-poly-traverse-check-terminate] (i.e. within \(\lceil 2N_1^\beta\rceil\) steps, the walk never returns to itself or visits a vertex \(w=\perp\) or an inconsistent vertex \(w\)), then the call returns a sample set \(S\) of size \(O(\log n)\) in which there exists \(j\) such that the \(\Pi_{\mathsf{HC}}^{T_R}\) instance attached to \(\mathrm{DC}^j(u)\) has size at most \(n^\star/N_1^\beta\). For fixed \(u\) and \(N_1\), this sample set is the same for all values of \(N\).
Proof. The behavior of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u,N_1,N)\) before entering the if-block in line [line:alg-poly-traverse-check-terminate] is independent of \(N\), and the sampling probability is also independent of \(N\). Hence it is enough to analyze the single random sample set on the first \(\lceil 2N_1^\beta\rceil+1\) positions of the \(\mathrm{DC}\) walk from \(u\), and all \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u, N_1, N)\) calls will give the same sampling set.
Let \(\delta = \min(1,4N_1^{-\beta}\log n)\) be the sampling probability. If \(\delta=1\), then \(N_1^\beta=O(\log n)\), so the sample set has size \(O(\log n)\). Suppose now that \(\delta<1\). We have \(\mathbb{E}[|S|] = (\lceil 2N_1^\beta\rceil+1)(4N_1^{-\beta}\log n) = \Theta(\log n),\) and a Chernoff bound implies that the sample size is \(O(\log n)\) with probability at least \(1-1/(2n^2)\).
Now assume that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u,N_1,N)\) never enters the if-block. Then the vertices \(\mathrm{DC}^j(u)\) for \(0\le j\le\lceil 2N_1^\beta\rceil\) are distinct consistent vertices of type \(r_T\). Consider the \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instances attached to them. Since these sub-instances are vertex-disjoint and all contained in \(I\), their total size is at most \(n^\star\). This means that at least \(N_1^\beta\) of them have a \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance of size at most \(n^\star/N_1^\beta\) attached. The probability that none of these vertices is sampled is at most \((1-\delta)^{N_1^\beta} \le \exp(-4\log n) \le \frac{1}{2n^2}\) for all sufficiently large \(n\). A union bound over two events proves the lemma. ◻
A union bound shows that with probability at least \(1-n^\star/n^2\), all sub-instances have an output label satisfying 13, and for every consistent vertex \(u\) of type \(r_T\), the event in 16 occurs. In the rest of the upper bound analysis, all lemmas assume that these events happen.
Now we verify that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) follows all conditions in 13. We first verify stability.
Lemma 17. \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) satisfies condition (i) in 13.
Proof. Fix a vertex \(u\) and the first size parameter \(N_1\). If \(u=\perp\), if \(u\) is inconsistent, or if \(u\) is consistent with \(t(u)=\perp\), then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(u,N_1,2N_2)\) returns an output independent of \(N_2\). Thus we may take \(N_2^\star(u,N_1)=N_1\).
Suppose next that \(u\) lies in a \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instance. Then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u,N_1,N_2)\) returns the output of \(\mathcal{A}_L(u,\lceil N_1^{1-\beta}\rceil,2N_2)\). By condition (i) for \(\mathcal{A}_L\), there is a threshold \(M^\star\) for the third parameter of \(\mathcal{A}_L\). Taking \(N_2^\star(u,N_1)\) to be the smallest integer \(N_2\ge N_1\) with \(2N_2\ge M^\star\) gives the desired statement. The argument for \(u\) in a \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance is identical, using the threshold \(M^\star\) for \(\mathcal{A}_R(u,\lceil N_1^{1-\beta}\rceil,\star)\) and taking the smallest \(N_2\ge N_1\) such that \(\lceil 2N_2N_1^{-\beta}\rceil\ge M^\star\).
It remains to consider a consistent vertex \(u\) with \(t(u)=r_T\). For every integer \(p\ge 0\), the output of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p)\) depends only on \(u,N_1,p\) and the fixed randomness, and not on the value of \(N_2\). If there exists \(p\) such that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p) \ne \perp\), take the minimum of them, denoted as \(p^\star\), and take \(N_2^\star(u, N_1)\) to be the smallest \(N_2 \ge N_1\) such that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u, N_1, N_2)\) calls \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1, p^\star)\); Otherwise the output label will be \((\mathsf{D}, 0)\) whatever the value of \(N_2\). Both cases satisfy condition (i). ◻
For condition (ii), we need the following lemma showing that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) behaves correctly when the parameter \(N\) is large enough.
Lemma 18. Fix \(N_2\), so the output labeling for \(u\) is generated from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u, N_1, N_2)\). During the execution of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u,N_1,N_2)\) for some consistent vertex \(u\) of type \(r_T\), if a call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,k,N_1,N)\) returns a bit \(B\), then \[B=\bigoplus_{j=0}^k \left(b_{\mathrm{in}}(\mathrm{DC}^j(u))\oplus b''(\mathrm{DC}^j(u))\right),\] where \(b''\) is defined in ?? . Moreover, if the total size of the \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instances attached to \(\mathrm{DC}^j(u)\) for \(0\le j\le k\) is at most \(N\), then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,k,N_1,N)\) returns a bit rather than \(\perp\).
Proof. For each call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,k,N_1,N)\) in \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u,N_1,N_2)\), we first have \(N_1 \le N \le 2N_2\). Additionally, \(k \le \lceil 2N_1^\beta \rceil\) and \(\mathrm{DC}^j(u)\) is consistent for each \(0 \le j \le k\): whenever \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) is called from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\), all these vertices were visited before the first terminating event, and whenever \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) is called from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\), \(j^\star \in S_u\) already indicates that \(j^\star \le \lceil 2N_1^\beta \rceil\) and all indices between zero and \(j^\star\) passes the termination check in line [line:alg-poly-traverse-check-terminate] of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\).
For the first claim, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) uses \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) with size parameter \((N_1, N)\) to obtain the output bit of each \(\mathrm{LC}(\mathrm{DC}^j(u))\), while the output label of \(\mathrm{LC}(\mathrm{DC}^j(u))\) is generated by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(\mathrm{LC}(\mathrm{DC}^j(u)), N_1, 2N_2)\) inside \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(\mathrm{LC}(\mathrm{DC}^j(u)), N_1, N_2)\). If \(\mathrm{LC}(\mathrm{DC}^j(u))\) falls into an edge case handled directly by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\), its output is independent of the size parameter. Otherwise, condition (i) for \(\mathcal{A}_L\) implies that, if \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(\mathrm{LC}(\mathrm{DC}^j(u)), N_1, N)\) returns an output label other than \((\mathsf{D}, 0)\), this label must be the final output label for \(\mathrm{LC}(\mathrm{DC}^j(u))\). When \(\mathrm{LC}(\mathrm{DC}^j(u)) = \perp\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) outputs \((\mathsf{X},0)\). In sum, no matter when \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) returns a bit, every \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) call has returned an output label other than \((\mathsf{D},0)\), and the output bit is indeed \(b''(\mathrm{DC}^j(u))\) defined in ?? . If a call returns \((\mathsf{D},0)\), then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) fails and returns \(\perp\) instead of a bit. This concludes the first claim.
For the second claim, for each \(0 \le j \le k\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u, N_1, N)\) generates a call \(\mathcal{A}_L(\mathrm{LC}(\mathrm{DC}^j(u)), \lceil N_1^{1-\beta}\rceil, N)\) when \(\mathrm{LC}(\mathrm{DC}^j(u))\) does not fall into the edge cases. For each \(0 \le j \le k\), we define \(m_j\) to be the size of the \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instance attached to \(\mathrm{DC}^j(u)\), and \(m_j = 0\) when it does not exist. These sub-instances are vertex-disjoint, so we have \(\sum_{j=0}^k m_j \le N\). This means that \(m_j \le N\) for each \(0 \le j \le k\), and additionally \(\lceil N_1^{1-\beta}\rceil\le N_1\le N\), so we can apply condition (iii) for \(\mathcal{A}_L\) to show that all of the \(\mathcal{A}_L\) calls return labels other than \((\mathsf{D}, 0)\).
We need to show further that the probe budget will not be used up by these \(\mathcal{A}_L\) calls. If \(T_L=\perp\), then each call uses \(O(1)\) probes, and the total cost is \(O(N_1^\beta) = O(NN_1^{\alpha-1})\) because \(N\ge N_1\) and \(\alpha = \beta\) when \(p = 0\). The case \(T_L = \bullet\) is impossible since then \(p = 1 \ge q\), contradicting the goodness of \(T\). In all remaining cases, the vertices queried are consistent vertices of type \(r_{T_L}\) in \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instances, so we apply ?? in condition (iv), and the total number of probes is \[\begin{align} & \sum_{j=0}^k O\left(\max(\lceil N_1^{1-\beta}\rceil, m_j)\lceil N_1^{1-\beta}\rceil^{p-1} \log^{d_{T_L}} n\right) \\ = & O\left(\left(N_1 \cdot N_1^{(1-\beta)(p-1)}+N N_1^{(1-\beta)(p-1)}\right)\log^{d_T} n\right) \rceil=\Theta(N_1^{1-\beta}), k=O(N_1^\beta) and \sum_{j=0}^k m_j\le N} \\ = & O \left(N N_1^{(p-1)(1-\beta)} \log^{d_T} n\right)\\ = & O \left(N N_1^{\alpha - 1} \log^{d_T} n\right) } \end{align}\] This is within the probe budget when we set the probe budget constant in \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) to be sufficiently large. ◻
We will prove condition (ii) for \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) by considering each constraint in \(\Pi_{\mathsf{HC}}^T\) one by one. During the analysis of condition (ii), we will fix the value \(N_2\). According to the induction hypothesis, constraints are satisfied on inconsistent vertices, vertices of type \(\perp\), and vertices in a sub-instance, so it remains to consider constraints touching consistent vertices of type \(r_T\). If the output label for such a vertex \(u\) is \((\mathsf{D}, 0)\), then it only violates item 4 in \(c_{\mathrm{out}}\) constraints, which is allowed for condition (ii). So we will focus on cases where \(u\) receives a label other than \((\mathsf{D}, 0)\).
For each consistent vertex \(u\) of type \(r_T\) that does not receive output label \((\mathsf{D}, 0)\), define \(p_u^\star\) as the minimum nonnegative integer \(p\) such that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1, p)\) does not return \(\perp\) and define \(N_u=2^{p_u^\star}N_1\). According to the algorithm description, \(p_u^\star\) exists and is bounded by \(\lceil \log_2 (N_2 / N_1) \rceil\), and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u,N_1,N_2)\) returns the output label from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1, p_u^\star)\). Now we distinguish different possibilities in \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p_u^\star)\) that generate an output label for \(u\), and show that in all these cases, constraints on \(u\) are satisfied. We start with an observation around \(S_{u,p}'\) in \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\).
For a consistent vertex \(u\) of type \(r_T\) and \(p \ge 0\), \(S_{u,p}' \subseteq S_{u,p+1}'\), where \(S_{u,p}'\) is defined in line [line:alg-poly-try-check-X] of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p)\).
Proof. Let \(N=2^pN_1\). The sample set \(S_u\) is the same between \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p)\) and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p+1)\) according to 16, so it is enough to prove that every \(j\in S_{u,p}'\) belongs to \(S_{u,p+1}'\). Write \(x=\mathrm{RC}(\mathrm{DC}^j(u))\), and compare the calls \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(x, N_1, N)\) and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(x, N_1, 2N)\).
If \(x\) lies in edge cases handled directly by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\), then the output is independent of the size parameter. This covers the cases \(x=\perp\), \(x\) is inconsistent, and \(t(x)=\perp\). The case where \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) returns \(\perp\) is impossible here: if \(x\) is consistent, then \(x\) is the right child of a consistent type-\(r_T\) vertex and therefore has type \(\mathrm{RC}_T(r_T)\), or type \(\perp\) when \(\mathrm{RC}_T(r_T)=\perp\). Hence \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(x,N_1,2N)\) is an output label other than \((\mathsf{D},0)\) whenever \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(x,N_1,N)\) is one, and \(j \in S_{u,p+1}'\).
It remains to consider the case where \(x\) lies in a sub-instance. If \(x\) lies in a \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instance, then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(x,N_1,N)\) calls \(\mathcal{A}_L(x,\lceil N_1^{1-\beta}\rceil,N)\). Since this value is not \((\mathsf{D},0)\), condition (i) for \(\mathcal{A}_L\) implies that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(x,N_1,2N)\) would give the same output. The argument for a \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance is identical. Thus \(j\in S_{u,p+1}'\), completing the proof. ◻
We first consider the case where \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p_u^\star)\) returns the backup label \((c_0,b_0)\) from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\).
Lemma 19. For a consistent vertex \(u\) of type \(r_T\), if \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p_u^\star)\) returns the backup label \((c_0,b_0)\) from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\), then \(\Pi_{\mathsf{HC}}^T\) constraints on \(u\) are satisfied.
Proof. Let \(v = \mathrm{DC}(u)\). The backup label is returned only when \(S_{u,p_u^\star}'=\varnothing\) and the backup label produced by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u,N_1,N_u)\) is not \((\mathsf{D},0)\). According to [obs:poly-upper-bound-sample-set-monotone], we also know that \(S_{u,p}' = \varnothing\) for every \(0 \le p < p_u^\star\).
First suppose this label is \((\mathsf{Cyc},0)\). Then for some \(\ell \in [1, \lceil 2N_1^{\beta} \rceil]\), \(\mathrm{DC}^\ell(u)=u\), and all vertices on this directed cycle are consistent vertices of type \(r_T\). Additionally, every \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u,N_1,N)\) call will see this cycle and produce backup label \((\mathsf{Cyc}, 0)\) whatever the value of \(N\) is, so \(p_u^\star = 0\). We claim that \(p_v^\star\) is also zero and the output label for \(v\) will be \((\mathsf{Cyc}, 0)\), then the \(\Pi_{\mathsf{HC}}^T\) constraints on \(u\) are satisfied.
To see this, consider the call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(v, N_1, 0)\). It calls \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(v,N_1,N_1)\), which will see the cycle and prepare \((\mathsf{Cyc}, 0)\) for the backup label. Additionally, this call will visit exactly the same set of vertices as in \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u,N_1,N_1)\), and the sampling is consistent across calls of the same \(N_1\) value, this means that \(S_v\) will point to the same set of vertices as \(S_u\). Since \(S_{u,0}' = \varnothing\), \(S_{v,0}'\) will also be empty and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(v, N_1, 0)\) will output the backup label \((\mathsf{Cyc}, 0)\).
Now suppose the backup label is \((\mathsf{U},b_0)\). This means \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\) reaches a vertex \(\mathrm{DC}^j(u)\) that is either \(\perp\) or inconsistent, \(u, \mathrm{DC}(u), \mathrm{DC}^2(u), \dots, \mathrm{DC}^{j-1}(u)\) are all consistent vertices of type \(r_T\), and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,j-1,N_1,N_u)\) returns \(b_0\). If \(j = 1\), \(\mathrm{DC}(u)\) is \(\perp\) or colored \((\perp, 0)\), satisfying item 2 in the \(c_{\mathrm{out}}\) constraints for \(u\), and from 18, \(b_{\mathrm{out}}(u) = b_{\mathrm{in}}(u) \oplus b''(u)\), which is just ?? with \(b'(u) = 0\).
Next, we consider the case where \(j > 1\), then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(v, N_1, N_u)\) will see the same terminating event by traveling along a suffix of the DC path traveled by \(u\), and the corresponding \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call collects a subset of bits from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,j-1,N_1,N_u)\). This means that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(v, N_1, N_u)\) successfully generates a backup label \((\mathsf{U}, b_0')\). It is possible that the backup label can be produced with a smaller guess: Define \(p_v'\) as the smallest guess \(p\) such that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(v, N_1, 2^pN_1)\) produces a backup label other than \((\mathsf{D}, 0)\). From the argument above, we know \(p_v' \le p_u^\star\). In the remaining, we show that \(p_v^\star = p_v'\) and the output label for \(v\) makes \(u\) satisfy its \(\Pi_{\mathsf{HC}}^T\) constraints.
We have \(S_v \subseteq S_u\), so similar to the argument in the cycle case, \(S_{v,p}' = \varnothing\) for \(0 \le p \le p_u^\star\). This means that for each such \(p\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\) will check whether the backup label is not \((\mathsf{D}, 0)\). As \(p_v'\) is the smallest possible \(p\) value that generates a backup label other than \((\mathsf{D}, 0)\) and \(p_v' \le p_u^\star\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(v,N_1,p_v')\) will output the backup label while smaller \(p\) outputs \(\perp\). This proves \(p_v' = p_v^\star\). Since the backup label colors \(v\) with \(\mathsf{U}\), item 2 in the \(c_{\mathrm{out}}\) constraint is satisfied on \(u\). For the \(b_{\mathrm{out}}\) constraint, according to 18, we have \[\begin{gather} b_{\mathrm{out}}(u) = \bigoplus_{r=0}^{j-1}\left(b_{\mathrm{in}}(\mathrm{DC}^r(u))\oplus b''(\mathrm{DC}^r(u))\right), \\ b_{\mathrm{out}}(v) = \bigoplus_{r=1}^{j-1}\left(b_{\mathrm{in}}(\mathrm{DC}^r(u))\oplus b''(\mathrm{DC}^r(u))\right). \end{gather}\] As a result, we have \(b_{\mathrm{out}}(u) = b_{\mathrm{out}}(v) \oplus b_{\mathrm{in}}(u) \oplus b''(u)\), which is ?? .
In both cases, it remains to consider item 5 in the \(c_{\mathrm{out}}\) constraints that \(\mathrm{LC}(u)\) should not be labeled \((\mathsf{D}, 0)\). This comes from the fact that the \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call, which would fail when one of the left children is labeled \((\mathsf{D}, 0)\), outputs a bit rather than a failure. ◻
The other possibility that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p_u^\star)\) generates an output label is when \(S_{u,p_u^\star}'\) is nonempty. The algorithm will then pick \(j^\star\) as the minimum item in \(S_{u,p_u^\star}'\) and set \(w = \mathrm{DC}^{j^\star}(u)\). We first consider the case where \(j^\star = 0\), so \(w = u\).
Lemma 20. For a consistent vertex \(u\) of type \(r_T\), if \(0 \in S_{u,p_u^\star}'\), then \(u\) is colored \(\mathsf{X}\) and the \(\Pi_{\mathsf{HC}}^T\) constraints on \(u\) are satisfied.
Proof. Since \(0\in S_{u,p_u^\star}'\), the minimum index \(j^\star\) chosen is zero. Thus, the branch for \(j^\star=0\) sets \(c^\star=\mathsf{X}\). As \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p_u^\star)\) succeeds, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,0,N_1,N_u)\) returns a bit, and the algorithm returns a label of color \(\mathsf{X}\).
The color \(\mathsf{X}\) is allowed at \(u\) because \(u\) has type \(r_T\) and \(r_T\) is not a leaf. As \(0\in S_{u,p_u^\star}'\), the call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(\mathrm{RC}(u),N_1,2^{p_u^\star}N_1)\) returns a label other than \((\mathsf{D},0)\). Since \(2^{p_u^\star}N_1\le 2N_2\), by condition (i) of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\), this will be the output label for \(\mathrm{RC}(u)\). This proves item 3(b) in the constraint on \(c_{\mathrm{out}}\). Similarly, the successful \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call implies, by 18, that the output label of \(\mathrm{LC}(u)\) is not \((\mathsf{D},0)\), proving item 5. In sum, \(c_{\mathrm{out}}\) constraints on \(u\) are satisfied.
Let \(b^\star\) be the output bit of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(\mathrm{RC}(u),N_1,2^{p_u^\star}N_1)\), then \(b^\star\) equals \(b_{\mathrm{out}}(\mathrm{RC}(u))\) when \(\mathrm{RC}(u)\) exists, and equals zero if \(\mathrm{RC}(u)=\perp\). This is exactly the definition of \(b'(u)\) in ?? . By 18, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,0,N_1,2^{p_u^\star}N_1)\) returns \(b_{\mathrm{in}}(u)\oplus b''(u)\). Therefore \(b_{\mathrm{out}}(u) = b_{\mathrm{in}}(u)\oplus b''(u)\oplus b^\star\), which is exactly ?? for a vertex of color \(\mathsf{X}\). ◻
When \(j^\star = \min S_{u,p_u^\star}' \ge 1\), we have \(w \ne u\) and \(\mathrm{DC}(u)\) is not \(\perp\). In this case, the call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p_u^\star)\) will always color \(u\) with \(\mathsf{U}\). We define \(v=\mathrm{DC}(u)\). Since \(j^\star\) is sampled only after the termination check in line [line:alg-poly-traverse-check-terminate], all vertices \(\mathrm{DC}^j(u)\) with \(0\le j\le j^\star\) are consistent vertices of type \(r_T\), so \(p^\star_{\mathrm{DC}^j(u)}\) is well-defined. We begin with the following lemma that all vertices between \(\mathrm{P}(w)\) and \(u\) will agree on the coloring plan and color itself with \(\mathsf{U}\).
Lemma 21. For a consistent vertex \(u\) of type \(r_T\), suppose \(S_{u,p_u^\star}'\ne\varnothing\) and \(0\notin S_{u,p_u^\star}'\). Define \(j^\star\) as the minimum element in \(S_{u,p_u^\star}'\), then for every \(0 \le j < j^\star\), \(c_{\mathrm{out}}(\mathrm{DC}^j(u)) = \mathsf{U}\).
Proof. Define \(y=\mathrm{DC}^j(u)\). When \(c_{\mathrm{out}}(y) = \mathsf{Cyc}\), the cycle containing \(y\) must contain \(u\) as otherwise the consistency will be violated. Then from the argument in 19, \(c_{\mathrm{out}}(u)\) should also be \(\mathsf{Cyc}\), a contradiction.
Another possibility is that \(c_{\mathrm{out}}(y) = \mathsf{X}\). This happens only when \(0\in S_{y,p_y^\star}'\), which by consistent sampling would imply \(j \in S_{u,p_y^\star}'\). According to [obs:poly-upper-bound-sample-set-monotone], to make sure \(j^\star > j\) is the minimum among \(S_{u,p_u^\star}'\), \(p_y^\star > p_u^\star\) must hold.
However, we will prove next that \(p_y^\star \le p_u^\star\), leading to a contradiction. Notice that \(j^\star\) is the minimum value in \(S_{u,p_u^\star}'\) implies that \(j^\star-j\) is the minimum value in \(S_{y,p_u^\star}'\). As a result, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(y, N_1, p_u^\star)\) will agree on the same vertex \(w\) as \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p_u^\star)\), the check \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w, N_1, N_u/2) \ge 0\) has the same result, and the corresponding \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call in \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(y,N_1,p_u^\star)\) collects a subset of bits compared to the successful \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call in \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p_u^\star)\). This means that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(y,N_1,p_u^\star)\) returns a label rather than a failure and \(p_y^\star \le p_u^\star\).
Since we have proved \(p_y^\star \le p_u^\star\), \(c_{\mathrm{out}}(y)\) cannot be \(\mathsf{D}\) either. So the only possible color for \(y\) is \(\mathsf{U}\), concluding the statement. ◻
Now we will prove the following lemma, which is sufficient to prove that \(u\) is locally consistent:
Lemma 22. For a consistent vertex \(u\) of type \(r_T\), suppose \(S_{u,p_u^\star}'\ne\varnothing\) and \(0\notin S_{u,p_u^\star}'\). Define \(i^\star_u\) to be the minimum value \(i\) such that \(\mathrm{DC}^i(u)\) is inconsistent, \(\mathrm{DC}^i(u) = \perp\) or \(c_{\mathrm{out}}(\mathrm{DC}^i(u)) = \mathsf{X}\). Then:
\(i^\star_u\) exists, and for every \(0\le i<i^\star_u\), \(\mathrm{DC}^i(u)\) is a consistent vertex of type \(r_T\) colored \(\mathsf{U}\);
The \(c_{\mathrm{out}}\) constraint on \(u\) is satisfied, meaning that \(\mathrm{DC}(u)\) is either \(\perp\) or colored using one of the colors in \(\{\mathsf{X}, \mathsf{U}, \perp\}\), and \(\mathrm{LC}(u)\) is not colored \(\mathsf{D}\) if exists.
If \(\mathrm{DC}^{i^\star_u}(u)\) is colored \(\mathsf{X}\), then \[b_{\mathrm{out}}(u) = b'(\mathrm{DC}^{i^\star_u}(u)) \oplus \left( \bigoplus_{j=0}^{i^\star_u} (b_{\mathrm{in}}(\mathrm{DC}^j(u)) \oplus b''(\mathrm{DC}^j(u)))\right),\label{eq:poly-upper-bound-consistency-eq-1}\qquad{(5)}\] where \(b'\) and \(b''\) are defined in ?? ?? ; otherwise, if \(\mathrm{DC}^{i^\star_u}(u)\) is inconsistent or \(\mathrm{DC}^{i^\star_u}(u) = \perp\), then \[b_{\mathrm{out}}(u) = \bigoplus_{j=0}^{i^\star_u-1} (b_{\mathrm{in}}(\mathrm{DC}^j(u)) \oplus b''(\mathrm{DC}^j(u))).\label{eq:poly-upper-bound-consistency-eq-2}\qquad{(6)}\]
Proof. We prove the statement by induction on \(p_u^\star\). This means that, to show the statement for a vertex \(u\), we assume that the induction hypothesis holds for every consistent vertex \(u'\) of type \(r_T\) with \(p_{u'}^\star < p_u^\star\). Let \(j^\star=\min S_{u,p_u^\star}'\) and \(w=\mathrm{DC}^{j^\star}(u)\), then \(j^\star \ge 1\). \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\) then checks whether \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w,N_1,N_u/2)\ne(\mathsf{D},0)\), and enters one of the two branches starting at lines [line:alg-poly-upper-bound-prev-success-block] and [line:alg-poly-upper-bound-prev-fail-block]. As \(N_u = 2^{p_u^\star} N_1\), this is equivalent to checking whether \(p_w^\star < p_u^\star\).
Consider first the branch where \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w,N_1,N_u/2)\ne(\mathsf{D},0)\). Then, according to condition (i) for \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\), the label returned by this call is the output label of \(w\), and we know \(p_w^\star < p_u^\star\). The case where \(c_{\mathrm{out}}(w) = \mathsf{Cyc}\) cannot exist: as otherwise the \(\mathrm{DC}\) cycle from \(w\) should pass \(u\), and \(c_{\mathrm{out}}(u)\) should also be \(\mathsf{Cyc}\) according to 19, a contradiction. \(p_w^\star < p_u^\star\) implies that \(c_{\mathrm{out}}(w) \ne \mathsf{D}\), thus \(w\) is colored \(\mathsf{X}\) or \(\mathsf{U}\).
If \(w\) is colored \(\mathsf{X}\), we set \(i^\star_u=j^\star\). 21 shows that for all \(0 \le j < j^\star\), \(c_{\mathrm{out}}(\mathrm{DC}^j(u)) = \mathsf{U}\), so \(j^\star\) is the correct value for \(i^\star_u\). If \(w\) is colored \(\mathsf{U}\), \(w\) receives this label from two possible places: one is from the backup label produced by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\), in which, according to the proof in 19, there exists a value \(i^\star_w\) such that \(\mathrm{DC}^{i^\star_w}(w)\) is inconsistent or \(\perp\) and all vertices between \(w\) and \(\mathrm{DC}^{i^\star_w - 1}(w)\) are colored \(\mathsf{U}\). As a result, \(i^\star_u\) exists and equals \(j^\star+i^\star_w\). The final case is that \(S_{w,p_w^\star}' \ne \varnothing\) and \(0 \not\in S_{w,p_w^\star}'\). In this case, since \(p_w^\star < p_u^\star\), we can apply the induction hypothesis to get \(i^\star_w\), and assign \(i^\star_u=i^\star_w + j^\star\). The arguments above in sum prove item 1).
The item 2 in the \(c_{\mathrm{out}}\) constraint on \(u\) follows because \(\mathrm{DC}(u)\) is either \(\perp\), inconsistent, or colored \(\mathsf{X}\) when \(i^\star_u=1\), and colored \(\mathsf{U}\) when \(i^\star_u>1\); also, the successful \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call implies that \(\mathrm{LC}(u)\) is not colored \(\mathsf{D}\) if it exists, so item 5 in the \(c_{\mathrm{out}}\) constraint is also satisfied. This proves item 2).
For items 3), notice that the \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call in this branch uses parameter \((u,j^\star-1,N_1,N_u)\), and it returns a bit \(B\) because \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p_u^\star)\) succeeds. By 18, the algorithm returns \(b_{\mathrm{out}}(u)=b_{\mathrm{out}}(w)\oplus B\) with \[B=\bigoplus_{i=0}^{j^\star-1} \left(b_{\mathrm{in}}(\mathrm{DC}^i(u))\oplus b''(\mathrm{DC}^i(u))\right).\]
If \(w\) is colored \(\mathsf{X}\), then substituting ?? for \(w\) proved in 20 gives ?? . If \(w\) is colored \(\mathsf{U}\) and receives the backup label from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(w,N_1,p_w^\star)\), the proof of 19 implies that \(b_{\mathrm{out}}(w) = \bigoplus_{i=0}^{i^\star_w - 1}(b_{\mathrm{in}}(\mathrm{DC}^i(w)) \oplus b''(\mathrm{DC}^i(w)))\), and this gives ?? . Finally, the case where \(w\) receives a label since \(S_{w,p_w^\star}' \ne \varnothing\) and \(0 \not\in S_{w,p_w^\star}'\) follows from the induction hypothesis.
It remains to consider the branch where \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w,N_1,N_u/2)=(\mathsf{D},0).\) In this case, we know \(p_w^\star \ge p_u^\star\). Since \(j^\star \in S_{u,p_u^\star}'\), the consistent sampling implies that \(0\in S_{w,p_u^\star}'\). Moreover, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(w,0,N_1,N_u)\) will succeed since it collects a subset of bits compared to the successful call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,j^\star,N_1,N_u)\). As a result, from 20, we know that \(p_w^\star = p_u^\star\), the output color for \(w\) will be \(\mathsf{X}\), and its local constraints are satisfied.
We set \(i^\star_u=j^\star\), then 21 immediately implies item 1). Also, the successful \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,j^\star,N_1,N_u)\) call implies that \(\mathrm{LC}(u)\) is not colored \(\mathsf{D}\) if it exists, so the \(c_{\mathrm{out}}\) constraint on \(u\) is satisfied, implying item 2).
For item 3), notice that the successful \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi(u,j^\star,N_1,N_u)\) call returns a bit \(B\) with \[B=\bigoplus_{j=0}^{j^\star} \left(b_{\mathrm{in}}(\mathrm{DC}^j(u))\oplus b''(\mathrm{DC}^j(u))\right)\] according to 18. At the same time, condition (i) for \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) implies that the bit \(b^\star\) obtained from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(\mathrm{RC}(w), N_1, N)\) is exactly \(b'(w)\). Since \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p_u^\star)\) returns \(b^\star\oplus B\), this gives ?? . ◻
Wrapping up, we are finally able to show condition (ii) for \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\).
Lemma 23. \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) satisfies condition (ii) in 13.
Proof. Fix \(N_2\ge N_1\) and consider the output labeling generated by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u,N_1,N_2)\). Inconsistent vertices, vertices of type \(\perp\), and vertices in \(\Pi_{\mathsf{HC}}^{T_L}\) or \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instances satisfy all relevant constraints by the definition of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) and the induction hypothesis. Hence it remains to consider a consistent vertex \(u\) with \(t(u)=r_T\).
If \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u,N_1,N_2)\) returns \((\mathsf{D},0)\), then the only possible violation is item 4 in the constraint on \(c_{\mathrm{out}}\), which is explicitly allowed in condition (ii). Otherwise \(p_u^\star\) is defined. If \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p_u^\star)\) returns the backup label from \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\), the constraints on \(u\) are satisfied by 19. Otherwise \(S_{u,p_u^\star} \ne \varnothing\). If \(0\in S_{u,p_u^\star}'\), constraints on \(u\) are satisfied by 20. The remaining case is that \(S_{u,p_u^\star}'\ne\varnothing\) and \(0\notin S_{u,p_u^\star}'\), which is handled by 22. These lemmas cover every possible cases, so condition (ii) follows. ◻
Now we proceed to conditions (iii) and (iv).
Lemma 24. \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) satisfies condition (iii) in 13.
Proof. Let \(N_2\ge \max(N_1,n^\star)\), and let \(u\) be a consistent vertex with \(t(u)=r_T\). Set \(p=\left\lceil \log_2(N_2/N_1)\right\rceil\) and \(N=2^pN_1\), then \(N_2\le N\le 2N_2\), and in particular \(N\ge n^\star\). Consider the call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,p)\), we will show that this call must return a label rather than a failure, so the output label for \(u\) is not \((\mathsf{D}, 0)\).
First of all, for every \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call during \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p)\), all \(\Pi_{\mathsf{HC}}^{T_L}\) sub-instances are vertex-disjoint, so their total size is at most \(n^\star \le N\). According to 18, every \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call will succeed.
Now consider every possibility that \(u\) gets a label. If \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u,N_1,N)\) reaches a terminating event (i.e. reaching \(\perp\), an inconsistent vertex, or returning to itself) and produces a backup label, the corresponding \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) call always succeed, so a backup label other than \((\mathsf{D}, 0)\) is produced. This means that, when \(S_{u,p}' = \varnothing\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, p)\) still output a label other than \((\mathsf{D}, 0)\). When \(S_{u,p}' \ne \varnothing\), \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\) always outputs a label other than \((\mathsf{D}, 0)\) no matter the result of \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w, N_1, N/2)\) is.
For the other case that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi(u,N_1,N)\) does not produce a backup label, according to 16, there is an index \(j\in S_u\) whose attached \(\Pi_{\mathsf{HC}}^{T_R}\) sub-instance has size at most \(n^\star/N_1^\beta\). \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(\mathrm{RC}(\mathrm{DC}^j(u)),N_1,N)\) will invoke \(\mathcal{A}_R(\mathrm{RC}(\mathrm{DC}^j(u)), \lceil N_1^{1-\beta}\rceil, \lceil NN_1^{-\beta}\rceil)\). As \(\lceil N_1^{1-\beta}\rceil\le \lceil NN_1^{-\beta}\rceil\) and \(n^\star / N_1^\beta \le \lceil NN_1^{-\beta} \rceil\), condition (iii) for \(\mathcal{A}_R\) implies that this \(\mathcal{A}_R\) call returns a label other than \((\mathsf{D}, 0)\). Hence \(S_{u,p}'\) is nonempty, and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\) outputs a label other than \((\mathsf{D}, 0)\) following the same argument as above. ◻
Lemma 25. \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) satisfies condition (iv) in 13.
Proof. Apart from the induction hypothesis for \(\mathcal{A}_L\) and \(\mathcal{A}_R\), we apply an induction on \(d\) to prove the following three claims simultaneously for the current instance of size \(n^\star\):
For every \(0\le r\le d\), \[\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,r) \text{ uses } O(2^rN_1^\alpha\log^{d_T}n) \text{ probes.}\]
For every \(N_1\le N_2\le N_12^d\) and every vertex \(u\), \[\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u,N_1,N_2) \text{ uses } O(N_2N_1^{\alpha-1}\log^{d_T}n) \text{ probes.}\]
For every \(N_1\le N_2\le N_12^d\) and every consistent vertex \(u\) with \(t(u)=r_T\), \[\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(u,N_1,N_2) \text{ uses } O(\max(N_1,n^\star)N_1^{\alpha-1}\log^{d_T}n) \text{ probes.}\]
The claims B\(_{\mathrm{all}}(d)\) and B\(_{\mathrm{root}}(d)\) for all \(d\ge 0\) are exactly the two bounds in condition (iv). The base case for \(d=-1\) is trivial. We show B\(_{\mathrm{all}}(d-1)\Rightarrow\) A(\(d\)), and then A(\(d)\Rightarrow\) B\(_{\mathrm{all}}(d)\) and B\(_{\mathrm{root}}(d)\), concluding the induction.
We first show B\(_{\mathrm{all}}(d-1)\Rightarrow\) A(\(d\)). Fix \(0\le r\le d\) and set \(N=2^rN_1\). Consider the subroutines that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,r)\) calls. It makes only constantly many \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Collect}}}^T\nolimits\else\textrm{\mathrm{\small Collect}}^T\fi\) calls, each with budget \[O(NN_1^{\alpha-1}\log^{d_T}n) = O(2^rN_1^\alpha\log^{d_T}n).\] The \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Traverse}}}^T\nolimits\else\textrm{\mathrm{\small Traverse}}^T\fi\) call uses \(O(N_1^\beta)\le O(N_1^\alpha)\le O(N_1^\alpha)\) probes. For each sampled index \(j\in S_u\), the call to \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(\mathrm{RC}(\mathrm{DC}^j(u)),N_1,N)\) is either handled directly in \(O(1)\) probes, or invokes \(\mathcal{A}_R(\mathrm{RC}(\mathrm{DC}^j(u)),\lceil N_1^{1-\beta}\rceil,\lceil NN_1^{-\beta}\rceil)\). By induction hypothesis, applying ?? for \(\mathcal{A}_R\), we know that each of these calls costs \[\begin{align} &O\left(NN_1^{-\beta}\cdot N_1^{(1-\beta)(q-1)}\log^{d_T - 1}n\right)\le d_T - 1}\\ ={}&O\left(NN_1^{\alpha-1}\log^{d_T-1}n\right). {1+q-p} + \frac{q-1}{1+q-p} = \frac{p-1}{1+q-p} = \alpha-1} \end{align}\] Since \(|S_u|=O(\log n)\) by 16, all calls together cost \(O(NN_1^{\alpha-1}\log^{d_T}n)\). Finally, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi\) may call \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi(w,N_1,N/2)\). If \(r=0\), this call returns immediately because \(N/2<N_1\). Otherwise, B\(_{\mathrm{all}}(d-1)\) applies and gives cost \[O((N/2)N_1^{\alpha-1}\log^{d_T}n) = O(NN_1^{\alpha-1}\log^{d_T}n).\] In sum, \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u, N_1, r)\) has a cost of \(O(2^rN_1^\alpha \log^{d_T} n)\). This proves A(\(d\)).
We now prove B\(_{\mathrm{all}}(d)\) from A\((d)\). The initial \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(u,N_1,2N_2)\) may call one of \(\mathcal{A}_L\) and \(\mathcal{A}_R\). By ?? applied to both \(\mathcal{A}_L\) and \(\mathcal{A}_R\), the call \(\mathcal{A}_L(u,\lceil N_1^{1-\beta}\rceil,2N_2)\) costs \[O(N_2N_1^{(1-\beta)(p-1)}\log^{d_{T_L}}n) = O(N_2N_1^{\alpha-1}\log^{d_T}n), }\] and the call \(\mathcal{A}_R(u, \lceil N_1^{1-\beta}\rceil,\lceil 2N_2N_1^{-\beta}\rceil)\) costs \[O(N_2N_1^{-\beta}N_1^{(1-\beta)(q-1)}\log^{d_{T_R}}n) = O(N_2N_1^{\alpha-1}\log^{d_T}n).\] If \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi\) returns a label, this proves B\(_{\mathrm{all}}(d)\). Otherwise, \(u\) is a consistent vertex of type \(r_T\), and \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) runs \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,r)\) over a geometric sequence of size guesses all the way up to \(2N_2\). By A(\(d\)), the total cost of all these calls is \(O(N_2N_1^{\alpha-1}\log^{d_T}n)\). This proves B\(_{\mathrm{all}}(d)\).
It remains to prove B\(_{\mathrm{root}}(d)\) from A\((d)\). Let \(u\) be a consistent vertex with \(t(u)=r_T\). Then \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Prepare}}}^T\nolimits\else\textrm{\mathrm{\small Prepare}}^T\fi(u,N_1,2N_2)\) returns \(\perp\) with \(O(1)\) probes. When \(N_2<n^\star\), B\(_{\mathrm{all}}(d)\) already implies B\(_{\mathrm{root}}(d)\), so we consider the other case where \(N_2\ge n^\star\). The proof of 24 shows that \(\ifmmode\mathop{\text{\normalfont\mathrm{\small Try}}}^T\nolimits\else\textrm{\mathrm{\small Try}}^T\fi(u,N_1,r)\) succeeds as soon as \(2^rN_1 \ge n^\star\). Therefore the largest size guess used by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\) is \(O(\max(N_1,n^\star))\), and the probe complexity forms a geometric sequence according to A(\(d\)). As a result, they sum up to \[O(\max(N_1,n^\star)N_1^{\alpha-1}\log^{d_T}n),\] which is the desired bound. This proves B\(_{\mathrm{root}}(d)\) and completes the proof of condition (iv). ◻
Proof of 4. The proof is by induction on the size of \(T\). The base cases are 14 15. For the induction part, assume that for some tree \(T\) there is a strong algorithm for \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\), then the algorithm is given by \(\ifmmode\mathop{\text{\normalfont\mathrm{\small SolveHC}}}^T\nolimits\else\textrm{\mathrm{\small SolveHC}}^T\fi\). For the conditions, when all the events described in the start of the analysis section happens, which is of probability at least \(1-n^\star/n^2\), all four conditions in 13 are satisfied shown in 17 23 24 25. ◻
We will show the lower bound via induction on a stronger claim that one specific output bit in a dedicated distribution is indistinguishable for any deterministic LCA with \(o(n^{\operatorname{val}(T)})\) probes.
Lemma 26. Let \(T\ne\perp\) be a good ordered binary tree. For every sufficiently large \(n\), there is a set \(\mathcal{S}_{T,n}\) of \(\Pi_{\mathsf{HC}}^T\) instances of size at most \(n\) with the following properties:
(i) All instances in \(\mathcal{S}_{T, n}\) have the same underlying graph and \(T\)-labeling, in which the underlying graph is a degree-4 tree, every vertex is consistent, and there is a unique root vertex \(x\) with \(t(x) = r_T\) and \(\mathrm{P}(x) = \perp\);
(ii) For any instance \(I\) in \(\mathcal{S}_{T,n}\), there exists \(b_I \in \{0,1\}\) such that any solution satisfying all \(\Pi_{\mathsf{HC}}^T\) constraints for \(I\) must have \(b_{\mathrm{out}}(x) = b_I\). Define \(\mathcal{S}_{T,n}^B\) as the set of instances \(I\) in \(\mathcal{S}_{T,n}\) with \(b_I = B\);
(iii) For any set \(V_0\) of vertices of size \(o(n^{\operatorname{val}(T)})\), there exists a bijection \(f_{V_0}\) between \(\mathcal{S}_{T,n}^0\) and \(\mathcal{S}_{T,n}^1\), where for each \(I \in \mathcal{S}_{T,n}\) and \(u \in V_0\), \(b_{\mathrm{in}}(u)\) is the same between \(I\) and \(f_{V_0}(I)\).
Proof. We prove the lemma by induction on the size of \(T\).
First, consider the base case \(T=\bullet\). \(\mathcal{S}_{\bullet,n}\) contains all instances with the following property: The underlying graph is a directed \(\mathrm{DC}\) path \(u_1,u_2,\ldots,u_n\), where \(u_1=x\); in the \(T\)-labeling, all vertices have type \(r_T\), all \(\mathrm{LC}\) and \(\mathrm{RC}\) ports are \(\perp\). There is no constraint on \(b_{\mathrm{in}}\) inputs on each vertex, so \(\mathcal{S}_{\bullet,n}\) contains \(2^n\) instances, one different \(b_{\mathrm{in}}\) assignment per instance.
Condition (i) is satisfied by definition. Since \(r_T\) is a leaf and a root, \(\mathsf{X}\) and \(\mathsf{D}\) are prohibited. Moreover, no vertex can output \(\mathsf{Cyc}\). Thus, every legal solution colors each vertex with \(\mathsf{U}\), and ?? gives \(b_I = b_{\mathrm{out}}(x)=\bigoplus_{i=1}^n b_{\mathrm{in}}(u_i)\). This proves condition (ii). Finally, for any \(V_0\) of size \(o(n)\), choose \(w\notin V_0\) and map an instance to the instance obtained by flipping only \(b_{\mathrm{in}}(w)\). This map is clearly a bijection between \(\mathcal{S}_{\bullet,n}^0\) and \(\mathcal{S}_{\bullet,n}^1\), and it preserves all input bits on \(V_0\). Hence condition (iii) holds.
Now assume that \(T \ne \bullet\), and write \[p=\operatorname{val}(T_L),\qquad q=\operatorname{val}(T_R),\qquad \alpha=\operatorname{val}(T),\qquad \beta=\frac{q-p}{1+q-p}.\] Since \(T\) is good, we have \(p<q\). Let \(\ell=\Theta(n^\beta)\) and \(m=\Theta(n^{1-\beta})\), and we define \(\mathcal{S}_{T,n}\) as all instances that can be generated by the following procedure:
Create a directed \(\mathrm{DC}\) path \(x = u_1,u_2,\ldots,u_\ell\) of length \(\ell\), all of which have type \(r_T\).
Generate \((A_1,\ldots,A_\ell) \in \{0,1\}^\ell\) and define \(S_i=A_{i+1}\oplus A_{i+2}\oplus\cdots\oplus A_\ell\) for \(0 \le i < \ell\) and \(S_\ell = 0\).
If \(T_L=\perp\), then for every vertex \(u_i (1 \le i \le \ell)\), set \(\mathrm{LC}(u_i)=\perp\) and \(b_{\mathrm{in}}(u_i)=A_i\). Otherwise, we set \(b_{\mathrm{in}}(u_i)=0\) and attach to \(\mathrm{LC}(u_i)\) an arbitrary instance drawn from \(\mathcal{S}_{T_L,m}^{A_i}\).
For every \(i \in [1,\ell]\), attach to \(\mathrm{RC}(u_i)\) an arbitrary instance drawn from \(\mathcal{S}_{T_R,m}^{S_i}\).
For “attaching an instance to a port”, we mean creating a copy of the instance, making the port point to the root of the copy, and setting the parent port of that copied root back to the vertex \(u_i\). The constants hidden in \(\Theta(\cdot)\) are chosen so that the final instance has at most \(n\) and \(\Theta(n)\) vertices. This completes the definition of \(\mathcal{S}_{T,n}\).
According to the induction hypothesis, the structure and \(T\)-labeling of the attached instance is fixed, while the structure and \(T\)-labeling of the top-level \(\mathrm{DC}\) path is also fixed. Hence all instances in \(\mathcal{S}_{T,n}\) have the same underlying graph and \(T\)-labeling, in which it is easy to prove that the graph is a tree, every vertex is consistent, and the only type-\(r_T\) vertex with parent \(\perp\) is \(x=u_1\). Thus condition (i) holds.
Now we consider condition (ii). Define the contribution of a vertex \(u_i\), denoted as \(c(u_i)\), as \(b''(u_i) \oplus b_{\mathrm{in}}(u_i)\), where \(b''\) is defined in ?? . According to the construction, \(c(u_i) = A_i\) for each \(1 \le i \le \ell\). Now, for any legal output, define \(k = \min\{i \mid c_{\mathrm{out}}(u_i) = \mathsf{X}\}\), and \(k = \infty\) when there is no such \(i\). Notice that \(\mathsf{Cyc}\) is prohibited since there is no cycle in the instance. When \(k \ne \infty\), expanding ?? gives \[b_{\mathrm{out}}(x)=c(u_1) \oplus \dots \oplus c(u_k) \oplus S_k = A_1\oplus\cdots\oplus A_k\oplus S_k= \oplus_{i=1}^\ell A_i.\] If \(k = \infty\), then we have \[b_{\mathrm{out}}(x)=c(u_1) \oplus \dots \oplus c(u_\ell) = A_1\oplus\cdots\oplus A_\ell=\oplus_{i=1}^\ell A_i.\] In all, condition (ii) is satisfied by \(b_I = \oplus_{i=1}^\ell A_i\).
It remains to prove condition (iii). Define \(L_i\) and \(R_i\) as the \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\) instance attached to \(u_i\), with \(L_i=\varnothing\) when \(T_L=\perp\). For a fixed set of vertices \(V_0\) of size \(o(n^{\operatorname{val}(T)})\), let \(V_i^L = V_0 \cap L_i\) and \(V_i^R = V_0 \cap R_i\). We have \[|V_i^R| = o(n^\alpha) = o(n^{q(1-\beta)}) = o(m^q),\] so according to the induction hypothesis, for each \(i \in [1,\ell]\) there exists a bijection \(f^R_i\) between \(\mathcal{S}_{T_R, m}^0\) and \(\mathcal{S}_{T_R, m}^1\) satisfying condition (iii) for \(V_i^R\). Additionally, when \(T_L \ne \perp\), we have \[\min_i |V_i^L| \le \frac{1}{\ell} \sum_{i=1}^\ell |V_i^L| \le \frac{o(n^\alpha)}{\ell} = o(n^{\alpha - \beta}) = o(n^{p(1-\beta)}) = o(m^p).\] Take \(i^\star = \arg \min_i |V_i^L|\), then according to the induction hypothesis, there exists a bijection \(f^L_{i^\star}\) between \(\mathcal{S}_{T_L, m}^0\) and \(\mathcal{S}_{T_L, m}^1\) satisfying condition (iii) for \(V_{i^\star}^L\). For the case where \(T_L = \perp\), \(\alpha = q/(1+q) = \beta\), so \(|V_0| = o(n^\beta)\) and there exists some \(i^\star\) where \(u_{i^\star} \not\in V_0\). We let \(f_{i^\star}^L\) denote the operation that flips \(b_{\mathrm{in}}(u_{i^\star})\).
Now we construct the bijection \(f_{V_0}\) between \(\mathcal{S}_{T,n}^0\) and \(\mathcal{S}_{T,n}^1\). For each instance \(I\) in \(\mathcal{S}_{T,n}\) with bits \(A_1, A_2, \dots, A_\ell\), we flip \(A_{i^\star}\) by replacing the \(\Pi_{\mathsf{HC}}^{T_L}\) instance attached to \(u_{i^\star}\) with its image in \(f_{i^\star}^L\) if \(T_L\ne\perp\), or by flipping \(b_{\mathrm{in}}(u_{i^\star})\) if \(T_L=\perp\). For every \(1 \le i < i^\star\), the value \(S_i\) also flips, so we replace the \(\Pi_{\mathsf{HC}}^{T_R}\) instance attached to \(u_i\) with its image under \(f_i^R\). All other inputs are unchanged. This completes the construction.
Since \(f_{i^\star}^L\) and all \(f_i^R\) are bijections, and the same components are changed when we apply the map again, \(f_{V_0}\) is an bijection. It remains to check that \(f_{V_0}\) flips \(b_I\). According to the induction hypothesis, the map changes exactly \(A_{i^\star}\) and \(S_1, S_2, \dots,S_{i^\star-1}\). By following the same analysis for condition (ii), we know that all solutions for \(f_{V_0}(I)\) must have \(b_{\mathrm{out}}(x) = b_I \oplus 1\), so \(f_{V_0}\) is indeed a bijection between \(\mathcal{S}_{T,n}^0\) and \(\mathcal{S}_{T,n}^1\).
Finally, we show that \(I\) and \(f_{V_0}(I)\) have the same input labels on \(V_0\). For replaced \(\Pi_{\mathsf{HC}}^{T_L}\) and \(\Pi_{\mathsf{HC}}^{T_R}\) copies, this follows from the induction hypothesis applied to \(V_{i^\star}^L\) and to the sets \(V_i^R\). All other attached instances are identical. Vertices in the top \(\mathrm{DC}\) chain keep the same input when \(T_L \ne \perp\), and when \(T_L = \perp\), the only input bit that changes is at \(u_{i^\star}\notin V_0\). This concludes condition (iii). ◻
Proof of 12. Suppose for contradiction that there is a randomized LCA that solves \(\Pi_{\mathsf{HC}}^T\) with \(o(n^{\operatorname{val}(T)})\) probes and succeeds in every \(\Pi_{\mathsf{HC}}^T\) instance of size at most \(n\) with probability larger than \(1/2\). Pick any distribution \(\mathcal{D}\) over instances of size at most \(n\). According to Yao’s minimax principle, there is a deterministic LCA \(\mathcal{A}\) with the same probe bound that succeeds with probability larger than \(1/2\) over \(\mathcal{D}\).
Now set \(\mathcal{D}\) to be a uniform distribution over \(\mathcal{S}_{T,n}\). Since all instances in the support have the same graph and \(T\)-labeling, the transcript of \(\mathcal{A}(x)\) is determined by the set of probed vertices and their \(b_{\mathrm{in}}\) values. Fix any possible transcript \(\tau\), and let \(V(\tau)\) be the set of vertices probed in this transcript. We have \(|V(\tau)|=o(n^{\operatorname{val}(T)})\). Applying condition (iii) of 26 to \(V(\tau)\) gives a bijection between \(\mathcal{S}_{T,n}^0\) and \(\mathcal{S}_{T,n}^1\) that preserves all input bits seen in \(\tau\). Since all instances have the same probability of being chosen, and by condition (ii), a correct output must have root bit \(b_I\), we have \(\Pr[b_I=0 \mid \tau]=\Pr[b_I=1 \mid \tau]=1/2\), and the success probability of \(\mathcal{A}\) over \(\mathcal{D}\) is at most \(1/2\), a contradiction. ◻
In this section, we provide discussions and propose several possible future directions.
As we have mentioned in the introduction, our construction is completely different from the previous approach to provide a similar result in the distributed \(\mathsf{LOCAL}\) model [34].
The \(\mathsf{LOCAL}\) constructions in [33], [34] encode the execution of some special Turing machines into the graph, and the time complexity of such Turing machines will determine the round complexity of the problem. The current realization of such encodings crucially relies on the fact that each vertex reads all vertices in its local neighborhood and checks whether the input graph follows certain nice structure locally, so the LCLs require \(\Omega(n)\) probes in the \(\mathsf{VOLUME}\) and LCA model.
Conversely, our construction does not yield dense round complexities in the \(\mathsf{LOCAL}\) model for the polynomial regime. For the problem \(\Pi_{\mathsf{HC}}^T\), follow the same argument in 2, if the left and right children have complexity \(\tilde{\Theta}(n^p)\) and \(\tilde{\Theta}(n^q)\), then the round complexity for a top path of length \(\ell\) will be \(\tilde{O}(\min(\ell + (n/\ell)^p, (n/\ell)^q))\). The term balancing always gives \(\tilde{\Theta}(n^{1/(p+1)})\) round complexity for \(p<q\), so the construction only gives \(\tilde{\Theta}(n^{1/k})\) round complexity for some positive integer \(k\).
As a consequence, we raise the following open question to find a possible way to integrate density results in the \(\mathsf{LOCAL}\) and \(\mathsf{VOLUME}\) model.
Question 1. For any pair of rationals \(0 < r/s < p/q < 1\), construct a LCL \(\Pi_{r/s,p/q}\) with round complexity \(\tilde{\Theta}(n^{r/s})\) in the \(\mathsf{LOCAL}\) model and probe complexity \(\tilde{\Theta}(n^{p/q})\) in the \(\mathsf{VOLUME}\) or LCA model.
From [obs:vol-weaker-than-lca], the \(\mathsf{VOLUME}\) model is an LCA with additional locality restrictions. However, are these additional restrictions necessary? Can we find a problem that separates LCAs and \(\mathsf{VOLUME}\) algorithms? This question is trivial if we allow arbitrary problems to be under consideration (for example, consider the problem that each vertex in a graph needs to output the input label on vertex \(1\)). But for LCLs, this question is still open.
Question 2. Provide an LCL that separates the LCA and \(\mathsf{VOLUME}\) model more than polynomially, or prove that such an LCL does not exist.
The constraint of connectivity for the probe region is shown to be not important in [35]: Any randomized LCA \(\mathcal{A}\) for an LCL can be transformed into another randomized LCA \(\mathcal{A}'\) with polynomial probe complexity blowup, with the additional property that \(\mathcal{A}'\) always keeps its probed region a connected component in the graph. So the remaining question is to show whether the difference in randomness is important.
The question about different randomness models is also explicitly mentioned as an open question in [29]. There is work discussing the benefit of shared randomness in the distributed setting [36], [37], and it has been shown that in the \(\mathsf{LOCAL}\) model, shared randomness helps exponentially for certain LCLs. Yet it is currently unknown whether this is also the case in the \(\mathsf{VOLUME}\) model and LCAs.
The definition of LCLs is almost the same as that of finite-domain CSPs, except that LCLs are defined on bounded-degree constraint graphs. A natural question is whether it is possible to utilize existing tools in CSP complexity classification for LCL complexity classification. From decades of research, it turns out that the complexity of a CSP is largely related to its polymorphism, an important definition in universal algebra. See [38] for an introduction to the application of polymorphism in complexity theory and [39] for a literature review.
Previous work suggests indirect connections between universal algebra tools and distributed graph algorithms: [40] applies universal algebra techniques to distributed CSPs [41], but the distributed model is not a standard one. An emergent line of research, connecting distributed graph algorithms with descriptive combinatorics [25], [42]–[44], may also have implicit connections to a universal algebraic approach [45]. Yet, we are not aware of a directly application of universal algebra to the classification of LCL complexities in standard distributed models. As a result, we raise the following question.
Question 3. Provide a way to apply a universal algebraic approach to LCL complexity classification in distributed settings, or provide evidence that these algebraic tools may not be suitable to classify LCLs.