Dynamic Planar Embeddings of Dynamic Graphs

TL;DR

This paper introduces a simplified, efficient algorithm for maintaining and updating planar embeddings of dynamic graphs, supporting edge insertions, deletions, and local modifications with logarithmic time complexity.

Contribution

It presents a new, simpler algorithm leveraging primal-dual tree interactions and Euler tours to support dynamic planar embeddings efficiently.

Findings

Supports all updates and queries in O(log^2 n) time

Matches the best known static embedding bounds

Simplifies previous algorithms using primal-dual tree interactions

Abstract

We present an algorithm to support the dynamic embedding in the plane of a dynamic graph. An edge can be inserted across a face between two vertices on the face boundary (we call such a vertex pair linkable), and edges can be deleted. The planar embedding can also be changed locally by flipping components that are connected to the rest of the graph by at most two vertices. Given vertices $u,v$, linkable$(u,v)$ decides whether $u$ and $v$ are linkable in the current embedding, and if so, returns a list of suggestions for the placement of $(u,v)$ in the embedding. For non-linkable vertices $u,v$, we define a new query, one-flip-linkable$(u,v)$ providing a suggestion for a flip that will make them linkable if one exists. We support all updates and queries in O(log$^2 n$) time. Our time bounds match those of Italiano et al. for a static (flipless) embedding of a dynamic graph. Our new algorithm is simpler, exploiting that the complement of a spanning tree of a connected plane graph is a spanning tree of the dual graph. The primal and dual trees are interpreted as having the same Euler tour, and a main idea of the new algorithm is an elegant interaction between top trees over the two trees via their common Euler tour.

Equations

$$\text{deactivation count}(c)=\sum _{\begin{array}{c}\text{cluster }C\in \text{root path}(c),\\ \text{segment }S\in C\mid c\in S\end{array}}\Delta (S)$$

Full text

1 Introduction

We present a data structure for supporting and maintaining a dynamic planar embedding of a dynamic graph. In this article, a dynamic graph is a graph where edges can be removed or inserted, and vertices can be cut or joined, but where an edge $(u,v)$ can only be added if it does not violate planarity. More precisely, the edges around each vertex are ordered cyclically by the embedding, similar to the edge-list representation of the graph. A corner (of a face) is the gap between consecutive edges incident to some vertex. Given two corners $c_{u}$ and $c_{v}$ of the same face $f$, incident to the vertices $u$ and $v$ respectively, the operation $\operatorname{insert}(c_{u},c_{v})$ inserts an edge between $u$ and $v$ in the dynamic graph, and embeds it across $f$ via the specified corners. We provide an operation $\operatorname{linkable}(u,v)$ that returns such a pair of corners $c_{u}$ and $c_{v}$ if they exist. If there are more options, we can list them in constant time per option after the first. A vertex may be cut through two corners, and linkable vertices may be joined by corners incident to the same face, if they are connected, or incident to any face otherwise. That is, joining vertices corresponds to linking them across a face with some edge $e$, and then contracting $e$.

It may often be relevant to change the embedding, e.g. in order to be able to insert an edge. In a dynamic embedding, the user is allowed to change the embedding by what we call flips, that is, to turn part of the graph upside down in the embedding. Of course, the relevance of this depends on what we want to describe with a dynamic plane graph. If the application is to describe roads on the ground, flipping orientation would not make much sense. But if we have the application of graph drawing or chip design in mind, flips are indeed relevant. In the case of chip design, a layer of a chip is a planar embedded circuit, which can be thought of as a planar embedded graph. An operation similar to flip is also supported by most drawing software.

Given two vertices $u,v$, we may ask whether they can be linked after modifying the embedding with only one flip. We introduce a new operation, the $\operatorname{one-flip-linkable}(u,v)$ query, which answers that question, and returns the vertices and corners describing the flip if it exists.

Our data structure is an extension to a well-known duality-based dynamic representation of a planar embedded graph known as a tree/cotree decomposition [4]. We maintain top trees [1] both for the primal and dual spanning trees. We use the fact that they share a common (extended) Euler tour - in a new way - to coordinate the updates and enable queries that either tree could not answer by itself. All updates and queries in the combined structure are supported in time $\mathcal{O}(\log^{2}n)$, plus, in case of $\operatorname{linkable}(u,v)$, the length of the returned list.

1.1 Dynamic Decision Support Systems

An interesting and related problem is that of dynamic planarity testing of graphs. That is, we have a planar graph, we insert some edge, and ask if the graph is still planar, that is, if there exist an embedding of it in the plane?

The problem of dynamic planarity testing appears technically harder than our problem, and in its basic form it is only relevant when the user is completely indifferent to the actual embedding of the graph. What we provide here falls more in the category of a decision support system for the common situation where the desired solution is not completely captured by the simple mathematical objective, in this case planarity. We are supporting the user in finding a good embedding, e.g., informing the user what the options are for inserting an edge (the $\operatorname{linkable}$ query), but leaving the actual choice to the user. We also support the user in changing their mind about the embedding, e.g. by flipping components, so as to make edge insertions possible. Using the $\operatorname{one-flip-linkable}$ query we can even suggest a flip that would make a desired edge insertion possible if one exists.

1.2 Previous work

Dynamic graphs have been studied for several decades. Usually, a fully dynamic graph is a graph that may be updated by the deletion or insertion of an edge, while decremental or incremental refer to graphs where edges may only be deleted or inserted, respectively. A dynamic graph can also be one where vertices may be deleted along with all their incident edges, or some combination of edge- and vertex updates [15].

Hopcroft and Tarjan [9] were the first to solve planarity testing of static graphs in linear time. Incremental planarity testing was solved by La Poutré [13], who improved on work by Di Battista, Tamassia, and Westbrook [2, 3, 19], to obtain a total running time of $\mathcal{O}(\alpha(q,n))$ where $q$ is the number of operations, and where $\alpha$ is the inverse-Ackermann function. Galil, Italiano, and Sarnak [8] made a data structure for fully dynamic planarity testing with $\mathcal{O}(n^{\left.2\middle/3\right.})$ worst case time per update, which was improved to $\mathcal{O}(n^{\left.1\middle/2\right.})$ by Eppstein et al. [5]. For maintaining embeddings of planar graphs, Italiano, La Poutré, and Rauch [10] present a data structure for maintaining a planar embedding of a dynamic graph, with time $\mathcal{O}(\log^{2}n)$ for update and for linkable-query, where insert only works when compatible with the embedding. The dynamic tree/cotree decomposition was first introduced by Eppstein et al. [6] who used it to maintain the Minimum Spanning Tree (MST) of a planar embedded dynamic graph subject to a sequence of change-weight$(e,\Delta x)$ operations in $\mathcal{O}(\log n)$ time per update. Eppstein [4] presents a data structure for maintaining the MST of a dynamic graph, which handles updates in $\mathcal{O}(\log n)$ time if the graph remains plane. More precisely the user specifies a combinatorial embedding in terms of a cyclic ordering of the edges around each vertex. Planarity of the user specified embedding is checked using Euler’s formula. Like our algorithm, Eppstein’s supports flips. The fundamental difference is that Eppstein does not offer any support for keeping the embedding planar, e.g., to answer $\operatorname{linkable}(u,v)$, the user would in principle have to try all $n^{2}$ possible corner pairs $c_{u}$ and $c_{v}$ incident to $u$ and $v$, and ask if $\operatorname{insert}(c_{u},c_{v})$ violates planarity.

As far as we know, the $\operatorname{one-flip-linkable}$ query has not been studied before. Technically it is the most challenging operation supported in this paper.

The highest lower bound for the problem of planarity testing is Pǎtraşcu’s $\Omega(\log n)$ lower bound for fully dynamic planarity testing [14]. From the reduction it is clear that this lower bound holds as well for maintaining an embedding of a planar graph as we do in this article.

1.3 Results

We present a data structure for maintaining an embedding of a planar graph under the following updates:

delete($e$)

Deletes the specified edge, $e$.

insert($c_{u}$,$c_{v}$)

Inserts an edge through the specified corners, if compatible with the current embedding.

linkable($u$,$v$)

Returns a data structure representing the (possibly empty) list of faces that $u$ and $v$ have in common, and for each common face, $f$, the (nonempty) lists of corners incident to $u$ and $v$, respectively, on $f$.

articulation-flip($c_{1}$,$c_{2}$,$c_{3}$)

If the corners $c_{1},c_{2},c_{3}$ are all incident to the same vertex, and $c_{1},c_{2}$ are incident to the same face, this update flips the subgraph between $c_{1}$ and $c_{2}$ to the space indicated by $c_{3}$.

separation-flip($c_{1}$, $c_{2}$, $c_{3}$, $c_{4}$)

If the corners $c_{1},c_{2}$ are incident to the vertex $v$, and $c_{3},c_{4}$ are incident to the vertex $u$, and $c_{2},c_{3}$ are incident to the face $f$, and $c_{1},c_{4}$ are incident to the face $g$. Flips the subgraph delimited by these corners, or, equivalently, by $u,g,v,f$.

one-flip-linkable($u$,$v$)

Returns a suggestion for an articulation-flip or separation-flip making $u$ and $v$ linkable, if they are not already.

1.4 Paper outline.

In Section 2, we give first a short introduction to the data structures needed in our implementation, then we describe the implementations of the functions linkable (Section 2.3), insert and delete (Section 2.4), and articulation-flip and separation-flip (Section 2.5). Finally, Section 3 is dedicated to our implementation of $\operatorname{one-flip-linkable}$.

2 Maintaining a dynamic embedding

In this section we present a data structure to maintain a dynamic embedding of a planar graph. In the following, unless otherwise stated, we will assume $G=(V,E)$ is a planar graph with a given combinatorial embedding and that ${G}^{*}=(F,{E}^{*})$ is its dual.

