A relational model of non-deterministic dataflow

1997

Abstract We recast dataflow in a modern categorical light using profunctors as a generalization of relations. The well known causal anomalies associated with relational semantics of indeterminate dataflow are avoided, but still we preserve much of the intuitions of a relational model. The development fits with the view of categories of models for concurrency and the general treatment of bisimulation they provide. In particular it fits with the recent categorical formulation of feedback using traced monoidal categories.

2000

This thesis is concerned with formal semantics and models for concurrent computational systems, that is, systems consisting of a number of parallel computing sequential systems, interacting with each other and the environment. A formal semantics gives meaning to computational systems by describing their behaviour in a mathematical model. For concurrent systems the interesting aspect of their computation is often how they interact with the environment during a computation and not in which state they terminate, indeed they may not be intended to terminate at all. For this reason they are often referred to as reactive systems, to distinguish them from traditional calculational systems, as e.g. a program calculating your income tax, for which the interesting behaviour is the answer it gives when (or if) it terminates, in other words the (possibly partial) function it computes between input and output. Church's thesis tells us that regardless of whether we choose the lambda calculus, Turing machines, or almost any modern programming language such as C or Java to describe calculational systems, we are able to describe exactly the same class of functions. However, there is no agreement on observable behaviour for concurrent reactive systems, and consequently there is no correspondent to Church's thesis. A result of this fact is that an overwhelming number of different and often competing notions of observable behaviours, primitive operations, languages and mathematical models for describing their semantics, have been proposed in the litterature on concurrency.

Theoretical Computer Science, 1991

Kearney, P. and J. Staples, An extensional fixed-point semantics for nondeterministic data flow, Theoretical Computer Science 91 (1991) 129-179. A fixed point semantics for nondeterministic data flow is introduced which refines and extends work of Park (1983). It can be seen also as an extension to the general case of Kahn's (1974) successful fixed point semantics for deterministic data flow. An associativity result for network construction is proved which shows that anomalies such as those of Brock and Ackerman do not arise in this semantics. The semantics is shown to be extensional, in the natural sense that nondeterministic processes which induce identical input-output relations in all contexts are equal.

PARLE'93 Parallel …, 1993

Data flow networks are a paradigm for concurrent computations in which a collection of concurrently and asynchronously executing nodes communicate by sending data over FIFO communication channels. The need to deal with data and the asynchronous communication make reasoning about the semantics of nondeterministic networks very difficult .

1996

Abstract. We propose Interaction Categories as a new paradigm for tinsemantics of functional and concurrent computation. Interaction categories have specifications as objects, processes as morphisms, and interaction as composition. We introduce two key examples of interaction categories for concurrent computation and indicate how a general axiomatisation can be developed.

