1. High-Level Abstraction of Concurrent Finite Automata
for the Purpose of Hierarchical Control
Klaus Schmidt
SVC - Seminar
September 16th, 2003

2. Overview Preliminaries Concurrent Systems
Structural Decentralized Finite Automata
- Properties
- Advantages
4. High – Level Abstraction
- Control Structure
- Hierarchical Consistency
- Example
5. Complexity Issues
6. Summary and Future Work

3. 1. Preliminaries

4. 1. Preliminaries: Notations in the DES Framework
Automaton G
automata and regular languages 1 2 3 4
deterministic finite automata G
states
events
transition function
marked states
initial state 4
regular languages
Alphabet
strings
closed language
marked language

5. 1. Preliminaries: Standard Control Structure
Automaton G
classification of events 1 2 3 4
controllable events – can be disabled:
uncontrollable events – always enabled:
feedback structure
Plant G
Supervisor S
disabled
events
occuring
in G 4
tracks strings occuring in G:
disables event after if
supervisor

6. 1. Preliminaries: Supervisor Design
automaton G
controlled language 1 2 3 4
specification
desired language:
0,0
0,1
0,2
0,3 4
generator for
Definition: Controllability
A language is controllable w.r.t. to a language
If and only if 4
supremal controllable sublanguage

7. 1. Preliminaries: Supervisor Design
nonblocking - condition
 there must exist a path to a marked state
 controlled language:
Controllability and Non-blocking Theorem
A non-blocking supervisor, which implements the
Specification for an automaton exists iff:
(i) controllable w.r.t.
(ii) is closed, i.e.

8. 1. Preliminaries: Supervisor Design
Advantages
systematic procedure for determining supervisors for finite automata
synthesize maximally permissive behavior: supremal controllable sublanguage
algorithms which are polynomial in time
Problem:
state explosion for monolithic design
formulation of specifications for large systems
modular design
decentralized architectures
 hierarchical architectures

9. 2. Concurrent Systems

10. 2. Concurrent Systems: Decentralized Architecture
subsystems: Finite Automata
Alphabet:
closed language:
marked language:
common events:
overall system: Finite Automaton
synchronous composition:
closed language:
marked language:
alphabet:
common
behavior
subsystem

11. 2. Concurrent Systems: Blocking Issues
Idea: local control
specifications for decentralized subsystems
supremal controllable sublanguage
 local supervisors
concurrent operation of 
interaction may lead to blocking in the overall behavior
nonconflicting-condition
concurrent operation is nonblocking and controllable iff
always check if condition is fulfilled
are nonblocking local languages

12. 2. Concurrent Systems: Blocking Issues
if concurrent operation is conflicting
 try to adapt specifications
 construct overall specification
and compute overall supremal controllable language
in case of conflict
in general
 for which systems equality holds?
Sword of damokles

13. 3. Structural Decentralized
Finite Automata

14. 3. Structural Decentralized Finite Automata: Conditions
(i) shared event marking condition:
marks
 predecessor state of each common event is marked
(ii) mutual controllability condition:
local language is controllable w.r.t. external behavior of other
languages as seen by

15. 3. Structural Decentralized Finite Automata: Example
two cooperating machine cells (Lee & Wong) 1 1 3 3 2 2 4 4 5 5
Controllability 1 1

16. 3. Structural Decentralized Finite Automata: Theorem
Theorem (Lee and Wong 2002):
Let the decentralized architecture be given as defined before. Suppose
that for and
(i) marks
(ii) and are mutually controllable
Then for any the following holds:
and
is nonblocking w.r.t.
verify local specifications
generate local supervisors
concurrent operation of local supervisors is nonblocking
concurrent operation of local supervisors is optimal (equals overall solution)

17. 4. High-Level Abstraction

18. 4. High-Level Abstraction: Control Structure
local system
Concurrent nonblocking Finite Automata
Structural Decentralized Architecture
shared event marking
mutual controllability
local control
local specifications ( closed)
local supervisor s.t.
equivalent overall supervisor
local closed-loop language
local controls are non-conflicting (mutual controllability)
closed loop language is nonblocking

19. 4. High-Level Abstraction: Control Structure
global system
high-level events (common events)
natural projection
high-level language
high-level marked language
high-level supervisor
translation map
with iff (i)
(ii)
concept of high-level abstraction: projection on common event set
coordination of system interaction via high-level control
translation of virtual high-level control action to low-level
low-level supervisor consists of low-level + translated high-level control

20. 4. High-Level Abstraction: Results
problems to be solved:
(1) complexity of projection is exponential in size of automaton
hierarchical consistency: translation of high-level control policy to low level
(3) interaction of high- and low-level part of low-level supervisor
(1): Theorem (Construction of High-Level Language)
Let the proposed hierarchical control architecture be given. Then the
high-level language can be constructed as follows:
States: left side: k^n states
right side: k states * n
apply projection only to sublanguages
compose abstracted sublanguages

21. 4. High-Level Abstraction: Results
(2) and (3):
Theorem (Hierarchical Consistency)
Assume the proposed hierarchical control architecture, then
(i) is hierarchical consistent w.r.t.
 for all high level specifications
it follows that
(ii) is nonblocking
(iii) is maximally permissive
high-level control action can be realized in low level
the closed-loop language is nonblocking
the translated low-level supervisor does not disable
behavior if it is not necessary

22. 4. High-Level Abstraction: Control Loop
Low
Level
Supervisor
Plant

23. 4. High-Level Abstraction: Example1 1 3 3 2 2 4 4 5 5 1 2 5a 4 3 5b
low-level spezifications

24. 4. High-Level Abstraction: Example
generator for
Generator for
1,1
0,0
generator for 1 1
high-level specification 1 2
controllable in high level
translate to low level

25. 4. High-Level Abstraction: Example
high-level specification 1 2
low-level realization 1 1 3 3 2 2 5b 4 5b 5a 4 5a

26. 5. Complexity Issues

27. 5. Complexity Issues: Structural Decentralized Architecture
Mutual Controllability:
projection:  exponential in number of states
controllability  polynomial in number of states
 worst case: exponential complexity
Shared-event marking:
 polynomial in number of states and transitions
marks
 polynomial
Low-Level Control:
 n times
 equvalent high level control
 nonconflicting condition need not be verified
 polynomial

28. 5. Complexity Issues: High-Level Architecture
High-Level Automaton: Theorem 1
 projection of local automata: exponential
 synchronous composition of projected automata:
 global marked states: polynomial
 exponential in number of subautomata and states of subautomata
High-Level Control: Theorem 2
 supremal controllable sublanguage for
high-level automaton:
 polynomial
Translation High-Level to Low-Level Supervisor: Theorem 2
 proposed architecture:
 more general architectures: ?
 polynomial ?

29. 6. Summary and Future Work

30. 6. Summary and Future Work
Structural Decentralized Architecture
Hierarchical Abstraction
Low-Level Supervision
High-Level Supervision
Hierarchical Consistency
Complexity
Future Work
elaborate conditions for mutual controllability
formulate more general architecture
multi-level hierarchy