Abstract 1 Introduction 2 Preliminaries 3 Basic Tools 4 The Labeling Scheme: Proof of Theorem 2 References

Near-Optimal Vertex Fault-Tolerant Labels for Steiner Connectivity

Koustav Bhanja ORCID Weizmann Institute of Science, Rehovot, Israel Asaf Petruschka ORCID Weizmann Institute of Science, Rehovot, Israel
Abstract

We present a compact labeling scheme for determining whether a designated set of terminals in a graph remains connected after any f (or less) vertex failures occur. An f-FT Steiner connectivity labeling scheme for an n-vertex graph G=(V,E) with terminal set UV provides labels to the vertices of G, such that given only the labels of any subset FV with |F|f, one can determine if U remains connected in GF. The main complexity measure is the maximum label length.

The special case U=V of global connectivity has been recently studied by Jiang, Parter, and Petruschka [33], who provided labels of n11/fpoly(f,logn) bits. This is near-optimal (up to poly(f,logn) factors) by a lower bound of Long, Pettie and Saranurak [37]. Our scheme achieves labels of |U|11/fpoly(f,logn) for general UV, which is near-optimal for any given size |U| of the terminal set. To handle terminal sets, our approach differs from [33]. We use a well-structured Steiner tree for U produced by a decomposition theorem of Duan and Pettie [24], and bypass the need for Nagamochi-Ibaraki sparsification [40].

Keywords and phrases:
Fault Tolerance, Labeling Schemes, Steiner Connectivity
Funding:
Koustav Bhanja: Supported by Merav Parter’s European Research Council (ERC) grant under the European Union’s Horizon 2020 research and innovation programme, grant agreement No. 949083.
Asaf Petruschka: Supported by an Azrieli Foundation fellowship, and by Merav Parter’s European Research Council (ERC) grant under the European Union’s Horizon 2020 research and innovation programme, grant agreement No. 949083.
Copyright and License:
[Uncaptioned image] © Koustav Bhanja and Asaf Petruschka; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Graph algorithms analysis
; Theory of computation Data structures design and analysis ; Theory of computation Distributed algorithms
Related Version:
Full Version: https://arxiv.org/abs/2506.23215
Acknowledgements:
We are thankful to Merav Parter for encouraging this collaboration and for valuable discussions.
Editors:
Anne Benoit, Haim Kaplan, Sebastian Wild, and Grzegorz Herman

1 Introduction

Labeling schemes are distributed graph data structures with many applications in graph algorithms and distributed computing. The goal is to assign the vertices (and/or edges) of the graph with succinct yet informative labels, so that queries of interest can be answered from only the labels of the query arguments, without any access to the graph or to any other centralized storage. The main complexity measure is the label length, which is the maximum number of bits stored in a single label; construction and query time are secondary measures. Diverse types of labeling have been studied, with notable examples being adjacency [14, 15, 34, 4, 7], ancestry and least common ancestors in trees [1, 6], exact or approximate distances [46, 26, 5, 12, 27], and pairwise edge- or vertex-connectivity [35, 30, 31, 44].

The error-prone nature of many real-life networks has further motivated researchers to consider labeling schemes designed to support events of failures in the graph. Courcelle and Twig [19] were the first to explicitly define and study fault-tolerant (FT) (a.k.a forbidden set) labeling schemes, where the goal is to answer queries subject to the failure (i.e., deletion) of a set F of vertices or edges in the graph. Here, the set F is part of the query arguments, so the labels assigned to F are available to the query algorithm. Usually, |F| is assumed to be bounded by some integer parameter f1 (this is abbreviated to the f-FT model). A lot of the works on FT labeling studied special graph families, such as planar or bounded doubling-dimension graphs [19, 18, 2, 3, 8, 13]. In this work, we consider a general n-vertex (undirected) graph G=(V,E) and focus on connectivity-related f-FT labeling schemes.

𝒔-𝒕 connectivity.

The “s-t variant” of this problem has been extensively studied in recent years. Here, a query consists of a triplet (s,t,F), and it is required to determine if s,t are connected in GF. The study of f-FT s-t connectivity labeling was initiated by Dory and Parter [23] with subsequent works in [32, 41, 42, 37], rendering it reasonably well-understood by now: it is known to admit very succinct labels of only poly(f,logn) bits, either with edge failures or with vertex failures; we refer to [37] for a detailed presentation of the state-of-the-art bounds.

Global connectivity.

Parter, Petruschka and Pettie [42] have proposed the “global connectivity” variant, where the query consists only of F, and it is required to determine if GF is a connected graph. Unlike with s-t connectivity, the global variant turns out to behave very differently with edge failures (FE) or with vertex failures (FV). Essentially all known labeling schemes for the s-t connectivity variant under edge failures [23, 32, 37] also solve the global variant en route, hence the latter also admits succinct poly(f,logn)-bit labels. However, in case of vertex failures, it was shown in [42] that polynomial dependency in f is impossible, and their lower bound was improved to Ω(n11/f/f) by Long, Pettie and Saranurak [37]. Very recently, Jiang, Parter and Petruschka [33] gave a nearly matching upper bound by providing a construction of f-FT global connectivity labels of n11/fpoly(f,logn) bits, essentially settling the problem.

