libFAUDES
Sections
Functions
|
Omega-Controllable SublanguagesFunctions related to controllability and controller synthesis on the infinite time axis. Definition of Omega-ControllabilityAddressing the control of discrete event systems on the infinite time axis, [S3] develops a notion of omega-controllability.
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:
Note 1: 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 2: The above definition of omega-controllability conforms to [S3] and [S4]. It must not be confused with the more general approach taken in [S5]. Note 3: 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. Controller Synthesis for Omega-LanguagesConsider two omega languages L and E over a common alphabet Sigma to represent the plant and the specification, respectively. Let Sigma_uc ⊆ Sigma denote the set of uncontrollable events. The task then is to find a topologically closed controller H ⊆ Sigma^w, such that
(1)
L and H are non-blocking, i.e.,
Prefix(L ∩ H) = Prefix(L) ∩ Prefix(H) ;
For any topologically closed controller which satisfies the above conditions, the closed loop K exhibits the following properties:
(a)
K is relatively topological closed w.r.t. L; and,
Note that (a) and (b) amount to omega-controllability. Moreover, if a language K satisfies (a)-(c), the controller H = Closure(K) solves the synthesis problem.
In contrast to the situation of star-languages, property (a) is not retained under arbitrary union.
Under the additional requirement, that E is relatively topological closed w.r.t. L,
[S3] establishes that 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, and a controller H↑ = Closure(K↑) would fail to enforce the specification. However, one could then use K↑ itself 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 controllable 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 a realisation of the supremal controllable and complete sublanguage
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
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 SupConCompleteNB
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 K = 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 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. 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 omega-closedness. Detailed description:
An 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.20s --- 2011.10.12 --- with "synthesis-observer-observability-diagnosis-hiosys-iosystem-multitasking-coordinationcontrol-timed-simulator-iodevice-luabindings"