Locally Checkable Proofs in Distributed Computing

: We study decision problems related to graph properties from the perspective of nondeterministic distributed algorithms . For a yes -instance there must exist a proof that can be veriﬁed with a distributed algorithm: all nodes must accept a valid proof, and at least one node must reject an invalid proof. We focus on locally checkable proofs that can be veriﬁed with a constant-time distributed algorithm. For example, it is easy to prove that a graph is bipartite: the locally checkable proof gives a 2-coloring of the graph, which only takes 1 bit per node. However, it is more difﬁcult to prove that a graph is not bipartite—it turns out that any locally checkable proof requires Ω ( log n ) bits per node. In this paper we classify graph properties according to their local proof complexity, i. e., how many bits per node are needed in a locally checkable proof. We establish tight or near-tight results for classical graph properties such as the chromatic number. We show that the local proof complexities form a natural hierarchy of complexity classes: for many classical graph properties, the local proof complexity is either 0, Θ ( 1 ) , Θ ( log n ) , or poly ( n ) bits per node. Among the most difﬁcult graph properties are proving that a graph is symmetric (has a non-trivial automorphism), which requires Ω ( n 2 ) bits per node, and proving that a graph is not 3-colorable, which requires Ω ( n 2 / log n ) bits per node. Any property of connected graphs admits a trivial proof with O ( n 2 ) bits per node.


Introduction
This paper studies decision problems related to graph properties from the perspective of distributed graph algorithms.In distributed graph algorithms, the nodes of an unknown communication network (modeled as a graph) work together in order to solve graph problems related to the structure of the communication graph itself.As argued by Fraigniaud in his PODC 2010 keynote talk [10], the appropriate model for distributed yes-no verification is the following: • For a yes-instance, all nodes must output 1.
• For a no-instance, at least one node must output 0.
Intuitively, if we have an acceptable input, all nodes will be happy, and if we have an invalid input, at least one node has to raise the alarm.
Our focus is on distributed verification that is made locally, by using a constant-time distributed algorithm [21,29].Throughout this paper, we follow the convention that the running time of a distributed algorithm equals the number of synchronous communication rounds.In particular, in a local algorithm all nodes stop after O(1) communication rounds and announce their outputs.Equivalently, each node makes its yes-no decision based on its constant-radius neighborhood in the communication graph.
Recall that a graph property is a family of graphs that is closed under isomorphism.We say that a graph property P is locally checkable if it can be checked by a local algorithm.That is, there exists a local algorithm, called verifier, that accepts all yes-instances G ∈ P and rejects all no-instances G / ∈ P.
Examples.An easy example of a locally checkable property is determining if a given connected graph is Eulerian: it is sufficient that each node outputs 1 if its degree is even, and 0 otherwise.Another example is checking if a given graph is a line graph.If the nodes have unique identifiers, a constant-time verifier can check that the graph does not contain any of the nine forbidden subgraphs in Beineke's [5] characterization of line graphs.
However, local checkability as such does not seem to lead to an interesting complexity theory-for many well-studied graph properties, it is often easy to show that they are not locally checkable.The key insight of Korman et al. [15,16,18,19] is to study locally checkable proofs.

Locally checkable proofs
To illustrate the idea of locally checkable proofs, we start with a canonical example.Consider the problem of checking if a given graph is bipartite.This is not a locally checkable property-indeed, if we consider odd vs. even cycles, we can see that any verifier that solves the problem must have the running time Ω(n).However, if we want to convince a local algorithm that the graph is indeed bipartite, we can augment the graph with a locally checkable proof.It is sufficient to give 1 bit of proof per node: if the graph is bipartite, we can give a 2-coloring of the graph as the proof, and a local verifier can check that the proof is correct.Conversely, if the graph is not bipartite, no matter what proof bits we choose, at least one node will detect that the proof is invalid.Hence we say the property of bipartiteness is in the class LCP(1): for any bipartite graph, there is a locally checkable proof of size 1 bit per node.Precise definitions are given in Section 2.
The concept of locally checkable proofs is related to locally checkable properties as the familiar complexity class NP is related to the class P. If a problem is in NP, then yes-instances have a concise proof that can be verified in P. Similarly, if the problem is in LCP( f ), then yes-instances have a concise proof with at most f (n) bits per node and the proof itself is checkable with a local algorithm.Equivalently, we can interpret locally checkable proofs as nondeterministic local algorithms: in the algorithm, each node can nondeterministically guess f (n) bits.

Class
Proof  an exception, we study anonymous models without unique identifiers in Sections 7.1-7.2.) Depending on the problem that we study, nodes and edges may also be associated with weights, colors, labels, etc.; if this is the case, we say that the graph is labeled, and otherwise it is unlabeled.

Proofs, verifiers and locality
Proofs.A proof P for G is a function P : V (G) → {0, 1} that associates a binary string with each node of G.The size |P| of a proof P is the maximum number of bits in any string P(v), over all v ∈ V (G).We write ε for an empty proof of size 0.

