Lösung 2

Theoretische Informatik
Prof. Dr. Juraj Hromkovič
http://www.ita.inf.ethz.ch/theoInf16
Departement Informatik
Lösungsvorschläge – Blatt 2
Zürich, 7. Oktober 2016
Lösung zu Aufgabe 4
(a) Wir geben zunächst für jedes n ∈ N − {0} ein Pascal-Programm an, das wn erzeugt:
begin
k:= n;
k:= 2*k;
j:= 1;
for i:=1 to
j:=2*j;
l:= 1;
for i:=1 to
l:=2*l;
for i:=1 to
write(0);
for i:=1 to
write(1);
end.
k do
j do
l do
l do
Dieses Programm berechnet zunächst k = 2n und verwendet dann eine Schleife, um
2n
j = 2k = 22n zu berechnen. In einer weiteren Schleife berechnet es dann l = 2j = 22 .
2n
Anschliessend gibt es in der dritten Schleife l = 22 Nullen und in der vierten Schleife
2n
l = 22 Einsen aus.
Wenn wir die Operation ^ für die Exponentiation zulassen (dies ist nicht ursprüngliche
Pascal-Syntax, wir wollen diese Notation aber im Folgenden verwenden, um die
Programme lesbarer darzustellen), erzeugt auch das folgende Programm das Wort
wn :
begin
k:= n;
k:= 2^(2^(2*k));
for i:=1 to k do
write(0);
for i:=1 to k do
write(1);
end.
Der einzige Teil des Maschinencodes dieses Programms, der von wn abhängt, ist
die Darstellung von n in der zweiten Zeile. Der restliche Programmcode hat eine
konstante Länge. Also ist die binäre Länge dieses Programms dlog2 (n + 1)e + c für
eine Konstante c.
Damit lässt sich die Kolmogorov-Komplexität von wn von oben abschätzen durch
K(wn ) ≤ dlog2 (n + 1)e + c ≤ log2 n + c + 1
für eine Konstante c. Man beachte hierfür, dass für jedes n ≥ 1 gilt, dass dlog2 (n +
1)e ≤ 1 + log2 n: Falls n keine Zweierpotenz ist, gilt dlog2 (n + 1)e = dlog2 (n)e, und
für n = 2m ist dlog2 (n + 1)e = m + 1 = 1 + log2 n.
2n
Die Länge von wn ist |wn | = 2 · 22 . Also gilt log2 |wn | = 22n + 1. Wir können diese
Gleichung jetzt verwenden, um log2 n in Abhängigkeit von |wn | auszudrücken, es gilt
log2 |wn | = 22n + 1 ⇐⇒ 22n = log2 |wn | − 1
⇐⇒ 2n =
q
log2 |wn | − 1
1
log2 (log2 |wn | − 1)
2
⇐⇒ log2 n = log2 log2 (log2 |wn | − 1) − 1 .
⇐⇒ n =
Es ergibt sich somit eine obere Schranke von
K(wn ) ≤ log2 log2 (log2 |wn | − 1) + c
für die Kolmogorov-Komplexität von wn .
(b) Wir definieren die Zahlenfolge y1 , y2 , y3 , . . . durch yn = 23n für alle n ∈ N − {0}.
√
Offenbar gilt yn < yn+1 und n = log2 3 yn für alle n. Die Binärdarstellung von yn ist
eine Eins gefolgt von 3n Nullen, also Bin(yn ) = 1(0)3n .
Nun konstruieren wir für jedes yn ein Pascal-Programm Cn , das Bin(yn ) erzeugt:
begin
k:= 3*n;
write(1);
for j:=1 to k do
write(0);
end.
In diesem Programm wird zuerst der Wert k = 3n berechnet und die Ausgabe 1
erzeugt. Anschliessend werden in der for-Schleife entsprechend viele Nullen in der
Ausgabe erzeugt. Der Teil des Maschinencodes von Cn , der von yn abhängt, ist
nur die Darstellung von n. Der Maschinencode für die Darstellung des restlichen
Programmteils hat nur eine konstante Länge, während die binäre Kodierung von n
die Länge dlog2 (n + 1)e ≤ log2 n + 1 hat. Damit folgt
K(yn ) ≤ log2 n + c
√
≤ dlog2 log2 3 yn e + c
für eine Konstante c.
Lösung zu Aufgabe 5
Offenbar erzeugen alle drei Programme An , Bn und Cn jeweils die Ausgabe wn . Die
oberen Schranken für die Kolmogorov-Komplexität von wn ergeben sich aus der Länge der
Darstellung der jeweiligen Programme im Maschinencode. Der einzige Teil der Programme,
dessen Darstellungslänge variabel ist, ist die Angabe des Parameters n. Dieser benötigt
eine Länge von dlog2 (n + 1)e. Der Rest der Programme ist für alle n gleich, hat also eine
konstante Länge.
Im Programm An kommt der Parameter n zweimal vor, also hat sein Maschinencode eine
Länge von 2dlog2 (n + 1)e + cA für eine Konstante cA . Damit liefert An eine obere Schranke
von
K(wn ) ≤ 2dlog2 (n + 1)e + cA
für die Kolmogorov-Komplexität von wn . Das Programm Bn enthält den Parameter n
einmal, liefert also eine Schranke von
K(wn ) ≤ dlog2 (n + 1)e + cB
für eine Konstante cB . Das Programm Cn enthält den Parameter n dreimal, liefert also
eine Schranke von
K(wn ) ≤ 3dlog2 (n + 1)e + cC
für eine Konstante cC .
Lösung zu Aufgabe 6
Das Intervall [2n , 2n+1 − 1] enthält 2n natürliche Zahlen der binären Länge n + 1. Weil die
binären Darstellungen dieser Zahlen alle mit einer führenden 1 beginnen, kann man sie
identifizieren mit den Wörtern der Länge n über dem binären Alphabet Σbool . Es bleibt
also zu zeigen, dass es unter den 2n Wörtern der Länge n mindestens 2n − 2n−i Wörter w
gibt mit K(w) ≥ n − i.
Die Anzahl der unterschiedlichen Programme der Länge kleiner als n − i ist höchstens
n−i−1
X
2j = 2n−i − 2 ,
j=1
da es für jede Länge nicht mehr Maschinencodes als nichtleere Binärstrings geben kann.
Also gibt es maximal 2n−i − 2 Wörter w mit K(w) < n − i. Für die Anzahl m der Wörter
w in (Σbool )n mit K(w) ≥ n − i gilt also
m ≥ 2n − (2n−i − 2) > 2n − 2n−i .