libFAUDES

Sections

Types

Functions

Synchronous Composition

Given two discrete event systems, the synchronous composition is a discrete event system that models the respective component behaviour under the constraint that shared events must be executed synchronously. Thus, each component restricts the behaviour of the other component.

In terms of languages L1 and L2 over alphabets Sigma1 and Sigma2, respectively, the resulting behaviour is defined

Lres = L1 || L2 := Pinv1(L1)  Pinv2(L2) = {s  Sigma*| P1(s)  L1 and P2(s)  L2},

where Pinv1 and Pinv2 denote the set-valued inverse of the natural Projections P1:Sigma*Sigma1*, P2:Sigma*Sigma2*, Sigma = Sigma1  Sigma2, respectively.

Parallel

Computes the parallel composition of two generators.

Signature:

Parallel(+In+ Generator G1, +In+ Generator G2, +Out+ Generator GRes)

Detailed description:

Given two generators G1 and G2, this function computes the parallel composition GRes = G1 || G2, with

L(GRes) = L(G1) || L(G2)
Lm(GRes) = Lm(G1) || Lm(G2)

The resulting generators alphabet is the union of the argument alphabets.

Technically, Parallel constructs its result on the product of the state spaces of G1 and G2, i.e. Qres = Q1 x Q2. Thus, to a resulting state q = (q1,q2) correspond the component states q1 and q2. Transitions are enabled in GRes whenever they are enabled in each component that include the event in their respective alphabet:

((q1,q2), o, (q1',q2'))  delta_res    
        o  Sigma1  or  (q1, o, q1')  delta1 and
        o  Sigma2  or  (q2, o, q2')  delta2

Example:

Our first example composes two independent "very simple machines". Since the components do not share any events, the parallel compositions turns out as the so called shuffle product.
Component G1 Component G2
Composition G=G1 || G2

Example:

In this example, the shared events are {a, b}. Component G2 does not impose any restrictions on the generated language, i.e. Pinv2(L(G2)) = Sigma*. However, G2 requires the marked language not to end with a b-event (when projected to Sigma2.
Component G1 Component G2
Composition G=G1 || G2

Parameter Conditions:

In this implementation, only accessible states are generated. On deterministic input this functions constructs a deterministic output. The resulting generators controllability attributes are copied from the arguments. It is considered an error if the controllability flags in the arguments don't match.

OmegaParallel

Parallel composition with relaxed acceptance condition.

Signature:

OmegaParallel(+In+ Generator G1, +In+ Generator G2, +Out+ Generator GRes)

Detailed description:

The marking introduced by the Parallel composition requires that each component accepts a string simultaneously. This condition may turn out too restrictive, in particular when focus is on the infinite time behaviour. The function OmegaParallel relaxes the acceptance condition, in that it requires each component always to eventually accept the generated prefix, but not necessarily simultaneously with the other component:


L(GRes) = L(G1) || L(G2)
Bm(GRes) = Bm(G1) || Bm(G2) := {w  Sigma^w| P1(w)  Bm(G1) and P2(w)  Bm(G2) }

where Bm(G) denotes the omega language realised by G with Buechi acceptance condition, see Generator.

Technically, OmegaParallel constructs its result on the product of the state spaces of G1 and G2 with an additional boolean flag. The flag is used to mark those states in GRes that correspond to a G2-marking with most recent marking in G1. Thus, a trajectory that passes a GRes-marking infinitely often, also passes infinitely many marked states in G1 and G2.

Example:

Component G1 Component G2
Composition G=G1 ||| G2

Parameter Conditions:

In this implementation, only accessible states are generated. Arguments are required to be deterministic, and so will be the result. It is considered an error if the controllability flags in the arguments don't match.

Product

Computes the product composition of two genertors.

Signature:

Product(+In+ Generator G1, +In+ Generator G2, +Out+ Generator GRes)

Detailed description:

Given two generators G1 and G2, this function computes the product composition GRes = G1 x G2, with

L(GRes) = L(G1)  (G2)
Lm(GRes) = Lm(G1)  Lm(G2)

The resulting generators alphabet is the intersection of the argument alphabets.

Technically, Product constructs its result on the product of the state spaces of G1 and G2, i.e. Qres = Q1 x Q2. Thus, to a resulting state q = (q1,q2) correspond the component states q1 and q2. Transitions are enabled in GRes whenever they are enabled in both components.

((q1,q2), o, (q1',q2'))  delta_res    
        (q1, o, q1')  delta1 and
        (q2, o, q2')  delta2

Parameter Conditions:

In this implementation, only accessible states are generated. On deterministic input this functions constructs a deterministic output. The resulting generators controllability attributes are copied from the arguments. It is considered an error if the controllability flags in the arguments don't match.

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