63 research outputs found
Breaking a monad-comonad symmetry between computational effects
Computational effects may often be interpreted in the Kleisli category of a
monad or in the coKleisli category of a comonad. The duality between monads and
comonads corresponds, in general, to a symmetry between construction and
observation, for instance between raising an exception and looking up a state.
Thanks to the properties of adjunction one may go one step further: the
coKleisli-on-Kleisli category of a monad provides a kind of observation with
respect to a given construction, while dually the Kleisli-on-coKleisli category
of a comonad provides a kind of construction with respect to a given
observation. In the previous examples this gives rise to catching an exception
and updating a state. However, the interpretation of computational effects is
usually based on a category which is not self-dual, like the category of sets.
This leads to a breaking of the monad-comonad duality. For instance, in a
distributive category the state effect has much better properties than the
exception effect. This remark provides a novel point of view on the usual
mechanism for handling exceptions. The aim of this paper is to build an
equational semantics for handling exceptions based on the coKleisli-on-Kleisli
category of the monad of exceptions. We focus on n-ary functions and
conditionals. We propose a programmer's language for exceptions and we prove
that it has the required behaviour with respect to n-ary functions and
conditionals.Comment: arXiv admin note: substantial text overlap with arXiv:1310.060
Shades of Iteration: from Elgot to Kleene
Notions of iteration range from the arguably most general Elgot iteration to
a very specific Kleene iteration. The fundamental nature of Elgot iteration has
been extensively explored by Bloom and Esik in the form of iteration theories,
while Kleene iteration became extremely popular as an integral part of
(untyped) formalisms, such as automata theory, regular expressions and Kleene
algebra. Here, we establish a formal connection between Elgot iteration and
Kleene iteration in the form of Elgot monads and Kleene monads, respectively.
We also introduce a novel class of while-monads, which like Kleene monads admit
a relatively simple description in algebraic terms. Like Elgot monads,
while-monads cover a large variety of models that meaningfully support
while-loops, but may fail the Kleene algebra laws, or even fail to support a
Kleen iteration operator altogether.Comment: Extended version of the accepted one for "Recent Trends in Algebraic
Development Techniques - 26th IFIP WG 1.3 International Workshop, WADT 2022
Exploring the Boundaries of Monad Tensorability on Set
We study a composition operation on monads, equivalently presented as large
equational theories. Specifically, we discuss the existence of tensors, which
are combinations of theories that impose mutual commutation of the operations
from the component theories. As such, they extend the sum of two theories,
which is just their unrestrained combination. Tensors of theories arise in
several contexts; in particular, in the semantics of programming languages, the
monad transformer for global state is given by a tensor. We present two main
results: we show that the tensor of two monads need not in general exist by
presenting two counterexamples, one of them involving finite powerset (i.e. the
theory of join semilattices); this solves a somewhat long-standing open
problem, and contrasts with recent results that had ruled out previously
expected counterexamples. On the other hand, we show that tensors with bounded
powerset monads do exist from countable powerset upwards
QoS-aware component composition
Component’s QoS constraints cannot be ignored when composing them to build reliable loosely-coupled, distributed systems. Therefore they should be explicitly taken into account in any formal model for component-based development. Such is the purpose of this paper: to extend a calculus of component composition to deal, in an effective way, with QoS constraints. Particular emphasis is put on how the laws that govern composition can be derived, in a calculational, pointfree style, in this new model
Composition Semantics of the Rosetta Specification Language
The Rosetta specification language aims to enable system designers to abstractly design complex heterogeneous systems. To this end, Rosetta allows for compositional design to facilitate modularity, separation of concerns, and specification reuse. The behavior of Rosetta components and facets can be viewed as systems, which are well suited for coalgebraic denotation. The previous semantics of Rosetta lacked detail in the denotational work, and had no firm semantic basis for the composition operators. This thesis refreshes previous work on the coalgebraic denotation of Rosetta. It then goes on to define the denotation of the composition operators. A real-world Rosetta example using all types of composition serves as a demonstration of the power of composition as well as the clean, modular abstractness it affords the designer
On refinement of software architectures
Although increasingly popular, software component techniques still lack suitable formal foundations on top of which rigorous methodologies for the description and analysis of software architectures could be built. This paper aims to contribute in this direction: building on previous work by the authors on coalgebraic semantics, it discusses component refinement at three different but interrelated levels: behavioural, syntactic, i.e., relative to component interfaces, and architectural. Software architectures are defined through component aggregation. On the other hand, such aggregations, no matter how large and complex they are, can also be dealt with as components themselves, which paves the way to a discipline of hierarchical design. In this context, a major contribution of this paper is the introduction of a set of rules for architectural refinement. Keywords: Software component, software architecture, refinement, coalgebra.Fundação para a Ciência e a Tecnologia (FCT
Programming with monadic CSP-style processes in dependent type theory
We introduce a library called CSP-Agda for representing processes in the dependently typed theorem prover and interactive programming language Agda. We will enhance processes by a monad structure. The monad structure facilitates combining processes in a modular way, and allows to define recursion as a direct operation on processes. Processes are defined coinductively as non-well-founded trees. The nodes of the tree are formed by a an atomic one step relation, which determines for a process the external, internal choices, and termination events it can choose, and whether the process has terminated. The data type of processes is inspired by Setzer and Hancock's notion of interactive programs in dependent type theory. The operators of CSP will be defined rather than atomic operations, and compute new elements of the data type of processes from existing ones. The approach will make use of advanced type theoretic features: the use of inductive-recursively defined universes; the definition of coinductive types by their observations, which has similarities to the notion of an object in object-oriented programming; the use of sized types for coinductive types, which allow coinductive definitions in a modular way; the handling of finitary information (names of processes) in a coinductive settings; the use of named types for automatic inference of arguments similar to its use in template Meta-programming in C++; and the use of interactive programs in dependent type theory.We introduce a simulator as an interactive program in Agda. The simulator allows to observe the evolving of processes following external or internal choices. Our aim is to use this in order to simulate railway interlocking system and write programs in Agda which directly use CSP processes
- …