On the distributed evaluation of recursive queries over graphs

Logical formalisms such as first-order logic (FO) and fixpoint logic (FP) are well suited to express in a declarative manner fundamental graph functionalities required in distributed systems. We show that these logics constitute good abstractions for programming distributed systems as a whole, since they can be evaluated in a fully distributed manner with reasonable complexity upper-bounds. We first prove that FO and FP can be evaluated with a polynomial number of messages of logarithmic size. We then show that the (global) logical formulas can be translated into rule programs describing the local behavior of the nodes of the distributed system, which compute equivalent results. Finally, we introduce local fragments of these logics, which preserve as much as possible the locality of their distributed computation, while offering a rich expressive power for networking functionalities. We prove that they admit tighter upper-bounds with bounded number of messages of bounded size. Finally, we show that the semantics and the complexity of the local fragments are preserved over locally consistent networks as well as anonymous networks, thus showing the robustness of the proposed local logical formalisms.

💡 Research Summary

The paper investigates the use of logical formalisms—first‑order logic (FO) and fixpoint logic (FP)—as high‑level, declarative specifications for graph‑based functionalities in distributed systems, and it establishes rigorous bounds on their distributed evaluation. The authors first show that any FO query can be evaluated across a network using only a polynomial number of messages, each of logarithmic size, while each node’s per‑round computational effort remains O(log n). For FP, a similar bound holds, with the additional cost that the number of distributed rounds may be polynomial in the size of the graph, reflecting the iterative nature of fixpoint computation.

A central contribution is the systematic translation of global logical formulas into local rule programs that can be executed by individual nodes. To this end the authors introduce Netlog, an extension of Datalog enriched with communication primitives (send, broadcast, etc.). They prove that any FO or FP formula can be compiled into an equivalent Netlog program, preserving semantics. Consequently, a global property such as “the graph contains a spanning tree” or “each node maintains a routing table” can be expressed once as a logical formula and automatically turned into a distributed algorithm where each node only manipulates its local state and messages from neighbors.

Recognizing that unrestricted FO and FP may still incur high communication costs, the paper defines two local fragments, FO_loc and FP_loc. These fragments restrict the use of quantifiers and the shape of fixpoint operators so that the number of messages exchanged and their size become bounded by constants (or at most logarithmic in the network size). Despite these restrictions, the fragments remain expressive enough to capture essential networking tasks: spanning‑tree construction, on‑demand routing, table‑based routing protocols, and other classic distributed algorithms. The authors provide concrete examples showing how FP_loc can encode a table‑based routing protocol similar to OLSR, and how FO_loc can express simple local checks with constant‑time distributed evaluation.

A notable robustness result is that the complexity guarantees for FO_loc and FP_loc hold not only on standard bounded‑degree synchronous networks but also on locally consistent networks (where neighboring nodes share consistent local views) and on anonymous networks (where nodes lack unique identifiers). This demonstrates that the logical abstractions are largely independent of the underlying topology and identifier scheme.

The paper also includes a detailed complexity analysis. For centralized evaluation, FO queries require O(n^v log n) time, O(Δ) distributed time, O(log n) message size, and O(n) total messages, where v is the number of variables and Δ the network diameter. Distributed evaluation improves the per‑node computational load to O(log n) per round while preserving polynomial total communication. For FP, the per‑round computation may increase to O(n^ℓ + v log n) (ℓ being the arity of the fixpoint relation), but the overall communication remains polynomial. In the special case of a clique (unbounded degree), the model collapses to Boolean circuits, yielding constant distributed time analogous to the classical AC⁰ bound.

Finally, the authors discuss extensions to unrestricted degree graphs and asynchronous settings, noting that while many algorithmic ideas carry over, the tight complexity bounds may not. They argue that the presented logical framework offers a powerful, high‑level programming model for distributed systems, bridging the gap between declarative database query theory and practical network protocol design. The work thus provides both theoretical insights and a concrete pathway for building robust, scalable distributed applications using logical specifications.