Showing papers on "Denotational semantics published in 2003"

FreshML: programming with binders made simple

Abstract: FreshML extends ML with elegant and practical constructs for declaring and manipulating syntactical data involving statically scoped binding operations User-declared FreshML datatypes involving binders are concrete, in the sense that values of these types can be deconstructed by matching against patterns naming bound variables explicitly This may have the computational effect of swapping bound names with freshly generated ones; previous work on FreshML used a complicated static type system inferring information about the 'freshness' of names for expressions in order to tame this effect The main contribution of this paper is to show (perhaps surprisingly) that a standard type system without freshness inference, coupled with a conventional treatment of fresh name generation, suffices for FreshML's crucial correctness property that values of datatypes involving binders are operationally equivalent if and only if they represent a-equivalent pieces of object-level syntax This is established via a novel denotational semantics FreshML without static freshness inference is no more impure than ML and experience with it shows that it supports a programming style pleasingly close to informal practice when it comes to dealing with object-level syntax modulo a-equivalence

SPQR: flexible automated design pattern extraction from source code

Abstract: Previous automated approaches to discovering design patterns in source code have suffered from a need to enumerate static descriptions of structural and behavioural relationships, resulting in a finite library of variations on pattern implementation. Our approach, System for Pattern Query and Recognition, or SPQR, differs in that we do not seek statically to encode each variant of the patterns that we wish to find. Our system finds pattern variants that were not explicitly defined, but instead are inferred dynamically during code analysis by a theorem prover, providing practical tool support for software construction, comprehension, maintenance, and refactoring. We use a logical inference system to reveal large numbers of patterns and their variations from a small number of definitions by encoding in a formal denotational semantics a small number of fundamental OO concepts (elemental design patterns), encode the rules by which these concepts are combined to form patterns (reliance operators), and encode the structural/behavioral relationships among components of objects and classes (rho-calculus). A chain of fully automated tools provides a path from source code to revealed patterns. We describe our approach in this paper with a concrete example to drive the discussion, accompanied by formal treatment of the foundational topics.

Comparing Petri net and activity diagram variants for workflow modelling - a quest for reactive Petri nets

Abstract: Petri net variants are widely used as a workflow modelling technique. Recently, UMLa ctivity diagrams have been used for the same purpose, even though the syntax and semantics of activity diagrams has not been yet fully worked out. Nevertheless, activity diagrams seem very similar to Petri nets and on the surface, one may think that they are variants of each other. To substantiate or deny this claim, we need to formalise the intended semantics of activity diagrams and then compare this with various Petri net semantics. In previous papers we have defined two formal semantics for UMLact ivity diagrams that are intended for workflow modelling. In this paper, we discuss the design choices that underlie these two semantics and investigate whether these design choices can be met in low-level and high-level Petri net semantics. We argue that the main difference between the Petri net semantics and our semantics of UML act ivity diagrams is that the Petri net semantics models resource usage of closed, active systems that are non-reactive, whereas our semantics of UMLact ivity diagrams models open, reactive systems. Since workflow systems are open, reactive systems, we conclude that Petri nets cannot model workflows accurately, unless they are extended with a syntax and semantics for reactivity.

Formalizing Dynamic Software Updating

Abstract: Dynamic software updating (DSU) enables running programs to be updated with new code and data without interrupting their execution. A number of DSU systems have been designed, but there is still little rigorous understanding of how to use DSU technology so that updates are safe. As a first step in this direction, we introduce a small update calculus with a precise mathematical semantics. The calculus is formulated as an extension of a typed lambda calculus, and supports updating technology similar to that of the programming language Erlang [2]. Our goal is to provide a simple yet expressive foundation for reasoning about dynamically updateable software. In this paper, we present the details of the calculus, give some examples of its expressive power, and discuss how it might be used or extended to guarantee safety properties.

Template semantics for model-based notations

Abstract: We propose a template-based approach to structuring the semantics of model-based specification notations. The basic computation model is a nonconcurrent, hierarchical state-transition machine (HTS), whose execution semantics are parameterized. Semantics that are common among notations (e.g., the concept of an enabled transition) are captured in the template, and a notation's distinct semantics (e.g., which states can enable transitions) are specified as parameters. The template semantics of composition operators define how multiple HTSs execute concurrently and how they communicate and synchronize with each other by exchanging events and data. The definitions of these operators use the template parameters to preserve notation-specific behavior in composition. Our template is sufficient to capture the semantics of basic transition systems, CSP, CCS, basic LOTOS, a subset of SDL88, and a variety of statecharts notations. We believe that a description of a notation's semantics using our template can be used as input to a tool that automatically generates formal analysis tools.

