CafeOBJ - Exemple de specicatii

1
1.1

Nivelul 1 - sorturi, operatii, ecuatii

[BASIC-CNAT] - specicatie ADT pentru multimea numerelor naturale.

1 2 3 4 5 6 7 8

module ! BASIC CNAT { signature { [ Nat ] op 0 : > Nat op s : Nat > Nat } }

[CNAT] - specicatie ADT pentru multimea numerelor naturale mpreun a cu operatiile: + pentru adunarea a dou numere naturale, a psub pentru scderea proprie a dou numere naturale, a a pentru nmultirea a dou numere naturale a i predicatele odd i even pentru testele de paritate. s s Listing 2: L1-CNAT
1 2 3 4 5 6 7 8 9 10 11 12

module ! CNAT { signature { > BASIC CNAT [ Nat ] op 0 : > Nat op s : Nat > Nat > CNAT op + : Nat Nat > Nat op p s u b : Nat Nat > Nat

13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

op

: Nat Nat > Nat

op odd : Nat > Bool op even : Nat > Bool } axioms { vars k m n : Nat eq eq eq eq + : Nat ( k + m) + m + 0 = m 0 + m = m m + s n = Nat > Nat n = k + (m + n ) . . . s (m + n ) . Nat > Nat . . n = m psub n .

p s u b : Nat eq 0 psub n = 0 eq m psub 0 = m eq ( s m) psub s eq eq eq eq eq eq eq eq eq } } : Nat ( k m) m s 0 = ( s 0) m m 0 = 0 m s n =

Nat > Nat n = k (m n ) . m . = m . . (m n ) + m .

odd : Nat > Bool & even : Nat > Bool odd ( 0 ) = f a l s e . even ( 0 ) = t r u e . odd ( s ( n ) ) = even ( n ) . even ( s ( n ) ) = odd ( n ) .

[BASIC-INT] - specicatie ADT pentru multimea numerelor ntregi. Listing 3: L1-BASIC-CINT

module ! BASICCINT { signature { [ Int ] op 0 : > I n t op s : I n t > I n t op : I n t > I n t } axioms { var n : I n t : I n t > I n t &

13 14 15 16 17 18

eq eq eq } }

s : I n t > I n t n = n . 0 = 0 . s s n = n .

1.2

Structuri algebrice

[SEMIGROUP] - specicatie algebric pentru semigrupuri. a Listing 4: L1-SEMIGROUP

module SEMIGROUP { signature { [ U ] op + : U U > U } axioms { vars x y z : U + : U U > U eq ( x + y ) + z = x + ( y + z ) . } }

[MONOID] - specicatie algebric pentru monoizi. a Listing 5: L1-MONOID

module MONOID { signature { [ U ] op 0 : > U op + : U U > U } axioms { vars x y z : U + : U eq ( x + y ) eq x + 0 = eq 0 + x = } } U + x x > U z = x + (y + z) . . .

[GROUP] - specicatie algebric pentru grupuri. a

Listing 6: L1-GROUP
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

module GROUP { signature { > MONOID [ U ] op 0 : > U op + : U U > U > GROUP op : U > U } axioms { vars x y z : U + : U eq ( x + y ) eq x + 0 = eq 0 + x = eq eq eq eq eq } } U + x x > U z = x + (y + z) . . . U 0 . = 0 . . = ( y ) + ( x ) .

: U > x + x = ( x ) + x x = x 0 = 0 . (x + y)

1.3

Structuri de date

[BASIC-CNAT-LIST] - specicatie ADT pentru liste de numere naturale. Listing 7: L1-BASIC-CNAT-LIST

