arXiv subjects

Toshimitsu Masuzawa

Publications and source records attributed to Toshimitsu Masuzawa.

At least 19 recordsLinked to original sources

arXiv2026

Beating Quadratic Time--Message Trade-off in Distributed Minimum Spanning Tree Construction

We present a new distributed algorithm for computing a minimum spanning tree (MST) in the \textsf{CONGEST-KT$_{1}$} model, where messages are limited to $O(\log n)$ bits and each vertex initially knows the identifiers of its neighbors. Our algorithm exposes a two-parameter time--message trade-off: for any $0 \leq \lambda \leq \kappa \leq 1/2$, it runs in $\tilde{O}(n^{\lambda}D_G + n^{1 - \kappa - \lambda} + n^{1 - 2\kappa + \lambda} + n^{1/2})$ rounds and uses $\tilde{O}(\min\{m, n^{1 + \kappa}\})$ messages, where $n$, $m$, and $D_G$ are the number of vertices, edges, and thenetwork diameter, respectively. In particular, setting $(\kappa, \lambda) = (1/3, 1/6)$ yields an MST algorithm running in $\tilde{O}(n^{1/2} + n^{1/6}D_G)$ rounds with only $\tilde{O}(n^{4/3})$ messages. Under the mild assumption $D_G = O(n^{1/3})$, this is round-optimal while improving the best known message bound of $\tilde{O}(n^{3/2})$. More broadly, our algorithm breaks the quadratic time--message trade-off barrier $\mathrm{\# rounds} \cdot \mathrm{\# messages} = \tilde{\Omega}(n^2)$, which no previous MST algorithm in the \textsf{CONGEST-KT$_{1}$} model has been able to overcome, and it does so for almost the entire range of the diameter $D_G$. As a byproduct, we also obtain new low-message broadcast, spanning-tree, and leader-election algorithms.

cs.DS↗

arXiv2026

Tight Bounds on Window Size and Time for Single-Agent Graph Exploration under T-Interval Connectivity

We study deterministic exploration by a single agent in $T$-interval-connected graphs, a standard model of dynamic networks in which, for every time window of length $T$, the intersection of the graphs within the window is connected. The agent does not know the window size $T$, nor the number of nodes $n$ or edges $m$, and must visit all nodes of the graph. We consider two visibility models, $KT_0$ and $KT_1$, depending on whether the agent can observe the identifiers of neighboring nodes. We investigate two fundamental questions: the minimum window size that guarantees exploration, and the optimal exploration time under sufficiently large window size. For both models, we show that a window size $T = \Omega(m)$ is necessary. We also present deterministic algorithms whose required window size is $O(\epsilon(n,m)\cdot m + n \log^2 n)$, where $\epsilon(n,m) = \frac{\ln n}{1 + \ln m - \ln n}$. These bounds are tight for a wide range of $m$, in particular when $m = n^{1+\Theta(1)}$. The same algorithms also yield optimal or near-optimal exploration time: we prove lower bounds of $\Omega((m - n + 1)n)$ in the $KT_0$ model and $\Omega(m)$ in the $KT_1$ model, and show that our algorithms match these bounds up to a polylogarithmic factor, while being fully time-optimal when $m = n^{1+\Theta(1)}$. This yields tight bounds when parameterized solely by $n$: $\Theta(n^3)$ for $KT_0$ and $\Theta(n^2)$ for $KT_1$.

cs.DC↗

arXiv2024

Independent Set Reconfiguration Under Bounded-Hop Token

The independent set reconfiguration problem (ISReconf) is the problem of determining, for given independent sets I_s and I_t of a graph G, whether I_s can be transformed into I_t by repeatedly applying a prescribed reconfiguration rule that transforms an independent set to another. As reconfiguration rules for the ISReconf, the Token Sliding (TS) model and the Token Jumping (TJ) model are commonly considered. While the TJ model admits the addition of any vertex (as far as the addition yields an independent set), the TS model admits the addition of only a neighbor of the removed vertex. It is known that the complexity status of the ISReconf differs between the TS and TJ models for some graph classes. In this paper, we analyze how changes in reconfiguration rules affect the computational complexity of reconfiguration problems. To this end, we generalize the TS and TJ models to a unified reconfiguration rule, called the k-Jump model, which admits the addition of a vertex within distance k from the removed vertex. Then, the TS and TJ models are the 1-Jump and D(G)-Jump models, respectively, where D(G) denotes the diameter of a connected graph G. We give the following three results: First, we show that the computational complexity of the ISReconf under the k-Jump model for general graphs is equivalent for all k >= 3. Second, we present a polynomial-time algorithm to solve the ISReconf under the 2-Jump model for split graphs. We note that the ISReconf under the 1-Jump (i.e., TS) model is PSPACE-complete for split graphs, and hence the complexity status of the ISReconf differs between k = 1 and k = 2. Third, we consider the optimization variant of the ISReconf, which computes the minimum number of steps of any transformation between Is and It. We prove that this optimization variant under the k-Jump model is NP-complete for chordal graphs of diameter at most 2k + 1, for any k >=3.

cs.DS↗

arXiv2024

A Nearly Linear Time Construction of Approximate Single-Source Distance Sensitivity Oracles

An \emph{$\alpha$-approximate vertex fault-tolerant distance sensitivity oracle} (\emph{$\alpha$-VSDO}) for a weighted input graph $G=(V, E, w)$ and a source vertex $s \in V$ is the data structure answering an $\alpha$-approximate distance from $s$ to $t$ in $G-x$ for any given query $(x, t) \in V \times V$. It is a data structure version of the so-called single-source replacement path problem (SSRP). In this paper, we present a new \emph{nearly linear-time} algorithm of constructing a $(1 + \epsilon)$-VSDO for any directed input graph with polynomially bounded integer edge weights. More precisely, the presented oracle attains $\tilde{O}(m \log (nW)/ \epsilon + n \log^2 (nW)/\epsilon^2)$ construction time, $\tilde{O}(n \log (nW) / \epsilon)$ size, and $\tilde{O}(1/\epsilon)$ query time, where $n$ is the number of vertices, $m$ is the number of edges, and $W$ is the maximum edge weight. These bounds are all optimal up to polylogarithmic factors. To the best of our knowledge, this is the first non-trivial algorithm for SSRP/VSDO beating $\tilde{O}(mn)$ computation time for directed graphs with general edge weight functions, and also the first nearly linear-time construction breaking approximation factor 3. Such a construction has been unknown even for undirected and unweighted graphs. In addition, our result implies that the known conditional lower bounds for the exact SSRP computation does not apply to the case of approximation.

cs.DS↗

arXiv2023

Near-linear Time Dispersion of Mobile Agents

Consider that there are $k\le n$ agents in a simple, connected, and undirected graph $G=(V,E)$ with $n$ nodes and $m$ edges. The goal of the dispersion problem is to move these $k$ agents to mutually distinct nodes. Agents can communicate only when they are at the same node, and no other communication means, such as whiteboards, are available. We assume that the agents operate synchronously. We consider two scenarios: when all agents are initially located at a single node (rooted setting) and when they are initially distributed over one or more nodes (general setting). Kshemkalyani and Sharma presented a dispersion algorithm for the general setting, which uses $O(m_k)$ time and $\log(k + \Delta)$ bits of memory per agent [OPODIS 2021], where $m_k$ is the maximum number of edges in any induced subgraph of $G$ with $k$ nodes, and $\Delta$ is the maximum degree of $G$. This algorithm is currently the fastest in the literature, as no $o(m_k)$-time algorithm has been discovered, even for the rooted setting. In this paper, we present significantly faster algorithms for both the rooted and the general settings. First, we present an algorithm for the rooted setting that solves the dispersion problem in $O(k\log \min(k,\Delta))=O(k\log k)$ time using $O(\log (k+\Delta))$ bits of memory per agent. Next, we propose an algorithm for the general setting that achieves dispersion in $O(k \log k \cdot \log \min(k,\Delta))=O(k \log^2 k)$ time using $O(\log (k+\Delta))$ bits. Finally, for the rooted setting, we give a time-optimal (i.e.,~$O(k)$-time) algorithm with $O(\Delta+\log k)$ bits of space per agent. All algorithms presented in this paper work only in the synchronous setting, while several algorithms in the literature, including the one given by Kshemkalyani and Sharma at OPODIS 2021, work in the asynchronous setting.

cs.DC↗

arXiv2023

A Nearly Time-Optimal Population Protocol for Self-Stabilizing Leader Election on Rings with Polylogarithmic States

We propose a self-stabilizing leader election (SS-LE) protocol on ring networks in the population protocol model. Given an integer $\psi$ satisfying $\log n \le \psi \le \log n+O(1)$, where $n$ is the population size, the proposed protocol reaches a safe configuration within $O(n^2 \log n)$ steps with high probability from any initial configuration, and thereafter preserves the same unique leader forever. Since no protocol solves SS-LE in $o(n^2)$ steps with high probability, the convergence time is near-optimal, with only an $O(\log n)$ multiplicative gap. The proposed protocol uses only $\mathit{polylog}(n)$ states. Two state-of-the-art protocols are known for SS-LE on ring networks. The first protocol uses a polynomial number of states and solves SS-LE in $O(n^2)$ steps, whereas the second protocol requires super-exponential time but uses only a constant number of states. Our proposed protocol provides a useful middle ground between these two approaches.

cs.DC↗

arXiv2022

Computational Power of a Single Oblivious Mobile Agent in Two-Edge-Connected Graphs

We investigated the computational power of a single mobile agent in an $n$-node graph with storage (i.e., node memory). Generally, a system with one-bit agent memory and $O(1)$-bit storage is as powerful as that with $O(n)$-bit agent memory and $O(1)$-bit storage. Thus, we focus on the difference between one-bit memory and oblivious (i.e., zero-bit memory) agents. Although their computational powers are not equivalent, all the known results exhibiting such a difference rely on the fact that oblivious agents cannot transfer any information from one side to the other across the bridge edge. Hence, our main question is as follows: Are the computational powers of one-bit memory and oblivious agents equivalent in 2-edge-connected graphs or not? The main contribution of this study is to answer this question under the relaxed assumption that each node has $O(\log\Delta)$-bit storage (where $\Delta$ is the maximum degree of the graph). We present an algorithm for simulating any algorithm for a single one-bit memory agent using an oblivious agent with $O(n^2)$-time overhead per round. Our results imply that the topological structure of graphs differentiating the computational powers of oblivious and non-oblivious agents is completely characterized by the existence of bridge edges.

cs.DS↗

arXiv2022

Deciding a Graph Property by a Single Mobile Agent: One-Bit Memory Suffices

We investigate the computational power of the deterministic single-agent model where the agent and each node are equipped with a limited amount of persistent memory. Tasks are formalized as decision problems on properties of input graphs, i.e., the task is defined as a subset $\mathcal{T}$ of all possible input graphs, and the agent must decide if the network belongs to $\mathcal{T}$ or not. We focus on the class of the decision problems which are solvable in a polynomial number of movements, and polynomial-time local computation. The contribution of this paper is the computational power of the very weak system with one-bit agent memory and $O(1)$-bit storage (i.e. node memory) is equivalent to the one with $O(n)$-bit agent memory and $O(1)$-bit storage. We also show that the one-bit agent memory is crucial to lead this equivalence: There exists a decision task which can be solved by the one-bit memory agent but cannot be solved by the zero-bit memory (i.e., oblivious) agent. Our result is deduced by the algorithm of simulating the $O(n)$-bit memory agent by the one-bit memory agent with polynomial-time overhead, which is developed by two novel technical tools. The first one is a dynamic $s$-$t$ path maintenance mechanism which uses only $O(1)$-bit storage per node. The second one is a new lexicographically-ordered DFS algorithm for the mobile agent system with $O(1)$-bit memory and $O(1)$-bit storage per node. These tools are of independent interest.

cs.DS↗

arXiv2022

Deterministic Fault-Tolerant Connectivity Labeling Scheme

The \emph{$f$-fault-tolerant connectivity labeling} ($f$-FTC labeling) is a scheme of assigning each vertex and edge with a small-size label such that one can determine the connectivity of two vertices $s$ and $t$ under the presence of at most $f$ faulty edges only from the labels of $s$, $t$, and the faulty edges. This paper presents a new deterministic $f$-FTC labeling scheme attaining $O(f^2 \mathrm{polylog}(n))$-bit label size and a polynomial construction time, which settles the open problem left by Dory and Parter [PODC'21]. The key ingredient of our construction is to develop a deterministic counterpart of the graph sketch technique by Ahn, Guha, and McGreger [SODA'12], via some natural connection with the theory of error-correcting codes. This technique removes one major obstacle in de-randomizing the Dory-Parter scheme. The whole scheme is obtained by combining this technique with a new deterministic graph sparsification algorithm derived from the seminal $\epsilon$-net theory, which is also of independent interest. As byproducts, our result deduces the first deterministic fault-tolerant approximate distance labeling scheme with a non-trivial performance guarantee and an improved deterministic fault-tolerant compact routing. The authors believe that our new technique is potentially useful in the future exploration of more efficient FTC labeling schemes and other related applications based on graph sketches.

cs.DS↗

arXiv2022

Gathering Despite Defected View

An autonomous mobile robot system consisting of many mobile computational entities (called robots) attracts much attention of researchers, and to clarify the relation between the capabilities of robots and solvability of the problems is an emerging issue for a recent couple of decades. Generally, each robot can observe all other robots as long as there are no restrictions for visibility range or obstructions, regardless of the number of robots. In this paper, we provide a new perspective on the observation by robots; a robot cannot necessarily observe all other robots regardless of distances to them. We call this new computational model defected view model. Under this model, in this paper, we consider the gathering problem that requires all the robots to gather at the same point and propose two algorithms to solve the gathering problem in the adversarial ($N$,$N-2$)-defected model for $N \geq 5$ (where each robot observes at most $N-2$ robots chosen adversarially) and the distance-based (4,2)-defected model (where each robot observes at most 2 closest robots to itself) respectively, where $N$ is the number of robots. Moreover, we present an impossibility result showing that there is no (deterministic) gathering algorithm in the adversarial or distance-based (3,1)-defected model. Moreover, we show an impossibility result for the gathering in a relaxed ($N$, $N-2$)-defected model.

cs.DC↗

arXiv2021

A cooperative partial snapshot algorithm for checkpoint-rollback recovery of large-scale and dynamic distributed systems and experimental evaluations

A distributed system consisting of a huge number of computational entities is prone to faults, because faults in a few nodes cause the entire system to fail. Consequently, fault tolerance of distributed systems is a critical issue. Checkpoint-rollback recovery is a universal and representative technique for fault tolerance; it periodically records the entire system state (configuration) to non-volatile storage, and the system restores itself using the recorded configuration when the system fails. To record a configuration of a distributed system, a specific algorithm known as a snapshot algorithm is required. However, many snapshot algorithms require coordination among all nodes in the system; thus, frequent executions of snapshot algorithms require unacceptable communication cost, especially if the systems are large. As a sophisticated snapshot algorithm, a partial snapshot algorithm has been introduced that takes a partial snapshot (instead of a global snapshot). However, if two or more partial snapshot algorithms are concurrently executed, and their snapshot domains overlap, they should coordinate, so that the partial snapshots (taken by the algorithms) are consistent. In this paper, we propose a new efficient partial snapshot algorithm with the aim of reducing communication for the coordination. In a simulation, we show that the proposed algorithm drastically outperforms the existing partial snapshot algorithm, in terms of message and time complexity.

cs.DC↗

arXiv2020

Time-Optimal Self-Stabilizing Leader Election on Rings in Population Protocols

We propose a self-stabilizing leader election protocol on directed rings in the model of population protocols. Given an upper bound $N$ on the population size $n$, the proposed protocol elects a unique leader within $O(nN)$ expected steps starting from any configuration and uses $O(N)$ states. This convergence time is optimal if a given upper bound $N$ is asymptotically tight, i.e., $N=O(n)$.

cs.DC↗

arXiv2020

Efficient Dispersion of Mobile Agents without Global Knowledge

We consider the dispersion problem for mobile agents. Initially, k agents are located at arbitrary nodes in an undirected graph. Agents can migrate from node to node via an edge in the graph synchronously. Our goal is to let the k agents be located at different k nodes with minimizing the number of steps before dispersion is completed and the working memory space used by the agents. Kshemkalyani and Ali [ICDCN, 2019] present a fast and space-efficient dispersion algorithm with the assumption that each agent has global knowledge such as the number of edges and the maximum degree of a graph. In this paper, we present a dispersion algorithm that does not require such global knowledge but keeps the asymptotically same running time and slightly smaller memory space.

cs.DC↗

arXiv2020

Communication Efficient Self-Stabilizing Leader Election (Full Version)

This paper presents a randomized self-stabilizing algorithm that elects a leader $r$ in a general $n$-node undirected graph and constructs a spanning tree $T$ rooted at $r$. The algorithm works under the synchronous message passing network model, assuming that the nodes know a linear upper bound on $n$ and that each edge has a unique ID known to both its endpoints (or, alternatively, assuming the $KT_{1}$ model). The highlight of this algorithm is its superior communication efficiency: It is guaranteed to send a total of $\tilde{O} (n)$ messages, each of constant size, till stabilization, while stabilizing in $\tilde{O} (n)$ rounds, in expectation and with high probability. After stabilization, the algorithm sends at most one constant size message per round while communicating only over the ($n - 1$) edges of $T$. In all these aspects, the communication overhead of the new algorithm is far smaller than that of the existing (mostly deterministic) self-stabilizing leader election algorithms. The algorithm is relatively simple and relies mostly on known modules that are common in the fault free leader election literature; these modules are enhanced in various subtle ways in order to assemble them into a communication efficient self-stabilizing algorithm.

cs.DC↗

arXiv2020

Time-optimal Loosely-stabilizing Leader Election in Population Protocols

We consider the leader election problem in population protocol models. In pragmatic settings of population protocols, self-stabilization is a highly desired feature owing to its fault resilience and the benefit of initialization freedom. However, the design of self-stabilizing leader election is possible only under a strong assumption (i.e. the knowledge of the \emph{exact} size of a network) and rich computational resources (i.e. the number of states). Loose-stabilization, introduced by Sudo et al [Theoretical Computer Science, 2012], is a promising relaxed concept of self-stabilization to address the aforementioned issue. Loose-stabilization guarantees that starting from any configuration, the network will reach a safe configuration where a single leader exists within a short time, and thereafter it will maintain the single leader for a long time, but not forever. The main contribution of the paper is a time-optimal loosely-stabilizing leader election protocol. While the shortest convergence time achieved so far in loosely-stabilizing leader election is $O(\log^3 n)$ parallel time, the proposed protocol with design parameter $\tau \ge 1$ attains $O(\tau \log n)$ parallel convergence time and $\Omega(n^{\tau})$ parallel holding time (i.e. the length of the period keeping the unique leader), both in expectation. This protocol is time-optimal in the sense of both the convergence and holding times in expectation because any loosely-stabilizing leader election protocol with the same length of the holding time is known to require $\Omega(\tau \log n)$ parallel time.

cs.DC↗

arXiv2020

The Power of Global Knowledge on Self-stabilizing Population Protocols

In the population protocol model, many problems cannot be solved in a self-stabilizing way. However, global knowledge, such as the number of nodes in a network, sometimes allows us to design a self-stabilizing protocol for such problems. In this paper, we investigate the effect of global knowledge on the possibility of self-stabilizing population protocols in arbitrary graphs. Specifically, we clarify the solvability of the leader election problem, the ranking problem, the degree recognition problem, and the neighbor recognition problem by self-stabilizing population protocols with knowledge of the number of nodes and/or the number of edges in a network.

cs.DC↗

arXiv2019

A Self-Stabilizing Minimal k-Grouping Algorithm

We consider the minimal k-grouping problem: given a graph G=(V,E) and a constant k, partition G into subgraphs of diameter no greater than k, such that the union of any two subgraphs has diameter greater than k. We give a silent self-stabilizing asynchronous distributed algorithm for this problem in the composite atomicity model of computation, assuming the network has unique process identifiers. Our algorithm works under the weakly-fair daemon. The time complexity (i.e., the number of rounds to reach a legitimate configuration) of our algorithm is O(nD/k) where n is the number of processes in the network and \diam is the diameter of the network. The space complexity of each process is O((n +n_{false})log n) where n_{false} is the number of false identifiers, i.e., identifiers that do not match the identifier of any process, but which are stored in the local memory of at least one process at the initial configuration. Our algorithm guarantees that the number of groups is at most $2n/k+1$ after convergence. We also give a novel composition technique to concatenate a silent algorithm repeatedly, which we call loop composition.

cs.DC↗

arXiv2019

Leader Election Requires Logarithmic Time in Population Protocols

This paper shows that every leader election protocol requires logarithmic stabilization time both in expectation and with high probability in the population protocol model. This lower bound holds even if each agent has knowledge of the exact size of a population and is allowed to use an arbitrarily large number of agent states. This lower bound concludes that the protocol given in [Sudo et al., SSS 2019] is time-optimal in expectation.

cs.DC↗