Reactive Petri nets for workflow modeling

Abstract: Petri nets are widely used for modeling and analyzing workflows Using the token-game semantics, Petri net-based workflow models can be analyzed before the model is actually used at run time At run time, a workflow model prescribes behavior of a reactive system (the workflow engine) But the token-game semantics models behavior of closed, active systems Thus, the token-game semantics behavior of a Petri net-based workflow model will differ considerably from its behavior at run time In this paper we define a reactive semantics for Petri nets This semantics can model behavior of a reactive system and its environment We compare this semantics with the token-game semantics and prove that under some conditions the reactive semantics and the token-game semantics induce similar behavior Next, we apply the reactive semantics to workflow modeling and show how a workflow net can be transformed into a reactive workflow net We prove that under some conditions the soundness property of a workflow net is preserved when the workflow net is transformed into a reactive workflow net This result shows that to analyze soundness, the token-game semantics can safely be used, even though that semantics is not reactive

Extending the Operational Semantics of a BDI Agent-Oriented Programming Language for Introducing Speech-Act Based Communication

Abstract: Work on agent communication languages has since long striven to achieve adequate speech act semantics; partly, the problem is that references to an agent’s architecture (in particular a BDI-like architecture) would be required in giving such semantics more rigorously. On the other hand, BDI agent-oriented programming languages have had their semantics formalised for abstract versions only, neglecting practical aspects such as communication primitives; this means that, at least in what concerns communication, implementations of BDI programming languages have been ad hoc. This paper tackles, however preliminarily, both these problems by giving semantics to speech-act based messages received by an AgentSpeak(L) agent. AgentSpeak(L) is a BDI, agent-oriented, logic programming language for which interpreters have been developed, and its theoretical foundations are of great interest. Our work here builds upon a structural operational semantics to AgentSpeak(L) that we have given in previous work. The contribution of this paper is two-fold: we here extend our earlier work on providing a solid theoretical background on which to base existing implementations of AgentSpeak(L) interpreters, as well as we shed light on a more computationally grounded approach to giving semantics for some key illocutionary forces used in speech-act based agent communication languages.

Generating embedded software from hierarchical hybrid models

Abstract: Benefits of high-level modeling and analysis are significantly enhanced if code can be generated automatically from a model such that the correspondence between the model and the code is precisely understood. For embedded control software, hybrid systems is an appropriate modeling paradigm because it can be used to specify continuous dynamics as well as discrete switching between modes. Establishing a formal relationship between the mathematical semantics of a hybrid model and the actual executions of the corresponding code is particularly challenging due to sampling and switching errors. In this paper, we describe an approach to compile the modeling language Charon that allows hierarchical specifications of interacting hybrid systems. We show how to exploit the semantics of Charon to generate code from a model in a modular fashion, and identify sufficient conditions on the model that guarantee the absence of switching errors in the compiled code. The approach is illustrated by compiling a model for coordinated motion of legs for walking onto Sony's AIBO robot.

Solving semantic problems with odd-length cycles in argumentation

Abstract: In the context of Dung’s abstract framework for argumentation, two main semantics have been considered to assign a defeat status to arguments: the grounded semantics and the preferred semantics. While the two semantics agree in most situations, there are cases where the preferred semantics appears to be more powerful. However, we notice that the preferred semantics gives rise to counterintuitive results in some other cases, related to the presence of odd-length cycles in the attack relation between arguments. To solve these problems, we propose a new semantics which preserves the desirable properties of the preferred semantics, while correctly dealing with odd-length cycles. We check the behavior of the proposed semantics in a number of examples and discuss its relationships with both grounded and preferred semantics.

A mathematical semantics for architectural connectors

Abstract: A mathematical semantics is proposed for the notion of architectural connector, in the style defined by Allen and Garlan, that builds on Goguen’s categorical approach to General Systems Theory and other algebraic approaches to specification, concurrency, and parallel program design. This semantics is, essentially, ADL-independent, setting up criteria against which formalisms can be evaluated according to the support that they provide for architectural design. In particular, it clarifies the role that the separation between computation and coordination plays in supporting architecture-driven approaches to software construction and evolution. It also leads to useful generalisations of the notion of connector, namely through the use of multiple formalisms in the definition of the glue and the roles, and their instantiations with programs or system components that can be implemented in different languages or correspond to "real-world" components.