Steiner connectivity.

In this work, we study the natural generalization of the problem to Steiner connectivity. In this variant, the graph G=(V,E) comes with a (fixed) subset of designated vertices UV called terminals. Given a query FVE of up to f faulty vertices/edges, it is required to report if F is a U-Steiner cut in G, i.e., if there is a pair of disconnected terminals in GF. Note that U is fixed and not a part of the query, so we only get to see the labels of F.111If we also get the labels of U, we can just use the poly(f,logn)-bit labels of the s-t variant, and apply |U|1 pairwise connectivity queries (between one terminal in U to all the others) in GF. We call this variant f-FT Steiner connectivity labeling scheme.

We first note that the lower bound for the global connectivity variant of [37] immediately yields a lower bound for the Steiner setting as well:222Construct the lower bound instance of [37] on k vertices set as terminals, and add nk isolated vertices.

Theorem 1 ([37]).

Any f-FT Steiner connectivity labeling schemes for n-vertex graphs with k terminals must have label length of Ω(k11/f/f) bits (in the worst case).

Our technical contribution is providing a nearly matching upper bound which is optimal up to poly(f,logn) factors, hence generalizing the result of [33] (recovered when U=V):

Theorem 2.

For every n-vertex graph G=(V,E) with terminal set UV and f1, there is an f-FT Steiner connectivity labeling scheme for (G,U) with labels of |U|11/fpoly(f,logn) bits. The labels are computed deterministically in polynomial time.

The f-FT Steiner connectivity labeling scheme of Theorem 2 supports any query FVE of vertices and edges with |F|f. However, the challenge lies entirely in the case of vertex failures, i.e., FV: proving Theorem 2 for this case implies also the general case. Indeed, we can construct a new instance (G,U) where G is obtained from G by splitting each edge e of G by a new middle ve, so the failure of e in G is equivalent to the failure of ve in G (in terms of affect on connectivity between original vertices).

As for the case of only edge failures FE, much like in the global connectivity variant, it behaves very differently and admits labels of poly(f,logn) bits, implicit by known constructions of f-FT connectivity labels for pairwise connectivity queries (the standard s-t variant in the literature). Specifically, both the labels of [23] based on linear graph sketches and its derandomized version in [32] are straightforward to augment to answer Steiner connectivity queries,333These are based on fixing some spanning tree T for G, and reconnecting the connected components of TF to obtain those of GF. Augment the label of each tree edge with the number of terminals in the subtree below it. Then we can invoke a similar strategy to the sketch computation in [23, 32] to determine the number of terminals in each component of TF, and hence also of GF. and other constructions in [23, 37] seem plausibly amenable to such augmentations as well. In light of the discussions above, in the rest of the paper we will only consider the case of vertex failures, i.e., queries are of the form FV with |F|f.

Related work: Steiner variants.

We mention that providing “Steiner generalizations” that interpolate between the two extreme scenarios of the terminal set (|U|=n and |U|=2) is a common objective in various algorithmic and graph-theoretic problems, such as computing Steiner mincut [22, 17, 29, 20], data structures for Steiner mincuts [21, 22, 9] and minimum+1 Steiner cuts [11], sensitivity oracles for Steiner mincuts [10, 11], Steiner connectivity augmentation and splitting-off [16] and construction of cactus graphs for compactly storing and characterizing Steiner mincuts [22, 29].

Related work: connectivity oracles.

FT connectivity labeling schemes can be seen as distributed versions of connectivity oracles under failures, which are centralized data structures designed to answer the same kind of queries. These have been extensively studied especially in the s-t variant, with both edge faults [43, 24, 28] and vertex faults [24, 47, 38, 45, 36, 39]. Much like with labeling schemes, in the global variant of connectivity oracles, vertex failures require much larger complexity than edge failures, as was first observed by Long and Saranurak [38]. Very recently, Jiang, Parter and Petruschka [33] provided almost-optimal oracles for global connectivity under vertex failures, and their approach seems plausible to extend also to the Steiner variant.

1.1 Our Approach

While our scheme of Theorem 2 and its formal analysis are not complicated, the intuitions behind them might seem illusive. In this section we aim to clarify these. We first introduce a warm-up suboptimal labeling scheme for the Steiner case, then survey the solution of [33] for the global variant, and finally explain how we “glue together” ideas from both to get our solution. For notational convenience, we use here O~() to hide poly(f,logn) factors.

A basic building block are the previously-introduced f-FT labels for the s-t connectivity variant, with length O~(1) bits [42, 37]. Their construction is highly complicated, but we use them as a black-box. Let () denote these labels, and L() the labels that we construct; each L()-label will store many ()-labels.

Warm-up: using degree classification.

To gain intuition, we first sketch a suboptimal construction based on a strategy introduced in [41]. Assume first U=V. Choose an arbitrary spanning tree T in G. Let r be some degree threshold. Let B be the set of vertices with T-degree r (high-deg), and VB be the rest (low-deg). For a low-deg xVB, let L(x) store {(x)}{(y)y is T-neighbor of x}. This handles the following queries:

  • (all-low-deg) If FVB, use the ()-labels to check pairwise connectivity between all T-neighbors of F; one observes that F is a cut in G iff we find some disconnected pair.