Verifiers.
A verifier A is a function that maps each triple (G, P, v) to a binary output 0 or 1.Here G ∈ F is a graph, P : Remark 2.1.The issue of whether or not A is computable (or polynomial-time bounded) is usually immaterial to our considerations.For simplicity, we do not impose any such resource constraints on A; our focus will be on studying the limitations of verifiers arising from locality-as defined next.
Local verifiers.For a natural number r ∈ N and a node v ∈ V (G), let V [v, r] ⊆ V (G) be the ball of radius r about v, i. e., set of nodes that are within distance r from v (the shortest path from v to any node in V [v, r] has at most r edges).Let G[v, r] be the subgraph of G induced by V [v, r], and let A verifier A is a local verifier if there exists a constant r ∈ N such that That is, the output of a node v only depends on the input in its radius-r neighborhood.Constant r is the local horizon of A. (Alternatively, if we consider Peleg's [25] LOCAL model, a local verifier can be defined as a constant-time distributed algorithm: a local verifier with horizon r can be implemented as a distributed message-passing algorithm that completes in r synchronous communication rounds.)(i) Completeness: If G ∈ P then there exists a proof P :

Locally checkable proofs
That is, yes-instances have a valid proof that is accepted by all nodes, while no-instances are always rejected by at least one node.If f is a function that associates a valid proof P = f (G) with each G ∈ P, we say that the pair ( f , A) is a proof labeling scheme.
If a property P admits locally checkable proofs of size s, we write P ∈ LCP(s).We use coLCP(s) to denote the class of graph properties whose complement is in LCP(s); that is, if F \ P ∈ LCP(s), we write P ∈ coLCP(s).The class LogLCP consists of properties that are in LCP(s) for s = O(log n); we will see in Section 5 that LogLCP admits many alternative characterizations, which makes it a particularly robust class.
Examples.As we observed in Section 1, Eulerian graphs and line graphs can be verified without a proof, and hence they are in LCP(0).As further observed in Section 1.1, bipartite graphs are not in LCP(0) but they are contained in LCP(1), as they can be verified with one bit of input per node.More generally, if a graph has chromatic number at most k, we can prove it with log k bits per node: simply give a proper k-coloring as the proof.

Extension: solutions to graph problems
If we consider labeled graphs, we can also define graph properties such as independent sets ("nodes with label 1 form an independent set") or spanning trees ("edges with label 1 induce a spanning tree").That is, we can interpret the labeling as a solution to a graph problem, and we can extend the definitions of locally checkable proofs to verify solutions of graph problems.Formally, a graph problem P associates any graph G ∈ F with a set P(G) of solutions; each solution is a labeled version of graph G. Contrary to the setting of graph properties, there are two natural variants to verifying solutions of graph problem P: • Strong proof labeling scheme ( f , A): for any graph G ∈ F, for any solution X ∈ P(G), there is a locally checkable proof f (X) that is accepted by A, and any incorrect labeling X / ∈ P(G) is rejected by A.
• Weak proof labeling scheme ( f , A): for any graph G ∈ F, there is at least one solution X ∈ P(G) such that there is a locally checkable proof f (X) that is accepted by A, and any incorrect labeling X / ∈ P(G) is rejected by A.
Put differently, in a strong proof labeling scheme, an adversary can choose both the input and the solution, and we must come up with a locally checkable proof.However, in a weak proof labeling scheme, an adversary chooses the input but we can choose a solution.These two notions are different even for natural verification tasks.
Example 2.3 (Separating Strong from Weak).Consider the task of verifying whether a set of vertices C ⊆ V (G) is a 2-approximation of a minimum vertex cover.It is straightforward to prove that without proof bits, no strong proof labeling scheme exists for this task, i. e., the approximation ratio achieved by an arbitrary C cannot be determined locally.On the other hand, on bounded-degree graphs there is a constant-time local algorithm [4] that always outputs a set C * ⊆ V (G) that is a 2-approximation of the minimum vertex cover-it is this C = C * that we can verify without proof bits in the weak sense.
In contrast to the above example, for the remaining problems studied in this paper, the local proof complexities of strong and weak proof labeling schemes are within a constant factor of each other.All proof labeling schemes that we will exhibit are of the strong variety whereas our lower-bound results preclude not only the existence of strong proof labeling schemes for various problems, but also the existence of weak proof labeling schemes.

Comparison with other models
Determinism.Our definition of the LCP hierarchy is an extension of locally checkable labelings (LCL) introduced by Naor and Stockmeyer [21] in their seminal work.Naor and Stockmeyer focus on boundeddegree graphs and constant-size labels, but if we generalize the class LCL in a straightforward manner, we arrive at the class LCP(0).
Our classes LCP( f ) with f > 0 thus extend the classical LCL concept by providing f (n) bits of additional information per node.We have chosen the terminology "LCP" to emphasize this connection, admitting that it is a departure from some of the other terminology available in the literature, as outlined next.
Nondeterminism.Our model is not the first, nor the last attempt at introducing nondeterminism in the setting of local decision problems.Indeed, similar extensions have appeared in prior and independent work.Two specific competing models are • proof labeling schemes of Korman et al. [15,16,18,19], and • nondeterministic local decision of Fraigniaud et al. [11].
Our LCP model is the strongest among the trio: positive results in the other models imply positive results in our model; this makes our lower-bound results widely applicable.In short, while an LCP verifier algorithm is limited only by locality, the verifiers in the other two models have additional restrictions.

Proof labeling schemes
The proof labeling scheme model of Korman et al. [15,16,18,19] is inspired by the classical notion of labeling schemes (see Gavoille and Peleg [12] for a survey).In this model, (i) the verifier has run-time of 1 communication round, and (ii) a node cannot see the identifiers nor the input labels of its neighboring nodes.
That is, the output of a single node must be determined on the basis of its own identifier, own input label, own proof label and the proof labels of the neighboring nodes.Thus, an upper bound on the local proof complexity in this model provides an extremely efficient local checking procedure.
Because of these restrictions, verifiers in the proof labeling scheme model are sometimes rather weak.For example, there are simple LCL problems that cannot be solved without proof labels in this model: one example is the agreement problem of checking whether all nodes in a connected graph are assigned the same input label [18, Lemma 2.3]; another example is checking whether the input graph is triangle-free.Hence the notion of proof labeling schemes is not a straightforward generalization of the LCL model-something our LCP model strives to be.
However, we note that in some cases the gap between the models can be bridged at the cost of an additive proof-size overhead of Θ(log n)-or however many bits of local data (node identifiers, input labels) are hidden by the restrictions (i)-(ii).This means, for instance, that the two models admit roughly the same analysis at the LCP(poly(n)) level (Section 6).
In comparison with prior work related to proof labeling schemes, the main challenges of the present paper can be summarized as follows: 1. Logarithmic lower bounds from prior work do not apply directly.It is harder to fool an LCP verifier that sees all the information available in its constant-radius neighborhood (in particular, O(log n)-bit identifiers).Therefore we need stronger techniques to prove Ω(log n) proof-size lower bounds in Section 5.
2. Superlogarithmic lower bounds would apply, but few such bounds are known for graph properties.It seems that the main focus in the prior work has been on problems related to labeled graphs.We can reuse ideas from prior work in Sections 6.1-6.2 in the context of symmetric graphs, but we are not aware of any prior work related to non-3-colorability that we could apply in Section 6.3.
For logarithmic lower bounds, our novel idea is to invoke an extremal result of Bondy and Simonovits [6] in the context of a "gluing" argument.For superlogarithmic lower bounds, the novel idea is to apply the disjointness problem to construct a difficult graph problem, while prior work has focused on constructions that are based on equality.

Nondeterministic local decision
Independently of our work, Fraigniaud et al. [11] have also studied nondeterminism (along with randomness) in the context of distributed decision problems.Here, the major difference to our model is that the local proofs P : V (G) → {0, 1} are not allowed to depend on the identifier assignment on G.This implies, for example, that many leader election problems are not solvable at all in their model, no matter how large P is (cf.Section 7.1).
To connect the results of

Problems in LCP(O(1))
As a warm-up, this section gives examples of graph properties and graph problems that admit locally checkable proofs of size O(1) but for which there is no locally checkable proof of size 0. We will see that many fundamental problems related to graph connectivity are in this class.

Reachability
To ask meaningful questions about connectivity in the LCP model, we require that two nodes s and t are always distinguished in the input graph G; that is, we have the promise that there is exactly one node with label s and exactly one node with label t.It is easy to see that in LCP(0) we cannot check whether there is a path from s to t in G.However, many questions related to reachability and connectivity are in Let us first consider the s-t reachability problem in an undirected graph G, i. e., proving that there is a path from s to t.This problem admits a locally checkable proof of size 1: we find a shortest path from s to t in G, define that U ⊆ V consists of all nodes on the shortest path, and set P(v) = 1 iff v ∈ U. A verifier can locally check that: (i) s,t ∈ U; (ii) s and t have unique neighbors in U; and (iii) every u ∈ U \ {s,t} has exactly two neighbors in U [14, p. 130].
Interestingly, the above method breaks down in directed graphs because of back-edges.In graphs of maximum degree ∆, one can still give an easy upper bound of O(log ∆) by using edge pointers in the proof labeling to describe a path from s to t, but it is an open problem whether directed s-t reachability is in LCP(O(1)) for general graphs (see also Ajtai and Fagin [1]).
However, it is easy to show that the complement of the above problem, s-t unreachability, is in LCP(O(1)) both for undirected and directed graphs.We find a partition S ∪ T of V such that s ∈ S, t ∈ T , and there is no (directed) edge from S to T .Such a partition can be encoded with 1 bit per node, and it can be verified locally.

Connectivity
As a natural generalization of reachability, we can study the s-t connectivity of undirected graphs; throughout this text, we focus on the vertex connectivity.By extending the techniques of Korman et al. [18] we can show that graphs with s-t connectivity equal to k admit locally checkable proofs of size O(log k).Here we assume that k is given as input to all nodes (or, equivalently, that k is a global constant).
If and only if the vertex connectivity is exactly k, then by Menger's theorem [7, p. 62] we can find (i) a partition S ∪ C ∪ T of V such that s ∈ S, t ∈ T , and |C| = k, and (ii) k vertex-disjoint s-t paths p 1 , p 2 , . . ., p k such that |C ∩ p i | = 1.Without loss of generality, we can assume that each p i is locally minimal in the sense that it cannot be made shorter without colliding with the other paths p j , j = i.
The proof label P(v) encodes whether v ∈ S, v ∈ C, or v ∈ T .Moreover, in the proof label P(v) of a vertex v ∈ p i \ {s,t}, we include the path index i (in binary) and also the distance of v from s modulo 3: this allows us to store the orientation on the path p i .The local verifier can verify that: 1. Nodes s and t have exactly k neighbors labeled with path indices 1, 2, . . ., k. 2. Each v ∈ p i \ {s,t} has exactly one predecessor and one successor along p i .3. We have s ∈ S, t ∈ T , and there is no edge between S and T .4. Each v ∈ C is on a path p i , its predecessor along p i is in S and its successor is in T .
If the above checks go through, the structure encoded by the proof P contains exactly k disjoint s-t paths.It may contain some oriented cycles inside S or inside T as well, but this is sufficient to convince the verifier that the connectivity of s and t is at least k.Moreover, if a path crosses C, its color changes from S to T ; its color cannot change back to S, and it cannot disappear without reaching t.Hence the above checks are also sufficient to convince the verifier that the size of the s-t separator C is at most k.In summary, s-t-connectivity has to be equal to k.
Finally, we note that the sole source for the O(log k) label size was the need to store the path indices.However, on planar graphs, only 3 path indices suffice to tell adjacent paths from one another; an adaptation of the above method gives a constant size proof in the case of planar graphs.

Bipartite matching
While maximal matchings can be verified without any proofs, verifying maximum-cardinality matchings requires some auxiliary information.In this section we study bipartite graphs; later in Section 5.4 we will show that the methods below break down on non-bipartite graphs.
Maximum matching.To construct a constant-size proof P for maximum matchings on a bipartite graph G we can use König's theorem [7, p. 35], which states that, on bipartite graphs, the maximum size of a matching equals the minimum size of a vertex cover.Indeed, take any minimum vertex cover C ⊆ V (G), and set P(v) = 1 iff v ∈ C. For any matching M ⊆ E(G), we then have, by König's theorem, that M is of maximum size if and only if |C| = |M|.To check this condition locally, we simply verify that M is a valid matching, the set C encoded in the proof forms a vertex cover, and each edge of M has THEORY OF COMPUTING, Volume 12 (19), 2016, pp.1-33 exactly one endpoint in C.This proves that maximum matchings in bipartite graphs are in LCP(1), as the size of P is 1.
Maximum-weight matching.Generalizing the above example, we can use linear programming duality to prove that in an edge-weighted bipartite graph G, a subset of edges M ⊆ E(G) is a maximum-weight matching.Associate a variable x e ≥ 0 with each edge e ∈ E, and a dual variable y v ≥ 0 with each node v ∈ V .Let w e ∈ N be the weight of edge e, and let A be the vertex-edge incidence matrix of graph G. Recall (e. g., [24, §13.2]) that matrix A and its transpose A are totally unimodular, and hence there are integral vectors x and y that maximize ∑ e w e x e subject to Ax ≤ 1 (primal LP) and minimize ∑ v y v subject to A y ≥ w (dual LP).Each maximum-weight matching M corresponds to an optimal integral solution x of the primal LP, and we can use an optimal dual solution y as a proof; for each node v ∈ V , the proof consists of a binary encoding of the value y v .To verify the proof, it is sufficient to check that x and y satisfy the complementary slackness conditions.If the weights are integers from 0, 1, . . .,W , then we can find an optimal dual solution such that y v ∈ {0, 1, . . .,W } for each node v. Hence the size of the proof is O(logW ) bits.

Problems in LogLCP
In this section we give examples of graph properties and graph problems that admit locally checkable proofs of size O(log n) but for which there is no locally checkable proof of size o(log n).That is, these problems are in LogLCP but not in any lower level of the LCP hierarchy.We begin with positive results that directly build on prior work-a key ingredient is the observation that spanning trees in connected graphs are in LogLCP.After that, we give our new lower-bound results.

Positive results
A spanning tree is not locally checkable, but Korman et al. [18] show that any spanning tree T can be equipped with a proof of size O(log n) that, for each vertex v, consists of (i) the identity of a particular vertex a, the root, and (ii) the distance from v to a in T .Such a proof can be locally verified by checking that the root-distance at a is 0, and that for each vertex v (i) all neighbors of v agree on the identity of the root, and (ii) the root-distance decreases at exactly one neighbor of v in T and increases at other neighbors.
A spanning tree equipped with a locally checkable proof is a versatile tool.For example, consider the leader election problem: there has to be exactly one node that is labeled as the leader.In connected graphs, we can verify any solution to the leader election problem by constructing a spanning tree that is rooted at the leader.
Spanning trees can be also used to prove that the graph is acyclic: we simply show that each component is a tree.Hamiltonian cycles and Hamiltonian paths can be verified by using the same technique: a Hamiltonian path can be interpreted as a spanning tree.
With spanning trees, we can also gather global information about the input graph.For instance, every node can be convinced of the value of n(G) on a connected graph G with the aid of a spanning tree with node counters along the paths towards the root: the leaves have counter value 1, and a non-leaf carries the sum of the counter values of its children plus 1. Hence graph properties such as having an odd number of nodes are also in LogLCP.
In LogLCP, we can also show that the chromatic number of a connected graph is larger than 2 (i.e., the graph is not bipartite).To construct a proof, first find an odd cycle in the graph-such a cycle exists if and only if the graph is non-bipartite.Then select one of the nodes of the cycle as the leader a.Construct a spanning tree rooted at a; this way the verifier can check that there exists exactly one leader.Then propagate a node counter along the cycle, starting and ending at a; this way the leader node can be convinced that it is indeed part of an odd cycle.

Negative results: overview
We will now prove the following theorem.
Theorem 5.1.The following graph properties and graph problems do not admit locally checkable proofs of size o(log n): graphs with odd number of nodes, non-bipartite graphs, spanning trees, and leader election.
Hence these are examples of problems whose containment in LogLCP is tight: their local proof complexity is exactly Θ(log n).
Proof sketch.The negative results build on the same basic idea.We will consider graph properties on cycles.We will assume that there is a proof labeling scheme ( f , A) with o(log n)-bit proofs.We will take several yes-instances-each of them is a short cycle-and inspect the encoding produced by f .Then we will show that some of the yes-instances are necessarily compatible with each other in the following sense: we can take several short cycles and glue them together to form a longer cycle; the unique identifiers and the proof labels are inherited from the short cycles, and each node of the long cycle will be locally indistinguishable from a node of a short cycle.Hence the verifier will accept the long cycle, as it has to accept all short cycles.However, even though the short cycles are yes-instances, the long cycle will be a no-instance.For example, in the case of non-bipartiteness, each short cycle has an odd number of nodes, but the long cycle is composed of an even number of short cycles, and is therefore a no-instance.In the case of leader election, each short cycle has one leader node, while the long cycle will contain multiple leaders, and is therefore an invalid solution.Similar ideas can be applied to many other lower bounds.
Subtleties.The only combinatorial hurdle in carrying out the above strategy is in making sure that there are enough proof-labeled neighborhoods among the yes-instances accepted by A that they can be reassembled into the long no-instance.To this end we invoke an extremal result of Bondy and Simonovits [6] on a certain bipartite compatibility graph.(By contrast, recall that in the model of Korman et al. [18] such gluing operations were made easy by the limited vision of a local verifier-we did not have to worry about node identifiers.)THEORY OF COMPUTING, Volume 12 (19), 2016, pp.1-33

The proof
Let F be a family of graphs that contains (at least) all cycles.In each graph G ∈ F, we may have a constant number of bits of auxiliary information per node (colors, labels, etc.).Let P ⊆ F be a graph property.Assume that ( f , A) is a proof labeling scheme for property P that uses o(log n)-bit proofs.Fix an integer constant k ≥ 2. Let n be a sufficiently large positive integer.We will assume that n-cycles (with appropriate auxiliary information) are in P.
Our plan is to show that we can always find k yes-instances, each of which is an n-cycle, and we can glue them together to form a kn-cycle that inherits the proof labels (and auxiliary information, if any) from the yes-instances.Verifier A will accept each n-cycle, and therefore it will also accept the kn-cycle.
For an example, refer to Figures 1 and 2.
Partitioning the space of identifiers.and set L ab (u) = 1 and L ab (v) = 0 for all v = u.We can consider either the best-case or the worst-case choice of the leader, thus covering both weak and strong proof labeling schemes.
Recording proof bits.Now we make use of the assumption that property P admits o(log n)-bit proofs.Apply f to C(a, b) to construct a locally checkable proof P ab of size o(log n).That is, c(a, b) consists of all auxiliary information and all proof bits that are available within distance 2r + 1 from the node a [1] or b [1] in C(a, b); see Figure 1a.By assumption, we have o(r log n) bits of information in c(a, b).
Gluing.Next, we glue together the n-cycles C(a 1 , b 1 ),C(a 2 , b 2 ), . . .,C(a k , b k ) to construct a kn-cycle C. That is, we take the node-disjoint graphs C(a i , b i ), remove the edges {a i [1], b i [1]} for each i, and add {b i−1 [1], a i [1]} for each i > 1.For each node v ∈ V (C), we inherit the auxiliary information L(v) and the proof bits P(v) from the cycles C(a i , b i ).The gluing process is illustrated in Figure 1c for the case k = 2.We have two compatible n-cycles, C(a, b) and C(a , b ), and we connect a [1] to b [1] and a [1] to b [1].
Analysis.It remains to argue that the computation of A on C with the labels L and proof P is accepting.To see this, pick a vertex v ∈ V (C).Then there is an , then the local neighborhood of v looks identical in C and C(a i+1 , b i ), which is another yes-instance.Similarly, if v is near a i [1], then its local neighborhood looks identical in C and C(a i , b i−1 ), which is also a yes-instance (see Figure 2 for an illustration).In all cases, v accepts the input.Thus the kn-cycle C is accepted by all nodes.If C / ∈ P, we have a contradiction, and we can conclude that the graph property P does not admit locally checkable proofs of size o(log n).

Implications
Now we can give concrete examples of graph properties and graph problems P for which C / ∈ P, provided that we choose the parameters k and n properly: • Non-bipartite graphs: We can select an odd n and k = 2.
• Leader election: It is sufficient to choose k = 2. Then each C(a, b) contains exactly one node labeled as a leader and C contains two nodes.
• Spanning trees: Again, we can choose k = 2.The spanning tree in each C(a, b) contains all edges of E(C(a, b)) except one, i. e., it is a spanning path.The solution encoded in C consists of two disjoint paths, and is therefore not a spanning tree.

Problems in LCP(poly(n))
In the previous sections, we have seen problems that admit locally checkable proofs of size O(log(n)).Now we turn our attention to the problems that require much larger proofs.If the nodes can have arbitrary labels (e. g., weights), it is easy to come up with artificial problems that require arbitrarily large proofs.However, in this section we will focus on finding natural examples of graph properties that are related to unlabeled graphs: we do not have any additional information besides the structure of the graph G and the unique node identifiers.
In connected graphs, any property of unlabeled graphs admits locally checkable proofs of size O(n 2 ).We can encode the structure of G and the unique node identifiers in O(n 2 ) bits; the nodes can verify that their neighbors agree on the structure of G and that their local neighborhoods match those in G. Finally, the nodes can solve the problem by brute force.
In this section, we will show that there are natural graph properties that Ω(n 2 )-bit proofs.Such problems are the most difficult problems from the LCP perspective-we can only save a constant factor in comparison with the brute-force solution.

Symmetric graphs
In this section, we fix F to be the family of connected graphs.We say that a graph G is symmetric if it has a non-trivial automorphism, that is, there is an automorphism g : V → V that is not the identity function; otherwise it is asymmetric.Theorem 6.1.Symmetricity of connected graphs requires locally checkable proofs of size Ω(n 2 ).
Proof.To reach a contradiction, assume that there exists a proof labeling scheme ( f , A) with o(n 2 )-bit proofs.To facilitate the proof, we will use canonical forms of graphs.We associate a canonical form C(G) with any graph G. Graphs G and C(G) are isomorphic; moreover, whenever G and H are isomorphic, their canonical forms C(G) and C(H) are equal.We assume that the node identifiers of a canonical form are V (C(G)) = {1, 2, . . ., n(G)}.We also define a graph with shifted identifiers as follows: for an integer i, graph C(G, i) has V (C(G, i)) = {i + 1, i + 2, . . ., i + n(G)} as the set of node identifiers.Moreover, we assume that g : Now we are ready to give the lower-bound construction.Given two connected graphs G 1 and ), and the path (k + 1, 1, 2, . . ., k, 2k + 1).That is, G consists of a path that joins graphs that are isomorphic to G 1 and G 2 .
Assume that G 1 and G 2 are asymmetric.If G 1 and G 2 are isomorphic, then G = G 1 G 2 is symmetric: there is a non-trivial automorphism that maps 1 → k and k + 1 → 2k + 1 and so on.Conversely, if G admits a non-trivial automorphism ϕ, then, by the construction of G, we must have that ϕ swaps G 1 and G 2 .This way, ϕ induces an isomorphism of G 1 and G 2 .
Let F k be a family containing a representative from each isomorphism class of asymmetric connected graphs with k nodes.For any G 1 ∈ F k , the local verifier A has to accept G 1 G 1 , as it is symmetric.Since almost all graphs are connected [7,Cor. 11.3.3]and asymmetric [8], we have Now assume that k ≥ 2r + 1, where r is the local horizon of A. Consider the proof labels of the nodes in U = {1, 2, . . ., 2r 1}.There are only o(rn 2 ) proof bits in U.As r = O(1) and n = 3k, we have only o(k 2 ) proof bits in U; for sufficiently large k this is less than log |F k |.Hence we must have two different graphs G 1 , G 2 ∈ F k such that the labeling scheme assigns the same proof bits to the nodes 1, 2, . . ., 2r Now we can construct the asymmetric graph G = G 1 G 2 .For the nodes k + 1, k + 2, . . ., 2k we inherit the proof labels from f (G 1 G 1 ), and for the nodes 2r + 2, 2r + 3, . . ., k, 2k + 1, 2k + 2, . . ., 3k we inherit the proof labels from f (G 2 G 2 ).For the nodes 1, 2, . . ., 2r + 1 we use the common labeling of f (G 1 G 1 ) and f (G 2 G 2 ).Now the radius-r neighborhood of any node in G looks identical to the neighborhood of a node in G 1 G 1 or G 2 G 2 .Hence all nodes will accept the input even though G is not symmetric, a contradiction.Remark 6.2.The basic idea of the above proof is similar to Korman et al. [18,Corollary 2.4].However, Korman et al.'s construction gives a problem related to graphs that are labeled with unique identifiers; it is not a graph property in the usual sense (closed under re-assigning the identifiers).

