A Strategy for Dynamic Programs: Start over and Muddle through

TL;DR

This paper presents a new strategy for dynamic programs that combines periodic recomputation with limited change maintenance, enabling the maintenance of complex queries in DynFO under certain conditions.

Contribution

It introduces a novel approach for constructing dynamic programs using periodic full recomputations and limited change steps, extending the capabilities of DynFO.

Findings

MSO-definable problems are in DynFO for bounded treewidth graphs

A Feferman-Vaught-type composition theorem for MSO is established

Dynamic maintenance of queries with limited change steps is feasible

Abstract

In the setting of DynFO, dynamic programs update the stored result of a query whenever the underlying data changes. This update is expressed in terms of first-order logic. We introduce a strategy for constructing dynamic programs that utilises periodic computation of auxiliary data from scratch and the ability to maintain a query for a limited number of change steps. We show that if some program can maintain a query for log n change steps after an AC$^1$-computable initialisation, it can be maintained by a first-order dynamic program as well, i.e., in DynFO. As an application, it is shown that decision and optimisation problems defined by monadic second-order (MSO) formulas are in DynFO, if only change sequences that produce graphs of bounded treewidth are allowed. To establish this result, a Feferman-Vaught-type composition theorem for MSO is established that might be useful in its own right.

Full text

1. Introduction

Each time a database is changed, any previously computed and stored result of a fixed query might become outdated. However, when the change is small, it is plausible that the new query result is highly related to the old result. In that case it might be more efficient to use previously computed information for obtaining the new answer to the query instead of recomputing the query result from scratch. A theoretical framework for studying when the result of a query over relational databases can be updated in a declarative fashion was formalised by Patnaik and Immerman [PatnaikI97], and Dong, Su, and Topor [DongST95]. In their formalisation, a dynamic program consists of a set of logical formulas that update a query result after the insertion or deletion of a tuple. The formulas may use additional auxiliary relations that, of course, need to be updated as well. The queries maintainable in this way via first-order formulas constitute the dynamic complexity class DynFO.

Recent work has confirmed that DynFO is a quite powerful class, since it captures, e.g., the reachability query for directed graphs [DattaKMSZ18], and even allows for more complex change operations than single-tuple changes [SchwentickVZ18, DattaMVZ18].

In this article we introduce a general strategy for dynamic programs that further underscores the expressive power of DynFO. All prior results for DynFO yield dynamic programs that are able to maintain a query for arbitrary long sequences of changes. Even if this is not (known to be) possible for a given query, in a practical scenario it might still be favourable to maintain the query result dynamically for a bounded number of changes, then to apply a more complex algorithm that recomputes certain auxiliary information from scratch, such that afterwards the query can again be maintained for some time, and so on.

Here we formalise this approach. Let ${\mathcal{C}}$ be a complexity class and $f\colon\mathbb{N}\rightarrow\mathbb{N}$ a function. A query $q$ is called $({\mathcal{C}},f)$-maintainable, if there is a dynamic program (with first-order definable updates) that, starting from some input structure ${\mathcal{A}}$ and auxiliary relations computed in ${\mathcal{C}}$ from ${\mathcal{A}}$, can answer $q$ for $f(|{\mathcal{A}}|)$ many steps, where $|{\mathcal{A}}|$ denotes the size of the universe of ${\mathcal{A}}$.

We feel that this notion might be interesting in its own right. However, in this article we concentrate on the case where ${\mathcal{C}}$ is (uniform) $\textsc{AC}^{1}$ and $f(n)=\log n$. The class $\textsc{AC}^{1}$ contains all queries that can be computed by a (uniform) circuit of depth ${\mathcal{O}}(\log n)$ that uses polynomially many $\wedge$-, $\vee$-, and $\neg$-gates, where $\wedge$- and $\vee$-gates may have unbounded fan-in. We show that $(\textsc{AC}^{1},\log n)$-maintainable queries are actually in DynFO, and thus can be maintained for arbitrary long change sequences.

We apply this insight to show that all queries and optimisation problems definable in monadic second-order logic (MSO) are in DynFO for (classes of) structures of bounded treewidth, by proving that they are $(\textsc{AC}^{1},\log n)$-maintainable. The same can be said about guarded second-order logic (GSO), simply because it is expressively equivalent to MSO on such classes [Courcelle94]. This implies that decision problems like 3-Colourability or HamiltonCycle as well as optimisation problems like VertexCover and DominatingSet are in DynFO, for such classes of structures. This result is therefore a dynamic version of Courcelle’s Theorem which states that all problems definable in (certain extensions of) MSO can statically be solved in linear time for graphs of bounded treewidth [Courcelle90].

The proof that MSO-definable queries are $(\textsc{AC}^{1},\log n)$-maintainable on structures of bounded treewidth makes use of a Feferman–Vaught-type composition theorem for MSO which might be useful in its own right.

The result that $(\textsc{AC}^{1},\log n)$-maintainable queries are in DynFO comes with a technical restriction: in a nutshell, it holds for queries that are invariant under insertion of (many) isolated elements. We call such queries almost domain independent and refer to Section 3 for a precise definition.

