arXiv subjects

Julian Werthmann

Publications and source records attributed to Julian Werthmann.

9 recordsLinked to original sources

arXiv2026

Supervised Distributed Computing: Efficiency and Robustness under a Majority of Adversarial Workers

We consider a recently proposed \emph{supervised distributed computing} paradigm \cite{augustine2025supervised} that extends and refines the standard master-worker paradigm for parallel computations. In this paradigm, there is a supervisor, a source, a target, and a collection of workers. The distributed computation is given as an acyclic task graph that is known to the supervisor. The source initially stores the input and the target is supposed to store the output of the computation. The individual tasks of the computation are supposed to be executed by the workers under the guidance of the supervisor. The source, target and supervisor are assumed to be reliable, while a $\beta$-fraction of the workers might be adversarial, for some $\beta \in [0,1)$. This covers, for example, the case where a supervisor has to work with untrusted volunteers. In the standard master-worker approach, the master checks whether the workers correctly execute the assigned tasks, creating a severe bottleneck, whereas in the supervised approach, the supervisor outsources this checking to the workers. Prior to this work, only supervised solutions were known for the case that $\beta$ is a sufficiently small constant. We show that robust and efficient supervised solutions are possible for \emph{any} constant $\beta<1$ while the expected work for the honest workers is close to a \emph{single} execution per task, given that there is a lightweight verification mechanism that allows honest workers to check the correctness of task outputs, which is significantly better than all robust master-worker as well as peer-to-peer approaches known so far.

cs.DC↗

arXiv2026

Logarithmic-Time Geodesically Convex Decomposition in Programmable Matter

The decomposition of complex structures into simpler substructures is a powerful technique with a wide range of applications. We study the computation of decompositions in the context of programmable matter. The amoebot model is a well-established model for programmable matter, which places $n$ tiny robots called amoebots on the triangular grid. We consider the reconfigurable circuit extension of the geometric amoebot model, which allows amoebots to interconnect via so-called circuits. Amoebots can then instantaneously transmit simple beeps to all amoebots connected by the same circuit. Using reconfigurable circuits, previous papers have described a linear-time triangulation algorithm, and a logarithmic-time decomposition algorithm into so-called tunnel regions. Both algorithms only work on a restricted class of amoebot structures. In this paper, we define a decomposition into $O(|\mathcal H|)$ simple, geodesically convex regions for arbitrary amoebot structures, and show how it can compute such a decomposition in $O(\log n)$ rounds, where $|\mathcal H|$ denotes the number of holes in the amoebot structure. As a byproduct, we also improve the global maxima algorithm of Padalkin et al. (Nat. Comput., 2024) for special cases and with that also their spanning tree algorithm to $O(\log n)$ rounds w.h.p.

cs.DC↗

arXiv2025

Simulations between Strongly Sublinear MPC and Node-Capacitated Clique

We study how the Massively Parallel Computation (MPC) model in the strongly sublinear regime relates to the classic, graph-centric distributed models, focusing on the Node-Capacitated Clique (NCC), a bandwidth-parametrized generalization of the Congested Clique. In MPC, $M$ machines with per-machine memory $S$ hold a partition of the input graph. In NCC, we are given $n$ nodes that are themselves machines that know their full neighborhood but can send/receive only a bounded number of $C$ words per round. We are interested in the strongly sublinear regime where $S=n^\delta$, for some constant $0 < \delta <1$ and $C = MS/n$, where no simulation results are known. We explore when deterministic round-preserving simulations between these models are possible and when they are provably not, for different model parameters, problem families and graph classes. On the positive side, we provide techniques that allow, under certain restrictions, simulations with only constant overhead. On the negative side, we prove simulation impossibility results, which show that the limitations of our simulation results are inherent.

cs.DC↗

arXiv2025

Supervised Distributed Computing