Our primary goal is to be able to answer $\operatorname{linkable}(u,v)$, where $u$ and $v$ are vertices: Determine if an edge between $u$ and $v$ can be added to $G$ without violating planarity and without changing the embedding. If it can be inserted, return the list of pairs of corners (see Definition 1 below). Each corner-pair, ($c_{u}$, $c_{v}$), describes a unique place where such an edge may be inserted. If no such pair exists, return the empty list.

The data structure must allow efficient updates such as $\operatorname{insert}$, $\operatorname{remove}$, $\operatorname{cut}$, $\operatorname{join}$, and $\operatorname{flip}$. We defer the exact definitions of these operations to Section 2.4.

As in most other dynamic graph algorithms we will be using a spanning tree as the main data structure, and note:

Observation 1**.**

[Tutte [18, p. 289]] If $E_{T}\subseteq{}E$ induces a spanning tree $T$ in $G$, then ${(E\setminus{}E_{T})}^{*}$ induces a spanning tree ${\overline{T}}^{*}$ in ${G}^{*}$ called the co-tree of $T$.

Lemma 1**.**

If $u$ and $v$ are vertices, $T$ is a spanning tree, and $e$ is any edge on the $T$-path between $u$ and $v$, then any face containing both $u$ and $v$ lies on the fundamental cycle in $G^{\ast}$ induced by ${e}^{*}$ in the co-tree ${\overline{T}}^{*}$.

Proof.

The fundamental cycle $C(e)$ induces a cut of the graph which separates $u$ and $v$.

Let $f$ be a face which is incident to both $u$ and $v$. Then there will be two paths between $u$ and $v$ on the face $f$, choose one of them, $p$. Since $C(e)$ induces a cut of the graph which separates $u$ and $v$, some edge $e_{C}\in p$ must belong to the cut. But then, $f$ is a dual endpoint of $e_{C}^{\ast}$, and thus, $f$ belongs to $C(e)$. ∎∎

Thus, the main idea is to search a path in the co-tree. This is complicated by the fact (see Figure 1) that the set of faces that are adjacent to $u$ and/or to $v$ need not be contiguous in ${\overline{T}}^{*}$, so it is possible for the cycle to change arbitrarily between faces that are adjacent to any combination of neither, one, or both of $u$, $v$.

Our linkable query will consist of two phases. A marking phase, in which we “activate” (mark) all corners incident to each of the two vertices we want to link (see Section 2.2), and a searching phase, in which we search for faces incident to “active” (marked) corners at both vertices (see Section 2.3). But first, we define corners.

2.1 Corners and the extended Euler tour

The concept of a corner in an embedded graph turns out to be very important for our data structure. Intuitively it is simply a place in the edge list of a vertex where you might insert a new edge, but as we shall see it has many other uses.

Definition 1**.**

If $G$ is a non-trivial connected, combinatorially embedded graph, a corner in $G$ is a $4$-tuple $(f,v,e_{1},e_{2})$ where $f$ is a face, $v$ is a vertex, and $e_{1}$, $e_{2}$ are edges (not necessarily distinct) that are consecutive in the edge lists of both $v$ and $f$.

If $G=(\{v\},\emptyset)$ and $G^{\ast}=(\{f\},\emptyset)$, there is only one corner, namely the tuple $(f,v,\mathbf{nil},\mathbf{nil})$.

Note that faces and vertices appear symmetrically in the definition. Thus, there is a one-to-one correspondence between the corners of $G$ and the corners of ${G}^{*}$. This is important because it lets us work with corners in $G$ and ${G}^{*}$ interchangeably. Another symmetric structure is the Extended Euler Tour (defined in Definition 2 below). Recall that an Euler Tour of a tree is constructed by doubling all edges and finding an Eulerian Circuit of the resulting multigraph. This is extended in the following the following way:

Definition 2**.**

Given a spanning tree $T$ of a plane graph $G$, an oriented Euler tour is one where consecutive tree edges in the tour are consecutive in the ordering around their shared vertex.

Given the oriented Euler tour of the spanning tree $T$ of a non-trivial connected graph $G$, we may define the extended Euler tour $\operatorname{EET}(T)$ by expanding between each consecutive pair of edges ($e_{-},e_{+}$) with the list of corners and non-tree edges that come between $e_{-}$ and $e_{+}$ in the orientation around their shared vertex. If $G$ is a single-vertex graph, its extended Euler tour consist solely of the unique corner of $G$.

Thus, $\operatorname{EET}(T)$ is a cyclic arrangement that contains each edge in $G$ exactly twice and each corner in $G$ exactly once (see Figure 3). Even more interesting is:

Lemma 2**.**

Given a spanning tree $T$ of $G$ with extended Euler tour $\operatorname{EET}(T)$, the corresponding tour $\operatorname{EET}({\overline{T}}^{*})$ in ${G}^{*}$ defines exactly the opposite cyclical arrangement of the corresponding edges and corners in ${G}^{*}$.

In order to prove the lemma, we use the following definition of an Euler cut:

Definition 3**.**

Given any closed simple curve $C$ on the sphere $S^{2}$, then $S^{2}\setminus C$ has two components, $A$ and $B$, each homeomorphic to the plane111Jordan curve Theorem.. Given an edge $e$ of the embedded connected graph $G$ with dual graph $G^{\ast}$, and a closed simple curve $C$, we say that $C$ intersects $e$ if $C$ intersects either $e$ of $G$, or $e^{\ast}$ of $G^{\ast}$. Given a tree/cotree decomposition for $G$, we call $C$ an Euler cut if the tree is entirely contained in $A$ and the cotree is entirely contained in $B$, and the curve only intersects each edge, $e$ or $e^{\ast}$, twice.

Proof of Lemma 2.

Given any Euler cut $C$, note that the edges visited along the Euler tour of $G$ come in exactly the same order as they are intersected by $C$, if we choose the same ordering of the plane (clockwise or counter-clockwise). The placement of the corners is uniquely defined by the ordering of the edges.

Such an Euler cut always exists, because both tree and cotree are connected, and because they share no common point. One can construct it by contracting one of the two trees to a point, and then considering an $\varepsilon$-circle $B_{\varepsilon}$ around that point, where $\varepsilon$ is small enough such that there is a minimal number of edge-intersections with that circle. The pre-image of $B_{\varepsilon}$ under the contraction will be an Euler cut. (See Figure 2.)

Now, the Euler tour of $G$ is uniquely given by $C$. But we also know that $G$ is the dual of $G^{\ast}$, so $C$ is also an Euler cut for $G^{\ast}$, and thus, the Euler tour of $G^{\ast}$ is uniquely given by $C$.

Lastly, notice that in order for $C$ to determine the same ordering of the edges, we need to orient the two components oppositely, that is, one clockwise and one counter-clockwise. ∎∎

Thus, segments of the extended Euler tour translate directly between $T$ and ${\overline{T}}^{*}$. By segment, we mean any contiguous sub-list of the cycle.

The high level algorithm for $\operatorname{linkable}(u,v)$, that is, to find a face in the embedding incident to both $u$ and $v$, (to be explained in detail later,) is now to build a structure consisting of an arbitrary spanning tree $T$ and its co-tree ${\overline{T}}^{*}$ such that we can

Find an edge $e$ on the $T$-path between $u$ and $v$. This is easy. 2. 2.

Mark all corners incident to $u$ and $v$ in $T$. This is complicated by the existence of vertices of high degree, so a lazy marking scheme is needed. However, it is easier than marking them in ${\overline{T}}^{*}$ directly, since each vertex has a unique place in $T$ and no place in ${\overline{T}}^{*}$. 3. 3.

Transfer those marks from $T$ to ${\overline{T}}^{*}$ using Lemma 2. We can do this as long as the lazy marking scheme works in terms of segments of the extended Euler tour. 4. 4.

Search the fundamental cycle induced by ${e}^{*}$ in ${\overline{T}}^{*}$ for faces that are incident to a marked corner on both sides of the path.

2.2 Marking scheme

We need to be able to mark all corners incident to the two query vertices $u$ and $v$, and we need to do it in a way that operates on segments of the extended Euler tour. To this end we will maintain a modified version of a top tree over $T$ (see Alstrup et al. [1] for an introduction to top trees), called the extended embedded top tree.

2.2.1 Embedded top trees.

Given a tree $T$, a top tree for $T$ is a binary tree. At the lowest level, its leaves are the edges of $T$. Its internal nodes, called clusters, are sub-trees of $T$ with at most two boundary vertices. The set of boundary vertices of a cluster $C$ is denoted $\partial C$. At the highest level its root is a single cluster containing all of $T$. A non-boundary vertex of the subset $S\subset V$ may not be adjacent to a vertex of $V\setminus S$. A cluster with two boundary vertices is called a path cluster, and other clusters are called leaf clusters. Any internal node is formed by the merged union of its (at most two) children. All operations on the top tree are implemented by first breaking down part of the old tree from the top with $\mathcal{O}(\log n)$ calls to a split operation, end then building the new tree with $\mathcal{O}(\log n)$ calls to a merge operation. (This was proven by Alstrup et al. in [1].)

The operation expose on the top tree takes one or two vertices and makes them boundary of the root cluster. We may even expose any constant number of vertices, and then, instead of having one top tree with the cluster containing all of $T$ in the root, we obtain a constant number of top trees with those vertices exposed.

Definition 4**.**

An embedded top tree is a top tree over an embedded tree $T$ with the additional property that whenever it is merging $\{C_{i}\}$ to form $C$, for each pair $C_{i},C_{i+1}$ there exist edges $e_{i}\in C_{i}$ and $e_{i+1}\in C_{i+1}$ that are adjacent in the cyclic order around the common boundary vertex.