Class analyses as abstract interpretations of trace semantics

Abstract: We use abstract interpretation to abstract a compositional trace semantics for a simple imperative object-oriented language into its projection over a set of program points called watchpoints. We say that the resulting watchpoint semantics is focused on the watchpoints. Every abstraction of the computational domain of this semantics induces an abstract, still compositional, and focused watchpoint semantics. This establishes a basis for developing static analyses obtaining information pertaining only to the watchpoints. As an example, we consider three domains for class analysis of object-oriented programs derived from three techniques present in the literature, namely, rapid type analysis, a simple dataflow analysis, and a constraint-based analysis. We obtain three static analyses which are provably correct and whose abstract operations are provably optimal. Moreover, we prove that our formalization of the constraint-based analysis is more precise than that of the other two analyses. We have implemented our watchpoint semantics and our three domains for class analysis. This implementation shows that the time and space costs of the analysis are actually proportional to the number of watchpoints, as a consequence of the focused nature of the watchpoint semantics.

Quantum Computation, Categorical Semantics and Linear Logic

Abstract: We develop a type theory and provide a denotational semantics for a simple fragment of the quantum lambda calculus, a formal language for quantum computation based on linear logic. In our semantics, variables inhabit certain Hilbert bundles, and computations are interpreted as the appropriate inner product preserving maps between Hilbert bundles. These bundles and maps form a symmetric monoidal closed category, as expected for a calculus based on linear logic.

ArcAngel: a Tactic Language for Refinement

Abstract: Morgan's refinement calculus is a successful technique for developing software in a precise and consistent way. This technique, however, can be hard to use, as developments may be long and repetitive. Many authors have pointed out that a lot can be gained by identifying commonly used development strategies, documenting them as tactics, and using them as single transformation rules. Also, it is useful to have a notation for describing derivations, so that they can be analysed and modified. In this paper, we present ArcAngel, a language for defining such refinement tactics; we present the language, its semantics, and some of its algebraic laws. Apart from Angel, a general-purpose tactic language that we are extending, no other tactic language has a denotational semantics and proof theory of its own.

Coalgebras and monads in the semantics of java

Abstract: This paper describes the basic structures in the denotational and axiomatic semantics of sequential Java, both from a monadic and a coalgebraic perspective. This semantics is an abstraction of the one used for the verification of (sequential) Java programs using proof tools in the LOOP project at the University of Nijmegen. It is shown how the monadic perspective gives rise to the relevant computational structure in Java (composition, extension and repetition), and how the coalgebraic perspective offers an associated program logic (with invariants, bisimulations, and Hoare logics) for reasoning about the computational structure provided by the monad.

Probabilistic Interval XML

Abstract: Interest in XML databases has been growing over the last few years. In this paper, we study the problem of incorporating probabilistic information into XML databases. We propose the Probabilistic Interval XML (PIXml for short) data model in this paper. Using this data model, users can express probabilistic information within XML markups. In addition, we provide two alternative formal model-theoretic semantics for PIXml data. The first semantics is a "global" semantics which is relatively intuitive, but is not directly amenable to computation. The second semantics is a "local" semantics which is more amenable to computation. We prove several results linking the two semantics together. To our knowledge, this is the first formal model theoretic semantics for probabilistic interval XML. We then provide an operational semantics that may be used to compute answers to queries and that is correct for a large class of probabilistic instances.

Non-Standard Semantics for Program Slicing

Abstract: In this paper we generalize the notion of compositional semantics to cope with transfinite reductions of a transition system. Standard denotational and predicate transformer semantics, even though compositional, provide inadequate models for some known program manipulation techniques. We are interested in the systematic design of extended compositional semantics, observing possible transfinite computations, i.e. computations that may occur after a given number of infinite loops. This generalization is necessary to deal with program manipulation techniques modifying the termination status of programs, such as program slicing. We include the transfinite generalization of semantics in the hierarchy developed in 1997 by P. Cousot, where semantics at different levels of abstraction are related with each other by abstract interpretation. We prove that a specular hierarchy of non-standard semantics modeling transfinite computations of programs can be specified in such a way that the standard hierarchy can be derived by abstract interpretation. We prove that non-standard transfinite denotational and predicate transformer semantics can be both systematically derived as solutions of simple abstract domain equations involving the basic operation of reduced power of abstract domains. This allows us to prove the optimality of these semantics, i.e. they are the most abstract semantics in the hierarchy which are compositional and observe respectively the terminating and initial states of transfinite computations, providing an adequate mathematical model for program manipulation.

