libFAUDES

Sections

Functions

Omega-Controllable Sublanguages

Regarding the control of discrete event systems on an infinite time axis, [S3] develops a notion of controllability and gives a condition for the existence of supremal closed-loop behaviour. A further discussion, including a synthesis algorithm, is given in [S4].

Consider two omega languages L and K over a common alphabet Sigma,
and a set of uncontrollable events Sigma_uc  Sigma.

Then K is said to be omega-controllable w.r.t (L,Sigma_uc)
if the following conditions are satisfied.

  • Prefix(K) is controllable w.r.t (Prefix(L),Sigma_uc), i.e.

    Prefix(K)Sigma_uc  Prefix(L)    Prefix(K)

  • and K is relatively closed w.r.t. L, i.e.

    K  =  Closure(K)  L.

Note 1: all omega-languages in the following discussion are assummed to be realizable by finite deterministic Buchi automata. We write Bm(G) to denote the omega language realized by G under Buchi acceptance condition; see also Generator.

Note 2: for omega-languages, the closure operator Closure(.) refers to the so called topological closure; see also OmegaClosure. The prefix operator Prefix(.) gives the set of all finite length prefixes.

Note 3: The above definition of omega-controllability conforms to [S3] and [S4]. It must not be confused with the more general approach taken in [S5].

For 0 ≠ K  L, the existence of a non-blocking supervisor that achieves the closed-loop behaviour K is equivalent to omega-controllability of K. By the second condition, the supervisor can be implemented by a generator that realizes Closure(K), where the closed loop is modelled by the composition Closure(K)  L. The latter trivialy satisfies the formal non-blocking condition.

Given a specification  L, the supremum

K := sup{ K  E | K is omega-controllable w.r.t (L,Sigma_uc) }

exists uniquely. Provided that E is relatively closed w.r.t. L, the supremum itself is omega-controllable and, hence, its closure can be used to implement a supervisor. For this case, methods for the computation of K are given [S4] and implemented by SupConCompleteNB.

A more general approach that drops the requirement of the specification E to be relatively closed is presented in [S5]. In this situation, K will fail to be relatively closed. However, K can still be used as a supervisor, provided that a technical realisation implements a mechanism that ensures that closed-loop trajectories fulfill the acceptance condition of K. Alternatively, one can extract a non-minimal restrictive supervisor that can be implemented by a closed behaviour. A generator that realises K can be computed by OmegaSupConNB (experimental).

Example

For illustration of omega-controllability, consider the below veriants of a machine that may run one of two processes A and B. The processes are initiated by the controllable events a and b, respectively. Once started, a process may terminate with success c or failure d. In the first variant, each process is guaranteed to eventually succeed. In the second variant, process B exhausts the machine and can subsequently only succeed after running process A. In the third variant, process B breaks the machine. Each variant exhibits an eventuality property and, hence, neither of the induced omega-languages are topologically closed.

A-B-machine, std. variant
A-B-machine, B exhausts the machine
A-B-machine, B breaks the machine

In our discussion, we consider three alternative specifications, that require the closed loop to

  • persistenly alternate successful operation of processes A and B, or to

  • persistently run some operation successfully, or to

  • start with process A, eventually switch to B, and, on success turn back to A.

Note that, technically, a specification language is required to be a subset of the plant language. The above realisations are "lazy" in the sense that they do not fulfil this requirement. For the following diccussion, we think of the above specifications to be intersected with the respective plant language; see also OmegaParallel.

For a minimal restrictive supervisor to exist, the specification is required to be relatively closed w.r.t. the plant. Intuitively, this is true whenever any eventuality property required by the specification is implied by the plant. The following table comments on relative closedness of indivual combinations of plant and specification.

A-B-machine, std. variant A-B-machine, B exhausts the machine A-B-machine, B breaks the machine
alternate eventual success in running A and B eventual success is guaranteed by the plant; relative closedness is satisfied the specification requires immediatly to process A after success in B; hence, the closed-loop will not suffer from an exhausted machine; relative closedness is satisfied the specification requires the machine to eventually process B, and, hence, the closed-loop will block with a broken machine; however, the intersection of plant and specification is empty; so, technically, relative closedness is satisfied
persistently run any process with eventual success the specification is a superset of the plant; relative closedness is satisfied a minimal restrictive supervisor cannot exist, since such a supervisor would need to eventually decide to process A once the machine is exhausted; relative closedness is not satisfied since B breaks the machine, persistent success implies not to run process B; relative closedness is satisfied
eventually switch to B plant does not imply the eventuality property to process B; relative closedness is not satisfied. plant does not imply the eventuality property to process B; relative closedness is not satisfied. plant does not imply the eventuality property to process B; relative closedness is not satisfied.