To handle the remaining queries where FB, we use recursion. For each xV let L(x) store, for every yB, x’s label to handle f1 faults in G{y} (recursively). Then,

  • (one-high-deg) If there is some yFB, we answer the query F{y} in Gy.

Let bf denote the resulting label length. As |B|=O(n/r), we get bf=O~(r+(n/r)bf1). Optimizing r and solving the recurrence (with base case b1=1) yields bf=O~(n11/2f1).

Generalizing to the Steiner variant with arbitrary terminals UV is rather smooth. Essentially, one takes T as a minimal Steiner tree that connects all terminals U. Then high-deg vertices in T are only |B|O(|U|/r), which eventually results in O~(|U|11/2f1)-bit labels. The details are provided in the full version of the paper.

Existing solution: the global case.

As previously mentioned, Jiang, Parter and Petruschka [33] gave near-optimal labels for the f-FT global connectivity variant, i.e., the case U=V. Roughly speaking, they also use a high/low-deg partition B and VB (with threshold r), but divide queries F in a dual manner to the warm-up above: (all-high-deg) FB, or (one-low-deg) F(VB). The high/low-deg partition is w.r.t. to degrees in G, not in a spanning tree. To enable this, they use Nagamochi-Ibaraki sparsification [40], yielding a subgraph H of G with O~(n) edges such that GF and HF have the same connected components, for every FV, |F|f. So w.l.o.g., G has only m=O~(n) edges.

To see the broad strokes, we explain their solution in the special case that G is f-vertex-connected. As [33] observe, in this case, if the query F is indeed a cut, then every xF is adjacent to every connected component of GF. Thus, for a low-deg xVB, one lets L(x) store {(y)(x,y)E}, and answers a query with xF by looking for a pair of neighbors disconnected in GF. Note that this argument crucially hinges on the fact that these are all of x’s neighbors in the (sparsified) graph G, and not in a spanning tree. To handle queries FB, one observes that a high-deg xB can participate in at most O(|B|f1) such queries, and simply writes the answers to these inside L(x). As |B|O(m/r), the label length is O~(r+(m/r)f1). Setting r=m11/f gives O~(m11/f)=O~(n11/f).

Our new solution: the Steiner case.

The main issue that prevents extending the solution of [33] to the Steiner case with arbitrary terminals UV lies in the sparsification step. Intuitively, to get O~(|U|11/f) label length, we would like to have O~(|U|) edges in the sparsified subgraph H, but then preserving connected components under faults is clearly impossible: |U| can be much smaller than |V|, so such H cannot even be connected. To tackle this, one may wish to construct other meaningful sparsifiers for Steiner connectivity under faults. This seems to be a challenging task, as even a plausible definition is non-trivial.

Instead, we take a different route and combine the “best-of-both-worlds”: we use a Steiner tree for high/low-deg partition as in the warm-up, but (roughly speaking) divide queries F to all-high-deg or one-low-deg as in [33]. Thus, even in the global case U=V, our approach yields a near-optimal scheme which is different than that of [33].

On a high level, the key is not using just any (minimal) Steiner tree T, but one where high-degree vertices B admit a lot of structure, by using a powerful graph decomposition of Duan and Pettie [24]. While it still holds that |B|O(|U|/r), the additional structure is that after deleting B from G, the remaining forest TB is still a Steiner forest for UB (i.e., connected terminals in GB are also connected in TB). The main technical part of our solution lies in a structural analysis that studies the interplay between the (known-in-advance) GB and TB, and the terminals in the graph GF defined by a given query F (this is mostly reflected in the correctness proof, specifically Claim 10). Essentially, this extra structure lets us design labels where it is enough for low-deg vertices to be defined w.r.t. the tree, and store the ()-labels of only their tree neighbors.

2 Preliminaries

Throughout the paper, G=(V,E) is an undirected graph with n vertices, UV is a designated terminal set in G, and f1 is an integer parameter.

For K,WV, we say that K separates W if there exist two vertices w,wWK that are disconnected in GK. A vertex set FV is called a cut in G if it separates V, and a Steiner cut if it separates the terminals U.

To shorten statements of theorems, lemmas, etc., we always use the term “algorithm” to mean a deterministic polynomial-time algorithm.

3 Basic Tools

As mentioned in Section 1.1, the most basic tool, which we use as a black box, is the succinct f-FT labels for s-t connectivity:

Theorem 3 ([37]).

There is an algorithm that outputs an O(f4log7.5(n))-bit label (v) to every vV with the following property:

For every FV with |F|f and s,tV, one can determine if s,t are connected in GF, by only inspecting the ()-labels of F{s,t}.

As explained in Section 1.1, our labels L() of Theorem 2 store many () labels, and to answer a query F, we make many s-t connectivity queries in GF using these ()-labels. Suppose that during the query algorithm, we found in this way a pair s,t which is disconnected in GF. Then clearly F is a cut in G, but we still cannot determine that is a Steiner cut, as one of s,t might lie in a connected component of GF without any terminals. We now present a simple tool that augments Theorem 3 to help us detect this situation.

