Laurent Feuilloley

Pierre Fraigniaud

Ivan Rapaport

Éric Rémila

Pedro Montealegre

Ioan Todinca

Compact Distributed Certification of Planar Graphs

Naor, Parter, and Yogev (SODA 2020) have recently demonstrated the existence of a distributed interactive proof for planarity (i.e., for certifying that a network is planar), using a sophisticated generic technique for constructing distributed IP protocols based on sequential IP protocols. The interactive proof for planarity is based on a distributed certification of the correct execution of any given sequential linear-time algorithm for planarity testing. It involves three interactions between the prover and the randomized distributed verifier (i.e., it is a dMAM protocol), and uses small certificates, on O(log n) bits in n-node networks. We show that a single interaction from the prover suffices, and randomization is unecessary, by providing an explicit description of a proof-labeling scheme for planarity, still using certificates on just O(log n) bits. We also show that there are no proof-labeling schemes -in fact, even no locally checkable proofs -for planarity using certificates on o(log n) bits.

Introduction

Planar graphs are arguably among the most studied classes of graphs in the context of algorithm design and analysis. In particular, planar graphs enable the design of algorithms provably faster than for general graphs (see, e.g., [START_REF] Cabello | Subquadratic algorithms for the diameter and the sum of pairwise distances in planar graphs[END_REF] for a subquadratic algorithm for diameter in planar graphs, in contrast to the quadratic lower bound in [START_REF] Roditty | Fast approximation algorithms for the diameter and radius of sparse graphs[END_REF]). In the context of distributed network computing too, planar graphs have been the source of many contributions. For instance, a distributed algorithm approximating a minimum dominating set (MDS) within a constant factor, in a constant number of rounds, has been designed for planar graphs [START_REF] Lenzen | What can be approximated locally?: case study: dominating sets in planar graphs[END_REF]. In contrast, even a poly-logarithmic approximation of the MDS problem requires at least Ω( log n/ log log n) rounds in arbitrary n-node networks [START_REF] Kuhn | What cannot be computed locally! In 23[END_REF]. See Section 1.2 for further references to contributions on distributed algorithm design for planar graphs.

In this paper, we are concerned with checking whether a given network is planar. Indeed, we aim at avoiding the risk of performing distributed computations dedicated to planar graphs in networks that are not planar, which may lead to erroneous outputs, or even lack of termination. Note that it is sufficient that one node detects if the actual graph is not planar, as this node can then broadcast an alarm, or launch a recovery procedure (e.g., for overlay networks).

Efficient planarity tests have been designed in the sequential setting [START_REF] Hopcroft | Efficient planarity testing[END_REF], but no such efficient algorithms are known in the distributed setting. In fact, it is known [START_REF] Fraigniaud | Towards a complexity theory for local distributed computing[END_REF] that there are no local decision algorithms for planarity. That is, there are no algorithms in which every node of a network exchange information solely with nodes in its vicinity, and outputs accept or reject such that the network is planar if and only if all nodes accept.

Kuratowski's theorem states that a graph is planar if and only if it does not contain a subgraph that is a subdivision of the complete graph K 5 , or the complete bipartite graph K 3,3 . This characterization can easily be turned into a proof-labeling scheme [START_REF] Korman | Proof labeling schemes[END_REF] that a network is not planar, by certifying the presence of a subdivided K 5 or K 3,3 as a subgraph. However, it is not clear whether Kuratowski's theorem can be used to prove that a network is planar, in a distributed manner. Indeed, this would require to certify that no subdivided K 5 or K 3,3 are present in the network. Also, it is not clear whether using the coordinates of the nodes in a planar embedding would help, as checking whether two edges cross seems difficult if the extremities of these edges are embedded at far away positions in the plane. Similarly, a distributed proof based on checking the consistency of the faces resulting from a planar embedding of the graph appears uneasy, as one can construct embeddings of non planar graphs in which the faces look locally consistent.

Yet, Kuratowski's theorem can be used to show that planarity is at the second level of the local decision hierarchy with alternating quantifiers (see [START_REF] Feuilloley | A hierarchy of local decision[END_REF]). That is, for every assignment of O(log n)-bit certificates to the nodes by a disprover aiming at convincing the nodes of a planar network that this network is not planar, a prover can assign other O(log n)-bit certificates to the nodes for certifying that the distributed proof provided by the disprover is erroneous. The fact that planarity is at a low level of the local decision hierarchy is conceptually informative, but this fact does not provide a concrete distributed mechanism for certifying planarity.

A breakthrough has been recently achieved by Naor, Parter, and Yogev [START_REF] Naor | The power of distributed verifiers in interactive proofs[END_REF], who showed the existence of a distributed interactive proof for planarity. Such types of protocols are motivated by the possible access to services provided by a computationally powerful external entity, e.g., the cloud [START_REF] Kol | Interactive distributed proofs[END_REF]. The interactive protocol for planarity is not explicit, but can be constructed automatically from any sequential linear-time algorithm for planarity testing. In fact, this protocol is just one illustration of a sophisticated generic compiler developed in [START_REF] Naor | The power of distributed verifiers in interactive proofs[END_REF] for constructing distributed IP protocols based on sequential IP protocols, which applies way beyond the case of planarity. Specifically, given an algorithm for planarity testing, the interactive protocol is roughly the following. The O(n) steps corresponding to the execution of the algorithm on the actual network are distributed to the nodes, and the interactive protocol checks that these steps are consistent (e.g., the output of step i is the input of step i + 1, etc.). The node handling the final step of the execution of the algorithm accepts or rejects according to the outcome of the algorithm. The steps of the execution (e.g., reading some memory location, or adding such and such registers) can be encoded on O(log n) bits, and it is shown that verifying the consistency of the O(n) steps distributed over the n nodes can be achieved by a dMAM interactive protocol, using certificates on O(log n) bits. In such a protocol, the non-trustable prover (a.k.a. Merlin) provides each node with an O(log n)-bit certificate. Then, at each node, the honest verifier (a.k.a. Arthur) running at that node challenges the prover with a random value. Finally the prover replies to each node by providing it with a second certificate, again on O(log n) bits. Once this is done, every node interacts with all its neighbors only once, and outputs accept or reject. The authors of [START_REF] Naor | The power of distributed verifiers in interactive proofs[END_REF] proved that, using their dMAM protocol, all nodes accept if and only if the network is planar.

The mechanism in [START_REF] Naor | The power of distributed verifiers in interactive proofs[END_REF] actually applies to all classes of graphs that can be recognized with a sequential polynomial-time algorithm. The resulting distributed interactive protocol is however efficient only for classes of sparse graphs, recognizable in quasi-linear time, among which the class of planar graphs plays a prominent role.

Our results

We show that several interactions between the prover and the verifier are not necessary for distributed certification of planarity, while the size of the certificates can be kept as small as in [START_REF] Naor | The power of distributed verifiers in interactive proofs[END_REF]. Indeed, we provide an explicit description of a proof-labeling scheme [START_REF] Korman | Proof labeling schemes[END_REF], still using certificates on just O(log n) bits. A proof-labeling scheme requires a single interaction between the prover and the distributed verifier, and no randomization is required. Specifically, the prover provides each node with an O(log n)-bit certificate, and then the nodes can directly move on with the local verification stage, in which every node interacts with all its neighbors once, and outputs accept or reject such that all nodes accept if and only if the network is planar. Prooflabeling schemes can be implemented even in absence of services provided by external entities like the cloud. Actually, in many frameworks, including the one in this paper, the certificates can be computed in a distributed manner by the network itself during a pre-processing phase.

As mentioned before, it is not clear whether Kuratowski's theorem, or the use of coordinates can be applied to prove that a network is planar, in a distributed manner (Kuratowski's theorem can be used to certify that a network is not planar). Therefore, we adopt a different approach, by asking the prover to certify a specific form of planar embedding of the network, not relying on coordinates. Our approach is inspired by the work on planar graphs by Fraysseix and Rosentiehl [START_REF] De | A characterization of planar graphs by trémaux orders[END_REF], based itself on Tutte's crossing number theory [START_REF] William | Toward a theoryof crossing number[END_REF]. Observe that any graph G can be embedded in the plane as a planar embedding of a spanning tree T of G, plus cotree edges (the cotree of G associated with T is the set of edges in G not in T ), such that the crossings occur between cotree edges only. Such an embedding is called a T -embedding of G. A graph G is planar if and only if there exists a T -embedding of G in the plane with no crossing edges. Given a planar graph G, our prover provides the nodes with a distributed proof that there is T -embedding of G in which no cotree-edges cross.

We also show that our proof-labeling scheme has certificates of optimal size, in the sense that there are no locally checkable proofs [START_REF] Göös | Locally checkable proofs in distributed computing[END_REF] for planarity that use certificates of size o(log n) bits (locally checkable proofs are verification mechanisms stronger than proof-labeling schemes). In fact, we show a more general result regarding the class of graphs excluding a complete graph K k as a minor, for any k ≥ 3, and the class of graphs excluding a complete bipartite graph K p,q as a minor, for any p, q ≥ 2. The proof for graphs excluding K k is an extension of the technique used in [START_REF] Feuilloley | Local verification of global proofs[END_REF] for lower bounding the size of global certificates. The proof for graphs excluding K p,q is a non-standard adaptation of the original proof of a lower bound for checking spanning tree and leader election in [START_REF] Göös | Locally checkable proofs in distributed computing[END_REF]. Combining these results allows us to consider the class of graphs excluding both K 5 and K 3,3 as minors, from which the lower bound for planarity follows directly.

