Determining robustness of synchronous programs under stuttering

Robustness of embedded systems under potential changes in their environment is crucial for reliable behaviour. One typical environmental impact is that of the inputs being slowed down — due to which, the system may no longer satisfy its specification. In this paper, we present a framework for analysing the behaviour of synchronous programs written in Lustre under such environmental interference. Representing slow input by stuttering, we introduce both strong and weak slowdown robustness constraints with respect to this phenomenon. Furthermore, static and dynamic algorithmic techniques are used to deduce whether such constraints are satisfied, and the relationship between stateful programs and the slowdown model considered is explored.peer-reviewe

Lachlan Non-Splitting Pairs and High Computably Enumerable Turing Degrees

A given c.e. degree a > 0 has a non-trivial splitting into c.e. degrees v and w if a is the join of v and w and v | w. A Lachlan Non-Splitting Pair is a pair of c.e. degrees such that a > d and there is no non-trivial splitting of a into c.e. degrees w and v with w > d and v > d. Lachlan [Lachlan1976] showed that such a pair exists by proving the Lachlan Non-Splitting Theorem. This theorem is remarkable for its discovery of the 0'''-priority method, and became known as the `Monster' due to its significant complexity. Harrington, Shore and Slaman subsequently tried to explain Lachlan's methods in more intuitive and comprehensible terms in a number of unpublished notes. Leonhardi [Leonhardi1997] then published a short account of the Lachlan Non-Splitting Theorem based on these notes and generalised the theorem in a different direction. In their work on the separation of the jump class High from the jump class Low2, Shore and Slaman [SlamanShore1993] also conjectured that every high c.e. degree strictly bounds a Lachlan Non-Splitting Pair, a fact which could be used to separate the two jump classes. While this separation was eventually achieved through the notion of a Slaman Triple, the conjecture itself remained an open question. Cooper, Yi and Li [CooperLiYi2002] also defined the notion of a c.e. Robinson degree as one which does not strictly bound the base d of a Lachlan Non-Splitting Pair , and sought to understand the relationship of this notion to the High/Low Hierarchy. In this dissertation we make the following two contributions. Firstly we show that a counter-example can be found to show that the account of the Lachlan Non-Splitting Theorem given by Leonhardi [Leonhardi1997] fails to satisfy its requirements. By rectifying the construction, we give a complete, correct and intuitive account of the Lachlan Non-Splitting Theorem. Secondly we show that the high permitting method developed by Shore and Slaman [SlamanShore1993] can be combined with the construction of the Lachlan Non-Splitting Theorem just described to prove that every high c.e. degree strictly bounds a Lachlan Non-Splitting Pair. From this it follows that the existence of a Lachlan Non-Splitting Pair can be used to separate the jump classes High and Low2, that the distribution of Lachlan Non-Splitting Pairs with respect to these jump classes mirrors the one for Slaman Triples, and that there is no high c.e. Robinson degree

Static and dynamic analysis for robustness under slowdown

Robustness of embedded systems to potential changes in their environment, which may result in the inputs being affected, is crucial for reliable behaviour. One typical possible change is that the system’s inputs are slowed down, altering its temporal behaviour. Algorithmic analysis of systems to be able to deduce their robustness under such environmental interference is desirable. In this paper, we present a framework for the analysis of synchronous systems to analyse their behaviour when the inputs slow down through stuttering. We identify different types of slowdown robustness constraints and present static and dynamic analysis techniques for determining whether systems written in Lustre satisfy these robustness properties.peer-reviewe

Slowdown invariance of timed regular expressions

In critical systems, it is frequently essential to know whether the system satisfies a number of real-time constraints, usually specified in a real-time logic such as timed regular expressions. However, after having verified a system correct, changes in its environment may slow it down or speed it up, possibly invalidating the properties. Colombo et al. (1) have presented a theory of slowdown and speedup invariance to determine which specifications are safe with respect to system retiming, and applied the approach to duration calculus. In this paper we build upon their approach, applying it to timed regular expressions. We hence identify a fragment of the logic which is invariant under the speedup or slowdown of a system, enabling more resilient verification of properties written in the logic.peer-reviewe