Polynomial Time Local Decision Revisited

Abstract: We consider three classification systems for distributed decision tasks: With unbounded computation and certificates, defined by Balliu, D'Angelo, Fraigniaud, and Olivetti [JCSS'18], and with (two flavors of) polynomially bounded local computation and certificates, defined in recent works by Aldema Tshuva and Oshman [OPODIS'23], and by Reiter [PODC'24]. The latter two differ in the way they evaluate the polynomial bounds: the former considers polynomials with respect to the size of the graph, while the latter refers to being polynomial in the size of each node's local neighborhood. We start by revisiting decision without certificates. For this scenario, we show that the latter two definitions coincide: roughly, a node cannot know the graph size, and thus can only use a running time dependent on its neighborhood. We then consider decision with certificates. With existential certificates ($Σ_1$-type classes), a larger running time defines strictly larger classes of languages: when it grows from being polynomial in each node's view, through polynomial in the graph's size, and to unbounded, the derived classes strictly contain each other. With universal certificates ($Π_1$-type classes), on the other hand, we prove a surprising incomparability result: having running time bounded by the graph size sometimes allows us to decide languages undecidable even with unbounded certificates. We complement these results with other containment and separation results, which together portray a surprisingly complex lattice of strict containment relations between the classes at the base of the three classification systems.

• The paper proves the equivalence of certificate-free polynomial-time local decision classes (PLD = LP*) and shows they are strictly weaker than centralized polynomial-time decision.
• It demonstrates that allowing existential certificates creates a strict hierarchy, where increased certificate bounds enable solving more complex languages.
• The study reveals that restricting certificate size can unintentionally leak global graph information, a discovery with significant implications for network verification.

Revisiting Polynomial-Time Local Decision in Distributed Complexity

Introduction and Background

The investigated paper addresses foundational questions in distributed computational complexity, particularly regarding the structure and relationships of polynomial-time decision and certification classes. The work builds upon several classification hierarchies for distributed decision tasks, originating from classic local decision and proof labeling schemes (PLS), and evolving towards more nuanced classes inspired by the polynomial hierarchy (PH) in classical complexity. Critical to this investigation are three systems:

• The Balliu et al. (2018) hierarchy, which allows unbounded local computation and certificates, revealing a hierarchy that collapses at the second level for decidable distributed languages.
• The Aldema Tshuva and Oshman (2023) framework, restricting local computation to polynomial time with respect to the entire graph size.
• The Reiter (2024) variant, restricting local computation and certificate size to polynomials in the size of each node's local neighborhood ("view"), rather than the global graph.

Understanding the fine-grained structure of these classes, especially in the lower levels of their respective hierarchies and under varying resource bounds, is crucial for both theory and applications of distributed decision.

Key Contributions and Results

Decision Without Certificates

A central result is the demonstrated equivalence between the two polynomial-time local decision classes when no certificates are used: polynomial in the graph size (global) and polynomial in the size of the local view (local). Formally, the class of languages locally decidable with polynomial time per node in the graph size ($\mathsf{PLD}$ as in [TshuvaO23]) and the one with time polynomial in the view ($\mathsf{LP*}$ as in [Reiter24]) are shown to coincide.

The core technical insight is that, in the absence of certificates, nodes lack access to the global graph size $n$ and cannot exploit a running time bound expressed as a function of $n$. Thus, polynomial-time bounds in $n$ effectively reduce to polynomial-time bounds in the (potentially much smaller) local view. This result establishes:

• $\mathsf{PLD} = \mathsf{LP*}$: Polynomial-time local decision with respect to graph size or view size is equivalent in the certificate-free case.

Additionally, it is shown that this class is strictly weaker than either centralized polynomial-time decision or local decision with unbounded time, formalized as $$\mathsf{PLD} \subsetneqq \mathsf{P} \cap \mathsf{LD}$$.

Existential Certificates ($\Sigma_1$-type Classes)