We introduce a new framework for distributed computing that extends and refines the standard master-worker approach of scheduling multi-threaded computations. In this framework, there are different roles: a supervisor, a source, a target, and a collection of workers. Initially, the source stores some instance $I$ of a computational problem, and at the end, the target is supposed to store a correct solution $S(I)$ for that instance. We assume that the computation required for $S(I)$ can be modeled as a directed acyclic graph $G=(V,E)$, where $V$ is a set of tasks and $(v,w) \in E$ if and only if task $w$ needs information from task $v$ in order to be executed. Given $G$, the role of the supervisor is to schedule the execution of the tasks in $G$ by assigning them to the workers. If all workers are honest, information can be exchanged between the workers, and the workers have access to the source and target, the supervisor only needs to know $G$ to successfully schedule the computations. I.e., the supervisor does not have to handle any data itself like in standard master-worker approaches, which has the tremendous benefit that tasks can be run massively in parallel in large distributed environments without the supervisor becoming a bottleneck. But what if a constant fraction of the workers is adversarial? Interestingly, we show that under certain assumptions a data-agnostic scheduling approach would even work in an adversarial setting without (asymptotically) increasing the work required for communication and computations. We demonstrate the validity of these assumptions by presenting concrete solutions for supervised matrix multiplication and sorting.

cs.DC↗

arXiv2024

Distributed And Parallel Low-Diameter Decompositions for Arbitrary and Restricted Graphs

