Download while new - UHasselt

Abstract State Machines
and
Computationally Complete Query Languages
Andreas Blass, U Michigan
Yuri Gurevich, Microsoft Research & U Michigan
Jan Van den Bussche, U Limburg
Outline
• Databases and queries
• Query languages:
– whilenew, whilenewsets
– ASMs
• Notions of polynomial time
• Comparisons
Relational databases
• Database schema = Finite set S of relation names
with associated arities
• Database B over S = Finite structure over S
– Finite domain D of atomic values
– For each R  S, a k-ary relation RB on D
Relational databases
• Database schema = Finite set S of relation names
with associated arities
• Database B over S = Finite structure over S
– Finite domain D of atomic values
– For each R  S, a k-ary relation RB on D
arity associated to R in S
Relational databases
• Database schema = Finite set S of relation names
with associated arities
• Database B over S = Finite structure over S
– Finite domain D of atomic values
– For each R  S, a k-ary relation RB on D
E.g. Graph:
arity associated to R in S
Relational databases
• Database schema = Finite set S of relation names
with associated arities
• Database B over S = Finite structure over S
– Finite domain D of atomic values
– For each R  S, a k-ary relation RB on D
arity associated to R in S
E.g. Graph:
1
2
3
4
Relational databases
• Database schema = Finite set S of relation names
with associated arities
• Database B over S = Finite structure over S
– Finite domain D of atomic values
– For each R  S, a k-ary relation RB on D
arity associated to R in S
E.g. Graph:
1
2
3
4
D
1
2
3
4
E
(1,2)
(2,3)
(2,4)
(3,4)
Queries
• General definition of query: a (partial, computable)
mapping Q
– from databases (over a common schema)
– to relations (of a common arity)
Queries
• General definition of query: a (partial, computable)
mapping Q
– from databases (over a common schema)
– to relations (of a common arity)
Q(B) is the answer to the query Q on database B.
Queries
• General definition of query: a (partial, computable)
mapping Q
– from databases (over a common schema)
– to relations (of a common arity)
Q(B) is the answer to the query Q on database B.
• Arity 0: {( )} or { }  Boolean query
Queries
• General definition of query: a (partial, computable)
mapping Q
– from databases (over a common schema)
– to relations (of a common arity)
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.
Queries
• General definition of query: a (partial, computable)
mapping Q
– from databases (over a common schema)
– to relations (of a common arity)
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?
Queries
• General definition of query: a (partial, computable)
mapping Q
– from databases (over a common schema)
– to relations (of a common arity)
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?
number of edges in graph
Queries
• General definition of query: a (partial, computable)
mapping Q
– from databases (over a common schema)
– to relations (of a common arity)
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?
arbitrary computable function on N
The consistency criterion
• The answer of a query on a database can depend
only on information that is logically contained in
that database.
If h is an isomorphism B  B, then h is also an
isomorphism Q(B)  Q(B).
Query languages
• In practice: SQL
 first-order logic + counting, summation, …
E.g. Give all pairs of nodes that are targets of a
common source:
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
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))
Expressiveness of first-order logic (FO)
• Many useful queries are expressible in FO.
• But many others are not:
– Connectivity: Is the graph connected?
– Is f(m)=2000, where
f(m) =
2000
if m is even
0
if m is odd
Expressiveness of first-order logic (FO)
• Many useful queries are expressible in FO.
• But many others are not:
– Connectivity: Is the graph connected?
– Is f(m)=2000, where
f(m) =
(parity query)
2000
if m is even
0
if m is odd
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)
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
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
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
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
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
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]
Example while-program
• Connectivity query:
Seen(2)  ;
Path(2)  E;
while Path  Seen   do
Seen  Path;
Path  Path  (x,z) y (Path(x,y)  E(y,z));
od.
Example while-program
• Connectivity query:
Seen(2)  ;
Path(2)  E;
while Path  Seen   do
Seen  Path;
Path  Path  (x,z) y (Path(x,y)  E(y,z));
od.
• Parity query:
Example while-program
• Connectivity query:
Seen(2)  ;
Path(2)  E;
while Path  Seen   do
Seen  Path;
Path  Path  (x,z) y (Path(x,y)  E(y,z));
od.
• Parity query: Not!
A complete language: whilenew
• S. Abiteboul & V. Vianu [1988]
• Allow introduction of new domain elements in the
computation.
• New operator:
A complete language: whilenew
• S. Abiteboul & V. Vianu [1988]
• Allow introduction of new domain elements in the
computation.
• New operator: new
A complete language: whilenew
• S. Abiteboul & V. Vianu [1988]
• Allow introduction of new domain elements in the
computation.
• New operator: new
X(3)  new R(2)
X
a
c
f
b
d
g
R
a
b
c
a
c
f
b
d
g
A complete language: whilenew
• S. Abiteboul & V. Vianu [1988]
• Allow introduction of new domain elements in the
computation.
• New operator: new
X(3)  new R(2)
X
a
c
f
b
d
g
R
a
b
c
a
c
f
b
d
g
• Every partial computable query can be
programmed in whilenew.
Parity in whilenew
1 Easy to check parity of a set S equipped with a
successor relation:
Even(0)  true;
Visit(1)   first element of S ;
while Visit   do
Even  Even;
Visit  succ(x)Visit(x)
od.
Parity in whilenew
2 Make a set S of new elements, one for each edge:
S0  new E;
S  3(S0);
Parity in whilenew
3 Compute a successor relation on S:
Impossible!
Parity in whilenew
3 Compute the tree T of all m! successor relations,
where m = |S|:
T  new  ;
Seen  ;
Extend  r,xTr  Sx;
while Extend   do
X  new Extend;
T  T  3X; succ  succ  1,3X;
Seen  Seen  n,x n Xn,x,n
 xx  Seenn,x;