Lemma 4.

There is an algorithm that outputs an O(f4log7.5)-bit label ¯(v) to every vV with the following property:

For every FV with |F|f and xV, one can determine there exists some uU such that x,u are connected in GF, by only inspecting the ¯()-labels of F{x}.

Proof.

Construct an auxiliary graph G from G by adding a new vertex z and adding an edge (z,u) for every terminal uU. Let () be the labels computed by the algorithm of Theorem 3 on G, and define ¯(v):=((v),(z)). Now, let FV with |F|f and xV. Note that there exists some uU which is connected to x in GF iff x,z are connected in GF. The ¯()-labels of F{x} contain all ()-labels of F{x,z}, so we can use them to determine if the latter condition holds.

4 The Labeling Scheme: Proof of Theorem 2

In this section, we prove our main Theorem 2, giving f-FT Steiner connectivity labels of |U|11/fpoly(f,logn) bits. Recall that, as discussed in the introduction, we only need to consider up to f vertex failures, i.e., queries FV with |F|f.

Subset labels.

We first introduce a somewhat technical lemma. Roughly speaking, in terms of the high-level intuition of Section 1.1, it serves to treat the all-high-degree case. The idea is to store explicit information for some relatively small collection of vertex-subsets (of “high-deg vertices”, see Section 1.1), such we have the information on KF, we can determine if K itself already separates UF, which implies that F is a Steiner cut.

Lemma 5.

There is an algorithm that given any KV, outputs a subset label ^(K) of O(flogn) bits with the following property:

For every FV with |F|f, one can determine if K separates UF, by only inspecting ^(K) and the names/identifiers of the vertices in F.

Proof.

Let C1,,Cp be the connected components of GK that contain some terminal, and denote Ui=CiU, where w.l.o.g. |U1||Up|. Our goal is that given ^(K) and any FV, |F|f, we can decide if at least two sets in {UiF1ip} are non-empty.

Suppose there exists some q such that i=1q|Ui|>f and i=q+1p|Ui|>f. Then for every FV with |F|f there is one non-empty set in {UiFiq} and another in {UiFiq+1}. Thus, we just indicate this situation in ^(K) and always answer YES.

Assume now that no such q exists.

  • If |Up|>f: Then i=1p1|Ui|<f, and we let ^(K) store U1,,Up1 (and indicate that |Up|>f). This suffices as for every FV with |F|f we know that UpF, so we only need to decide if {UiF1ip1} has a non-empty set.

  • If |Up|f: We assert that the sum i=1p|Ui| is at most 3f. Indeed, if it is more than f, let q be maximal such that i=q+1p|Ui|>f. Then i=1q|Ui|f, i=q+2p|Ui|f (by maximality), and |Uq+1||Up|f. Thus, we just let ^(K) store all of U1,,Up.

The Duan-Pettie Decomposition.

Our label construction crucially relies on a graph decomposition algorithm of Duan-Pettie [24] (as explained in Section 1.1). This algorithm is a recursive version of the Fürer-Raghavachari [25] algorithm for finding a Steiner tree with smallest possible maximum degree, up to +1 error. The Duan-Pettie decomposition utilizes the structural properties of the Fürer-Raghavachari tree (rather than its strong approximation guarantee). In the following, a Steiner forest means a forest in the graph where each pair of connected terminals (in the graph) is also connected in the forest.

Theorem 6 ([24]).

Let r3 be a degree threshold. There is an algorithm 𝖣𝖾𝖼𝗈𝗆𝗉(G,U,r) that outputs a pair (T,B) such that the following hold:

  1. 1.

    T is a Steiner forest for U in G, and TB is a Steiner forest for UB in GB.

  2. 2.

    The maximum degree in the forest TB is at most r.

  3. 3.

    |B|<|U|/(r2) and |BU|<|U|/(r1).

The running time of 𝖣𝖾𝖼𝗈𝗆𝗉(G,U,r) is O(|U|mlog|U|).

In the following we assume that f2, as Theorem 2 is trivial when f=1: the label of vertex x just stores a single bit indicating whether {x} is a Steiner cut.

Labeling.

Our first step is to invoke 𝖣𝖾𝖼𝗈𝗆𝗉(G,U,r:=|U|11/f+2) of Theorem 6; let (T,B) be the output. For every xV, we choose an arbitrary terminal uxU such that x,ux are connected in GB (where ux:=, i.e., a null value, if there is no such terminal). Next, we construct the ()-labels and ¯()-labels of Theorems 3 and 4; for every vV, define (v):=(v,(v),¯(v)). Finally, the L() labels are constructed as follows:

Algorithm 1 Creating the label L(x) of a xV.

The label length analysis is rather straightforward, given in detail in the following claim.

Claim 7.

Each label L(x) generated by Algorithm 1 has |U|11/fpoly(f,logn) bits, and takes polynomial time to compute.

Proof.