Definition 5**.**

Given an embedded graph $G$ and a spanning tree $T$ of $G$, an extended embedded top tree of $T$ is an embedded top tree over the embedded tree $T^{\prime}$ defined as follows:

• •

The vertices of $T^{\prime}$ are the vertices of $G$, plus one extra vertex for each corner of $G$ and two extra vertices for each non-tree edge (one for each end vertex of the edge).

• •

The edges of $T^{\prime}$ are the edges of $T$, together with edges connecting each vertex $v$ of $G$ with the vertices representing the corners and non-tree edges incident to $v$.

• •

The cyclic order around each vertex is the order inherited from the embedding of $G$.

Observation 2**.**

In any extended embedded top tree over a tree $T$, path clusters consist of the edges and corners from two segments of $\operatorname{EET}(T)$, and leaf clusters consist of the edges and corners from one segment of $\operatorname{EET}(T)$.

Lemma 3**.**

We can maintain an extended embedded top tree over $T$ using $\mathcal{O}(\log n)$ calls to merge and split per update.

Proof.

First note that we can easily maintain $T^{\prime}$. Now construct the ternary tree $\widehat{T^{\prime}}$ by substituting each vertex by its chain (see Italiano et al. [10]). Consider the top tree for $T^{\prime}$ made via reduction to the topology tree for $\widehat{T^{\prime}}$ (see Alstrup et al. [1]). Since the chain is defined to have the vertices in the same order as the embedding, this top tree is naturally an embedded top tree. ∎∎

For the rest of this paper, we will assume all top trees are extended embedded top trees, without any further mention.

Observation 3**.**

Since corners in $T$ are represented by vertices in $T^{\prime}$, we automatically get the ability to expose corners, giving complete control over which $\operatorname{EET}(T)$ segment is available for information or modification.

2.2.2 Slim-path top trees and four-way merges.

We can tweak the top tree further such that the following property, called the slim path invariant, is maintained:

• •

for any path-cluster, all edges in the cluster that are incident to a boundary vertex belong to the cluster path. In other words, for each boundary vertex $b$, there is at most one edge in the cluster that is incident to $b$.

This can be done by allowing the following merge: Given path-clusters $C,C^{\prime}$ with boundary vertices $\partial C=\{u,v\}$ and $\partial C^{\prime}=\{v,w\}$, and given two leaf-clusters with boundary vertex $v$, allow the merge of those four, to obtain one path cluster with boundary vertices $\{u,w\}$. For lack of a better word, we call this a four-way merge.

We allow the following merges:

• •

Two leaves merge to one,

• •

A path cluster with boundary vertices $u,v$, and a leaf cluster with boundary vertex $v$, merge to form a leaf with boundary vertex $u$,

• •

Two path clusters with boundary vertices $u,v$, and $v,w$, respectively, and up to two leaves with boundary vertex $v$ make a four-way merge to form a path cluster with boundary vertices $u,v$ (see Figure 4).

Since the slim-path invariant has no restriction on leaves, clearly the first two do not break the invariant. The four-way merge does not break the invariant: If, before the merge, there was only one edge incident to $u$ and only one incident to $w$, this is still maintained after the merge.

Definition 6**.**

A slim-path top tree is a top tree which maintains the slim-path invariant by allowing four-way merges.

Lemma 4**.**

We can maintain a slim-path top tree over a dynamic tree with height $\mathcal{O}(\log n)$, using $\mathcal{O}(\log n)$ calls to $\operatorname{merge}$ and $\operatorname{split}$ per update.

Proof.

Proof by reduction to top trees (see figure 5). For each path cluster in the ordinary top tree, keep track of a slim path cluster, and up to four internal leaves; two for each boundary vertex, one to each side of the cluster path. In the slim-path top tree, this would correspond to four different clusters, but this doesn’t harm the asymptotic height of the tree. When merging two path clusters in the ordinary top tree, with paths $u\cdots v$ and $v\cdots w$, this simply correspond to two levels of merges in the slim-path top tree: First, the incident leaf clusters are merged, pairwise, and then, we perform a four-way merge. Other merges in the ordinary top tree correspond exactly to merges in the slim-path top tree. Thus, each merge in the ordinary top tree corresponds to at most $2$ levels of merges in the slim-path top tree, and the maintained height is $\mathcal{O}(\log n)$. ∎∎

Note that four-way merges and the slim-path invariant are not necessary. One could simply maintain, within each path cluster, information about the internal leaf clusters incident to each boundary vertex; one to each side of the cluster path. We present four-way merges because they provide some intuition about this particular form of usage of top trees.

We also note that the expose($u,v$)-operation is different in a slim-path top tree, whenever $u$ or $v$ is not a leaf in the tree (see Figure 6.) Instead of returning a top tree which has at its top a path cluster with path $u\cdots v$, the operation returns up to three top trees: one with at its root a path cluster with path $u\cdots u$, and, up to two top trees with leaf clusters at their roots, one for each exposed non-leaf vertex.

Lemma 5**.**

Whenever a merge of two clusters in the slim-path top tree causes a vertex $w$ to stop being a boundary vertex (see Figure 7), all corners incident to $w$ are contained in one or two $\operatorname{EET}(T)$ segments. These segments will be sub-segments of the (one or two) segments corresponding to the parent cluster $C$ (blue in Figure 7), and will not contain any corners incident to the (one or two) boundary vertices of $C$.

Proof.

There are two statements to prove. Firstly, all corners incident to $w$ are contained in the one or two $\operatorname{EET}(T)$ segments described in Observation 2. Secondly, it follows from the slim-path invariant that the delimiting corners for any boundary vertex $v\in\partial C$ are exactly those incident to the unique tree-edge in $C$ incident to $v$. ∎∎

The following term is defined for both top trees and slim-path top trees and is very convenient:

Definition 7**.**

Given a vertex $v$, let $C_{v}$ denote the deepest cluster in the top tree where $v$ is not a boundary vertex. The root path of $v$ in the top tree is the path from $C_{v}$ to the root in the top tree. For a corner $c$ incident to a vertex $v$, the root path of $c$ is the root path of $v$.

2.2.3 Deactivation counts

Now suppose we associate a (lazy) deactivation count with each corner. The deactivation count is set to [math] before we start building the top tree. Define the $\operatorname{merge}$ operation on the top tree such that whenever a merge discards a boundary vertex we deactivate all corners on the at most two segments of $\operatorname{EET}(T)$ mentioned in Lemma 5 by increasing that count (and define the $\operatorname{split}$ operation on the top tree to reactivate them as necessary). When the top tree is complete, the corners that are still active (have deactivation count [math]) are exactly those incident to the boundary vertices of the root of the top tree. These boundary vertices are controlled by the $\operatorname{expose}$ operation on the top tree and changing the boundary vertices require only $\mathcal{O}(\log n)$ merges and splits, so we have now argued the following:

Lemma 6**.**

We can mark/unmark all corners incident to vertices $u$ and $v$ by increasing and decreasing the deactivation counts on $\mathcal{O}(\log n)$ segments of the extended Euler tour.

What we really want, is to be able to search for the marked corners in ${\overline{T}}^{*}$, so instead of storing the counts (even lazily) in the top tree over $T$, we will store them in a top tree over ${\overline{T}}^{*}$. Again, each cluster in this top tree covers one or two segments of the extended Euler tour. For each segment $S$ we keep track of a number $\Delta(S)$ such that for every corner, $c$, the deactivation count for $c$ equals the sum of $\Delta(S)$ over all segments $S$ containing $c$ in the root path of $c$ .

[TABLE]

In addition, for each boundary vertex (face) $f\in\partial C$, we keep track the value $c_{\min}(C,f)$, defined as the minimum deactivation count over all corners in the cluster $C$ that are incident to $f$.

To update the deactivation counts of an arbitrary segment $S$, all we need to do is modify the $\mathcal{O}(\log n)$ clusters that are affected, which can be done in $\mathcal{O}(\log n)$ time, leading to

Lemma 7**.**

We can maintain a top tree over ${\overline{T}}^{*}$ that has $c_{\min}(C,f)$ for each boundary vertex $f\in\partial C$ where $C$ is a cluster in ${\overline{T}}^{*}$, in $\mathcal{O}(\log^{2}n)$ time per change in the set of (at most two) marked vertices.

Proof.

To mark a given set of vertices, expose them in the top tree for $T$. For each merge of clusters $\{C_{i}\}$ into a new cluster $C$ in the top tree over $T$, where $\partial C\neq\bigcup\partial C_{i}$, consider the at most two segments of $\operatorname{EET}(T)$ associated with $C$. For each such segment, $S$, expose the delimiting corners of $S$ in the top tree over ${\overline{T}}^{*}$ (see Observation 3), and increase $\Delta(R)$ for the relevant segment $R$ of the root cluster (in the dual top tree).

For each merge in the dual top tree, where $\{C_{i}\}$ merge to form $C$, and for each boundary vertex $f\in\partial C$, set $c_{\min}(C,f)=\min\{c_{\min}(C_{i},f)\,\mid\,f\in\partial C_{i}\}$.

For each split of a cluster $C$ into clusters $\{C_{i}\}$, and each segment $S$ in $C$ corresponding to segments $\{S_{i}\}$ with $S_{i}$ in $C_{i}$, propagate $\Delta(S)$ down by setting $\Delta(S_{i})=\Delta(S_{i})+\Delta(S)$.

Since expose in the primal top tree can be implemented with $\mathcal{O}(\log n)$ calls to $\operatorname{merge}$ and $\operatorname{split}$, this will yield at most $\mathcal{O}(\log n)$ calls to expose in the dual top tree, and thus, in total, the time for marking a set of vertices is $\mathcal{O}(\log^{2}n)$. ∎∎