Extend  n,xn  3X  Sx  Seen(n,x
od.
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-PSPACEprograms running in polynomial time.
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.
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)
Connectivity with a BGS-ASM
if Mode  0 then
forall x  D do Frontierx  x enddo,
Mode  1
endif,
if Mode 1then
forall x  D do
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.
BGS-PTIME
• BGS-PTIME: class of BGS-ASMs
– running for at most polynomially many steps
– constructing at most polynomially many sets
• “Choiceless polynomial time”
BGS-PTIME versus whilenew-PTIME?
• Structure In :
• •  •
• •  •
n
2n
BGS-PTIME versus whilenew-PTIME?
• Structure In :
• •  •
• •  •
n
2n
• There is a PTIME BGS-program that outputs:
BGS-PTIME versus whilenew-PTIME?
• Structure In :
• •  •
• •  •
n
2n
• There is a PTIME BGS-program that outputs:
– true on every In with n even;
BGS-PTIME versus whilenew-PTIME?
• Structure In :
• •  •
• •  •
n
2n
• There is a PTIME BGS-program that outputs:
– true on every In with n even;
– false
odd.
BGS-PTIME versus whilenew-PTIME?
• Structure In :
• •  •
• •  •
n
2n
• There is a PTIME BGS-program that outputs:
– true on every In with n even;
– false
odd.
(Just construct all red subsets of even size.)
BGS-PTIME versus whilenew-PTIME?
• Structure In :
• •  •
• •  •
n
2n
• There is a PTIME BGS-program that outputs:
– true on every In with n even;
– false
odd.
(Just construct all red subsets of even size.)
Theorem: There is no such PSPACE whilenewprogram (let alone PTIME).
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.
The language whilenewsets
• Theory of object-based query languages, studied
late 80s – early 90s.
• Operator new from whilenew is really tuple-new.
We need also a set-new!
 Language whilenewsets
set-new
Y2  set-new R2
R
a
a
b
b
c
c
c
d
e
e
d
e
f
g
set-new
Y2  set-new R2
R
a
a
b
b
c
c
c
d
e
e
d
e
f
g
set-new
Y2  set-new R2
R
a
a
b
b
c
c
c
d
e
e
d
e
f
g
set-new
Y2  set-new R2
Y
a a
b a
c b
R
a
a
b
b
c
c
c
d
e
e
d
e
f
g
Equivalence results
• whilenewsets and BGS can simulate each other.
• Simulation:
– linear step overhead
– polynomial space overhead
 BGS-PTIME  whilenewsets-PTIME  whilenew-PTIME
Concluding remarks
• ASMs and query languages are quite related, and
share the common concern of computation on the
“logical” level.
• Purely mathematically,
– basic parallel ASMs
– whilenew
are essentially the same thing.
• ASMs clearly win from query languages in flexibility,
appeal to practitioners, developed philosophy, and
people like Yuri and Egon.
• whilenew never “escaped” database theory!
• Challenge: the Web (querying XML, WWW, …)