Dynamic Complexity: From Regular Languages to Regular Path Queries - - PowerPoint PPT Presentation

(20 Years of)

Dynamic Complexity: From Regular Languages to Regular Path Queries

Thomas Schwentick AutoMathA 2015

Leipzig, May 2015 Lehrstuhl Logik in der Informatik

The general setting (1/2)

Input

t s t s

• Aux. data

yes Reach(s,t)? Reach(s,t)? no

t s

Reach(s,t)? yes

!(TZ) !

The general setting (2/2)

‚ In this talk,

– we consider graph queries and regular lan- guages – Graphs can be changed by insertions and deletions of edges — one at a time – The auxiliary data usually consists of relations

∗ There is a particular aux relation Q (the

“query relation”) yielding the current query result – The auxiliary relations are updated after each change – These updates are specified by first-order formulas

‚ We will often consider the (Boolean) reachability

query:

Definition: REACH

Input: Directed Graph G, vertices s, t Question: Is there a path from s to t in G?

!

Examples (1/2)

Example: Reachability under Insertion

1 2 3 4 5

G

1 2 3 4 5

T

INS(2,4)

1 2 3 4 5

G1

1 2 3 4 5

T 1

‚ Intention: Binary auxiliary relation T stores the transitive

closure of the edge relation

‚ Update formula φINS

T pa, b; x, yq:

– determines the pairs px, yq in T after insertion of

pa, bq to E,

–

def

“ T px, yq _ pT px, aq ^ T pb, yqq

✎ T does not suffice if edges can also be deleted

[Dong, Libkin, Wong 95]

Definition ‚ A dynamic program P “ pINIT, Φq

– updates the auxiliary relations via first-order update formulas from Φ,

• ne for every auxiliary relation and

possible change, and – initializes the auxiliary relations via initialization mapping INIT

‚ P maintains a query if one of its aux-

iliary relations always stores the query result

‚ DynFO

def

“

class of maintainable queries – under insertion and deletion of tu- ples, – with empty initialization, – starting from empty structures

!

Examples (2/2)

Example: Reachability in acyclic graphs under deletion

1 2 3 4 5 6 7 8 9

x y

G

a b u v

‚ For acyclic graphs, Reachability is in DynFO

[Dong, Su 93/95; Patnaik, Immerman 94/97]

‚ Challenge: how to know, whether after deletion of an edge pa, bq there

still exists a path p from x to y?

‚ There are two cases:

(1.) (a not reachable from x) or (y not reachable from b); or (2.) p must have a last edge pu, vq for which a can be reached from u

‚ Update formula φDEL

T pa, b; x, yq:

` T px, yq ^ pT px, aq _ T pb, yqq ˘ _ Du, vpT px, uq ^ Epu, vq ^ T pv, yqq^ pT pu, aq ^ T pv, aqq ^pu ­“ a _ v ­“ bq

Motivation & related approaches

‚ Why (first-order) logic as update language?

– Database theory view:

∗ SQL ” FO · ☞ ignoring counting, grouping, ... · Which recursive queries can be main-

tained without recursion?

· Which SQL queries can be maintained

which SQL fragments? – Complexity theoretic view:

∗ uniform AC0 ” FOp`, ˆq

[Barrington, Immerman, Straubing 90]

· AC0 is the “weakest complexity class”

– Logical view:

∗ Gain more insight into · the “dynamics” of descriptive complexity · the power of FO on finite structures ‚ A close relative: First-order incremental evalua-

tion systems (FOIES) – FOIES can add elements – set updates – queries

‚ History:

– FOIES: Dong, Su 1993 – DynFO: Patnaik, Immerman 1994

‚ A remote relative: dynamic algorithms

Research goals and questions

‚ Main Goal: Understand Dynamic Complexity ‚ Specific goals:

– Which queries are in DynFO?

∗ Is Reachability on directed graphs in DynFO?

– Which queries are not in DynFO?

∗ Methods for inexpressibility results? ‚ More generally:

– Which queries are in DynL? – Which DynL1 capture which logics L2 for

L1 ă L2? dynamically?

!

Contents

Introduction

Settings

Dynamic Complexity of Formal Languages Dynamic Complexity of Reachability Dynamic Complexity of Regular Path Queries Conclusion

The setting: some options

‚ Towards an exact setting of dynamic complexity,

there are many options to choose from: – Universe:

b fixed or l changing over time?

– Initialization:

∗ To be discussed soon

– Change operations:

b Insertions and deletions of single tuples l Insertions and deletions of sets of tuples l Updates defined by formulas/queries with

parameters – Logics:

∗ Many choices, some to be discussed

throughout the talk – Auxiliary data:

b Relations b Relations and functions l Other

– Query types:

b Boolean

☞ in this talk

l Arbitrary arity

☞ in general

– Semantics of update formulas:

b They define the aux data explicitly l They only define the changes (δ-semantics)

!

Initialization settings: all empty (main setting)

Input

t s

• Aux. data

Reach(s,t)? no

t s

Reach(s,t)? no

t s

Reach(s,t)? yes

‚ Starts from empty input and

empty auxiliary data

[Patnaik, Immerman 94/97]

‚ Quite generous:

– E.g.: a linear order can be de- fined incrementally

‚ DynFO

def

“ class of queries that

can be maintained with first-order logic in the main setting

‚ DynFO contains, e.g.

– Reachability on acyclic graphs – Reachability on undirected graphs

[Patnaik, Immerman 94/97]

– Reachability on embedded pla- nar graphs

[Datta, Hesse, Kulkarni 14]

– Bipartiteness

[Patnaik, Immerman 94/97]

– Tree isomorphism [Etessami 98]

!

Initialization settings: non-empty aux data

Input

t s

• Aux. data

Reach(s,t)? no

t s

Reach(s,t)? no

t s

Reach(s,t)? yes

‚ Starts from empty input and pre-

computed auxiliary relations – (depending on the size of the universe)

‚ It relates to circuit complexity

classes

‚ Arbitrary aux data:

Non-uniform DynFO