Observation 4**.**

This is enough for, given a face $f$ and a vertex $u$, checking whether $f$ is incident to $u$ in $\mathcal{O}(\log^{2}n)$ time.

Proof.

Expose $u$ in the primal top tree. This takes $\mathcal{O}(\log^{2}n)$ time. Expose $f$ in the dual top tree. This takes $\mathcal{O}(\log n)$ time. Then, for the root cluster $R$ which has boundary vertex $f$, $c_{\min}(R,f)=0$ if an only if $f$ and $u$ are incident. ∎∎

2.3 Linkable query

Unfortunately, the $c_{\min}$ and $\Delta$ values discussed in Section 2.2 are not quite enough to let us find the corners we are looking for. We can use them to ask what marked corners a given face is incident to, but we do not have enough to find pairs of marked corners on opposite sides of the same face on the co-tree path.

As noted in Lemma 1, for two given vertices $u$ and $v$, there exists a path in the dual tree containing all candidates for a common face. And this path is easily found! Since the dual of a primal tree edge induces a fundamental cycle that separates $u$ and $v$, we may use the path between the dual endpoints $f,g$ of any edge on the primal tree path between $u$ and $v$. Furthermore, once we expose $(f,g)$ in the dual tree, if $f\neq g$, the root will have two EET-segments: the minimum deactivation count of one EET-segment is [math] if and only if any non-endpoint faces are incident to $v$, the other is [math] if and only if any are incident to $u$. Checking the endpoint faces can be done (cf. Observation 4), but to find non-endpoint faces we need more structure.

To just output one common face, our solution is for each path cluster in the top tree over the co-tree to keep track of a single internal face $f_{\min}$ on the cluster path that is incident to minimally deactivated corners on either side of the cluster path if such a face exists. For that purpose, we define for any EET-segment $S$ the value $c_{\min}(S)$ to represent the minimal deactivation count of a corner in $S$.

Lemma 8**.**

We can maintain a top tree over ${\overline{T}}^{*}$ that has $c_{\min}$ and $\Delta$ values for each EET-segment in each cluster and $f_{\min}$ values for each path cluster in $\mathcal{O}(\log^{2}n)$ time per change to the set of (at most two) marked vertices.

Proof.

We maintain a slim-path top tree for the dual tree (see Lemma 4).

Merge and split of leaf-clusters are handled as in the proof of Lemma 7. When two leaf clusters $L,L^{\prime}$ with segments $S_{L},S_{L^{\prime}}$ merge, $c_{\min}$ for the resulting segment is set to be $\min\{c_{\min}(S_{L}),c_{\min}(S_{L^{\prime}})\}$.

For a $4$-way $\operatorname{merge}$ (see Figure 8) of two path clusters $P,P^{\prime}$ and two leaf clusters $L,L^{\prime}$ with common boundary vertex (face) $f$ into a cluster $C$, we need to calculate $c_{\min}(S_{C})$ and $c_{\min}(S^{\prime}_{C})$ for its two EET-segments, and the value of $f_{\min}(C)$. The EET-segment $S_{C}$ is the concatenation of three EET-segments, $S_{P}$ from $P$, $S_{p^{\prime}}$ from $P^{\prime}$, and $S_{L}$ from $L$. We may then set $c_{\min}(S_{C})=\min\{c_{\min}(S_{p}),c_{\min}(S_{p^{\prime}}),c_{\min}(S_{L})\}$.

Similarly, $c_{\min}(S^{\prime}_{C})=\min\{c_{\min}(S^{\prime}_{p}),c_{\min}(S^{\prime}_{p^{\prime}}),c_{\min}(S_{L^{\prime}})\}$.

We may now assume we have calculated the values $c_{\min}(S_{C})$ and $c_{\min}(S^{\prime}_{C})$. To determine $f_{\min}(C)$, one only has to check the three values: $f_{\min}(P),f_{\min}(P^{\prime})$, and $f$. If $c_{\min}(S_{C})=c_{\min}(S_{P})$, and $c_{\min}(S^{\prime}_{C})=c_{\min}(S^{\prime}_{P})$, then we may set $f_{\min}(C)=f_{\min}(P)$. Otherwise, if $c_{\min}(S_{C})=c_{\min}(S_{P^{\prime}})$, and $c_{\min}(S^{\prime}_{C})=c_{\min}(S^{\prime}_{P^{\prime}})$, then we may set $f_{\min}(C)=f_{\min}(P^{\prime})$. Otherwise, if $c_{\min}(S_{C})=c_{\min}(L)$ and $c_{\min}(S^{\prime}_{C})=c_{\min}(L^{\prime})$, we may set $f_{\min}(C)=f$. Otherwise, finally, we have to set $f_{\min}(C)=\mathbf{nil}$. ∎∎

Lemma 9**.**

We can support each $\operatorname{linkable}(u,v)$ in $\mathcal{O}(\log^{2}n)$ time per operation.

Proof.

If $u$ and $v$ are not in the same connected component we pick any corners $c_{u}$ and $c_{v}$ adjacent to $u$ and $v$ and return them. Otherwise, we use $\operatorname{expose}(u,v)$ on the top tree over $T$ to activate all corners adjacent to $u$ and $v$ and to find an edge $e$ on the $T$-path from $u$ to $v$ (e.g. the first edge on the path). Let $g,h$ be the endpoints of ${e}^{*}$, and call $\operatorname{expose}(g,h)$ on the top tree over ${\overline{T}}^{*}$. By Lemma 1, a common face lies on the cotree path from $g$ to $h$. Let $f$ be the $f_{\min}$ value of the resulting root. We can now test each of $f,g,h$ using the $c_{\min}$ values to find the desired corners if they exist. ∎∎

Lemma 10**.**

If there are more valid answers to $\operatorname{linkable}(u,v)$ we can find $k$ of them in $\mathcal{O}(\log^{2}n+k)$ time.

Proof.

For each leaf cluster and for each side of each path cluster we can maintain the list of minimally deactivated corners adjacent to each boundary vertex. Then, instead of maintaining a single face $f_{\min}$ for each path cluster, we can maintain a linked list of all relevant faces in the same time. And for each side of each face in the list we can point to a list of minimally deactivated corners that are adjacent to that side. For leaf-clusters, we point to a linked list of minimally deactivated corners incident to the boundary vertex. Upon the merge of clusters, face-lists and corner-lists may be linked together, and the point of concatenation is stored in the resulting merged cluster in case of a future split. Note that each face occurs in exactly one face-list.

As before, to perform $\operatorname{linkable}(u,v)$, expose $u,v$ in the primal tree. Let $e_{0}$ be an edge on the tree-path between $u$ and $v$, and expose the endpoints of $e_{0}^{\ast}$ in the dual top tree. Now, the maintained face-list in the root of the dual top tree contains all faces incident to $u,v$, except maybe the endpoints of $e_{0}^{\ast}$, which can be handled separately, as before. The total time is therefore $\mathcal{O}(\log^{2}n)$ for the necessary expose operations, and then $\mathcal{O}(1)$ for each reply. ∎∎

Observation 5**.**

If we separately maintain a version of this data structure for the dual graph, then for faces $f,g$, $\operatorname{linkable}(f,g)$ in that structure lets us find vertices that are incident to both $f$ and $g$.

2.4 Updates

In addition to the query, our data structure supports the following set of update operations:

• •

$\operatorname{insert}(c_{u},c_{v})$ where $c_{u}$ and $c_{v}$ are corners that are either in different connected components, or incident to the same face. Adds a new edge to the graph, inserting it between the edges of $c_{u}$ at one end and between the edges of $c_{v}$ at the other. Returns the new edge.

• •

$\operatorname{remove}(e)$. Removes the edge $e$ from the graph. Returns the two corners that could be used to insert the edge again.

• •

$\operatorname{join}(c_{u},c_{v})$ where $c_{u}$ and $c_{v}$ are corners that are either in separate components of the graph or in the same face. Combines the vertices $u$ and $v$ into a single new vertex $w$ and returns the two new corners $c_{w}$ and $c_{w}^{\prime}$ that may be used to split it again using $\operatorname{cut}(c_{w},c_{w}^{\prime})$.

• •

$\operatorname{cut}(c_{w},c_{w}^{\prime})$ where $c_{w}$ and $c_{w}^{\prime}$ are corners sharing a vertex $w$. Splits the vertex into two new vertices $u$ and $v$ and returns corners $c_{u}$ and $c_{w}$ that might be used to join them again using $\operatorname{join}(c_{u},c_{v})$.

When calling $\operatorname{remove}(e)$ on a non-bridge tree-edge $e$, we need to search for a replacement edge. Luckily, $e^{\ast}$ induces a cycle in the dual tree, and any other edge on that cycle is a candidate for a replacement edge. If we like, we can augment the dual top tree so we can find the minimal-weight replacement edge, simply let each path cluster remember the cheapest edge on the tree-path, and expose the endpoints of $e^{\ast}$. If we want to keep $T$ as a minimum spanning tree, we also need to check at each $\operatorname{insert}$ and $\operatorname{join}$ that we remove the maximum-weight edge on the induced cycle from the spanning tree.

In general, when we need to update both the top trees over $T$ and ${\overline{T}}^{*}$ we must be careful that we first do the $\operatorname{split}$s needed in the top tree over $T$ to make each unchanged sub-tree a (partial) top tree by itself, then update the top tree over ${\overline{T}}^{*}$ and finally do the remaining $\operatorname{split}$s and $\operatorname{merge}$s to rebuild the top tree over $T$. This is necessary because the $\operatorname{merge}$ and $\operatorname{split}$ we use for $T$ depend on $T$ and ${\overline{T}}^{*}$ having related extended Euler tours.

