Deskrpitive Komplexitätstheorie und Datenbanken

Relationale Datenbanken
Tabellen von Elementen
E:
Komplexitätstheorie
Datenbanken und Deskriptive Komplexität
Helmut Veith
Technische Universität München
A
B
=========
1
2
2
1
3
4
2
3
1
4
3
1
1
1
1
2
4
3
SQL: Anfragen über Tabellen
Relationale Datenbanken
Tabellen haben verschiedene Breite: Stelligkeit
Einfaches Datenbankschema: Signatur
Tabellennamen und Stelligkeit
zB E:2, D:3, F:4
Queries / Anfragen:
• SQL verwendet Namen für Spalten:
select A,B from E
where A=B
• Relationenalgebra:
A=B(E)
• Prädikatenlogik 1. Stufe:
E(x,y) ∧ x = y
Relationale Datenbanken
Relationale Algebra =
SQL ohne Aggregatfunktionen =
Prädikatenlogik 1. Stufe (First Order Logic)
Datenbanken & Queries
Datenbankschema / Signatur
E1:r1, E2: r2, ..., Ek: rk
Datenbank / (Relationale) Struktur:
1. Universum U
2. E1 ⊆ Ur1, ..., Ek ⊆ Urk
Query = Anfrage an die Datenbank
Generizität: Resultat unabhängig von interner
Datendarstellung.
Boolesche Queries und
Entscheidungsprobleme
• Queries mit Ja/Nein Antworten
• zB Ergebnistabelle leer/nicht leer
Eingaben von Entscheidungsproblemen können als
relationale Strukturen modelliert werden.
Beweis: einfache Übersetzungen.
zB Graphen
Wir wissen: First Order Logic kann in LOGSPACE
ausgewertet werden.
Datenbankabfragen komplexitätsbeschränkt.
Datenbank-Semantik ebenfalls beschränkt.
Boolesche Queries entsprechen dann den Queries
im Instance/Query Schema von Garey/Johnson
zB Ist der Graph 3-färbbar ?
1
Komplexität von Queries
Komplexität von Queries
Für eine Query Language untersuchen wir:
SQL / Relationale Algebra / FO
• Datenkomplexität:
Komplexität in der Grösse der Datenbank
• Ausdruckskomplexität:
Komplexität in der Grösse der Query
• Kombinierte Komplexität:
Komplexität in der Grösse der Query und der
Datenbank
• Datenkomplexität: in LOGSPACE
Komplexität in der Grösse der Datenbank
• Ausdruckskomplexität: PSPACE-vollständig
Komplexität in der Grösse der Query
• Kombinierte Komplexität: PSPACE-vollständig
Komplexität in der Grösse der Query und der
Datenbank
Reduktion von QBF auf FO Ausdruckskomplexität.
FO/SQL und LOGSPACE
Datenkomplexität:
FO ⊆ LOGSPACE:
jeder Quantor entspricht einer for-Schleife.
fixer Algorithmus.
Formel konstanter Grösse
FO LOGSPACE:
Erreichbarkeit nicht ausdrückbar!
FO
0/1 Law
Für ein fixes Schema T, und eine FO Boolean
Query f, sei
• Vn die Menge aller Strukturen mit Universum der
Grösse n, und
• Fn die Menge aller Strukturen mit Universum der
Grösse n, für die Query f wahr ist.
Dann gilt:
lim n ∞ |Fn | / |Vn | ist 0 oder 1.
D.h. nur asymptotisch wahre oder falsche
Eigenschaften definierbar. (ohne Beweis)
LOGSPACE
Query / Eigenschaft / Problem EVEN:
Universum hat gerade Anzahl von Elementen
Trivialerweise in LOGSPACE.
Limit existiert nicht.
Wegen 0/1 Law nicht in FO.
Auch Erreichbarkeit / REACH nicht in FO.
Datalog
Datenbanksprache in Anlehnung an Prolog
“Logic Programming Style”
Typisches Datalog Programm:
R(x,y) :E(x,y)
R(x,y) :R(x,z), E(z,y)
Extensionales Schema (Input): E
Intensionales Schema (Output): R
Was berechnet R ?
Datalog nicht einfacher als NL.
2
Circuit Evaluation in Datalog
Ist Datalog genau PTIME ?
Extensionales Schema:
A(x,y,z):
Gatter x ist AND von y und z.
O(x,y,z):
Gatter x ist OR von y und z.
I(x):
Input-Gatter x hat Wert 1.
Datalog Auswertung ist in PTIME.
Warum ?
Intensionales Schema:
V(x):
Gatter x hat Wert 1.
Kann jede polynomiell berechenbare Boolesche
Query in Datalog ausgedrückt werden ?
Datalog Programm:
V(x) :I(x).
V(x) :A(x,y,z), V(y), V(z).
V(x) :O(x,y,z), V(y).
V(x) :O(x,y,z), V(z).
Nein! Auch Datalog hat ein 0/1 Law.
Wie kann man EVEN über dem leeren Schema in
Datalog ausdrücken ? Offenbar nicht möglich.
Datalog nicht einfacher als PTIME !
Negation in Datalog:
Stratifiziertes Datalog
Negation von extensionalen Relationen immer erlaubt.
Rekursion durch Negation ist verboten:
A(x) :- NOT B(x)
B(x) :- NOT A(x)
Spezielle KI-Semantiken erforderlich.
Stratifizierte Negation:
d.h. keine Rekursion durch Negation möglich.
F(x,y) :- NOT E(x,y)
zB
Berechnet das Komplement eines Graphen.
< und succ
succ kann aus < berechnet werden:
far(x,y)
:x < z, z < y
succ(x,y) :x < y, NOT far(x,y)
< kann aus succ berechnet werden:
x<y
:succ(x,y)
x<y
:succ(x,z), z < y
Datalog mit Ordnung ist ein eindeutiger Begriff.
Nicht generische Queries !
EVEN in Datalog ?
Generizität: Elemente des Universums können nur
durch Relationen unterschieden werden
Mit Hilfsrelation succ(x,y) “x+1 = y” über dem
Universum Unterscheidung möglich:
Last(x)
First(x)
Odd(x)
Even(x)
Odd(x)
Result
::::::-
NOT succ(x,y)
NOT succ(z,x)
Last(x)
E(x,y), Odd(y)
E(x,y), Even(y)
First(x), Even(x).
Polynomielle Arithmetik
Universum der Groesse n stellt Zahlen 0...n-1 dar.
Vektor (a,b) stellt Zahlen 0..n2-1 dar.
k-Vektor stellt Zahlen 0.. nk-1 dar.
Lineare Ordnung auf k-Vektoren:
lexikographisch definiert. (Programm
Übung)
Kleiner(a,b,c,d) :- a < c.
Kleiner(a,b,c,d) :- a=c, b < d.
3
Datalog captures PTIME
Sei f eine Boolesche Query. Dann gilt
f ist in PTIME
gdw
f ist in Datalog mit Ordnung ausdrückbar.
“Languages that capture complexity classes.”
Korollar: Datenkomplexität ist PTIME.
Fragments of Datalog
Unter Voraussetzung einer linearen Ordnung gelten
folgende Äquivalenzen:
Datalog captures PTIME
Beweisidee:
Eingabe Graph G = (V,E)
Datalog Programm beschreibt Konfigurationen
der Turing Maschine.
Extensionale Relationen:
Sq(x,t): “Zustand q zur Zeit t”
H(x,t): “Kopf zur Zeit t am Ort x”
Sa(x,t): “Symbol a zur Zeit t am Ort x”
x,t: Variablenvektoren: drücken Zahlen polynomieller Grösse
aus.
Ausdruckskomplexität
Datalog = PTIME
Ausdruckskomplexität: EXPTIME
Stratifiziertes Datalog = PTIME
Datalog = PTIME
Stratifiziertes Datalog = PTIME
Datalog mit Tail Rekursion = NL
Datalog mit deterministischer Tail Rekursion = L
Ausdruckskomplexität: EXPTIME
Datalog mit Tail Rekursion = NL
Ausdruckskomplexität: PSPACE
Datalog mit deterministischer Tail Rekursion = L
Ausdruckskomplexität: PSPACE
Korollar: Datenkomplexität in derselben Klasse.
Second Order Logic
Logik 2. Stufe.
Quantifizierung nicht nur über Knoten, sondern
auch über Mengen und Relationen:
∃ R,G,B ∀ x,y:
(R(x) ∨ G(x) ∨ B(x)) ∧
¬ (R(x) ∧ G(x)) ∧ ¬ (R(x) ∧ B(x)) ∧ ¬ (G(x) ∧ B(x)) ∧
( E(x,y)
¬ (R(x) ∧ R(y)) ∧ ¬ (B(x) ∧ B(y)) ∧ ¬ (G(x) ∧ G(y)) )
3-Colorability
Kombinierte Komplexität i.a. gleich Ausdruckskomplexität.
Second Order Logic
Hamiltonian Path
∃ R: “R ist lineare Ordnung” ∧
∀ x,y: “succ(x,y)” → E(x,y)
“R ist lineare Ordnung”
∀ x,y,z : (R(x,y) ∧ R(y,z) → R(x,z)) ∧
(R(x,y) → ¬ R(y,x)) ∧
(R(x,y) ∨ R(y,x))
“succ(x,y)”:
R(x,y) ∧ ¬∃z. R(x,z) ∧ R(z,y)
4
Fagin’s Theorem
Fagin 1974:
NP = existentielle Second Order Logic.
(ohne Voraussetzung einer Ordnung.)
Beweisidee:
: Guess and Check Algorithmus.
: PTIME Maschine zur Überprüfung
Datalog Programm mit Ordnung
SOL Formel definiert Ordnung und
simuliert Datalog Programm.
PTIME = NP ?
Zeige, dass PTIME nur durch Logiken mit Ordnung
ausgedrückt werden kann.
P verschieden von NP.
5