We emphasise that the main technical challenge in maintaining MSO-queries on graphs of bounded treewidth is that tree decompositions might change drastically after an edge insertion, and can therefore not be maintained incrementally in any obvious way. In particular, the result does not simply follow from the DynFO-maintainability of regular tree languages shown in [GeladeMS12]. We circumvent this problem by periodically recomputing a new tree decomposition (this can be done in logarithmic space [ElberfeldJT10] and thus in $\textsc{AC}^{1}$) and by showing that MSO-queries can be maintained for $\mathcal{O}(\log n)$ many change operations, even if they make the tree decomposition invalid.

Contributions

We briefly summarise the contributions described above. In this article, we introduce the notion of $({\mathcal{C}},f)$-maintainability and show that, amongst others, (almost domain independent) $(\textsc{AC}^{1},\log n)$-maintainable queries are in DynFO. We show that MSO-definable decision problems and optimisation problems are $(\textsc{AC}^{1},\log n)$-maintainable and therefore in DynFO, for structures of bounded treewidth. These proofs make use of a Feferman–Vaught-type composition theorem for MSO logic.

Related work

The simulation-based technique for proving that $(\textsc{AC}^{1},\log n)$-maintainable queries are in DynFO is inspired by proof techniques from [DattaKMSZ15] and [SchwentickVZ18]. As mentioned above, in [GeladeMS12] it has been shown that tree languages, i.e. MSO on trees, can be maintained in DynFO. Independently, the maintenance of MSO definable queries on graphs of bounded treewidth is also studied in [BouyerJM17], though in the restricted setting where the tree decomposition stays the same for all changes. A static but parallel version of Courcelle’s Theorem is given in [ElberfeldJT10]: every MSO-definable problem for graphs of bounded treewidth can be solved with logarithmic space.

Organisation

Basic terminology is recalled in Section 2, followed by a short introduction into dynamic complexity in Section 3. In Section 4 we introduce the notion of $({\mathcal{C}},f)$-maintainability and show that $(\textsc{AC}^{1},\log n)$-maintainable queries are in DynFO. A glimpse on the proof techniques for proving that MSO queries are in DynFO for graphs of bounded treewidth is given in Section 5 via the example 3-Colourability. The proof of the general results is presented in Section LABEL:section:mso. An extension to optimisation problems can be found in Section LABEL:section:mso-opt.

This article is the full version of [DattaMSVZ17].

2. Preliminaries

We now introduce some notation and notions regarding logics, graph theory and complexity theory. We assume familiarity with first-order logic FO and other notions from finite model theory [ImmermanDC, Libkin04].

Relational structures

In this article we consider finite relational structures over relational signatures $\Sigma=\{R_{1},\ldots,R_{\ell},c_{1},\ldots,c_{m}\}$, where each $R_{i}$ is a relation symbol with a corresponding arity $\text{Ar}(R_{i})$, and each $c_{j}$ is a constant symbol. A $\Sigma$-structure ${\mathcal{A}}$ consists of a finite domain $A$, also called the universe of ${\mathcal{A}}$, a relation $R_{i}^{\mathcal{A}}\subseteq A^{\text{Ar}(R_{i})}$, and a constant $c_{j}^{\mathcal{A}}\in A$, for each $i\in\{1,\ldots,\ell\},j\in\{1,\ldots,m\}$. The active domain $\text{adom}({\mathcal{A}})$ of a structure ${\mathcal{A}}$ contains all elements used in some tuple or as some constant of ${\mathcal{A}}$. For a set $B\subseteq A$ that contains all constants and a relation $R$, the restriction $R[B]$ of $R$ to $B$ is the relation $R\cap B^{\text{Ar}(R)}$. The structure ${\mathcal{A}}[B]$ induced by $B$ is the structure obtained from ${\mathcal{A}}$ by restricting the domain and all relations to $B$.

Sometimes, especially in Section 3, we consider relational structures as relational databases. This terminology is common in the context of dynamic complexity due to its original motivation from relational databases. Also for this reason, dynamic complexity classes defined later will be defined as classes of queries of arbitrary arity, and not as a class of decision problems. However, we will mostly consider queries over structures with a single binary relation symbol $E$, that is, queries on graphs.

We will often use structures ${\mathcal{A}}$ with a linear order $\leq$ on the universe $A$, and compatible ternary relations encoding arithmetical operations $+$ and $\times$ or, alternatively, a binary relation encoding the relation $\text{BIT}=\{(i,j)\mid$ the $j$-th bit in the binary representation of $i$ is $1\}$. The linear order in particular allows us to identify $A$ with the first $|A|$ natural numbers. We write $\textsc{FO}(+,\times)$ or $\textsc{FO}(\text{BIT})$ to emphasise that we allow first-order formulas to use such additional relations.111The question of $<$-invariance (c.f. [Libkin04]) will not be relevant in the context of this article as a specific relation $\leq$ will be available in the structure. We also use that $\textsc{FO}(+,\times)=\textsc{FO}(\text{BIT})$ [ImmermanDC].

Tree decompositions and treewidth

A tree decomposition $(T,B)$ of $G$ consists of a (rooted, directed) tree $T=(I,F,r)$, with (tree) nodes $I$, (tree) edges $F$, a distinguished root node $r\in I$, and a function $B\colon I\rightarrow 2^{V}$ such that

1. (1)

the set $\{i\in I\mid v\in B(i)\}$ is non-empty for each node $v\in V$, 2. (2)