Any change to the graph, especially to the spanning tree, implies a change to the extended Euler tour. Furthermore, any deletion or insertion of an edge implies a merge or split in the dual tree. E.g. if an edge is inserted across a face, that face is split in two. As a more complex example, if the non-bridge tree-edge $e=(u,v)$ is deleted, the replacement edge is removed from the dual tree, and the endpoints of $e^{\ast}$ are merged.

2.4.1 Cut and join of faces.

Given a face $f$ and two corners incident to the face, say, $c_{1}$ and $c_{2}$, we may cut the face in those corners, producing new faces $f$ and $f^{\prime}$. We go about this by exposing $c_{1},c_{2}$ in the dual top tree. We then have two chains for $f$, which we rename as $f$ and $f^{\prime}$.

Similarly, faces may be joined. Given a face $f$ and a face $g$, a corner $c_{f}$ incident to $f$ and a corner $c_{g}$ incident to $g$, we may join the two faces to a new face $h$, with two new corners $c_{1}$ and $c_{2}$, such that all edges incident to $h$ between $c_{1}$ and $c_{2}$ are exactly those from $f$, in the same order, and those between $c_{2}$ and $c_{1}$ are those from $g$. We do this by exposing $f$ and $c_{f}$ in one top tree, and $g$ and $c_{g}$ in the other top tree, and then by the link and join operation.

2.4.2 Inserting an edge

We now show how to perform $\operatorname{insert}(c_{u},c_{v})$, when compatible with the embedding.

To insert an edge between two components, we must add it to the primal tree. Given a vertex $v$ with an incident corner $c_{v}$ to the face $g$, and a vertex $u$ with an incident corner $c_{u}$ to the face $f$, we may insert an edge $a$ between $u$ and $v$.

In each primal top tree, we expose $v,c_{v}$ and $u,c_{u}$, respectively. In the dual top tree, we expose $g,c_{v}$ and $f,c_{u}$, respectively. We then link $u$ and $v$, and update the EET correspondingly: New corners $c_{1},\ldots,c_{4}$ are formed, such that the new edge $a=(u,v)$ appears as the successor of $c_{4}$ and the predecessor of $c_{1}$, and the successor of $c_{2}$ and the predecessor of $c_{3}$ (see figure 10). That is, we may view the top tree in its current form as the top tree with an exposed path $(u,v)$ which is trivial (consisting of one edge) and two leaves, one at each end.

In the dual tree, the faces $f$ and $g$ are simply joined at the incident corners $c_{u}$ and $c_{v}$, respectively.

To insert an edge inside a component, the two vertices must belong to the same face. Let $u$ and $v$ be vertices with corners $c_{u}$ and $c_{v}$ incident to a face $f$. We can then expose the corners $c_{u}$ and $c_{v}$, which gives us a path cluster in the primal top tree (and some leaves, because we use slim-path top trees), and in the dual tree, exposing those corners gives us two leaves, both incident to $f$.

We now create new corners $c_{1},\ldots,c_{4}$, and update the EET to list the new edge, $a=(u,v)$, as the successor of $c_{1}$ and predecessor of $c_{2}$, replacing $c_{v}$, and as the successor of $c_{3}$ and predecessor of $c_{4}$, replacing $c_{u}$ (see figure 11). In the dual tree, the face $f$ is split in the corners $c_{u}$ and $c_{v}$, creating new faces $g$ and $h$, and a new edge $(g,h)$ is added to the dual tree.

2.4.3 Deleting an edge

We show now how to perform $\operatorname{delete}(e)$.

There are three cases, depending on whether the edge to be deleted is a bridge, a non-tree edge, or a replacement edge exists.

An edge, $e$, is a bridge if its dual $e^{\ast}$ is a self-loop of some face. To delete a bridge $e=(u,v)$ incident to the face $f$ in corners $c_{1},\ldots c_{4}$ (see figure 12), do the following. Expose $u$ and $v$ in the primal tree. Expose the corners $c_{1},\ldots c_{4}$ in the dual tree, meaning we have at the top a four-leaf clover of clusters incident to $f$. Cut $f$ into those four parts, and delete the leaves corresponding to $c_{4}ec_{1}$ and $c_{2}ec_{3}$. Let $c_{u}$ denote the newly formed corner incident to $u$ and $c_{v}$ that incident to $v$. We have now split the face $f$ in two, and have two corresponding EETs and two dual top trees. In the primal top tree, delete the edge $u$; this leaves us with two top trees, one with a leaf with boundary vertex $v$ exposed and one with boundary vertex $u$ exposed – update the corresponding corners to be exactly the $c_{v}$ and $c_{u}$ created in the dual top tree, respectively.

If a non-bridge tree-edge is to be deleted, its dual induces a fundamental cycle in the dual tree, $C(e^{\ast})$. Any edge on this cycle would reconnect the components and can be added to the primal tree as a replacement edge. For simplicity, we can just choose the edge after $e^{\ast}$ on that cycle.

Let $e=(u,v)$ be the edge we want to delete. Let $f$ and $g$ be the faces incident to $e$. First, expose $u$ and $v$ in the primal tree. The top of the primal top tree is now of the form leaf-path-leaf, where the path-cluster consists of one edge, $(u,v)$. Since $f\neq g$, exposing corners $c_{1},c_{2}$ incident to $e$ (and to $v$) in the dual tree returns a top tree with a path-cluster as root. Let $a_{1}=(f,h)=e_{1}^{\ast}$ be the first edge on the cluster path from $g$ to $f$. We want to replace $e$ with $e_{1}=(u^{\prime},v^{\prime})$. (See figure 13.)

Let $c_{h}$ and $c_{h}^{\prime}$ be the corners of $a_{1}$ incident to $h$. Expose the vertices $u,v,u^{\prime},v^{\prime}$ and the corners $c_{h}$ and $c_{h}^{\prime}$ in the primal top tree.

Expose the faces $f$ and $g$ and the corners $c_{1}\ldots c_{4}$ in the dual top tree. In the dual tree, delete the edge $a_{1}=(f,h)$ from the tree. Cut $f$ in $c_{2},c_{3}$ and $g$ in $c_{1},c_{4}$, delete the leaves corresponding to $c_{2}ec_{3}$ and $c_{4}ec_{1}$, and name the replacing corners $c_{f}$ and $c_{g}$ (updating the EET). Then, join the faces $f$ and $g$ in the corners $c_{f}$ and $c_{g}$, and name the newly constructed corners $c_{u}$ and $c_{v}$. The dual top tree now has the path cluster with boundary vertices $h$ and $g$ as root.

In the primal tree, delete the edge $(u,v)$. The newly formed corners are exactly the $c_{u}$ and $c_{v}$ formed in the dual top tree. Link the vertices $u^{\prime}$ and $v^{\prime}$, and update the EET correspondingly. That is, if $r_{1},r_{2},r_{3},r_{4}$ are corners incident to $e_{1}=(u^{\prime},v^{\prime})$, then exchange the segments $r_{2}e_{1}r_{1}$ and $r_{4}e_{1}r_{3}$ to $r_{2}e_{1}r_{3}$ and $r_{4}e_{1}r_{1}$.

Deleting a non-tree edge is the opposite of inserting an edge inside a face (see figure 11). If a non-tree edge $e=(u,v)$ is deleted, its incident faces $f$ and $g$ must be joined. In the primal tree, expose $u,v$ and the corners $c_{1},\ldots,c_{4}$ incident to $e$. In the dual tree, expose the edge $e^{\ast}=(f,g)$, which must belong to the cotree, and all four corners incident to $e$. Cut $g$ in the corners $c_{1},c_{4}$, cut $f$ in the corners $c_{2},c_{3}$. Delete the cluster containing $e^{\ast}$, and join $f$ and $g$ in the corners $c_{f}$ and $c_{g}$ which were created from the cut. The join produces new corners $c_{u}$ and $c_{v}$. In the primal tree, the leaves with EET $c_{2}ec_{1}$ and $c_{4}ec_{3}$ are deleted, and the delimiting corners for the cluster path are updated to be the newly formed $c_{u}$ and $c_{v}$. During this procedure, the EET is updated to contain $c_{v}$ in place of $c_{2}ec_{1}$ and $c_{u}$ in place of $c_{4}ec_{3}$.

2.5 Flip

Finally, for $\operatorname{flip}$ to work we have to use a version of top trees that is not tied to a specific clockwise orientation of the vertices. The version in [1] that is based on a reduction to Frederickson’s topology trees [7] works fine for this purpose.

Definition 8** (Articulation flip).**

Having $\operatorname{cut}$ and $\operatorname{join}$ functions, we may perform an articulation-flip (see Figure 15) — a flip in an articulation point: Given a vertex $\alpha$ incident to the face $f_{1}$ in two corners, $c_{1}$ and $c_{2}$, we may cut through $c_{1},c_{2}$, obtaining two graphs $G_{1},G_{2}$, having split $\alpha$ in vertices $\alpha_{1}\in G_{1},\alpha_{2}\in G_{2}$, and having introduced new corners $c,c^{\prime}$ where we cut. Now, given a corner $\alpha_{p}$ incident to $\alpha_{1}$ and incident to some face $f_{2}$, we may join $\alpha_{1}$ with $\alpha_{2}$ by the corners $\alpha_{2},\alpha_{p}$, with or without having flipped the orientation of $G_{2}$.

Definition 9** (Separation flip).**

Similarly, given a separation pair $\alpha,\beta$, incident to the faces $f,g$ with corners $c_{1},\ldots c_{4}$, we may cut through those corners, obtaining two graphs. We may then flip the orientation of one of them, and rejoin. We call this a separation-flip.

