Abstract Music composition used to be a pen and paper activity. These days music is often composed with the aid of computer software, even to the point where the computer composes parts of the score autonomously. The composition of most styles of music is governed by rules. We show that by approaching the automation, analysis and verification of composition as a knowledge representation task and formalising these rules in a suitable logical language, powerful and expressive intelligent composition tools can be easily built. This application paper describes the use of answer set programming to construct an automated system, named Anton , that can compose melodic, harmonic and rhythmic music, diagnose errors in human compositions and serve as a computer-aided composition tool. The combination of harmonic, rhythmic and melodic composition in a single framework makes Anton unique in the growing area of algorithmic composition. With near real-time composition, Anton reaches the point where it can not only be used as a component in an interactive composition tool but also has the potential for live performances and concerts or automatically generated background music in a variety of applications. With the use of a fully declarative language and an “off-the-shelf” reasoning engine, Anton provides the human composer a tool which is significantly simpler, more compact and more versatile than other existing systems.

A solution for a version of the identify problem is proposed for a class of functions including the elementary functions. Given f(x), g(x), defined at some point b we decide whether or not f(x) = g(x) in some neighbourhood of b. This problem is first reduced to a problem about zero equivalence of elementary constants. Then a semi algorithm is given to solve the elementary constant problem. This semi algorithm is guaranteed to give the correct answer whenever it terminates, and it terminates unless the problem being considered contains a counterexample to Schanuel's conjecture.

We describe the approach to the concurrent execution of object-oriented programs that is being research at the University of Bath. The aim of this project is the concurrent execution of both new Lisp programs and existing Lisp applications. We are pursuing this goal by addressing the problems of concurrent execution at several levels: static analysis of Lisp programs as a basis for semi-automatic transformation, modification of medium-sized Lisp programs to use concurrent primitives to gain experience in their use and behaviour and the implementation of various concurrency primitives in a compiled distributed heterogeneous Lisp environment. Each of these topics is described in turn and its relationship to the long term aim defined above is examined.

A non-LISP delivery system for REDUCE is described and compared with other implementations of REDUCE for speed and size, as well as ease of porting. The mechanism for this delivery system is direct compilation of the REDUCE sources into ANSI C, which is then compiled and linked together with some support code for arithmetic and space administration. The resulting system is compared with a number of other implementations of true REDUCE, and is shown to be similar in size, but faster. The time to port the system is measured in hours. Also considered are the difficulties in this method of delivering LISP code, and an assessment of the loss of flexibility.

In order to make a substantial improvement in the performance of algebra systems it will eventually be necessary to use a parallel execution system. This paper considers one approach to detecting parallelism, an automatic method related to compilation, and applies it to REDUCE, and to the factoriser in particular. The conclusions are preliminary, and this is only a small step on a long road.

This paper considers current solutions to the problem of representing multiple environments, and uses the results to develop a new model. The motivation is partly a consequence of the renewed interest in the more sophisticated forms of access and control [Sussman & Steele 1978], [Smith 1983]. [Friedman et al. 1984], and partly because the problem identified by Moses [1970] has not, as yet, been satisfactorily resolved. The new model is derived from a consideration of the semantics of identifier binding interrogation. The implementation itself rests on the existence of an environment labeling function which solves a variant of a well known graph theory problem called nearest common ancestor. We describe a suitable implementation of such a function. The new scheme has been implemented in two different LISP systems (Cambridge LISP and Portable Standard LISP), and a third (LISP/VM) is under consideration. In addition, pure deep binding and full shallow binding have both been implemented on top the same base system (Cambridge LISP). Thus it is possible to collect comparisons of the relative efficiencies running simple (stack behavior) programs and complex (multiple context) programs. Some timing results for various tests are given in the final section.

A variation of the Haddon and Waite compacting garbage collector is presented that needs only bounded workspace, but which has typical runtime proportional to the size of the heap rather than n log n for a heap of size n. The algorithm has been measured in the context of a LISP system where it has been seen to behave close to its optimum. The relationship of this algorithm to one due to Lang and Weigbreit is also explained.

Abstract A profiling technique is used on a large algebra system, CAMAL, in order to determine where time is being used. The system is written in a machine‐independent language, and a machine‐independent measuring device is used. The end result is an improvement on various algorithms, which together save up to 70 per cent of the processor time when running user programs.

Abstract The problems of producing an efficient but robust implementation of a high‐level language by building on existing compilers are discussed with reference to a LISP system consisting of an interpreter, a compiler and a large collection of support routines. In retrospect it can be seen that almost all of the major difficulties encountered were facets of a general problem concerned with the global control of the use of store. The garbage collector, originally intended solely to manage the LISP heap, extends its scope to simplify the solution of many of these problems.

After a brief review of the current state of simplification this paper proposes a classification of simplification rules that may help in the practical implementation of simplification procedures. The last part of the paper is concerned in the mathematical theory of simplification, and the set of expressions formed from rational powers of polynomials is shown to have a canonical form.

This paper describes the applications area of computer programs that carry out formal algebraic manipulation. The first part of the paper is tutorial and severed typical problems are introduced which can be solved using algebraic manipulative systems. Sample programs for the solution of these problems using several algebra systems are then presented. Next, two more difficult examples are used to introduce the reader to the true capabilities of an algebra program and these are proposed as a means of comparison between rival algebra systems. A brief review of the technical problems of algebraic manipulation is given in the final section.

This paper describes a computing system that enables problems of manipulative algebra involving a number of elementary functions to be simply and efficiently programmed. The system has been designed with particular reference to the problems involved in the explicit calculation of the Riemann tensor and associated quantities.