there is an $i\in I$ with $\{u,v\}\subseteq B(i)$ for each edge $(u,v)\in E$, and 3. (3)

the subgraph $T[\{i\in I\mid v\in B(i)\}]$ is connected for each node $v\in V$.

We refer to the number of children of a node $i$ of $T$ as its degree, and to the set $B(i)$ as its bag. We denote the parent node of $i$ by $p(i)$. The width of a tree decomposition is defined as the maximal size of a bag minus $1$. The treewidth of a graph $G$ is the minimal width among all tree decompositions of $G$. A tree decomposition is $d$-nice, for some $d\in\mathbb{N}$, if

1. (1)

$T$ has depth at most $d\log n$, 2. (2)

the degree of the nodes is at most $2$, and 3. (3)

all bags are distinct.

Often we do not make the constant $d$ explicit and just speak of nice tree decompositions.

Later we will use that tree decompositions can be transformed into nice tree decompositions with slightly increased width. This is formalized in the following lemma, whose proof is an adaption of [ElberfeldJT10, Lemma 3.1].

Lemma 2.1**.**

For every $k\in\mathbb{N}$ there is a constant $d\in\mathbb{N}$ such that for every graph of treewidth $k$, a $d$-nice tree decomposition of width $4k+5$ can be computed in logarithmic space.

Proof 2.2**.**

Let $G$ be a graph of treewidth $k$. By [ElberfeldJT10, Lemma 3.1] a tree decomposition $(T,B)$ of width $4k+3$ can be computed in logarithmic space, such that each non-leaf node has degree 2 and the depth is at most $d\log n$, for a constant $d$ that only depends on $k$. To obtain a tree decomposition with distinct bags, we compose this algorithm with three further algorithms, each reading a tree decomposition $(T,B)$ and transforming it into a tree decomposition $(T^{\prime},B^{\prime})$ with a particular property. Since each of the four algorithms requires only logarithmic space, the same holds for their composition.

The first transformation algorithm produces a tree decomposition, in which for each leaf bag $i$ it holds $B(i)\not\subseteq B(p(i))$. In particular, after this transformation, each bag of a leaf node $i$ contains some graph node $u(i)$ that does not appear in any other bag. This transformation inspects each node $i$ separately in a bottom-up fashion, and removes it if (1) $B(i)\subseteq B(p(i))$ and (2) every bag below $i$ is a subset of $B(i)$. Clearly, logarithmic space suffices for this.

The second transformation (inductively) removes an inner node $i$ of degree 1 with a child $i^{\prime}$ and inserts an edge between $B(p(i))$ and $B(i^{\prime})$ whenever $B(i)\subseteq B(p(i))$ or $B(i)\subseteq B(i^{\prime})$ holds. For this transformation, only one linear chain of nodes in $T$ has to be considered at any time and therefore logarithmic space suffices again. Clearly, the connectivity property is not affected by these deletions.

The third transformation adds to every bag of an inner node $i$ the nodes $u(i_{1})$ and $u(i_{2})$, guaranteed to exist by the first transformation, of the leftmost and rightmost leaf nodes $i_{1}$ and $i_{2}$ of the subtree rooted at $i$, respectively. Here, we assume the children of every node to be ordered by the representation of $T$ as input to the algorithm. After this transformation, each node of degree 2 has a different bag than its two children thanks to the addition of $u(i_{1})$ and $u(i_{2})$. Each node of degree 1 has a different bag than its child, since this was already the case before (and to both of them the same two nodes might have been added). Altogether, all bags are pairwise distinct and the bag sizes have increased by at most 2.

We emphasise that, whenever a leftmost graph node $u(i_{1})$ is added to $B(i)$, it is also added to all bags of nodes on the path from $i$ to $i_{1}$ and therefore the connectivity property is not corrupted. It is easy to see that the third transformation can also be carried out in logarithmic space.

The three presented algorithms never increase the depth of a tree decomposition, so the final result is a $d$-nice tree decomposition for $G$ of width $4k+5$.

In this paper we only consider nice tree decompositions, and due to property (3) of these decompositions we can identify bags with nodes from $I$.

For two nodes $i,i^{\prime}$ of $I$, we write $i\preceq i^{\prime}$ if $i^{\prime}$ is in the subtree of $T$ rooted at $i$ and $i\prec i^{\prime}$ if, in addition, $i^{\prime}\not=i$. A triangle $\delta$ of $T$ is a triple $(i_{0},i_{1},i_{2})$ of nodes from $I$ such that $i_{0}\preceq i_{1}$, $i_{0}\preceq i_{2}$, and (1) $i_{1}=i_{2}$ or (2) neither $i_{1}\preceq i_{2}$ nor $i_{2}\preceq i_{1}$. In case of (2) we call the triangle proper, in case of (1) unary, unless $i_{0}=i_{1}=i_{2}$ in which we call it open (see Figure 1 for an illustration).

The subtree $T(\delta)$ induced by a triangle consists of all nodes $j$ of $T$ for which the following holds:

1. (i)

$i_{0}\preceq j$, 2. (ii)

if $i_{0}\prec i_{1}$ then $i_{1}\not\prec j$, and 3. (iii)

if $i_{0}\prec i_{2}$ then $i_{2}\not\prec j$.

