Andrzej Tarlecki

Specifications in an arbitrary institution

A formalism for constructing and using axiomatic specifications in an arbitrary logical system is presented. This builds on the framework provided by Goguen and Burstall’s work on the notion of an institution as a formalisation of the concept of a logical system for writing specifications. We show how to introduce free variables into the sentences of an arbitrary institution and how to add quantitiers which bind them. We use this foundation to define a set of primitive operations for building specifications in an arbitrary institution based loosely on those in the ASL kernel specification language. We examine the set of operations which results when the definitions are instantiated in institutions of total and partial tirst-order logic and compare these with the operations found in existing specification languages. We present proof rules which allow proofs to be conducted in specifications built using the operations we define. Finally, we introduce a simple mechanism for defining and applying parameterised specifications and briefly discuss the program development

Extended ML: Past, Present, and Future

An overview of past, present and future work on the Extended ML formal program development framework is given, with emphasis on two topics of current active research: the semantics of the Extended ML specification language, and tools to support formal program development.

Toward formal development of programs from algebraic specifications: implementations revisited

SummaryThe program development process is viewed as a sequence of implementation steps leading from a specification to a program. Based on an elementary notion of refinement, two notions of implementation are studied: constructor implementations which involve a construction “on top of” the implementing specification, and abstractor implementations which additionally provide for abstraction from some details of the implemented specification. These subsume most formal notions of implementation in the literature. Both kinds of implementations satisfy a vertical composition and a (modified) horizontal composition property. All the definitions and results are shown to generalise to the framework of an arbitrary institution, and a way of changing institutions during the implementation process is introduced. All this is illustrated by means of simple concrete examples.

CASL: the common algebraic specification language

The Common Algebraic Specification Language (CASL) is an expressive language for the formal specification of functional requirements and modular design of software. It has been designed by CoFI, the international Common Framework Initiative for algebraic specification and development. It is based on a critical selection of features that have already been explored in various contexts, including subsorts, partial functions, first-order logic, and structured and architectural specifications. CASL should facilitate interoperability of many existing algebraic prototyping and verification tools.This paper gives an overview of the CASL design. The major issues that had to be resolved in the design process are indicated, and all the main concepts and constructs of CASL are briefly explained and illustrated -- the reader is referred to the CASL Language Summary for further details. Some familiarity with the fundamental concepts of algebraic specification would be advantageous.

FM 2005: Formal Methods

Keynote Talks.- Formal Aids for the Growth of Software Systems.- Formal Methods and Testing: Hypotheses, and Correctness Approximations.- The Natural History of Bugs: Using Formal Methods to Analyse Software Related Failures in Space Missions.- Object Orientation.- Modular Verification of Static Class Invariants.- Decoupling in Object Orientation.- Controlling Object Allocation Using Creation Guards.- Symbolic Animation of JML Specifications.- Resource Analysis and Verification.- Certified Memory Usage Analysis.- Compositional Specification and Analysis of Cost-Based Properties in Probabilistic Programs.- Formally Defining and Verifying Master/Slave Speculative Parallelization.- Timing and Testing.- Systematic Implementation of Real-Time Models.- Timing Tolerances in Safety-Critical Software.- Timed Testing with TorX.- Automatic Verification and Conformance Testing for Validating Safety Properties of Reactive Systems.- CSP, B and Circus.- Adding Conflict and Confusion to CSP.- Combining CSP and B for Specification and Property Verification.- Operational Semantics for Model Checking Circus.- Control Law Diagrams in Circus.- Security.- Verification of a Signature Architecture with HOL-Z.- End-to-End Integrated Security and Performance Analysis on the DEGAS Choreographer Platform.- Formal Verification of Security Properties of Smart Card Embedded Source Code.- Networks and Processes.- A Formal Model of Addressing for Interoperating Networks.- An Approach to Unfolding Asynchronous Communication Protocols.- Semantics of BPEL4WS-Like Fault and Compensation Handling.- Abstraction, Retrenchment and Rewriting.- On Some Galois Connection Based Abstractions for the Mu-Calculus.- Retrenching the Purse: Finite Sequence Numbers, and the Tower Pattern.- Strategic Term Rewriting and Its Application to a Vdm-sl to Sql Conversion.- Scenarios and Modeling Languages.- Synthesis of Distributed Processes from Scenario-Based Specifications.- Verifying Scenario-Based Aspect Specifications.- An MDA Approach Towards Integrating Formal and Informal Modeling Languages.- Model Checking.- Model-Checking of Specifications Integrating Processes, Data and Time.- Automatic Symmetry Detection for Model Checking Using Computational Group Theory.- On Partitioning and Symbolic Model Checking.- Dynamic Component Substitutability Analysis.- Industry Day: Abstracts of Invited Talks.- Floating-Point Verification.- Preliminary Results of a Case Study: Model Checking for Advanced Automotive Applications.- Model-Based Testing in Practice.- Testing Concurrent Object-Oriented Systems with Spec Explorer.- ASD Case Notes: Costs and Benefits of Applying Formal Methods to Industrial Control Software.- The Informal Nature of Systems Engineering.

On observational equivalence and algebraic specification

Abstract The properties of a simple and natural notion of observational equivalence of algebras and the corresponding specification-building operation are studied. We begin with a definition of observational equivalence which is adequate to handle reachable algebras only, and show how to extend it to cope with unreachable algebras and also how it may be generalised to make sense under an arbitrary institution. Behavioural equivalence is treated as an important special case of observational equivalence, and its central role in program development is shown by means of an example.

Some fundamental algebraic tools for the semantics of computation, part 3: indexed categories

Abstract This paper presents indexed categories which model uniformly defined families of categories, and suggests that they are a useful tool for the working computer scientist. An indexed category gives rise to a single flattened category as a disjoint union of its component categories plus some additional morphisms. Similarly, an indexed functor (which is a uniform family of functors between the components categories) induces a flattened functor between the corresponding flattened categories. Under certain assumptions, flattened categories are (co)complete if all their components are, and flattened functors have left adjoints if all their components do. Several examples are given. Although this paper is Part 3 of the series “Some fundamental algebraic tools for the semantics of computation”, it is entirely independent of Parts 1 and 2.

Essential concepts of algebraic specification and program development

The main ideas underlying work on the model-theoretic foundations of algebraic specification and formal program development are presented in an informal way. An attempt is made to offer an overall view, rather than new results, and to focus on the basic motivation behind the technicalities presented elsewhere.

Moving Between Logical Systems

This paper presents a number of concepts of a mapping between logical systems modelled as institutions, discusses their mutual merits and demerits, and sketches their role in the process of system speciication and development. Some simple properties of the resulting categories of institutions are given.

Toward formal development of programs from algebraic specifications: Parameterisation revisited

Parameterisation is an important mechanism for structuring programs and specifications into modular units. The interplay between parameterisation (of programs and of specifications) and specification (of parameterised and of non-parameterised programs) is analysed, exposing important semantic and methodological differences between specifications of parameterised programs and parameterised specifications. The extension of parameterisation mechanisms to the higher-order case is considered, both for parameterised programs and parameterised specifications, and the methodological consequences of such an extension are explored.A specification formalism with parameterisation of an arbitrary order is presented. Its denotational-style semantics is accompanied by an inference system for proving that an object satisfies a specification. The formalism includes the basic specification-building operations of the ASL specification language and is institution independent.