Internally, both flip operations are done by cutting out a subgraph, altering its orientation, and joining the subgraph back in. In the dual graph, a flip corresponds to two splits, two cuts, two links, and two merges.

First, the articulation flip will be described. To flip in an articulation point, we only need to be able to cut a vertex, and join two vertices to one. (See figure 16.)

2.5.1 Articulation flip

Given a vertex $v$ and two corners $c_{1},c_{2}$ incident to $v$, we may cut the vertex in two such that all edges between $c_{1}$ and $c_{2}$ belong to the new vertex $v^{\prime}$, and all edges between $c_{2}$ and $c_{1}$ belong to $v$. (See Figure 16.) The corners $c_{1}$ and $c_{2}$ are deleted, and new corners $c$ and $c^{\prime}$ are created, and the extended Euler tours are updated correspondingly. (See figure 17.)

The EET cycle is split into two cycles; let $e_{1}$ and $e_{l}$ denote the successor of $c_{2}$ and the predecessor of $c_{1}$, respectively, and let $e_{1}^{\prime}$ and $e_{l^{\prime}}^{\prime}$ denote the successor of $c_{1}$ and the predecessor of $c_{2}$, respectively. The corner $c$ will take place between $e_{l}$ and $e_{1}$ in the EET containing $v$, and the corner $c^{\prime}$ will take place between $e_{l^{\prime}}^{\prime}$ and $e_{1}^{\prime}$ in the EET containing $v^{\prime}$. (See figure 17.)

We need to be able to cut both primal and dual vertices. By convention, the extended Euler tour is updated when primal vertices are cut, and never when dual vertices are cut.

Similarly, given two vertices, and given a corner incident to either vertex, we may join the two vertices, as an inverse operation to the vertex cut.

If $c$ is a corner incident to the vertex $v$ and $c^{\prime}$ is incident to $v^{\prime}$, we may perform the operation join($c,c^{\prime}$). Now, the extended Euler tour is updated correspondingly. We must create new corners, $c_{1}$ and $c_{2}$. In the Euler tour, $c_{1}$ must point to the predecessor of $c$ as its predecessor, and the successor of $c^{\prime}$ as its successor, and similarly for $c_{2}$. And vice versa, the object of those edges must point to $c_{1}$ and $c_{2}$.

We now have the necessary tools for flipping in an articulation point, that is, if a vertex has two corners incident to the same face, we may flip the subgraph spanned by those corners into another face incident to the vertex. This is done by the two-step scheme of cut and join. Namely:

Theorem 1**.**

We can support $\operatorname{articulation-flip(c_{1},c_{2},c_{3})}$ in time $\mathcal{O}(\log^{2}n)$.

Proof.

Given a vertex $v$ and two corners $c_{1}$ and $c_{2}$ incident both to $v$ and some common face $f_{1}$, and given a third corner, $c_{3}$ incident to $v$ and some face $f_{2}$, we first perform the vertex cut, cut($v,c_{1},c_{2}$) in the primal top tree. Then, we perform the operation of cut($f_{1},c_{1},c_{2}$) in the dual top tree. Together, these two operations return two graphs, $G$ and $G^{\prime}$, with respectively $v,c$ and $v^{\prime},c^{\prime}$ exposed in their primal top trees, and with $f_{1},c$ and $f_{1}^{\prime},c^{\prime}$ exposed in their dual top trees. Then, we expose $c_{3}$ (incident to $v$ and $f_{2}$) in the top trees of $G$. Finally, we perform the operation join($c_{3},c^{\prime}$), first in the dual, and then in the primal top tree, gluing $G^{\prime}$ back to $G$.

This operation takes $\mathcal{O}(\log^{2}n)$ time, dominated by the expose-operation in the primal top tree.∎∎

2.5.2 Altering the orientation

To perform a flip in a separation pair, we introduce the following three operations: seclude, alter the orientation, include. Seclude and include are similar to those of the previous section, while altering the orientation means that the ordering of edges around any vertex becomes the opposite. In the EET, the predecessor becomes a successor, and vice versa.

To implement this, we let the clusters of the primal and dual top tree contain one more piece of information, namely the orientation of the cluster, which is plus $+$, or minus $-$.

When a cluster is “negative”, some of its information changes character:

• •

its left-hand child becomes a right-hand child and vice versa,

• •

if it is a path cluster, the two EET-segments switch places,

• •

and, finally, in the extended Euler tour, predecessor is interpreted as successor and vice versa.

When a cluster is split, its sign is multiplied with the signs of its children. That is, if a cluster with a minus is split, the minus is propagated down to the children. When clusters are merged, the new union-cluster is simply equipped with a plus, while its children clusters keep their sign.

In the 3-step program of “seclude, alter, include,” the alter-step simply consists of changing the sign of the top cluster of the dual top tree for the secluded graph.

2.5.3 Separation flip

Given four corners $c_{1},\ldots,c_{4}$ such that $c_{1},c_{2}$ are incident to the vertex $v$, $c_{3},c_{4}$ are incident to the vertex $u$, $c_{2},c_{3}$ are incident to the face $f$ and $c_{4},c_{1}$ are incident to the face $g$. See figure 19.

To seclude($c_{1},c_{2},c_{3},c_{4}$), cut the vertex $v$ through the corners $c_{1}$ and $c_{2}$, cut $u$ through $c_{3}$ and $c_{4}$. In the dual top tree, cut the face $f$ in $c_{2}$ and $c_{3}$ (obtain $f$ and $f^{\prime}$), and cut the face $g$ in $c_{4}$ and $c_{1}$ (which returns $g$ and $g^{\prime}$). Then, join $f^{\prime}$ with $g^{\prime}$, and $f$ with $g$ in the dual top tree. We now have two graph-stumps, denote them $G$ and $G^{\prime}$, where $G$ contains $u$ and $v$ which are both incident to one face $h$ which was formed by joining $f$ with $g$, and where $G^{\prime}$ contains $u^{\prime}$ and $v^{\prime}$, both incident to the new face $h^{\prime}$.

This procedure consists of two vertex cuts in the primal tree, this takes $\mathcal{O}(\log^{2}n)$ time, two vertex cuts in the dual tree, which takes the time $\mathcal{O}(\log n)$. Note that between the seclude and the subsequent include we may not have a spanning tree for one of the components. This is not a problem, since we are not doing any other operations in between.

Include is the inverse operation of seclude above.

Given two graphs, $G$ and $G^{\prime}$, and given two vertices $u,v\in G$ and two vertices $u^{\prime},v^{\prime}\in G^{\prime}$, and given a designated face $h\in G$ incident to both $u$ and $v$, and similarly a face $h^{\prime}\in G^{\prime}$ incident to $u^{\prime}$ and $v^{\prime}$. Let four corners be given, such that $c_{u,h}$ is incident to $u$ and $h$, and so on, $c_{v,h},c_{u^{\prime},h^{\prime}},c_{v^{\prime},h^{\prime}}$.

To perform $\operatorname{include}(c_{u,h},c_{v,h},c_{u^{\prime},h^{\prime}},c_{v^{\prime},h^{\prime}})$: Cut the face $h$ through the corners $c_{v,h}$ and $c_{v,h}$, and cut the face $h^{\prime}$ similarly. Let the resulting faces be denoted $f,g$, and $f^{\prime},g^{\prime}$, respectively. Now, join the faces $f$ with $f^{\prime}$ and $g$ with $g^{\prime}$. Finally, join the vertices $u$ with $u^{\prime}$ and $v$ with $v^{\prime}$.

Theorem 2**.**

We can support $\operatorname{separation-flip}(c_{1},c_{2},c_{3},c_{4})$ in time $\mathcal{O}(\log^{2}n)$.

Proof.

Given two vertices which are incident to two faces, and given four delimiting corners $c_{1}\ldots c_{4}$ pairwise incident to both vertices and both faces (as in Definition 9), we perform $\operatorname{separation-flip}$($c_{1},c_{2},c_{3},c_{4}$) with a three-step procedure: Seclude, alter, include.

Let $g,f,c_{1},\ldots,c_{4}$ be as in Definition 9 (see Figure 19). First, seclude the subgraph $G^{\prime}$ delimited by the corners $c_{1},\ldots,c_{4}$, splitting the faces $f$ and $g$ to $f,f^{\prime}$ and $g,g^{\prime}$, respectively. Then, alter the orientation of $G^{\prime}$ by changing its sign. Finally, perform include, such that $f$ joins with $g^{\prime}$, and $g$ with $f^{\prime}$.

This takes $\mathcal{O}(\log^{2}n)$ time, dominated by the seclude and include operations.∎∎

3 One-flip linkable query

Given vertices $u,v$, we have already presented a data structure to find a common face for $u,v$. Given they do not share a common face, we will determine if an articulation flip exists such that an edge between them can be inserted, and given no such articulation-flip exists, we will determine if a separation-flip that makes the edge insertion $(u,v)$ possible exists.

Let $f_{1}$ and $f_{2}$ be faces in $G$, and let $S$ be a subgraph of $G$. We say that $S$ separates $f_{1}$ and $f_{2}$ if $f_{1}$ and $f_{2}$ are not connected in ${G}^{*}\setminus{}{(E[S])}^{*}$. Here, $E[X]$ denotes the set of edges of the subgraph $X$, $E[f]$ the edges incident to the face $f$, and $V[f]$ the incident vertices.

Observation 6**.**

Given a fundamental cycle $C$ that is induced in $T\cup\left\{e\right\}$ by some edge $e$ and given any two faces $f_{1}$, $f_{2}$ not separated by $C$, any face $f$ such that $C\cup{}E[f]$ separates $f_{1}$ and $f_{2}$ lies on the path $f_{1}\cdots{}f_{2}$ in ${\overline{T}}^{*}$.