The third row of the above table points out that there are relevant applications that do not fulfil the requirement of a relatively closed specification. This has been addressed in [S5]; see also OmegaSupConNB.

For the cases where relative closedness is satisfied, the minimal restrictive closed-loop behaviour has been computed using SupConCompleteNB.

A-B-machine, std. variant, with alternate-A-and-B-success specification
A-B-machine, std. variant, with persistently-any-success specification
A-B-machine, B exhausts the machine, with alternate-A-and-B-success specification
A-B-machine, B breaks the machine, with persistenly-any-success specification

IsOmegaControllable

Tests controllablity condition.

Signature:

IsOmegaControllable(+In+ Generator GPlant, +In+ EventSet ACntrl, +In+ Generator GCand, +Out+ Boolean BRes)
IsOmegaControllable(+In+ System GPlant, +In+ Generator GCand, +Out+ Boolean BRes)

Detailed description:

This function tests omega-controllability of Bm(GCand) w.r.t. (Bm(GPlant),Sigma_uc), where the set of uncontrollable events Sigma_uc is specified as the complement of the parameter ACntrl.

The current implementation performs the test by invoking IsControllable and IsRelativelyOmegaClosed. It returns true, if both conditions are satisfied.

Parameter Conditions:

This implementation requires the alphabets of plant and specification to match. Furthermore, both generators must be deterministic and omega-trim.

SupConComplete

Computes the supremal controllable and complete sublanguage.

Signature:

SupConComplete(+In+ System GPlant, +In+ Generator GSpec, +Out+ Generator GSupervisor)
SupConComplete(+In+ Generator GPlant, +In+ EventSet AContr, +In+ Generator GSpec, +Out+ Generator GSupervisor)

Detailed description:

Given a plant L = L(GPlant) and a specification E = L(GSpec), this function computes the supremal controllable and complete sublanguage  EL:

L(GSupervisor) = sup{ K  EL | K is controllable w.r.t (L,Sigma_uc)  and complete } .

The set of uncontrollable events Sigma_uc is either taken from the plant generator's event attributes or specified as the complement of the parameter ACntrl. See e.g. [S4] for the base algorithm used in the implementation of this function.

It is shown in [S4] that the omega-language B(GSupervisor) is the supremal omega-controllable sublanguage of B(GSpec), where omega-controllablity is w.r.t. (B(GPlant),Sigma_uc).

Parameter Conditions:

This implementation requires the alphabets of plant and specification to match. Furthermore, both generators must be deterministic. Effectively, the specification is intersected with the plant language. The result will be deterministic and accessible.

SupConCompleteNB

Computes the supremal controllable and complete sublanguage.

Signature:

SupConCompleteNB(+In+ System GPlant, +In+ Generator GSpec, +Out+ Generator GSupervisor)
SupConCompleteNB(+In+ Generator GPlant, +In+ EventSet AContr, +In+ Generator GSpec, +Out+ Generator GSupervisor)

Detailed description:

Given a plant L = Lm(GPlant) and a specification E = Lm(GSpec), this function computes the supremal controllable and complete sublanguage  EL:

Lm(GSupervisor) = sup{ K  EL | K is controllable w.r.t (L,Sigma_uc)  and complete } .

The set of uncontrollable events Sigma_uc is either taken from the plant generator's event attributes or specified as the complement of the parameter ACntrl. The algorithm used in this implementation is similar to the one presented in [S4].

Assume that the omega-language Bm(GSpec) is relatively closed w.r.t. Bm(GPlant), and substitute GSpec with GSpec' such that Lm(GSpec') = L(GSpec) to realize the closure of the specification. Then the generator GSupervisor returned by SupConComplete realizes the supremal omega-controllable sublanguage of Bm(GSpec):

Bm(GSupervisor) = sup{ K  Bm(GSpec) | K is omega-controllable w.r.t (Bm(GPlant),Sigma_uc) } .

Parameter Conditions:

This implementation requires the alphabets of plant and specification to match. Furthermore, both generators must be deterministic and omega-trim. The result will be deterministic and omega-trim.

OmegaSupConNB

Synthesis for omega-languages (experimental!).

Signature:

OmegaSupConNB(+In+ System GPlant, +In+ Generator GSpec, +Out+ Generator GSupervisor)
OmegaSupConNB(+In+ Generator GPlant, +In+ EventSet AContr, +In+ Generator GSpec, +Out+ Generator GSupervisor)

Detailed description:

The function OmegaSupConNB addresss the situation where the specification fails to be relatively closed w.r.t. the plant. We formaly model the closed-loop interconnection of a plant  Sigma^w and supervisor  L by the intersection LK. Since we dropped the requirement of relative closedness, we obtain

 K  =  K    L  Closure(K).

