Korrekte Software: Grundlagen und Methoden Vorlesung 10 vom 12.06.17: Veriﬁkationsbedingungen Revisited

(1)

Korrekte Software: Grundlagen und Methoden

Vorlesung 10 vom 12.06.17: Verifikationsbedingungen Revisited

Serge Autexier, Christoph Lüth

Universität Bremen

Sommersemester 2017

(2)

Fahrplan

I Einführung

I Die Floyd-Hoare-Logik

I Operationale Semantik

I Denotationale Semantik

I Äquivalenz der Operationalen und Denotationalen Semantik

I Korrektheit des Hoare-Kalküls

I Vorwärts und Rückwärts mit Floyd und Hoare

I Funktionen und Prozeduren

I Referenzen und Speichermodelle

I Verifikationsbedingungen Revisited

I Vorwärtsrechnung Revisited

I Programmsicherheit und Frame Conditions

I Ausblick und Rückblick

(3)

Heute

I Der Hoare-Kalkül ist viel Schreibarbeit

I Deshalb haben wir Verifikationsbedingungen berechnet:

I

Approximative schwächste Vorbedingung

I

Approximative stärkste Nachbedingung

I Mit Zeigern ist rückwärts nicht das beste . . .

(4)

Formal: Konversion in Zustandsprädikate

(−) ^† : Lexp → Lexp v ^† = v (v Variable) l .id ^† = l ^† .id

