Lösungen zu den ¨Ubungen — Mathematik für Informatiker

Lösungen zu den Übungen — Mathematik für Informatiker
Komplexität und Berechenbarkeit
PostCorProbSolver::usage =
"’PostCorProbSolver’ ist ein verfänglich falscher Name. Das Programm löst
das Post´sche Korrespondenzproblem nicht für alle Instanzen auf den Array
’strArr1’ und ’strArr2’. Es kann lediglich bis zu einer vorgegebenen
Rekursionstiefe ’break’ versuchen, eine Lösung zu finden. Wird dann keine
Lösung gefunden, bricht das Programm ab und versucht sein Glück auf einem
anderen Weg falls vorhanden. Ohne diesen Mechanismus läuft das Programm
Gefahr, aufgrund der Halbentscheidbarkeit des zugrundeliegenden Problems,
nicht zu terminieren.
Mit geeigneten Heuristiken kann das Programm verfeinert werden - viel
Spass dabei! ";
Aufgabe 1
a)
nn
b)
n!
c)
|{0, 1}n | = 2n ,
|{0, 1}m | = 2m .
2n
Zahl der Funktionen = (2m )
d)
= 2m2
n
(* Testlauf *)
f nicht invertierbar, wenn m < n. Sei also nun m ≥ n:
arr1 = {"01", "0", "100"};
arr2 = {"11", "010", "00"};
PostCorProbSolver[arr1, arr2, 100]
Zahl der Funktionen = 2m (2m − 1) . . . (2m − 2n + 1)
Aufgabe 2
a)
Problem gelöst mit Lösungsstring: "010001100"
Indexfolge= {2, 3, 1, 3}
Berechenbar, denn tan(π/4) = 1. Also π = 4 arctan(1).
Mit d. Taylorreihe von arctan kann π beliebig genau berechnet werden.
b)
Man weiss nicht, og g berechenbar ist.
c)
h ist berechenbar, auch wenn wir h nicht kennen.
c)
Aufgabe 6 Reguläre Grammatik:
G = ({S, T }, {0, 1}, P, S)
P = {S → 1T,
T → 0T,
T → 1T,
T → 0}
Aufgabe 3 Nein, denn es gibt überabzählbar viele reelle Zahlen, aber nur abzählbar viele Programme (Turingmaschinen).
Aufgabe 4
a)
b)
Das Beispielprogramm zeigt, dass es eine TM gibt, die
nach endlicher Zeit hält, wenn die Instanz des Problems
lösbar ist. Ist die Instanz nicht lösbar, so hält die TM,...oder
auch nicht! ⇒Das Problem ist halbentscheidbar.
Hier gibt es eine Lösung: Die Reihe der Paare: 2,3,1,3
Die Folge lautet dann: 010001100
Regulärer Ausdruck: 1(0|1)∗ 0
(* Der BackTracker *)
BackTrack[index_, break_, strArr1_, strArr2_, solStr1_,
solStr2_, soltab_] :=
Module[{i, RetVec, RetStr, concat1, concat2, len, solv},
(* Vorinitialisierung *)
RetVec = {False, "", "", soltab};
If[index < break,
(* Alle Möglichkeiten durchgehen *)
For[i = 1, i <= Length[strArr1] && RetVec[[1]] == False ,
i++,
concat1 = solStr1 <> strArr1[[i]];
concat2 = solStr2 <> strArr2[[i]];
Aufgabe 7
len = Min[StringLength[concat1],
StringLength[concat2]];
(* ist Zwischenlösung gültig? *)
If[StringTake[concat1, len] == StringTake[concat2, len],
(*Indexfolge merken*)
solv = Append[soltab, i];
(* Ist es die endgültige Lösung ? *)
If[ concat1 == concat2,
RetVec = {True, concat1, concat2, solv},
(*Sonst Backtracker rekursiv aufrufen*)
RetVec =
BackTrack[index + 1, break, strArr1, strArr2,
concat1, concat2, solv];
(*Wenn Kein Ergebnis -> Backtrack!*)
If[RetVec[[1]] == False,
RetVec = {False, solStr1, solStr2, soltab}] ;
];
];
];
a)
Der Nachweis der Korrektheit von Turingmaschinen umfasst das Finden von Endlosschleifen. Dieses ist jedoch
unentscheidbar (Halteproblem). Nach der Church’schen
These ist das Halteproblem auch für C-Programme unentscheidbar. Damit ist dann auch die (schwierigere) Verifikation von C-Programmen unentscheidbar.
b)
Betrachte die Menge alle C-Programme, die nur Zeilen
der Form
printf(”<TEXT_i>”);
enthalten. Diese Menge ist zwar unendlich gross, jedoch
ist die Korrektheit entscheidbar, denn die Programme
enthalten keine Schleifen und Verzweigungen. Damit muß
zum Nachweis der Korrektheit nur geprüft werden, ob die
Konkatenation aller Texte gleich dem Text ist, der ausgedruckt werden soll und ob die im Text vorkommenden
Zeichen erlaubte Zeichen in Strings sind.
Aufgabe 8 Zu zeigen ist, dass R überabzählbar unendlich
ist.
Beweis:
Ann.: R ist abzählbar. Dann ist auch [0, 1) abzählbar und es
existiert eine Folge (xi ) mit [0, 1) = {xi | i ≥ 1}
];
RetVec
];
(* Das Prog *)
PostCorProbSolver[strArr1_, strArr2_, break_] := Module[{ret},
ret =
Block[{$RecursionLimit = Infinity},
z.B. könnte die Folge so anfangen:
BackTrack[0, break, strArr1, strArr2, "", "", {}]];
If[ret[[1]], Print["Problem gelöst mit Lösungsstring: ", ret[[2]]],
Print["Halbentscheidbarkeit hat durchgeschlagen!"]];
x1 = 0,1111111111111111111111...
If[ret[[1]], Print["Indexfolge= ", ret[[4]]]];
]
x2 = 0,2222222222222222222222...
1
x3
x4
x5
x6
x7
..
.
=
=
=
=
=
0,1212121212121212121212...
0,1234567890123456789012...
0,1231231231231231231231...
0,3149567452095874532490...
0,0985666255245348345302...
Aufgabe 13 Die Wahrscheinlichkeit für zwei aufeinanderfolgende Einsen in der Folge ist p2 und für zwei aufeinanderfolgende Nullen ist sie (1 − p)2 . Sei n = |(an )n∈{0,1} | und
m = |(bn )n∈{0,1} | die Länge der Ergebnis-Folge (bn )n∈{0,1} .
Dann gilt
dann wählen wir eine Zahl 0,2121111..., die sicher kein Ele1
1
2
2
ment dieser Folge ist, was im Widerspruch zur Annahme der m = 2 (1 − p − (1 − p) ) · n = 2 · 2 · p(1 − p) · n = p(1 − p) · n.
Abzählbarkeit von [0, 1) steht.
Allgemein lautet der Beweis:
Computeralgebra
x1 = 0, a11 , a12 , a13 , ...
x2 = 0, a21 , a22 , a23 , ...
x3 = 0, a31 , a32 , a33 , ...
..
.
mit aij ∈ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
Sei nun (y) := 0, b1 b2 b3 b4 ... wie folgt definiert:
1 falls aii 6= 1
bi :=
2 falls aii = 1
Aufgabe 14
a)
fac[n_] :=
For[{a
a = a
If[n <
]
fac::usage = "fac[n] computes the factorial of n"
b)
Fac[0] := 1;
Fac[n_] := n * Fac[n - 1] /; n > 1
Fac[_] := Print["Not defined"];
damit sind alle Folgen (xi ) von (y) verschieden. Laut Annahme
Fac::usage
existiert aber eine Folge xn mit (y) = (xn ), was zum Widerspruch führt.
Folgerung: Die Menge R \ Q der irrationalen Zahlen ist über- Numerik
abzählbar.
Aufgabe 16
Aufgabe 9 Die Menge ist leer. (Siehe Gödel´sche Sätze)
In[5]:= Table[PNorm[{1,2,3,4,5},p], {p,1,50}]
Out[5]=
{15., 7.4162, 6.0822, 5.59365, 5.36022,
...
5.00001, 5.00001, 5., 5., 5., 5., 5., 5.}
Aufgabe 10 Da bei einem Modul m höchstens m verschiedene Zahlen in der Folge auftreten können, muss sich spätestens
nach m Folgengliedern eine Zahl wiederholen. Dann wiederholt
sich aber zwingend die ganze Folge, denn bei einem linearen
Kongruenzgenerator hängt die Zahl xn nur von der Vorgängerzahl xn−1 ab. Bei gleichem xn−1 ist damit auch xn gleich. Die
Folge wiederholt sich also periodisch.
Das Gesagte gilt übrigens für alle Generatoren, bei denen xn
nur von der Vorgängerzahl xn−1 oder einer anderen Zahl vor
xn abhängt.
Um bei festem Modul m die Periode zu verlängern, kann man
zur Bestimmung von xn eine Funktion f wählen, die von zwei
Vorgängerzahlen abhängt, z.B. xn = f (xn−1 , xn−2 ). Die maximale Periodendauer ist dann m(m − 1).
Aufgabe 18
EquiPoints[a_, b_, n_, f_] := Module[{j, x},
x = N[a + j (Abs[b - a]/(n - 1))];
Table[{x, f[x]}, {j, 0, n - 1}]
]
ChebyshevPoints[a_, b_, n_, f_] := Module[{k, x},
x = N[-Cos[(2k - 1) Pi/( 2n)]];
t = (a + b)/2 + (b - a) x /2;
Table[{t, f[t]}, {k, 1, n}]
]
PolyIntPol[n_,
Module[{i,
If[bEqui,
PntVec =
PntVec =
Aufgabe 12
b)
c)
= "Fac[n] computes the factorial of n"
PNorm[x_,p_] := N[(Sum[Abs[x[[i]]]^p, {i,1,Length[x]}])^(1/p)]
Table[PNorm[{1,2,3,4,5},p], {p,1,50}]
Zufallszahlen
a)
Module[{a, b},
= 1; b = n}, b > 1, b--,
* b];
0, Print["Not defined"], a]
Die Folge 101010101010 . . . ist absolut symmetrisch, aber
nicht zufällig, denn die Bits sind nicht unabhängig.
a_, b_, f_, bEqui_:True, Ext_:1] :=
j, m, y, g, x, s, t, PntVec},
EquiPoints[a, b, n, f],
ChebyshevPoints[a, b, n, f]];
m = Table[If[i == 0,1,(Part[PntVec, j + 1, 1])^i ],
{j, 0, n - 1} , {i, 0,n - 1}];
y = Table[Part[PntVec, j + 1, 2], {j, 0, n - 1}];
g = LinearSolve[m, y];
Die Häufigkeit aller Buchstabenpaare (11, 10, 01, 00)
zählen und testen ob sie gleich häufig sind. Die Folge
101010101010 . . . würde diesen Test offensichtlich nicht
bestehen. Allgemein kann man die Häufigkeiten aller nBit-Blöcke testen. Die relative Häufigkeit jedes der 2n nBit-Blöcke sollte nahe bei 1/2n liegen, denn dann sind die
Blöcke gleichverteilt.
func[x_] := g . Table[x^i, {i, 0, n - 1}];
Print["Koeffizientenmatrix:\n", N[MatrixForm[g]], "\nPlot:"];
s = Plot[{f[x], func[x]}, {x, a - Ext, b + Ext},
DisplayFunction -> Identity];
t = ListPlot[PntVec, DisplayFunction -> Identity,
PlotStyle -> PointSize[0.015]];
Show[{s, t}, DisplayFunction -> $DisplayFunction, PlotRange -> All];
Die Folge der Zahlen xi besitzt eine Periode, die höchstens die Länge n − 2 hat, wobei n der Modul ist. Die
Periode kann nicht die Länge n haben, denn die Zahlen 0
und 1 können in der Folge nicht vorkommen. Andernfalls
wäre die Periode gleich 1. Die Folge der Zufallsbits hat
dann eine Periode von höchstens n − 2.
]
PolyIntPol::usage = "PolyIntPol computes the polynomial interpolation of ’n’
points on a given function ’f’ in a specified interval between ’a’ and
’b’.The points are calculated equidistant in the interval with ’bEqui’ = True
(Default:=True), or with the Chebyshev-abscissa with ’bEqui’ = False. You can
extend the picture on the x-axis with the factor ’Ext’(Default:=1.0). Prototype:
PolyIntPol[n,a,b,f,bEqui,Ext]"
2
Koeffizienten fuer eine Linearkombination der
Basisfunktionen f[[1]],...,f[[k]]."
Aufgabe 19
a)
Wertetab = ReadList["ueb2neu.dat",Number, RecordLists -> True]
f[x_] := Exp[-x^2];
PolyIntPol[11, -2, 10, f]
ftab =
f4[x_]
f3[x_]
f2[x_]
f1[x_]
f0[x_]
20
15
10
xtab = Transpose[Wertetab][[1]]
ytab = Transpose[Wertetab][[2]]
5
-2
LeastSq[xtab,ytab,ftab]
2
4
6
8
Show[ListPlot[Transpose[{xtab,ytab}], DisplayFunction -> Identity],
Plot[{Sum[a[[i]]ftab[[i]][x], {i,1,Length[ftab]}],f[x]+3000},
{x,Min[xtab],Max[xtab]},
DisplayFunction -> Identity],
DisplayFunction -> $DisplayFunction,
Prolog -> PointSize[.01]
]
10
-5
-10
Aufgabe 20
a)
{f0,f1,f2,f3,f4}
:= x^4
:= x^3
:= x^2
:= x
:= 1
Display["ueb2neu.eps",%20,"EPS"]
Wenn man aus dem Modul aus Aufgabe 18 den Parameter func“
löscht, so ist dieser nach Beenden der Funktion PolyIntPol“” noch
”
bekannt. Die Funktion:
g[x_] := Sum[a[[i]]ftab[[i]][x], {i,1,Length[ftab]}]
Sumqu = Sum[(g[xtab[[i]]] - ytab[[i]])^2, {i,1,Length[xtab]}]
Max[Table[Abs[f[i] - func[i]], {i, -2, 10, 12/99}]]
bringt dann die Lösung: 1.39222
b)
c) Plot von Originalfunktion, Punkten und Lösungsfunktion:
Für diese Aufgabe wird der Funktionsaufruf “Max“ in die Funktion “PolyIntPol“ eingebunden:
40000
PolyIntPol[n_, a_, b_, f_, bEqui_:True, Ext_:1] :=
20000
Module[{i, j, m, y, g, func, max, x, s, t, PntVec},
If[bEqui,
PntVec = EquiPoints[a, b, n, f],
PntVec = ChebyshevPoints[a, b, n, f]];
m = Table[
10
If[i == 0, 1, (Part[PntVec, j + 1, 1])^i], {j, 0, n - 1}, {i, 0,
n - 1}];
y = Table[Part[PntVec, j + 1, 2], {j, 0, n - 1}];
-20000
g = LinearSolve[m, y];
15
20
25
30
35
40
45
func[x_] := g.Table[x^i, {i, 0, n - 1}];
-40000
Print["Koeffizientenmatrix:\n", N[MatrixForm[g]], "\nPlot:"];
(*Funktionserweiterung :*)
Print["Maximumnorm auf 100 Stützstellen: " ,
Max[Table[Abs[f[i] - func[i]], {i, a, b, Abs[b - a]/99}]]];
s = Plot[{f[x], func[x]}, {x, a - Ext, b + Ext},
DisplayFunction -> Identity];
t = ListPlot[PntVec, DisplayFunction -> Identity,
PlotStyle -> PointSize[0.015]];
Aufgabe 24
Show[{s, t}, DisplayFunction -> $DisplayFunction, PlotRange -> All];]
und anschließend zweimal aufgerufen mit
1 3
x
2
+ 23 x2
und
s1 (x) = − 21 x3 + 23 x2
a)
s0 (x) =
b)
Weil die zweite Ableitung an beiden Randpunkten nicht Null ist.
• Äquidistante Interpolation (bEqui:=False)
Ergebnis: Maximumnorm auf 100 Stützstellen: 1.39222
• Tschebyscheff-Interpolation (bEqui:=True)
Ergebnis: Maximumnorm auf 100 Stützstellen: 0.191125
Aufgabe 22
a)
Aufgabe 26
f[x_] := -(x-10)(x-20)(x-30)(x-40)+.5 x^3
Plot[f[x],{x,0,50}]
Wertetab = Table[{x,f[x]+6000 Random[]}, {x,8,46,1}]
ListPlot[Wertetab]
LeastSq[x_,y_,f_] := Module[{A,b,n,k},
k = Length[f];
n = Length[x];
A = Table[Sum[f[[l]][x[[i]]] f[[j]][x[[i]]], {i,1,n}],
{l,1,k}, {j,1,k}];
b = Table[Sum[y[[i]] f[[j]][x[[i]]], {i,1,n}],
{j,1,k}];
a = LinearSolve[A,b]
]
LeastSq::usage = "LeastSq[x,y,f] berechnet aus den Wertepaaren
(x[[i]],y[[i]]) eine Tabelle aller
TriDiag[hi_] := Module[{i, j, len},
len = Length[hi] + 1;
Table[
Switch[i - j,
0, 2 (hi[[i]] + hi[[i + 1]]),
-1, hi[[i + 1]],
1,hi[[i]],
_, 0],
{i, 1, len - 2}, {j, 1, len - 2}]
];
3
b)
Aufgabe 27
konvergent:
CubicSpline[x_, y_] :=
Module[{hi, ri, TriVec, y2, ai, bi, ci, di, func, s, k},
len = Length[x];
hi = Table[(x[[i + 1]] - x[[i]]), {i, 1, len - 1}];
ri =
N[Table[((6(y[[i + 1]] - y[[i]]))/
hi[[i]]) - ((6(y[[i]] - y[[i - 1]]))/hi[[i - 1]]), {i, 2,
len - 1}]];
TriVec = TriDiag[hi];
y2 = Join[{0}, LinearSolve[TriVec, ri], {0}];
c)
ai = N[Table[(y2[[i + 1]] - y2[[i]])/( 6 hi[[i]]), {i, 1, len - 1} ]];
bi = N[Table[y2[[i]]/2, {i, 1, len - 1}]];
ci =
N[Table[((y[[i + 1]] - y[[i]])/
hi[[i]]) - ((y2[[i + 1]] + 2 y2[[i]]) hi[[i]] /6), {i, 1,
len - 1}]];
di = y;
func =
N[Table[(ai[[i]]*(s - x[[i]])^3) + (bi[[i]]*(s x[[i]])^2) + (ci[[i]]*(s - x[[i]])) + di[[i]], {i, 1,
len - 1}]];
Show[
Table[Plot[func[[k]], {s, x[[k]], x[[k + 1]]},
DisplayFunction -> Identity], {k, 1, Length[func]}],
ListPlot[Transpose[{x, y}], DisplayFunction -> Identity,
PlotStyle -> PointSize[0.02]],
DisplayFunction -> $DisplayFunction];
];
Aufgabe 28
Funktionsaufruf:
Points2 = Table[{i, \[ExponentialE]^(-i^2)}, {i, -2, 10, 13/11}];
x = Transpose[Points2][[1]];
y = Transpose[Points2][[2]];
CubicSpline[x, y]
Ergebnis:
0.8
0.6
0.4
0.2
-2
2
4
6
8
10
Aufgabe 30
a)
y=a / x n
y=x
x
1
0
x + x/a ist symmetrisch zu y = x.
x
b)
Bew.:
c)
y = a/x,
x ↔ y : x = a/y ⇒ y = a/x.
Kurve flacher machen bei gleichem Schnittpunkt mit y = x.
Aufgabe 31
a)
Def.: (an )n∈N konvergiert gegen a gdw.
∀ε > 0∃N ∈ N∀n ≥ N |an − a| ≤ ε.
4
divergent:
alternierend konvergent:
alternierend divergent:
„ «
1
n n∈N
(n)n∈N
«
„
1
(−1)n
n
n∈N
((−1)n )n∈N
Quotientenkriterium; Jede beschränkte monotone Folge konvergiert.