20th Annual IEEE Symposium on Logic in Computer Science (LICS' 05), 2005

A path-based domain theory for higher-order processes is extended to allow name generation. The original domain theory is built around the monoidal-closed category Lin consisting of path orders with join-preserving functions between their domains of path sets. Name generation is adjoined by forming the functor category [I, Lin], where I consists of finite sets of names and injections. The functor category [I, Lin] is no longer monoidal-closed w.r.t. the tensor inherited pointwise from Lin. However, conditions are given under which function spaces exist. The conditions are preserved by a rich discipline of linear types, including those of new-HOPLA, a recent powerful language for higher-order processes with name generation.

1983

Almost ten years ago, Gilles Kahn used the fixed point theory of Dana Scott to define a formal and elegant model of computation for determinate dataflow graphs, networks of determinate processes communicating asynchronously through unbounded channels. Kahn viewed each process as a function mapping each tuple of streams, or sequences of values, received through its input channels to the tuple of streams produced at its output channels. Determinacy was defined as the requirement that the mapping be functional--that for each input stream tuple there be only one possible output stream tuple. Although most useful computation can be accomplished with only determinate processes, there are many important, inherently non-determinate application areas to which Kahn''s theory cannot be applied. In this thesis, a formal model of computation for non-determinate networks is presented in which each possible computation of a network is represented by a scenario. A scenario is a pair consist...

Lecture Notes in Computer Science, 1997

We present a new type system for TyCO, a name-passing calculus of concurrent objects. The system captures dynamic aspects of the behaviour of objects, namely non-uniform service availability. The notion of processes without errors is loosened, demanding only weak fairness in the treatment of messages.

Theoretical Computer Science, 2004

Concurrent computation can be given an abstract mathematical treatment very similar to that provided for sequential computation by domain theory and denotational semantics of Scott and Strachey. A simple domain theory for concurrency is presented. Based on a categorical model of linear logic and associated comonads, it highlights the role of linearity in concurrent computation. Two choices of comonad yield two expressive metalanguages for higher-order processes, both arising from canonical constructions in the model. Their denotational semantics are fully abstract with respect to contextual equivalence. One language, called HOPLA for Higher-Order Process LAnguage, derives from an exponential of linear logic. It can be viewed as an extension of the simply-typed lambda calculus with CCS-like nondeterministic sum and prefix operations, in which types express the form of computation path of which a process is capable. HOPLA can directly encode calculi like CCS, CCS with process passing, and mobile ambients with public names, and it can be given a straightforward operational semantics supporting a standard bisimulation congruence. The denotational and operational semantics are related with simple proofs of soundness and adequacy. Full abstraction implies that contextual equivalence coincides with logical equivalence for a fragment of Hennessy-Milner logic, linking up with simulation equivalence. The other language is called Affine HOPLA and is based on a weakening comonad that yields a model of affine-linear logic. This language adds to HOPLA an interesting tensor operation at the price of linearity constraints on the occurrences of variables. The tensor can be understood as a juxtaposition of independent processes, and allows Affine HOPLA to encode processes of the kind found in treatments of nondeterministic dataflow. The domain theory can be generalised to presheaf models, providing a more refined treatment of nondeterministic branching and supporting notions of bisimulation. The operational semantics for HOPLA is guided by the idea that derivations of transitions in the operational semantics should correspond to elements of the presheaf denotations. Similar guidelines lead to an operational semantics for the first-order fragment of Affine HOPLA. An extension of the operational semantics to the full language is based on a stable denotational semantics which associates to each computation the minimal input necessary for it. Such a semantics is provided, based on event structures; it agrees with the presheaf semantics at first order and exposes the tensor operation as a simple parallel composition of event structures. The categorical model obtained from presheaves is very rich in structure and points towards more expressive languages than HOPLA and Affine HOPLA-in particular concerning extensions to cover independence models. The thesis concludes with a discussion of related work towards a fully fledged domain theory for concurrency. v Thanks to my supervisor, Glynn Winskel, for four years of joint work under his expert leadership-and for introducing me to some of the good things in life besides research, like Jalfrezi and Habit Ale; my committee members Pierre-Louis Curien and Guy McCusker for their thoughtful and detailed comments, corrections and suggestions for improving the thesis; Pino Rosolini and the people at DISI, University of Genoa, for their hospitality during my stay there and for helpful comments on my work-and especially to Matías Menni for his friendship; Marcelo Fiore for his insightful suggestions at my Part A exam; Erik Meineche Schmidt and Mogens Nielsen for their early encouragement; the staff and students at Daimi/BRICS for creating a stimulating working environment; "Laesegruppen" and "Frokostklubben" for forcing me to have a life besides my studies (or, at least for trying); my family for boldly asking questions about my research even though my answers were often incomprehensible. Last, but certainly not least, I wish to thank my wife Mette for her support, her patience, and her unwavering faith in me.

Proceedings of the 4th Workshop on Scala - SCALA '13, 2013

The dataflow programming paradigm addresses how data flows inside programs. Program components, that are often concurrently active, send data to one another; this eases software composition. Mainstream programming languages do not support the paradigm well because of their deterministic and sequential nature. A language that focuses on concurrency is better suited to incorporate concepts from the dataflow paradigm. SubScript is an extension to the Scala programming language with constructs from the Algebra of Communicating Processes, targeted at event-driven and concurrent programming. Like ACP, SubScript focuses on program behavior; support for data was through local variables and parameters. However, the ACP background enabled SubScript to deal with the challenges of the dataflow paradigm. This is achieved through several new features. 1. A process may have a result value, like a method 2. A process result value may be passed on to another process that starts subsequently. This helps getting rid of variables, e.g., in GUI controller specifications. 3. Output actions from a process may be piped to a parallel process, yielding a similar expressiveness as pipes in Unix command shell language. 4. Actors written in Scala often need to keep track of a state, and their program text poorly expresses the conceptual control flow. When such actors are written in SubScript, incoming data may be treated as events that may appear anywhere in the specification, just like in SubScript GUI specifications.