Dynamic Complexity of Formal Languages

The paper investigates the power of the dynamic complexity classes DynFO, DynQF and DynPROP over string languages. The latter two classes contain problems that can be maintained using quantifier-free first-order updates, with and without auxiliary functions, respectively. It is shown that the languages maintainable in DynPROP exactly are the regular languages, even when allowing arbitrary precomputation. This enables lower bounds for DynPROP and separates DynPROP from DynQF and DynFO. Further, it is shown that any context-free language can be maintained in DynFO and a number of specific context-free languages, for example all Dyck-languages, are maintainable in DynQF. Furthermore, the dynamic complexity of regular tree languages is investigated and some results concerning arbitrary structures are obtained: there exist first-order definable properties which are not maintainable in DynPROP. On the other hand any existential first-order property can be maintained in DynQF when allowing precomputation.

💡 Research Summary

The paper investigates the expressive power of three dynamic complexity classes—DynFO, DynQF, and DynPROP—when applied to string, tree, and general relational structures. Dynamic complexity studies how the answer to a query can be updated efficiently after a small change (insertion or deletion) to the underlying data, using a fixed set of logical formulas that describe the update.

DynPROP is the most restrictive class: updates must be described by quantifier‑free first‑order formulas and no auxiliary functions are allowed. The authors prove that, even if arbitrary preprocessing is permitted, the set of languages maintainable in DynPROP coincides exactly with the regular languages. The proof builds a correspondence between the states of a deterministic finite automaton (DFA) for a regular language and the quantifier‑free update rules, showing that any non‑regular language would require a form of counting or unbounded memory that cannot be expressed without quantifiers or auxiliary functions. This result yields a clean lower bound for DynPROP and separates it from the more powerful classes DynQF and DynFO.

DynFO allows full first‑order updates, i.e., formulas with quantifiers. Using this additional expressive power, the authors demonstrate that every context‑free language (CFL) can be maintained in DynFO. The construction encodes a push‑down automaton’s stack as a collection of first‑order relations; each insertion or deletion of a symbol triggers a first‑order update that simulates a push, pop, or state transition. Because first‑order quantifiers can express the necessary existential checks over the stack, the dynamic program can keep the parsing tree consistent after each change, thereby preserving membership in any CFL.

DynQF sits between DynPROP and DynFO: it permits auxiliary functions but still restricts updates to quantifier‑free formulas. The paper shows that certain non‑regular languages, most notably the Dyck languages (balanced parentheses of arbitrary nesting depth), are maintainable in DynQF. The key observation is that the stack operations required by Dyck languages can be implemented as auxiliary functions (e.g., “next‑open” and “matching‑close”), while the actual update of the Boolean answer remains quantifier‑free. Consequently, the presence of functions expands the class beyond regular languages without needing full quantification.

The authors also extend the analysis to regular tree languages. By representing a deterministic tree automaton’s state assignment as first‑order relations on the tree nodes, they show that both DynFO and DynQF can maintain any regular tree language under node insertions and deletions. This mirrors the string case: regular tree languages are exactly those recognizable by a finite set of local constraints, which can be updated with first‑order formulas.

Finally, the paper addresses arbitrary relational structures. It proves that there exist first‑order definable properties that cannot be maintained in DynPROP, reinforcing the earlier regular‑language characterization. Conversely, any existential first‑order property (∃FO) can be maintained in DynQF when preprocessing is allowed, because the existential witness can be stored in an auxiliary function and the quantifier‑free update can simply adjust the witness after each modification.

In summary, the work establishes a hierarchy of dynamic complexity classes: DynPROP = regular languages, DynQF ⊃ regular languages (including Dyck and other specific CFLs), and DynFO ⊇ all context‑free languages. It also provides concrete dynamic programs for tree automata and clarifies the role of preprocessing and auxiliary functions in expanding maintainability. These results deepen our understanding of how logical restrictions shape the feasibility of dynamic algorithms for language‑recognition tasks.