To sum up, the paper is dedicated to establishing the following results.

Theorem 1 There is a 1-round proof-labeling scheme for planarity with certificates on O(log n) bits in n-node networks.

For a finite family H of graphs, let Forb(H) be the class of graphs with all the graphs in H excluded as "forbidden minors".

Theorem 2 Let F = {K k : k ≥ 3} ∪ {K p,q : p, q ≥ 2}. For any non-empty finite family H of graphs in F, there are no locally checkable proofs for Forb(H) using certificates on o(log n) bits.

The following result follows directly from Theorem 2 as the planar graphs form the class Forb({K 5 , K 3,3 }) by Wagner's theorem (see [START_REF] Diestel | Graph Theory[END_REF]).

Corollary 1 There are no locally checkable proofs for planarity, using certificates on o(log n) bits.

Theorem 2 can also be used for other graph classes. For example, outerplanar graphs, which are the planar graphs that can be drawn in the plane with all the vertices on the outerface, form the class Forb({K 4 , K 2,3 }), and thus have no locally checkable proof with certificates on o(log n) bits.

Remark. All our lower bounds hold even if one allows verification algorithms performing an arbitrarily large constant number of rounds.

Related work

Distributed algorithms for planar graphs. As for the case of sequential computing, planar graphs have attracted significant interest in the context of distributed computing. Indeed, planar graphs do have structural properties that allow for fast distributed algorithms, in particular as far as approximation algorithms for classic problems such as minimum dominating set, or maximum matching are concerned. We refer to [START_REF] Czygrinow | Distributed approximation algorithms for planar graphs[END_REF][START_REF] Czygrinow | Distributed local approximation of the minimum k-tuple dominating set in planar graphs[END_REF][START_REF] Czygrinow | Improved distributed local approximation algorithm for minimum 2dominating set in planar graphs[END_REF][START_REF] Czygrinow | Distributed packing in planar graphs[END_REF][START_REF] Czygrinow | Fast distributed approximations in planar graphs[END_REF][START_REF] Hilke | Brief announcement: local approximability of minimum dominating set on planar graphs[END_REF][START_REF] Lenzen | What can be approximated locally?: case study: dominating sets in planar graphs[END_REF][START_REF] Lenzen | Distributed minimum dominating set approximations in restricted families of graphs[END_REF][START_REF] Wawrzyniak | A strengthened analysis of a local algorithm for the minimum dominating set problem in planar graphs[END_REF] for a non-exhaustive list of examples of such contributions.

Recently, it was proved that a combinatorial planar embedding that consists of each node knowing the clockwise order of its incident edges in a fixed planar drawing can be computed efficiently in the CONGEST model [START_REF] Ghaffari | Distributed algorithms for planar networks I: planar embedding[END_REF], and then used to derive O(D)-round distributed algorithms for MST and min-cut in planar networks of diameter D [START_REF] Ghaffari | Distributed algorithms for planar networks II: low-congestion shortcuts, MST, and min-cut[END_REF], hence bypassing the lower bounds Ω(D + √ n) for general networks [START_REF] Peleg | A near-tight lower bound on the time complexity of distributed minimum-weight spanning tree construction[END_REF][START_REF] Das Sarma | Distributed verification and hardness of distributed approximation[END_REF]. Even more recently, a randomized distributed algorithm for computing a DFS tree in planar networks has been designed [START_REF] Ghaffari | Near-optimal distributed DFS in planar graphs[END_REF], whose complexity beats the best known complexity bound O(n) for general graphs [START_REF] Awerbuch | A new distributed depth-first-search algorithm[END_REF]. More generally, it is worth to mention that there is also a large recent literature on distributed algorithms designed for other families of sparse graphs, beyond planar graphs. This is for instance the case of graphs of bounded genus, and graphs of bounded expansion (see, e.g., [START_REF] Saeed Akhoondian Amiri | Distributed domination on graph classes of bounded expansion[END_REF][START_REF] Saeed Akhoondian Amiri | Distributed dominating set approximations beyond planar graphs[END_REF]). We refer to [START_REF] Feuilloley | Bibliography of distributed approximation beyonf bounded degree[END_REF] for a bibliography on distributed algorithms in classes of sparse graphs.

Distributed decision and verification. Locally checkable proofs (LCPs) were introduced in [START_REF] Göös | Locally checkable proofs in distributed computing[END_REF], as an extension of the seminal notion of proof-labeling scheme (PLS) introduced in [START_REF] Korman | Proof labeling schemes[END_REF]. There are only two differences between these two concepts, but they are subtle, and require some care. The first difference is that LCPs allow for verification procedures performing many rounds, while PLS are restricted to a single round of verification. Nevertheless, PLS can be easily extended to many rounds whenever the certificates are large enough to contain IDs, which enables to trade longer verification time for smaller certificates size (see, e.g., [START_REF] Feuilloley | Redundancy in distributed proofs[END_REF]). The second difference is more profound. While PLSs impose verification procedures exchanging the certificates only, LCPs allow the verification procedures to exchange additional information, e.g., the entire states of the nodes.

As a consequence, a PLS with certificates on O(log n) bits can be systematically implemented in one round in the CONGEST model, while this is not necessarily the case of LCPs, if the additional information is of size ω(log n) bits. Nevertheless, this phenomenon has little impact on upper bounds in general, as the states of the nodes are often encoded on a logarithmic number of bits too (e.g., a constant number of pointers to neighbors, a constant number of bits marking the nodes, etc.). On the other hand, the difference between LCPs and PLSs has strong impact on the design of lower bounds, especially for demonstrating impossibility results when using sub-logarithmic certificates, as the IDs of the nodes (which are part of their states) are seen by the neighbors in LCPs, but not in PLSs with certificates on o(log n) bits. Nondeterministic local decision (NLD) [START_REF] Fraigniaud | Towards a complexity theory for local distributed computing[END_REF] is yet another similar notion of distributed certification. It differs from the PLS and LCP in the fact that the certificates must be independent from the identity-assignment to the nodes. We refer to [START_REF] Feuilloley | Introduction to local certification[END_REF][START_REF] Feuilloley | Survey of distributed decision[END_REF] for recent surveys on distributed decision and verification.

Remark. Observe that the upper bound in Theorem 1 is obtained by designing a PLS for planarity, while the lower bounds in Theorem 2 hold even for LCPs.

All the aforementioned notions were extended by allowing the verifier to be randomized (see [START_REF] Fraigniaud | Randomized proof-labeling schemes[END_REF]). Such protocols were originally referred to as randomized PLS (RPLS), but are nowadays referred to as distributed Merlin-Arthur (dMA) protocols. The concept of distributed verification has also been extended [START_REF] Balliu | What can be verified locally?[END_REF][START_REF] Feuilloley | A hierarchy of local decision[END_REF] in a way similar to the way NP was extended to the complexity classes forming the Polynomial Hierarchy, by alternating quantifiers.

Distributed interactive proofs. Recently, distributed interactive proofs were formalized [START_REF] Kol | Interactive distributed proofs[END_REF], and the classes dAM[k] and dMA[k], k ≥ 1, were defined, where k denotes the number of alternations between the centralized Merlin, and the decentralized Arthur. For instance, dAM [START_REF] Saeed Akhoondian Amiri | Distributed dominating set approximations beyond planar graphs[END_REF] = dMAM and dMA [START_REF] Saeed Akhoondian Amiri | Distributed domination on graph classes of bounded expansion[END_REF] = dMA, while LCP and PLS can be viewed as equal to dAM [START_REF] Afek | The local detection paradigm and its application to self-stabilization[END_REF] = dM (Merlin provides the nodes with their certificates, without challenges from Arthur). Distributed interactive protocols for problems like the existence of a non-trivial automorphism (AUT), and non-isomorphism (ISO) were designed and analyzed in [START_REF] Kol | Interactive distributed proofs[END_REF]. The follow up paper [START_REF] Naor | The power of distributed verifiers in interactive proofs[END_REF] improved the complexity of some of the protocols in [START_REF] Kol | Interactive distributed proofs[END_REF], either in terms of the number of interactions between the prover and the verifier, and/or in terms of the size of the certificates. A sophisticated generic way for constructing distributed IP protocols based on sequential IP protocols is presented in [START_REF] Naor | The power of distributed verifiers in interactive proofs[END_REF]. One of the main outcome of this latter construction is a dMAM protocol for planarity, using certificates on O(log n) bits. For other recent results on distributed interactive proof, see [START_REF] Crescenzi | Trade-offs in distributed interactive proofs[END_REF][START_REF] Fraigniaud | On distributed Merlin-Arthur decision protocols[END_REF].

Model and definitions

We consider the standard model for distributed network computing [START_REF] Peleg | Distributed Computing: A Locality-Sensitive Approach[END_REF]. The network is modeled as a simple connected graph G = (V, E) -note that self-loops and multiple edges can be eliminated without impacting planarity, and the planarity test could trivially be performed independently in each connected components if the graphs were not connected. The number of nodes is denoted by n = |V |. Each node v has an identifier id(v), which is unique in the network, and picked from a range of IDs polynomial in n. Therefore, every node identifier can be stored on O(log n) bits.

