Beweis durch vollständige Induktion

Skriptteil zur Vorlesung:
Proinformatik - Funktionale Programmierung
Dr. Marco Block-Berlitz
24.Juli 2009
Beweis durch vollständige Induktion
Die fünf Peano-Axiome
Grundlage für die vollständige Induktion sind die natürlichen Zahlen. Es folgt eine Denition der
Menge der natürlichen Zahlen
durch die fünf Peano-Axiome, die erstmals
N
1889
von Giuseppe
Peano angegeben wurden:
1)
0
ist eine natürliche Zahl.
n
2) Zu jeder natürlichen Zahl
gibt es genau einen Nachfolger
S(n),
der ebenfalls eine
natürliche Zahl ist.
3) Es gibt keine natürliche Zahl, deren Nachfolger
0
ist.
4) Jede natürliche Zahl ist Nachfolger höchstens einer natürlichen Zahl.
X , welche die Zahl 0 und mit jeder natürlichen Zahl n auch stets
S(n) enthalten, ist die Menge der natürlichen Zahlen die kleinste.
5) Von allen Mengen
deren Nachfolger
Beweiskonzept
Um für alle natürlichen Zahlen zu beweisen, dass eine Aussage
P
gilt, genügt es zwei Dinge zu
zeigen
(1) (Induktionsanker) Zeige, dass
P (0)
gilt
(2) (Induktionsschritt) Zeige, dass die Aussage
Schritt
2
(2)
P
gilt,
∀n ∈ N : P (n) ⇒ P (n + 1)
läÿt sich noch verallgemeinern zu
∀n ∈ N : (P (0) ∧ P (1) ∧ ... ∧ P (n) ⇒ P (n + 1)
Um den zweiten Schritt
P (n + 1)
anwenden zu können, setzen wir voraus, dass
(Induktionsvoraussetzung). Wird eine korrekte Reduktion von
nur noch gezeigt werden, dass
n
auf
n−1
n+1
nach
n
P (n)
gelten muss
vorgenommen, muss
usw. reduzierbar ist. Es lässt sich aber zeigen, dass es
genügt, den Induktionanker und den Induktionsschritt zu beweisen, damit es für alle natürlichen
Zahlen gilt.
Dieses Prinzip wollen wir zunächst einmal mit Beispielen untersuchen und anwenden.
Beispiele zur vollständigen Induktion
1)
A(n) : 1 + 2 + ... + n =
IA(n
= 1):
1·(1+1)
2
n·(n+1)
2
=1=
P1
i=1
i
⇒ n + 1): wenn für ein beliebiges aber festes n A(n) gälte:
P(n+1)
Pn
i = i=1 i + (n + 1) =IV n·(n+1)
+ (n + 1) = n·(n+1)
+
i=1
2
2
IS(n
1
2(n+1)
(n+1)·(n+2)
=
2
2
2)
B(n) : 1 + 2 + 4 + 8 + ... + 2n = 2n+1 − 1
IA(n
= 1): 20 + 21 = 3 = 22 − 1
IS(n
⇒ n + 1)
wenn für ein beliebiges aber festes
n
1 + 2 + 4 + 8 + ... + 2 + 2
3)
C(n) : 1 +
1
2
+
+
IA(n
= 1):
IA(n
= 2): 1 +
IS(n
⇒ n + 1)
1
2
1
3
1
4
+ ... +
1
2n
n
=IV 2 − 1 + 2
≥1+n·
n B(n)
n+1
=
2
n+2
gälte:
−1
1
2
(trivial)
1+ + +
1 + n · 21 + 2
4)
1
3
n+1
1
4
n
1
2
+
1
3
+
1
4
≥1+
1
2
+ ( 14 + 41 ) = 1 + 2 ·
wenn für ein beliebiges aber festes
1
2 (nicht notwendig)
n C(n)
1
+ ... + 21n + ( 2n1+1 + ... + 2n+1
) ≥IV 1 + n
1
1
1
· 2n +2n = 1 + n · 2 + 2 = 1 + (n + 1) · 12
gälte:
1
2
·
1
+ ( 2n +2
n + ... +
D(n) : 1 + 3 + 5 + ... + (2n − 1) = n2
IA(n
= 1): 1 = 12
IS(n
⇒ n + 1)
wenn für ein beliebiges aber festes
n D(n)
gälte:
2
1 + 3 + 5 + ... + (2n − 1) + (2(n + 1) − 1) =IV n + (2(n + 1) − 1)
(n + 1)2
5)
1
2n +2n ) =
=
n2 + 2n + 2 − 1
=
E(n) : 5 + 8 + 11 + 14 + ... + (5 + 3n) = 5(n + 1) + 3 n·(n+1)
2
IA(n
= 1): 5 + 8 = 13 = 10 + 3 = 5 · 2 + 3 22 = 5 · 2 + 3 1·(1+1)
2
IS(n
⇒ n + 1)
wenn für ein beliebiges aber festes
n E(n)
gälte:
+ (5 + 3(n + 1))
5 + 8 + 11 + 14 + ... + (5 + 3n) + (5 + 3(n + 1)) =IV 5(n + 1) + 3 n·(n+1)
2
n·(n+1)
n·(n+1)
n·(n+1)
= 5(n + 2) + 3
+
3(n
+
1)
= 3(
+
(n
+
1))
= 3(
+ 2(n+1)
) =
2
2
2
2
(n+1)·(n+2)
5(n + 2) + 3
2
6)
F (n) : 1 + 2 + ...n <
n·(n+1)
(ACHTUNG! nur Schritt zeigen)
2
IS(n ⇒ n + 1) wenn für ein beliebiges aber festes n F (n) gälte:
P(n+1)
Pn
i = i=1 i + (n + 1) <IV n·(n+1)
+ (n + 1) = n·(n+1)
+
i=1
2
2
Schritt funktioniert, obwohl die Aussage (siehe
7)
G(n) : n2 ≥ 2n + 1
ab einem bestimmten
IA(n
= 3): 32 = 9 ≥ 7 = 2 · 3 + 1
IS(n
⇒ n + 1)
(n + 1)
2
=
A(n))
2(n+1)
(n+1)·(n+2)
=
2
2
falsch ist.
n
wenn für ein beliebiges aber festes
2
n + 2n + 1≥IV 2n + 1 + 2n + 1
2
=
n (n ≥ 3) E(n)
gälte:
(2n + 2) + 2n ≥ 2(n + 1) + 1
8)
H(n) : n
Pferde haben die gleiche Farbe
IA(n
= 1):
IS(n
⇒ n + 1)
trivialerweise richtig
wenn für ein beliebiges aber festes
n H(n)
gälte:
n + 1 Pferden ein beliebiges heraus. Nach Induktionsn Pferde die gleiche Farbe. Man tue das weggeHerde und nehme ein anderes weg. Die nun verbliebenen n
Man nehme aus einer Herde von
voraussetzung haben die verbliebenen
nommene Pferd wieder zur
Pferde haben wieder nach Induktionsvoraussetzung die gleiche Farbe. Insgesamt haben
also alle
n+1
Pferde die gleiche Farbe.
FRAGE: Wo liegt der Fehler?
Beispiel: Bezug zu Programmen
Satz: Für jedes
n=0
den
n ∈ N mit n > 0 berechnet die Funktion fakultaet n den Wert
Wert 1. Die Funktion facultaet ist dabei wie folgt deniert
fakultaet :: Int
fakultaet n
| n <0
=
| n ==0
=
| otherwise =
Qn
i=1
i
und für
-> Int
error " n.d."
1
n * fakultaet (n -1)
-- ( fac .0)
-- ( fac .1)
-- ( fac .2)
Die Bezeichnungen der Zeilen werden uns helfen, die Beweisschritte anzugeben. Per Denition sei
Q0
i=1
i = 1.
Beweis:
Induktionsanker(n=0): Zunächst wollen wir den Induktionsanker mit
fakultaet 0 = 1
n=0
zeigen
| (faku.1)
Der Induktionsanker ist erfüllt.
Induktionsvoraussetzung(n): Wir setzen voraus, dass für ein beliebiges aber festes
fakultaet n =
Qn
i=1
n
i
erfüllt ist.
Induktionsschritt(n+1): Die Aussage für
fakultaet n+1 =
Qn+1
i=1
n + 1,
mit
i
gilt unter der Induktionsvoraussetzung.
fakultaet (n+1) =
=
=
=
(n+1)·fakultaet((n+1)-1)
(n+1)·fakultaet
n
Q
(n+1)· ni=1 i
Qn+1
i=1 i
| (faku.2)
| Ind.Vor.
Damit ist der Satz bewiesen.
Häuge Fehler beim Induktionsbeweis
•
Der Induktionsschritt funktioniert zwar, die Behauptung gilt für die Anfangsbedingung aber
nicht.
•
Der Induktionsschritt ist nicht für alle
n
gültig, d. h., es gibt mindestens ein
Verankerung), für das er nicht anwendbar ist.
3
n ≥ n0
(der
Vollständige Induktion über Listen
Bei Listen können wir uns die Tatsache zu Nutze machen, dass die Länge einer Liste eine natürliche
Zahl ist. Um nun die vollständige Induktion auf Listen anwenden zu können, ändern wir das
Konzept in der Art, dass die Induktion über die Struktur vorgenommen wird. In diesem Fall reden
wir auch von einer strukturellen Induktion.
Beispiel 1
Satz: Für alle Listen
xs
(endliche Länge) und
ys
von ganzen Zahlen gilt
elem z (xs ++ ys) = elem z xs || elem z ys
Dabei sind (++) und
elem
wie folgt deniert
(++) :: [a] -> [a] -> [a ]
[] ++ vs
= vs
(u: us ) ++ vs = u :( us ++ vs )
-- (++.1)
-- (++.2)
elem :: Eq a => a -> [a ] -> Bool
elem u []
= False
elem u (v: vs ) = (u == v ) || elem u vs
-- ( elem .1)
-- ( elem .2)
Auch an dieser Stelle sind die Bezeichnungen der Zeilen für die Beweisführung nützlich.
Beweis:
An dieser Stelle soll die strukturelle Induktion über die Länge der Liste
Allgemein soll
n
die Länge der Liste
Induktionsanker(n=0,
xs=[]):
xs
xs vorgenommen werden.
sein.
Wir setzen
xs=[]
und zeigen, dass der Anker gilt
(1) elem z ([] ++ ys)
= elem z ys
(2) elem z [] || elem z ys = False || elem z ys
= elem z ys
| (++.1)
| (elem.1),
| False∨x=x
Der Induktionsanker ist erfüllt, (1) und (2) liefern das gleiche Ergebnis.
Induktionsvoraussetzung(n,
xs
mit der Länge
n
xs):
Wir setzen voraus, dass für eine beliebige aber feste Liste
die Aussage
elem z (xs ++ ys) = elem z xs || elem z ys
erfüllt ist.
Induktionsschritt(n+1,
(x:xs)):
Für
(x:xs)
mit der Listenlänge
n+1
gilt die Aussage
elem z ((x:xs) ++ ys) = elem z (x:xs) || elem z ys
unter der Induktionsvoraussetzung.
elem z ((x:xs) ++ ys) =
=
=
=
=
elem z (x:(xs++ys))
(z==x)||elem z (xs++ys)
(z==x)||(elem z xs||elem z ys)
(z==x)||elem z xs||elem z ys
elem z (x:xs) || elem z ys
Damit ist der Satz bewiesen.
4
|
|
|
|
(++.2)
(elem.2)
I.V.
Assoz.
Beispiel 2
Satz: Für alle Listen
xs
(endliche Länge) und
ys
von ganzen Zahlen gilt
summe (xs ++ ys) = summe xs + summe ys
Dabei ist
summe deniert über summe=fRechts (+) 0
fRechts
nitionen für (++) und
-- (summe). Gegeben seien folgende De-
(++) :: [a] -> [a] -> [a ]
[] ++ vs
= vs
(u: us ) ++ vs = u :( us ++ vs )
-- (++.1)
-- (++.2)
fRechts :: (b -> a -> a) -> a -> [b] -> a
fRechts _ s [] = s
-- ( fr .1)
fRechts f s (x: xs ) = f x ( faltenRechts f s xs ) -- ( fr .2)
Beweis:
An dieser Stelle soll die strukturelle Induktion über die Länge der Liste
Allgemein soll
n
die Länge der Liste
xs=[]):
Induktionsanker(n=0,
xs
Wir setzen
(1) summe ([] ++ ys)
(2) summe [] + summe ys
=
=
=
=
xs vorgenommen werden.
sein.
xs=[]
und zeigen, dass der Anker gilt
summe ys
| (++.1)
fRechts (+) 0 [] + summe ys | (summe)
0 + summe ys
| (fr.1)
summe ys
| neut.Ele.Add.
Der Induktionsanker ist erfüllt, (1) und (2) führen zum gleichen Ergebnis.
Induktionsvoraussetzung(n,
xs
mit der Länge
n
xs):
Wir setzen voraus, dass für eine beliebige aber feste Liste
die Aussage
summe (xs ++ ys) = summe xs + summe ys
erfüllt ist.
Induktionsschritt(n+1,
(x:xs)):
summe((x:xs)++ys)
Für
(x:xs)
mit der Listenlänge
n+1
gilt die Aussage
= summe (x:xs) + summe ys
unter der Induktionsvoraussetzung.
summe((x:xs)++ys)
=
=
=
=
=
=
=
=
fRechts (+) 0 ((x:xs)++ys)
|
x + (fRechts (+) 0 (xs ++ ys))
|
x + (summe (xs ++ ys))
|
x + (summe xs + summe ys)
|
(x + summe xs) + summe ys
|
(x + fRechts (+) 0 xs) + summe ys |
(fRechts (+) 0 (x:xs)) + summe ys |
summe (x:xs) + summe ys
Damit ist der Satz bewiesen.
5
(summe)
(fr.2)
(summe)
I.V.
Ass. Add.
(summe)
(fr.2)
Literatur
[1] O'Neill
M.E.:
The
Genuine
Sieve
of
Eratosthenes ,
unpublished
draft,
siehe:
http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf
[2] Block M.: Java Intensivkurs - In 14 Tagen lernen Projekte erfolgreich zu realisieren ,
Springer-Verlag 2007
[3] Dankmeier D.: Grundkurs Codierung: Verschlüsselung, Kompression, Fehlerbeseitigung.,
3.Auage, Vieweg-Verlag, 2006
[4] Schulz R.-H.: Codierungstheorie: Eine Einführung , 2.Auage, Vieweg+Teubner, 2003
[5] Schöning U.: Algorithmik , ISBN-13: 978-3827410924, Spektrum Akademischer Verlag, 2001
[6] Pope B.: A tour of the Haskell Prelude , unpublished (http://www.cs.mu.oz.au/~bjpop/ ),
2001
[7] Hudak P., Peterson J., Fasel J.: A gentle introduction to Haskell Version 98 , unpublished
(http://www.haskell.org/tutorial/ ), 2000
[8] Cormen T.H., Leiserson C.E., Rivest R.L.: Introduction to Algorithms , MIT-Press, 2000
[9] Gibbons J., Jones G.: The Under-Appreciated Unfold , Proceedings of the third ACM SIGPLAN international conference on Functional programming, pp. 273-279, United States, 1998
[10] Haskell-Onlinereport
98:
http://haskell.org/onlinereport/index.html
[11] Data.Char: http://www.haskell.org/ghc/docs/6.4.1/html/libraries/base/Data-Char.html
[12] Webseite der Helium-IDE: http://www.cs.uu.nl/wiki/Helium
[13] Wikibook zur Datenkompression: http://de.wikibooks.org/wiki/
Datenkompression
[14] Haskell-Funktionen: http://www.zvon.org/other/haskell/Outputglobal/
index.html
[15] Webseite des Euler-Projekts: http://projecteuler.net/
[16] Webseite Haskellprojekte: http://hackage.haskell.org/packages/archive/
pkg-list.html
[17] Projektwebseite Frag: http://haskell.org/haskellwiki/Frag
[18] Projektwebseite Monadius: http://www.geocities.jp/takascience/haskell/
monadius_en.html
[19] Haskell-Suchmaschine Hoogle: http://www.haskell.org/hoogle/
[20] Wikipedia: http://www.wikipedia.com
6