By Theorem 3, Lemma 4 and Lemma 5 each ()-label or ^()-label consists of poly(f,logn) bits, so we show that only O(|U|11/f) such labels are stored in L(x). The first four lines only store O(|B|) such labels, and |B||U|/(r2)=|U|1/f by the properties of 𝖣𝖾𝖼𝗈𝗆𝗉(G,U,r) in Theorem 6). As we assume f2, |U|1/f|U|11/f, so this is within budget. If xB, then, line 6 stores (y) for each neighbor y of x in TB, which are at most r=O(|U|11/f) again by Theorem 6. Next suppose xB. The number of sets KB s.t. xK and |K|f can be bounded by

k=0f1(|B|1k)1+k=1f1(|B|ek)k1+|B|f1k=1f1(ek)kO(|U|11/f)

(we used (nk)(n/k)k for 1kn, k=1(e/k)k is convergent, and |B||U|1/f). Thus, lines 8 and 9 store O(|U|11/f) ^()-labels.

Note that constructing the () labels for all vertices takes polynomial time by Theorem 3 and Lemma 4. Also, we only need to construct ^(K) labels for sets KB such that xB and |K|f (or such that K=), and there are only O(|U|11/f) such sets K by the arguments above; constructing each ^(K) takes polynomial time by Lemma 5.

 Remark 8.

The subset labels of Lemma 5 are trivial to construct with O(f2logn) bits: with notations from the proof, choose arbitrary f+1 sets among U1,,Up (or all if pf), take f+1 terminals from each chosen Ui (or all if |Ui|f). We’ve included the more efficient version to demonstrate that the poly(f,logn) factors in Claim 7 come from the f-FT labels of the s-t variant (Theorem 3). These have an Ω(f+logn)-bit lower bound bits [42], so even if the latter is matched, the contribution of the subset labels is lightweight.

Query algorithm.

The pseudo-code for the query algorithm is given in the following Algorithm 2, designed to return YES if the query F is a Steiner cut, and NO otherwise.

Algorithm 2 Answering a query FV, |F|f from the labels {L(x)xF}.

We now provide the implementation details:

  • Line 2 is executed using ^(K) of Lemma 5 (and the names of the vertices in F, given in their labels). If K=FB is non-empty, we can find ^(K) in the label L(x) of some xFB. Otherwise, ^(K) is stored in L(x) for every xF.

  • Line 4 is executed by using the ¯()-labels of the vertices in SF (which appear in their ()-labels). For every wS, we use ¯(w) and {¯(x)xF} to decide if w is connected to some uU in GF, which is possible by Lemma 4.

  • Line 8 is executed using the ()-labels of w,w and F (which appear in their ()-labels), which enable to determine if w,w are connected in GF by Theorem 3.

Correctness.

We need to show that YES is returned if and only if F is a Steiner cut, namely F separates U in G. The soundness direction (‘only if’) is trivial:

Claim 9.

If the query algorithm (Algorithm 2) returns YES then F is a Steiner cut in G.

Proof.

If YES was returned in line 2, then F has a subset K which separates two terminals in UF, so these are also separated by F. Thus, F is a Steiner cut.

Otherwise, YES was returned in line 8, so there are w,wW disconnected in GF. By definition of W (line 4 of Algorithm 1), there exists terminals u,uU such that u,w and u,w are connected pairs in GF. Thus, u,u are two terminals disconnected in GF, so F is a Steiner cut.

Next, we address the completeness (‘if’) direction:

Claim 10.

If F is a Steiner cut in G, then the query algorithm (Algorithm 2) returns YES.

Proof.

Let us first consider the trivial case when K=FB separates UF in G. Then Algorithm 2 returns YES in line 2 as needed. Henceforth, we assume that F satisfies the following property:

  • (P1)

    FB does not separate UF in G.

Note that given Property (P1), the only possible place where Algorithm 2 can return YES is in line 8, so we aim to show that this is indeed the case. We will crucially use Property (P1) later on in the proof.

Figure 1: Illustrating the proof of Claim 10. Given (P1) and (P2), the connected component Cu of u in GF is fully contained in some connected component of GB, and Cu has some neighbor xF within this bigger component. Thus, both u and the chosen terminal ux for x are connected to x in this component. The forest TB contains a tree that connects all terminals in this component, so it must connect u and ux. If uxCu (as shown in the figure), then the tree must contain a vertex wCu which is a neighbor of some xF in TB, and so wS. Otherwise, uxCuS. In either case, we find some vertex in CuS as required.

Let u,uU be two terminals disconnected in GF, which exists as F is a Steiner cut. We will show there exists w,wW such that (i) u,w are connected in GF and (ii) u,w are connected in GF. Let us argue why this suffices to complete the proof. First, this clearly implies that W. Second, one of w,w must be disconnected from w in GF, as otherwise w,w would be connected in GF, so by (i) and (ii) we get that u,u are also connected in GF, but this is a contradiction. Therefore, line 8 of Algorithm 2, when executed with either w or w must return YES as required.

We thus focus on showing the existence of wW which is connected to u in GF (and the proof for w and u is symmetric). Let Cu be the connected component of u in GF. Recall the definitions of S and its subset W from lines 3 and 4 of Algorithm 2. Note that every vertex wCuS is automatically in W, since it belongs to S and is connected to the terminal u in GF. So, our goal is simply to show that CuS, or in other words, that the ()-label of some vertex in Cu is stored in some L(x) of xF.