We recall the notion of proof-labeling schemes, and locally checkable proofs for certifying graph classes. (These mechanisms can also be used to certify classes of node-or edge-labeled graphs, but we are solely interested in unlabeled graph classes in this paper). Let C be a graph class, e.g., planar graphs. A locally checkable proof for C is a prover-verifier pair where the prover is a non-trustable oracle assigning certificates to the nodes, and the verifier is a distributed algorithm enabling the nodes to check the correctness of the certificates by performing a single round of communication with their neighbors. Note that the certificates may not depend on the instance G only, but also on the identifiers assigned to the nodes. In proof-labeling schemes, the information exchanged between the nodes during the verification phase is limited to the certificates. Instead, in locally checkable proofs, the nodes may exchange extra-information regarding their individual state (e.g., their IDs, if not included in the certificates, which might be the case for certificates of sub-logarithmic size). The prover-verifier pair must satisfy the following two properties.

Completeness: Given G ∈ C, the non-trustable prover can assign certificates to the nodes such that the verifier accepts at all nodes;

Soundness: Given G / ∈ C, for every certificate assignment to the nodes by the non-trustable prover, the verifier rejects in at least one node.

The main complexity measure for both locally checkable proofs, and proof-labeling schemes is the size of the certificates assigned to the nodes by the prover.

As an example, let us consider the class of paths. A possible proof-labeling scheme is as follows. Given a path P = (v 1 , . . . , v n ), the prover assigns the certificate c(v i ) to node v i , simply defined as the hop-distance between v 1 and v i , for i = 1, . . . , n. The verifier executed at node u checks that u has degree 1 or 2, and, if u has degree 2, then it also checks that one of its two neighbors has certificate c(u) -1 while the other has certificate c(u) + 1. If all tests are passed, then u accepts, else it rejects. Completeness holds by construction. For soundness, we simply observe that, if all nodes accept, then the nodes are necessarily forming a path as we assume the network to be connected.

Certifying the class of graphs containing a path of length at least k, for some fixed k ≥ 1 can be done similarly, by also providing in the certificate of a node the IDs of its predecessor and successor in the path. The extremity of the path with positive hop-distance also checks that its hop-distance is at least k. In addition, the certificates must contain a distributed proof that the path exists somewhere in the network. This is achieved by asking the prover to provide the nodes with a distributed encoding of a tree spanning all nodes, rooted at one origin of the path, plus a distributed proof for this spanning tree. Such proof is known for long, as it is implicitly or explicitly present in the early work on self-stabilizing algorithm [START_REF] Afek | The local detection paradigm and its application to self-stabilization[END_REF][START_REF] Awerbuch | Self-stabilization by local checking and correction (extended abstract)[END_REF][START_REF] Itkis | Fast and lean self-stabilizing asynchronous protocols[END_REF] -it simply consists of yet another hop-distance counter, plus the ID of the root.

The examples above are the main ingredients enabling the design of a proof-labeling scheme for certifying non planarity, whose existence is folklore in the context of distributed certification.

It is indeed sufficient to provide the nodes with a distributed proof that the graph contains a subdivided K 5 or a subdivided K 3,3 . In both cases, this can be done by encoding the paths corresponding to these subdivided graphs in the certificates of the nodes in these paths. In addition, a spanning tree and its proof are given in the certificates of all nodes for establishing the existence of the subdivided graph (every node receives a pointer to a parent, its hopdistance to the root, and the ID of the root, which must be a node of the subdivided K 5 , or subdivided K 3,3 ). We omit all the tedious details, and we expect that the reader has now understood the concept of proof-labeling schemes (and locally checkable proofs).

Observe that, in all the examples mentioned in this section, including certifying nonplanarity, all certificates can be encoded on O(log n) bits. In the remaining part of the paper, we demonstrate that planarity can be distributedly certified, with O(log n)-bit certificates too.

Upper bound

In this section, we establish our main result, namely, that there is a 1-round proof-labeling scheme for planarity with certificates on O(log n) bits in n-node networks. The design and analysis of our proof-labeling scheme for planarity is decomposed into three stages. First, in Section 3.1, we describe a proof-labeling scheme for a specific class of planar graphs, called path-outerplanar graphs. Roughly, these graphs are Hamiltonian graphs which can be drawn in the plane without crossing edges in such a way that the Hamiltonian path forms a line, and the edges not in the path, are all on the same side of the line. Note that a non-Hamiltonian tree is outerplanar, but is not path-outerplanar. Next, in Section 3.2, we show how to transform a planar graph into a path-outerplanar graph. More precisely, we show how to transform a T -embedding [START_REF] De | A characterization of planar graphs by trémaux orders[END_REF] of a graph into a drawing of a new graph such that, roughly, the new graph is path-outerplanar if and only if the original graph is planar. Finally, Section 3.3 shows how to use this transformation for extending the proof-labeling scheme for path-outerplanarity to a proof-labeling scheme for planarity. Throughout the scheme, we use the key property that every planar graph is 5-degenerate (i.e., every subgraph has a vertex of degree at most 5), in order to distribute the certificates evenly among the nodes.

Certifying path-outerplanar graphs

In this section, we present a proof-labeling scheme for a subclass of outerplanar graphs, that will be used as a building block for our scheme for planar graphs. Recall that a graph is outerplanar if it has a planar drawing with all vertices incident to the same face, called the outerface. We start with a combinatorial definition of path-outerplanarity, and then show the equivalence with a geometric definition.

Definition 1 A graph G = (V, E) is path-outerplanar if there is a total ordering P = (V, <)
of its vertices such that P forms a path (i.e., consecutive vertices in P are adjacent in G), and, for any pair of edges {a, b}, {c, d} ∈ E with a < b and c < d, one of the following inequalities holds:

a < b ≤ c < d, c < d ≤ a < b, a ≤ c < d ≤ b, or c ≤ a < b ≤ d. The ordering P is called a path-outerplanarity witness of G.

Lemma 1 A graph is path-outerplanar if and only if it has a Hamiltonian path that can be drawn as a horizontal line such that all edges that do not belong to the path can be drawn above that line as semi-circles without crossings.

Proof. Assume that G is path-outerplanar with witness (1, . . . , n). The vertices {1, . . . , n} can be drawn on a horizontal line, with vertex i at coordinate i. Each edge {a, b} of G can be drawn as a semi-circle, with endpoints a and b, above the line. The drawing is planar since, by definition, for every two edges {a, b}, {c, d} of G with a < b and c < d, we have

|[a, b]∩[c, d]| ≤ 1, or [a, b] ⊂ [c, d], or [c, d] ⊂ [a, b].
Conversely, let us assume that there exists a planar drawing as described. Let us then consider the total order induced by the placement of the vertices along this horizontal path (say, from left to right). Since no two semi-circles cross, for every pair {a, b}, {c, d} of edges, one of the four inequalities in Definition 1 must be satisfied, and thus the graph is path-outerplanar.

Lemma 2 There is a 1-round proof-labeling scheme for path-outerplanarity, with certificates on O(log n) bits in n-node networks.

Proof. Given a path-outerplanar graph G, the prover computes a witness P = (v 1 , . . . , v n ) for G, and sends an O(log n)-bit certificate to every vertex x, with the following information:

1. the number n of vertices of the graph; 2. the rank of x in P , i.e., the value i such that x = v i ; 3. the shortest interval I(x) = [a, b] such that {v a , v b } is an edge of G, and a < i < b (if no such interval exists, then the prover sets I(x) to [0, n + 1]).

In addition, the prover provides the nodes with information in their certificates enabling them to check that n is indeed the correct number of vertices, that the vertices are correctly ranked from 1 to n, and that this ranking induces a path. We do not detail these parts of the certificates, nor we describe the verification algorithm for these certificates, as this can be achieved using standard techniques [START_REF] Korman | Proof labeling schemes[END_REF] using O(log n)-bit certificates. For simplicity, in the algorithm as well as in the remaining part of the proof, we denote the vertices by their ranks, as numbers from 1 to n. We also add two virtual vertices 0 and n + 1, with virtual edges {0, 1}, {0, n + 1}, and {n, n + 1}. We set I(0

) = I(n + 1) = [-∞, ∞].
This ensures that any vertex x with 1 ≤ x ≤ n has at least one neighbor smaller than itself, and another larger than itself. Of course, the verification algorithm is only performed at the real vertices, i.e., those from 1 to n, with node 1 (resp., node n) simulating the behavior of its virtual neighbor 0 (resp., n + 1).

The verification algorithm performed at each node x is displayed in Algorithm 1.

We first show completeness.

Claim 1 If G is path-outerplanar, and if the prover provides certificates corresponding to a witness P , then Algorithm 1 accepts at all nodes.

Proof. For any node x, let

x - ℓ < • • • < x - 0 < x + 0 < • • • < x + k
, with ℓ ≥ 0 and k ≥ 0, be the neighbors of x in the ordering P . In particular, x - 0 < x < x + 0 . Figure 1 illustrates the structure of the neighborhood of a node x, and the interval