module ! BASICCNAT LIST { signature { > BASIC CNAT [ Nat ] op 0 : > Nat op s : Nat > Nat > BASICCNAT LIST [ List ] op [ ] : > L i s t op ( : ) : Nat L i s t > L i s t }

15

[CNAT-LIST] - specicatie ADT pentru liste de numere naturale mpreun a cu operatiile: ++ pentru concatenarea a dou liste, a length pentru lungimea unei liste, reverse pentru inversarea unei liste i testul de apartenet a unui numr natural unei liste in . s a a Listing 8: L1-CNAT-LIST
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

module ! CNAT LIST { signature { > BASIC CNAT [ Nat ] op 0 : > Nat op s : Nat > Nat > BASICCNAT LIST [ List ] op [ ] : > L i s t op ( : ) : Nat L i s t > L i s t > CNAT LIST op ++ : L i s t L i s t > L i s t op l e n g t h : L i s t > Nat op r e v e r s e : L i s t > L i s t op i n : Nat L i s t > Bool } axioms { vars m n : Nat vars l k j : L i s t eq eq eq eq ++ : L i s t L i s t > L i s t ( l ++ k ) ++ j = l ++ ( k ++ j ) . l ++ [ ] = l . [ ] ++ l = l . (m : l ) ++ k = m : ( l ++ k ) .

l e n g t h : L i s t > Nat eq l e n g t h ( [ ] ) = 0 . eq l e n g t h (m : l ) = s l e n g t h ( l ) . r e v e r s e : L i s t > L i s t eq r e v e r s e ( [ ] ) = [ ] .

37 38 39 40 41 42 43

eq r e v e r s e (m : l ) = r e v e r s e ( l ) ++ (m : i n : Nat L i s t > Bool eq m i n [ ] = f a l s e . eq m i n ( n : l ) = m == n o r m i n l . } }

[])

2
2.1

Nivelul 2 - ierarhii de sorturi

[BASIC-CNAT] - specicatie ADT pentru multimea numerelor naturale. Listing 9: L2-BASIC-CNAT

module ! BASIC CNAT { signature { [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat } }

[CNAT] - specicatie ADT pentru multimea numerelor naturale mpreun a cu operatiile: + pentru adunarea a dou numere naturale, a psub pentru scderea proprie a dou numere naturale, a a pentru nmultirea a dou numere naturale, a udiv pentru partea ntreag superioar a artirii, a a mp ldiv pentru partea ntreag inferioar a artirii, a a mp cafeobj pentru restul artirii, mp gcd pentru cel mai mare divizor comun al dou numere a i predicatele odd i even pentru testele de paritate. s s Listing 10: L2-CNAT
1 2 3 4 5

module ! CNAT { signature { > BASIC CNAT [ Zero NzNat < Nat ]

6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

op 0 : > Zero op s : Nat > NzNat > op op op op op op op op op CNAT + : Nat Nat > Nat + : NzNat NzNat > NzNat p s u b : Nat Nat > Nat : Nat Nat > Nat : NzNat NzNat > NzNat u d i v : Nat NzNat > Nat u d i v : NzNat NzNat > NzNat ldiv : Nat NzNat > Nat mod : Nat NzNat > Nat

op odd : Nat > Bool op even : Nat > Bool op gcd : Nat Nat > Nat op gcd : NzNat NzNat > NzNat } axioms { vars k m n : Nat vars p q : NzNat eq eq eq eq + : Nat ( k + m) + m + 0 = m 0 + m = m m + s n = Nat > Nat n = k + (m + n ) . . . s (m + n ) . Nat > Nat . . n = m psub n .

p s u b : Nat eq 0 psub n = 0 eq m psub 0 = m eq ( s m) psub s eq eq eq eq eq : Nat ( k m) m s 0 = ( s 0) m m 0 = 0 m s n =

Nat > Nat n = k (m n ) . m . = m . . (m n ) + m .

u d i v : Nat NzNat > Nat eq 0 udiv q = 0 . eq p udiv q = s ( ( p psub q ) udiv q ) . l d i v : Nat NzNat > Nat eq m l d i v q = ( ( s m) udiv q ) psub s 0 .

56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

mod : Nat NzNat > Nat eq m mod q = m psub ( q (m l d i v q ) ) . eq eq eq eq odd : Nat > Bool & even : Nat > Bool odd ( 0 ) = f a l s e . even ( 0 ) = t r u e . odd ( s ( n ) ) = even ( n ) . even ( s ( n ) ) = odd ( n ) .

gcd : Nat Nat > Nat eq gcd (m, 0 ) = m . eq gcd (m, q ) = gcd ( q , m mod q ) . } }

[BASIC-INT] - specicatie ADT pentru multimea numerelor ntregi. Listing 11: L2-BASIC-CINT
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

module ! BASICCINT { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > BASICCINT [ NzNat < NzInt ] [ Nat NzInt < I n t ] op op op s : NzNat > NzInt : I n t > I n t : I n t > I n t

} axioms { var n : Nat eq eq eq } } : I n t > I n t & s : I n t > I n t n = n . 0 = 0 . s s n = n .

2.2

Structuri de date

[BASIC-CNAT-LIST] - specicatie ADT pentru liste de numere naturale. 8

Listing 12: L2-BASIC-CNAT-LIST

module ! BASICCNAT LIST { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > BASICCNAT LIST [ NEList < L i s t ] op [ ] : > L i s t op ( : ) : Nat L i s t > NEList } }

[CNAT-LIST] - specicatie ADT pentru liste de numere naturale mpreun a cu operatiile: head pentru primul element al unei liste nevide, tail pentru coada unei liste nevide, ++ pentru concatenarea a dou liste, a length pentru lungimea unei liste, reverse pentru inversarea unei liste, min pentru minimul unei liste nevide i testul de apartenet a unui numr natural unei liste in . s a a Listing 13: L2-CNAT-LIST
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