That is, for a proper or unary triangle, $T(\delta)$ contains all nodes of the subtree rooted at $i_{0}$ which are not below $i_{1}$ or $i_{2}$. For an open triangle $\delta=(i_{0},i_{0},i_{0})$, $T(\delta)$ is just the subtree rooted at $i_{0}$.

Each triangle $\delta$ induces a subgraph $G(\delta)$ of $G$ as follows: $V(\delta)$ is the union of all bags of $T(\delta)$. By $B(\delta)$ we denote the set $B(i_{0})\cup B(i_{1})\cup B(i_{2})$ of interface nodes of $V(\delta)$. All other nodes in $V(\delta)$ are called inner nodes. The edge set of $G(\delta)$ consists of all edges of $G$ that involve at least one inner node of $V(\delta)$.

MSO-logic and MSO-types

MSO is the extension of first-order logic that allows existential and universal quantification over set variables $X,X_{1},\ldots$. The (quantifier) depth of an MSO formula is the maximum nesting depth of (second-order and first-order) quantifiers in the syntax tree of the formula.

For a signature $\Sigma$ and a natural number $d\geq 0$, the depth-$d$ MSO type of a $\Sigma$-structure ${\mathcal{A}}$ is defined as the set of all MSO sentences $\varphi$ over $\Sigma$ of quantifier depth at most $d$, for which ${\mathcal{A}}\models\varphi$ holds. We also define the notion of types for structures with additional constants and MSO formulas with free variables. Let ${\mathcal{A}}$ be a $\Sigma$-structure and $\bar{v}=(v_{1},\ldots,v_{m})$ a tuple of elements from ${\mathcal{A}}$. We write $({\mathcal{A}},\bar{v})$ for the structure over $\Sigma\cup\{c_{1},\ldots,c_{m}\}$ which interprets $c_{i}$ as $v_{i}$, for every $i\in\{1,\ldots,m\}$. For a set ${\mathcal{Y}}$ of first-order and second-order variables and an assignment $\alpha$ for the variables of ${\mathcal{Y}}$, the depth-$d$ MSO type of $({\mathcal{A}},\bar{v},\alpha)$ is the set of MSO formulas with free variables from ${\mathcal{Y}}$ of depth $d$ that hold in $({\mathcal{A}},\bar{v},\alpha)$. For every depth-$d$ MSO type $\tau$, there is a depth-$d$ MSO formula $\alpha_{\tau}$ that is true in exactly the structures and for those assignments of type $\tau$.

The logic guarded second-order logic (GSO) extends MSO by guarded second-order quantification. Thus, it syntactically allows to quantify over non-unary relation variables. However, this quantification is semantically restricted: a tuple $\bar{t}=(a_{1},\ldots,a_{m})$ can only occur in a quantified relation, if all elements from $\{a_{1},\ldots,a_{m}\}$ occur together in some tuple of the structure, in which the formula is evaluated.

For more background on MSO logic and types, readers might consult, e.g., [Libkin04].

Complexity classes and descriptive characterisations

Our main result refers to the complexity class (uniform) $\textsc{AC}^{1}$. It contains all queries that can be computed by (families of uniform) circuits of depth $\mathcal{O}(\log n)$, consisting of polynomially many “and”, “or” and “not” gates, where “and” and “or” gates may have unbounded fan-in. It contains the classes LOGSPACE and NL, and it can be characterised as the class $\text{IND}[\log n]$ of problems that can be expressed by applying a first-order formula $\mathcal{O}(\log n)$ times [ImmermanDC, Theorem 5.22]. Here, $n$ denotes the size of the universe and the formulas can use built-in relations $+$ and $\times$. More generally, this characterisation is also valid for the analogously defined classes $\textsc{AC}[f(n)]$ and $\text{IND}[f(n)]$, where the depth of the circuits and the number of applications of the first-order formula is $f(n)$, respectively, for some function $f\colon\mathbb{N}\to\mathbb{N}$. Technically, the function $f$ needs to be first-order constructible, that is, there has to be a FO$(+,\!\times\!)$ formula $\psi_{f}(\bar{x})$ such that ${\mathcal{A}}\models\psi_{f}(\bar{a})$ if and only if $\bar{a}$ is a base-$n$ representation of $f(n)$, for any ordered structure ${\mathcal{A}}$ with domain $\{0,\ldots,n-1\}$.

Our proofs often assume that $\log n$ is a natural number, but they can be easily adapted to the general case.

3. Dynamic Complexity

We briefly repeat the essentials of dynamic complexity, closely following [SchwentickZ16, DattaKMSZ18].

The goal of a dynamic program is to answer a given query on an input database subjected to changes that insert or delete single tuples. The program may use an auxiliary data structure represented by an auxiliary database over the same domain. Initially, both input and auxiliary database are empty; and the domain is fixed during each run of the program.

