A standard for a graph representation for functional programs

The data structures used in the authors' functional language graph reduction implementations are described, together with a standard notation for representing the graphs in a textual format. The graphs employed are compatible with FLIC and with the functional languages in use at Birmingham and Warwick. The textual format is designed to be transmittable easily across networks

Recursive structure in computer systems

PhD ThesisStructure plays a important part in the design of large systems. Unstructured programs are difficult to design or test and good structure has been recognized as essential to all but the smallest programs. Similarly, concurrently executing computers must co-operate in a structured way if an uncontrolled growth in complexity is to be avoided. The thesis presented here is that recursive structure can be used to organize and simplify large programs and highly parallel computers. In programming, naming concerns the way names are used to identify objects. Various naming schemes are examined including 'block structured' and 'pathname' naming. A new scheme is presented as a synthesis of these two combining most of their advantages. Recursively structured naming is shown to be an advantage when programs are to be de-composed or combined to an arbitrary degree. Also, a contribution to the UNIX United/Newcastle Connection distributed operating system design is described. This shows how recursive naming was used in a practical system. Computation concerns the progress of execution in a computer. A distinction is made between control driven computation where the programmer has explicit control over sequencing and data driven or demand driven computation where sequencing is implicit. It is shown that recursively structured computation has attractive locality properties. The definition of a recursive structure may itself be cyclic (self-referencing). A new resource management ('garbage collection') algorithm is presented which can manage cyclic structures without costs proportional to the system size. The scheme is an extension of 'reference counting'. Finally the need for structure in program and computer design and the advantages of recursive structure are discussed.The Science and Engineering Research Council of Great Britain

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

A common graphical form

We present the Common Graphical Form, a low level, abstract machine independent structure which provides a basis for implementing graph reduction on distributed processors. A key feature of the structure is its ability to model disparate abstract machines in a uniform manner; this enables us to experiment with different abstract machines without having to recode major parts of the run-time system for each additional machine. Because we are dealing with a uniform data structure it is possible to build a suite of performance measurement tools to examine interprocessor data-flow and to apply these tools to different abstract machines in order to make relative comparisons between them at run-time. As a bonus to our design brief we exploit the unifying characteristics of the Common Graphical Form by using it as an intermediate language at compile-time

A hierarchy of languages, logics, and mathematical theories

We present mathematics from a foundational perspective as a hierarchy in which each tier consists of a language, a logic, and a mathematical theory. Each tier in the hierarchy subsumes all preceding tiers in the sense that its language, logic, and mathematical theory generalize all preceding languages, logics, and mathematical theories. Starting from the root tier, the mathematical theories in this hierarchy are: combinatory logic restricted to the identity I, combinatory logic, ZFC set theory, constructive type theory, and category theory. The languages of the first four tiers correspond to the languages of the Chomsky hierarchy: in combinatory logic Ix = x gives rise to a regular language; the language generated by S, K in combinatory logic is context-free; first-order logic is context-sensitive; and the typed lambda calculus of type theory is recursively enumerable. The logic of each tier can be characterized in terms of the cardinality of the set of its truth values: combinatory logic restricted to I has 0 truth values, while combinatory logic has 1, first-order logic 2, constructive type theory 3, and categeory theory omega_0. We conjecture that the cardinality of objects whose existence can be established in each tier is bounded; for example, combinatory logic is bounded in this sense by omega_0 and ZFC set theory by the least inaccessible cardinal. We also show that classical recursion theory presents a framework for generating the above hierarchy in terms of the initial functions zero, projection, and successor followed by composition and m-recursion, starting with the zero function I in combinatory logic This paper begins with a theory of glossogenesis, i.e. a theory of the origin of language, since this theory shows that natural language has deep connections to category theory and since it was through these connections that the last tier and ultimately the whole hierarchy were discovered. The discussion covers implications of the hierarchy for mathematics, physics, cosmology, theology, linguistics, extraterrestrial communication, and artificial intelligence