Concurrent Constraint Conditional Branching Interactive Scores

2013 22nd Australian Software Engineering Conference, 2013

Scenario-based specifications have been widely used to specify the behavior of reactive systems in a visual and intuitive way. Timed Property Sequence Chart (TPSC) is a recently proposed scenario-based specification for specifying timing properties for real-time systems. However, there is currently no model checking tool available to verify timing properties specified by TPSC specifications. To mitigate this gap, this paper provides the semantics rules for TPSC by explicitly translating TPSC into Timed Computational Tree Logic (TCTL) that is a realtime temporal logic. Two kinds of rules are defined: basic and compositional rules. Basic rules discuss how to translate a single message in a TPSC specification into a TCTL formula, while compositional rules show how to compose these basic TCTL formulas according to compositional operators. The classification of basic and compositional rules makes our translations more efficient. The translation process is illustrated by a case study. The translating correctness is also proved by the practical measurement of real-time specification patterns. The work described here opens an indirect way to model checking real-time requirements represented in TPSC specifications by translating TPSC specifications into TCTL formulas.

2015 15th International Conference on Application of Concurrency to System Design, 2015

Interactive Scores (IS) is a formalism for composing and performing interactive multimedia scenarios. In IS, the composer defines temporal relations (TRs) between temporal objects (TOs) in order to specify the temporal organization of the scenario. During execution, the performer may trigger interaction points to modify the star/stop times of TOs, while the system guarantees that all the TRs are satisfied. IS is implemented in the tool I-SCORE and its semantics is formally defined as a Hierarchical Time Stream Petri Net (HTSPN). However, this model is not able to represent branching behaviors that are necessary to properly deal with applications such as video games and museum installations. Moreover, HTSPN does not provide tools for the automatic verification of critical properties of scenarios. In this work we define a semantics for IS based on Timed Automata (TA) and we show that such model yields to a complete framework to compose, verify and execute interactive scenarios. More precisely, we show that: 1) our model is able to deal with conditional statements in IS; 2) efficient verification techniques can be now used to reason about the written scenarios; and 3) our model allows for a directly implementation on a reconfigurable device, thus guaranteeing a real-time performance.

Information and Computation, 2000

We study a timed concurrent constraint language, called tccp, which is obtained by a natural timed interpretation of the usual ccp constructs: action-prefixing is interpreted as the next-time operator and the parallel execution of agents follows the scheduling policy of maximal parallelism. Additionally, tccp includes a simple primitive which allows one to specify timing constraints. We define the operational semantics of tccp by means of a transition system and we define a denotational model which is fully abstract with respect to the usual notion of observables (that is, the results of terminating computations). Moreover, we study the semantics and expressive power of the notion of maximal parallelism underlying the computational model of tccp: We define a fully abstract semantics for a sublanguage of tccp, called ccpm, which essentially is concurrent constraint programming, provided that we interpret the parallel operator in terms of maximal parallelism rather than of interleaving. We show that tccp is strictly more expressive than ccpm which, in its turn, is strictly more expressive than ccp.

2005

We provide semantics for the powerful scenario-based language of live sequence charts (LSCs). We show how the semantics of live sequence charts can be captured using temporal logic. This is done by studying various subsets of the LSC language and providing an explicit translation into temporal logic. We show how a kernel subset of the LSC language (which omits variables, for example) can be embedded within the temporal logic CTL*. For this kernel subset the embedding is a strict inclusion.

Lecture Notes in Computer Science, 2004

A constraint is a piece of (partial) information on the values of the variables of a system. Concurrent constraint programming (ccp) is a model of concurrency in which agents (also called processes) interact by telling and asking information (constraints) to and from a shared store (a constraint). Timed (or temporal) ccp (tccp) extends ccp by agents evolving over time. A distinguishing feature of tccp, is that it combines in one framework an operational and algebraic view from process algebra with a declarative view based upon temporal logic. Tccp has been widely used to specify, analyze and program reactive systems. This note provides a comprehensive introduction to the background for and central notions from the theory of tccp. Furthermore, it surveys recent results on a particular tccp calculus, ntcc , and it provides a classification of the expressive power of various tccp languages.

Proceedings Ninth Annual IEEE Symposium on Logic in Computer Science, 1994

We develop a model for timed, reactive computation by extending the asynchronous, untimed concurrent constraint programming model in a simple and uniform way. In the spirit of process algebras, we develop some combinators expressible in this model, and reconcile their operational, logical and denotational character. We show how programs may be compiled into finite-state machines with loop-free computations at each state, thus guaranteeing bounded response time.

Interactive Scores (IS) are a formalism for the design and performance of interactive multimedia scenarios. IS provide temporal relations (TR), but they cannot represent conditional branching and TRs simultaneously. We propose an extension to Allombert et al.'s IS model by including a condition on the TRs. We found out that in order to have a coherent model in all possible scenarios, durations must be flexible; however, sometimes it is possible to have fixed durations. To show the relevance of our model, we modeled an existing multimedia installation called Mariona. In Mariona there is choice, random durations and loops. Whether we can represent all the TRs available in Allombert et al.'s model into ours, or we have to choose between a timed conditional branching model and a pure temporal model before writing a scenario, still remains as an open question.

Information Sciences, 2007

In model checking environments, system requirements are usually expressed by means of temporal logic formulas. We propose a user-friendly interface (UFI) with the aim of simplifying the writing of concurrent system properties. The tool is endowed with a graphical interface that supplies a set of patterns from the natural language; the defined patterns constitute a logic (UFL) that is adequate

Proceedings of the 2006 international workshop on Scenarios and state machines: models, algorithms, and tools - SCESM '06, 2006

Temporal logics are commonly used for reasoning about concurrent systems. Model checkers and other finite-state verification techniques allow for automated checking of system model compliance to given temporal properties. These properties are typically specified as linear-time formulae in temporal logics. Unfortunately, the level of inherent sophistication required by these formalisms too often represents an impediment to move these techniques from "research theory" to "industry practice". The objective of this work is to facilitate the non trivial and error prone task of specifying, correctly and without expertise, temporal properties. In order to understand the basis of a simple but expressive formalism for specifying temporal properties we critically analyze commonly used in practice visual notations. Then we present a scenario-based visual language that, in our opinion, fixes the highlighted lacks of these notations. We propose an extended graphical notation of a subset of UML 2.0 Interaction Sequence Diagrams. A precise semantics of this new language, called Property Sequence Chart (PSC), is provided via translation, by means of an algorithm implemented as a plugin of our Charmy tool, into Büchi automata. Expressiveness of PSC has been validated with respect to well known property specification patterns.

Theory and Practice of Logic Programming, 2014

We propose a timed and soft extension of Concurrent Constraint Programming. The time extension is based on the hypothesis of bounded asynchrony: the computation takes a bounded period of time and is measured by a discrete global clock. Action prefixing is then considered as the syntactic marker which distinguishes a time instant from the next one. Supported by soft constraints instead of crisp ones, tell and ask agents are now equipped with a preference (or consistency) threshold which is used to determine their success or suspension. In the paper we provide a language to describe the agents behavior, together with its operational and denotational semantics, for which we also prove the compositionality and correctness properties. After presenting a semantics using maximal parallelism of actions, we also describe a version for their interleaving on a single processor (with maximal parallelism for time elapsing). Coordinating agents that need to take decisions both on preference values and time events may benefit from this language.