We require the closed-loop to be nonblocking and the supervisor not to disable uncontrollable events, i.e. for all  Prefix(L)  Prefix(K) we must have

(a)    Prefix(LK) and
(b)    Sigma_uc, so  Prefix(L)        so  Prefix(K) .

The nonblockng condition (a) is trivially fulfilled, while (b) amounts to controllabiliy for the prefix of K w.r.t. the prefix of L. Neither for the plant nor for the supervisor we ask how a technical realization actually manages to satisfy their respective acceptance condition. However, while  L ensures that the supervisor will support the plant in this regard, the plant could permanently prevent the supervisor from running into a marked state. Thus, we introcude as condition (c) that while the closed-loop evolves, the supervisor must allways have the chance to eventually force the trajectory to pass a maked state. Technically, we require for all  Prefix(L)  Prefix(K)

(c)     V  K: V is omega-controllable w.r.t. L, and s  Prefix(V).

It is readily verified that condition (c) implies condition (b). Furthermore, all three conditions are preserved under arbitrary union. Thus, given a specification  L, there exists a supremal closed-loop behaviour  E that satisfies conditions (a), (b) and (c). It can also be observed that the supremal closed-loop behaviour equals the union over all omega-controllable sublanguages of E.

Given a plant L = Bm(GPlant) and a specification E = Bm(GSpec), the function OmegaSupConNB returns a generator GSupervisor such that Bm(GSupervisor) fulfills conditions (a), (b) and (c). The implementation first constructs a realisation the intersection LE similar to OmegaParallel. It then iteratively indentifies and removes undesired states that directly conflict with conditions (a), (b) and (c). Regarding (a) and (b), we require for the realisation completeness and controllability. Hence, undesired states can be detected as usual. Regarding (c), the implementation itertively detects states that can be driven to a state that corresponds to a string within Lm(GSpec). The test includes an analysis of SCCs that avoid states that correspond to strings from Lm(GPlant), since the plant is known to eventually force the closed-loop trajectory to exit any auch SCC. Any state that can not be driven to a string witin Lm(GSpec) is considered undesirable.

Note. A very general approach to the control of omega-languages has been developed in [S5]. When applied to the more specific case of determinitsic Buchi automata addressed here and despite some minor differences in the perspective we take, the above condition (c) is equivalent to the notion of omega-controllability proposed in [S5]. There, it has been shown that the supremal controllable sublanguage can be represented in terms of the so called controllability prefix and the marking of the specification. We believe that our implementation leads to the same result. In due course, we will need to verify this claim and/or reimplement this function according to the results in [S5]. Until then, our implementation remains "experimental".

Example:

The following results have been obtained for the three variants of A-B-machine and the eventually-switch-to-B specification.

A-B-machine, std. variant, with eventually-switch-to-B specification
A-B-machine, B exhausts the machine, with eventually-switch-to-B specification
A-B-machine, B breaks the machine, eventually-switch-to-B specification

Parameter Conditions:

This implementation requires the alphabets of plant and specification to match. Furthermore, both generators must be deterministic. Effectively, the specification is intersected with the plant. The result will be deterministic and omega-trim.

IsRelativelyOmegaClosed

Test for relative prefix-closedness.

Signature:

IsRelativelyOmegaClosed(+In+ Generator GPlant, +In+ Generator GCand, +Out+ Boolean BRes)

Detailed description:

A omega-language K is relatively closed w.r.t. the omega-language L, if K can be recovered from its closure and L. Formally:

K = Closure(K)  L .

Note that, the closure operator refers to the so called topological closure; see also OmegaClosure.

This function tests, whether

Bm(GCand) = B(GCand)  Bm(GPlant)

by performing the product composition of the two generators in order to verify the following three conditions:

  • L(GCand)  L(GPlant);

  • no SCC of GPlant x GCand without GCand-marking contains a state with GPlant-marking; and

  • no SCC of GPlant x GCand without GPlant-marking contains a state with GCond-marking.

The function returns "true" if all conditions are satisfied.

Example:

Consider the A-B-machine in the variant in which B exhausts the machine and the specification that persistently requires any sucessful operation. Then the product will generate strings b c (b d)^*. Consider the omega-limit w of this set of strings. The states attained when generating w eventually correspond to the plant states XB and FB and to the specification state B. In the product generator, the states must be part of an SCC. Furthermore, since B is not marked there must exists an SCC with no specification-marked state. However, this SCC also contains a state that coresponds to XB, which is marked by the plant. Thus, the procedure return "false".

Parameter Conditions:

This implementation requires the alphabets of both generators to match. Furthermore, both specified generators must be deterministic and omega-trim.

libFAUDES 2.16b --- 2010-9-8 --- plugins "example synthesis observer diagnosis hiosys multitasking timed simulator iodevice luabindings"