Peter D. Mosses

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.

Casl Reference Manual

Syntax Sorts and Constructors . ...................... 495 Synabol Index . ................................................. 501 Concept Index . ................................................ 511

TAPSOFT '95: Theory and Practice of Software Development

A decade of TAPSOFT.- Theory and practice of software development.- Rational spaces and set constraints.- Formal methods and social context in software development.- Testing can be formal, too.- Anatomy of the Pentium bug.- Rational mechanics and natural mathematics.- First-order logic on finite trees.- Decidability of equivalence for deterministic synchronized tree automata.- The equivalence problem for letter-to-letter bottom-up tree transducers is solvable.- ?I: A symmetric calculus based on internal mobility.- Complete inference systems for weak bisimulation equivalences in the ?-calculus.- Reasoning about higher-order processes.- Confluence of processes and systems of objects.- An algebraic approach to temporal logic.- On behavioural abstraction and behavioural satisfaction in higher-order logic.- Assumption/guarantee specifications in linear-time temporal logic (extended abstract).- Fine hierarchy of regular ?-languages.- Computing the Wadge degree, the Lifschitz degree, and the Rabin index of a regular language of infinite words in polynomial time.- Semi-trace morphisms and rational transductions.- Nonfinite axiomatizability of shuffle inequalities.- On the category of Petri net computations.- High undecidability of weak bisimilarity for Petri nets.- Polynomial algorithms for the synthesis of bounded nets.- Semi-completeness of hierarchical and super-hierarchical combinations of term rewriting systems.- Lazy narrowing: Strong completeness and eager variable elimination (extended abstract).- On the expressive power of algebraic graph grammars with application conditions.- Generated models and the ?-rule: The nondeterministic case.- CPO models for a class of GSOS languages.- Statecharts, transition structures and transformations.- An imperative object calculus.- A refinement of import/export declarations in modular logic programming and its semantics.- Strictness and totality analysis with conjunction.- Generic techniques for source-level debugging and dynamic program slicing.- Reasoning with executable specifications.- Calculating software generators from solution specifications.- Comparing flow-based binding-time analyses.- Can you trust your data.- Static and dynamic processor allocation for higher-order concurrent languages.- Mechanized inductive proof of properties of a simple code optimizer.- Describing a Signal Analyzer in the process algebra PMC - A case study.- A gentle introduction to specification engineering using a case study in telecommunications.- Precise interprocedural dataflow analysis with applications to constant propagation.- Formal specification and prototyping of a program specializer.- Proving the correctness of recursion-based automatic program transformations.- Reactive system specification and refinement.- Measuring concurrency of regular distributed computations.- Non-speculative and upward invocation of continuations in a parallel language.- A model inference system for generic specification with application to code sharing.- Relations as abstract datatypes: An institution to specify relations between algebras.- Performance-oriented formal specifications - the LotoTis approach.- Signal: A formal design environment for real-time systems.- The META-Frame: An environment for flexible tool management.- STeP: The Stanford Temporal Prover.- The HOL-UNITY verification system.- PLATO: A tool to assist programming as term rewriting and theorem proving.- LOFT: A tool for assisting selection of test data sets from algebraic specifications.- The SMoLCS ToolSet.- The Asf+Sdf Meta-environment documentation tools for free.- The B-Toolkit demonstration.- Object Oriented Semantics Directed Compiler Generation: A prototype.

Theoretical Computer Science: Exploring New Frontiers of Theoretical Informatics