Let $f_{1}$ and $f_{2}$ be faces of $G$, and let $S=V[f_{1}]\cap{}V[f_{2}]$ be the set of vertices they have in common. Let $C$ denote the set of corners between vertices in $S$ and faces in $\{f_{1},f_{2}\}$. The sub-graphs obtained by cutting $G$ through all the corners of $C$ are called flip-components of $G$ w.r.t. $f_{1}$ and $f_{2}$. Flip-components which are only incident to one vertex of $S$ can be flipped with an articulation-flip, and flip-components incident to two vertices can be flipped with a separation-flip. (See Figure 20.)

Observation 7**.**

Note that the perimeter of a flip component always consists of the union of a path along the face of $f_{u}$ with a path along the face of $f_{v}$. One of these paths is trivial (equal to a point) exactly when $u,v$ are linkable via an articulation-flip.

Given vertices $u$, $v$ in $G$, that are connected and not incident to a common face, we wish to find faces $f_{u}$ and $f_{v}$ such that $u$ and $v$ are in different flip-components w.r.t. $f_{u}$ and $f_{v}$.

3.1 Finding one face

Let $u$ and $v$ be given vertices, and assume there exist faces $f_{u}$ and $f_{v}$ such that $u\in{}V[f_{u}]\setminus{}V[f_{v}]$, $v\in{}V[f_{v}]\setminus{}V[f_{u}]$, and $u$ and $v$ are in different flip-components w.r.t. $f_{u}$ and $f_{v}$.

Let $u_{L},u_{R}$ be the left and right faces adjacent to the first edge on the path from $u$ to $v$. Similarly let $v_{L},v_{R}$ be the left and right faces adjacent to the first edge on the path from $v$ to $u$.

Lemma 11**.**

Face $f_{u}$ is on the ${\overline{T}}^{*}$-path $u_{L}\cdots{}u_{R}$ and face $f_{v}$ is on the ${\overline{T}}^{*}$-path $v_{L}\cdots{}v_{R}$.

Proof.

For symmetry reasons, we need only be concerned with the case $f_{u}$. The perimeter of a flip-component consists of edges incident to $f_{u}$ and edges incident to $f_{v}$ (see Observation 7). Furthermore, in order for $u,v$ to be linkable via a flip, $u$ needs to lie on the perimeter of its flip-component. We also know that the tree-path from $v$ to $u$ must go through a point $s$ in $S$ which lies on the boundary of $u$’s flip-component. Thus, there must exist a path $p$ in $G$ from $\pi\in S$ to $u$, consisting only of edges incident to $f_{u}$. Note that $u\notin S$ since $u,v$ were not already linkable. If the first edge $e_{u}$ on the tree path from $u$ to $v$ is not already incident to $f_{u}$, then the union of $p$ and the tree must contain a fundamental cycle containing $e_{u}$, separating $u_{L}$ from $u_{R}$, induced by an edge $e_{i}$ incident to $f_{u}$. (See Figure 21.) But then, the co-tree path from $u_{L}$ to $u_{R}$ goes through $e_{i}^{\ast}$, which means it goes through $f_{u}$. ∎∎

Lemma 12**.**

If there exists a fundamental cycle $C$ separating $f_{u}$ from $f_{v}$ such that $u\notin{}V[C]$ and $v\in{}V[C]$, then $f_{u}=\operatorname{m}(u_{L},u_{R},f)$ where $f\in\left\{v_{L},v_{R}\right\}$ is the face that is on the same side of $C$ as $u$. Here, $\operatorname{m}(a,b,c)$ denotes $a$’s projection to the path $b\cdots{}c$.

Proof.

By Lemma 11 $f_{u}$ is on the path $u_{L}\cdots{}u_{R}$. And since $C\cup{}E[f_{u}]$ separates $f$ from $u_{L}$ and $u_{R}$ it is on the paths $u_{L}\cdots{}f$ and $u_{R}\cdots{}f$ by Observation 6. ∎∎

Lemma 13**.**

If there exists a fundamental cycle $C$ separating $f_{u}$ from $f_{v}$ such that $u\not\in{}V[C]$ and $v\not\in{}V[C]$, then either $f_{u}=\operatorname{m}(u_{L},u_{R},v_{L})=\operatorname{m}(u_{L},u_{R},v_{R})$ or $f_{v}=\operatorname{m}(v_{L},v_{R},u_{L})=\operatorname{m}(v_{L},v_{R},u_{R})$.

Proof.

Let $e$ be the edge in $C\setminus{}T$, and let $e_{u},e_{v}$ be the faces adjacent to $e$ that are on the same side of $C$ as $f_{u}$ and $f_{v}$ respectively. Then $e$ is on all 4 paths in ${\overline{T}}^{*}$ with $u_{L}$ or $u_{R}$ at one end and $v_{L}$ or $v_{R}$ at the other. At least one of $u,v$ is in a different flip-component from $e$, so we can assume without loss of generality that $u$ is. By Lemma 11 $f_{u}$ is on the path $u_{L}\cdots{}u_{R}$. And since $C\cup{}f_{u}$ separates $u_{L}$ and $u_{R}$ from $e_{u}$, $f_{u}$ is on both the paths $u_{L}\cdots{}e_{u}$ and $u_{R}\cdots{}e_{u}$ by Observation 6. Thus $f_{u}=\operatorname{m}(u_{L},u_{R},e_{u})=\operatorname{m}(u_{L},u_{R},v_{L})=\operatorname{m}(u_{L},u_{R},v_{R})$. ∎∎

Lemma 14**.**

If a fundamental cycle $C$ separates $f_{u}$ from $f_{v}$ such that $u\in{}V[C]$ and $v\in{}V[C]$, then either $f_{u}=\operatorname{m}(u_{L},v_{L},v_{R})=\operatorname{m}(u_{L},u_{R},v_{R})$ or $f_{u}=\operatorname{m}(u_{R},v_{L},v_{R})=\operatorname{m}(u_{L},u_{R},v_{L})$ or $f_{v}=\operatorname{m}(v_{L},u_{L},u_{R})=\operatorname{m}(v_{L},v_{R},u_{R})$ or $f_{v}=\operatorname{m}(v_{R},u_{L},u_{R})=\operatorname{m}(v_{L},v_{R},u_{L})$.

Proof.

Let $e$ be the edge in $C\setminus{}T$, and let $e_{u},e_{v}$ be the faces adjacent to $e$ that are on the same side of $C$ as $f_{u}$ and $f_{v}$ respectively. Then $e$ is on all 4 paths in ${\overline{T}}^{*}$ with $u_{L}$ or $v_{R}$ at one end and $v_{L}$ or $u_{R}$ at the other. Assume that $u_{L}$ and $v_{R}$ are on the side of $C$ containing $f_{u}$ and $u_{R}$ and $v_{L}$ are on the side of $C$ containing $f_{v}$. At least one of $u,v$ is in a different flip-component from $e$, so assume that $v$ is. By Lemma 11 $f_{u}$ is on the path $u_{L}\cdots{}e_{u}\subset u_{L}\cdots{}u_{R}$. And since $C\cup{}f_{u}$ separates $u_{L}$ and $e_{u}$ from $v_{R}$ it is on both the paths $u_{L}\cdots{}v_{R}$ and $e_{u}\cdots{}v_{R}$ by Observation 6. Thus $f_{u}=\operatorname{m}(u_{L},e_{u},v_{R})=\operatorname{m}(u_{L},v_{L},v_{R})=\operatorname{m}(u_{L},u_{R},v_{R})$. The remaining cases are symmetric. ∎∎

Theorem 3**.**

If $f_{u},f_{v}$ exist, either $f_{u}\in\left\{\operatorname{m}(u_{L},u_{R},v_{L}),\operatorname{m}(u_{L},u_{R},v_{R})\right\}$ or $f_{v}\in\left\{\operatorname{m}(u_{L},v_{L},v_{R}),\operatorname{m}(u_{R},v_{L},v_{R})\right\}$.

Proof.

If they exist there is at least one fundamental cycle $C$ separating them. This cycle must have the properties of at least one of Lemmas 12, 13, or 14. ∎∎

By computing the at most two different $\operatorname{m}$ values and checking which ones (if any) contain $u$ or $v$ we therefore get at most two candidates and are guaranteed that at least one of them is in $\left\{f_{u},f_{v}\right\}$ if they exist.

3.2 Finding the other face

Lemma 15**.**

Let $u$, $v$, and $f_{u}$ be given. Then the first edge $e_{L}$ on $f_{u}\cdots{}v_{L}$ or the first edge $e_{R}$ on $f_{u}\cdots{}v_{R}$ induces a fundamental cycle $C(e_{R})$ or $C(e_{L})$ in $T$ that separates $f_{u}$ from $f_{v}$.

Proof.

By lemma 11, $f_{v}$ is on $v_{L}\cdots{}v_{R}$ in ${\overline{T}}^{*}$, so the first edge on $f_{u}\cdots{}f_{v}$ is also the first edge on either $f_{u}\cdots{}v_{L}$ or $f_{u}\cdots{}v_{R}$. ∎∎

Thus given the correct $f_{u}$ we can find at most two candidates for an edge $e$ that induces a fundamental cycle $C(e)$ in $T$ that separates $f_{u}$ from $f_{v}$, and be guaranteed that one of them is correct.

Observation 8**.**

For each vertex, $v$, we may consider the projection $\pi(v)$ of $v$ onto the cycle $C$. For each flip-component, $X$, we may consider the projection $\pi(X)=\{\pi(v)\mid v\in X\}$. If $X$ is an articulation-flip component, the projection $\pi(X)$ is a single point in $S=V\left[f_{u}\right]\cap V\left[f_{v}\right]$. If $X$ is a separation-flip component, its projection is a segment of the cycle, $\pi_{1}\cdots{}\pi_{2}$, between the separation pair $(\pi_{1},\pi_{2})\subset C(e)$ where $\pi_{1},\pi_{2}\in S$.

