An introduction to (Co)algebras and (Co)induction and their application to the semantics of programming languages

This report summarizes operational approaches to the formal semantics of programming languages and shows that they can be interpreted inductively by least fixed points as well as coinductively by greatest fixed points. While the inductive interpretation gives semantics to all terminating programs, the coinductive one defines moreover also a semantics for all non-terminating programs. This is especially important in areas where programs do not terminate in general, e.g. data bases, operating systems, or control software in embedded systems. The semantic foundations described in this report can be used to verify that transformations (e.g. in compilers) of such software systems are correct. In the course of this report, coalgebras and coinduction are introduced, starting with a gentle intuitive motivation and ending with a detailed mathematical description within the notions of category theory

Datatype Laws Without Signatures

Using the well-known categorical notion of `functor' one may define the concept of datatype (algebra) without being forced to introduce a signature, that is, names and typings for the individual sorts (types) and operations involved. This has proved to be advantageous for those theory developments where one is not interested in the syntactic appearance of an algebra. The categorical notion of `transformer' developed in this paper allows the same approach to laws: without using signatures one can define the concept of law for datatypes (lawful algebras), and investigate the equational specification of datatypes in a syntax-free way. A transformer is a special kind of functor and also a natural transformation on the level of dialgebras. Transformers are quite expressive, satisfy several closure properties, and are related to naturality and Wadler's Theorems For Free. In fact, any colimit is an initial lawful algebra

Farms, pipes, streams and reforestation : reasoning about structured parallel processes using types and hylomorphisms

The increasing importance of parallelism has motivated the creation of better abstractions for writing parallel software, including structured parallelism using nested algorithmic skeletons. Such approaches provide high-level abstractions that avoid common problems, such as race conditions, and often allow strong cost models to be defined. However, choosing a combination of algorithmic skeletons that yields good parallel speedups for a program on some specific parallel architecture remains a difficult task. In order to achieve this, it is necessary to simultaneously reason both about the costs of different parallel structures and about the semantic equivalences between them. This paper presents a new type-based mechanism that enables strong static reasoning about these properties. We exploit well-known properties of a very general recursion pattern, hylomorphisms, and give a denotational semantics for structured parallel processes in terms of these hylomorphisms. Using our approach, it is possible to determine formally whether it is possible to introduce a desired parallel structure into a program without altering its functional behaviour, and also to choose a version of that parallel structure that minimises some given cost model.Postprin

Parallel programming using functional languages

It has been argued for many years that functional programs are well suited to parallel evaluation. This thesis investigates this claim from a programming perspective; that is, it investigates parallel programming using functional languages. The approach taken has been to determine the minimum programming which is necessary in order to write efficient parallel programs. This has been attempted without the aid of clever compile-time analyses. It is argued that parallel evaluation should be explicitly expressed, by the programmer, in programs. To do achieve this a lazy functional language is extended with parallel and sequential combinators. The mathematical nature of functional languages means that programs can be formally derived by program transformation. To date, most work on program derivation has concerned sequential programs. In this thesis Squigol has been used to derive three parallel algorithms. Squigol is a functional calculus from program derivation, which is becoming increasingly popular. It is shown that some aspects of Squigol are suitable for parallel program derivation, while others aspects are specifically orientated towards sequential algorithm derivation. In order to write efficient parallel programs, parallelism must be controlled. Parallelism must be controlled in order to limit storage usage, the number of tasks and the minimum size of tasks. In particular over-eager evaluation or generating excessive numbers of tasks can consume too much storage. Also, tasks can be too small to be worth evaluating in parallel. Several program techniques for parallelism control were tried. These were compared with a run-time system heuristic for parallelism control. It was discovered that the best control was effected by a combination of run-time system and programmer control of parallelism. One of the problems with parallel programming using functional languages is that non-deterministic algorithms cannot be expressed. A bag (multiset) data type is proposed to allow a limited form of non-determinism to be expressed. Bags can be given a non-deterministic parallel implementation. However, providing the operations used to combine bag elements are associative and commutative, the result of bag operations will be deterministic. The onus is on the programmer to prove this, but usually this is not difficult. Also bags' insensitivity to ordering means that more transformations are directly applicable than if, say, lists were used instead. It is necessary to be able to reason about and measure the performance of parallel programs. For example, sometimes algorithms which seem intuitively to be good parallel ones, are not. For some higher order functions it is posible to devise parameterised formulae describing their performance. This is done for divide and conquer functions, which enables constraints to be formulated which guarantee that they have a good performance. Pipelined parallelism is difficult to analyse. Therefore a formal semantics for calculating the performance of pipelined programs is devised. This is used to analyse the performance of a pipelined Quicksort. By treating the performance semantics as a set of transformation rules, the simulation of parallel programs may be achieved by transforming programs. Some parallel programs perform poorly due to programming errors. A pragmatic method of debugging such programming errors is illustrated by some examples

