COMP2111 Glossary. Kai Engelhardt. Contents. 1 Symbols. 1 Symbols 1. 2 Hoare Logic 3. 3 Refinement Calculus 5. rational numbers Q, real numbers R.

Transcription

1 COMP2111 Glossary Kai Engelhardt Revision: 1.3, May 18, 2018 Contents 1 Symbols 1 2 Hoare Logic 3 3 Refinement Calculus 5 1 Symbols Booleans B = {false, true}, natural numbers N = {0, 1, 2,...}, integers Z = {0, 1, 1, 2, 2,...}, rational numbers Q, real numbers R. 1

2 symbol usage meaning/pronunciation example/definition. :.. id : type type function type declaration f : D R dom(.) dom(f) function domain dom(f) = D ran(.) ran(f) function range ran(f) = R expr set set membership 5 N 2 / Q.. num 1..num 2 number range 2..5 = {2, 3, 4, 5}.. expr expr maplet x 0 σ iff σ(x) = 0 {.. } { expr pred } set comprehension { 3n + 1 n N } = {1, 4, 7,...} P(.) P(set) powerset P({a}) = {, {a}} (x = 7 x (10 > x > y))[ 7 / x ] =.[. /. ] φ[ e / x ] substitution (7 = 7 x (10 > x > y)) (. :..) (f : k v) function variant (! : 3 5)(x) = { 5 if x = 3 x! otherwise φ, ψ assertions phi, psi. :=. x := e assignment statement x := x φ ψ frameless spec x = x 0 x = x : [.,.] w : [pre, post] Morgan-style spec x : [true, x = x 0 + 1] {.}. {.} {φ} P {ψ} Hoare triple {x = x 0 } x := x + 1 {x = x 0 + 1}.. A C refinement order x : [true, x = x 0 + 1] x := x f g function composition (f g)(x) = f(g(x)).;. R; S relation composition R; S = { (a, c) b (arb bsc) } Γ Γ(x), Γ(T ) successor function Γ(T ) = t T Γ(t) id id D identity function id S = { s s s S }.. f i function iteration f 0 = id dom(f), f k+1 = f f k. + f + irreflexive closure f + (x) = k>0 f k (x). f reflexive closure f (x) = k 0 f k (x) 2

3 2 Hoare Logic Assignment axiom: {φ[ e / x ]} x := e {φ} Array assignment axiom: { } φ[ (a:e 1 e 2 ) { } / a ] a[e 1 ] := e 2 φ ass array-ass Guard axiom: If φ is a Boolean expression in program variables, then {φ ψ} φ {ψ} grd Sequential composition rule: {φ} P {ψ}, {ψ} Q {ρ} {φ} P ; Q {ρ} seq Choice rule: {φ} P {ψ}, {φ} Q {ψ} {φ} P + Q {ψ} choice If rule: {φ g} P {ψ}, {φ g} Q {ψ} {φ} if g then P else Q fi {ψ} if While rule: {φ g} P {φ} {φ} while g do P od {φ g} loop Consequence rule: φ φ, {φ} S {ψ}, ψ ψ {φ } S {ψ } cons Adaptation axiom: Let x express the vector of free program variables inside assertions φ, ψ, and π, let x 0 express the vector of free logical variables inside φ and ψ, and let y 0 express a vector of fresh logical variables of the same length as x. { π } ( ))} φ ψ { y 0 (π[ y 0 / x ] x 0 φ[ y 0 / x ] ψ 3

4 wlp-adaptation axiom: (with the same proviso as above) Recursion rule: ( ) )} { y 0 ( x 0 φ ψ[ y 0 / x ] ρ[ y 0 / x ] φ ψ { ρ } {π} S[ π ρ / X ] {ρ} {π} µx.s {ρ} 4

5 3 Refinement Calculus Assignment: If w = w 0 pre post[ e / w ], then w : [pre, post] w := e ass Array assignment: If a = a 0 pre post[ (a:e 1 e 2 ) / a ], then a : [pre, post] a[e 1 ] := e 2 a-ass Multiple assignment: For disjoint w and x w, x := e, f[ e / w ] w := e; x := f l-ass Introduce constant: If pre c (pre ) and c doesn t occur in w, pre or post, then w : [pre, post] con c w : [pre, post] i-con Contract frame: w, x : [pre, post] w : [pre, post[ x / x0 ]] c-frame Expand frame: w : [pre, post] w, x : [pre, post x = x 0 ] e-frame Conditional: w : [φ, ψ] if g then w : [g φ, ψ] else w : [ g φ, ψ] fi if Loop: If inv does not contain 0-subscripted variables w : [inv, inv g] while g do w : [g inv, inv] od while Initialised loop: If ψ contains no initial variables then w : [φ, ψ g] w : [φ, ψ]; while g do w : [ψ g, ψ] od ido Introduce local variable: If x does not occur freely in w, pre, or post, then w : [pre, post] var x : T w, x : [pre, post] i-loc 5

6 Sequential composition: If neither mid nor post contains 0-subscripted variables, then w : [pre, post] w : [pre, mid]; w : [mid, post] seq Sequential composition 2: If mid contains no 0-subscripted variables and post contains no w 0, then w, x : [pre, post] w : [pre, mid]; w, x : [mid, post] seq2 Following assignment: w, x : [φ, ψ] w, x : [φ, ψ[ e / x ]]; x := e f-ass Strengthen postcondition: If pre[ w 0 / w ] post post, then w : [pre, post] w : [pre, post ] s-post Weaken precondition: If pre pre, then w : [pre, post] w : [pre, post] w-pre Skip: If pre post[ w / w0 ], then w : [pre, post] skip skip Named procedure: When we have a specification of a named procedure p proc p w : [φ, ψ] we may replace specs by procedure calls w : [φ, ψ] p Named procedure with value parameter: When we have a specification of a named procedure p proc p(value v) w, v : [φ, ψ] we may replace like this in contexts if ψ contains no v w : [φ[ e / v ], ψ[ e[w 0 / w] / v0 ]] p(e) Named procedure with result parameter: When we have a specification of a named procedure p proc p(result r) w, r : [φ, ψ[ r / y ]] 6

7 we may replace like this in contexts if r does not occur in φ and neither r nor r 0 occur in ψ w, y : [φ, ψ] p(y) Named procedure with value-result parameter: When we have a specification of a named procedure p proc p(r) w, r : [φ, ψ[ r / y ]] with ψ not containing r we can replace in contexts with w, y : [φ[ y / r ], ψ[ y 0 / r0 ]] p(y) Recall that for procedures with more than one formal paramater, the above rules need to be combined into new rules. Logically speaking, the resulting rules are not derived rules! A C function returns a value unless its return type is void. We can imagine using a specification of a function f with return type T that looks like this: func f(...) : T w : [φ, ψ]; return e and use it in assignments like this x := f(...) Assuming r is fresh, we can translate the function spec to proc p f (..., result r) w : [φ, ψ]; r := e and the function call to p f (..., x) Whenever we refine a specification statement to a procedure call, we justify that step by proc. 7