module ! CNAT LIST { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > BASICCNAT LIST [ NEList < L i s t ] op [ ] : > L i s t op ( : ) : Nat L i s t > NEList > CNAT LIST

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

op op op op op op

head : NEList > Nat t a i l : NEList > L i s t ++ : L i s t L i s t > L i s t l e n g t h : L i s t > Nat r e v e r s e : L i s t > L i s t in : Nat L i s t > Bool

op < : Nat Nat > Bool op min : Nat Nat > Nat op min : NEList > Nat } axioms { vars m n : Nat vars l k j : L i s t var p : NEList head : NEList > Nat eq head (m : l ) = m . t a i l : NEList > Nat eq t a i l (m : l ) = l . eq eq eq eq ++ : L i s t L i s t > L i s t ( l ++ k ) ++ j = l ++ ( k ++ j ) . l ++ [ ] = l . [ ] ++ l = l . (m : l ) ++ k = m : ( l ++ k ) .

l e n g t h : L i s t > Nat eq l e n g t h ( [ ] ) = 0 . eq l e n g t h (m : l ) = s l e n g t h ( l ) . r e v e r s e : L i s t > L i s t eq r e v e r s e ( [ ] ) = [ ] . eq r e v e r s e (m : l ) = r e v e r s e ( l ) ++ (m : : Nat L i s t > Bool i n eq m i n [ ] = f a l s e . eq m i n ( n : l ) = m == n o r m i n l . < : eq 0 < s eq m < 0 eq s m < Nat Nat > Bool m = true . = false . s n = m< n .

[])

min : Nat Nat > Nat cq min (m, n ) = m i f m < n . cq min (m, n ) = n i f not m < n . min : NEList > Nat

10

66 67 68 69

eq min (m : [ ] ) = m . eq min (m : p ) = min (m, min ( p ) ) . } }

[CNAT-STACK] - specicatie ADT pentru stive de numere naturale. Listing 14: L2-CNAT-STACK
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

module ! CNAT STACK { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > CNAT STACK [ NEStack < Stack ] op n i l : > Stack op p u s h : Stack Nat > NEStack op pop : NEStack > Stack op top : NEStack > Nat } axioms { var m : Nat var q : Stack pop : NEStack > Stack eq pop ( q push m) = q . top : NEStack > I n t eq top ( q push m) = m . } }

[CNAT-QUEUE] - specicatie ADT pentru cozi de numere naturale. Listing 15: L2-CNAT-QUEUE
1 2 3 4 5 6 7 8 9

module ! CNAT QUEUE { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > CNAT QUEUE

11

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

[ NEQueue < Queue ] op n i l : > Queue op p u s h : Queue Nat > NEQueue op pop : NEQueue > Queue op end : NEQueue > Nat } axioms { var m : Nat var p : NEQueue pop : NEQueue > Queue eq pop ( n i l push m) = n i l . eq pop ( p push m) = pop ( p ) push m . end : NEQueue > I n t eq end ( n i l push m) = m . eq end ( p push m) = end ( p ) . } }

3
3.1

Nivelul 3 - atribute
Numere

[CNAT] - specicatie ADT pentru multimea numerelor naturale mpreun cu a operatiile: + pentru adunarea a dou numere naturale, a psub pentru scderea proprie a dou numere naturale, a a pentru nmultirea a dou numere naturale, a udiv pentru partea ntreag superioar a artirii, a a mp ldiv pentru partea ntreag inferioar a artirii, a a mp cafeobj pentru restul artirii, mp gcd pentru cel mai mare divizor comun al dou numere a i predicatele odd i even pentru testele de paritate. s s Listing 16: L3-CNAT
1 2 3

