libFAUDES

Sections

Types

Functions

Generator

A generator is a finite representation of a (regular) formal language. In the context of discrete event systems, generators are used to model the dynamic behaviour in the sense that the corresponding language consists of all strings of events which the system can exhibit.

libFAUDES provides the plain Generator and the derived type System. The latter attaches controllability attributes to individual events to implement various decompositions of the alphabet from a control system perspective. Plug-ins may provide further specialized generator models.

Definition

A generator is a tuple G = (Q, Sigma, delta, Qo, Qm), with

  • the alphabet Sigma;

  • the state set Q;

  • the transition relation delta with transitions from Q x Sigma x Q;

  • the set of initial states Qo;

  • the set of marked states Qm.

The relation delta can be conveniently re-interpreted as a set-valued map on the domain Q x Sigma and extended to strings in its second argument. For  Sigma and  Sigma* let

delta(q,o) := {q'  Q| (q,o,q')  delta}, and
delta(q,so) := delta(delta(q,s),o).

The generated and marked languages L(G) and Lm(G), respectively, are defined by:

L(G) := {s  Sigma*| delta(Qo,s) ≠ 0}, and
Lm(G) := {s  Sigma*| delta(Qo,s)  Qm ≠ 0}.

When infinite length strings are to be considered, we may refer to Buechi acceptance condition to obtain

B(G) := {w  Sigma_w| all prefixes s < w are in L(G) }
Bm(G) := {w  Sigma_w| infinitely many prefixes s < w are in Lm(G) } .

Example

The simple machine can

  • pick up a workpiece to process it (event alpha);

  • dump a workpiece after processing it (event beta);

  • break down while processing a workpiece (event mue);

  • be serviced after break-down (event lambda).

Our generator model refers to the alphabet Sigma={alpha, beta, mue, lambda} and utilises the states Q={idle, busy, down}. Transitions are given by the below graph.

Example simple machine

Note that we decided to have idle as initial and marked state, i.e. Qm=Qo={idle}. The marking expresses that once a workpiece has been picked up it eventually will either be processed successfully or break-down and service will take place.

Token IO

Token-IO example for a Generator that models the simple machine:

<Generator>
% libFAUDES Generator for the simple machine
"simple machine"                   

<Alphabet>                         
"alpha" "beta" "mue" "lambda"      
</Alphabet>

<States>                           
"idle" "busy" "down"
</States>

<TransRel>
"idle" "alpha" "busy"
"busy" "beta" "idle"
"busy" "mue" "down"
"down" "lambda" "idle"
</TransRel>

<InitStates>
"idle"
</InitStates>

<MarkedStates>
"idle"
</MarkedStates>
</Generator>

System

A System is a Generator with a controllability attribute attached to each individual event. The attribute is used to indicate controllability, observability, forcibility and whether or not the respective event is regarded as an high-level event. Thus, attributes implement four disjoint union decompositions of the generator's alphabet Sigma:

  • Sigma = Sigma_c  Sigma_uc,

  • Sigma = Sigma_o  Sigma_uo,

  • Sigma = Sigma_f  Sigma_uf and

  • Sigma = Sigma_hi  Sigma_lo.

When reading or writing a System from/to a token stream, each event specified in the Alphabet section is optionally followed by a token of the form +xyz+, where each letter in xyz indicates membership in one of the above sets:

controllable +C+
uncontrollable +c+
observable +O+
unobservable +o+
forcible +F+
unforcible +f+
high-level +A+
low-level +a+

The default amounts to +cOfA+, i.e.  Sigma_uc  Sigma_o  Sigma_uf  Sigma_hi.

Token-IO example for a System that models the simple machine:

<Generator>
% libFAUDES Generator for the simple machine with controllability attributes
"simple machine"                   

<Alphabet>                         
"alpha"  +C+  % controllable event alpha
"beta"        % default, i.e. +cOfA+
"mue" 
"lambda" +CO+ % controllable and observable, same as +C+ since +O+ is default    
</Alphabet>

[ ... same as above generator example ... ]

</Generator>

The token-io format of Systems is compatible to Generators. I.e., a System can be configured from a tokenized Generator where attributes take a default value, and, vice versa, a Generator can be configured from a System, where attributes are ignored.

libFAUDES 2.14g --- 2009-12-3 --- plugins "example synthesis observer diagnosis hiosys multitasking timed simulator iodevice luabindings"