I(x) = [a, b] (cf. Lemma 1). Note that, since G is planar, a ≤ x - ℓ , and b ≥ x + k .
The test of Line 3 succeeds since P is the witness for G. Observe that the vertices y with I(y) = [a, b] are exactly the vertices incident to the unique face below the edge {a, b}, except a and b -this also holds for the nodes 0 and n + 1, as we could add a virtual edge between -∞ and ∞. In particular, no edge incident to x can cross the edge {a, b}, which implies that the test of Line 5 is passed. The same arguments applied to x + i explains why the test of Line 7 is passed (respectively, x - i and Line 9). For the rightmost neighbor x + k of x, we distinguish between the cases x + k < b, and x + k = b. In the first case, x k is also incident to the face below the edge {a, b}, and thus the test of Line 11 succeeds. The same arguments apply for the test at Line 13. The case x k = b is not explicitly addressed by Algorithm 1: Verification procedure for path-outerplanarity at node x, 1 ≤ x ≤ n.

1 let x - ℓ < • • • < x - 0 < x + 0 < • • • < x + k
, with ℓ ≥ 0 and k ≥ 0, be the neighbors of x; 2 collect the certificates of each neighbor: graph size, rank, and interval; 3 check that the ranks correspond to a spanning path of size n; 4 let I(x) = [a, b]; 5 check that a < x < b, and that all neighbors of x are in the interval [a, b]; 18 if all checks are passed then accept else reject.

6 for i = 0 to k -1 do 7 check that I(x + i ) = [x, x + i+1 ]; 8 for i = 0 to ℓ -1 do 9 check that I(x - i ) = [x - i+1 , x]; 10 if x + k < b then 11 check that I(x + k ) = [a, b]; 12 if x - ℓ > a then
Algorithm 1 applied on x. However, it is part of the tests performed at Lines 16 and 17, when applied to node x + k . These two tests succeed by definition of I(x) and I(y). It follows that node x accepts, as desired. ⋄

x x + 0 x + 1 x + k b a x - 0 x - 1 x - ℓ Figure 1:
The neighborhood of a node x, and the edge {a, b} covering x.

It remains to establish soundness. Namely, we prove that, if Algorithm 1 accepts at all nodes, then G is path-outerplanar. As mentioned before, we do not detail the test for the spanning path (Line 3), but this test ensures that the ranks are consistent, from 1 to n, and that consecutive vertices in this order are adjacent in G. We thus safely denote the vertices by their ranks. In fact, we show that if Algorithm 1 accepts at all nodes, then G is pathouterplanar with witness P = (1, 2, . . . , n). Let us assume, for the purpose of contradiction, that this is not the case. It follows that there are four nodes x < y < z < t such that both edges {x, z} and {y, t} appear in G. Under these conditions, let us choose such four nodes with the additional conditions that (i) zy is minimum, and (ii) tx is minimum subject to (i).

The following claim is a straightforward consequence of conditions (i) and (ii) -see Figure 2 for an illustration of the framework of the claim.

Claim 2 For every edge {a, b}, if y < a < z, then y ≤ b ≤ z. Also, if y = a < b < t, then b ≤ z, and if x < a < z = b, then a ≥ y. Finally, any two edges with both endpoints in the interval [y, z] are non-crossing. ⋄ To understand the structure of the graph in between y and z, let us define:

• y + j , the rightmost neighbor of y strictly before t in the ordering P ,

• z - i , the leftmost neighbor of z strictly after x in the ordering P . Note that these two nodes exist, as the node immediately on the right of y in the path appears strictly before t, and the node immediately on the left of z in the path appears strictly after x.

Claim 3

The following holds:

y < y + j < z - i < z, I(y + j ) = [y, t], and
I(z - i ) = [x, z].
Proof. By Claim 2, the inequality y < y + j ≤ z holds. Also, as the test of Line 7 applied to vertex y succeeds, it follows that I(y + j ) = [y, t]. Observe that {y, z} cannot be an edge of the graph. Indeed, if {y, z} is an edge of the graph, then it must be the case that z = y + j , and thus I(z) = [y, t]. Also, symmetrically, the equality I(y) = [x, z] must hold too. As the test of Line 17 applied to vertex y succeeds, it follows that I(z) I(y), which contradicts the fact that the two intervals overlap. Therefore {y, z} is not an edge of the graph. It follows that y + j < z. By the same arguments as for y + j , but applied to the left-hand side of z, it follows that y < z - i , and

I(z - i ) = [x, z].
Also observe that we have y + j ≤ z - i , by Claim 2 applied to edges {y, y + j } and {z - i , z}. Finally, as I(y + j ) = [y, t] and I(z - i ) = [x, z], and as these two intervals are different, it must be that y + j < z - i . ⋄

In the following, an edge {u, v} is said to be maximal if v is the rightmost neighbor of u, and u is the leftmost neighbor of v. See Figure 3. The next claim describes the structure of the graph between y + j and z - i (see Figure 4). Claim 4 There is a path Q = (q 1 , . . . , q s ) in G, with s > 1, q 1 = y + j , and q s = z - i , such that, for every i = 1, . . . , s -1, q i < q i+1 and {q i , q i+1 } is a maximal edge.

v = u + k b a u
Proof. The path is constructed as follows: q 1 = y + j and, as long as the rightmost vertex q i of the partial path created so far satisfies q i < z - i , we pick q i+1 as the rightmost neighbor of q i . We claim that q i+1 ≤ z - i . This is because:

1. by Claim 2, it cannot be the case that q i+1 > z;

2. q i+1 = z cannot hold because q i would then contradict the choice of z - i as leftmost neighbor of z larger than x;

3. z - i < q i+1 < z is impossible as the crossing edges {q i , q i+1 } and {z - i , z} would contradict Claim 2.

Therefore the construction of Q correctly terminates at vertex z - i . It remains to show that edges {q i , q i+1 } are maximal for all i = 1, . . . , s -1. By construction, q i+1 is the rightmost neighbor of q i , and thus it is sufficient to prove that q i is the leftmost neighbor of q i+1 . Assume that q i+1 has a neighbor q ′ < q i . As for the construction of Q, observe that q ′ ≥ y by Claim 2 applied to the edge {q ′ , q i+1 }. Also, q ′ cannot be one of the vertices y ∈ {q 1 , . . . , q i } because, for every j = 1, . . . , i, q j is the rightmost neighbor of q j-1 smaller than z. Eventually, q ′ cannot be strictly between q j-1 and q j for some j with 1 ≤ j ≤ i, by Claim 2 applied to edges {q ′ , q i } and {q j-1 , q j }. Therefore, q i is the leftmost neighbor of q i+1 , and all edges {q i , q i+1 } are maximal. ⋄

We were interested in maximal edges because of the following claim.

Claim 5 If the edge {u, v} is maximal, and Algorithm 1 accepts at all nodes, then I(u) = I(v).

Proof. We refer to Figure 3

If

v = b but u = v - ℓ > c
, where v - ℓ is the leftmost neighbor of v, then, by symmetry, the test of Line 9 applied to x = v implies that I(u) = I(v), as claimed. This completes the proof of Claim 5. ⋄

We can now complete the soundness proof for our proof-labeling scheme. By Claims 4 and 5, all the vertices of the path Q (formed of maximal edges) were assigned the same interval I. This contradicts the fact that, according to Claim 3, I(q 1 ) = [y, t] and I(q s ) = [x, z]. This contradiction completes the proof of Lemma 2.

From path-outerplanar graphs to planar graphs

The previous section has demonstrated how to construct a compact proof-labeling scheme for the class of path-outerplanar graphs. For extending the scheme to planar graphs, this section presents a transformation that maps any planar graph to a path-outerplanar graph. To get an intuition of this transformation, let us first explain how a tree T can be transformed into a path. The transformation is inspired by the classical approximation algorithm by Christofides for the traveling salesman problem. A depth-first search (DFS) traversal of the tree returns an ordering of the nodes by indices from 1 to 2n -1, where a same node can be assigned several indices. This ordering can be transformed into a path on 2n -1 nodes, by creating a copy of each node for each time it is visited by the DFS traversal, and linking such nodes according to the ordering of the traversal.

More formally, let T be a tree spanning a planar graph G. We fix a drawing of G in the plane without crossing edges (see Figure 5(a), ignoring node r ′ at this stage of the proof). We can assume, w.l.o.g., that all edges are drawn as straight lines (it is not crucial in the construction, but it helps for understanding it). The tree T is rooted at an arbitrary vertex r. For any vertex v = r, its neighbor on the path from v to r is called the parent of v, and the other neighbors of v are called its children. For any node v, deg T (v) is the degree of v in T . A DFS traversal of T starting from r provides a DFS-mapping f : {1, . . . , 2n -1} → V (T ) satisfying the following: f (1) = r, and, for 1 ≤ i < 2n -1,

f (i + 1) = a child of f (i) that is not in f ({1, . . . , i -1}) if there is such a node; the parent of f (i) otherwise.
Note that f is onto but not one-to-one. In particular, each vertex v of T , different from the root is mapped by f -1 to deg T (v) different vertices of the path P = (1, 2, . . . , 2n -1) (see Figure 5(b)). The root r is mapped to deg T (r) + 1 vertices of P . Intuitively, each edge of T is mapped by f -1 on exactly two edges of P . Note that if 1 ≤ i, j ≤ 2n -1 are two integers such that i is the least integer satisfying f (i) = v, and j is the largest integer satisfying f (j) = v, then, for every i ≤ k ≤ j, f (k) is either a descendent of v, or v itself. Given (G, T, f ), we define a class of graphs induced by (G, T, f ) in such a way that: (1) if G is planar, then there exists a choice of T and f for which a graph induced by (G, T, f ) is path-outerplanar, and (2) if G is not planar, then for every T and f , no graph induced by (G, T, f ) is path-outerplanar. Figure 5 provides an illustration of the definition below (again, ignore node r ′ at this stage of the proof).

