ISITCom Hammam Sousse

Examen A. U. : 2021 / 2022

Niveau : 1ére année MRID Date : 16 / 05 / 2022
Module : Méthodes Formelles Durée : 1H 30
Enseignant : Haykal Tej Session : Principale
Documents Autorisés : NON Nombre Total de Pages : 2

Exercice 1 : (17 points)

On veut modéliser en B un système d’enregistrement de l’attribution des places de passagers sur un avion.
La machine abstraite correspondante « réservationAvion » est partiellement définie de la manière suivante :

MACHINE réservationAvion

SETS
PERSONNE /* l’ensemble de toutes les personnes */
SIEGE /* l’ensemble de tous les sièges de cet avion */
REPONSE = {OK , déjaRéservé , nonRéservé , pasLeVotre , possèdePasDeRéservation}
SiègeCatégorie = {FirstClass , BusinessClass , economyClass}

CONSTANTS Max, SiègeType

PROPERTIES Max  N*  SiègeType  SIEGE  SiègeCatégorie  …………..

VARIABLES réservéPour

INVARIANTS réservéPour  PERSONNE  SIEGE  …………….

INITIALISATION
…………
OPERATIONS
……………..

Q1. Donner les clauses PROPERTIES, INVARIANTS et INITIALISATION compètes, sachant que :
(2,5 pts)

1. Chaque siège a une catégorie et de chaque catégorie il y’a au moins un siège.

2. Un même siège ne peut être réservé que pour une seule personne et une même personne ne doit pas
dépasser un nombre Max de sièges réservés.
3. L’état initial du système : tous les sièges sont libres

PROPERTIES

Max  N*  Max ≤ card (SIEGE)  (SiègeType  SIEGE  SiègeCatégorie  )

« redondante »
SiègeType  SIEGE →> SiègeCatégorie (surjection, totale)

(ou bien ( c . c  SiègeCatégorie 

1/2
( s1,s2 . s1  SIEGE  s2  SIEGE  (s1, c)  SiègeType 
(s2, c)  SiègeType → s1= s2)))  (fonction partielle)
Dom(SiègeType) = SIEGE  (total)
ran(SiègeType) = SiègeCatégorie (surjection)

INVARIANTS

( réservéPour  PERSONNE  SIEGE  ) « redondante »

réservéPour -1  SIEGE +→ PERSONNE  (fonction partielle)

(ou bien  s1 . s1 SIEGE 
( p1,p2 p1  PERSONNE  p2  PERSONNE  (p1, s1)  réservéPour 
(p2, s1)  réservéPour → p1= p2))

 p . p  dom(réservéPour) → card(réservéPour[({p})]) ≤ Max)

INITIALISATION

réservéPour = 

Q2. Spécifier les opérations suivantes :

(14,5 pts)

1) pR ← listePersonnesRéserver : retourne l’ensemble pR de personnes qui ont réservé. (1,5 pt)

pR ← listePersonnesRéserver = BEGIN
pR := dom(réservéPour)
END

2) b ← siègeLibres(s) : retourne la valeur booléenne b indiquant si le siège s est libre. (1,5 pt)

b ← siègeLibres(s) = PRE s  SIEGE THEN

IF s  ran(réservéPour)
THEN b := FAUX
ELSE b := VRAI
END
END

3) b ← personnesRéserver(p):retourne la valeur booléenne b indiquant si la personne p a réservé.(1,5 pt)

b ← personnesRéserver(p) = PRE p  PERSONNE THEN

IF p  dom(réservéPour)
2/2
 THEN b := VRAI
ELSE b := FAUX
END
END
4) nbr ← nbrPlacesLibres : retourne le nombre nbr de sièges libres. (1,5 pt)

nbr ← nbrPlacesLibres = BEGIN

nbr := card(SIEGE - ran(réservéPour))
END

5) p ← passagerSiège(s) : retourne la personne p qui a réservé le sièges s. (1,5 pt)

p ← passagerSiège(s) = PRE s  SIEGE  s  ran(réservéPour)

THEN
p := réservéPour -1(s)
END
6) nbr ← PlacesPersonne(p,c) : retourne le nombre nbr de sièges de catégorie c réservé par
la personne p. (1,5 pt)