Again, there is a trivial case: if CuB then we are done, because {(b)bB} is stored in every L(x) of xF (line 3 of Algorithm 1), so BS. Thus, we assume that:

  • (P2)

    The connected component Cu of u in GF does not intersect B.

In fact, the inclusion of the ()-labels of B in every label L(x) is precisely aimed at enforcing Property (P2).

Our next step is to “capitalize on” properties (P1), (P2), and the important property that TB is a Steiner forest for UB in GB (guaranteed by Theorem 6). Consider the set NG(Cu) of all vertices outside Cu that are adjacent to Cu in G. Note that, as Cu is a connected component in GF, we have NG(Cu)F. Observe that NG(Cu) separates UF in G, as u,uUF with uCu and uCu. Thus, by Property (P1), it must be that NG(Cu)FB. Hence, there exists some xNG(Cu)(FB). Now, using Property (P2), we see that all vertices in Cu{x} are connected in GB, so u is connected to x in GB. Recall that the terminal uxU is also (by definition) connected to x in GB. (Note that ux exists since x is connected to the terminal u in GB.) Hence, u,ux are connected in GB, and thus also in TB. This is the crux for finishing the proof in the following argument. See Figure 1 for an illustration.

Observe that uxS, since (ux) is stored in L(x) (line 2 of Algorithm 1). So, if u,ux are connected in GF, then uxCuS and we are done. Otherwise, the path in TB between u and ux must go through F. Let xF be the vertex closest to u on this path, and let w be its neighbor in the direction of u on the path. (It might be that x=x.) Then the subpath between u and w avoids F, so wCu. Also, xB and (x,w) is an edge of TB, hence (w) is stored in L(x) (line 6 of Algorithm 1), so wS. Namely, we have shown that CuS, and the proof is concluded.

Theorem 2 follows immediately from the combination of Claim 7, Claim 9 and Claim 10.