module ! CNAT { signature { > BASIC CNAT

12

4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

[ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > op op op op op op op op op CNAT + : Nat Nat > Nat { a s s o c comm i d r : 0 p r e c : 33} + : NzNat NzNat > NzNat { a s s o c comm i d r : 0 p r e c : 33} p s u b : Nat Nat > Nat { p r e c : 33} : Nat Nat > Nat { a s s o c comm i d r : ( s 0 ) p r e c : 31} : NzNat NzNat > NzNat { a s s o c comm i d r : ( s 0 ) p r e c : 31} u d i v : Nat NzNat > Nat { p r e c : 31} u d i v : NzNat NzNat > NzNat { p r e c : 31} ldiv : Nat NzNat > Nat { p r e c : 31} mod : Nat NzNat > Nat { p r e c : 31}

op odd : Nat > Bool op even : Nat > Bool op gcd : Nat Nat > Nat op gcd : NzNat NzNat > NzNat } axioms { vars m n : Nat vars p q : NzNat + : Nat Nat > Nat eq m + s n = s (m + n ) . p s u b : Nat eq 0 psub n = 0 eq m psub 0 = m eq ( s m) psub s Nat > Nat . . n = m psub n .

: Nat Nat > Nat eq m 0 = 0 . eq m s n = m n + m . u d i v : Nat NzNat > Nat eq 0 udiv q = 0 . eq p udiv q = s ( ( p psub q ) udiv q ) . : Nat NzNat > Nat l d i v eq m l d i v q = ( s m) udiv q psub s 0 . mod : Nat NzNat > Nat eq m mod q = m psub q (m l d i v q ) . odd : Nat > Bool &

13

54 55 56 57 58 59 60 61 62 63 64

eq eq eq eq

even : Nat > Bool odd ( 0 ) = f a l s e . even ( 0 ) = t r u e . odd ( s ( n ) ) = even ( n ) . even ( s ( n ) ) = odd ( n ) .

gcd : Nat Nat > Nat eq gcd (m, 0 ) = m . eq gcd (m, q ) = gcd ( q , m mod q ) . } }

[CINT] - specicatie ADT pentru multimea numerelor ntregi mpreun cu a operatiile: + pentru adunarea a dou numere a ntregi, pentru scderea a dou numere a a ntregi, psub pentru scderea proprie a dou numere naturale, a a pentru nmultirea a dou numere a ntregi, udiv pentru partea ntreag superioar a artirii, a a mp ldiv pentru partea ntreag inferioar a artirii, a a mp cafeobj pentru restul artirii, mp abs pentru valoarea absolut a unui numr a a ntreg, gcd pentru cel mai mare divizor comun al dou numere a i predicatele odd i even pentru testele de paritate. s s Listing 17: L3-CINT
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

module ! CINT { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > BASICCINT [ NzNat < NzInt ] [ Nat NzInt < I n t ] op op op s : NzNat > NzInt : I n t > I n t : I n t > I n t

14

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

op s > op op op op op op op op op op op op op

: Nat > Nat

CINT + : I n t I n t > I n t { a s s o c comm i d r : 0 p r e c : 33} + : NzInt NzInt > NzInt { a s s o c comm i d r : 0 p r e c : 33} : I n t I n t > I n t { p r e c : 33} p s u b : Nat Nat > Nat { p r e c : 33} : : : udiv udiv udiv ldiv ldiv mod I n t I n t > I n t { a s s o c comm i d r : ( s 0 ) p r e c : 31} NzInt NzInt > NzInt { a s s o c comm i d r : ( s 0 ) p r e c : 31} Nat Nat > Nat { a s s o c comm i d r : ( s 0 ) p r e c : 31} : I n t NzInt > I n t { p r e c : 31} : NzInt NzInt > NzInt { p r e c : 31} : NzNat NzNat > NzNat { p r e c : 31} : I n t NzInt > I n t { p r e c : 31} : Nat NzNat > Nat { p r e c : 31} : I n t NzNat > Nat { p r e c : 31}

op odd : I n t > Bool op even : I n t > Bool op abs : I n t > Nat { s t r a t : ( 1 0 ) } op gcd : I n t I n t > Nat op gcd : NzInt NzInt > NzNat } axioms vars vars vars { m n : Nat a b : Int p q : NzNat

> BASICCINT : I n t > I n t & s : I n t > I n t eq n = n . eq 0 = 0 . eq s s n = n . > CINT + : eq m + s eq ( s m) eq m +

Int n = + n

I n t > I n t s (m + n ) . s n = m + n . = (m + n ) .

: I n t I n t > I n t eq a b = a + b . p s u b : Nat Nat > Nat eq 0 psub n = 0 . eq m psub 0 = m .

15

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

eq ( s m) psub s n = m psub n . eq eq eq eq eq eq eq eq eq eq eq eq eq m m m m : 0 s Int = 0 n = n = n I n t > I n t . m n + m . (m n ) . = m n . NzInt > I n t . ( ( p q ) udiv q ) . (m l d i v q ) . (m l d i v q ) . = m udiv q .

udiv : 0 udiv q p udiv q m udiv m udiv m udiv ldiv : m ldiv q m ldiv m ldiv m ldiv

Int = 0 = s q = q = q

I n t NzInt > I n t = ( s m) udiv q psub s 0 . q = (m udiv q ) . q = (m udiv q ) . q = m ldiv q .

mod : I n t NzNat > Nat eq m mod q = m psub q (m l d i v q ) . eq m mod q = ( q psub m mod q ) mod q . eq eq eq eq eq eq odd : I n t > Bool & even : I n t > Bool odd ( 0 ) = f a l s e . even ( 0 ) = t r u e . odd ( s ( n ) ) = even ( n ) . even ( s ( n ) ) = odd ( n ) . odd( m) = odd (m) . even( m) = even (m) .

abs : I n t > Nat eq abs (m) = m . eq abs( m) = m . eq eq eq eq eq } } gcd : I n t I n t > Nat gcd (m, 0 ) = m . gcd (m, q ) = gcd ( q , m mod q ) . gcd (m, n ) = gcd (m, n ) . gcd( m, n ) = gcd (m, n ) . gcd( m, n ) = gcd (m, n ) .

16

3.2

Structuri algebrice
Listing 18: L3-SEMIGROUP

[SEMIGROUP] - specicatie algebric pentru semigrupuri. a

1 2 3 4 5 6 7

[MONOID] - specicatie algebric pentru monoizi. a Listing 19: L3-MONOID

module MONOID { signature { [ U ] op 0 : > U op + : U U > U { a s s o c i d r : 0} } }

[GROUP] - specicatie algebric pentru grupuri. a Listing 20: L3-GROUP

module GROUP { signature { > MONOID [ U ] op 0 : > U op + : U U > U { a s s o c i d r : 0} > GROUP op : U > U } axioms { vars x y : U eq eq eq eq eq } } : U > x + x = ( x ) + x x = x 0 = 0 . (x + y) U 0 . = 0 . . = ( y ) + ( x ) .

17

3.3

Structuri de date

[BASIC-CNAT-LIST] - specicatie ADT pentru liste de numere naturale. Listing 21: L3-BASIC-CNAT-LIST
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

module ! BASICCNAT LIST { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > BASICCNAT LIST [ NEList < L i s t ] op [ ] : > L i s t op ( : ) : Nat L i s t > NEList { p r e c : 25} } }

