Semantyka i Weryfikacja Programów

Semantyka i Weryfikacja Programów - Laboratorium 7
Weryfikacja twierdzeń logicznych
Cel. Celem ćwiczenia jest zapoznanie się z metodą automatycznego dowodzenia twierdzeń, tzn.
weryfikacji, czy dane twierdzenie jest tautologią (twierdzenie prawdziwe nazywa się tautologią).
Przykładami takich problemów są:
- dowodzenie twierdzeń w klasycznym ujęciu, tzn. czy z założenia wynika teza (implikacja)
- badanie równoważności wyrażeń (np. wzory upraszczające)
- weryfikacja, czy program daje wynik zgodny ze swą specyfikacją
- weryfikacja, czy schemat elektroniczny, na którym ma być wzorowany program, realizuje
wymaganą funkcję.
Podstawowy program automatycznego weryfikatora tautologii zaprezentowano na wykładzie 5 i
następnych. Poniżej podano wersję zmodyfikowaną, wygodniejszą w użyciu i optymalniejszą pod
względem czasu obliczeń. Niżej omówiono jedynie różnice w stosunku do wersji oryginalnej
oprogramowania.
Deklaracja typu danych prop
Wprowadzono infiksowe konstruktory typu i zdefiniowano ich priorytety, Uzupełniono typ prop o
symboliczną prawdę i fałsz. Ułatwia to symboliczne zapisywanie wyrażeń rachunku zdań.
infix
infix
6
5
**;
++;
datatype prop =
|
|
|
|
At of string
!! of prop
++ of prop * prop
** of prop * prop
T | F;
(*
(*
(*
(*
(*
atom
*)
negacja *)
alternatywa - suma
*)
koniunkcja - iloczyn *)
symboliczne prawda i falsz *)
Przykład
Poniżej zdefiniowano atomy i zapisano symbolicznie wyrażenie p or q and r.
val p = At "p"; val q = At "q"; val r = At "r";
val wyraz = p ++ q ** r; (* uzycie nawiasow nie jest konieczne *)
Implikacja i równoważność. Zdefiniowano je infiksowo jako funkcje o odpowiednich
priorytetach:
infix 4 --> ;
fun p --> q = !!p ++ q;
infix 4 <=> ;
fun p<=>q = p ** q
++
!!p ** !! q;
Przekształcenie do normalnej formy negacyjnej. Funkcję nnf weryfikatora uzupełniono o nowe
warianty z wprowadzonymi konstruktorami T i F.
fun
|
|
|
|
|
|
|
|
|
|
nnf
nnf
nnf
nnf
nnf
nnf
nnf
nnf
nnf
nnf
nnf
(At a)
(!!(At a))
(!!T)
(!!F)
T
F
(!!(!! p))
(!!((p++q)))
(!!((p**q))
(p**q)
(p++q)
=
=
=
=
=
=
=
=
=
=
=
At a
!!(At a)
F (* zaprzeczenie prawdy jest falszem *)
T
T (* brak negacji, konstruktor pozostaje *)
F
nnf p
(* podwojna negacja *)
nnf (!!p ** !!q) (* negacja sumy,iloczyn negacji *)
nnf (!!p ++ !!q)
(nnf p) ** (nnf q)
(nnf p) ++ (nnf q);
-1-
Kanoniczna forma koniunkcyjna. Przytoczone niżej funkcje roz i cnf nie wymagają
wprowadzenia zmian.
fun
roz(p,q**r) = roz(p,q) ** roz(p,r)
(* p+q*r = (p+q)*(p+r) *)
| roz(q**r,p) = roz(q,p) ** roz(r,p)
(* q*r+p = (q+p)*(r+p) *)
| roz(p,q)
= p ++ q ;
(* zaden skladnik nie jest koniunkcja *)
fun
cnf (p ++ q) = roz(cnf p , cnf q) (* Alt zastapione przez roz (j.w.) *)
| cnf (p ** q) = (cnf p) ** (cnf q) (* rozklad skladnikow iloczynu
*)
| cnf p
= p;
(* pojedynczy atom lub stala
*)
Przebieg weryfikacji. W alternatywach oprócz atomów i ich negacji występują teraz
konstruktor T i F. Sprawdzanie poprawności wykonuje się w dwóch etapach:
1. Sprawdzenie za pomocą podanej niżej funkcji chk_alt , czy w alternatywie znajduje się
T (wtedy jest ona tautologią).
(* sprawdzenie, czy w alternatywie znajduje się T *)
fun chk_alt (T)
= true (* tak, alternatywa jest tautologia *)
| chk_alt(p++q) = (chk_alt p) orelse (chk_alt q)
| chk_alt _
= false;
2. Wyznaczenie części wspólnej list atomów zanegowanych i niezanegowanych, podobnie
jak w dotychczasowym weryfikatorze. Funkcje neg i pos uzupełniono o warianty z
nowymi konstruktorami T i F (ale są one pomijane).
exception NieCNF;
(* wyrazenie nie przeksztalcone do CNF *)
fun
|
|
|
|
|
pos
pos
pos
pos
pos
pos
(At a)
= [a]
(!! (At _)) = []
(p++q)
= pos p @ pos q
T
= []
F
= []
_
= raise NieCNF;
fun
|
|
|
|
|
neg
neg
neg
neg
neg
neg
(At _)
(!! (At a))
(p ++ q)
T
F
_
infix mem;
fun x mem []
=
=
=
=
=
=
[]
[a]
neg p @ neg q
[]
[]
raise NieCNF;
= false | x mem (y::l) = (x=y) orelse (x mem l);
(* czesc wspolna dwu list *)
fun inter ([],ys)=[]
| inter (x::xs,ys) = if x mem ys then x::inter(xs,ys)
else
inter(xs,ys);
Funkcja sprawdzająca
(* funkcja sprawdzajaca *)
fun taut (p**q) = taut p andalso taut q(* p,q - czynniki Kon *)
| taut p
= (chk_alt p) orelse ([] <> inter(pos p, neg p));
fun
check(s) = taut (cnf (nnf (s)));
(* zbiorcza funkcja *)
Cały przedstawiony wyżej program znajduje się w załączonym pliku „lab_5.sml”.
-2-
Przykłady
P.1. Dowód twierdzenia
Prawdziwość koniunkcji implikuje prawdziwość alternatywy, tzn. p ⋅ q → ( p + q )
val p = At "p" and q = At "q";
(* deklaracje symboli jako atomy *)
val tw = p ** q --> (p ++ q);
(* symboliczny zapis twierdzenia *)
check tw;
(* automatyczna weryfikacja *)
P.2. Równoważność wzorów
A. Wykazanie, że wyrażenie p + p ⋅ p + q jest prawdziwe (true) dla dowolnych p, q
val wyr = p ++ !! (p ** !!(p ++ q));
(* zapis wyrażenia *)
check wyr; (* weryfikacja *)
B. Sprawdzenie, że wyrażenia p ≡ q i ( p → q ) ⋅ (q → p) są równoważne.
val wz1 = p <=> q;
(* pierwszy wzor *)
val wz2 = (p-->q) ** (q-->p); (* drugi *)
val tw = wz1 <=> wz2; (* twierdzenie o ich rownowazności *)
check tw; (* weryfikacja *)
P.3. Sterowanie logiczne
Dany jest mikrokomputerowy układ START-STOP włączania i wyłączania pewnej maszyny.
s ta r t
s ta n
s to p
µP
out
M
s ta n
Specyfikacja programu ma postać: OUT = ( START + STAN ) ⋅ STOP
Sterowanie jest realizowane przez program mikroprocesora w dziedzinie boolowskiej. Jego zapis
zgodny z metodą FBD (zob. wykł. 6) jest reprezentowany w postaci bramek AND, OR, NOT
(bloków funkcyjnych) w postaci układu
s ta r t
s ta n
s to p
O R
NO T
y1
AND
out
y2
Niżej podano przykładowy program realizujący takie sterowanie (wartość logiczna – true,
false).
(* funkcje biblioteczne występujące na schemacie *)
fun OR(x1,x2) = x1 orelse x2;
fun AND(x1,x2) = x1 andalso x2;
fun NOT(x)
= not x;
(* funkcja sterujaca *)
fun start_stop(start, stan,
let val y1 = OR(start,stan)
val y2 = NOT(stop)
val y3 = AND(y1,y2);
in y3 end;
stop) =
(* wyjście bloku pierwszego *)
(* wyjście bloku drugiego
*)
(* wyjście bloku trzeciego *)
(* obliczenie wyjscia ukladu - sterowania *)
val out = start_stop(true, false, false); (* rezultat bool *)
-3-
Weryfikacja programu sterującego
Realizacja i weryfikacja w dziedzinie symbolicznej jest następująca:
(* definicja atomów reprezentujacych sygnaly *)
val START = At "start" and STOP = At "stop" and STAN = At "stan";
(* funkcje symboliczne *)
fun OR_S(X1,X2) = X1++X2; fun AND_S(X1,X2) = X1**X2; fun NOT_S(X) = !!X;
(* symboliczne wykonanie – odpowiadajace funkcji start_stop*)
val Y1 = OR_S(START,STAN);
val Y2 = NOT_S(STOP);
val Y3 = AND_S(Y1,Y2);
val OUT = Y3; (* symboliczny rezultat wykonania programu *)
val SPEC_OUT = (START ++ STAN) ** !! STOP; (* specyfikacja symboliczna *)
(* twierdzenie o rownowaznosci specyfikacji i wyniku *)
val tw = SPEC_OUT <=> OUT;
check tw;
(* weryfikacja - rezultatem jest true *)
P. 4. Schematy elektroniczne
Programy realizujące funkcje zabezpieczeń są często wzorowane na sprawdzonych rozwiązaniach
sprzętowych. Na poniższych rysunkach pokazano kolejno:
1) ideę funkcjonowania multipleksera 4:1 (4WE, 1WY)
2) symbol logiczny multipleksera
3) realizację funkcji
y = abc + abc + ab
4) realizację funkcji
y = abcd + abcd + abc d + abc d + abc d + abcd + abc d + abc d
(1)
(2)
3
S
S
2
out
0
1
2
3
0
1
1
(3)
b
a
S
S
1
MUX
1
S
0
S
0
0
out
(4)
b
a
0
1
S
S
MUX
1
c
c
0
1
2
3
0
1
MUX
y
c
d
-4-
c
0
1
2
3
y
Specyfikacja i realizacja multipleksera
Specyfikację można zapisać jako y= !s0·!s1·x0 + !s0· s1·x1 + !s0· s1·x2 + s0· s1· x3.
Realizacja multipleksera w dziedzinie boolowskiej jest następująca:
fun mux4(s0,s1,x0,x1,x2,x3) =
if not s0 andalso not s1 then x0
else if s0 andalso not s1 then x1
else if not s0 andalso s1 then x2
else x3;
Specyfikację można zapisać symbolicznie stosując pomocnicze wielowejściowe funkcje koniunkcji
i alternatywy.
(* realizacja symboliczna funkcji wielowejsciowych *)
fun OR4_S(X1,X2,X3,X4) = X1 ++ X2 ++ X3 ++ X4;
fun AND3_S(X1,X2,X3)
= X1 ** X2 ** X3;
fun MUX4_S(S0,S1,X0,X1,X2,X3)
OR4_S(
AND3_S(!! S0, !!S1,
AND3_S(
S0, !!S1,
AND3_S(!! S0,
S1,
AND3_S(
S0,
S1,
);
=
X0),
X1),
X2),
X3)
Sprawdzenie realizacji funkcji z rys. 3
(* realizacja symboliczna funkcji z rys.3 *)
val A = At "A" and B = At "B" and C = At "C";
val uklad = MUX4_S(B, A, F, T, C, !!C);
(* specyfikacja *)
val spec = A ** B ** !!C ++ A ** !!B ** C ++ !!A ** B;
(* twierdzenie *)
val tw = uklad <=> spec;
(* sprawdzenie *)
check tw;
Rezultatem jest true, co potwierdza poprawność realizacji.
Sprawdzenie realizacji funkcji z rys. 4
(* realizacja symboliczna funkcji z rys.4 *)
val A = At "A" and B = At "B" and C = At "C"
and D = At "D";
fun NAND_S(X1,X2) = !! (X1 ** X2); (* definicja funkcji NAND *)
val Y1 = NAND_S(!!C,D);
val Y = MUX4_S(B, A, F, Y1, !!C, Y1);
(* specyfikacja *)
val spec =
A **
B **
!!A **
B **
A ** !!B **
A **
B **
(* twierdzenie *)
val tw = Y <=> spec;
check tw; (* sprawdzenie
C
!!C
!!C
!!C
**
D ++ !!A **
B **
C **
D ++
** !!D ++ !!A **
B **
C ** !!D ++
** !!D ++
A ** !!B ** !!C **
D ++
** !!D ++
A **
B **
C ** !!D ;
- trwa dlugo ok. 20 sekund!!!*)
Polecenia
-5-
1. Zweryfikuj formalnie podane niżej równoważności:
c d + cd = c
cd + c d + c d = cd
2. Zrealizuj (narysuj schemat) i zweryfikuj formalnie układ multipleksera zbudowanego
wyłącznie z wielowejściowych bramek NAND.
Wskazówki.
● Wykorzystaj specyfikację układu w postaci alternatywy koniunkcji.
● Skorzystaj z tożsamości: !(a·a) = !a
● Zastosuj w praktyce przekształcenia: a+b = !(!(a+b)) = !(!a·!b)
-6-
Zadania do samodzielnego rozwiązania
1. Udowodnij, że z założenia (a + b) ⋅ ( a → b) wynika teza a → b (implikacja).
2. Sprawdź formalnie, czy prawdziwe są następujące wzory ?
a)
ab + c a + bc = ab
b)
abc + abc = a
c)
a + abc = ab + a c
3. Jaką funkcję realizuje przedstawiony na poniższym rysunku układ? Wykaż formalnie.
b
a
S
S
0
1
MUX
1
0
1
2
3
f
4. Sprawdź formalnie które z poniższych wzorów są prawdziwe?
a) [( p → q) → r ] ≡ [ p → ( q → r )]
b) [( p ⇔ q ) ⇔ r ] ≡ [( p ⇔ q ) ⋅ ( q ⇔ r )]
5. Sprawdź formalnie które z poniższych wzorów są prawdziwe?
a) ( p + q) ⋅ ( p + r ) ⋅ ( q + r ) ≡ ( p + q ) ⋅ ( p + r )
b) q ⇒ [( p + q) ⇒ p ]
DX
0
n
6. Dekoder jest układem o n wejściach i 2 wyjściach. Do
dekodera 2:4 dołączono sygnały A, B. Zaproponuj układ,
który dołączony do wyjść dekodera odtworzy sygnały
A,B. Wykaż formalnie poprawność działania.
A
B
0
1
1
2
?
A
B
3
7. Wykaż słuszność następującego rozumowania:
Jeśli student nie złoży projektu, to nie zaliczy przedmiotu X. Jeśli student nie zaliczy przedmiotu
X, to nie przejdzie na następny rok. Zatem jeśli student przeszedł na następny rok, to znaczy, że
musiał złożyć projekt z przedmiotu X.
Wskazówka. Jako atomy można przyjąć następujące zdania logiczne: 1) student składa projekt,
2) przedmiot X zaliczony, 3) student przechodzi na następny rok.
-7-
8. Zaproponuj układ, który 4-bitowe słowo uzupełni 5-tym bitem parzystości (even), tzn.
słowo oryginalne
słowo z bitem parzystości
0
1
1
0
0
1
1
0
0
0
1
0
0
0
1
0
0
1
0
1
1
1
0
1
1
1
1
1
0
0
1
1
0
0
1
0
Jaką funkcję logiczną realizuje układ? Podaj specyfikację i zweryfikuj formalnie.
Wsk.: Użyj bramek EXOR
9. Wykaż, że poniższy układ realizuje podaną funkcję.
a
b
x = a(b + cd )
x
c
d
10. Koder ma zamieniać kod unitarny „1 z 10” na kod BCD. Jeżeli wyjściom a, b, c, d
przyporządkować wagi – a=1, b=2, c=4, d=8, to otrzymuje się następujące wyrażenia logiczne
a=x1+x3+x5+x7+x9
b=x2+x3+x6+x7
c=x4+x5+x6+x7
d=x8+x9
x1
x2
x3
...
x9
a
b
c
d
Zaproponuj programową realizację kodera i wykaż, że odpowiada ona specyfikacji.
-8-
11. Dwa spośród sześciu sygnałów sterujących odłącznikami transformatorów i odłącznikiem
sekcyjnym w stacji dwutransformatorowej mają postać
x =a+c ,
gdzie: a, b
z =e+a+c+b+d +c+d
– stany przekaźników podnapięciowych
(1 – jest napięcie (true))
c, d
– stany odłączników transformatorów
(1 – zamknięty)
e
– stan odłącznika sekcyjnego
(1 – zamknięty)
x
– sygnał otwierania odłącznika transformatora I (1 – otwieranie)
z
– sygnał zamykania odłącznika sekcyjnego (1 – zamykanie).
Narysuj schemat złożony z dowolnych bramek i zweryfikuj go.
12. Udowodnij formalnie, że następujące dwa układy kombinacyjnie nie generują identycznych
wyjść.
b
a
c
a
c
Y
Y
d
13. Górny moduł wyświetlacza 7-segmentowego jest zapalany zgodnie z funkcją
x = ab d + acd + bcd + abc
Zaproponuj układ złożony z multipleksera 4:1 i bramek, który zrealizuje taką funkcję. Wykaż
formalnie jego poprawność.
-9-