A dynamic program has a set of update rules that specify how auxiliary relations are updated after a change of the input database. An update rule for updating an auxiliary relation $T$ is basically a formula $\varphi$. As an example, if $\varphi(\bar{x},\bar{y})$ is the update rule for auxiliary relation $T$ under insertions into input relation $R$, then the new version of $T$ after insertion of a tuple $\bar{a}$ to $R$ is $T\mathrel{\smash{\stackrel{{\scriptstyle\scriptscriptstyle{\text{def}}}}{{=}}}}\;\{\bar{b}\mid({\mathcal{I}},Aux)\models\varphi(\bar{a},\bar{b})\}$ where ${\mathcal{I}}$ and $Aux$ are the current input and auxiliary databases. For a state ${\mathcal{S}}=({\mathcal{I}},Aux)$ of the dynamic program ${\mathcal{P}}$ with input database ${\mathcal{I}}$ and auxiliary database $Aux$ we denote the state of the program after applying a sequence $\alpha$ of changes by ${\mathcal{P}}_{\alpha}({\mathcal{S}})$. The dynamic program ${\mathcal{P}}$ maintains a $k$-ary query $q$ if, for each non-empty sequence $\alpha$ of changes and each empty input structure ${\mathcal{I}}_{\emptyset}$, a designated auxiliary relation $Q$ in ${\mathcal{P}}_{\alpha}({\mathcal{S}}_{\emptyset})$ and $q(\alpha({\mathcal{I}}_{\emptyset}))$ coincide. Here, ${\mathcal{S}}_{\emptyset}=({\mathcal{I}}_{\emptyset},Aux_{\emptyset})$, where $Aux_{\emptyset}$ denotes the empty auxiliary structure over the domain of ${\mathcal{I}}_{\emptyset}$, and $\alpha({\mathcal{I}}_{\emptyset})$ is the input database after applying $\alpha$.

In this article, we are particularly interested in maintaining queries for structures of bounded treewidth. There are several ways to adjust the dynamic setting to restricted classes ${\mathcal{C}}$ of structures. Sometimes it is possible that a dynamic program itself detects that a change operation would yield a structure outside the class ${\mathcal{C}}$. However, here we simply disallow change sequences that construct structures outside ${\mathcal{C}}$. That is, in the above definition, only change sequences $\alpha$ are considered, for which each prefix transforms an initially empty structure into a structure from ${\mathcal{C}}$. We say that a program maintains $q$ for a class ${\mathcal{C}}$ of structures, if $Q$ contains its result after each change sequence $\alpha$ such that the application of each prefix of $\alpha$ to ${\mathcal{I}}_{\emptyset}$ yields a structure from ${\mathcal{C}}$.

The class of queries that can be maintained by a dynamic program with first-order update formulas is called DynFO. We say that a query $q$ is in DynFO for a class ${\mathcal{C}}$ of structures, if there is such a dynamic program that maintains $q$ for ${\mathcal{C}}$. Programs for queries in DynFO$(+,\times)$ have three particular auxiliary relations $\leq,+,\times$ that are initialised as a linear order and the corresponding addition and multiplication relations.

For a wide class of queries, membership in DynFO$(+,\times)$ implies membership in DynFO [DattaKMSZ18]. Queries of this class have the property that the query result does not change considerably when elements are added to the domain but not to any relation. Informally, a query $q$ is called almost domain independent if there is a constant $c$ such that if a structure already has at least $c$ “non-active” elements, adding more “non-active” elements does not change the query result with respect to the original elements. More formally, a query $q$ is almost domain independent if there is a $c\in\mathbb{N}$ such that, for every structure ${\mathcal{A}}$ and every set $B\subseteq A\setminus\text{adom}({\mathcal{A}})$ with $|B|\geq c$ it holds $q({\mathcal{A}})[(\text{adom}({\mathcal{A}})\cup B)]=q({\mathcal{A}}[(\text{adom}({\mathcal{A}})\cup B)])$.

{exas}

1. (a)

The binary reachability query $q_{\text{Reach}}$, that maps a directed input graph $G=(V,E)$ to its transitive closure relation, is almost domain independent with $c=0$: adding any set $B\subseteq V\setminus\text{adom}(G)$ of isolated nodes to a graph does not create or destroy paths in the remaining graph. Note that, for each node $v\in V$, the tuple $(v,v)$ is part of the query result $q_{\text{Reach}}(G)$, so $q_{\text{Reach}}(G)\neq q_{\text{Reach}}(G[\text{adom}(G)])$ in general and therefore $q_{\text{Reach}}$ is not domain independent in the sense of [DattaKMSZ15]. 2. (b)

The FO definable Boolean query $q_{|\neg\text{adom}|=2}$, which is true if and only if exactly two elements are not in the active domain, is almost domain independent with $c=3$. 3. (c)

The Boolean query $q_{\text{even}}$, which is true for domains of even size and false otherwise, is not almost domain independent.

Furthermore, all properties definable in monadic second-order logic are almost domain dependent.

Proposition 3.1**.**

All MSO-definable queries are almost domain independent.

Proof 3.2** (Proof sketch.).**