nbr ← PlacesPersonne(p,c) =
PRE p  PERSONNE  c  SiègeCatégorie
THEN
nbr := card(dom( ({p} <| réservéPour)|>(dom (SiègeType |> {c}))))
( ou bien nbr := card(dom({p} <| (réservéPour |>(dom (SiègeType |> {c}))))))
( ou bien nbr := card(dom({p} <| (réservéPour |> (SiègeType-1 {c})))))
( ou bien nbr := card(ran({p} <| (réservéPour))  (SiègeType-1 {c}))
( ou bien nbr := card((SiègeType |> {c}) ([réservéPour([{p}])]))
END

7) AnnulerRéservation(p) : annuler toutes les réservations de la personne p. (1,5 pt)

AnnulerRéservation(p) =
PRE p  PERSONNE  p  dom(réservéPour)
THEN réservéPour := réservéPour – ( {p} <| réservéPour)
( ou bien réservéPour := {p} <<| réservéPour )
END

8) s ← Réserver(p, c) : réserver un siège de catégorie c pour la personne p et retourner le siège s réservé.

(2 pts)
s ← Réserver(p, c) =
PRE p  PERSONNE  c  SiègeCatégorie 
card(réservéPour[({p})]) < Max 
 ss. ss SIEGE  (ss, c) SiègeType  ¬ (ss  ran(réservéPour))

3/2
 THEN
ANY ss WHERE ss SIEGE  (ss, c) SiègeType  ¬ (ss  ran(réservéPour))
THEN
réservéPour := réservéPour  {(p, ss)} || s := ss
END

END

9) modifierRéservation(p1,s,p2) : modifier la réservation d’un siège s (déjà réservé par une personne p1)
pour une nouvelle personne p2 (n’a aucune réservation). (2 pts)

modifierRéservation(p1,s,p2) =
PRE p1  PERSONNE  p2  PERSONNE 
s  SIEGE  (p1,s)  réservéPour  ¬ (p2  dom(réservéPour))
THEN

réservéPour := (réservéPour - {(p1, s)})  {(p2, s)}

(ou bien réservéPour := (réservéPour -1  {(s, p2)})-1)
END

10) mes ← AnnulerToutesRéservations(p) : annuler toutes les réservations de la personne p et retourner

un message mes pour chaque cas possible.

mes ← AnnulerToutesRéservatiosn(p) =
PRE p  PERSONNE
THEN
IF p  dom(réservéPour)
THEN réservéPour := réservéPour – ( {p} <| réservéPour) || mes := OK
( ou bien réservéPour := {p} <<| réservéPour || mes := OK )
ELSE mes := possèdePasDeRéservation
END
END

4/2
 11) mes ← AnnulerRéservation(p,s) : annuler la réservation du siège s pour la personne p et retourner un
message mes pour chaque cas possible.
mes ← AnnulerRéservation(p,s) =

PRE p  PERSONNE  s  SIEGE

THEN
IF p  dom(réservéPour)
THEN IF s  réservéPour([{p}])
THEN réservéPour := réservéPour – {(p,s)} || mes := OK
ELSE IF s  ran(réservéPour)
THEN mes := pasLeVotre
ELSE mes := nonRéservé
END
END
ELSE mes := possèdePasDeRéservation
END
END

Exercice 2 : (3 points)

Calculer les obligations de preuve pour la machine suivante :

MACHINE Examen

VARIABLES x, y

INVARIANTS x  N*  y  N

INITIALISATION x := 1 || y := 0

OPERATIONS

Op(a) = PRE a  N THEN

IF a >0 THEN x := a+y END
END

Obligations de preuve :

1- Initialisation :

[x := 1 || y := 0]( x  N*  y  N) = ( x  N*  y  N)(x, y/1,0) = 1  N*  0  N

= VRAI

2- Opération

5/2
( x  N*  y  N)  a  N → [IF a >0 THEN x := a+y END] ( x  N*  y  N)

= ( x  N*  y  N)  a  N →
[ (a >0 ==> x := a+y) [] (¬(a >0) ==> SKIP)] ( x  N*  y  N)

= ( x  N*  y  N)  a  N →
[ a >0 ==> x := a+y] ( x  N*  y  N)  [a ≤ 0 ==> SKIP] ( x  N*  y  N)

= ( x  N*  y  N)  a  N →
(a >0 → [x := a+y] ( x  N*  y  N))  (a ≤ 0 →[ SKIP] ( x  N*  y  N))

= ( x  N*  y  N)  a  N →
(a >0 → ( x  N*  y  N) (x /a+y))  (a ≤ 0 → ( x  N*  y  N))

=( x  N*  y  N)  a  N →
(a >0 → ( a+y  N*  y  N))  (a ≤ 0 → ( x  N*  y  N))
---------------------------------------------------
=( x  N*  y  N)  a  N → (a >0 → ( a+y  N*  y  N))

( ( x  N*  y  N)  a  N → (a ≤ 0 → ( x  N*  y  N)))

=( x  N*  y  N)  a  N  a >0 → a+y  N*  y  N)

(( x  N*  y  N)  a  N  a ≤ 0 → ( x  N*  y  N)))
= VRAI

6/2