|
libFAUDES
Sections
Functions
|
Omega-Controllable SublanguagesRegarding 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,
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 E ⊆ L, the supremum
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). ExampleFor 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.
In our discussion, we consider three alternative specifications, that require the closed loop to
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.
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.
IsOmegaControllableTests controllablity condition.
Signature:
IsOmegaControllable(+In+ Generator GPlant, +In+ EventSet ACntrl, +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.
SupConCompleteComputes the supremal controllable and complete sublanguage.
Signature:
SupConComplete(+In+ System GPlant, +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 K ⊆ E∩L:
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.
SupConCompleteNBComputes the supremal controllable and complete sublanguage.
Signature:
SupConCompleteNB(+In+ System GPlant, +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 K ⊆ E∩L:
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):
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.
OmegaSupConNBSynthesis for omega-languages (experimental!).
Signature:
OmegaSupConNB(+In+ System GPlant, +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 L ⊆ Sigma^w
and supervisor K ⊆ L by the intersection
L∩K. Since we dropped the requirement of relative closedness,
we obtain
It is readily verified that condition (c) implies condition (b). Furthermore, all three conditions are preserved under arbitrary union. Thus, given a specification E ⊆ L, there exists a supremal closed-loop behaviour K ⊆ 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 L∩E 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 Example: The following results have been obtained for the three variants of A-B-machine and the 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.
IsRelativelyOmegaClosedTest for relative prefix-closedness.
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:
This function tests, whether
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.18b --- 2010-12-17 --- plugins "example synthesis observer diagnosis hiosys iosystem multitasking timed simulator iodevice luabindings"