It is an open problem whether weak bisimilarity is decidable for Basic Process Algebra (BPA) and Basic Parallel Processes (BPP). A PSPACE lower bound for BPA and NP lower bound for BPP were demonstrated by Stribrna. Mayr recently achieved a result, saying that weak bisimilarity for BPP is $\Pi_2^P$-hard. We improve this lower bound to PSPACE, and, moreover, prove this result for the restricted class of normed BPP. It is also not known whether weak regularity (finiteness) of BPA and BPP is decidable. In the case of BPP there is a $\Pi_2^P$-hardness result by Mayr, which we improve to PSPACE. No lower bound has previously been established for BPA. We demonstrate DP-hardness, which, in particular, implies both NP and co-NP-hardness. In each of the bisimulation/regularity problems we also consider the classes of normed processes. Finally, we show how the technique for proving co-NP lower bound for weak bisimilarity of BPA can be applied to strong bisimilarity of BPP.

In ACP-style process algebra the interpretation of a constant atomic action combines action execution with termination. In a setting with timing, different forms of termination can be distinguished: some-time termination, termination before the next clock tick, urgent termination, having terminated. In a setting with the silent action $\tau$, we also have silent termination. This leads to problems with the interpretation of atomic actions in timed theories that involve some form of the empty process or some form of the silent action. Reflection on these problems led to a redesign of basic process algebra, where action execution and termination are separated. Instead of actions as constants, we have action prefix operators. Sequential composition remains a basic operator, and thus we have two basic constants for termination: $\delta$ for unsuccessful termination (deadlock) and $\epsilon$ for successful termination (skip). We can recover standard ACP-style process algebras as subtheories of the new theory. The new approach has definite advantages over the standard approach. The paper contributes to ongoing work on relationships between algebras with different timing features.

We introduce the $\lambda-coiteration$ schema for a distributive law $\lambda$ of a functor $\Functor{T}$ over a functor $\Functor{F}$. Parameterised by $\Functor{T}$ and $\lambda$ it generalises the basic coiteration schema uniquely characterising functions into a final $\Functor{F}$-coalgebra. Furthermore, the same parameters are used to generalise the categorical notion of a bisimulation to that of a $\lambda-bisimulation$, while still giving rise to a proof technique for bisimilarity. We first present a theorem showing the validity of the resulting definition and proof principles for categories with countable coproducts.

Our approach gives a unifying categorical presentation and justification of several extensions of the basic coinduction schemata that have been treated separately before, and some only for specific types of system. As examples, the duals of primitive recursion and course-of-value iteration, which are known extensions of coiteration, arise as instances of our framework.

Moreover, we derive schemata involving auxiliary operators definable with GSOS-style specifications such as addition of streams, regular operators on languages, or parallel and sequential composition of processes. The argument is based on a variation of the theory in the setting of monads and copointed functors. The schemata justify guarded recursive definitions and an up-to-context proof technique for operators of the type mentioned. The latter can ease bisimilarity proofs considerably.

We show how the principal typing property of the rank 2 intersection type system enables the specification of a modular and polyvariant control-flow analysis.

We present a type-based flow analysis for simply typed lambda calculus with booleans, data-structures and recursion. The analysis is exact in the following sense: if the analysis predicts a redex, there exists a reduction sequence (using standard reduction plus context propagation rules) such that this redex will be reduced. The precision is accomplished using intersection typing.

It follows that the analysis is non-elementary recursive – more surprisingly, the analysis is decidable. We argue that the specification of such an analysis provides a good starting point for developing new flow analyses and an important benchmark against which other flow analyses can be compared. Furthermore, we believe that the techniques employed for stating and proving exactness are of independent interest: they provide methods for reasoning about the precision of program analyses.

A preliminary version of this paper has previously been published (Mossin 1997b). The present paper extends, elaborates and corrects this previously published abstract.

In this paper we show how the expressive power of a language for the description of timed processes strongly affects the discriminating power of urgent and patient actions. In a sense, it studies the interplay between syntax and semantics of time-critical systems.

Whilst the relationship between initial algebras and monads is well understood, the relationship between final coalgebras and comonads is less well explored. This paper shows that the problem is more subtle than might appear at first glance: final coalgebras can form monads just as easily as comonads, and, dually, initial algebras form both monads and comonads.

In developing these theories we strive to provide them with an associated notion of syntax. In the case of initial algebras and monads this corresponds to the standard notion of algebraic theories consisting of signatures and equations: models of such algebraic theories are precisely the algebras of the representing monad. We attempt to emulate this result for the coalgebraic case by first defining a notion of cosignature and coequation and then proving that the models of such coalgebraic presentations are precisely the coalgebras of the representing comonad.

We investigate the use of conjunctive non-standard type inference for the elimination of useless code in higher-order typed functional programs. In particular, we present a non-standard type assignment system for detecting useless code together with a mapping that simplifies a program by removing the useless code detected using the system.