black box algorithmen hartmut klauck universität frankfurt ss 05 20.5

Black Box Algorithmen

Hartmut KlauckUniversität FrankfurtSS 05

20.5.

bs(f) vs. C(f)

Wir wissen schon, dass C(f) und D(f) polynomiell verwandt sind

Auch bs(f) und D(f)? Für s(f) immer noch unbekannt! Theorem 10.5

C(f) · bs(f) s(f) Kommentar: Damit sind D(f), C(f), bs(f)

polynomiell äquivalent Man erhält immer untere Schranken für D(f)

mit bloß polynomiellem „Verlust“ über bs(f)

Beweis

Beobachtung:Wenn (für f und x) B ein minimaler

Block von Variablen ist, den zu flippen den Funktionswert ändert,dann ist s(f)¸ |B|.

Denn: Sei x‘ wie x mit B geflipptDann ändert auf x‘ jede Variable in B

den Funktionswert, d.h. s(f,x‘) ¸ |B|

Beweis

Idee: für jedes x konstruiere ein kurzes Zertifikat

Wenn für alle x ein Zertifikat der Länge s(f)bs(f,x) existiert, gilt C(f)· s(f) bs(f)

Sei x gegeben, B1,..., Bk Blöcke wie in Def mit k=bs(f,x)

Blöcke seien minimal, d.h. |Bi|· s(f)