References

  • [1] Serge Abiteboul, Stephen Alstrup, Haim Kaplan, Tova Milo, and Theis Rauhe. Compact labeling scheme for ancestor queries. SIAM J. Comput., 35(6):1295–1309, 2006. doi:10.1137/S0097539703437211.
  • [2] Ittai Abraham, Shiri Chechik, and Cyril Gavoille. Fully dynamic approximate distance oracles for planar graphs via forbidden-set distance labels. In Proceedings of the 44th Symposium on Theory of Computing Conference, STOC 2012, New York, NY, USA, May 19 - 22, 2012, pages 1199–1218. ACM, 2012. doi:10.1145/2213977.2214084.
  • [3] Ittai Abraham, Shiri Chechik, Cyril Gavoille, and David Peleg. Forbidden-set distance labels for graphs of bounded doubling dimension. ACM Trans. Algorithms, 12(2):22:1–22:17, 2016. doi:10.1145/2818694.
  • [4] Stephen Alstrup, Søren Dahlgaard, and Mathias Bæk Tejs Knudsen. Optimal induced universal graphs and adjacency labeling for trees. J. ACM, 64(4):27:1–27:22, 2017. doi:10.1145/3088513.
  • [5] Stephen Alstrup, Cyril Gavoille, Esben Bistrup Halvorsen, and Holger Petersen. Simpler, faster and shorter labels for distances in graphs. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12, 2016, pages 338–350. SIAM, 2016. doi:10.1137/1.9781611974331.CH25.
  • [6] Stephen Alstrup, Esben Bistrup Halvorsen, and Kasper Green Larsen. Near-optimal labeling schemes for nearest common ancestors. In Proceedings of the Twenty-Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2014, Portland, Oregon, USA, January 5-7, 2014, pages 972–982. SIAM, 2014. doi:10.1137/1.9781611973402.72.
  • [7] Stephen Alstrup, Haim Kaplan, Mikkel Thorup, and Uri Zwick. Adjacency labeling schemes and induced-universal graphs. SIAM J. Discret. Math., 33(1):116–137, 2019. doi:10.1137/16M1105967.
  • [8] Aviv Bar-Natan, Panagiotis Charalampopoulos, Pawel Gawrychowski, Shay Mozes, and Oren Weimann. Fault-tolerant distance labeling for planar graphs. Theor. Comput. Sci., 918:48–59, 2022. doi:10.1016/J.TCS.2022.03.020.
  • [9] Surender Baswana and Abhyuday Pandey. The connectivity carcass of a vertex subset in a graph: both odd and even case. In 2025 Symposium on Simplicity in Algorithms, SOSA 2025, New Orleans, LA, USA, January 13-15, 2025, pages 385–422. SIAM, 2025. doi:10.1137/1.9781611978315.30.
  • [10] Koustav Bhanja. Optimal sensitivity oracle for steiner mincut. In 35th International Symposium on Algorithms and Computation, ISAAC 2024, December 8-11, 2024, Sydney, Australia, volume 322 of LIPIcs, pages 10:1–10:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.ISAAC.2024.10.
  • [11] Koustav Bhanja. Minimum+1 steiner cuts and dual edge sensitivity oracle: Bridging gap between global and (s,t)-cuts. In The 52nd EATCS International Colloquium on Automata, Languages, and Programming (ICALP), 2025.
  • [12] Marthe Bonamy, Cyril Gavoille, and Michal Pilipczuk. Shorter labeling schemes for planar graphs. SIAM J. Discret. Math., 36(3):2082–2099, 2022. doi:10.1137/20M1330464.
  • [13] Itai Boneh, Shiri Chechik, Shay Golan, Shay Mozes, and Oren Weimann. Õptimal fault-tolerant labeling for reachability and approximate distances in directed planar graphs.
  • [14] Melvin A. Breuer. Coding the vertexes of a graph. IEEE Trans. Inf. Theory, 12(2):148–153, 1966. doi:10.1109/TIT.1966.1053860.
  • [15] Melvin A Breuer and Jon Folkman. An unexpected result in coding the vertices of a graph. Journal of Mathematical Analysis and Applications, 20(3):583–600, 1967. doi:10.1016/0022-247X(67)90082-0.
  • [16] Ruoxu Cen, William He, Jason Li, and Debmalya Panigrahi. Steiner connectivity augmentation and splitting-off in poly-logarithmic maximum flows. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2449–2488. SIAM, 2023. doi:10.1137/1.9781611977554.CH95.
  • [17] Richard Cole and Ramesh Hariharan. A fast algorithm for computing steiner edge connectivity. In Proceedings of the thirty-fifth annual ACM symposium on Theory of computing, pages 167–176, 2003. doi:10.1145/780542.780568.
  • [18] Bruno Courcelle, Cyril Gavoille, Mamadou Moustapha Kanté, and Andrew Twigg. Connectivity check in 3-connected planar graphs with obstacles. Electron. Notes Discret. Math., 31:151–155, 2008. doi:10.1016/J.ENDM.2008.06.030.
  • [19] Bruno Courcelle and Andrew Twigg. Compact forbidden-set routing. In STACS 2007, 24th Annual Symposium on Theoretical Aspects of Computer Science, Aachen, Germany, February 22-24, 2007, Proceedings, volume 4393 of Lecture Notes in Computer Science, pages 37–48. Springer, 2007. doi:10.1007/978-3-540-70918-3_4.
  • [20] Matthew Ding and Jason Li. Deterministic minimum steiner cut in maximum flow time. In 32nd Annual European Symposium on Algorithms, ESA 2024, September 2-4, 2024, Royal Holloway, London, United Kingdom, volume 308 of LIPIcs, pages 46:1–46:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.ESA.2024.46.
  • [21] Yefim Dinitz and Alek Vainshtein. The connectivity carcass of a vertex subset in a graph and its incremental maintenance. In Proceedings of the twenty-sixth annual ACM symposium on Theory of computing, pages 716–725, 1994. doi:10.1145/195058.195442.
  • [22] Yefim Dinitz and Alek Vainshtein. The general structure of edge-connectivity of a vertex subset in a graph and its incremental maintenance. odd case. SIAM J. Comput., 30(3):753–808, 2000. doi:10.1137/S0097539797330045.
  • [23] Michal Dory and Merav Parter. Fault-tolerant labeling and compact routing schemes. In PODC ’21: ACM Symposium on Principles of Distributed Computing, Virtual Event, Italy, July 26-30, 2021, pages 445–455. ACM, 2021. doi:10.1145/3465084.3467929.
  • [24] Ran Duan and Seth Pettie. Connectivity oracles for graphs subject to vertex failures. SIAM J. Comput., 49(6):1363–1396, 2020. doi:10.1137/17M1146610.
  • [25] M. Furer and B. Raghavachari. Approximating the minimum-degree steiner tree to within one of optimal. Journal of Algorithms, 17(3):409–423, 1994. doi:10.1006/jagm.1994.1042.
  • [26] Cyril Gavoille, David Peleg, Stéphane Pérennes, and Ran Raz. Distance labeling in graphs. J. Algorithms, 53(1):85–112, 2004. doi:10.1016/J.JALGOR.2004.05.002.
  • [27] Pawel Gawrychowski and Przemyslaw Uznanski. Better distance labeling for unweighted planar graphs. Algorithmica, 85(6):1805–1823, 2023. doi:10.1007/S00453-023-01133-Z.
  • [28] David Gibb, Bruce M. Kapron, Valerie King, and Nolan Thorn. Dynamic graph connectivity with improved worst case update time and sublinear space. CoRR, abs/1509.06464, 2015. arXiv:1509.06464.
  • [29] Zhongtian He, Shang-En Huang, and Thatchaphol Saranurak. Cactus representations in polylogarithmic max-flow via maximal isolating mincuts. In Proceedings of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1465–1502. SIAM, 2024. doi:10.1137/1.9781611977912.60.
  • [30] Tai-Hsin Hsu and Hsueh-I Lu. An optimal labeling for node connectivity. In Algorithms and Computation, 20th International Symposium, ISAAC 2009, Honolulu, Hawaii, USA, December 16-18, 2009. Proceedings, volume 5878 of Lecture Notes in Computer Science, pages 303–310. Springer, 2009. doi:10.1007/978-3-642-10631-6_32.
  • [31] Rani Izsak and Zeev Nutov. A note on labeling schemes for graph connectivity. Inf. Process. Lett., 112(1-2):39–43, 2012. doi:10.1016/J.IPL.2011.10.001.
  • [32] Taisuke Izumi, Yuval Emek, Tadashi Wadayama, and Toshimitsu Masuzawa. Deterministic fault-tolerant connectivity labeling scheme. In Proceedings of the 2023 ACM Symposium on Principles of Distributed Computing, PODC 2023, Orlando, FL, USA, June 19-23, 2023, pages 190–199. ACM, 2023. doi:10.1145/3583668.3594584.
  • [33] Yonggang Jiang, Merav Parter, and Asaf Petruschka. New oracles and labeling schemes for vertex cut queries. CoRR, abs/2501.13596, 2025. doi:10.48550/arXiv.2501.13596.
  • [34] Sampath Kannan, Moni Naor, and Steven Rudich. Implicit representation of graphs. SIAM J. Discret. Math., 5(4):596–603, 1992. doi:10.1137/0405049.
  • [35] Michal Katz, Nir A. Katz, Amos Korman, and David Peleg. Labeling schemes for flow and connectivity. SIAM J. Comput., 34(1):23–40, 2004. doi:10.1137/S0097539703433912.
  • [36] Evangelos Kosinas. Connectivity Queries Under Vertex Failures: Not Optimal, but Practical. In 31st Annual European Symposium on Algorithms (ESA 2023), volume 274 of Leibniz International Proceedings in Informatics (LIPIcs), pages 75:1–75:13, Dagstuhl, Germany, 2023. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ESA.2023.75.
  • [37] Yaowei Long, Seth Pettie, and Thatchaphol Saranurak. Connectivity labeling schemes for edge and vertex faults via expander hierarchies. In Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1–47, 2025. doi:10.1137/1.9781611978322.1.
  • [38] Yaowei Long and Thatchaphol Saranurak. Near-optimal deterministic vertex-failure connectivity oracles. In 63rd IEEE Annual Symposium on Foundations of Computer Science, FOCS 2022, Denver, CO, USA, October 31 - November 3, 2022, pages 1002–1010. IEEE, 2022. doi:10.1109/FOCS54457.2022.00098.
  • [39] Yaowei Long and Yunfan Wang. Better decremental and fully dynamic sensitivity oracles for subgraph connectivity. In 51st International Colloquium on Automata, Languages, and Programming, ICALP 2024, July 8-12, 2024, Tallinn, Estonia, volume 297 of LIPIcs, pages 109:1–109:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.ICALP.2024.109.
  • [40] Hiroshi Nagamochi and Toshihide Ibaraki. A linear-time algorithm for finding a sparse k-connected spanning subgraph of a k-connected graph. Algorithmica, 7(5&6):583–596, 1992. doi:10.1007/BF01758778.
  • [41] Merav Parter and Asaf Petruschka. Õptimal dual vertex failure connectivity labels. In Christian Scheideler, editor, 36th International Symposium on Distributed Computing, DISC 2022, October 25-27, 2022, Augusta, Georgia, USA, volume 246 of LIPIcs, pages 32:1–32:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPICS.DISC.2022.32.
  • [42] Merav Parter, Asaf Petruschka, and Seth Pettie. Connectivity labeling and routing with multiple vertex failures. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, Vancouver, BC, Canada, June 24-28, 2024, pages 823–834. ACM, 2024. doi:10.1145/3618260.3649729.
  • [43] Mihai Pătraşcu and Mikkel Thorup. Planning for fast connectivity updates. In 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2007), October 20-23, 2007, Providence, RI, USA, Proceedings, pages 263–271. IEEE Computer Society, 2007. doi:10.1109/FOCS.2007.59.
  • [44] Seth Pettie, Thatchaphol Saranurak, and Longhui Yin. Optimal vertex connectivity oracles. In STOC ’22: 54th Annual ACM SIGACT Symposium on Theory of Computing, Rome, Italy, June 20 - 24, 2022, pages 151–161. ACM, 2022. doi:10.1145/3519935.3519945.
  • [45] Michal Pilipczuk, Nicole Schirrmacher, Sebastian Siebertz, Szymon Torunczyk, and Alexandre Vigny. Algorithms and data structures for first-order logic with connectivity under vertex failures. In 49th International Colloquium on Automata, Languages, and Programming, ICALP 2022, July 4-8, 2022, Paris, France, volume 229 of LIPIcs, pages 102:1–102:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPICS.ICALP.2022.102.
  • [46] Mikkel Thorup and Uri Zwick. Approximate distance oracles. J. ACM, 52(1):1–24, 2005. doi:10.1145/1044731.1044732.
  • [47] Jan van den Brand and Thatchaphol Saranurak. Sensitive distance and reachability oracles for large batch updates. In 60th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2019, Baltimore, Maryland, USA, November 9-12, 2019, pages 424–435. IEEE Computer Society, 2019. doi:10.1109/FOCS.2019.00034.