Fixed-point-free symmetry on trees
In this section, we fix F to be the family of connected trees.Here, any graph property P ⊆ F admits a locally checkable proof of size O(n): for each node v of the tree G ∈ P, we encode the structure of G and an index that identifies which node of G is v; the structure of a tree can be encoded in Θ(n) bits, and the index requires Θ(log n) bits.Now we will show that there are properties of unlabeled trees that require Θ(n)-bit proofs.We will use the following (artificial) problem as an example.We say that a graph G has a fixed-point-free symmetry if there is an automorphism that fixes no nodes, i. e., there is an automorphism g : Theorem 6.3.Trees with a fixed-point-free symmetry require locally checkable proofs of size Θ(n).
The proof is analogous to the case of symmetric graphs.The only difference is that we let [28,Seq.A000081]; hence a proof of size o(n) bits leads to a contradiction.

Non-3-colorability
Now we turn our attention to the classical problem of graph coloring.In Section 5 we have already seen that in the case of 2-colorability, the complement of the problem is strictly more difficult: to show that THEORY OF COMPUTING, Volume 12 (19), 2016, pp.1-33 a graph can be colored with 2 colors a Θ(1)-bit proof is sufficient, but to show that a graph cannot be colored with 2 colors we need Θ(log n)-bit proofs.
In the case of 3-colorings, the difference between the problem and its complement is even more dramatic.Again, constant-size proofs are enough to show that a graph can be colored with 3 colors, as we can give a 3-coloring as a proof.However, to prove a graph cannot be colored with 3 colors, we need very large proofs, with polynomially many bits per node.Theorem 6.4.Non-3-colorability requires locally checkable proofs of size Ω(n 2 / log n).
Let F be the family of connected graphs, and let P ⊆ F consist of graphs that have chromatic number larger than 3.We will show that property P does not admit locally checkable proofs of size o(n 2 / log n).Recall that any property of unlabeled graphs admits proofs of size O(n 2 ); hence the result is almost tight, and shows that non-3-colorability does not have a proof labeling scheme that is substantially better than the brute-force approach.
Proof overview.The template for our lower-bound proof will be the disjointness problem in two-party communication complexity: two players, Alice and Bob, are given sets A and B, respectively, and they need to communicate to find out whether A ∩ B = ∅.It is well-known that this problem has high communication complexity even in the nondeterministic setting where the players seek to prove that A ∩ B = ∅; see Example 1.23 and Lemma 2.4 in Kushilevitz and Nisan [20].Recall also that proving A ∩ B = ∅ is easy: simply guess an element in A ∩ B.
Our lower bound graph G = G A,B will have two subgraphs G A and G B that are owned by Alice and Bob, respectively.These subgraphs are connected by some Θ(log n) wires, that, intuitively, allow nondeterministic communication between the players (via the proof labels).The subgraphs G A and G B are constructed in such a way that if we are given any partial 3-coloring c of G defined only on the wires of G, then c can be extended to 3-coloring of G A (resp., G B ) if and only if c encodes, in a certain way, an element in A (resp., B).This means that G A,B will be 3-colorable iff A ∩ B = ∅-or in other words G A,B will be non-3-colorable iff A ∩ B = ∅.A communication complexity argument then implies that the wires must carry large proof labels.
Moreover, proper 3-colorings of G A have the following properties: (iii) The nodes T , F, and N have three different colors.The nodes with the same color as T are said to be true, those with the same color as F are false, and others are neutral.
(iv) Each of x i and y i has to be true or false.Hence we can interpret the coloring of the nodes x i as a binary encoding of an integer x ∈ I; similarly the coloring of the nodes y i is a binary encoding of an integer y ∈ I.
(v) In any 3-coloring, we must have (x, y) ∈ A. Conversely, we can find a proper 3-coloring that encodes any (x, y) ∈ A.
An explicit construction of G A follows.In the subsequent analysis the details of the construction are not used outside of the above properties (i)-(v).
Gadgets.We begin with the basic building blocks of G A .In graph G A , nodes T , F, and N form a triangle, ensuring that in any 3-coloring these nodes have different colors.