r ′ r v 1 v 2 v 3 v 4 v 5 v 6 v 7 (a) (b)
Definition 2 A graph H is said to be induced by (G, T, f ) if V (H) = {1, . . . , 2n -1}, and (1) {i, i+1} ∈ E(H) for every 1 ≤ i < 2n-1, and (2) for every cotree edge {u, v} ∈ E(G)\E(T ), there exists a unique edge {i, j} ∈ E(H) such that {f (i), f (j)} = {u, v}.

Note that the definition does not imply the uniqueness of H as a graph induced by (G, T, f ). For example, in Figure 5(b), if we replace the edge between nodes 7 and 9 by an edge between 7 and 5, we get another graph induced by the graph on Figure 5(a) that satisfies Definition 2.

Lemma 3 For every planar graph G, and every spanning tree T of G, there exists a DFSmapping f of T , and a graph G T,f induced by (G, T, f ), such that G T,f is path-outerplanar.

Proof. Let G = (V, E) be a planar graph, and consider a drawing of it in the plane. Let T be a spanning tree of G, rooted at an arbitrary node r. For every vertex v ∈ V , we set a numbering

ν v : {0, . . . , deg T (v) -1} → N (v),
where N (v) denotes the set of neighbors of v in T . In this numbering, ν v (0) is the parent of v in T if v = r. These numberings satisfy that, for i = 0, . . . , deg T (v) -1, the edge {v, ν v (i)} is immediately followed by the edge {v, ν v (i + 1 mod deg T (v))} when one follows the counterclockwise ordering of the edges of T incident to v in the planar drawing of G. For every two distinct children u, u ′ of v, the fact that u = ν v (k) and

u ′ = ν v (k ′ ) with k < k ′ is denoted by u ≺ u ′ .
We now define the DFS-mapping f of T as follows. The DFS traversal used for constructing f starts from r, and explores the children of each node v in counterclockwise order, i.e., in the order provided by the numbering ν v . It follows that, for every v ∈ V , there exists a sequence

1 ≤ i 1 < • • • < i d ≤ 2n -1 of integers, with d = deg T (v) if v =
r, and d = deg T (r) + 1 otherwise, such that f -1 (v) = {i 1 , . . . , i d }, and

f (i 1 + 1) = f (i 2 -1) ≺ f (i 2 + 1) = f (i 3 -1) ≺ • • • ≺ f (i d-1 + 1) = f (i d -1).
To construct the desired path-outerplanar graph G T,f , it is convenient to add an extra node r ′ to G, of degree 1, connected to the root r of T . In the drawing, r ′ is placed so that {r, r ′ } appears between the edges {r, ν r (0)} and {r, ν r (deg T (r) -1)} when one follows the clockwise ordering of the edges of T incident to r in the planar drawing of G. Moreover, r ′ is placed close enough to r in the plane so that the edge {r, r ′ } drawn as a straight line does not cross any edge in the drawing of G (see Figure 5(a)). We extend f to {0, 2n} by setting f (0) = f (2n) = r ′ . In this way, r becomes an internal node of the tree T ′ = T + r ′ , avoiding special considerations in the construction of G T,f regarding whether a node v is the root r or not. In particular, d systematically denotes the degree of the considered node v ∈ V , including r, and thus

f (i 1 -1) = f (i d + 1) is the parent of v in T ′ , for every v ∈ V .
For every v ∈ V , let us fix a circle C v centered at the point representing v in the planar drawing of G. We choose C v sufficiently small so that (i ) v is the only node inside C v , (ii ) the only drawings of edges crossing C v have v as endpoints, and (iii )

C v ∩ C v ′ = ∅ whenever v = v ′ .
See Figure 6. For 1 ≤ k ≤ d, let x i k be the point of the plane at the intersection of C v with the drawing of the edge {f (i k ), f (i k + 1))}. These points are met in the order x i 1 , . . . , x i d whenever one travels along C v counterclockwise, starting from x i 1 .

We say that a point x of C v is of type i k if, traveling along C v counterclockwise starting from x, the first point met among {x i 1 , . . . , x i d } is x i k . The type of x is denoted by τ (x). For every cotree edge {u, v} ∈ E \ E(T ), the drawing of {u, v} meets C u in a point x (u,v) , and meets C v in a point x (v,u) (see Figure 6). We now consider the graph G T,f induced by (G, T, f ), with the specific requirement that, for every cotree edge {u, v} of E(G) \ E(T ), the unique edge {i, j} ∈ E(G T,f ) such that {f (i), f (j)} = {u, v} is the edge {i, j} = {τ (x (u,v) ), τ (x (v,u) )}.

The proof of the lemma is completed by establishing that G T,f is outerplanar. To do so, it is convenient to state the following simple result. For a graph G = (V, E) with vertices numbered from 1 to n, let G + be the graph obtained from G by adding two vertices 0 and n + 1, and

E(G + ) = E ∪ {0, 1}, {0, n + 1}, {n, n + 1} .
Claim 6 If G is path-outerplanar with witness (1, 2, . . . , n), then G + is outerplanar, and has a drawing in which the outerface corresponds to the cycle (0, 1 . . . , n, n + 1). Conversely, if G + is outerplanar with a drawing in which the outerface forms a cycle (0, 1, . . . , n, n + 1) in G + , then G is path-outerplanar with witness (1, 2, . . . , n). ⋄

By Claim 6, it is sufficient to provide a planar embedding of G + T,f in which the vertices {0, . . . , 2n}, which form a cycle, are on the same face, in order. For this purpose, at each node v of G, the circle C v is split in d sections, such that section k, for 1 ≤ k ≤ d, contains all the points of C v with type i k (see Figure 6). We draw node i k on the middle of the section k. In this way, all the nodes of G T,f are placed in the plane. Each edge {i, j} of G T,f is drawn as a straight line connecting the corresponding points in the plane. In addition, the extra node r ′ is split into two nodes 0 and 2n, and three edges are added: {0, 1}, {0, 2n}, and {2n -1, n}. The two nodes 0 and 2n are placed next to each other, close enough so that these three edges do not intersect.

The transformation simply corresponds to thickening the edges, and the internal nodes of the tree T ′ , where the thickness of the tree is at most the maximum, taken over all the nodes v, of the radius of C v , which can be chosen as small as desired. It follows that planarity is preserved.

By the setting of f , the nodes (0, . . . , 2n) form a path. By construction of G T,f , the cycle (0, 1, . . . , 2n) in G + T,f draws in a plane a Jordan curve, splitting the plane into two regions. The one containing the original drawing of T is also a face of G + T,f , all the cotree edges being drawn on the other region. It then follows from Claim 6 that G T,f is path-outerplanar.

x i d x v,u x v,u ′ x i1 x i2 x i k x v,u ′′ i 1 i 2 i k i d u v ∈ V u ′ u ′′ i 1 i 2 i k i d u u ′ u ′′ i 1 + 1 i 2 -1 i 2 + 1 i k -1 i k + 1 i d -1 i d + 1 i 1 -1 Figure 6: Planar drawing: from (G, T, f ) to G + T,f .
The next result is a form of reciprocal of Lemma 3.

Lemma 4 If G has a spanning tree T , and a DFS-mapping f of T , such that a graph H induced by (G, T, f ) is path-outerplanar, then G is planar.

Proof. Let us assume that G has a spanning tree T , and a DFS-mapping f of T such that some graph H induced by (G, T, f ) is path-outerplanar. Let G f be the graph with vertex set {1, 2, . . . , 2n -1} such that, for every 1 ≤ i < j ≤ 2n -1, {i, j} is an edge if and only if (1) j = i + 1, or (2) f (i) = f (j), and every k ∈ {i + 1, . . . , j -1} satisfies f (k) = f (i). The graph G f is path-outerplanar by construction, due to the definition of the mapping f . Let G ′ be the graph defined as V (G ′ ) = {1, . . . , 2n -1}, and

E(G ′ ) = E(H) ∪ E(G f
). G ′ is planar, since both H and G f are path-outerplanar graphs, and thus, for each of the two graphs, its edges can be drawn in one of the two sides of the path (1, . . . , 2n -1) -if these two graphs share edges, then they are considered as belonging to H. It follows that if all edges of G ′ belonging to E(G f ) \ E(H) are contracted, then the resulting graph is planar. Now, observe that the resulting graph is precisely the graph G, because the contractions identify all pairs of nodes i, j for which f (i) = f (j) holds.

Certifying planar graphs

The previous sections provide us with the ingredients for the proof of Theorem 1. Lemma 3 provides a tool for transforming a planar graph into a path-outerplanar graph, by "cutting along" a spanning tree, and transforming the tree into a path through a specific DFS traversal. Importantly, this transformation is both ways, in the sense that, as stated in Lemma 4, if a graph G has been transformed into a path-outerplanar graph by cutting along a spanning tree, then G is necessarily planar. Our proof-labeling scheme for planar graphs aims at implementing this transformation, and then checking the path-outerplanarity of the resulting graph using the scheme provided in Lemma 2. The rest of the section contains the details of the implementation, including the delicate issue of keeping the certificate size small, which is not direct, as a same node of the graph may have to simulate the behavior of many vertices of the path-outerplanar graph after applying the transformation.

