PPT

Programmierung 1 - Repetitorium
WS 2002/2003
Programmierung 1 - Repetitorium
Andreas Augustin und Marc Wagner
Homepage: http://info1.marcwagner.info
Programmierung 1 - Repetitorium
Donnerstag, den 10.04.03
Kapitel 7
Korrektheit
Programmierung 1 - Repetitorium
7.1 Abstrakte Prozeduren
Abstrakte Prozedur = Vorschrift, die zu jedem Wert eines vorgegebenen
Argumentbereichs eine Berechnung definiert, die, wenn sie terminiert,
ein eindeutig bestimmtes Ergebnis in einem vorgegebenen
Ergebnisbereich liefert.
Typzusicherung :
sum : ℤ → ℕ
Argumentbereich
Ergebnisbereich
definierende Gleichung :
sum (x) = if x < 1 then 0 else sum (x-1) + x
Für abstrakte Prozeduren gilt :
- keine Speicherbeschränkung
- keine Größenbeschränkung für Zahlen
- keine undefinierte Operations- und Funktionsanwendungen
Programmierung 1 - Repetitorium
7.1 Abstrakte Prozeduren
Abstrakte Prozeduren divergieren oder terminieren.
Eine Prozedur p ist eine Prozedur X → Y, wenn X → Y die Typzusicherung von p ist.
Sei p eine Prozedur X → Y.
Ein Paar (x,y)  X2 heißt Rekursionspaar von p, wenn für die Bestimmung
von p(x) gemäß der definierenden Gleichung von p die rekursive Bestimmung
von p(y) erforderlich ist.
Die Rekursionsrelation von p ist die Menge aller Rekursionspaare von p.
Rekursionsrelation von sum ist { (n,n-1) | n  ℕ+ }
Die Rekursionsrelation einer Prozedur X → Y ist immer eine binäre Relation auf X.
Sei r eine binäre Relation.
Eine unendliche Kette in r ist eine unendliche Folge x0 , x1 , x2 , ..., für die gilt :
∀ n  ℕ : ( xn , xn+1 )  r
Programmierung 1 - Repetitorium
7.1 Abstrakte Prozeduren
Wir sagen, dass r für x terminiert, wenn es keine unendliche Kette in r gibt,
die mit x beginnt.
Wir sagen, dass r terminiert, wenn es keine unendliche Kette in r gibt.
Sei p eine Prozedur X → Y.
Wir sagen, dass p auf x  X terminiert, wenn die Rekursionsrelation
von p für x terminiert.
Die Menge aller x  X, für die p terminiert, bezeichnen wir mit Dom p (domain)
und nenne sie den Definitionsbereich von p.
Wenn p für ein Argument x  X terminiert, bezeichnen wir das eindeutig bestimmte
Ergebnis mit p(x). Die Funktion { ( x , p(x) ) | x  Dom p } bezeichnen wir als
Ergebnisfunktion der Prozedur p.
Eine Prozedur ist linear-rekursiv gdw. alle Rekursionsbäume linear sind.
Eine Prozedur ist binär-rekursiv gdw. alle Rekursionsbäume binär sind.
Programmierung 1 - Repetitorium
7.1 Abstrakte Prozeduren
Beispiel : Fibonacci - Funktion
fib : ℕ → ℕ
fib(n) = if n<2 then n else fib(n-1) + fib(n-2)
Die Rekursionsrelation von fib ist { ( n , n – i ) | n  ℕ ⋀ n ≥ 2 ⋀ i  {1,2} }
Offensichtlich terminiert diese Relation, also auch fib.
Rekursionsbaum für fib mit Argument 4 :
fib 4
fib 3
fib 2
fib 1
fib 0
fib 2
fib 1
fib 1
fib 0
Jede Kante entspricht
einem Rekursionspaar !
Programmierung 1 - Repetitorium
7.2 Beweis durch Nachrechnen
(1) sum  ℤ → ℕ
(2) ∀ x  ℤ : sum(x) = if x<1 then 0 else sum(x-1) + x
Behauptung :
sum (2) = 3
Beweis :
sum (2) = sum(1) + 2 = ( sum(0) + 1 ) + 2 = ( 0 + 1 ) + 2 = 3
∎
Behauptung :
∀ x  ℤ : x < 1 ⇒ sum(x) = 0
Beweis :
Sei x  ℤ und x < 1. Dann folgt sum(x) = 0 gem. Def. von sum.
∎
Beweistechniken für A ⇒ B
1.
2.
( A Prämisse , B Konklusion )
Beweise B unter Verwendung der Gültigkeit von A.
Beweise, dass  A gilt.
( A ⇒ B ) ⇔ ( A v B )
Programmierung 1 - Repetitorium
7.2 Beweis durch Nachrechnen
Behauptung :
∀ x  ℤ : sum(x) = if x<1 then 0 else x/2 * (x+1)
Beweis :
f1(x) = if x < 1 then 0 else x/2 * (x+1)
f2(x) = if x < 1 then 0 else f2(x-1) + x
Sei x < 1. f1(x) = 0 = f2(x)
klar nach Def.
Sei x ≥ 1. f1(x) = x/2 * (x+1)
= x-1/2 * (x-1+1) + x
= f1(x-1) + x
(IA)
= if x < 1 then 0 else f2(x-1) + x
= f2(x)
∎
Programmierung 1 - Repetitorium
7.3 Ordnungsrelation
Infixschreibweise einer binären Relation r :
xry = (x,y)r
Sei ≤ eine binäre Relation.
x≤y
x kleiner gleich y
x≥y ⇔ y≤x
x größer gleich y
x<y ⇔ x≤y⋀x≠y
x kleiner y
x Vorgänger von y
x>y ⇔ y<x
x größer y
x Nachfolger von y
Eine binäre Relation ≤ heißt ...
- reflexiv, wenn Dom (≤) = Ran (≤) und ∀ x  Dom (≤) : x ≤ x
- transitiv, wenn für alle x,y,z  Dom (≤) gilt : ( x ≤ y ⋀ y ≤ z ) ⇒ x ≤ z.
- antisymmetrisch, wenn für alle x,y  Dom (≤) gilt : ( x ≤ y ⋀ y ≤ x ) ⇒ x = y.
- partielle Ordnung, wenn sie reflexiv, transitiv und antisymmetrisch ist.
- linear, wenn für alle x,y  Dom (≤) gilt : x ≤ y v y ≤ x
- wohlfundiert, wenn > terminiert.
Programmierung 1 - Repetitorium
7.3 Ordnungsrelation
Eine partielle Ordnung ≤ heißt ...
- partielle Ordnung für eine Menge X, wenn Dom (≤) = X ist.
- lineare Ordnung, wenn sie linear ist.
- wohlfundierte Ordnung, wenn sie wohlfundiert ist.
- Wohlordnung, wenn sie linear und wohlfundiert ist.
natürliche Ordnung
NO(x) = { (x,y)  X2 | x ≤ y }
strukturelle Ordnung
SO(x) = { (x,y)  X2 | x Teilobjekt von y }
Inklusionsordnung
IO(x) = { (y,z) | y ⊆ z und z ⊆ x }
Identität
Id(x) = { (x,x) | x  X }
Programmierung 1 - Repetitorium
7.4 Terminierungsbeweise
Sei X eine nach unten beschränkte Teilmenge der ganzen Zahlen.
Dann ist NO(X)≻ eine terminierende Relation.
Sei X eine Menge.
Dann ist SO(X)≻ eine terminierende Relation.
Jede Teilmenge einer terminierenden Relation ist eine terminierende Relation.
Eine Funktion f bettet eine binäre Relation r in eine binäre Relation r‘ ein, wenn gilt :
1.
2.
( Dom r ∪ Ran r ) ⊆ Dom f
∀ (x,y)  r : ( f x , f y )  r‘
Jede Relation, die in eine terminierende Relation einbettbar ist, terminiert.
Programmierung 1 - Repetitorium
7.4 Terminierungsbeweise
Eine Prozedur p heißt ...
- natürlich rekursiv, wenn es eine nach unten beschränkte Teilmenge X der
ganzen Zahlen gibt, sodass die Rekursionsrelation von p in NO(X)≻
eingebettet werden kann.
- strukturell rekursiv, wenn es eine Menge X gibt, sodass die
Rekursionsrelation von p in SO(X)≻ eingebettet werden kann.
Jede natürlich – oder strukturell – rekursive Prozedur terminiert.
Programmierung 1 - Repetitorium
7.4 Terminierungsbeweise
Beispiel : Größe von Bäumen
( T(X) = X x ℒ (T(X)) )
size : T(x) → ℕ
size ( x , [ t1 , ... , tn ] ) = 1 + size(t1) + ... + size(tn)
Rekursionsrelation
{ ( ( x , [ t1 , ... , tn ] , ti ) | ( x , [ t1 , ... , tn ] )  T(X) ⋀ n ≥ 1 ⋀ i  { 1 , ... , n } }
Dies ist eine Teilmenge von SO(T(X))≻.
⇒ size ist strukturell – rekursiv und terminiert.
Beispiel : Potenzen
power : ℝ x ℕ → ℝ
power (x,n) = if n=0 then 1 else power (x,n-1) * x
Rekursionsrelation
{ ( (x,n) , (x,n-1) ) | x  ℝ ⋀ n  ℕ+ }
wird von  (x,n)  ℝ x ℕ . n in NO(ℕ)≻ eingebettet.
⇒ power ist natürlich – rekursiv und terminiert.
Programmierung 1 - Repetitorium
7.5 Induktion
Eine Relation ≤ ist genau dann wohlfundiert, wenn jede nichtleere Menge ein
minimales Element für ≤ enthält.
Wohlfundierte Induktion :
Sei ≤ eine wohlfundierte Relation, X eine Menge und A ⊆ X.
Dann gilt A = X, wenn gilt : ∀ x  X : ( ∀ y  X : y < x ⇒ y  A ) ⇒ x  A
Grundmenge : X
Aussagemenge : A ⊆ X
Zielbehauptung : ∀ x  X : x  A
bzw.
X⊆A
Induktionsrelation : wohlfundierte Ordnung
( z.B. NO(X) )
Induktionsbehauptung : ∀ x  X : ( ∀ y  X : y < x ⇒ y  A ) ⇒ x  A
Induktionsannahme für x  X : ∀ y  X : y < x ⇒ y  A
→ Beweis unter Verwendung der Induktionsannahme
Programmierung 1 - Repetitorium
7.5 Induktion
Von der Wahl der „richtigen“ Induktionsrelation hängt der Erfolg des
Induktionsbeweises ab.
Wenn die Grundmenge eine nach unten beschränkte
Menge von Zahlen ist, ist die natürliche Ordnung die naheliegende Wahl.
Man spricht dann von natürlicher Induktion.
Wenn die Elemente der Grundmenge dagegen zusammengesetzte Objekte sind
(z.B. Listen oder Bäume), bietet sich die strukturelle Ordnung an.
Man spricht dann von struktureller Induktion.
Programmierung 1 - Repetitorium
7.5 Induktion
Beispiel : Summenfunktion
sum  ℤ → ℕ
sum (x) = if x < 1 then 0 else sum (x-1) + x
Behauptung :
∀ n  ℕ : sum (n) = n/2 * (n+1)
Beweis mit natürlicher Induktion :
Grundmenge : ℕ
Aussagemenge : A := { n  ℕ | sum(n) = n/2 * (n+1) } ⊆ ℕ
Zielbehauptung : ℕ ⊆ A
Induktionsrelation : NO(ℕ)
Sei n=0.
sum(n) = 0 = n/2 * (n+1)
klar nach Definition
Sei n>0.
sum(n) = sum(n-1) + n
Definition von sum
= n-1/2 * (n-1+1) + n
= n/2 * (n+1)
∎
(IA)
Programmierung 1 - Repetitorium
7.6 Strukturelle Induktion über Listen
ℒ (X) = { ( ) } ∪ ( X x ℒ (X) )
Konkatenation
@  ℒ (X) x ℒ (X) → ℒ (X)
nil @ ys = ys
( x :: xr ) @ ys = x :: ( xr @ ys )
| _ |  ℒ (X) → ℕ
Länge
| nil | = 0
Reversion
| x :: xr | = 1 + | xr |
rev  ℒ (X) → ℒ (X)
rev ( nil ) = nil
rev ( x :: xr ) = rev ( xr ) @ [ x ]
Sei X eine Menge und seien xs,ys,zs  ℒ (X). Dann gilt :
1.
xs @ nil = xs
2.
| xs @ ys | = | xs | + | ys |
3.
| rev ( xs ) | = | xs |
4.
rev ( xs @ ys ) = rev ( ys ) @ rev ( xs )
5.
rev ( rev ( xs ) ) = xs
Programmierung 1 - Repetitorium
7.6 Strukturelle Induktion über Listen
Behauptung :
Sei X eine Menge und seien xs,ys,zs  ℒ (X)
Dann gilt : ( xs @ ys ) @ zs = xs @ ( ys @ zs )
Beweis :
Seien ys,zs  ℒ (X). Wir beweisen
∀ xs  ℒ (X) : ( xs @ ys ) @ zs = xs @ ( ys @ zs )
durch strukturelle Induktion über xs  ℒ (X)
Sei xs = nil.
( xs @ ys ) @ zs = ys @ zs
= xs @ ( ys @ zs )
Sei xs = x :: xr.
( xs @ ys ) @ zs = ( x :: ( xr @ ys ) ) @ zs
= x :: ( ( xr @ ys ) @ zs )
= x :: ( xr @ ( ys @ zs ) )
= xs @ ( ys @ zs )
∎
(IA)
Programmierung 1 - Repetitorium
7.7 Größenverhältnisse in Bäumen
T(X) = X x ℒ (T(X))
Größe
s  T(X) → ℕ
s ( x , [ t1 , ... , tn ] ) = 1 + s ( t1 ) + ... + s ( tn )
Tiefe
d  T(X) → ℕ
d ( x , [ t1 , ... , tn ] ) = 1 + max { -1 , d ( t1 ) , ... , d ( tn ) }
Breite
b  T(X) → ℕ+
b ( x , [ t1 , ... , tn ] ) = if n=0 then 1 else b ( t1 ) + ... + b ( tn )
Die inneren Knoten eines Baumes sind die Knoten, die keine Blätter sind.
Programmierung 1 - Repetitorium
7.7 Größenverhältnisse in Bäumen
Behauptung :
Für jeden balancierten Binärbaum t  T (X) gilt : b ( t ) = 2 d ( t )
Beweis durch strukturelle Induktion :
Sei t = ( x , [ ] ).
b ( t ) = 1 = 2 d(t)
nach Definition
Sei t = ( x , [ t1 , t2 ] ).
b ( t ) = b ( t1 ) + b ( t 2 )
Definition von b ( t )
= 2 d ( t1 ) + 2 d ( t2 )
(IA)
= 2 * 2 d ( t1 )
t balanciert, also d ( t1 ) = d ( t2 )
= 2 1 + d ( t1 )
= 2 1 + max { d ( t1 ) , d ( t2 ) }
t balanciert, also d ( t1 ) = d ( t2 )
= 2 d(t)
Definition von d ( t )
∎
Programmierung 1 - Repetitorium
7.7 Größenverhältnisse in Bäumen
Behauptung : Für jeden balancierten Binärbaum t  T(X) gilt : s ( t ) = 2 d ( t ) + 1 - 1
Beweis durch strukturelle Induktion :
Sei t = ( x , [ ] ).
s ( t ) = 1 = 2 d(t)+1 - 1
nach Definition
Sei t = ( x , [ t1 , t2 ] ).
s ( t ) = 1 + s ( t 1 ) + s ( t2 )
Definition von b ( t )
= 1 + 2 d ( t1 ) + 1 - 1 + 2 d ( t2 ) + 1 - 1
(IA)
= 2 * 2 d ( t1 ) + 1 - 1
t balanciert, also d ( t1 ) = d ( t2 )
= 2 1 + d ( t1 ) + 1 - 1
= 2 1 + max { d ( t1 ) , d ( t2 ) } + 1 - 1
t balanciert, also d ( t1 ) = d ( t2 )
= 2 d(t)+1 - 1
Definition von d ( t )
∎