N T F
Recall that the nodes with the same color as T are said to be true, those with the same color as F are false, and others are neutral.Nodes T , F, and N are extensively used in the construction of the following gadgets.
A Boolean gadget has two terminals; see Figure 3.In a proper 3-coloring, exactly one terminal is true and the other terminal is false; conversely, any such assignment is a proper 3-coloring.
A color changer has one input node and one output node; see Figure 4.In any proper 3-coloring, a true input implies a true output while a neutral input implies a false output (and a false input is not possible); conversely, any such assignment can be realized as a proper 3-coloring.
A disjunction gadget has a number of output nodes; see Figure 5.In any proper 3-coloring, at least one output node is true and all other output nodes are neutral; conversely, any such assignment can be realized as a proper 3-coloring.The construction uses Boolean gadgets.
Finally, we construct a binary decoder as illustrated in Figure 6.There are k input nodes, labeled with x 0 , x 1 , . . ., x k−1 , and 2 k output nodes, labeled with 0, 1, . . ., 2 k − 1, i. e., with a number in I.In any 3-coloring, each input node is either true or false, while each output node is either true or neutral.The color assignment of the input nodes can be interpreted as a binary encoding of a number i ∈ I, and the decoder guarantees that only the output node with label i is true.Conversely, any such assignment can be realized as a proper 3-coloring.In the construction of the binary decoder, a disjunction gadget ensures that at least one output node is true, while the edges between inputs and outputs ensure that if an output node is true, its index matches the truth assignment of the input nodes.Now we have all basic ingredients for constructing graph G A .
Construction of G A .The high-level structure of graph G A is shown in Figure 7.There are 2k + 3 terminals: T , F, N, x 0 , x 1 , . . ., x k−1 , and y 0 , y 1 , . . ., y k−1 .There are also non-terminal nodes a i , b i , and c i for i ∈ I.
The construction contains two binary decoders: one mapping inputs x j to outputs a i , and the other mapping inputs y i to outputs c j .Moreover, there are 2 k color changers, each of them mapping input a i to output b i .Finally, we have an edge {b i , c j } if and only if (i, j) / ∈ A. Now in any proper 3-coloring, nodes x j and y j have to be either true or false; we can interpret the coloring of nodes x j as the binary encoding of a number x ∈ I, and the coloring of nodes y j as the binary encoding of a number y ∈ I.By construction, we have  (i) a i is true iff i = x; otherwise a i is neutral, (ii) b i is true iff i = x; otherwise b i is false, (iii) c i is true iff i = y; otherwise c i is neutral.
In particular, both b x and c y are true, and therefore we must have (x, y) ∈ A. Conversely, for any pair of integers (x, y) ∈ A, we can construct a proper 3-coloring of G A such the coloring of x j forms the binary encoding of x and the coloring of y j forms the binary encoding of y.
Construction of G = G A,B .We have now completed the construction of G A for any given set A ⊆ I × I.
In what follows, we denote by G A an isomorphic copy of G A ; we use the primed symbols T , F , N , x i , and y i to refer to the terminal nodes of G A .
We will need one more gadget: a wire that propagates colors; see Figure 8.A wire w consists of 9r nodes, labeled w(i, j) for i = 1, 2, . . ., 3r and j = 1, 2, 3.For each i, the nodes w(i, 1), w(i, 2), and w(i, 3) form a triangle.For each i < 3r and j = j , the nodes w(i, j) and w(i + 1, j ) are connected with an edge.It follows that in any 3-coloring of a wire, the nodes w(i, 1), w(i, 2) and w(i, 3) must have different colors, and w(i, j) must have the same color as w(i + 1, j).Given two sets A, B ⊆ I × I, we construct a graph G = G A,B that consists of subgraphs G A and G B that are connected to each other by 2k + 1 wires; see Figure 9.The wires ensure that G A and G B agree on the coloring of the terminals.
In more detail, we label the 2k + 1 wires with w T , w x 1 , w x 2 , . . ., w x k , and w y 1 , w y 2 , . . ., w y k .The endpoints of the wires are identified with the nodes of the subgraphs G A and G B as follows: w(1, 1) = N and w(3r, 1) = N for each wire w, w T (1, 2) = T and w T (3r, 2) = T , Analysis.We make the following observations of G: (i) The total number of nodes in G is n = Θ(2 k ).
(ii) Let W ⊆ V (G) consist of the nodes that are not in G A or G B ; these are internal nodes of the wires.The number of nodes in W is Θ(rk) = Θ(r log n).x' 0 wire (iii) The shortest path from a node of G A to a node of G B has length at least 3r − 1.In particular, for sufficiently large r, the local neighborhood of any node is a subset of W ∪V (G A ) or a subset of W ∪V (G B ).
Moreover, 3-colorings of G have the following properties: (iv) Nodes N and N have the same color, nodes T and T have the same color, and nodes F and F have the same color.Hence the concepts of true, false, and neutral nodes are well-defined in G.
(v) Nodes x i and x i have the same color for each i, and nodes y i and y i have the same color for each i.In particular, both G A and G B agree on the encoding of the same pair (x, y), and we must have It follows that G A,B has a 3-coloring if and only if A ∩ B = / 0. Let A ⊆ I × I and let Ā be its complement.Now A ∩ Ā = / 0 and G A, Ā does not have a 3-coloring; hence it is in P. If we had locally checkable proofs of size o(n 2 / log n), the total number of proof bits in W would be o(rn 2 ); on the other hand, there are Θ(n 2 ) elements in I × I. Hence for sufficiently large n there are two different sets A, B ⊆ I × I such that we have the same proof bits in W for both G A, Ā and G B, B. Now we are ready to apply a fooling set argument.As A = B, we have A ∩ B = / 0 or Ā ∩ B = / 0 (or both).Without loss of generality, assume that A ∩ B = / 0. Hence G A, B admits a 3-coloring, and it is therefore not in P.But we can construct a proof as follows: the proof bits of G A are inherited from the proof of G A, Ā, the proof bits of G B are inherited from the proof of G B, B, and the proof bits of wires are the same as in G A, Ā and G B, B. Hence each node of G A, B has a local neighborhood that looks identical to a node of G A, Ā or G B, B. As G A, Ā and G B, B are yes-instances, all nodes will accept G A, B, a contradiction.
This completes the proof of Theorem 6.4 that non-3-colorability requires proofs of size Ω(n 2 / log n).For comparison, proofs of size O(n 2 ) are trivially sufficient.