Proof of Theorem 1. Given a planar graph G, the prover draws it on the plane, constructs a spanning tree T , a DFS-mapping f on its vertices, and a path-outerplanar graph G T,f as in Lemma 3. The prover then provides the nodes with certificates allowing them to verify that:

1. T is a spanning tree of G, and f is a DFS-mapping of T ;

2. G T,f is path-outerplanar, with witness f .

Certifying the conditions in the first item is quite simple and standard [START_REF] Korman | Proof labeling schemes[END_REF]. It is therefore omitted, apart from the issue of the certificates size, which we discuss later. We focus on the second item. The proof-labeling scheme of the path-outerplanarity of G T,f with witness f was presented in Lemma 2. Let us recall that a vertex x of G is transformed into several nodes in G T,f , namely into the nodes in f -1 (x) = {i 1 , . . . , i d }. The verification at node x involves the simulation of the verification protocol for path-outerplanarity for each of the nodes i 1 , . . . , i d of the graph G T,f . The index d may however be large, even as large as O(n). It follows that, for keeping certificates of logarithmic size, the prover cannot simply assign the d path-outerplanarity certificates of its d copies in G T,f to node x. We now explain how to cope with this issue for preserving O(log n)-bit certificates. Every edge {x, y} of T is mapped on two edges {i, j} and {i ′ , j ′ } of G T,f , and every non-tree edge {x, y} of G is mapped on one edge {i, j} of G T,f . The certificates corresponding to the 2n -1 vertices of G T,f are distributed to the n vertices of G in such a way that, after a single communication round in G, each vertex x collects the certificates of all its copies i 1 , . . . , i d in the protocol for path-planarity, as well as the certificates of all the neighbors in G T,f of each copy i j , j = 1, . . . , d. To see how this is achieved, let us consider for now a virtual scenario in which the certificates can be distributed on the edges of G. Let e = {x, y} be an edge of G, and let {i, j} and {i ′ , j ′ } be its two associated edges in G T,f (if e is mapped to a unique edge of G T,f , which is the case of cotree edges, we simply set {i ′ , j ′ } = {i, j}). Then the certificate c(e) of the edge e includes the following information:

• the identifiers of x and y in G;

• the values i, j, i ′ , j ′ ∈ {1, . . . , 2n -1};

• the certificates of nodes i, j, i ′ , j ′ in the proof-labeling scheme for path-outerplanarity in G T,f with witness f .

If we could assign c(e) to every edge e = {x, y} of G, then c(e) could be sent to its endpoints x and y, and vertex x could simulate the verification protocol of Algorithm 1 for checking the pathouterplanar graph G T,f with witness f , for each copy i 1 . . . , i d of x. Since assigning certificates to edges is not doable, the certificate c(e) is actually assigned to one of its two endpoints. This assignment is performed so that each node receives at most five edge-certificates. For this purpose we use the fact that a planar graph G = (V, E) has degeneracy at most 5. That is, there exists a total ordering σ of the vertices of G such that every node x has at most five neighbors y with σ(y) > σ(x). Every edge e is associated to its smaller endpoint, according to σ. It follows that each node x is associated to at most five edges, all with x as endpoint.

The prover assigns the certificate c(x) to node x, defined as the concatenation of the at most five edge-certificates associated to x. Extra-informations are also added to every certificate, for allowing the nodes to check that T is a spanning tree of G. Overall, the certificates are of the due size O(log n) bits.

The verification protocol executed at each node of G is displayed in Algorithm 2.

Algorithm 2: Verification procedure for planarity at node x ∈ V (G)

1 collect the certificate of each neighbor;

2 //Phase 1: recover local information regarding T, f , and G T,f ;// 3 compute ID of the parent of x in T , and the IDs of all its children in T ;

4 compute f -1 (x) = {i 1 , i 2 , . . . , i d }, i.
e., all nodes corresponding to x in G T,f ; 5 for every i ∈ f -1 (x) do 6 retrieve certificate of node i in G T,f dedicated to the path-outerplanarity of G T,f ; 7 compute the neighbors of i in G T,f , and their certificates for path-outerplanarity;

8 //Phase 2: check that T is a spanning tree of G, and f is a DFS-mapping of T ;// 9 check local consistency of certificates for spanning tree; 10 check local consistency of certificates for DFS-mapping; 11 // Phase 3: check the path-outerplanarity of G T,f with witness f ;// 12 for every i ∈ f -1 (x) do 13 simulate execution of Algorithm 1 at node i of G T,f ; 14 if all checks are passed then return accept else return reject.

In Phase 1 of Algorithm 2, every node x retrieves information regarding x itself as a node of G, and all the "virtual" nodes i ∈ f -1 (x) of G T,f . Observe that, for every edge e = {x, y} incident to x in G, node x obtains all information contained in c(e) after one single communication round with its neighbors. An edge e = {x, y} is in T if and only if the pair (x, y) has been mapped on two disjoint pairs (i, j), (i ′ , j ′ ) corresponding to distinct edges G T,f . Node y is the parent of x if min{i, i ′ } < min{j, j ′ }, and is a child otherwise. By considering all incident edges in G, x retrieves all its corresponding nodes i 1 , . . . , i d in G T,f , their neighbors in G T,f , and all the corresponding certificates for the path-outerplanarity of G T,f with witness f . Phase 2 checks that T is a spanning tree of G (see [START_REF] Korman | Proof labeling schemes[END_REF]), and checks that f is a DFS-mapping of T . This latter condition is rather simple to check, so we only provide some hints. Let f -1 min (x) and f -1 max (x) be the smallest and largest values in f -1 (x). These values correspond to the first, and last time the DFS visited node x. The children y 1 , . . . , y k of x in T are then sorted by increasing value of f -1 min (y i ). The main test consists to check that:

• if x has no children, then f -1 max (x) = f -1 min (x); • if x has children y 1 , . . . , y k , then f -1 min (x) = f -1 min (y 1 ) -1, f -1 max (x) = f -1 max (y k ) + 1, and, for every j = 1, . . . , k, f -1 min (y j+1 ) = f -1 max (y j ) + 2.
In addition, the root r of T checks that {1, 2n -1} ⊆ f -1 (r). Finally, Phase 3 of Algorithm 2 at x applies the verification protocol for checking the consistency of the distributed proof of the path-outerplanarity of G T,f , for every node i ∈ f -1 (x) of G T,f corresponding to x.

Completeness holds as, if the input graph G is planar, and if the prover constructs T and f correctly, as well as the path-outerplanar graph G T,f whose existence is guaranteed by Lemma 3, then Phase 2 accepts by construction of T and f , and Phase 3 accepts since the verification algorithm for path-outerplanarity is correct by Lemma 2.

For the soundness, assume that Algorithm 2 returns accepts at all nodes of G. Then, thanks to Phase 2, T is necessarily a spanning tree of G, and f is a DFS-mapping of T . Also, thanks to Phase 3, G T,f is necessarily path-outerplanar with witness f . Therefore, by Lemma 4, G is planar. This completes the proof of Theorem 1.

Lower bounds

This section is dedicated to the proof of Theorem 2. The proof is modular: Section 4.1 treats the case of Forb(K k ), while Section 4.2 treats the case of Forb(K p,q ). Finally, Section 4.3 combines the two cases, and completes the proof. All proofs in this section can be generalized to the setting where the verification algorithm performs t rounds instead of just one round, for any constant t ≥ 1, by replacing some edges of the graph instances constructed hereafter by a path of length O(t).

Lower bound for Forb(K k )

Our lower bound proof for Forb(K k ) is based on extending the techniques developed in [START_REF] Feuilloley | Local verification of global proofs[END_REF].

Lemma 5 For every k ≥ 3, there are no locally checkable proofs for Forb(K k ) with o(log n)-bit certificates.

Proof. We first define two similar types of instances that we call paths of blocks and cycles of blocks. We prove that paths of blocks are legal instances, that is, they are K k -minor-free, and that cycles of blocks are illegal instances, that is, they contain K k as a minor. Then, we show by a counting argument that, if all the paths of blocks are accepted, and if the certificates used for these instances are too small, then there exists a cycle of blocks that is also accepted, which implies that the scheme is not correct.

Blocks and block connections. Let p ≥ 1, and let n = (k -1)(p + 2). For every r = 0, . . . , p + 1, let us consider a path P r of k -1 nodes with identifiers r(k -1), r(k -1) + 1, ..., (r + 1)(k -1) -1, in consecutive order. A block B r is a graph formed of such a path P r , plus edges between every pair of nodes in P r . In other words, a block is a complete graph K k-1 , with an ordering of the nodes given by their identifiers. There are two special blocks: B 0 , called the starting block, and B p+1 , called the ending block. The p other blocks are called ordinary blocks. Note that the identifiers of the blocks are all distinct.