We consider the distributed and parallel construction of low-diameter decompositions with strong diameter for (weighted) graphs and (weighted) graphs that can be separated through $k \in \tilde{O}(1)$ shortest paths. This class of graphs includes planar graphs, graphs of bounded treewidth, and graphs that exclude a fixed minor $K_r$. We present algorithms in the PRAM, CONGEST, and the novel HYBRID communication model that are competitive in all relevant parameters. Given $\mathcal{D} > 0$, our low-diameter decomposition algorithm divides the graph into connected clusters of strong diameter $\mathcal{D}$. For a arbitrary graph, an edge $e \in E$ of length $\ell_e$ is cut between two clusters with probability $O(\frac{\ell_e\cdot\log(n)}{\mathcal{D} })$. If the graph can be separated by $k \in \tilde{O}(1)$ paths, the probability improves to $O(\frac{\ell_e\cdot\log \log n}{\mathcal{D} })$. In either case, the decompositions can be computed in $\tilde{O}(1)$ depth and $\tilde{O}(kn)$ work in the PRAM and $\tilde{O}(1)$ time in the HYBRID model. In CONGEST, the runtimes are $\tilde{O}(HD + \sqrt{n})$ and $\tilde{O}(HD)$ respectively. All these results hold w.h.p. Broadly speaking, we present distributed and parallel implementations of sequential divide-and-conquer algorithms where we replace exact shortest paths with approximate shortest paths. In contrast to exact paths, these can be efficiently computed in the distributed and parallel setting [STOC '22]. Further, and perhaps more importantly, we show that instead of explicitly computing vertex-separators to enable efficient parallelization of these algorithms, it suffices to sample a few random paths of bounded length and the nodes close to them. Thereby, we do not require complex embeddings whose implementation is unknown in the distributed and parallel setting.

cs.DC↗

arXiv2023

Distributed Construction of Near-Optimal Compact Routing Schemes for Planar Graphs

We consider the problem of computing compact routing tables for a (weighted) planar graph $G:= (V, E,w)$ in the PRAM, CONGEST, and the novel HYBRID communication model. We present algorithms with polylogarithmic work and communication that are almost optimal in all relevant parameters, i.e., computation time, table sizes, and stretch. All algorithms are heavily randomized, and all our bounds hold w.h.p. For a given parameter $\epsilon>0$, our scheme computes labels of size $\widetilde{O}(\epsilon^{-1})$ and is computed in $\widetilde{O}(\epsilon^{-2})$ time and $\widetilde{O}(n)$ work in the PRAM and the HYBRID model and $\widetilde{O}(\epsilon^{-2} \cdot HD)$ (Here, $HD$ denotes the network's hop-diameter) time in CONGEST. The stretch of the resulting routing scheme is $1+\epsilon$. To achieve these results, we extend the divide-and-conquer framework of Li and Parter [STOC '19] and combine it with state-of-the-art distributed distance approximation algorithms [STOC '22]. Furthermore, we provide a distributed decomposition scheme, which may be of independent interest.

cs.DS↗

arXiv2022

Routing Schemes for Hybrid Communication Networks

We consider the problem of computing routing schemes in the $\mathsf{HYBRID}$ model of distributed computing where nodes have access to two fundamentally different communication modes. In this problem nodes have to compute small labels and routing tables that allow for efficient routing of messages in the local network, which typically offers the majority of the throughput. Recent work has shown that using the $\mathsf{HYBRID}$ model admits a significant speed-up compared to what would be possible if either communication mode were used in isolation. Nonetheless, if general graphs are used as the input graph the computation of routing schemes still takes polynomial rounds in the $\mathsf{HYBRID}$ model. We bypass this lower bound by restricting the local graph to unit-disc-graphs and solve the problem deterministically with running time $O(|\mathcal H|^2 \!+\! \log n)$, label size $O(\log n)$, and size of routing tables $O(|\mathcal H|^2 \!\cdot\! \log n)$ where $|\mathcal H|$ is the number of ``radio holes'' in the network. Our work builds on recent work by Coy et al., who obtain this result in the much simpler setting where the input graph has no radio holes. We develop new techniques to achieve this, including a decomposition of the local graph into path-convex regions, where each region contains a shortest path for any pair of nodes in it.

cs.DC↗

arXiv2021

Beep-And-Sleep: Message and Energy Efficient Set Cover

We observe message-efficient distributed algorithms for the Set Cover problem. Given a ground set $U$ of $n$ elements and $m$ subsets of $U$, we aim to find the minimal number of these subsets that contain all elements. In the default distributed setup of this problem, each set has a bidirected communication link with each element it contains. Our first result is a $\tilde{O}(\log^2(\Delta))$-time and $O(\sqrt{\Delta)}(n+m))$-message algorithm with expected approximation ration of $O(\log(\Delta))$ in the $KT_0$ model. The value $\Delta$ denotes the maximal cardinality of each subset. Our algorithm is \emph{almost} optimal with regard to time and message complexity. Further, we present Set Cover algorithm in the Beeping model that only relies on carrier-sensing and can trade runtime for approximation ratio similar to the celebrated algorithm by Kuhn and Wattenhofer [PODC '03].

cs.DC↗

arXiv2020

Time-Optimal Construction of Overlay Networks

We show how to construct an overlay network of constant degree and diameter $O(\log n)$ in time $O(\log n)$ starting from an arbitrary weakly connected graph. We assume a synchronous communication network in which nodes can send messages to nodes they know the identifier of, and new connections can be established by sending node identifiers. If the initial network's graph is weakly connected and has constant degree, then our algorithm constructs the desired topology with each node sending and receiving only $O(\log n)$ messages in each round in time $O(\log n)$, w.h.p., which beats the currently best $O(\log^{3/2} n)$ time algorithm of [G\"otte et al., SIROCCO'19]. Since the problem cannot be solved faster than by using pointer jumping for $O(\log n)$ rounds (which would even require each node to communicate $\Omega(n)$ bits), our algorithm is asymptotically optimal. We achieve this speedup by using short random walks to repeatedly establish random connections between the nodes that quickly reduce the conductance of the graph using an observation of [Kwok and Lau, APPROX'14]. Additionally, we show how our algorithm can be used to efficiently solve graph problems in \emph{hybrid networks} [Augustine et al., SODA'20]. Motivated by the idea that nodes possess two different modes of communication, we assume that communication of the \emph{initial} edges is unrestricted, whereas only polylogarithmically many messages can be communicated over edges that have been established throughout an algorithm's execution. For an (undirected) graph $G$ with arbitrary degree, we show how to compute connected components, a spanning tree, and biconnected components in time $O(\log n)$, w.h.p. Furthermore, we show how to compute an MIS in time $O(\log d + \log \log n)$, w.h.p., where $d$ is the initial degree of $G$.

cs.DC↗