A robust semantics hides fewer errors

Electronic Notes in Theoretical Computer Science, 2009

Refinement by interpretation replaces signature morphisms by logic interpretations as a means to translate specifications and witness refinements. The approach was recently introduced by the authors [MMB09] in the context of equational specifications, in order to capture a number of relevant transformations in software design, reuse and adaptation. This paper goes a step forward and discusses the generalization of this idea to deductive systems of arbitrary dimension. This makes possible, for example, to refine sentential into equational specifications and the latter into modal ones. Moreover, the restriction to logics with finitary consequence relations is dropped which results in increased flexibility along the software development process.

Artificial Intelligence, 2002

An algorithm for computing the stable model semantics of logic programs is developed. It is shown that one can extend the semantics and the algorithm to handle new and more expressive types of rules. Emphasis is placed on the use of efficient implementation techniques. In particular, an implementation of lookahead that safely avoids testing every literal for failure and that makes the use of lookahead feasible is presented. In addition, a good heuristic is derived from the principle that the search space should be minimized.

Concepts, Methodologies, Tools, and Applications, 2014

This chapter contributes to the formal specification of Kermeta, a popular metamodelling framework useful for the design of DSL structure and semantics. The formal specification is tool-/tool syntax independent; it only uses classical mathematical instruments taught in usual computer science courses. This specification serves as a reference specification from which specialised implementation can be derived for execution, simulation, or formal analysis of DSLs. By providing such a specification, the chapter ensures that each and every DSL written in Kermeta, receives de facto a formal counterpart, making its definition fully formal. This radically contrasts with other approaches that require a new ad hoc semantics defined for every new DSL. The chapter briefly reports on two implementations conducted to demonstrate the feasibility of the approach.

In this paper we give simple example abstract data types, with atomic opera- tions, that are related by data refinement under a definition used widely in the liter- ature, but these abstract data types are not related by singleton failure refinement. This contradicts results found in the literature. Further we show that a common way to change a model of atomic operations to one of value passing operations actually changes the underlying atomic operational semantics.

Computer Standards & Interfaces, 1989

Most language definitions strike compromises be-DK 8000 Aarhus C, Denmark tween these goals, and it may be that no single Charles RATTRAY document can adequately address all audiences. Because informal methods are inadequate, re

2009 Seventh IEEE International Conference on Software Engineering and Formal Methods, 2009

Traditional notions of refinement of algebraic specifications, based on signature morphisms, are often too rigid to capture a number of relevant transformations in the context of software design, reuse and adaptation. This paper proposes an alternative notion of specification refinement, building on recent work on logic interpretation. The concept is discussed, its theory partially developed, its use illustrated through a number of examples.

2000

Over the last years various semantics have been proposed for dealing with updates in the setting of logic programs. The availability of dierent semantics naturally raises the question of which are the most adequate to model updates. A systematic approach to face this question is to identify general principles against which such semantics should be tested. In this paper we

1995

The notion of action re nement has been studied intensively in the past few years. It is usually introduced in the form of an operator in a process algebraic language, for which a denotational semantics in a suitable model is then given. In this paper we complement this approach b y de ning a corresponding operational semantics for re nement, in the form of derivation rules for a transition relation. Because of the (well-known) fact that ordinary transition systems are not expressive enough to capture the e ects of re nement, we use an event-based transition system model described elsewhere in the literature. The operational semantics of renement t h us de ned is equivalent (in fact event isomorphic) to the usual denotational semantics.

2018

This chapter looks at these issues in process algebras. As a canonical example we look at CSP, but we also discuss CCS and LOTOS. The link to the semantics is made to Chap. 1 as well as elements of Chap. 5. Process algebras describe a system in terms of interacting components which evolve concurrently. The components are called processes. The use of the word algebra refers to the fact that these languages are often equipped with a rich algebraic theory in terms of laws giving equivalence of processes. The alternative term of "process calculi" is sometimes used. CSP (for Communicating Sequential Processes) describes a system as a collection of interacting communicating components running concurrently. The components are called processes, and the interaction between them is in terms of the synchronisation on events. We will think of a process as a self-contained component with an interface, through which it interacts with the environment, and the interface is described as a set of events. Events are instantaneous and atomic, just as the actions in a labelled transition system. Notation: We will use the following notation. Σ is the set of all possible events. will be a termination event, not in Σ. We define the set Σ to be Σ ∪ { } (and similarly for A ). TRACE is the set of all traces over Σ . As usual traces(P) is the set of all finite traces of a process P. Processes are described by guarded equations as in the following small example (c.f. Fig. 1.1 in Chap. 1): V M = pound →((coffee_button → coffee → stop) (tea_button → tea → stop))

Refinement in bisimulation semantics is defined differently from refinement in failure semantics: in bisimulation semantics refinement is based on simulations between labelled transition systems, whereas in failure semantics refinement is based on inclusions between failure systems. There exist however pairs of refinements, for bisimulation and failure semantics respectively, that have almost the same properties. Furthermore, each refinement in bisimulation semantics implies its counterpart in failure semantics, and conversely each refinement in failure semantics implies its counterpart in bisimulation semantics defined on the canonical form of the compared processes.