Mapping RT-LOTOS specifications into Time Petri Nets

RT-LOTOS is a timed process algebra which enables compact and abstract specification of real-time systems. This paper proposes and illustrates a structural translation of RT-LOTOS terms into behaviorally equivalent (timed bisimilar) finite Time Petri nets. It is therefore possible to apply Time Petri nets verification techniques to the profit of RT-LOTOS. Our approach has been implemented in RTL2TPN, a prototype tool which takes as input an RT-LOTOS specification and outputs a TPN. The latter is verified using TINA, a TPN analyzer developed by LAAS-CNRS. The toolkit made of RTL2TPN and TINA has been positively benchmarked against previously developed RT-LOTOS verification tool

Design and Implementation of a Tool for Hierarchical Graphical Specification of Real-Time Systems

Práce je zaměřena na návrh a implementaci univerzálního nástroje schopného graficky popsat systémy pracující s reálným časem. Tento nástroj dále umožňuje použít libovolný verifikační přístupu pro ověření výsledného modelu. Je proveden souhrn základních formálních metod popisu systémů založený na matematické logice. Jsou přiblíženy přístupy schopné hierarchicky popsat systémy pracující s reálným časem. Byly navrženy vhodné úlohy pro následné ověření funkčnosti vytvářeného systému.This thesis is aimed to specify and implement multi-purpose framework able to deal with graphical real-time system specification. This tool allows to use arbitrary verification approach to resulting system model check. Description of basic formal specification methods based on mathematic logic is done. Some well-known hierarchical graphical specifications for real-time systems are depictured. Author proposed suitable cases for functionality examination of resulting framework.

GCSR: A Graphical Language With Algebraic Semantics for the Specification of Real-Time Systems

Graphical Communicating Shared Resources, GCSR, is a formal language for specifying real-time systems including their functional and resource requirements. A GCSR specification consists of a set of nodes that are connected with directed, labeled edges, which describe possible execution flows. Nodes represent instantaneous selection among execution flows, or time and resource consuming system activities. In addition, a node can represent a system subcomponent, which allows modular, hierarchical, thus scalable system specifications. Edges are labeled with instantaneous communication actions or time to describe the duration of activities in the source node. GCSR supports the explicit representation of resources and priorities to resolve resource contention. The semantics of GCSR is the Algebra of Communicating Shared Resources, a timed process algebra with operational semantics that makes GCSR specifications executable. Furthermore, the process algebra provides behavioral equivalence relations between GCSR specifications. These equivalence relations can be used to replace a GCSR specification with an equivalent specification inside another, and to minimize a GCSR specification in terms of the number of nodes and edges. The paper defines the GCSR language, describes GCSR specification reductions that preserve the specification behaviors, and illustrates GCSR with example design specifications

Time in SCCharts

Synchronous languages, such as the recently proposed SCCharts language, have been designed for the rigorous specification of real-time systems. Their sound semantics, which builds on an abstraction from physical execution time, make these languages appealing, in particular for safety-critical systems. However, they traditionally lack built-in support for physical time. This makes it rather cumbersome to express things like time-outs or periodic executions within the language. We here propose several mechanisms to reconcile the synchronous paradigm with physical time. Specifically, we propose extensions to the SCCharts language to express clocks and execution periods within the model. We draw on several sources, in particular timed automata, the Clock Constraint Specification Language, and the recently proposed concept of dynamic ticks. We illustrate how these extensions can be mapped to the SCChart language core, with minimal requirements on the run-time system, and we argue that the same concepts could be applied to other synchronous languages such as Esterel, Lustre or SCADE

A Temporal Logic for Modelling Activities of Daily Living

Behaviour support technology is aimed at assisting people in organizing their Activities of Daily Living (ADLs). Numerous frameworks have been developed for activity recognition and for generating specific types of support actions, such as reminders. The main goal of our research is to develop a generic formal framework for representing and reasoning about ADLs and their temporal relations. This framework should facilitate modelling and reasoning about 1) durative activities, 2) relations between higher-level activities and subactivities, 3) activity instances, and 4) activity duration. In this paper we present a temporal logic as an extension of the logic TPTL for specification of real-time systems. Our logic TPTL_{bih} is defined over Behaviour Identification Hierarchies (BIHs) for representing ADL structure and typical activity duration. To model execution of ADLs, states of the temporal traces in TPTL_{bih} comprise information about the start, stop and current execution of activities. We provide a number of constraints on these traces that we stipulate are desired for the accurate representation of ADL execution, and investigate corresponding validities in the logic. To evaluate the expressivity of the logic, we give a formal definition for the notion of Coherence for (complex) activities, by which we mean that an activity is done without interruption and in a timely fashion. We show that the definition is satisfiable in our framework. In this way the logic forms the basis for a generic monitoring and reasoning framework for ADLs

Kleene-Schützenberger and Büchi Theorems for Weighted Timed Automata

In 1994, Alur and Dill introduced timed automata as a simple mathematical model for modelling the behaviour of real-time systems. In this thesis, we extend timed automata with weights. More detailed, we equip both the states and transitions of a timed automaton with weights taken from an appropriate mathematical structure. The weight of a transition determines the weight for taking this transition, and the weight of a state determines the weight for letting time elapse in this state. Since the weight for staying in a state depends on time, this model, called weighted timed automata, has many interesting applications, for instance, in operations research and scheduling. We give characterizations for the behaviours of weighted timed automata in terms of rational expressions and logical formulas. These formalisms are useful for the specification of real-time systems with continuous resource consumption. We further investigate the relation between the behaviours of weighted timed automata and timed automata. Finally, we present important decidability results for weighted timed automata

UML 2.0 interactions with OCL/RT constraints

The use of formal methods at early stages of software development contributes to the reliability and robustness of the system to be constructed. Int his context, real-time system development benefits from the construction of behavioral models in order to verify the correct satisfaction of time constraints. The Unified Modeling Language (UML) is a software specification language widely used by the industry and the academia. Nevertheless, its version 2.0 lacks a formal semantics for the development of provably-correct models. In addition, its constraint specification language, Object Constraint Language (OCL), has limitations for its use in behavioral models of real-time systems. This work concerns the inter-component behavioral specification of real-time systems. Such behavior is described using the UML 2.0 Interactions language extended for the inclusion of time constraints using the OCL for Real Time (OCL/RT) language. The main problem addressed in this work is the definition of a formal semantics for the fusion of both languages. The semantics allows recognizing valid and invalid behaviors of a system with time constraints. Intended for formal verification, an analysis of the properties derived from the semantics is also done. In particular, the notions of refinement of interactions and refinement of constraints are explored. Finally, the proposal is compared with related works and its practical application is studied in order to analyze its benefits and weaknesses. This work contributes to the formalization of concepts widely used in practice and, inconsequence, to its inclusion in modeling and formal reasoning tools. More-over, the expressivity of the UML 2.0 Interactions language is augmented in order to support complex real-time constraints, not expressable until this moment