l [e] ^† = l ^† [e ^# ]

∗l ^† = l ^#

(−) ^# : Aexp → Aexp

e ^# = read(σ, e ^† ) (e ∈ Lexp) n ^# = n

v ^# = v (v logische Variable)

&e ^# = e ^†

e 1 + e 2 # = e 1 # + e 2 #

\result ^# = \result

\old(e) ^# = \old(e )

Γ ` {Q[upd(σ, x ^† , e ^# )/σ]} x = e {Q|R}

(5)

Approximative schwächste Vorbedingung

I Für die Berechnung der approximativen schwächsten Vorbedingung (AWP) und der Verifikationsbedingungen (WVC) müssen zwei Anpassungen vorgenommen werden:

I

Sowohl AWP als auch WVC berechnen symbolische Zustandsprädikate.

I

Die Zuweisungsregel muss angepasst werden.

I Berechnung von awp und wvc:

awp(Γ, f (x ₁ , . . . , x _n )/** pre P post Q */ {ds blk})

def

= awp(Γ ⁰ , blk, Q ^# , Q ^# ) wvc(Γ, f (x 1 , . . . , x n )/** pre P post Q */ {ds blk})

def

={P ^# = ⇒ awp(Γ ⁰ , blk, Q ^# , Q ^# )[e j # / \old(e j )]}

∪ wvc(Γ ⁰ , blk, Q ^# , Q ^# )

Γ ⁰

^def

= Γ[f 7→ ∀x ₁ , . . . , x _n . (P , Q)]

(6)

Approximative schwächste Vorbedingung (Revisited)

awp(Γ, { }, Q, Q _R )

^def

= Q

awp(Γ, l = f (e 1 , . . . , e n ), Q, Q _R )

^def

= P[e i /x i ] ^#

mit Γ(f ) = ∀x ₁ , . . . , x _n . (P , R) awp(Γ, f (e ₁ , . . . , e _n ), Q, Q _R )

^def

= P[e _i /x _i ] ^#

mit Γ(f ) = ∀x ₁ , . . . , x n . (P , R) awp(Γ, l = e, Q, Q _R )

^def

= Q[upd(σ, l ^† , e ^# )/σ]

awp(Γ, {c c _s }, Q, Q _R )

^def

= awp(Γ, c , awp({c _s }, Q, Q _R ), Q _R ) awp(Γ, if (b ) {c ₀ } else {c ₁ }, Q, Q R )

^def

= ( b ^# && awp(Γ, c 0 , Q, Q R ))

|| ( ! b ^# && awp(Γ, c ₁ , Q, Q _R )) awp(Γ, /∗∗ {q} ∗/ , Q, Q _R )

^def

= q

awp(Γ,







while (b ) /∗∗ inv i ∗/

c





 , Q, Q _R )

^def

= i

awp(Γ, return e, Q, Q _R )

^def

= Q _R [e ^# / \result]

awp(Γ, return, Q, Q _R )

^def

= Q _R

(7)

Approximative Verifikationsbedingungen (Revisited)

wvc(Γ, { }, Q, Q _R ) =

^def

∅ wvc(Γ, x = e , Q, Q _R ) =

^def

∅

wvc(Γ, x = f (e 1 , . . . , e n ), Q, Q _R ) =

^def

{ (R[e i /x i ][x/ \result]) ^# = ⇒ Q}

mit Γ(f ) = ∀x ₁ , . . . , x n . (P , R) wvc(Γ, f (e ₁ , . . . , e _n ), Q, Q _R ) =

^def

{ (R[e _i /x _i ]) ^# = ⇒ Q}

mit Γ(f ) = ∀x ₁ , . . . , x n . (P , R)

wvc(Γ, {c c _s }, Q, Q _R ) =

^def

wvc(Γ, c , awp(Γ, {c _s }, Q, Q _R ), Q _R )

∪ wvc(Γ, {c _s }, Q, Q _R ) wvc(Γ, if (b) c ₀ else c ₁ , Q, Q _R ) =

^def

wvc(Γ, c ₀ , Q, Q _R )

∪ wvc(Γ, c 1 , Q, Q R ) wvc(Γ, /∗∗ {q} ∗/ , Q, Q R ) =

^def

{q = ⇒ Q}

wvc(Γ, while (b) /∗∗ inv i ∗/ c, Q, Q R ) = wvc(Γ,

^def

c , i )

∪ {i ∧ b ^# = ⇒ awp(Γ, c, i, Q _R )}

∪ {i ∧ ! b ^# = ⇒ Q}

wvc(Γ, return e , Q, Q _R ) =

^def

∅

(8)

Beispiel: swap

v o i d swap ( i n t ∗x , i n t ∗ y ) / ∗ ∗ p r e \ v a l i d ( ∗ x ) ;

p r e \ v a l i d ( ∗ x ) ; ∗/

/ ∗ ∗ p o s t \ o l d ( ∗ x ) == ∗ y

&& \ o l d ( ∗ y ) == ∗ x ; ∗ / {

i n t z ; z= ∗ x ;

∗ x= ∗ y ;

∗ y= z ;

}

(9)

swap I

v o i d swap (i n t ∗x , i n t ∗y ) /∗∗ p r e \ v a l i d (∗x ) ;

p r e \ v a l i d (∗x ) ; ∗/

/∗∗ p o s t \ o l d (∗x ) ==∗y

&& \ o l d (∗y ) == x ; ∗/

{ i n t z ; z=∗x ;

∗x=∗y ;

∗y= z ; }

G = [ swap |−−> \ f o r a l l x , y . ( P = \ v a l i d (∗x ) && \ v a l i d (∗y ) , Q = \o l d(∗x ) ==∗y && \o l d(∗y ) == x ) ] Q# = {\o l d(∗x ) == r e a d ( s , r e a d ( s , y ) ) && \o l d(∗y ) == r e a d ( s , r e a d ( s , x ) ) }

∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗

(A) awp (G , z =∗x ; ∗x =∗y ; ∗y = z , Q#, Q#)

= awp ( G , z = ∗x , awp (G , ∗x =∗y , awp ( G , ∗y = z , Q#, Q#) , Q#) , Q#) // Siehe Einzelberehcnungen unten

= { \o l d(∗x ) == r e a d ( s , r e a d ( s , x ) ) && \o l d(∗y ) == r e a d ( s , r e a d ( s , y ) ) }

(A . 1 ) awp (G , ∗y = z , Q#, Q#)

= { l e t s 3=Upd ( s2 , r e a d ( s2 , y ) , r e a d ( s2 , z ) ) ;

i n \o l d(∗x ) == r e a d ( s3 , r e a d ( s3 , y ) ) && \o l d(∗y ) == r e a d ( s3 , r e a d ( s3 , x ) ) } Da : r e a d ( s3 , y ) = r e a d ( Upd ( s2 , r e a d ( s2 , y ) , r e a d ( s2 , z ) ) , y )

= r e a d ( s3 , y ) // da y != read(s2, y)

A l s o : r e a d ( s3 , r e a d ( s3 , y ) ) = r e a d ( s3 , r e a d ( s2 , y ) ) = r e a d ( s2 , z )

(10)

swap II

= { l e t s 3=Upd ( s2 , r e a d ( s2 , y ) , r e a d ( s2 , z ) ) ;

i n \o l d(∗x ) == r e a d ( s2 , z ) && \o l d(∗y ) == r e a d ( s3 , r e a d ( s3 , x ) ) }

= Q1

(A . 2 ) awp (G , ∗x =∗y , Q1 , Q#)

= { l e t s 2=Upd ( s1 , r e a d ( s1 , x ) , r e a d ( s1 , r e a d ( s1 , y ) ) ; l e t s 3=Upd ( s2 , r e a d ( s2 , y ) , r e a d ( s2 , z ) ) ;

i n \o l d(∗x ) == r e a d ( s2 , z ) && \o l d(∗y ) == r e a d ( s3 , r e a d ( s3 , x ) ) } Da : r e a d ( s3 , x ) = r e a d ( s2 , x ) // x != read(s2, y)

r e a d ( s2 , x ) = r e a d ( s1 , x ) // x != read(s1, x) r e a d ( s2 , z ) = r e a d ( s1 , z ) // z != read(s1, x)

= { l e t s 2=Upd ( s1 , r e a d ( s1 , x ) , r e a d ( s1 , r e a d ( s1 , y ) ) ; l e t s 3=Upd ( s2 , r e a d ( s2 , y ) , r e a d ( s2 , z ) ) ;

i n \o l d(∗x ) == r e a d ( s1 , z ) && \o l d(∗y ) == r e a d ( s3 , r e a d ( s1 , x ) ) }

= Q2

(A . 3 ) awp (G , z =∗x , Q2 , Q#)

= { l e t s 1=Upd ( s , z , r e a d ( s , r e a d ( s , x ) ) ) ;

l e t s 2=Upd ( s1 , r e a d ( s1 , x ) , r e a d ( s1 , r e a d ( s1 , y ) ) ; l e t s 3=Upd ( s2 , r e a d ( s2 , y ) , r e a d ( s2 , z ) ) ;

i n \o l d(∗x ) == r e a d ( s1 , z ) && \o l d(∗y ) == r e a d ( s3 , r e a d ( s1 , x ) ) } Da : r e a d ( s1 , z ) = r e a d ( s , r e a d ( s , x ) )

i n \o l d(∗x ) == r e a d ( s , r e a d ( s , x ) ) && \o l d(∗y ) == r e a d ( s3 , r e a d ( s1 , x ) ) } Es g i l t : r e a d ( s2 , r e a d ( s1 , x ) ) = r e a d ( s1 , r e a d ( s1 , x ) )

(11)

swap III

∗∗ F a l l u n t e r s c h e i d u n g ∗∗

1 ) r e a d ( s1 , y ) != r e a d ( s1 , x ) :

Dann : r e a d ( s3 , r e a d ( s1 , x ) ) = r e a d ( s2 , r e a d ( s1 , x ) ) A l s o : r e a d ( s2 , r e a d ( s1 , x ) ) = r e a d ( s1 , r e a d ( s1 , y ) F o l g t :

i n \o l d(∗x ) == r e a d ( s , r e a d ( s , x ) ) && \o l d(∗y ) == r e a d ( s1 , r e a d ( s1 , y ) ) } Da a u s s e r d e m : r e a d ( s1 , y ) != ( l o k a l e V a r i a b l e s i n d von a u s s e n n i c h t s i c h t b a r )

F o l g t :

i n \o l d(∗x ) == r e a d ( s , r e a d ( s , x ) ) && \o l d(∗y ) == r e a d ( s , r e a d ( s , y ) ) } 2 ) r e a d ( s1 , y ) == r e a d ( s1 , x ) :

Dann war a u c h : r e a d ( s , y ) == r e a d ( s , x ) :

Dann : r e a d ( s2 , r e a d ( s2 , y ) ) = r e a d ( s1 , r e a d ( s1 , y ) Dann : r e a d ( s3 , r e a d ( s1 , x ) ) = r e a d ( s2 , z )

= r e a d ( s , r e a d ( s , x ) )

= r e a d ( s , r e a d ( s , y ) ) F o l g t ( a u c h w i e i n 1 )

l e t s 2=Upd ( s1 , r e a d ( s1 , x ) , r e a d ( s1 , r e a d ( s1 , y ) ) ) ; l e t s 3=Upd ( s2 , r e a d ( s2 , y ) , r e a d ( s2 , z ) ) ;

i n \o l d(∗x ) == r e a d ( s , r e a d ( s , x ) ) && \o l d(∗y ) == r e a d ( s , r e a d ( s , y ) ) }

∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗

(B) wvc ( G , swap ) =

(12)

swap IV

{ P# ==> awp (G , z =∗x ; ∗x =∗y ; ∗y = z , Q#, Q#)[ e _ i /\o l d( e _ i ) ] } U wvc (G , z =∗x ; ∗x =∗y ; ∗y = z , Q#, Q#)

= { P# ==> ( \o l d(∗x ) == r e a d ( s , r e a d ( s , x ) ) && \o l d(∗y ) == r e a d ( s , r e a d ( s , y ) ) ) [ r e a d ( s , r e a d ( s , x ) ) / \o l d(∗x ) , r e a d ( s , r e a d ( s , y ) ) / \o l d(∗y ) ] } U wvc (G , z =∗x ; ∗x =∗y ; ∗y = z , Q#, Q#)

= { P# ==> ( r e a d ( s , r e a d ( s , x ) ) == r e a d ( s , r e a d ( s , x ) ) &&

r e a d ( s , r e a d ( s , y ) ) == r e a d ( s , r e a d ( s , y ) ) ) } U wvc (G , z =∗x ; ∗x =∗y ; ∗y = z , Q#, Q#)

= { True } U wvc (G , z =∗x ; ∗x = ∗y ; ∗y = z , Q#, Q#) ( Aus B . 2 f o l g t )

= { True }

(B . 1 ) P# = ( \ v a l i d (∗x ) && \ v a l i d (∗y ))#

= \ v a l i d ( r e a d ( s , r e a d ( s , x ) ) ) && \ v a l i d ( r e a d ( s , r e a d ( s , y ) ) ) (B . 2 ) wvc (G , z =∗x ; ∗x = ∗y ; ∗y = z , Q#, Q#)

= wvc ( G , z =∗x , awp ( G , ∗x =∗y ; ∗y = z , Q#, Q#)) U wvc (G , ∗x =∗y , awp ( G , ∗y = z , Q#, Q#)) U wvc (G , ∗y = z , awp (G , { } , Q#, Q#)) U wvc (G , { } , Q#, Q#)

= wvc ( G , z =∗x , awp ( G , ∗x =∗y ; ∗y = z , Q#, Q#)) [ A . 2 ] U wvc (G , ∗x =∗y , awp ( G , ∗y = z , Q#, Q#)) [ A . 1 ] U wvc (G , ∗y = z , Q#)

U {}

Durch (A . 1 ) , (A . 2 )

= wvc ( G , z =∗x , Q2 ) U wvc (G , ∗x =∗y , Q1 ) U wvc (G , ∗y = z , Q#)

= {}

(13)

Korrekte Software: Grundlagen und Methoden Vorlesung 10 vom 12.06.17: Veriﬁkationsbedingungen Revisited