Blocks are connected by block connections. A block connection from block B i to block B j is as follows. Place the block B i on an horizontal line with the nodes in increasing order of their IDs, and then place the block B j to the right of B i , also with the nodes in increasing order of their IDs. Then, add all edges between the ⌈(k -1)/2⌉ rightmost nodes of B i (which is called the right part of B i ) and the ⌊(k -1)/2⌋ leftmost nodes of B j (which is called the left part of B j ). See Fig. 7 for an example with k = 4, where the edges inside the blocks are grey, and the edges between the blocks are black (since ⌈(k -1)/2⌉ = 2 and ⌊(k -1)/2⌋ = 1, there are two edges between these blocks). Note that two nodes that are linked by an edge have at most k -3 nodes between them in the horizontal ordering. In other words, no edge can "jump" over more than k -3 nodes. Also note that, if B i has a block connection to B j , and if B j has a block connection to B k , then, every node of B j is connected either to a node of B i , or to a node of B k , but not both.

B i B j
Path and cycles of blocks. Let π be a permutation on p elements. To create a path of blocks, B 0 has a block connection to B π -1 (1) , B π -1 (1) has a block connection to B π -1 (2) , etc., and B π -1 (p) has a block connection to B p+1 . A cycle of blocks is constructed in a similar way, as follows. Let k, k ′ with 1 ≤ k < k ′ ≤ p. To create a cycle of blocks, B π -1 (ℓ) has a connection to B π -1 (ℓ+1) for every ℓ ∈ {k, . . . , k ′ -1}, and B π -1 (k ′ ) has a connection to B π -1 (k) . Note that a cycle of blocks uses only a subset of blocks. Note also that, as the node identifiers given to different blocks are distinct, the paths and the cycles of blocks are well defined.

Claim 7 Paths of blocks are K k -minor-free.

Proof. By symmetry, there is no loss of generality in proving the claim only for the identity permutation π. For simplicity of the notation, the nodes are referred to by their identifiers. Also, for the sake of clarity, we do not consider a path of blocks but an extension of it. That is, we add some edges, to make the path of blocks more symmetric, and hence avoid some case analysis. Note that, to prove the claim, it is sufficient to show that the larger graph G obtained by adding edges to the path of blocks, is K k -minor-free.

For every 0 ≤ r ≤ p, and every 0 ≤ i ≤ k -1, the node r(k -1) + i of B r is connected in G to all nodes (r + 1)(k -1) + j, 0 ≤ j < i, of B r+1 . See Figure 8 for an example. Note that, for every node ℓ, the closed neighborhood of ℓ (i.e., ℓ and its neighbors) is the interval Let us assume, for the purpose of contradiction, that G contains K k as minor. Then, there are k disjoint sets of nodes S 1 , . . . , S k such that each set S i is connected, and, for every pair (S i , S j ) of sets, S i ∪ S j is a connected subgraph of G. Each node belongs to at most one set S i . Let us visit the nodes of the path of blocks, by increasing order of their IDs, and let S a be the last visited set. Let ℓ a be the first node belonging to S a , i.e., the node with minimum ID in S a . Let us now consider a set S b such that S b ∩ [ℓ ak + 2, ℓ a ] = ∅. Such a set exists because there are k disjoint sets, and the interval is of size k -1. Let ℓ b be a node of S b such that ℓ b < ℓ a . Such a node exists because, by definition of S a , S b is visited before S a when nodes are traversed according to the increasing order of their IDs. The interval I = [ℓ ak + 2, ℓ a -1] contains k -2 integers, and (S a ∪ S b ) ∩ I is empty. Now, on the one hand, there cannot exist an edge {ℓ, ℓ ′ } with ℓ < ℓ ak + 2, and ℓ ′ > ℓ a -1, because |ℓℓ ′ | ≥ k -1. However, on the other hand, the sets S a ∩ [ℓ a , (r + 1)(p + 2)] and

[ℓ -k + 2, ℓ + k -2]. It follows that, for every edge {ℓ, ℓ ′ }, |ℓ -ℓ ′ | ≤ k -2.
S b ∩ [0, ℓ a -k + 1]
are both non-empty, as they respectively contain ℓ a and ℓ b . It follows that S a ∪ S b is not connected, and therefore K k cannot be a minor of the path of blocks. ⋄ Claim 8 Cycles of blocks are not K k -minor-free.

Proof. Let us consider a cycle of blocks, and let B be an arbitrary block of this cycle. By construction, the graph obtained by removing B from the cycle is connected. Let us contract this graph into one node v. The node v is connected to all nodes of B since, as pointed out before, every node of B is linked to at least one node outside B. Now, as B is in itself K k-1 , the resulting contracted graph is K k . ⋄

To complete the proof of Lemma 5, it is sufficient to show that cycles and paths of blocks are indistinguishable whenever the certificates are too small.

Let us assume that there exists a locally checkable proof with certificates of size g(n) = o(log n) bits. We show that there exist two paths of blocks for which the prover gives to every block the exact same certificates. For this purpose, let us call labeled block a block in which every node is given a certificate of size g(n). Every block can be labeled in 2 (k-1)g(n) manners. Let us consider a set of labeled blocks where one labeled version of each block appears as element of this set. There are 2 (k-1)g(n)p such sets. On the other hand, there are p! different paths of blocks, as there are p! permutations of the ordinary blocks. To compare these numbers, it is simpler to compare their logarithms. We get the following asymptotics (having in mind that k is a constant, and p = Θ(n)): log 2 (k-1)g(n)p = o(n log n) and log(p!) = Ω(n log n).

It follows that, for large n, there are more paths of blocks than distinct sets of labeled blocks. Thus, by the pigeon-hole principle, for large enough n, there exist two paths of blocks, P and P ′ , where all nodes accept with a same certificate assignment, i.e., certificates inducing identical labeled blocks. Let A be this certificate assignment.

Without loss of generality, let us assume that P corresponds to the identity permutation. In the permutation π corresponding to P ′ , there must exist two indices i and j with i < j such that π(i) > π(j). We define a cycle of blocks C as follows. The blocks B i , B i+1 , ..., B j are connected in this order, and the cycle is closed by connecting B j to B i . We claim that every node in C accepts whenever it is given certificates according to A. Indeed, let u be any node of C, except the ones incident to an edge between B j and B i . Node u has the same view in C as in P (i.e., it has the same neighbors, with the same identifiers, and the same certificates), thus it accepts. Now, let us consider a node that is incident to an edge between B j and B i . As pointed out before, such a node is not linked to any node from a third block. It follows that it has the same view in C as in P ′ . Therefore, all the nodes of C accept, in contradiction with the soundness condition. This completes the proof of Lemma 5.

Note that the proof of Lemma 5 can be adapted to a larger verification radius t, by replacing each edge by a path of length t.

Lower bound for Forb(K p,q )

Our lower bound proof for Forb(K p,q ) is an adaptation of the lower bound proof for spanning tree and leader election, by Göös and Suomela [START_REF] Göös | Locally checkable proofs in distributed computing[END_REF]. Roughly speaking, we show that, if the certificates are of size o(log n), then it is possible to define a set of legal instances (i.e., K p,qfree graphs) which can be "glued" together in order to obtain an illegal instance (i.e., a graph containing K p,q as a minor) in such a way that no vertices can locally distinguish which instance they belong to.

Lemma 6 For every p, q ≥ 2, there are no locally checkable proofs for Forb({K p,q }) using certificates on o(log n) bits.

Proof. If p = q = 2, then K p,q is a 4-cycle, and thus Forb({K p,q }) is the family of graphs in which the only allowed cycles are of length 3. The fact that this class of graphs cannot be certified by a locally checkable proof using certificates on o(log n) bits follows directly for previously known constructions (see [START_REF] Göös | Locally checkable proofs in distributed computing[END_REF]).

Let p ≥ 2 and q ≥ 3, and let us assume, for the purpose of contradiction, that Forb({K p,q }) admits a locally checkable proof with certificates of size o(log n). Without loss of generality, we assume that q ≥ p, and we consider n ≥ 6q. The range of identifiers is split into subsets, as in [START_REF] Göös | Locally checkable proofs in distributed computing[END_REF]. Let n A = ⌊n/2⌋, and n B = ⌈n/2⌉. Let us fix any partition of the identifiers {1, . . . , n 2 } into 2n subsets a 1 , . . . , a n , b 1 , . . . , b n so that each a i ∈ A = {a 1 , . . . , a n } is of size n A , and each b

i ∈ B = {b 1 , . . . , b n } is of size n B . We denote by a i [j] (resp. b i [j]) the j-th identifier of a i ∈ A (resp. b i ∈ B) in increasing order of the IDs in a i (resp. b i ).
For every pair (a, b) ∈ A × B, let I a,b be a legal instance, i.e., a K p,q -minor-free graph G with a specific identity-assignment to its nodes, defined as follows. Let d = ⌊ n 2q ⌋. The graph G is defined as two disjoint paths, one of length n A , and another of length n B . In I a,b , the nodes in the former path are given IDs in a, in increasing order, while the nodes in the latter path are given IDs in b, also in increasing order. Also, for every j ∈ {1, . . . , q}, there is an edge in G between the node with ID a[jd] and the node with ID b[jd]. An illustration of this construction is displayed on Figure 9.

Observe that G is outerplanar, and thus G ∈ Forb({K 2,3 }), from which it follows that G ∈ Forb({K p,q }) for every p ≥ 2 and q ≥ 3. It is known [START_REF] Füredi | An upper bound on Zarankiewicz'problem[END_REF] that every graph with n 2-1/q + o(n 2-1/q ) edges contains K q,q as subgraph. It follows that, for sufficiently large n, the graph H = (A ∪ B, F ) contains K q,q as subgraph. Up to reindexing the elements in the sets A and B, the vertices of this subgraph are a 1 , . . . , a q and b 1 , . . . , b q . Since all edges in H have the same color,

