Locally Computing Edge Orientations

2025-01-03

Embedded Systems and Applications

AI Summary

This paper studies the local computation algorithm (LCA) problem of edge orientation in graphs: given a graph $G$, assign directions to edges so that each vertex’s out-degree approximates its arboricity $alpha$, with sublinear probe complexity per query. First, it establishes the first probe-complexity lower bound for edge orientation in the LCA model—$Omega(sqrt{n}/r)$ for forests—breaking the $Omega(n)$ barrier inherent to conventional peeling-based approaches. Second, it introduces a novel algorithm integrating edge coloring and shattering-like techniques. Third, for bounded-degree trees, it designs an LCA with probe complexity $Delta cdot n^{1-log_Delta r + o(1)}$. Finally, it presents a sublinear-probe LCA for 4-edge-coloring of trees. Collectively, these results advance the theoretical foundations for sublinear-query processing in distributed and massive-scale graph analytics.

Technology Category

• Search and Optimization: Distributed Search
• Machine Learning: Graph-based Machine Learning
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Algorithms and analysis for incomplete, noisy, or partially observed Web-related graphs
• Social Networks and Social Media: Social mining and social search on the Web
• Security and Privacy: Data transparency and provenance

Abstract

We consider the question of orienting the edges in a graph $G$ such that every vertex has bounded out-degree. For graphs of arboricity $alpha$, there is an orientation in which every vertex has out-degree at most $alpha$ and, moreover, the best possible maximum out-degree of an orientation is at least $alpha - 1$. We are thus interested in algorithms that can achieve a maximum out-degree of close to $alpha$. A widely studied approach for this problem in the distributed algorithms setting is a ``peeling algorithm'' that provides an orientation with maximum out-degree $alpha(2+epsilon)$ in a logarithmic number of iterations. We consider this problem in the local computation algorithm (LCA) model, which quickly answers queries of the form ``What is the orientation of edge $(u,v)$?'' by probing the input graph. When the peeling algorithm is executed in the LCA setting by applying standard techniques, e.g., the Parnas-Ron paradigm, it requires $Omega(n)$ probes per query on an $n$-vertex graph. In the case where $G$ has unbounded degree, we show that any LCA that orients its edges to yield maximum out-degree $r$ must use $Omega(sqrt n/r)$ probes to $G$ per query in the worst case, even if $G$ is known to be a forest (that is, $alpha=1$). We also show several algorithms with sublinear probe complexity when $G$ has unbounded degree. When $G$ is a tree such that the maximum degree $Delta$ of $G$ is bounded, we demonstrate an algorithm that uses $Delta n^{1-log_Delta r + o(1)}$ probes to $G$ per query. To obtain this result, we develop an edge-coloring approach that ultimately yields a graph-shattering-like result. We also use this shattering-like approach to demonstrate an LCA which $4$-colors any tree using sublinear probes per query.

Problem

• Local Computation Algorithm
• Graph Orientations
• Sublinear Query Complexity

Innovation

• Local Computation Algorithm
• Edge Direction Determination
• Graph Coloring