Abstract State Machines and Computationally Complete Query Languages

1. Abstract State MachinesandComputationally Complete Query Languages Andreas Blass, U Michigan Yuri Gurevich, Microsoft Research & U Michigan Jan Van den Bussche, U Limburg

2. Outline • Databases and queries • Query languages: • whilenew, whilenewsets • ASMs • Notions of polynomial time • Comparisons

3. Relational databases • Database schema = Finite set S of relation names with associated arities • DatabaseB over S = Finite structure over S • Finite domain D of atomic values • For each R S, a k-ary relation RB onD

4. Relational databases • Database schema = Finite set S of relation names with associated arities • DatabaseB over S = Finite structure over S • Finite domain D of atomic values • For each R S, a k-ary relation RB onD arity associated to R in S

5. Relational databases • Database schema = Finite set S of relation names with associated arities • DatabaseB over S = Finite structure over S • Finite domain D of atomic values • For each R S, a k-ary relation RB onD E.g. Graph: arity associated to R in S

6. Relational databases • Database schema = Finite set S of relation names with associated arities • DatabaseB over S = Finite structure over S • Finite domain D of atomic values • For each R S, a k-ary relation RB onD E.g. Graph: arity associated to R in S 1 2 3 4

7. Relational databases D 1 2 3 4 E (1,2) (2,3) (2,4) (3,4) • Database schema = Finite set S of relation names with associated arities • DatabaseB over S = Finite structure over S • Finite domain D of atomic values • For each R S, a k-ary relation RB onD E.g. Graph: arity associated to R in S 1 2 3 4

8. Queries • General definition of query: a (partial, computable) mapping Q • from databases • to relations (over a common schema) (of a common arity)

9. Queries • General definition of query: a (partial, computable) mapping Q • from databases • to relations • Q(B) is the answer to the query Q on database B. (over a common schema) (of a common arity)

10. Queries • General definition of query: a (partial, computable) mapping Q • from databases • to relations • Q(B) is the answer to the query Q on database B. • Arity 0: {( )} or { } Boolean query (over a common schema) (of a common arity)

11. Queries • General definition of query: a (partial, computable) mapping Q • from databases • to relations • Q(B) is the answer to the query Q on database B. • Arity 0: {( )} or { } Boolean query E.g. On a graph: • Give all pairs of nodes that are targets of a common source. (over a common schema) (of a common arity)

12. Queries • General definition of query: a (partial, computable) mapping Q • from databases • to relations • Q(B) is the answer to the query Q on database B. • Arity 0: {( )} or { } Boolean query E.g. On a graph: • Give all pairs of nodes that are targets of a common source. • Is f(m)=2000? (over a common schema) (of a common arity)

13. Queries • General definition of query: a (partial, computable) mapping Q • from databases • to relations • Q(B) is the answer to the query Q on database B. • Arity 0: {( )} or { } Boolean query E.g. On a graph: • Give all pairs of nodes that are targets of a common source. • Is f(m)=2000? (over a common schema) (of a common arity) number of edges in graph

14. Queries • General definition of query: a (partial, computable) mapping Q • from databases • to relations • Q(B) is the answer to the query Q on database B. • Arity 0: {( )} or { } Boolean query E.g. On a graph: • Give all pairs of nodes that are targets of a common source. • Is f(m)=2000? (over a common schema) (of a common arity) arbitrary computable function on N

15. The consistency criterion • The answer of a query on a database can depend only on information that is logically contained in that database. • If his an isomorphism B B, then h is also an isomorphism Q(B)  Q(B).

16. Query languages • In practice: SQL • first-order logic + counting, summation, … E.g. Give all pairs of nodes that are targets of a common source:

17. Query languages • In practice: SQL • first-order logic + counting, summation, … E.g. Give all pairs of nodes that are targets of a common source: select E1.target, E2.target from E E1, E E2 where E1.source = E2.source

18. Query languages • In practice: SQL • first-order logic + counting, summation, … E.g. Give all pairs of nodes that are targets of a common source: select E1.target, E2.target from E E1, E E2 where E1.source = E2.source (x,y) z(E(z,x)  E(z,y))

19. Expressiveness of first-order logic (FO) 2000 0 if m is even if m is odd f(m) = • Many useful queries are expressible in FO. • But many others are not: • Connectivity: Is the graph connected? • Is f(m)=2000, where

20. Expressiveness of first-order logic (FO) 2000 0 if m is even if m is odd f(m) = • Many useful queries are expressible in FO. • But many others are not: • Connectivity: Is the graph connected? • Is f(m)=2000, where • (parity query)

21. Towards a complete language: while • Make FO basis of a small programming language for working with relations: • relation variables (typed by fixed arities) • operations on relations provided by FO • assignment: X(x1,…,xj)(x1,…,xj)

22. Towards a complete language: while • Make FO basis of a small programming language for working with relations: • relation variables (typed by fixed arities) • operations on relations provided by FO • assignment: X(x1,…,xj)(x1,…,xj) relation variable of arity j

23. Towards a complete language: while • Make FO basis of a small programming language for working with relations: • relation variables (typed by fixed arities) • operations on relations provided by FO • assignment: X(x1,…,xj)(x1,…,xj) FO-formula over db relations and relation variables

24. Towards a complete language: while • Make FO basis of a small programming language for working with relations: • relation variables (typed by fixed arities) • operations on relations provided by FO • assignment: X(x1,…,xj)(x1,…,xj) • sequential composition

25. Towards a complete language: while • Make FO basis of a small programming language for working with relations: • relation variables (typed by fixed arities) • operations on relations provided by FO • assignment: X(x1,…,xj)(x1,…,xj) • sequential composition • while-loops: while  do … od