[CNAT-LIST] - specicatie ADT pentru liste de numere naturale mpreun a cu operatiile: head pentru primul element al unei liste nevide, tail pentru coada unei liste nevide, ++ pentru concatenarea a dou liste, a length pentru lungimea unei liste, reverse pentru inversarea unei liste, min pentru minimul unei liste nevide i testul de apartenet a unui numr natural unei liste in . s a a Listing 22: L3-CNAT-LIST
1 2 3 4 5 6 7 8 9 10 11 12

module ! CNAT LIST { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > BASICCNAT LIST [ NEList < L i s t ] op [ ] : > L i s t

18

13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

op ( : ) : Nat L i s t > NEList { p r e c : 25} > CNAT LIST op head : NEList > Nat op t a i l : NEList > L i s t op ++ : L i s t L i s t > L i s t { a s s o c i d r : ( [ ] ) } op l e n g t h : L i s t > Nat op r e v e r s e : L i s t > L i s t op i n : Nat L i s t > Bool op < : Nat Nat > Bool op min : Nat Nat > Nat op min : NEList > Nat } axioms { vars m n : Nat vars l k : L i s t var p : NEList head : NEList > Nat eq head (m : l ) = m . t a i l : NEList > Nat eq t a i l (m : l ) = l . ++ : L i s t L i s t > L i s t eq (m : l ) ++ k = m : ( l ++ k ) . l e n g t h : L i s t > Nat eq l e n g t h ( [ ] ) = 0 . eq l e n g t h (m : l ) = s l e n g t h ( l ) . r e v e r s e : L i s t > L i s t eq r e v e r s e ( [ ] ) = [ ] . eq r e v e r s e (m : l ) = r e v e r s e ( l ) ++ m : : Nat L i s t > Bool i n eq m i n [ ] = f a l s e . eq m i n n : l = m == n o r m i n l . < : eq 0 < s eq m < 0 eq s m < Nat Nat > Bool m = true . = false . s n = m< n .

[]

min : Nat Nat > Nat cq min (m, n ) = m i f m < n . cq min (m, n ) = n i f not m < n . min : NEList > Nat

19

63 64 65 66

eq min (m : [ ] ) = m . eq min (m : p ) = min (m, min ( p ) ) . } }

[BASIC-CNAT-SET] - specicatie ADT pentru multimi de numere natu rale. Listing 23: L3-BASIC-CNAT-SET
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

module BASICCNAT SET { signature { > BASIC CNAT [ Zero NzNat < Nat ] op 0 : > Zero op s : Nat > NzNat > BASICCNAT SET [ Nat < Sequence ] [ Set ] op n i l : > Sequence op : Sequence Sequence > Sequence { a s s o c comm i d : n i l idem } op { } : Sequence > S e t op emptyset : > S e t } axioms { { } : Sequence > S e t eq { n i l } = emptyset . } }

4
4.1

Nivelul 4 - importuri
Numere

[CNAT] - specicatie ADT pentru multimea numerelor naturale mpreun cu a operatiile: + pentru adunarea a dou numere naturale, a psub pentru scderea proprie a dou numere naturale, a a pentru nmultirea a dou numere naturale, a udiv pentru partea ntreag superioar a artirii, a a mp ldiv pentru partea ntreag inferioar a artirii, a a mp

20

 cafeobj pentru restul artirii, mp gcd pentru cel mai mare divizor comun al dou numere a i predicatele odd i even pentru testele de paritate. s s Listing 24: L4-CNAT
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

i n p u t L4BASIC CNAT. c a f e o b j module ! CNAT { imports { protecting (BASIC CNAT) } signature { op + : Nat Nat > Nat { a s s o c comm i d r : 0 p r e c : 33} op + : NzNat NzNat > NzNat { a s s o c comm i d r : 0 p r e c : 33} op p s u b : Nat Nat > Nat { p r e c : 33} op op op op op op : Nat Nat > Nat { a s s o c comm i d r : ( s 0 ) p r e c : 31} : NzNat NzNat > NzNat { a s s o c comm i d r : ( s 0 ) p r e c : 31} u d i v : Nat NzNat > Nat { p r e c : 31} u d i v : NzNat NzNat > NzNat { p r e c : 31} ldiv : Nat NzNat > Nat { p r e c : 31} mod : Nat NzNat > Nat { p r e c : 31}

op odd : Nat > Bool op even : Nat > Bool op gcd : Nat Nat > Nat op gcd : NzNat NzNat > NzNat } axioms { vars m n : Nat vars p q : NzNat + : Nat Nat > Nat eq m + s n = s (m + n ) . p s u b : Nat eq 0 psub n = 0 eq m psub 0 = m eq ( s m) psub s Nat > Nat . . n = m psub n .

: Nat Nat > Nat eq m 0 = 0 . eq m s n = m n + m . u d i v : Nat NzNat > Nat eq 0 udiv q = 0 . eq p udiv q = s ( ( p psub q ) udiv q ) .

21

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

l d i v : Nat NzNat > Nat eq m l d i v q = ( s m) udiv q psub s 0 . mod : Nat NzNat > Nat eq m mod q = m psub q (m l d i v q ) . eq eq eq eq odd : Nat > Bool & even : Nat > Bool odd ( 0 ) = f a l s e . even ( 0 ) = t r u e . odd ( s ( n ) ) = even ( n ) . even ( s ( n ) ) = odd ( n ) .

gcd : Nat Nat > Nat eq gcd (m, 0 ) = m . eq gcd (m, q ) = gcd ( q , m mod q ) . } }