‚ Arithmetic (`, ˆ) as aux data:

DynFOp`, ˆq

‚ Various other subsettings depend-

ing on the power of the precompu- tation

!

Initialization Settings: non-empty input

Input

t s

• Aux. data

Reach(s,t)? yes

t s

Reach(s,t)? no

t s

Reach(s,t)? yes

‚ Starts from non-empty input and

precomputed aux data (depend- ing on the actual input)

✎ The combination of non-empty

input and empty-aux is not meaningful

‚ Emphasizes “maintainability” ‚ With PTIME precomputation, the

“non-empty aux” and “non-empty input” settings coincide

‚ With “logical aux initialization”, this

setting is weaker: – First-order logic can

∗ not build a linear order within

the aux data (in general)

∗ not maintain Tree Isomor-

phism, but ...

∗ ... can (still) maintain Reach-

ability on undirected graphs and Bipartiteness

[Grädel, Siebertz 12] !

Overview of settings

Aux-Initalization Empty initial structure Arbitrary initial structure Arbitrary Non-uniform DynFO

`, ˆ

DynFOp`, ˆq FOp`, ˆq Empty DynFO [Patnaik/Immerman 94/97] FO PTime DynFO` [Patnaik/Immerman 94/97] Logical

[Grädel/Siebertz 12] !

Plan

‚ As we want to maintain regular path queries:

– How to maintain membership in regular languages? – How to maintain Reachability? – How to combine the two?

!

Contents

Introduction Settings

Dynamic Complexity of Formal Languages

Dynamic Complexity of Reachability Dynamic Complexity of Regular Path Queries Conclusion

Dynamic complexity of formal languages: setting

Definition ‚ A word structure W representing a string w

consists of – a set of positions t1, ..., nu, – with an ordering ă, – and one unary relation Sσ for each alpha- bet symbol σ.

‚ For every i, there is at most one σ with i P Sσ

– In that case: Wi

def

“ σ

– Otherwise: Wi

def

“ ǫ ‚ The word represented by W is W1 ¨ ¨ ¨ Wn Example ‚ The word structures

–

b b c c

and –

b b c c

both represent the same string bbcc

‚ We allow two kinds of update operations:

– operation insσpiq, inserts i in Sσpiq and deletes it from all Sσ1piq, for σ1 ‰ σ, – operation delpiq, setting all Sσpiq to false.

‚ The linear order can not be changed! Example b c b c ‚ inscp2q , delp4q, insbp6q

(MM)

Strings: Results

Theorem [Patnaik, Immerman 94/97] ‚ Reg Ď DynFO ‚ All Dyck languages can be maintained in

DynFO

Definition ‚ DynProp:

– Queries that can be maintained in DynFO with quantifier-free formulas and aux rela- tions

‚ DynQF:

– Queries that can be maintained in DynFO with quantifier-free formulas and aux functions (and relations)

Theorem [Hesse 03] ‚ Reg Ď DynQF Theorem [Gelade, Marquardt, TS 09/12] ‚ With respect to languages: DynProp “ Reg Theorem [Gelade, Marquardt, TS 09/12] ‚ CFL Ď DynFO ‚ All Dyck languages can be maintained in DynQF Corollary ‚ DynProp Ĺ DynQF

!

Reg Ď DynProp

Proof sketch ‚ Let A “ pΣ, Q, δ, s, F q be a DFA for the regular language L ‚ To maintain membership of a word in L:

– we mainly use binary auxiliary relations Rp,q, for every pair p, q P Q – Intention: Rp,qpi, jq ” δ˚pp, wi`1 ¨ ¨ ¨ wj´1q “ q

Example

w1

¨ ¨ ¨

wi wi`1 ¨ ¨ ¨

¨ ¨ ¨

wj´1 wj

¨ ¨ ¨

wn

p q

wk´1 wk`1

p1 p1 Proof sketch (cont.) ‚ Update formula for insertions: φRp,q

insσ pk; i, jq

def

“ „ pi ă k ă jq^ ł

δpp1,σq“q1

pRp,p1pi, kq^Rq1,qpk, jq  _. . . ‚ Update formula for deletions: φRp,q

del

pk; i, jq

def

“ „ pi ă k ă jq ^ ł

p1

pRp,p1pi, kq ^ Rp1,qpk, jq  _ . . .

(MM)

DynProp Ď Reg

Proof sketch ‚ Let L P DynProp (for simplicity: no initialization) ‚ For a word w “ w1 ¨ ¨ ¨ wn consider the change sequence that inserts w1, w2, . . .

from left to right

Example

w1 w2 w3 w4 w5 w6 w7 w8 w9 w10 insw11p11q w11

Proof sketch (cont.) ‚ After each insertion all k-tuples of “empty” positions have the same atomic type (“e-

type”), for every k

‚ The number of e-types is finite (depending on the signature) ‚ The current e-type & the inserted symbol determine the new e-type ‚ The current e-type & the inserted symbol determine the (0-ary) query relation ➨ This is just an automaton! ‚ In the setting with initialization: build the word on an indiscernible set

!

Contents

Introduction Settings Dynamic Complexity of Formal Languages

Dynamic Complexity of Reachability

Dynamic Complexity of Regular Path Queries Conclusion

Some previous results on Reachability

DynFOC (with counting quantifiers)

‚ directed graphs [Hesse 01]

non-uniform DynFOr‘s (with modulo-2 counting quantifiers)

‚ directed graphs [Datta, Hesse, Kulkarni 14]

DynFO

‚ acyclic graphs

[Patnaik, Immerman 94/97]

DynQF

‚ undirected graphs [Hesse 03]

DynProp

‚ acyclic deterministic graphs [Hesse 03] ‚ Known lower bounds

– for DynFO

∗ REACH R unary DynFO

[Dong, Su ’98]

– for DynQF

∗ REACH R unary DynQF [Zeume, TS 13]

– for DynProp

∗ Alternating Reachability R DynProp

[Gelade, Marquardt, TS 09]

∗ REACH R binary DynProp

[Zeume, TS 13]

Reach in DynFO: main proof steps

Theorem [Datta, Kulkarni, Mukherjee, TS, Zeume 15] ‚ REACH P DynFO ‚ Main proof steps:

• 1. REACH can be reduced to matrix rank

– with a reduction type under which DynFO is closed – and matrix entries ď n (number of nodes)

• 2. Matrix rank can be maintained in DynFOp`, ˆq

– if entries are ď n – Thus: REACH P DynFOp`, ˆq

• 3. Domain independent queries in DynFOp`, ˆq are

in DynFO – And: REACH is domain independent

Step 1: Reducing REACH to matrix rank (1/2)

Proof ‚ Let G be a graph with n vertices and AG its adjacency matrix ‚ Important observation

(similarly: Laubner 11):

I ´ 1

nAG is invertible and

pI ´ 1 nAGq´1 “ I `

8

ÿ

i“1

p 1 nAGqi ‚ Crux: s, t-entry of this matrix is zero ð ñ t is not reachable from s ‚ We rather work with integer matrices: B

def

“ nI ´ AG ‚ pB´1qst “ 0 ð ñ t is not reachable from s ‚ pB´1qst “ 0 ð ñ Bx “ et has a solution with xs “ 0

✎ et: column vector with 1 in row t, oth-

erwise 0

Proof (cont.) ‚ B x et ¨ ˚ ˚ ˚ ˚ ˝ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ˛ ‹ ‹ ‹ ‹ ‚ ˆ ¨ ˚ ˚ ˚ ˚ ˚ ˝ x1 xs ¨ ¨ xn ˛ ‹ ‹ ‹ ‹ ‹ ‚ “ ¨ ˚ ˚ ˚ ˚ ˚ ˝ 1 ˛ ‹ ‹ ‹ ‹ ‹ ‚

has a solution with xs “ 0 if and only if

B1 x e1

t

¨ ˚ ˚ ˚ ˚ ˚ ˚ ˚ ˝ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ B ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ 1 ˛ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‚ ˆ ¨ ˚ ˚ ˚ ˚ ˚ ˝ x1 xs ¨ ¨ xn ˛ ‹ ‹ ‹ ‹ ‹ ‚ “ ¨ ˚ ˚ ˚ ˚ ˚ ˚ ˚ ˝ 1 ˛ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‚

has a solution at all

Step 1: Reducing REACH to matrix rank (2/2)

Proof B1 x e1

t

¨ ˚ ˚ ˚ ˚ ˚ ˚ ˚ ˝ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ B ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ 1 ˛ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‚ ˆ ¨ ˚ ˚ ˚ ˚ ˚ ˝ x1 xs ¨ ¨ xn ˛ ‹ ‹ ‹ ‹ ‹ ‚ “ ¨ ˚ ˚ ˚ ˚ ˚ ˚ ˚ ˝ 1 ˛ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‚ B1|e1

t

¨ ˚ ˚ ˚ ˚ ˚ ˚ ˚ ˝ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ B ¨ ¨ ¨ ¨ ¨ ¨ ¨ 1 ¨ ¨ ¨ ¨ ¨ 1 ˛ ‹ ‹ ‹ ‹ ‹ ‹ ‹ ‚ Proof (cont.) ‚ B1x “ e1

t has a solution

ð ñ e1

t P ColumnSpacepB1q

ð ñ rankpB1q “ rankpB1|e1

tq

‚ Since B is invertible,

rankpB1q “ rankpBq “ n

‚ Putting everything together: t is reachable from s ð ñ rankpB1|e1

tq “ n ` 1

ð ñ B1|e1

t has full rank

‚ Important:

– One edge change in G only yields one entry change in B1|e1

t

– All entries in B1|e1

t are of value ď n

Step 2: Maintaining matrix rank (1/3)

Proof (cont.) ‚ How to maintain rankpAq for an n ˆ n matrix with integer entries from t0, . . . , nu under single entry changes? ‚ Claim:

it suffices to maintain rankpA mod pq for at most n2 primes ď n3 – Clearly: rankpAq ě k ð

ñ A has a pk ˆ kq-submatrix A1 such that detpA1q ­“ 0

– Let us assume detpA1q ­“ 0, for some such submatrix

➨ detpA1q ď n!nn ➨ detpA1q has Opn log nq (binary) digits ➨ detpA1 mod pq “ detpA1q mod p ­“ 0,

for some of the first n2 primes p – Therefore: rankpAq ě k

ð ñ A has a pk ˆ kq-submatrix A1 with detpA1q ıp 0,

for some of the first n2 primes p

ð ñ rankpA mod pq ě k for some ... ➨ Claim ‚ We next show how to maintain rankpA mod pq

– This is done for n2 primes p in parallel (and: p ď n3)

Step 2: Maintaining matrix rank (2/3)

Proof (cont.) ‚ It remains to show how to maintain

rankpA mod pq for pn ˆ nq-matrices with entries ď n and p ď n3

‚ We give such an algorithm in [Datta et al. 15] but

an ICALP reviewer pointed us to an algorithm in [Frandsen&Frandsen 09] which can be adapted for our purposes – and is actually simpler than ours

‚ Both algorithms are based on Gaussian elimi-

nation

Proof (cont.) ‚ The idea is to maintain

– an invertible matrix U and – a matrix E in reduced row-echelon form such that UA “ E

‚ Reduced row-echelon form:

– The leading entry in every row is 1 – The column of such a leading entry is all- zero otherwise – Rows are sorted in a “diagonal” fashion

¨ ˚ ˚ ˝ 1 4 2 2 1 3 4 1 7 ˛ ‹ ‹ ‚ ‚ Thanks to

– rankpEq “ rankpUAq “ rankpAq and – the structure of E rankpAq “ number of non-zero rows of E

Step 2: Maintaining matrix rank (3/3)

Proof (cont.) U A E ¨ ˚ ˚ ˚ ˚ ˝ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ˛ ‹ ‹ ‹ ‹ ‚ ˆ ¨ ˚ ˚ ˚ ˚ ˝ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ˛ ‹ ‹ ‹ ‹ ‚ “ ¨ ˚ ˚ ˚ ˚ ˝ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ¨ ˛ ‹ ‹ ‹ ‹ ‚ ‚ A change of the i, j-entry of A can only affect the j-th column of E ‚ To bring E back to reduced echelon form:

(1) If new leading entries occur in column j: – keep the one with the maximum number of successive zeros in its row, and – set all other entries of column j to 0 by appropriate row operations (2) If a former leading entry of a row k is lost in column j (by the change in A or by (1)) – Take the next non-zero-entry on row k – Clean its column by appropriate row operations (3) If needed: move the (ď 2) rows whose leading entry has changed during (1) or (2) to their correct positions (and adapt them so that their leading entries are 1) (4) Update U accordingly

‚ These operations can be performed in constant parallel time (using ` and ˆ)

Step 3: From uniform DynAC0 to DynFO (1/2)

‚ We have shown: REACH P uniform DynAC0 ‚ Fact:

– uniform AC0 “ FOp`, ˆq

[Barrington, Immerman, Straubing 90]

– ... thus DynAC0 “ DynFOp`, ˆq... – ... and therefore: REACH P DynFOp`, ˆq

‚ How to get from DynFOp`, ˆq to DynFO? Illustration of DynFOp`, ˆq

inp 1 2 3 4 5 6 aux

` p1, 1, 2q p1, 2, 3q p2, 1, 3q

. . . . . .

ˆ p1, 1, 1q p1, 2, 2q p2, 1, 2q

. . . . . .

R1 R2

. . .

‚ Updates can use arithmetic

(from the very beginning)

Illustration of DynFO

inp 1 2 3 aux

` p1, 1, 2q p1, 2, 3q p2, 1, 3q ˆ p1, 1, 1q p1, 2, 2q p2, 1, 2q p3, 1, 3q p1, 3, 3q R1 R2

. . .

‚ Initially, updates can not use arithmetic ‚ DynFO ­“ DynFOp`, ˆq

– “Domain is even” R DynFO

‚ [Etessami ’98]: Arithmetic on active domain can be

built on the fly

‚ We show:

– For domain-independent queries this can be organized so that DynFO captures DynFOp`, ˆq – And thus: REACH P DynFO

Step 3: From uniform DynAC0 to DynFO (2/2)

‚ How to simulate a DynFOp`, ˆq pro-

gram P by a DynFO program P1?

‚ We sketch how to ensure that P1

can give correct answers as soon as

m “ ℓ2 elements of the domain are

activated – This can be done for every m in parallel – For non-square m some more care is needed

‚ Notation: Gi

def

“ graph after activation

• f the i-th element

‚ Phase 1: Until the first ℓ elements are activated

– Establish arithmetic on these elements

☞ as in [Etessami 98] ✎ For simplicity we assume the first m “ ℓ2 elements

are 1, . . . , m

‚ Phase 2: When element ℓ ` 1 is activated

– Start simulating P on vertex set t1, . . . , ℓu2 instead

• f t1, . . . , mu

∗ building an isomorphic copy G1

m of Gm

∗ Crux: Arithmetic on t1, . . . , ℓu is already there and

can be instantly lifted to t1, . . . , ℓu2

∗ Challenge: catch up! · All edges from Gℓ together with the ongoing

changes have to be dealt with when m is activated – For each change operation δ:

∗ insert (up to 3) edges of Gℓ into G1

m and do the re-

spective update operations and

∗ do the updates for δ ‚ At the end of phase 2, all edges of Gℓ are inserted and P1

can just give P’s answer on G1

m

Reachability in DynFO: Wrap-up

Theorem [Datta, Kulkarni, Mukherjee, TS, Zeume 15] ‚ REACH P DynFO Corollary [Datta, Kulkarni, Mukherjee, TS, Zeume 15] ‚ 2-SAT in DynFO ‚ Perfect matching in non-uniform DynFO ‚ What about regular path queries?

!

Contents

Introduction Settings Dynamic Complexity of Formal Languages Dynamic Complexity of Reachability

Dynamic Complexity of Regular Path Queries

Conclusion

Regular path queries

‚ Maintaining RPQs is now quite easy:

– Let G “ pV, Eq with edge labels from alphabet Σ – Let q be a regular expression and A an equivalent NFA with unique initial and final states s and t – There is a q-path from i to j in G ð

ñ

there is a path from pi, sq to pj, tq in the product graph G ˆ A, where

∗ pi, pq Ñ pj, qq is an edge in G ˆ A

def

ô i σ Ñj and p σ Ñq, for some σ P Σ

– Since a single change in G only induces ď |Q| changes in G ˆ A, and A is fixed, this yields a DynFO upper bound

‚ Generalizes to unions of conjunctive regular path queries

(UCRPQs)

‚ When q can change, it is a different story

!

Contents

Introduction Settings Dynamic Complexity of Formal Languages Dynamic Complexity of Reachability Dynamic Complexity of Regular Path Queries

Conclusion

How do small fragments of DynFO relate?

‚ Small fragments in the static world

FO UCQ “ D˚FO

@˚FO

UCQ CQ CQ FO UCQ “ D˚FO

@˚FO

UCQ CQ CQ Prop PropUCQ PropCQ PropCQ

‚ Small fragments in the dynamic world

DynFO DynD˚FO Dyn@˚FO DynCQ DynUCQ

“ “ “ “

DynCQ DynUCQ

“

DynQF DynProp DynPropUCQ DynPropCQ DynPropUCQ

“ “ “ “

DynPropCQ (non-empty input, PTIME aux) [Zeume, TS 14]

‚ Many static classes coincide in the dynamic world ‚ Linear hierarchy of classes! ‚ Further: FO Ď DynCQ

Conclusion

‚ Dynamic complexity is an interesting field that is not yet

well understood

‚ Many open problems:

– Which other problems can be placed in DynFO

∗ with the help of Reachability? ∗ with the Linear Algebra approach?

– Develop dynamic lower bound methods – Show that some (concrete, domain-independent) PTIME problem is not in DynFO – Show that some (concrete, domain-independent) PTIME problem is not in DynQF – Show that DynQF Ĺ DynFO – Show that REACH R DynProp – Can distance be maintained in DynFO?

Thank you!

References (1/2)

‚ Guozhu Dong and Jianwen Su. First-order incre-

mental evaluation of datalog queries. In DBPL 1993, pages 295–308, 1993

‚ Guozhu Dong and Jianwen Su. Incremental and

decremental evaluation of transitive closure by first-order queries. Inf. Comput., 120(1):101–106, 1995

‚ Sushant Patnaik and Neil Immerman. Dyn-fo:

A parallel, dynamic complexity class. In PODS 1994, pages 210–221, 1994

‚ Sushant Patnaik and Neil Immerman. Dyn-FO:

A parallel, dynamic complexity class. J. Comput.

• Syst. Sci., 55(2):199–209, 1997

‚ D. A. M. Barrington, N. Immerman, and

• H. Straubing. On uniformity within NC1. Journal
• f Computer and System Sciences, 41:274–306,

1990

‚ Guozhu Dong, Leonid Libkin, and Limsoon

• Wong. On impossibility of decremental recom-

putation of recursive queries in relational calculus and sql. In DBPL 1995, page 7, 1995

‚ Guozhu Dong and Jianwen Su. Arity bounds in

first-order incremental evaluation and definition

• f polynomial time database queries. J. Comput.
• Syst. Sci., 57(3):289–308, 1998

‚ Kousha Etessami. Dynamic tree isomorphism via

first-order updates. In PODS, pages 235–243. ACM Press, 1998

‚ William Hesse. The dynamic complexity of tran-

sitive closure is in DynTC0. In ICDT 2001, pages 234–247, 2001

‚ William Hesse. Dynamic Computational Com-

• plexity. PhD thesis, University of Massachusetts,

Amherst, 2003

‚ Volker Weber and Thomas Schwentick. Dynamic

complexity theory revisited. Theory Comput. Syst., 40(4):355–377, 2007

References (2/2)

‚ Wouter Gelade, Marcel Marquardt, and Thomas

• Schwentick. The dynamic complexity of formal
• languages. ACM Trans. Comput. Log., 13(3):19,

2012

‚ Bastian Laubner. The structure of graphs and

new logics for the characterization of Polynomial

• Time. PhD thesis, Humboldt University of Berlin,

2011

‚ Gudmund Skovbjerg Frandsen and Peter Frands

• Frandsen. Dynamic matrix rank. Theor. Comput.

Sci., 410(41):4085–4093, 2009

‚ Samir Datta, William Hesse, and Raghav Kulka-

• rni. Dynamic complexity of directed reachability

and other problems. In ICALP (1), pages 356– 367, 2014

‚ Samir Datta, Raghav Kulkarni, Anish Mukher-

jee, Thomas Schwentick, and Thomas Zeume. Reachability is in DynFO. To be presented at ICALP 15

‚ Erich Grädel and Sebastian Siebertz. Dynamic

• definability. In Alin Deutsch, editor, ICDT, pages

236–248. ACM, 2012

‚ Thomas Zeume and Thomas Schwentick. On

the quantifier-free dynamic complexity of reacha-

• bility. In Mathematical Foundations of Computer

Science 2013, pages 837–848, 2013

‚ Thomas Zeume and Thomas Schwentick. Dy-

namic conjunctive queries. In ICDT 2014, pages 38–49, 2014

‚ Thomas Zeume. The dynamic descriptive com-

plexity of k-clique. In MFCS 2014, 2014