Setze alle Variablen in [i Bi wie in x Klar: Monom c mit s(f)bs(f,x) Variablen

Beweis

Ist c ein korrektes Zertifikat? Sei x‘ eine Eingabe mit f(x‘) f(x) und x‘

konsistent mit c Sei Bk+1 die Menge der Variablen, wo x, x‘

unterschiedlich Klar: auf x ist f für Bk+1 sensitiv

Aber Bk+1 ist disjunkt von den Variablen in c, denn dort sind x und x‘ gleich!

Also ist bs(x)>k, Widerspruch!

Monotone Funktionen

f heisse monoton, wenn Ändern eines Eingabebits von 0 auf 1 den Funktionswert nicht von 1 auf 0 ändern kann

Theorem 10.6Für monotone f gilt:

s(f)=bs(f)=C(f) Beweis: Übung

Damit gilt insgesamt:

D· C2(f)· s(f)2(f)bs2(f)· bs4(f) Kann verbessert werden zu

D(f)· bs3(f) Unterschiede s, bs und bs, D sind

manchmal quadratisch

Insbesondere giltlog bs(f) = (log C(f)) = (log D(f))

Anwendung: PRAMs

PRAM: Parallel Random Access Machine

Definition 10.7 Eine PRAM mit p Prozessoren besteht aus p

Registermaschinen [RAM], die über zusätzliche Lese und Schreiboperationen auf einen gemeinsamen Speicher zugreifen können

In einer EREW PRAM [exclusive read/write] muß sichergestellt sein, daß dieselbe Speicherzelle nie gleichzeitig von zwei Prozessoren benutzt wird

In einer CREW PRAM [concurrent read/exclusive write] dürfen mehrere Prozessoren eine Zelle lesen

In einer CRCW PRAM darf gleichzeitig gelesen und geschrieben werden, Schreibkonflikte werden z. B. nach Prozessornummer gelöst

Minimale Rechenzeit

Die Laufzeit einer PRAM ist wie üblich definiert

Dabei ist ein Schritt ein (paralleler) Lesezugriff plus interne Berechnung plus Schreibzugriff

Insbesondere interessieren uns hier die minimalen Laufzeiten, die bei beliebig grosser Anzahl von Prozessoren möglich sind

Beobachtung 1

Jede Boolesche Funktion auf n Variablen kann in konstanter Zeit auf einer CRCW PRAM berechnet werden Nichtuniforme Berechnung Verwende DNF, n Prozessoren pro Term Alle Prozessoren eines Terms lesen die

entsprechenden Literale, und wer ein falsche Literal findet, schreibt 0 in eine mit 1 initialisierte Zelle

Dann schreiben alle Prozessoren eines Terms der zu 1 evaluierte eine 1 in eine mit 0 initialisierte Zelle

Beobachtung 2

Auf EREW PRAMs brauchen alle Funktionen, die von n Variablen abhängen Zeit (log n)Betrachte Simulation durch

Schaltkreise mit konstantem Ingrad der Gatter, solche haben bei n Eingaben (log n) Tiefe

Was ist mit CREW?

Theorem 10.8CREW PRAMs für Boolsche

Funktionen f brauchen (log D(f)) Zeit (bei beliebig vielen Prozessoren)

Drei Lemmata

Lemma 10.9 Ein CREW Algorithmus braucht (log s(f)) Zeit,

d.h. Wenn die Zeit T beträgt, ist s(f)· constT

Lemma 10.10 Ein CREW Algorithmus braucht (log bs(f)) Zeit

Lemma 10.11 Eine CREW PRAM kann eine Funktion in Zeit

O(log D(f)) berechnen (d.h. kann einen Entscheidungsbaum in der Zeit auswerten).

Zusammen ergibt sich das Theorem

Erste Idee 10.9

PRAM akkumuliert Information über die Eingabe

Pro Schritt wird Information über Eingabe verdoppelt (bisherige Information eines Prozessors plus Information einer Speicherzelle=bisherige Information anderer Prozessor

Daher Zeit log s(f) ? Problem: OR braucht nur Zeit <log n

Parallele Berechnung von OR

Erster Ansatz:In Schritt 1 liest Prozessor i Zellen 2i,

2i-1 und schreibt ODER nach iIteration mit n/2 Eingaben und

ProzessorenNach genau log n Schritten fertig

Parallele Berechnung von OR Schneller: Fibonacci Zahlen F0=0, F1=1, Fi+2=Fi+Fi+1 F2t¼

Verwende Schreibzugriff für weitere Akkumulation von Ergebnissen

Beispiel: OR, wenn wir wissen, dass nur max. eine Eingabe 1 ist: Alle lesen ihre Eingabe, schreiben in eine

gemeinsame Zelle, wenn diese 1 ist Daher EREW Algorithmus, Zeit 1

Parallele Berechnung von OR Verwende lokale Speicherzellen Y(i) Globale Zellen M(i) Eingabe X(i) sei in M(i) Berechnungsschritt t für Prozessor i:

Schreibe Y(i) Ç M(i+F2t) nach Y(i) [Leseschritt plus intern]

Wenn i>F2t+1, und Y(i)=1, dann schreibe 1 nach M(i- F2t+1)

Fertig nach t Schritten für n=F2t+1 Daher Zeit t für >>2t Eingaben, bzw. Zeit c log n mit c<1

Analyse

Klar: EREW Algorithmus, Zeit t Korrektheit:

Nach Schritt t istY(i)=OR(x(i),…, X(i+F2t-1))M(i)=OR(x(i),…, X(i+F2t+1-1))Beweis per Induktion

Schlussfolgerung: Lemma 10.9 ist nicht trivial!

Lemma 10.11

Zeigen zuerst obere Schranke Lemma 10.11

Eine CREW PRAM kann eine Funktion in ZeitO(log D(f)) berechnen (d.h. kann einen Entscheidungsbaum in der Zeit auswerten)

Eingabe: x, dazu soll Entscheidungsbaum T simuliert werden

Algorithmus

Repräsentiere Baum als Array von Pointern zu den Söhnen

Array sei in gemeinsamem Speicher [Setup] Prozessor i liest für Knoten i die zugehörige

Variable x(j(i)) und streicht die nicht zutreffende Kante im Array [CREW]

Übrig: Pfad der Länge d<D(f) im Array als Kette von Pointern

Verwende Pointer Jumping, um in Zeit O(log d) das Blatt/Ende des Pfades zu finden

Pointer Jumping

Prozessor i liest Pointer p(i) in Zelle i, liest Zelle p(i) und schreibt Ergebnis nach i

Pfadlänge halbiert sich pro Schritt!

Insgesamt

Erhalten PRAM Algorithmus, der f in Zeit O(log D(f)) berechnet, CREW ist und soviel Prozessoren braucht, wie der Entscheidungsbaum für f Knoten hat

CREW Zeit ist also O(log D(f))=O(log bs(f))

Noch zu zeigen: auch (log bs(f))