3.2.1 Finding an articulation-flip.

Let $(x,y)$ be any edge inducing a cycle $C$ in $T\cup\left\{(x,y)\right\}$ that separates $f_{u}$ from $f_{v}$, let $\pi(u)=\operatorname{m}_{T}(u,x,y)$ be the projection of $u$ on $C$.

Now the articulation-flip cases are not necessarily symmetrical. First we present how to detect an articulation-flip, given $u,v,$ and $f_{u}$, if $f_{v}$ plays the role of $f_{2}$ (see Section 2.5.1).

If the flip-component containing $v$ is an articulation-flip component, then $\pi(v)$ is an articulation point incident to both $f_{u}$ and $f_{v}$, but the opposite is not necessarily the case. Assume $\pi(v)$ is incident to both $f_{u}$ and $f_{v}$ and let $c_{u}$ denote a corner between $\pi(v)$ and $f_{u}$.

Note that if $\pi(v)$ is an articulation point with corners $c_{1},c_{2}$ both incident to $f_{v}$, then $f_{v}$ is an articulation point in the dual graph with corners $c_{1},c_{2}$ both incident to $\pi(v)$. Removing $f_{v}$ from the dual graph would split its component into several components, and clearly, aside from $f_{v}$, only faces in one of these components may contain faces incident to $v$. Any path in the co-tree starting and ending in different components w.r.t the split will have the property that the first face incident to $v$ on that path is $f_{v}$. (See Figure 22.)

Now, in the case $f_{u}=f_{1}$ and $f_{v}=f_{2}$, to find the corner of $\pi(v)$ incident to $f_{u}$, we can simply use $\operatorname{linkable}(\pi(v),u)$ from before, which will return a corner of $f_{u}$ incident to $\pi(v)$. To find the two corners of $f_{v}$: With the dual structure (see Observation 5) we may mark the face $f_{v}$, and expose the vertices $u,v$. Now, $\pi(v)$ has a unique place in the face-list of some cluster — if and only if that place is in the root cluster, and $n_{\min}=s_{\min}=0$ for that cluster, $f_{v}$ plays the role of $f_{2}$. That is, if and only if $\pi(v)$ has a corner incident to $f_{v}$ to one side, and a corner incident to $f_{v}$ to the other side. In affirmative case, $\pi(v)$ appears with at least one corner to either vertex list; those corners can now be used as cutting-corners for the articulation-flip.

If instead $f_{v}$ played the role of $f_{1}$, a similar procedure is done with $\pi(u)$.

Theorem 4**.**

Given $u,v$ are not already linkable, we can determine whether $u,v$ are linkable via an articulation-flip in time $\mathcal{O}(\log^{2}n)$.

3.2.2 Finding a separation-flip

Assume $v,u$ are not linkable via an articulation-flip, determine if they are linkable via a separation-flip.

Lemma 16**.**

Let $(x,y)$ be any edge inducing a cycle $C$ in $T\cup\left\{(x,y)\right\}$ that separates $f_{u}$ from $f_{v}$, let $\pi(u)=\operatorname{m}_{T}(u,x,y)$ be the projection of $u$ on $C$. Let $e_{1},e_{2}$ be the edges incident to $\pi(u)$ on $C$. Then at least one of $e_{1}$, $e_{2}$ is in the same flip-component as $u$ w.r.t $f_{u}$ and $f_{v}$.

Proof.

This follows from Observation 8: If $\pi(u)$ is incident to both $f_{u}$ and $f_{v}$, then exactly one of the edges $e_{1},e_{2}$ is in the same flip-component as $u$. Otherwise, both of the edges $e_{1},e_{2}$ are in the same flip-component as $u$. ∎∎

Lemma 17**.**

Let $C$ be any fundamental cycle separating $f_{u}$ from $f_{v}$, let $e_{u}$ be an edge on $C$ in the same flip-component as $u$, let $f_{1}$ be the face adjacent to $e_{u}$ that is separated from $f_{u}$ by $C$, and let $f_{2}\in\left\{v_{L},v_{R}\right\}$ be a face on the same side of $C$ as $f_{1}$. Then $f_{v}$ is the first face on $f_{1}\cdots{}f_{2}$ that contains $v$.

Proof.

$C\cup{}E[f_{v}]$ separates $f_{1}$ and $f_{2}$, so by Observation 6 $f_{v}$ is on the $f_{1}\cdots{}f_{2}$ path. It must be the first face on that path that contains $v$ because for any face $f$ after that, $C\cup{}V[f]$ does not separate $f_{1}$ and $f_{2}$, since it can only touch the part of $C$ between $u^{\prime}=\operatorname{m}(u,x,y)$ and $v^{\prime}=\operatorname{m}(v,x,y)$ where $(x,y)$ is the edge inducing $C$. ∎∎

3.3 Finding the separation pair and corners

Assume $u,v$ are not linkable and not linkable via an articulation-flip.

Lemma 18**.**

Given $u$, $v$, $f_{u}$, and $f_{v}$, let ${(x,y)}^{*}$ be any edge on $f_{u}\cdots{}f_{v}$ inducing a separating cycle $C$. If $\pi(u)=\pi(v)=\alpha$, then $\alpha$ is one of the separation points if it is adjacent to both $f_{u}$ and $f_{v}$, and otherwise no separation pair for $u,v$ exists. The other separation point, $\beta$, is then the first vertex $\neq\alpha$ adjacent to both $f_{u}$ and $f_{v}$ on either $\alpha\cdots{}x$ or $\alpha\cdots{}y$. If instead $\pi(u)\neq\pi(v)$, then $\alpha,\beta$ are among the first two vertices adjacent to both $f_{u}$ and $f_{v}$ either on $\pi(u)\cdots{}x$ and $v\cdots{}x$, or on $u\cdots{}y$ and $v\cdots{}y$.

Proof.

If the projection of $u$ equals the projection of $v$, but $u$ and $v$ are in different flip-components, then the next point incident to both $f_{u}$ and $f_{v}$ along the cycle to either side will be the one we are looking for. However, $(x,y)$ may be internal in the flip component containing $u$ or that containing $v$, and thus one of the searches may return the empty list. But then the other will return the desired pair of vertices.

If the projections are different, and do not themselves form the desired pair $(\alpha,\beta)$, then we may assume without loss of generality that $\pi(v)$ does not belong to the flip-component containing $u$. Let $X_{v},X_{u}$ denote the flip-components containing $u$ and $v$, respectively. If $(x,y)$ is in $X_{v}$, such that no edge on $\pi(v)\cdots{}x$ is incident to both $f_{u}$ and $f_{v}$, then the first vertex on $\pi(v)\cdots{}y$ incident to $f_{u}$ and $f_{v}$ is $\alpha$. Recall (Observation 8) that $\pi(X_{u})$ is an arc $\pi_{1}\cdots\pi_{2}\subset C$, and suppose without loss of generality $\pi_{1}$ is on the path $u\cdots{}v$. If $\pi(u)=\pi_{1}$, $\beta$ is the second vertex on the path $u$ to $y$ incident to both $f_{u}$ and $f_{v}$, as $\pi(u)$ itself is the first. Otherwise, the first such vertex on the path is $\beta$. If, on the other hand, $(x,y)$ did not belong to $X_{v}$, let $x$ be the vertex of $x,y$ with the property that the path $u\cdots{}x$ goes through $\pi(u)$. Then the first vertices on the paths to $x$ which are incident to $f_{u}$ and $f_{v}$ both, will be the desired separation pair. ∎∎

Lemma 19**.**

In the scenario above, we may find the first two vertices on the path incident to both faces in time $\mathcal{O}(\log^{2}n)$.

Proof.

We use the dual structure (see Observation 5) to search for vertices incident to $f_{u}$ and $f_{v}$. Now since the path $\pi(u)\cdots{}x$ is a sub-path of the fundamental cycle $C$ induced by $(x,y)$ which separates $f_{u}$ from $f_{v}$, all corners incident to $f_{v}$ will be on one side, and all corners incident to $f_{u}$ will be on the other side of the path, or at the endpoints. Thus, we expose $f_{u}$ and $f_{v}$ in the dual structure, which takes time $\mathcal{O}(\log^{2}n)$. Now expose $\pi(u),x$ in the primal tree. Since this path is part of the separating cycle, if $n_{\min}=s_{\min}=0$, then the maintained vertex-list will contain exactly those vertices incident to both faces, and a corner list for each of them. We now deal separately with the endpoints exactly as with $\operatorname{linkable}$, by exposing the endpoint faces one by one in the dual structure, and noting whether $c_{\min}=0$ and in that case, the corner list, for each endpoint. ∎∎

We conclude with the following theorem.

Theorem 5**.**

We can maintain an embedding of a dynamic graph under $\operatorname{insert}$ (edge), $\operatorname{remove}$ (edge), $\operatorname{cut}$ (vertex), $\operatorname{join}$ (vertex), and $\operatorname{flip}$ (subgraph), together with queries that

(linkable)* Answer whether an edge can be inserted between given endpoints with no other changes to the embedding, and if so, where.* 2. 2.

(one-flip-linkable)* Answer whether there exists a flip that would change the answer for linkable from “no” to “yes”, and if so, what flip.*

The worst case time per operation is $\mathcal{O}(\log^{2}n)$.

Acknowledgments

We would like to thank Christian Wulff-Nilsen and Mikkel Thorup for many helpful and interesting discussions and ideas.