[BASIC-CINT] - specicatie ADT pentru multimea numerelor ntregi. Listing 25: L4-BASIC-CINT
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

i n p u t L4BASIC CNAT. c a f e o b j module ! BASICCINT { imports { protecting (BASIC CNAT) } signature { [ NzNat < NzInt ] [ Nat NzInt < I n t ] op op op s : NzNat > NzInt : I n t > I n t : I n t > I n t

} axioms { var n : Nat eq eq eq } } : I n t > I n t & s : I n t > I n t n = n . 0 = 0 . s s n = n .

[CINT] - specicatie ADT pentru multimea numerelor ntregi mpreun cu a operatiile: 22

 + pentru adunarea a dou numere a ntregi, pentru scderea a dou numere a a ntregi, pentru nmultirea a dou numere a ntregi, udiv pentru partea ntreag superioar a artirii, a a mp ldiv pentru partea ntreag inferioar a artirii, a a mp cafeobj pentru restul artirii, mp abs pentru valoarea absolut a unui numr a a ntreg, gcd pentru cel mai mare divizor comun al dou numere a i predicatele odd i even pentru testele de paritate. s s Listing 26: L4-CINT
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

i n p u t L4BASICCINT . c a f e o b j i n p u t L4 CNAT. c a f e o b j module ! CINT { imports { protecting (BASICCINT) protecting (CNAT) } signature { op + : I n t I n t > I n t { a s s o c comm i d r : 0 p r e c : 33} op + : NzInt NzInt > NzInt { a s s o c comm i d r : 0 p r e c : 33} op : I n t I n t > I n t { p r e c : 33} op op op op op op : I n t I n t > I n t { a s s o c comm i d r : ( s 0 ) p r e c : 31} : NzInt NzInt > NzInt { a s s o c comm i d r : ( s 0 ) p r e c : 31} u d i v : I n t NzInt > I n t { p r e c : 31} u d i v : NzInt NzInt > NzInt { p r e c : 31} ldiv : I n t NzInt > I n t { p r e c : 31} mod : I n t NzNat > Nat { p r e c : 31}

op odd : I n t > Bool op even : I n t > Bool op abs : I n t > Nat { s t r a t : ( 1 0 ) } op gcd : I n t I n t > Nat op gcd : NzInt NzInt > NzNat } axioms { vars m n : Nat vars a b : I n t var q : NzNat

23

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

+ : I n t I n t > I n t eq ( s m) + s n = m + n . eq m + n = (m + n ) . : I n t I n t > I n t eq a b = a + b . : I n t I n t > I n t eq m n = (m n ) . eq m n = m n . u d i v : eq m udiv eq m udiv eq m udiv l d i v : eq m l d i v eq m l d i v eq m l d i v Int q = q = q Int q = q = q NzInt > I n t (m l d i v q ) . (m l d i v q ) . = m udiv q . NzInt > I n t (m udiv q ) . (m udiv q ) . = m ldiv q .

mod : I n t NzNat > Nat eq m mod q = ( q psub m mod q ) mod q . odd : I n t > Bool eq odd( m) = odd (m) . even : I n t > Bool eq even( m) = even (m) . abs : I n t > Nat eq abs (m) = m . eq abs( m) = m . eq eq eq } } gcd : I n t I n t gcd (m, n ) = gcd( m, n ) = gcd( m, n ) > Nat gcd (m, n ) . gcd (m, n ) . = gcd (m, n ) .

[BASIC-CRAT] - specicatie ADT pentru multimea numerelor rationale. Listing 27: L4-BASIC-CRAT
1 2 3 4 5

i n p u t L4CINT . c a f e o b j module ! BASIC CRAT { imports { protecting (CINT)

24

6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

} signature { [ NzInt < NzRat ] [ I n t NzRat < Rat ] op op / / : NzRat NzRat > NzRat { p r e c : 27} : Rat NzRat > Rat { p r e c : 27}

} axioms { vars m n : Nat vars p q : NzNat var r : NzInt vars a b : I n t eq eq eq eq eq cq } } / : Rat NzRat > Rat 0 / q = 0 . a / s 0 = a . a / q = a / q . (a / q) / ( r / p) = (a p) / (q r ) . (a / q) / r = a / (q r ) . r / q = ( r udiv gcd ( r , q ) ) / ( q udiv gcd ( r , q ) ) i f gcd ( r , q ) =/= s 0 .

[CRAT] - specicatie ADT pentru multimea numerelor rationale mpreun a cu operatiile: + pentru adunarea a dou numere rationale, a pentru scderea a dou numere rationale, a a pentru nmultirea a dou numere rationale. a Listing 28: L4-CRAT
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