Structural properties
In the previous sections we have discussed concrete examples of graph properties and their local proof complexities.By contrast, the focus of this final section is on the structural properties of the LCP hierarchy: We study the sensitivity of our LCP model to the definitional choices made in Section 2. In a similar vein, we will seek alternative characterizations of the class LogLCP.Finally, we give some observations relating our LCP classes to other complexity classes.

Port numbering algorithms
Throughout this paper, we have used the assumption that the local verifier can access the unique identifiers of the nodes (in accordance with Peleg's [25] LOCAL model).Furthermore, we have assumed that the proof can depend on the identifier assignment (recall that this convention is not followed by Fraigniaud et al. [11]).In this section we ask what one can locally prove in a setting where node identifiers are not available.
The standard model for computing on networks without unique identifiers is the port numbering model (PN) of Angluin [3].In the PN model the nodes are considered anonymous; they do not have 2. P is an encoding of a spanning tree T rooted at a.However, G ∈ P and therefore A(G, ε, a) = 1.
Hence Ā outputs 0 at the root node a.
We conclude that for each G ∈ P there is a proof P that is accepted by Ā, and for each G / ∈ P any proof P is rejected by Ā. Hence P is in LogLCP.

Containment in NP and NP/poly
Comparing classes such as LogLCP and NP is not straightforward.To define the LCP hierarchy, we have used the LOCAL model, which allows unlimited local computation.Hence if we have unbounded node degrees in G (or unbounded amount of additional information per node in the form of colors or weights), we can easily come up with artificial problems that are in LCP(0) but not in NP.
However, the situation becomes much more interesting if we study bounded-degree graphs; moreover, we will consider properties of unlabeled graphs, i. e., there is no additional information besides the node identifiers and the topology of the graph.
In this restricted case, we can still show that there are problems in LogLCP that are not contained in NP.Once again, we can resort to spanning tree methods: without loss of generality, we can assume that a LogLCP verifier has access to n = n(G) in any connected graph G. Hence the verifier can solve arbitrarily hard problems concerning the integer n, including those that are not in NP (which exist by the hierarchy theorems [23, §7.2]).
However, if P ∈ LogLCP is a graph property related to unlabeled bounded-degree graphs, we can show that P is in NP/poly, i. e., NP with a polynomial-size non-uniform advice.In a bounded-degree graph, the number of nodes inside the local horizon is bounded by a constant, and hence a LogLCP verifier A uses only O(log n) bits of input in total.Thus verifier A can be encoded as a lookup table of size 2 O(log n) , which is polynomial in n.We can provide the entire lookup table as the advice string S to an NP/poly machine M. Then M merely guesses the O(n log n)-bit proof P : V (G) → {0, 1} , and uses the advice string S to verify the guess.

Connections to descriptive complexity
A central result in descriptive complexity theory and one that began the field is Fagin's [9], [14,Ch. 7] characterization of the class NP as graph properties expressible by existential second-order formulas (Σ 1 1 )-this is the extension of first-order logic that allows existential quantification over relation symbols X 1 , X 2 , . . .(of any arity).Some NP-complete graph properties (e. g., 3-colorability) are even expressible by monadic Σ 1  1 formulas that only quantify over unary relation symbols [1,26].In this section, we make observations of a connection between the LogLCP class and the class of graph properties that are expressible by monadic Σ 1  1 formulas.In the study of first-order expressibility, locality is a thematic subject; this is illustrated by Hanf's theorem and the work of Gaifman [14,Ch. 6].Building on this work, Schwentick and Barthelmann [27] have shown that on connected graphs, every monadic Σ 1 1 formula is equivalent to a formula of the form ϑ = ∃X 1 ∃X 2 . . .∃X k ∃x∀y : ϕ(X 1 , . . ., X k , x, y) , where ϕ is first-order (using relation symbols X 1 , . . ., X k ) and local around y. Here, a formula ϕ is local around y if there is a constant r so that for all graphs G and all interpretations of X 1 , X 2 , . . ., X k , x, y it THEORY OF COMPUTING, Volume 12 (19), 2016, pp.1-33 can be determined whether G satisfies φ (X 1 , X 2 , . . ., X k , x, y) on the basis of the r-radius neighborhood of y in G. (More formally, the quantifications in ϕ are always of the form ∃z : (dist(z, y) ≤ r ∧ ψ) or ∀z : (dist(z, y) ≤ r → ψ), where "dist(z, y) ≤ r" simply stands for "the distance between z and y is at most r".)Let us consider the family F of connected graphs.If and only if a graph G ∈ F has property ϑ , there are unary relations A 1 , A 2 , . . ., A k and a node a ∈ V such that G satisfies ∀y : ϕ(A 1 , A 2 , . . ., A k , a, y).For each node v and each relation A i , encoding A i (v) takes 1 bit.To prove the existence of the node a, we can use a spanning tree rooted at a; a locally checkable spanning tree requires O(log n) bits per node (recall Section 5).To check the proof, the verifier A first checks the spanning tree, and then evaluates ϕ(A 1 , A 2 , . . ., A k , a, y) for each node y.As ϕ is local around y, the verifier A is a local algorithm.Hence in connected graphs, any monadic Σ 1  1 graph property P admits locally checkable proofs of size O(log n), i. e., P ∈ LogLCP.

Open problems
We conclude by summarizing some open problems raised by our paper.While the local proof complexity as a function of the number of nodes n is now fairly well understood, we left a small gap in the case of non-3-colorability, which is probably a proof artifact.
There are also many open questions related to the local proof complexity as a function of the maximum degree ∆: 2. In Section 4.1 we saw that directed s-t reachability admits locally checkable proofs of size O(log ∆).
Is there a proof labeling scheme with O(1)-bit proofs?
3. Eulerian tours admit a straightforward proof of size O(∆ log n), and the lower-bound techniques of Section 5 imply a lower bound of Ω(log n).Is there a proof labeling scheme with O(log n)-bit proofs?
If we increase the local horizon of a verifier, can we decrease the proof size?Korman et al. [17] show how this can be done when verifying minimum weight spanning trees.Do such trade-offs exist for all properties in LCP(O(1)), or not: 4. Do we have LCP(k) LCP(k + 1) for all constants k ∈ N?
The analogous question has been answered affirmatively for monadic Σ 1 1 expressibility [22].Perhaps our most nagging question is one that involves another structural property of the class LCP(O(1)).Recall that in Section 7.4 it was straightforward to see that LogLCP NP.The analogous question for LCP(O(1)) is the following: 5.If P ⊆ F is a graph property in LCP(O(1)) related to connected, unlabeled, bounded-degree graphs, do we necessarily have P ∈ NP?
Fraigniaud et al. to our work, let us define LCP ( f ) similarly to LCP( f ) but restricted to computable properties of connected graphs.With this notation, the class LD of local decision problems defined by Fraigniaud et al. is equal to LCP (0).The nondeterministic variants of LD are called NLD and NLD #n ; in the latter class each node knows the total number of nodes in the graph.It turns out that our class LCP (∞) is equal to NLD #n : both classes contain all computable properties of connected graphs.Hence using the separation results of Fraigniaud et al. we have LCP (0) = LD NLD NLD #n = LCP (∞) .While Fraigniaud et al. place one class between the extreme ends of LCP (0) and LCP (∞), our work introduces an entire hierarchy of LCP( f ) classes.
First, split n = n A + n B , where n A = n/2 and n B = n/2 .Fix any partition of the set of identifiers {1, . . ., n 2 } into 2n subsets a 1 , . . ., a n , b 1 , . . ., b n so that each a ∈ A := {a 1 , . . ., a n } is of size n A , and each b ∈ B := {b 1 , . . ., b n } is of size n B .We denote by a[i] (resp., b[i]) the i-th identifier in a (resp., b) in the natural order.For example, if n = 10, we have n A = n B = 5.We can choose the partition a 1 = {1, 2, . . ., 5}, a 2 = {6, 7, . . ., 10}, . . ., b 10 = {96, 97, . . ., 100}.In this case a 2 [1] = 6, b 10 [2] = 97, etc. Family of yes-instances.Next, we define a family of yes-instances C(a, b) indexed by pairs (a, b) ∈ A × B. Define C(a, b) to be the n-cycle that contains the nodes a in increasing order followed by the nodes b in decreasing order, completing the cycle.That is, a[1] and b[1] are adjacent, as are a[n A ] and b[n B ]; see Figure 1a.Note that V (C(a, b)) and V (C(a , b )) are disjoint if a = a and b = b .Augment each C(a, b) with auxiliary information such that C(a, b) is in P, if necessary; let L ab (v) ∈ {0, 1} be the bit string associated with node v ∈ V (C(a, b)).For example, if we are interested in the leader election problem, label exactly one node in each C(a, b) as the leader: select a node u ∈ V (C(a, b)) Finally, define c(a, b) = P ab (a[2r + 1]), P ab (a[2r]), . . ., P ab (a[1]), P ab (b[1]), P ab (b[2]), . . ., P ab (b[2r + 1]) .

Figure 1 :
Figure 1: An illustration of the Ω(log n) lower-bound construction; here n = 10, r = 1, and k = 2. (a) Construction of the cycle C(a, b).We consider the leader election problem in this example; hence precisely one node is highlighted to indicate the leader node.(b) A monochromatic 2k-cycle a, b, a , b in K n,n .(c) Constructing the kn-cycle C by gluing together two compatible n-cycles, C(a, b) and C(a , b ).

Figure 2 :
Figure 2: Cycle C was constructed by gluing together two compatible n-cycles, C(a, b) and C(a , b ).The grey arrows indicate pairs of nodes that have identical local neighborhoods: some parts of C look locally identical to C(a, b) or C(a , b ), while other parts look locally identical to C(a, b ) or C(a , b).

Figure 5 :
Figure 5: (a) Disjunction gadget with four output nodes.(b) An example of a proper 3-coloring.

Figure 8 :
Figure 8: (a) A wire between terminals a and a .(b) An example of a proper 3-coloring.

Figure 9 :
Figure 9: Graph G A,B consists of graphs G A and G B that are connected by 2k + 1 wires.

Table 1 :
The local proof complexity of verifying graph property P, when we are promised that the input graph is in graph family F. Constant k is a natural number.In reachability problems, nodes s and t are labeled; otherwise the graphs are unlabeled.

Table 2 :
The local proof complexity of verifying a solution to graph problem P, when we are promised that the input graph is in graph family F.Here W is the maximum weight of an edge.
of distinct colors in K n,n is therefore smaller than 3 √ n.Hence there is a subset of edges H ⊆ E such that |H| > |E|/3 THEORY OF COMPUTING, Volume 12 (19), 2016, pp.1-33 and the number (19)RY OF COMPUTING, Volume 12(19), 2016, pp.It should be noted that in case F is closed under disjoint unions of graphs, a single component C ⊂ G in a graph G ∈ F can have node identifiers that are not bounded by a polynomial in n(C).In this case, a modification of the Ramsey argument of Naor and Stockmeyer[21,  §3]applies to get rid of the identifier dependencies and proves P ∈ NP.