Towards sharing in lazy computation systems

Work on proving congruence of bisimulation in functional programming languages often refers to [How89,How96], where Howe gave a highly general account on this topic in terms of so-called lazy computation systems . Particularly in implementations of lazy functional languages, sharing plays an eminent role. In this paper we will show how the original work of Howe can be extended to cope with sharing. Moreover, we will demonstrate the application of our approach to the call-by-need lambda-calculus lambda-ND which provides an erratic non-deterministic operator pick and a non-recursive let. A definition of a bisimulation is given, which has to be based on a further calculus named lambda-~, since the na1ve bisimulation definition is useless. The main result is that this bisimulation is a congruence and contained in the contextual equivalence. This might be a step towards defining useful bisimulation relations and proving them to be congruences in calculi that extend the lambda-ND-calculus

Simulation in the call-by-need lambda-calculus with letrec

This paper shows the equivalence of applicative similarity and contextual approximation, and hence also of bisimilarity and contextual equivalence, in the deterministic call-by-need lambda calculus with letrec. Bisimilarity simplifies equivalence proofs in the calculus and opens a way for more convenient correctness proofs for program transformations. Although this property may be a natural one to expect, to the best of our knowledge, this paper is the first one providing a proof. The proof technique is to transfer the contextual approximation into Abramsky's lazy lambda calculus by a fully abstract and surjective translation. This also shows that the natural embedding of Abramsky's lazy lambda calculus into the call-by-need lambda calculus with letrec is an isomorphism between the respective term-models.We show that the equivalence property proven in this paper transfers to a call-by-need letrec calculus developed by Ariola and Felleisen

The Brauer group of modified supergroup algebras

The computation of the Brauer group BM of modified supergroup algebras is perfomed, yielding, in particular, the computation of the Brauer group of all finite-dimensional triangular Hopf algebras when the base field is algebraically closed and of characteristic zero. The results are compared with the computation of lazy cohomology and with Yinhuo Zhang's exact sequence. As an example, we compute explicitely the Brauer group and lazy cohomology for modified supergroup algebras with (extensions of) Weyl groups of irreducible root systems as a group datum and their standard representation as a representation datum.Comment: 47 pages, submitte

Twisting algebras using non-commutative torsors

Non-commutative torsors (equivalently, two-cocycles) for a Hopf algebra can be used to twist comodule algebras. After surveying and extending the literature on the subject, we prove a theorem that affords a presentation by generators and relations for the algebras obtained by such twisting. We give a number of examples, including new constructions of the quantum affine spaces and the quantum tori.Comment: 27 pages. Masuoka is a new coauthor. Introduction was revised. Sections 1 and 2 were thoroughly restructured. The presentation theorem in Section 3 is now put in a more general framework and has a more general formulation. Section 4 was shortened. All examples (quantum affine spaces and tori, twisting of SL(2), twisting of the enveloping algebra of sl(2)) are left unchange

Cocycle twisting of E(n)-module algebras and applications to the Brauer group

We classify the orbits of coquasi-triangular structures for the Hopf algebra E(n) under the action of lazy cocycles and the Hopf automorphism group. This is applied to detect subgroups of the Brauer group $BQ(k,E(n))$ of E(n) that are isomorphic. For a triangular structure $R$ on E(n) we prove that the subgroup $BM(k,E(n),R)$ of $BQ(k,E(n))$ arising from $R$ is isomorphic to a direct product of $BW(k)$, the Brauer-Wall group of the ground field $k$, and $Sym_n(k)$, the group of $n \times n$ symmetric matrices under addition. For a general quasi-triangular structure $R'$ on E(n) we construct a split short exact sequence having $BM(k,E(n), R')$ as a middle term and as a left term a central extension of the group of symmetric matrices of order $r<n$ ($r$ depending on $R'$). We finally describe how the image of the Hopf automorphism group inside $BQ(k,E(n))$ acts on $Sym_n(k)$.Comment: Accidentally an old version of the paper was posted. Main corrections are in Section 2 and in Section 4.

How to prove similarity a precongruence in non-deterministic call-by-need lambda calculi

Extending the method of Howe, we establish a large class of untyped higher-order calculi, in particular such with call-by-need evaluation, where similarity, also called applicative simulation, can be used as a proof tool for showing contextual preorder. The paper also demonstrates that Mann’s approach using an intermediate “approximation” calculus scales up well from a basic call-by-need non-deterministic lambdacalculus to more expressive lambda calculi. I.e., it is demonstrated, that after transferring the contextual preorder of a non-deterministic call-byneed lambda calculus to its corresponding approximation calculus, it is possible to apply Howe’s method to show that similarity is a precongruence. The transfer is not treated in this paper. The paper also proposes an optimization of the similarity-test by cutting off redundant computations. Our results also applies to deterministic or non-deterministic call-by-value lambda-calculi, and improves upon previous work insofar as it is proved that only closed values are required as arguments for similaritytesting instead of all closed expressions

On conservativity of concurrent Haskell

The calculus CHF models Concurrent Haskell extended by concurrent, implicit futures. It is a process calculus with concurrent threads, monadic concurrent evaluation, and includes a pure functional lambda-calculus which comprises data constructors, case-expressions, letrec-expressions, and Haskell’s seq. Futures can be implemented in Concurrent Haskell using the primitive unsafeInterleaveIO, which is available in most implementations of Haskell. Our main result is conservativity of CHF, that is, all equivalences of pure functional expressions are also valid in CHF. This implies that compiler optimizations and transformations from pure Haskell remain valid in Concurrent Haskell even if it is extended by futures. We also show that this is no longer valid if Concurrent Haskell is extended by the arbitrary use of unsafeInterleaveIO