Marc Aiguier

A formal abstract framework for modelling and testing complex software systems

The contribution of this paper is twofold: first, it defines a unified framework for modelling abstract components, as well as a formalization of integration rules to combine their behaviour. This is based on a coalgebraic definition of components, which is a categorical representation allowing the unification of a large family of formalisms for specifying state-based systems. Second, it studies compositional conformance testing i.e. checking whether an implementation made of correct interacting components combined with integration operators conforms to its specification.

Testing from algebraic specifications: test data set selection by unfolding axioms

This paper deals with test data set selection from algebraic specifications. Test data sets are generated from selection criteria which are usually defined to cover specification axioms. The unfolding selection criterion consists in covering the input domain of an operation using case analysis. The unfolding procedure can be iterated in order to split input domains of operations into finer subdomains. In this paper we propose to extend an unfolding procedure previously developed in [5, 19] that could only be performed on very low level, i.e. executable specifications. On the contrary, our new unfolding procedure can be applied to any positive conditional specification. We show that our unfolding procedure is sound (no test is added) and complete (no test is lost) with respect to the starting reference test data set.

Modeling of complex systems II: A minimalist and unified semantics for heterogeneous integrated systems

The purpose of this paper is to contribute to a unified formal framework for complex systems modeling. To this aim, we define a unified semantics for systems including integration operators. We consider complex systems as functional blackboxes (with internal states), whose structure and behaviors can be constructed through a recursive integration of heterogeneous components. We first introduce formal definitions of time (allowing to deal uniformly with both continuous and discrete times) and data (allowing to handle heterogeneous data), and introduce a generic synchronization mechanism for dataflows. We then define a system as a mathematical object characterized by coupled functional and states behaviors. This definition is expressive enough to capture the functional behavior of any real system with sequential transitions. We finally provide formal operators for integrating systems and show that they are consistent with the classical definitions of those operators on transfer functions which model real systems.

An Institution-independent Proof of the Beth Definability Theorem

A few results generalizing well-known classical model theory ones have been obtained in institution theory these last two decades (e.g. Craig interpolation, ultraproduct, elementary diagrams). In this paper, we propose a generalized institution-independent version of the Beth definability theorem.

Stratified institutions and elementary homomorphisms

For conventional logic institutions, when one extends the sentences to contain open sentences, their satisfaction is then parameterized. For instance, in the first-order logic, the satisfaction is parameterized by the valuation of unbound variables, while in modal logics it is further by possible worlds. This paper proposes a uniform treatment of such parameterization of the satisfaction relation within the abstract setting of logics as institutions, by defining the new notion of stratified institutions. In this new framework, the notion of elementary model homomorphisms is defined independently of an internal stratification or elementary diagrams. At this level of abstraction, a general Tarski style study of connectives is developed. This is an abstract unified approach to the usual Boolean connectives, to quantifiers, and to modal connectives. A general theorem subsuming Tarskis elementary chain theorem is then proved for stratified institutions with this new notion of connectives.

A temporal logic for input output symbolic transition systems

In this paper, we present a temporal logic called /spl Fscr/ whose interpretation is over input output symbolic transition systems (IOSTS). IOSTS extend transition systems to communications and data in order to tackle communications with system environment. /spl Fscr/ is then defined as an extension of temporal logic CTL* (a temporal logic which mixes together the features of linear temporal logic (LTL) and computational temporal logic (CTL)). Three basic properties are established on /spl Fscr/: adequacy and preservation of properties along synchronized product and IOSTS refinement.

Test selection criteria for quantifier-free first-order specifications

This paper deals with test case selection from axiomatic specifications whose axioms are quantifier-free first-order formulae. Test cases are modeled as ground formulae and any specification has an exhaustive test data set whose successful submission means correctness, provided that the software under verification can be modeled as a first-order structure over the same signature. As it has already been done for positive conditional equational specifications, we derive test cases from selection criteria based on axiom coverage. Our selection criteria allows us to select test cases by iteratively unfolding an initial target test purpose, given as a formula. The initial reference test set is iteratively split into successive subsets. Each subset of test cases is defined by constraints which are increasingly introduced by the unfolding procedure to ensure an appropriate matching between the current test purpose under unfolding and specification axioms. Our unfolding procedure is sound (no test is added) and complete (no test is lost) with respect to the starting test purpose. It is exemplified on a simple example.

Label algebras and exception handling

Abstract We propose a new algebraic framework for exception handling which is powerful enough to cope with many exception handling features such as recovery, implicit propagation of exceptions, etc. This formalism treats all the exceptional cases; on the contrary, we show that within all the already existing frameworks, the case of bounded data structures with certain recoveries of exceptional values remained unsolved. We justify the usefulness of “labelling” some terms in order to easily specify exceptions without inconsistency. Surprisingly, there are several cases where even if two terms have the same value, one of them is a suitable instance of a variable in a formula while the other one is not. The main idea underlying our new framework of label algebras is that the semantics of algebraic specifications can be deeply improved when the satisfaction relation is defined via assignments with range in terms instead of values. We give initiality results, which are useful for structured specifications, and a calculus for positive conditional label specifications, which is complete on ground formulas. Exception algebras and exception specifications are then defined as a direct application of label algebras. The usual inconsistency problems raised by exception handling are avoided by the possibility of labelling terms. We also sketch out how far the application domain of label algebras is more general than exception handling.

ÉTOILE-specifications: An Object-oriented Algebraic Formalism with Refinement

In this paper, we investigate the formal specification of reactive systems described in an object-oriented style. We define a formalism, called ETOILE1-specifications, to deal with concurrent (active) object systems, and propose to extend algebraic approaches to dynamic and concurrent aspects by considering implicit states and implicit transitions, respectively. ETOILE-specifications emphasize systems composed of object types. Consequently, the ETOILE-formalism is split into two sub-formalisms. The first one enables us to specify the behaviour of object types. Then, it is extended from object types to systems by adding new requirements, mainly to describe the underlying architectural aspects of the system under specification (i.e. relationships between objects). The complexity of real systems results in the definition of formal means to manage their size. To deal with this issue, we propose a refinement of object type specifications by systems in the framework of ETOILE-specifications, which enables one to build his(her) specification in an incremental way.

On a Generalised Logicality Theorem

In this paper, the correspondence between derivability (syntactic consequences obtained from ?) and convertibility in rewriting (?), the so-called logicality, is studied in a generic way (i.e. logic-independent). This is achieved by giving simple conditions to characterise logics where (bidirectional) rewriting can be applied. These conditions are based on a property defined on proof trees, that we call semi-commutation. Then, we show that the convertibility relation obtained via semi-commutation is equivalent to the inference relation ? of the logic under consideration.