This can be easily shown by an Ehrenfeucht game. Let $\varphi$ be an MSO-formula of quantifier depth $d$ with $e$ free (node) variables and let $c=2^{d}d+e$. Consider two graphs ${\mathcal{A}}_{1}$ and ${\mathcal{A}}_{2}$ that result from adding $c_{1}\geq c$ and $c_{2}\geq c$ isolated nodes to some graph ${\mathcal{A}}$, respectively. Since $\varphi$ might have free variables, the game is played on $({\mathcal{A}}_{1},\bar{a}_{1})$ and $({\mathcal{A}}_{2},\bar{a}_{2})$, where $\bar{a}_{1}$ and $\bar{a}_{2}$ are tuples of elements of length $e$. Within $d$ moves the spoiler can use at most $d$ set moves and can therefore induce at most $2^{d}$ different “colours” on ${\mathcal{A}}_{1}$ and ${\mathcal{A}}_{2}$. However, the duplicator can easily guarantee that, for each such “colour”, the number of isolated nodes (which do not occur in the initial tuples on both structures) of that colour is the same in ${\mathcal{A}}_{1}$ and ${\mathcal{A}}_{2}$ or it is larger than $d$, in both of them. Since the spoiler can have at most $d$ node moves, he can not make use of this difference in the two structures.

The following proposition adapts Proposition 7 from [DattaKMSZ18].

Proposition 3.3**.**

Let $q$ be an almost domain independent query. If q\in\textsc{DynFO(+,\times)} then also $q\in\textsc{DynFO}$.

The same statement is proved for weakly domain independent queries in [DattaKMSZ18, Proposition 7]. A query $q$ is weakly domain independent, if $q({\mathcal{A}})[\text{adom}({\mathcal{A}})]=q({\mathcal{A}}[\text{adom}({\mathcal{A}})])$ for all structures ${\mathcal{A}}$, that is, if it is almost domain independent with $c=0$. The proof of [DattaKMSZ18, Proposition 7] can easily be adapted for this more general statement, so we omit a full proof here. However, for readers who are familiar with the proof of [DattaKMSZ18, Proposition 7], we sketch the necessary changes.

Proof 3.4** (Proof sketch.).**

We assume familiarity with the proof of [DattaKMSZ18, Proposition 7] and only repeat its main outline. That proof explains, for a given DynFO$(+,\times)$-program ${\mathcal{P}}$, how to construct a DynFO-program ${\mathcal{P}}^{\prime}$ that is equivalent to ${\mathcal{P}}$. This program ${\mathcal{P}}^{\prime}$ relies on the observation that a linear order, addition and multiplication can be maintained on the activated domain [Etessami98], that is, on all elements that were part of the active domain at some time during the dynamic process. The linear order is determined by the order in which the elements are activated.

The program ${\mathcal{P}}^{\prime}$ can be regarded as the parallel composition of multiple copies, called threads, of the same dynamic program. Each thread simulates ${\mathcal{P}}$ for a certain period of time: thread $i$ starts when $f(i-1)$ elements are activated and does some initialisation, and it is in charge of answering the query whenever more than $f(i)$ but at most $f(i+1)$ elements are activated, for some function $f$. Thanks to weak domain independence, thread $i$ only needs to simulate ${\mathcal{P}}$ on a domain with $f(i+1)$ elements, for which it can define the arithmetic relations $\leq$, $+$ and $\times$ based on the available arithmetic relations on the $f(i-1)$ activated elements.

For almost domain independent queries we extend this technique slightly. Let $c$ be the constant from almost domain independence. The query result for a structure with domain size $n$ coincides with the result of a simulation on a domain of size $n^{\prime}$, if $n=n^{\prime}$ or if there are at least $c$ non-activated elements in both domains. To ensure that the simulation can in principle represent these $c$ elements, phase $i$ is generally in charge as long as the number of activated elements is at least $f(i)-c+1$ but at most $f(i+1)-c$, as in phase $i$ one can simulate ${\mathcal{P}}$ on a domain of size $f(i+1)$.

However, if in the original structure the number of non-activated elements becomes smaller than $c$, the simulation has to switch to a domain of the same size as the original domain. Therefore in phase $i$ there is not only one simulation with domain size $f(i+1)$, but one simulation (denoted by the pair $(i,\ell)$) for each domain size $\ell\in\{f(i)-c+1,\ldots,f(i+1)\}$. During phase $i$ the simulation denoted by $(i,f(i+1))$ is in charge unless there are fewer than $c$ non-activated elements in the original domain, which can be easily detected by a first-order formula. As soon as that happens, the simulation denoted by $(i,n)$ takes over, where $n$ is the size of the domain.

4. Algorithmic Technique

The definition of DynFO requires that for the problem at hand each change can be handled by a first-order definable update operation. There are alternative definitions of DynFO, where the initial structure is non-empty and the initial auxiliary relations can be computed within some complexity class [PatnaikI97, WeberS07]. However, in a practical scenario of dynamic query answering it is conceivable that the quality of the auxiliary relations decreases over time and that they are therefore recomputed from scratch at times. We formalise this notion by a relaxed definition of maintainability in which the initial structure is non-empty, the dynamic program is allowed to apply some preprocessing, and query answers need only be given for a certain number of change steps.

A query $q$ is called $({\mathcal{C}},f)$-maintainable, for some complexity class222Strictly speaking ${\mathcal{C}}$ should be a complexity class of functions. In this paper, the implied class of functions will always be clear from the stated class of decision problems. ${\mathcal{C}}$ and some function $f:\mathbb{N}\to\mathbb{R}$, if there is a dynamic program ${\mathcal{P}}$ and a ${\mathcal{C}}$-algorithm ${\mathcal{A}}$ such that for each input database ${\mathcal{I}}$ over a domain of size $n$, each linear order $\leq$ on the domain, and each change sequence $\alpha$ of length $|\alpha|\leq f(n)$, the relation $Q$ in ${\mathcal{P}}_{\alpha}({\mathcal{S}})$ and $q(\alpha({\mathcal{I}}))$ coincide where ${\mathcal{S}}=({\mathcal{I}},{\mathcal{A}}({\mathcal{I}},\leq))$.

