Rodney Martineau Burstall -Rod, as he was known to us all -died on Thursday, 13th February, 2025, after a long illness.Rod was a kind and generous man who will be remembered by those who knew him as much for his humanity as for his contributions to computer science.While he made major contributions to our subject, he constantly demonstrated humility, curiosity, openness, tolerance, and acceptance.He read widely and enjoyed discussing -or learning about -basically any topic that his conversational partner felt passionate about.Perhaps more than anything he exemplified a comfortable way of being human.To many of us that was his greatest contribution to our lives.Rod was born in 1934, the son of a draftsman and a housewife from Liverpool.He attended King George V Grammar School at Southport, moved on to King's College, Cambridge, reading Natural Sciences, and then took a Masters in

Abstract Parametric runtime verification is the process of verifying properties of execution traces of (data carrying) events produced by a running system. This paper continues our work exploring the relationship between specification techniques for parametric runtime verification. Here we consider the correspondence between trace-slicing automata-based approaches and rule systems. The main contribution is a translation from quantified automata to rule systems, which has been implemented inScala. This then allows us to highlight the key differences in how the two formalisms handle data, an important step in our wider effort to understand the correspondence between different specification languages for parametric runtime verification. This paper extends a previous conference version of this paper with further examples, a proof of correctness, and an optimisation based on a notion of redundancy observed during the development of the translation.

This paper presents a technique for using execution traces to mine parametric temporal specifications in the form of quantified event automata (QEA) - previously introduced as an expressive and efficient formalism for runtime verification. We consider a pattern-based mining approach that uses a pattern library to generate and check potential properties over given traces, and then combines successful patterns. By using predefined models to measure the tool's precision and recall we demonstrate that our approach can effectively and efficiently extract specifications in realistic scenarios.

In Barringer et al. (2004,Vol. 2937, LNCS), Eagle was introduced as a general purpose rule-based temporal logic for specifying run-time monitors. A novel interpretative trace-checking scheme via stepwise transformation of an Eagle monitoring formula was defined and implemented. However, even though Eagle presents an elegant formalism for the expression of complex trace properties, Eagle's interpretation scheme is complex and appears difficult to implement efficiently. In this article, we introduce RuleR, a primitive conditional rule-based system, which has a simple and easily implemented algorithm for effective run-time checking, and into which one can compile a wide range of temporal logics and other specification formalisms used for run-time verification. As a formal demonstration, we provide a translation scheme for linear-time propositional temporal logic with a proof of translation correctness. We then introduce a parameterized version of RuleR, in which rule names may have rule-expression or data parameters, which then coincides with the same expressivity as Eagle with data arguments. RuleR with just rule-expression parameters extend the expressiveness of RuleR strictly beyond the class of context-free languages. For the language classes expressible in propositional RuleR, the addition of rule-expression and data parameters enables more compact translations. Finally, we outline a few simple syntactic extensions of ‘core’ RuleR that can lead to further conciseness of specification but still enabling easy and efficient implementation.

We consider continuous quantities that are used to describe the physical world, such as colour, shape, sound, texture and spatial and temporal arrangements. Natural languages are not adept at describing these quantities, nor are they easily incorporated into ontologies in the form of discrete terms. In this article, we analyse the way that natural languages handle continuous quantities, propose a general semantics based on metric spaces, and describe how to treat semantic values computationally, so that we may automate the processing of texts which describe continuous quantities allowing, for example, query evaluation and the integration of multiple texts. This provides a basis for incorporating these quantities into ontologies and combining their semantics with automated reasoning tools. We run a series of experiments to evaluate the semantics, the general framework, and the computational system we have developed.

We present a revision-based logical framework for modelling hierarchical assemblies of evolvable component systems. An evolvable component is a tight coupling of a pair of components, consisting of a supervisor and a supervisee, with the supervisor able to both monitor and evolve its supervisee. An evolvable component pair is itself a component so may have its own supervisor, or may be encapsulated as part of a larger component. Components are modelled as logical theories containing actions which describe state revisions. Supervisor components are modelled as theories which are logically at a meta-level to their supervisee. Revision actions at the meta-level describe theory changes in the supervisee at the object-level. These correspond to various evolutionary changes in the component. We present this framework and show how it enables us to describe the architecture and logical structure of evolvable systems.

Formal Aspects of Computing are dedicated to Professor Rod Burstall, and, as a collection of papers, memoirs and incidental pieces, form a Festschrift for Rod. The contributions are made by some of the many who know Rod and have been in uenced by him. The research papers included here represent some of the areas in which Rod has been active, and the editors thank their colleagues for agreeing to contribute to this Festschrift.

We investigate the proof structure and models of theories of classes, where classes are ‘collections’ of entities. The theories are weaker than set theories and arise from a study of type classes in programming languages, as well as from comprehension schemata in categories. We introduce two languages of proofs: one a simple type theory and the other involving proof environments for storing and retrieving proofs. The relationship between these languages is defined in terms of a normalisation result for proofs. We use this result to define a categorical semantics for classes and establish its coherence. Finally, we show how the formal systems relate to type classes in programming languages.

Abstract We consider an extension of the functional programming language Standard ML with a modular structure based upon concepts in category theory such as categories, functors, natural transformations and adjunctions. In essence, we are following the categorical imperative of considering arrows as well as objects. This is intended to enforce a certain mathematical rigour on the programmer, so that the only programs that can be expressed are those with a categorical significance. The essentially algebraic nature of category theory means that we may generate equational correctness conditions for the modular structure of programs, thus separating the correctness of individual functions from that of modules. We describe this programming language, give examples of its use, and explain how it is implemented in a type system.