Concurrency and Refinement in the Unified Modeling Language

Abstract: This paper defines a formal semantics for a subset of the Unified Modeling Language (UML). It shows how suitable combinations of class, object, state, and sequence diagrams can be associated with patterns of interaction, expressed in the event notation of Communicating Sequential Processes (CSP). The diagram semantics is then extended to give a meaning to complete models - suitable combinations of diagrams - and thus a concurrency semantics for object models written in UML. This model semantics is in turn used to define a theory of refinement, based upon existing notions of data and process refinement.

Model-theoretic semantics for the web

Abstract: Model-theoretic semantics is a formal account of the interpretations of legitimate expressions of a language. It is increasingly being used to provide Web markup languages with well-defined semantics. But a discussion of its roles and limitations for the Semantic Web has not yet received a coherent and detailed treatment. This paper takes the first steps towards such a treatment. The major result is an introductory explication of key ideas that are usually only implicit in existing accounts of semantics for the Web. References to more detailed accounts of these ideas are also provided. The benefit of this explication is increased awareness among Web users of some important issues inherent in using model-theoretic semantics for Web markup languages.

Causal pi-Calculus for Biochemical Modelling

Abstract: We present a reduction semantics for the ?-calculus from which causality and concurrency can be mechanically derived. We prove that our semantics agrees with the causal definitions presented in the literature. We then apply the causal reduction semantics in the domain of biochemical systems to study the interactions of components.

Formal semantics of hybrid Chi

Abstract: The verification formalism / modeling and simulation language hybrid Chi is defined The semantics of hybrid Chi is formally specified using Structured Operational Semantics (SOS) and a number of associated functions The χ syntax and semantics can also deal with local scoping of variables and/or channels, implicit differential algebraic equations, such as higher index systems, and they are very well suited for specification of pure discrete event systems

A monadic multi-stage metalanguage

Abstract: We describe a metalanguage MMML, which makes explicit the order of evaluation (in the spirit of monadic metalanguages) and the staging of computations (as in languages for multi-level binding-time analysis) The main contribution of the paper is an operational semantics which is sufficiently detailed for analyzing subtle aspects of multi-stage programming, but also intuitive enough to serve as a reference semantics For instance, the separation of computational types from code types, makes clear the distinction between a computation for generating code and the generated code, and provides a basis for multilingual extensions, where a variety of programming languages (aka monads) co-exist The operational semantics consists of two parts: local (semantics preserving) simplification rules, and computation steps executed in a deterministic order (because they may have side-effects) We focus on the computational aspects, thus we adopt a simple type system, that can detect usual type errors, but not the unresolved link errors Because of its explicit annotations, MMML is suitable as an intermediate language

The Rosetta meta-model framework

Abstract: Heterogeneous systems are naturally complex and their design is a tedious process. The modeling of components that constitute such a system mandates the use of different techniques. This gives rise to the problem of methodology integration that is needed to provide a consistent design. In this paper, we propose a meta-model framework that provides such an integration. The semantics of different computational models can be expressed and used together in the Rosetta framework. We use denotational semantics to define unifying semantic domains, which are themselves extended to provide ontologies for models of computation. Interaction relations defined between models are then used to exploit and analyze model integration. We demonstrate our approach by providing applications where different computational models are used together.

An Indexed Model of Impredicative Polymorphism and Mutable References

Abstract: We present a semantic model of the polymorphic lambda calculus augmented with a higher-order store, allowing the storage of values of any type, including impredicative quantified types, mutable references, recursive types, and functions. Our model provides the first denotational semantics for a type system with updatable references to values of impredicative quantified types. The central idea behind our semantics is that instead of tracking the exact type of a mutable reference in a possible world our model keeps track of the approximate type. While high-level languages like ML and Java do not themselves support storage of impredicative existential packages in mutable cells, this feature is essential when representing ML function closures, that is, in a target language for typed closure conversion of ML programs.

The Kell Calculus: Operational Semantics and Type System

Abstract: This paper presents the Kell calculus, a new distributed process calculus that retains the original insights of the Seal calculus (local actions, process replication) and of the M-calculus (higher-order processes and programmable membranes), although in a much simpler setting than the latter. The calculus is equipped with a type system that enforces a unicity property for location names that is crucial for the efficient implementation of the calculus.