i n p u t L4BASIC CRAT. c a f e o b j module ! CRAT { imports { protecting (BASIC CRAT) } signature { op : Rat > Rat op : NzRat > NzRat op op op op + + : Rat Rat > Rat { a s s o c comm i d r : 0 p r e c : 33} : NzRat NzRat > NzRat { a s s o c comm i d r : 0 p r e c : 33} : Rat Rat > Rat { p r e c : 33} : Rat Rat > Rat { a s s o c comm i d r : ( s 0 ) p r e c : 31}

25

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

op : NzRat NzRat > NzRat { a s s o c comm i d r : ( s 0 ) p r e c : 31} } axioms { vars p q : NzNat vars a b : I n t : Rat > Rat eq ( a / p ) = a / p . + : Rat Rat > Rat eq a / p + b / q = ( a q + b p ) / ( p q ) . eq a / p + b = ( a + b p ) / p . : eq a / p eq a / p eq a b Rat b b / q Rat > Rat / q = (a q b p) / (p q) . = (a b p) / p . = (a q b) / q .

: Rat Rat > Rat eq a / p b / q = ( a b ) / ( p q ) . eq a / p b = ( a b ) / p . } }

4.2

Structuri algebrice

[GROUP] - specicatie algebric pentru grupuri. a Listing 29: L4-GROUP