Independence in Algebraic Complexity Theory

This thesis examines the concepts of linear and algebraic independence in algebraic complexity theory. Arithmetic circuits, computing multivariate polynomials over a field, form the framework of our complexity considerations. We are concerned with polynomial identity testing (PIT), the problem of deciding whether a given arithmetic circuit computes the zero polynomial. There are efficient randomized algorithms known for this problem, but as yet deterministic polynomial-time algorithms could be found only for restricted circuit classes. We are especially interested in blackbox algorithms, which do not inspect the given circuit, but solely evaluate it at some points. Known approaches to the PIT problem are based on the notions of linear independence and rank of vector subspaces of the polynomial ring. We generalize those methods to algebraic independence and transcendence degree of subalgebras of the polynomial ring. Thereby, we obtain efficient blackbox PIT algorithms for new circuit classes. The Jacobian criterion constitutes an efficient characterization for algebraic independence of polynomials. However, this criterion is valid only in characteristic zero. We deduce a novel Jacobian-like criterion for algebraic independence of polynomials over finite fields. We apply it to obtain another blackbox PIT algorithm and to improve the complexity of testing the algebraic independence of arithmetic circuits over finite fields.Die vorliegende Arbeit untersucht die Konzepte der linearen und algebraischen Unabhängigkeit innerhalb der algebraischen Komplexitätstheorie. Arithmetische Schaltkreise, die multivariate Polynome über einem Körper berechnen, bilden die Grundlage unserer Komplexitätsbetrachtungen. Wir befassen uns mit dem polynomial identity testing (PIT) Problem, bei dem entschieden werden soll ob ein gegebener Schaltkreis das Nullpolynom berechnet. Für dieses Problem sind effiziente randomisierte Algorithmen bekannt, aber deterministische Polynomialzeitalgorithmen konnten bisher nur für eingeschränkte Klassen von Schaltkreisen angegeben werden. Besonders von Interesse sind Blackbox-Algorithmen, welche den gegebenen Schaltkreis nicht inspizieren, sondern lediglich an Punkten auswerten. Bekannte Ansätze für das PIT Problem basieren auf den Begriffen der linearen Unabhängigkeit und des Rangs von Untervektorräumen des Polynomrings. Wir übertragen diese Methoden auf algebraische Unabhängigkeit und den Transzendenzgrad von Unteralgebren des Polynomrings. Dadurch erhalten wir effiziente Blackbox-PIT-Algorithmen für neue Klassen von Schaltkreisen. Eine effiziente Charakterisierung der algebraischen Unabhängigkeit von Polynomen ist durch das Jacobi-Kriterium gegeben. Dieses Kriterium ist jedoch nur in Charakteristik Null gültig. Wir leiten ein neues Jacobi-artiges Kriterium für die algebraische Unabhängigkeit von Polynomen über endlichen Körpern her. Dieses liefert einen weiteren Blackbox-PIT-Algorithmus und verbessert die Komplexität des Problems arithmetische Schaltkreise über endlichen Körpern auf algebraische Unabhängigkeit zu testen