Although we feel that $({\mathcal{C}},f)$-maintainability deserves further investigation, in this paper we exclusively use it as a tool to prove that queries are actually maintainable in DynFO. To this end, we show next that every $(\textsc{AC}^{1},\log n)$-maintainable query is actually in DynFO and prove later that the queries in which we are interested are $(\textsc{AC}^{1},\log n)$-maintainable.

Theorem 4.1**.**

Every $(\textsc{AC}^{1},\log n)$-maintainable, almost domain independent query is in DynFO.

We do not prove this theorem directly, but instead give a more general result, strengthening the correspondence between depth of the initialising circuit families and number of change steps the query has to be maintained.

Theorem 4.2**.**

Let $f:\mathbb{N}\to\mathbb{N}$ be a first-order constructible function with $f\in\mathcal{O}(n)$. Every $(\textsc{AC}[f(n)],f(n))$-maintainable, almost domain independent query is in DynFO.

Proof 4.3**.**

Let $f:\mathbb{N}\to\mathbb{N}$ be first-order constructible with $f\in\mathcal{O}(n)$ and assume that an $\textsc{AC}[f(n)]$ algorithm ${\mathcal{A}}$ and a dynamic program ${\mathcal{P}}$ witness that an almost domain independent query $q$ is $(\textsc{AC}[f(n)],f(n))$-maintainable. Thanks to Proposition 3.3 it suffices to construct a dynamic program ${\mathcal{P}}^{\prime}$ that witnesses q\in\textsc{DynFO(+,\times)}. We restrict ourselves to graphs, for simplicity.

The overall idea is to use a simulation technique similar to the ones used in Proposition 3.3 and in [SchwentickVZ18, Theorem 8.1]. We first present the computations performed by ${\mathcal{P}}^{\prime}$ intuitively and later explain how they can be expressed in first-order logic.

We consider each application of one change as a time step and refer to the graph after time step $t$ as $G_{t}=(V,E_{t})$. After each time step $t$, the program ${\mathcal{P}}^{\prime}$ starts a thread that is in charge of answering the query at time point $t+f(n)$. Each thread works in two phases, each lasting $\frac{f(n)}{2}$ time steps. Roughly speaking, the first phase is in charge of simulating ${\mathcal{A}}$ and in the second phase ${\mathcal{P}}$ is used to apply all changes that occur from time step $t+1$ to time step $t+f(n)$. Using $f(n)$ many threads, ${\mathcal{P}}^{\prime}$ is able to answer the query from time point $f(n)$ onwards.

We now give more details on the two phases and describe afterwards how to deal with time points earlier than $f(n)$. For the first phase, we make use of the equality $\textsc{AC}[f(n)]=\text{IND}[f(n)]$, see [ImmermanDC]. Let $\psi$ be an inductive formula that is applied $df(n)$ times, for some $d$, to get the auxiliary relations ${\mathcal{A}}(G,\leq)$ for a given graph $G$ and the given order $\leq$. The program ${\mathcal{P}}^{\prime}$ applies $\psi$ to $G_{t}$, $2d$ times during each time step, and thus the result of ${\mathcal{A}}$ on $(G_{t},\leq)$ is obtained after $\frac{f(n)}{2}$ steps. The change operations that occur during these steps are not applied to $G_{t}$ directly but rather stored in some additional relation. If some edge $e$ is changed multiple times, the stored change for $e$ is adjusted accordingly.

During the second phase the $\frac{f(n)}{2}$ stored change operations and the $\frac{f(n)}{2}$ change operations that happen during the next $\frac{f(n)}{2}$ steps are applied to the state after phase 1. To this end, it suffices for ${\mathcal{P}}^{\prime}$ to apply two changes during each time step by simulating two update steps of ${\mathcal{P}}$. Observe that ${\mathcal{P}}^{\prime}$ processes the changes in a different order than they actually occur. However, both change sequences result in the same graph. Since ${\mathcal{P}}$ can maintain $q$ for $f(n)$ changes, the program ${\mathcal{P}}^{\prime}$ can give the correct query answer for $q$ about $G_{t+f(n)}$ at the end of phase 2, that is, at time point $t+f(n)$.

The following auxiliary relations are used by thread $i$:

• •

a binary relation $\hat{E}_{i}$ that contains the edges currently considered by the thread,

• •

binary relations $\Delta^{+}_{i}$ and $\Delta^{-}_{i}$ that cache edges inserted and deleted during the first phase, respectively,

• •

a relation $\hat{R}_{i}$ for each auxiliary relation $R$ of ${\mathcal{P}}$ with the same arity,

• •

and a relation $C_{i}$ that is used as a counter: it contains exactly one tuple which is interpreted as the counter value, according to its position in the lexicographic order induced by $\leq$.