26. Towards a complete language: while • Make FO basis of a small programming language for working with relations: • relation variables (typed by fixed arities) • operations on relations provided by FO • assignment: X(x1,…,xj)(x1,…,xj) • sequential composition • while-loops: while  do … od FO-sentence

27. Towards a complete language: while • Make FO basis of a small programming language for working with relations: • relation variables (typed by fixed arities) • operations on relations provided by FO • assignment: X(x1,…,xj)(x1,…,xj) • sequential composition • while-loops: while  do … od • Chandra & Harel [1982]

28. Example while-program • Connectivity query: Seen(2); Path(2)  E; whilePath  Seen   do Seen  Path; Path  Path  (x,z) y(Path(x,y)  E(y,z)); od.

29. Example while-program • Connectivity query: Seen(2); Path(2)  E; whilePath  Seen   do Seen  Path; Path  Path  (x,z) y(Path(x,y)  E(y,z)); od. • Parity query:

30. Example while-program • Connectivity query: Seen(2); Path(2)  E; whilePath  Seen   do Seen  Path; Path  Path  (x,z) y(Path(x,y)  E(y,z)); od. • Parity query: Not!

31. A complete language: whilenew • S. Abiteboul & V. Vianu [1988] • Allow introduction of new domain elements in the computation. • New operator:

32. A complete language: whilenew • S. Abiteboul & V. Vianu [1988] • Allow introduction of new domain elements in the computation. • New operator: new

33. A complete language: whilenew X R a b a c d b f g c a b c d f g • S. Abiteboul & V. Vianu [1988] • Allow introduction of new domain elements in the computation. • New operator: new X(3) newR(2)

34. A complete language: whilenew X R a b a c d b f g c a b c d f g • S. Abiteboul & V. Vianu [1988] • Allow introduction of new domain elements in the computation. • New operator: new X(3) newR(2) • Every partial computable query can be programmed in whilenew.

35. Parity in whilenew • Easy to check parity of a set Sequipped with a successor relation: Even(0) true; Visit(1)  first element of S ; whileVisit   do Even  Even; Visit  succ(x)Visit(x) od.

36. Parity in whilenew • Make a set S of new elements, one for each edge: S0 newE; S  3(S0);

37. Parity in whilenew • Compute a successor relation on S: Impossible!

38. Parity in whilenew • Compute the tree T of all m! successor relations, where m = |S|: T new  ; Seen  ; Extend  r,xTr  Sx; whileExtend   do X  newExtend; T  T  p3X; succ  succ  p1,3X; Seen  Seen  n,x nXn,x,n  xx  Seenn,x; Extend  n,xn  p3X  Sx  Seen(n,x od.

39. We can’t do better! • whilenew-PSPACE: class of whilenew-programs running in polynomial space. Theorem: [Abiteboul–Vianu 1991] The parity query cannot be done in whilenew-PSPACE. • Intuition: In whilenew you cannot make arbitrary choices (recall consistency criterion) • Instead of choosing one successor relation, we must work with them all. • whilenew-PTIME: class of whilenew-PSPACE-programs running in polynomial time.

40. BGS • Blass, Gurevich, Shelah [1996]: • How can we formalize algorithms that never have to make arbitrary choices? • What can such algorithms still do in polynomial time? • Instantiation of ASMs for expressing database queries.

41. BGS ASMs • Universe: HF(D) • every x D is in HF(D); • every finite set of elements of HF(D) is itself in HF(D). • Infinite, but at any point only finitely many sets are “active”. • Set-theoretic static functions: • pairing • bounded set-construction • forall do (parallel ASMs)

42. Connectivity with a BGS-ASM ifMode0then forallxDdoFrontierxx enddo, Mode  1 endif, ifMode= 1 then forallxDdo Reached(x) := Reached(x) Frontier(x), Frontier(x) := {y D z  Frontier(x): E(z,y)  y  Reached(x) Frontier(x)} enddo, Halt := {Frontier(x)x D} = endif.

43. BGS-PTIME • BGS-PTIME: class of BGS-ASMs • running for at most polynomially many steps • constructing at most polynomially many sets • “Choiceless polynomial time”

44. BGS-PTIME versus whilenew-PTIME? • Structure In: • •  • • •  • n 2n

45. BGS-PTIME versus whilenew-PTIME? • Structure In: • There is a PTIME BGS-program that outputs: • •  • • •  • n 2n

46. BGS-PTIME versus whilenew-PTIME? • Structure In: • There is a PTIME BGS-program that outputs: • true on every In with neven; • •  • • •  • n 2n

47. BGS-PTIME versus whilenew-PTIME? • Structure In: • There is a PTIME BGS-program that outputs: • true on every In with neven; • falseodd. • •  • • •  • n 2n

48. BGS-PTIME versus whilenew-PTIME? • Structure In: • There is a PTIME BGS-program that outputs: • true on every In with neven; • falseodd. • (Just construct all red subsets of even size.) • •  • • •  • n 2n

49. BGS-PTIME versus whilenew-PTIME? • Structure In: • There is a PTIME BGS-program that outputs: • true on every In with neven; • falseodd. • (Just construct all red subsets of even size.) Theorem: There is no such PSPACE whilenew-program (let alone PTIME). • •  • • •  • n 2n

50. Sets versus lists • BGS programs can construct sets. • whilenew programs can only construct lists. • operator new works tuple- ( list-) based. • Lists are ordered; sets can be unordered. • If you want to simulate something unordered by something ordered, you have to work with all orders. • (Recall parity in whilenew.) • BGS-PTIME strictly encompasses whilenew-PTIME.