Breaking and fixing the Needham-Schroeder public-key protocol using FDR.- Reconciling Two Views of Cryptography.- Theory and Construction of Molecular Computers.- Theory and Construction of Molecular Computers.- On the hardness of the permanent.- List Decoding: Algorithms and Applications.- Approximation Algorithms for String Folding Problems.- Approximation Algorithms for String Folding Problems.- Fast multi-dimensional approximate string matching.- An Index for Two Dimensional String Matching Allowing Rotations.- Parallel Edge Coloring of a Tree on a Mesh Connected Computer.- Parallel Edge Coloring of a Tree on a Mesh Connected Computer.- Linear Time 1/2-Approximation Algorithm for Maximum Weighted Matching in General Graphs.- Parallel Approximation Algorithms for Maximum Weighted Matching in General Graphs.- It Is on the Boundary: Complexity Considerations for Polynomial Ideals.- It Is on the Boundary: Complexity Considerations for Polynomial Ideals.- An Efficient Parallel Algorithm for Scheduling Interval Ordered Tasks.- An Efficient Parallel Algorithm for Scheduling Interval Ordered Tasks.- Reducibility among combinatorial problems.- Task Distributions on Multiprocessor Systems.- Fast Interpolation Using Kohonen Self-Organizing Neural Networks.- Fast Interpolation Using Kohonen Self-Organizing Neural Networks.- Steganography Using Modern Arts.- Steganography Using Modern Arts.- Gossiping in Vertex-Disjoint Paths Mode in d-dimensional Grids and Planar Graphs.- Trade-Offs between Density and Robustness in Random Interconnection Graphs.- An effcient way for edge-connectivity augmentation.- The (? + 1)-Edge-Connectivity Augmentation Problem without Creating Multiple Edges of a Graph.- On the Approximability of NP-complete Optimization Problems.- On the Hardness of Approximating Some NP-Optimization Problems Related to Minimum Linear Ordering Problem.- How Many People Can Hide in a Terrain ?.- Maximum Clique and Minimum Clique Partition in Visibility Graphs.- Language recognition and the synchronization of cellular automata.- Real-Time Language Recognition by Alternating Cellular Automata.- Inducing an order on cellular automata by a grouping operation.- Damage Spreading and ?-Sensitivity on Cellular Automata.- Financial Applications of Monte Carlo and Quasi-Monte Carlo Methods.- Discrepancy Theory and Its Application to Finance.- Fully consistent extensions of partially defined Boolean functions with missing bits.- Fully Consistent Extensions of Partially Defined Boolean Functions with Missing Bitsv.- Dealing necessary and sufficient numbers of cards for sharing a one-bit secret key.- Characterization of Optimal Key Set Protocols.- Algebraic Complexity Theory.- On the Complexity of Integer Programming in the Blum-Shub-Smale Computational Model.- On Logarithmic Simulated Annealing.- On Logarithmic Simulated Annealing.- Specification and verification of concurrent programs in CESAR.- Hierarchical State Machines.- Validating firewalls in mobile ambients.- Ambient Groups and Mobility Types.- Multiway synchronization verified with coupled simulation.- An Asynchronous, Distributed Implementation of Mobile Ambients.- Graph types for monadic mobile processes.- Type Systems for Concurrent Processes: From Deadlock-Freedom to Livelock-Freedom, Time-Boundedness.- Aliasing Models for Mobile Objects.- Local ?-Calculus at Work: Mobile Objects as Mobile Processes.- Typed concurrent objects.- An Interpretation of Typed Concurrent Objects in the Blue Calculus.- Inductive definitions in the system coq. rules and properties.- A Higher-Order Specification of the ?-Calculus.- Compositionality through an operational semantics of contexts.- Open Ended Systems, Dynamic Bisimulation and Tile Logic.- Observe behaviour categorically.- Fibred Models of Processes: Discrete, Continuous, and Hybrid Systems.- The Equivalence Problem for Deterministic Pushdown Automata is Decidable.- On the Complexity of Bisimulation Problems for Pushdown Automata.- Session 2.4.- A Type-Theoretic Study on Partial Continuations.- Partially Typed Terms between Church-Style and Curry-Style.- Alternating Automata and Logics over Infinite Words.- Hypothesis Support for Information Integration in Four-Valued Logics.- Invited Talk 2.2.- Masaccio: A Formal Model for Embedded Components.- Session 2.5.- A Single Complete Refinement Rule for Demonic Specifications.- Reasoning about Composition Using Property Transformers and Their Conjugates.- Invited Talk 2.3.- Some New Directions in the Syntax and Semantics of Formal Languages.- Panel Discussion on New Challanges for TCS.- New Challenges for Theoretical Computer Science.- Algorithm Design Challenges.- Quantumization of Theoretical Informatics.- Two Problems in Wide Area Network Programming.- New Challenges for Computational Models.- Towards a Computational Theory of Everything.- Open Lectures.- On the Power of Interactive Computing.- The Varieties of Programming Language Semantics.

Theory and Practice of Action Semantics

Action Semantics is a framework for the formal description of programming languages. Its main advantage over other frameworks is pragmatic: action-semantic descriptions (ASDs) scale up smoothly to realistic programming languages. This is due to the inherent extensibility and modifiability of ASDs, ensuring that extensions and changes to the described language require only proportionate changes in its description. (In denotational or operational semantics, adding an unforeseen construct to a language may require a reformulation of the entire description.)

Composing programming languages by combining action-semantics modules

This article demonstrates a method for composing a programming language by combining action-semantics modules. Each module is defined separately, and then a programming-language module is defined by combining existing modules. This method enables the language designer to gradually develop a language by defining, selecting and combining suitable modules. The resulting modular structure is substantially different from that previously employed in action-semantic descriptions.It also discusses how to resolve the conflicts that may arise when combining modules, and indicates some advantages that action semantics has over other approaches in this respect.

Unified algebras and institutions

A framework for algebraic specification of abstract data types is introduced. It involves so-called unified algebras, where sorts are treated as values, so that operations can be applied to sorts as well as to the elements that they classify. An institution for unified algebras is defined and shown to be liberal. However, the ordinary forgetful functor does not forget any values in unified algebras, so the usual data constraints do not have any models. A more forgetful functor is introduced and used to define so-called bounded data constraints, which have the expected models.<<ETX>>

Unified Algebras and Action Semantics

The recently-developed framework of Unified Algebras is intended for axiomatic specification of abstract data types. In contrast, the somewhat older framework of Action Semantics (earlier known as “Abstract Semantic Algebras”) is for denotational specification of programming languages. This paper gives an introduction to the main features of Unified Algebras and Action Semantics, and discusses the relation between them. The two frameworks both exploit nondeterministic choice in unconventional ways.

Implicit Propagation in Structural Operational Semantics

In contrast to a transition system specification in process algebra, a structural operational semantics (SOS) of a programming language usually involves auxiliary entities: stores, environments, etc. When specifying SOS rules, particular auxiliary entities often need to be propagated unchanged between premises and conclusions. The standard technique is to make such propagation explicit, using variables. However, referring to all entities that need to be propagated unchanged in each rule can be tedious, and it hinders direct reuse of rules in different language descriptions. This paper proposes a new interpretation of SOS rules, such that each auxiliary entity is implicitly propagated in all rules in which it is not mentioned. The main benefits include significant notational simplification of SOS rules and much-improved reusability. This new interpretation of SOS rules is based on the same foundations as Modular SOS, but avoids the notational overhead of grouping auxiliary entities together in labels. After motivating and explaining implicit propagation, the paper considers the foundations of SOS and Modular SOS specifications, and defines the meaning of SOS specifications with implicit propagation by translating them to Modular SOS. It then shows how implicit propagation can simplify various rules found in the SOS literature.

Formal Semantics of Programming Languages

These notes give an overview of the main frameworks that have been developed for specifying the formal semantics of programming languages. Some of the pragmatic aspects of semantic descriptions are discussed, including modularity, and potential applicability to visual and modelling languages. References to the literature provide starting points for further study.