When thread $i$ starts its first phase at time point $t$, it sets $\hat{E}_{i}$ to $E_{t}$ and the counter $C_{i}$ to [math]; its other auxiliary relations are empty in the beginning. Whenever an edge $(u,v)$ is inserted (or deleted), $\hat{E}_{i}$ is not changed, $(u,v)$ is inserted into $\Delta^{+}_{i}$ (or $\Delta^{-}_{i}$)333If an edge $(u,v)$ with $(u,v)\in\Delta^{-}_{i}$ is inserted, it is instead deleted from $\Delta^{-}_{i}$, and accordingly for deletions of edges $(u,v)\in\Delta^{+}_{i}$., and the counter $C_{i}$ is incremented by one. The relations $\hat{R}_{i}$ are replaced by the result of applying their defining first-order formulas $2d$ times, as explained above.

When the counter value is at least $\frac{f(n)}{2}$, the thread enters its second phase and proceeds as follows. When an edge $(u,v)$ is inserted (or deleted), it applies this change and the change implied by the lexicographically smallest tuple in $\Delta^{+}_{i}$ and $\Delta^{-}_{i}$, if these relations are not empty: it simulates ${\mathcal{P}}$ for these changes using the edge set $\hat{E}_{i}$ and auxiliary relations $\hat{R}_{i}$, replaces the auxiliary relations accordingly and adjusts $\hat{E}_{i},\Delta^{+}_{i}$ and $\Delta^{-}_{i}$. Again, the counter $C_{i}$ is incremented. If the counter value is $f(n)$, the thread’s query result is used as the query result of ${\mathcal{P}}^{\prime}$, and the thread stops. All steps are easily seen to be first-order expressible.

So far we have seen how ${\mathcal{P}}^{\prime}$ can give the query answer from time step $f(n)$ onwards. For time steps earlier than $f(n)$ the approach needs to be slightly adapted as the program does not have enough time to simulate ${\mathcal{A}}$. The idea is that for time steps $t<f(n)$ the active domain is small and, exploiting the almost domain independence of $q$, it suffices to compute the query result with respect to this small domain extended by $c$ isolated elements, where $c$ is the constant from almost domain independence. The result on this restricted domain can afterwards be used to define the result for the whole domain.

Towards making this idea more precise, let $n_{0},b$ be such that $bn\geq f(n)$ for all $n\geq n_{0}$. We focus on explaining how ${\mathcal{P}}^{\prime}$ handles structures with $n\geq n_{0}$, as small graphs with less than $n_{0}$ nodes can be dealt with separately.

The program ${\mathcal{P}}^{\prime}$ starts a new thread at time $\frac{t}{2}$ for the graph $G_{\frac{t}{2}}$ with at most $\frac{t}{2}$ edges. Such a thread is responsible for providing the query result after $t$ time steps, and works in two phases that are similar to the phases described above. It computes relative to a domain $D_{t}$ of size $\min\{2t+c,n\}$, where $c$ is the constant from (almost) domain independence. The size of $D_{t}$ is large enough to account for possible new nodes used in edge insertions in the following $\frac{t}{2}$ change steps. The domain $D_{t}$ is chosen as the first $|D_{t}|$ elements of the full domain (with respect to $\leq$). The program ${\mathcal{P}}^{\prime}$ maintains a bijection $\pi$ between the active domain $D_{G}$ of the current graph $G$ and the first $|D_{G}|$ elements of the domain to allow a translation between $D_{G}$ and $D_{t}$.

The first phase of the thread for $t$ starts at time point $\frac{t}{2}+1$ and applies $\psi$ for $8bcd$ times during each of the next time steps. This simulation of ${\mathcal{A}}$ is finished after at most $\frac{(2t+c)b}{8bc}\leq\frac{t}{4}$ time steps, and therefore the auxiliary relations are properly initialised at time point $\frac{3t}{4}$.

In the second phase, starting at time step $\frac{3t}{4}+1$ and ending at time step $t$, the changes that occurred in the first phase are applied, two at a time. The thread is then ready to answer $q$ at time point $t$. Since at time $t$ at most $2t$ elements are used by edges, the almost domain independence of $q$ guarantees that the result computed by the thread relative to $D_{t}$ coincides with the $D_{t}$-restriction of the query result for $\pi(G_{t})$. The query result for $G_{t}$ is obtained by translating the obtained result according to $\pi^{-1}$, and extending it to the full domain. More precisely, a tuple $\bar{t}$ is included in the query result, if it can be generated from a tuple $\bar{t}^{\prime}$ of the restricted query result by replacing elements from $\pi^{-1}(D_{t})\setminus\text{adom}(G_{t})$ by elements from $V\setminus\text{adom}(G_{t})$ (under consideration of equality constraints among these elements). Again, all steps are easily seen to be first-order definable using the auxiliary relations from above.

The above presentation assumes a separate thread for each time point and each thread uses its own relations. These threads can be combined into one dynamic program as follows. Since at each time point at most $f(n)$ threads are active, we can number them in a round robin fashion with numbers $1,\ldots,f(n)$ that we can encode by tuples of constant arity. The arity of all auxiliary relations is incremented accordingly and the additional dimensions are used to indicate the number of the thread to which a tuple belongs.

5. Warm-up: 3-Colourability

In this section, we show that the 3-colourability problem

Problem 5.1**.**

3Col for graphs of bounded treewidth can be maintained in DynFO. Given an undirected graph,