i n p u t L4 MONOID. c a f e o b j module GROUP { imports { using (MONOID) } signature { op : U > U } axioms { vars x y : U eq eq eq eq eq } : U > x + x = ( x ) + x x = x 0 = 0 . (x + y) U 0 . = 0 . . = ( y ) + ( x ) .

26

20

4.3

Structuri de date

[BASIC-NAT-LIST] - specicatie ADT pentru liste de numere naturale. Listing 30: L4-BASIC-CNAT-LIST
1 2 3 4 5 6 7 8 9 10 11

module ! BASICNAT LIST { imports { protecting (NAT) } signature { [ NEList < L i s t ] op [ ] : > L i s t op ( : ) : Nat L i s t > NEList { p r e c : 25} } }

[NAT-LIST] - specicatie ADT pentru liste de numere naturale mpreun a cu operatiile: head pentru primul element al unei liste nevide, tail pentru coada unei liste nevide, ++ pentru concatenarea a dou liste, a length pentru lungimea unei liste, reverse pentru inversarea unei liste, min pentru minimul unei liste nevide i testul de apartenet a unui numr natural unei liste in . s a a Listing 31: L4-NAT-LIST
1 2 3 4 5 6 7 8 9 10 11 12

i n p u t L4BASICNAT LIST . c a f e o b j module ! NAT LIST { imports { protecting (BASICNAT LIST ) } signature { op head : NEList > Nat op t a i l : NEList > L i s t op ++ : L i s t L i s t > L i s t { a s s o c i d r : ( [ ] ) } op l e n g t h : L i s t > Nat op r e v e r s e : L i s t > L i s t

27

13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

op

in

: Nat L i s t > Bool

op min : Nat Nat > Nat op min : NEList > Nat } axioms { vars m n : Nat vars l k : L i s t var p : NEList head : NEList > Nat eq head (m : l ) = m . t a i l : NEList > Nat eq t a i l (m : l ) = l . ++ : L i s t L i s t > L i s t eq (m : l ) ++ k = m : ( l ++ k ) . l e n g t h : L i s t > Nat eq l e n g t h ( [ ] ) = 0 . eq l e n g t h (m : l ) = s l e n g t h ( l ) . r e v e r s e : L i s t > L i s t eq r e v e r s e ( [ ] ) = [ ] . eq r e v e r s e (m : l ) = r e v e r s e ( l ) ++ m : i n : Nat L i s t > Bool eq m i n [ ] = f a l s e . eq m i n n : l = m == n o r m i n l . min : Nat Nat > Nat cq min (m, n ) = m i f m < n . cq min (m, n ) = n i f not m < n . min : NEList > Nat eq min (m : [ ] ) = m . eq min (m : p ) = min (m, min ( p ) ) . } }

[]

[NAT-LIST-QUICKSORT] - specicatie pentru sortarea (quicksort) a unei liste de numere naturale. Listing 32: L4-NAT-LIST-QUICKSORT
1 2 3 4 5

i n p u t L4NAT LIST . c a f e o b j module ! NAT LISTQUICKSORT { imports { protecting (NAT LIST )

28

6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

} signature { op f i l t e r l t e : L i s t Nat > L i s t op f i l t e r g t : L i s t Nat > L i s t op quick s o r t : L i s t > L i s t } axioms { vars m n : Nat vars l k : L i s t var p : NEList f i l t e r l t e : L i s t Nat > L i s t eq f i l t e r l t e ( [ ] , n ) = [ ] . eq f i l t e r l t e (m : l , n ) = i f m <= n then m : f i l t e r l t e ( l , n) else f i l t e r l t e ( l , n) fi . f i l t e r g t : L i s t Nat > L i s t eq f i l t e r g t ( [ ] , n ) = [ ] . eq f i l t e r g t (m : l , n ) = i f m <= n then f i l t e r g t ( l , n) else m : f i l t e r g t ( l , n) fi .

quick s o r t : L i s t > L i s t eq quick s o r t ( [ ] ) = [ ] . eq quick s o r t (m : l ) = quick s o r t ( f i l t e r l t e ( l , m) ) ++ m : quick s o r t ( f i l t e r g t ( l , } }

[NAT-LIST-MERGESORT] - specicatie pentru sortarea (mergesort) a unei liste de numere naturale. Listing 33: L4-NAT-LIST-MERGESORT
1 2 3 4 5 6 7 8 9 10 11 12 13

i n p u t L4BASICNAT LIST . c a f e o b j module ! NAT LIST MERGESORT { imports { protecting (BASICNAT LIST ) } signature { op merge : L i s t L i s t > L i s t {comm} op getodd : L i s t > L i s t op geteven : L i s t > L i s t op merges o r t : L i s t > L i s t } axioms {

29

14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

vars m n : Nat vars l k : L i s t var p : NEList merge : L i s t L i s t > L i s t eq merge ( l , [ ] ) = l . eq merge (m : l , n : k ) = i f m < n then m : merge ( l , n : k ) else n : merge (m : l , k ) fi . eq eq eq eq eq eq eq } } getodd : L i s t > L i s t & geteven : L i s t > L i s t getodd ( [ ] ) = [ ] . getodd (m : l ) = m : get even ( l ) . geteven ( [ ] ) = [ ] . geteven (m : l ) = get odd ( l ) . merges o r t : L i s t > L i s t merges o r t ( [ ] ) = [ ] . merges o r t (m : [ ] ) = m : [ ] . merges o r t (m : p ) = merge ( merges o r t ( get odd (m : p ) ) , merges o r t ( get even (m : p ) ) ) .

[BASIC-INT-SET] - specicatie ADT pentru multimi de numere ntregi. Listing 34: L4-BASIC-INT-SET
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

module ! BASICINTSET { imports { protecting (INT) } signature { [ I n t < Sequence ] [ Set ] op n i l : > Sequence op : Sequence Sequence > Sequence { a s s o c comm i d : n i l idem } op { } : Sequence > S e t op emptyset : > S e t } axioms { { } : Sequence > S e t eq { n i l } = emptyset . } }

30

[INT-SET] - specicatie ADT pentru multimi de numere ntregi mpreun a cu operatiile: card pentru cardinalitate, U pentru reuniuna a dou multimi, a \ pentru diferenta a dou multimi a i testul de apartenent in . s a Listing 35: L4-INT-SET
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

i n p u t L4BASICINTSET . c a f e o b j module ! INTSET { imports { protecting (BASICINTSET) } signature { op i n : I n t Sequence > Bool : I n t S e t > Bool op i n op l e n g t h : Sequence > Nat { s t r a t : ( 1 0 ) } op c a r d : S e t > Nat op op U \ : S e t S e t > S e t { a s s o c comm i d : emptyset } : S e t S e t > S e t

} axioms { vars n m : I n t vars s t : Sequence var A : S e t : I n t Sequence > Bool i n eq n i n n i l = f a l s e . eq n i n m s = n == m o r n i n s . i n : I n t S e t > Bool eq n i n emptyset = f a l s e . eq n i n { s } = n i n s . l e n g t h : Sequence > Nat eq l e n g t h ( n i l ) = 0 . eq l e n g t h ( n s ) = l e n g t h ( s ) + 1 . c a r d : S e t > Nat eq c a r d ( emptyset ) = 0 . eq c a r d ( { s } ) = l e n g t h ( s ) . U : S e t S e t > S e t eq { s } U { t } = { s t } .

31

39 40 41 42 43 44 45 46 47 48 49

: S e t S e t > S e t . then A ( { s } \ A)

eq emptyset \ A = emptyset eq { n s } \ A = i f n i n A { s } \ else { n } U fi . } }

[INT-VECTOR] - specicatie ADT pentru vectori de numere ntregi mpreun a cu operatiile: ++ pentru concatenarea a doi vectori, [] pentru recuperarea unei componente a unui vector, []< pentru actualizarea unei componente a unui vector. Listing 36: L4-INT-VECTOR
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

module ! INT VECTOR { imports { protecting (INT) } signature { [ I n t < Sequence ] [ Vector ] : Sequence Sequence > Sequence { a s s o c } op op < > : Sequence > Vector op ++ : Vector Vector > Vector

op [ ] : Vector Nat > I n t op outo f bounds : > ? I n t op [ ]< : Vecto r Nat I n t > Vector } axioms { var i : Nat var k : NzNat vars m n : I n t vars s t : Sequence ++ : Vector Vector > Vector eq < s > ++ < t > = < s t > . [ ] : Vector Nat > I n t

32

28 29 30 31 32 33 34 35 36 37 38 39

eq eq eq eq eq eq eq eq } }

< < < <

n n n n

> s > s

[ > [ >

0 [ k [

] 0 ] k

= ] = ]

n . = n . outo f bounds . = < s > [ p(k) ] . Nat < m = < < n = < I n t > Vector > . m s > . > . n > ++ (< s >[ p ( k ) ]< m) .

< < < <

[ ]< : Vecto r n >[ 0 ]< m = n s >[ 0 ]< m n >[ k ]< m = n s >[ k ]< m

33