c(a i , b j ) = c(a i ′ , b j ′ ),
for every (i, i ′ , j, j ′ ) ∈ {1, . . . , q} 4 . We now create a new instance J, that roughly consists in gluing together the instances I a i ,b j with 1 ≤ i, j ≤ q, for constructing an illegal instance. Let us consider q disjoint copies P 1 , . . . , P q (resp., Q 1 , . . . , Q q ) of a path P of length n A (resp., of a path Q of length n B ), such that, in P i (resp., Q i ), i = 1, . . . , q, the nodes are given the IDs in a i (resp., b i ) in increasing order. For every i, j ∈ {1, . . . , q}, the nodes a i [jd] and b i+j [jd], where by i + j is taken modulo q whenever greater than q, are connected by an edge. Figure 10 displays an example of the construction. Observe that, by construction, if each of the q paths P 1 , . . . , P q , and each of the q paths Q 1 , . . . , Q q is contracted into a single node, then the resulting graph is K q,q . In other words, the underlying network in J contains K q,q as a minor, and therefore also K p,q as a minor. It follows that the instance J is illegal.

a 1 [3] a 1 [6] a 1 [9] b 1 [3] b 1 [6] b 1 [9]
Let us consider the following certificate assignment c J to the nodes in instance J. For every i ∈ {1, . . . , q}, every node u of the path P i (resp., Q i ) is given the certificate that it would receive in I a i ,b i . It follows from this assignment that, for every node u whose ID is different from a i [jd] and b i [jd]), for all i, j ∈ {1, . . . , q}, then the closed neighborhood of u in J with certificate assignment c J is identical to the closed neighborhood of the same node u in I a i ,b i with certificates assignment c a i ,b i . It follows that such a node u accepts in J. Let u be a node of P i with ID a i [jd]) for some i, j ∈ {1, . . . , q}. The closed neighborhood of u in J with certificate assignment c J is identical to the view of the same node u in I a i ,b i+j with certificates assignment c a i ,b i+j . It follows that such a node u accepts in J as well. The case of a node of Q i with ID b i [jd]) for some i, j ∈ {1, . . . , q} is identical, i.e., such a node accepts in J too. Therefore, with certificate assignment c J , all nodes accept in J, and thus soundness is not satisfied. This contradicts the existence of a locally checkable proof for Forb({K p,q }) with o(log n) bits, and completes the proof of Lemma 6.

Again, the proof can be adapted to a larger verification radius t. The instances are formed by paths with identifiers only in a, or only in b, and edges having an endpoint in a, and an endpoint in b. We replace each edge of the former type (identifiers only in a, or only in b) by a path of length t. The same proof as for Lemma 6 applies after this change, in particular the legal instances are still outerplanar.

Proof of Theorem 2

Let F = {K k : k ≥ 3} ∪ {K p,q : p, q ≥ 2}, and H be a finite set of graphs in F. If H contains a unique graph in F, the fact that there are no locally checkable proofs for Forb(H) using certificates on o(log n) bits has been established in Lemma 5 and Lemma 6. We are left with the case of |H| ≥ 2.

Let us first make a few remarks about the family H. If H contains two cliques K k and K k ′ with k ′ > k, then we can remove K k ′ , because K k -minor-freeness implies K k ′ -minor-freeness. Thus H contains at most one clique. Similarly, if H contains two complete bipartite graphs K p,q and K p ′ ,q ′ , with p ′ ≥ p and q ′ ≥ q, then we can safely remove K p ′ ,q ′ from the family. Also, if H contains K 3 , then, Forb(H) is the class of trees, for which it is known that o(log n) bits are not sufficient for certification. Similarly, if H contains K 2,2 (and no K 3 ) then Forb(H) is the class of the graphs that do not contain cycles larger than 4, and, as noted in the proof of Lemma 6, this is also a case where o(log n) is not enough.

We are then left with the case of a family H included in {K k : k ≥ 4} ∪ {K p,q : p ≥ 2, q ≥ 3}, containing exactly one clique K k , k ≥ 4, and one or many complete bipartite graphs K p,q , p ≥ 2, q ≥ 3. Consequently, the class of graphs Forb(H) contains the class Forb({K 4 , K 2,3 }). The latter is precisely the class of outerplanar graphs. Recall that in the construction of proof of Lemma 6 the legal instances are outerplanar, therefore these instances must be in Forb(H). The construction of the proof of Lemma 6 shows that if a scheme with o(log n) bits accepts all these instances, it also accepts an instance with K p,q as a minor, which is a contradiction. The result follows.

Conclusion and further work

This paper provides a proof-labeling scheme for planarity, using certificates of optimal size Θ(log n) bits, hence improving the previously known dMAM interactive protocol [START_REF] Naor | The power of distributed verifiers in interactive proofs[END_REF], by decreasing the number of interactions between the prover and the verifier, and avoiding the use of randomization. This work could find extensions in many directions, fitting with the aforementioned interest of the distributed computing community for classes of sparse graphs beyond planar graphs (see [START_REF] Feuilloley | Bibliography of distributed approximation beyonf bounded degree[END_REF]). For instance, the approach in this paper appears to be generalizable to the design of a proof-labeling scheme for the class of graphs with bounded genus g > 1, still using certificates on O(log n) bits, by cutting along so-called nooses until the resulting surface is planar. Certifying the correctness of such cuts, and the consistency of the embedding after these cuts requires to fix many technical details, but appear doable with certificates on O(log n) bits.

Perhaps more interesting is to extend our result to the certification of graph classes defined by a finite set of forbidden minors. The technique in this paper also enables to certify the class of outerplanar graphs with certificates on O(log n) bits, but the general case of classes defined by forbidden minors is open. A standard tool to consider in general for graphs excluding a fixed minor, that is, to certify G ∈ Forb(H) for a fixed graph H, is the characterization of the topological embeddings for these graphs provided by Robertson and Seymour's Theorem. However, certifying the correctness of such embeddings seems challenging using certificates of small size. In fact, the minor-excluding graphs have a linear number of edges, and therefore they admit proof-labeling schemes using certificates on O(n log n) bits [START_REF] Göös | Locally checkable proofs in distributed computing[END_REF][START_REF] Korman | Proof labeling schemes[END_REF]. Even the design of proof-labeling schemes for these graph classes with certificates on O(n ǫ ) bits, ǫ < 1, appears challenging.

  13 check that I(x - ℓ ) = [a, b]; 14 for every neighbor y of x do 15 if one of the endpoints of I(y) is x then 16 check that the other endpoint of I(y) is adjacent to x; 17 check that I(y) I(x);

Figure 2 :

 2 Figure 2: The crossings involving edges depicted by dotted lines cannot exist.

Figure 3 :

 3 Figure 3: A maximal edge {u, v}.

Figure 4 :

 4 Figure 4: The path Q of maximal edges between y and z.

1 .

 1 for an illustration of the arguments developed in the proof. Let I(u) = [a, b] and I(v) = [c, d]. Let us assume, w.l.o.g., that u < v. Since {u, v} is maximal, v = u + k where u + k is the largest neighbor of u. Since Algorithm 1 accepts at all nodes, all tests performed by the algorithm at all nodes have positive outcome. Therefore, by the test of Line 5 applied to x = u, we derive that u + k ≤ b, and thus v ≤ b. Now let us consider three cases separately. If v < b, then the test of Line 11 applied to u guarantees that I(u + k ) = I(u), and the claim follows.

3 .

 3 If v = b and u = c, then the test of Line 17 applied at x = u, and at x ′ = b = v implies that I(v) I(u). Symmetrically, by the same test at x = v and x ′ = u = c, we also get that I(u) I(v). This is a contradiction, and thus this case cannot appear.

Figure 5 :

 5 Figure 5: Transformation of a planar graph to a path planar graphs.

Figure 7 :

 7 Figure 7: Block connexion for k = 4, from a block B i to a block B j .

Figure 8 :

 8 Figure 8: The graph G that extends the path of blocks with three blocks, for k = 4. The edges of the original path of blocks are plain edges and the new edges are dotted edges.

Figure 9 :

 9 Figure 9: An instance I a,b for n = 22, p = q = 3, and d = 3.

a 2 [ 3 ] a 2 [ 6 ] a 2 [ 9 ]

 3269

Figure 10 :

 10 Figure 10: Example of the instance J for p = q = 3, and d = 3.

* Additional support from MIPP and José Correa's Amazon Research Award † Additional support from ANR project DESCARTES, and from INRIA project GANG ‡ Additional support from CONICYT via PIA/Apoyo a Centros Científicos y Tecnológicos de Excelencia AFB 170001 and Fondecyt 1170021 § Additional support from IDEXLYON (project INDEPTH) within the Programme Investissements d'Avenir (ANR-16-IDEX-0005) and "Mathématiques de la Décision pour l'Ingénierie Physique et Sociale" (MODMAD) ¶ Additional support from CONICYT via PAI + Convocatoria Nacional Subvención a la Incorporación en la Academia Año 2017 + PAI77170068 and FONDECYT 11190482