When existential certificates are permitted, the hierarchy behaves as intuition suggests:

• $$\Sigma_1^{\mathrm{LP}} \subsetneqq \Sigma_1^{\mathrm{PLD}} \subsetneqq \Sigma_1^{\mathrm{LD}}$$,

where $\Sigma_1^{\cdot}$ denotes existential-certificate classes parameterized by computation/certificate bounds. This chain is strictly increasing: larger bounds strictly increase the class of solvable languages. The separation results rely on explicit language constructions known in the literature, such as the “NOT-ALL-SELECTED” language for separating $\mathsf{LP*}$0 and $\mathsf{LP*}$1, and classical applications of the space hierarchy theorem for the uppermost class.

Universal Certificates ($\mathsf{LP*}$2-type Classes) and Incomparability Phenomena

A major, counter-intuitive finding is the incomparability between certain classes with universal certificates:

• Certificate size bounded by graph size gives strictly more power than certificate size bounded by local view, but does not always increase power monotonically. In some cases, bounding certificate size by the graph may allow decision of tasks undecidable even with unbounded certificates if the bound is not carefully controlled.
• Incomparability: The classes $\mathsf{LP*}$3 (polynomial certificates in graph size) and $\mathsf{LP*}$4 (unbounded time/certificates) are incomparable. One constructed language, "All Greater Than size of Graph", is in $\mathsf{LP*}$5 but not in $\mathsf{LP*}$6, since the certificate size bound leaks information about the global size $\mathsf{LP*}$7—a property inaccessible in the unbounded case.
• Explicit use of certificate size: The result demonstrates that, contrary to expectation, restricting certificate size can sometimes increase the power of the model due to information-theoretic leakage about global graph parameters.

Impact of Additional Knowledge (Graph Size)

The study further explores the impact of giving nodes explicit knowledge of the global graph size $\mathsf{LP*}$8 (class $\mathsf{LP*}$9). Informing the nodes of $n$0 strengthens the class further compared to not knowing $n$1, and the resulting class remains incomparable with $n$2.

Hierarchy of Classes and Simulations

The authors systematically establish the relationships between all considered classes, proving strict contaiments and separations where possible, and formally characterizing incomparability through concrete language separations. Simulation results demonstrate that increased locality can in some cases substitute for polynomial bounds in local decision, but not vice versa.

Implications

The results have significant implications for distributed complexity theory. The nuanced hierarchy emphasizes:

• The critical role of knowledge and certificate-bounding mechanisms: Knowing the global graph size, or being able to infer it via certificate size bounds, yields distinct computational power unattainable with local-only or unbounded resources.
• The unreliability of analogies to centralized complexity: In the local distributed setting, resource bounds and information flows interact in ways fundamentally distinct from centralized Turing machine models. Hierarchies that collapse or separate in the centralized case may behave unpredictably in distributed settings.
• Practical considerations: In the design of distributed certification systems (e.g., for network verification or security), careful attention must be paid to how resource bounds and protocol assumptions might inadvertently leak global information, breaking intended security or locality properties.

Outlook and Future Directions

This refined understanding of distributed polynomial-time hierarchies invites further investigation along several directions:

• Formalization and exploitation of information-leakage effects induced by bounded certificates, possibly adapting cryptographic notions,
• Deeper exploration of randomized certification classes, and the impact of randomness on distributed decision hierarchies,
• Studying analogous hierarchy behavior for decision problems on dynamic or anonymous networks, where node knowledge is further restricted,
• Practical algorithms for certifiable local computation that robustly distinguish between global and local complexity under varying adversarial models.

Conclusion

The revisited framework offers a comprehensive and technically rigorous classification of polynomial-time local decision and certification classes, revealing subtleties in containment, separation, and incomparability that challenge prior intuition from both distributed and centralized perspectives. The paper serves as a reference point for ongoing theoretical developments and practical considerations in distributed decision and certification.