Mutual Recursion Research Articles

"Bagatelle in C arranged for VDM SoLo"

This paper sketches a engineering discipline which combines formal and semi-formal methods. Central to the former is denotational semantics, expressed in the ISO/IEC 13817-1 standard specification language (VDM-SL). This is strengthened with algebra of pro- gramming, which is applied in reverse order so as to reconstruct formal specifications from legacy code. The latter include code slicing, a shortcut which trims down the complexity of handling the formal semantics of all program variables at the same time. A key point of the approach is its constructive style. Reverse calculations go as far as absorbing auxiliary variables, introducing mutual recursion (if applicable) and reversing semantic denota- tions into standard generic programming schemata such as cata/paramorphisms. The approach is illustrated for a small piece of code already studied in the code-slicing literature: Kernighan and Richtie's word countC programming bagatelle.

Using binary decision diagrams for representation and analysis of communication protocols

A symbolic representation of a state/transition system based on binary decision diagrams (BDDs) is generally more compact than an explicit representation like a state/transition table. This is due to regular and repetitive patterns occurring in state/transition systems. By exploiting this property, huge state spaces can be represented, and the resulting BDDs can be profitably used for activities such as symbolic model checking and sequential circuit synthesis. This paper shows how such techniques can be applied to communication protocols by presenting a systematic method to build BDD representations from protocol specifications expressed in the ISO standard protocol specification language LOTOS. The method exploits the compositionality of the process algebra of LOTOS to avoid the enumeration of all the states and transitions, takes also data into account, enables building the BDDs in the more convenient disjunctive partitioned form, and can handle any LOTOS specification characterized by a finite LTS. The method consists in partitioning the set of process definitions according to their mutual recursion relationships, building an LTS for each set of mutually recursive process definitions, encoding these LTSs as BDDs which in turn are combined together, according to the process algebraic operators, to obtain the overall BDD representation. An example is used throughout the paper to illustrate the method.

Experimenting with tail-recursion and simulating coroutines

The efficiency of tail recursion and the simplicity of its removal makes some people wonder why we cannot transform all recursive definitions to this form? Clearly, the usual trick of introducing a new variable and using it as an accumulator to hold the intermediate results during the winding phase does not always work. But, by trying to generalize this technique to primitive recursion one can easily find a sufficient condition which makes it work. The class of functions satisfying this condition may be interesting also on its own. A direct generalization of this function class for mutual recursion is fairly straightforward.

Transformational methodology for proving termination of logic programs

A methodology for proving the termination of well-moded logic programs is developed by reducing the termination problem of logic programs to that of term rewriting systems. A transformation procedure is presented to derive a term rewriting system from a given well-moded logic program such that the termination of the derived rewrite system implies the termination of the logic program for all well-moded queries under a class of selection rules. This facilitates applicability of a vast source of termination orderings proposed in the literature on term rewriting, for proving termination of logic programs. The termination of various benchmark programs has been established with this approach. Unlike other mechanizable approaches, the proposed approach does not require any preprocessing and works well, even in the presence of mutual recursion. The transformation has also been implemented as a front end to Rewrite Rule Laboratory (RRL) and has been used in establishing termination of nontrivial Prolog programs such as a prototype compiler for ProCoS, PL 0 language.

Termination of Nested and Mutually Recursive Algorithms

This paper deals with automated termination analysis for functional programs. Previously developed methods for automated termination proofs of functional programs often fail for algorithms with nested recursion and they cannot handle algorithms with mutual recursion. We show that termination proofs for nested and mutually recursive algorithms can be performed without having to prove the correctness of the algorithms simultaneously. Using this result, nested and mutually recursive algorithms do no longer constitute a special problem and the existing methods for automated termination analysis can be extended to nested and mutual recursion in a straightforward way. We give some examples of algorithms whose termination can now be proved automatically (including well-known challenge problems such as McCarthy’s f_91 function).

Termination of logic programs: the never-ending story

We survey termination analysis techniques for Logic Programs. We give an extensive introduction to the topic. We recall several motivations for the work, and point out the intuitions behind a number of LP-specific issues that turn up, such as: the study of different classes of programs and LP languages, of different classes of queries and of different selection rules, the difference between existential and universal termination, and the treatment of backward unification and local variables. Then, we turn to more technical aspects: the structure of the termination proofs, the selection of well-founded orderings, norms and level mappings, the inference of interargument relations, and special treatments proposed for dealing with mutual recursion. For each of these, we briefly sketch the main approaches presented in the literature, using a fixed example as a file rouge. We conclude with some comments on loop detection and cycle unification and state some open problems.

Characteristic Formulas for Processes with Divergence

Characteristic formulae have been introduced by Graf and Sifakis to relate equational reasoning about proceses to reasoning in a modal logic, and therefore to allow proofs about processes to be carried out in a logical framework. This work, which concerned finite processes and bisimulation-like equivalences, has later on been extended to finite state processes and further equivalences. Based upon an intuitionistic understanding of Hennessy-Milner Logic (HML) with mutual recursion, we extend these results to cover bisimulation-like preorders, which are sensitive to liveness properties. This demonstrates the expressive power of intuitionistically interpreted HML with mutual recursion, and it builds the theoretical basis for a uniform and efficient method to automatically verify bisimulation-like relations between processes by means of model checking.

Recursion induction for real-time processes

Abstract The theory of timed Communicating Sequential Processes is a mathematical approach to the design and analysis of timed distributed systems. This paper extends the language of timed CSP to include a general treatment of recursion. A semantics for mutual recursion is introduced, together with a sufficient condition for the necessary fixpoint to be unique. The resulting language has the familiar unwinding property of process algebra, and exhibits a number of useful algebraic identities. A theory of recursion induction is formulated, and a simple example is presented to illustrate its use.

Compilation and evaluation of linear mutual recursions

A linear mutual recursion is a recursion that consists of a set of rules, each of which has at most one predicate in its body that is mutually recursive with its head predicate. This paper studies techniques for compilation and efficient evaluation of linear mutual recursions. It demonstrates that a large class of linear mutual recursions can be compiled to one or a set of linear recursions or pseudo-linear recursions and be evaluated efficiently using the well-studied linear recursive query processing techniques and/or their variations. The benefits and limitations of such a compilation and evaluation technique are also discussed in the paper.

On the conversion of indirect to direct recursion

Procedure inlining can be used to convert mutual recursion to direct recursion. This allows use of optimization techniques that are most easily applied to directly recursive procedures, in addition to the well-known benefits of inlining. We present tight (necessaryandsufficient) conditions under which inlining can transform all mutual recursion to direct recursion, and those under which heuristics to eliminate mutual recursion always terminate. We also present a technique to eliminate mutually recursive circuits that consist of only tail calls. From this, we conclude that tail recursion elimination should be interleaved with inlining.

Pascal: an interactive text, by S.J. Abas and J. Rangel Mondragon. Pp 249 + disc. £17.50 + £32.50. 1990. ISBN 0-7503-0020-5,0021-3 (Adam Hilger)

Part 1 Pascal and programming - an overview: about pascal about problem solving and programming. Part 2 Writing simple programs: the structure of a pascal program some basic concepts producing output from the computer supplying input to the computer doing repetitions making choices designing a user-friendly interface. Part 3 A first look at functions and procedures: the importance of modularization structure of a Pascal module functions procedures scope of variables top-down programming. Part 4 More on syntax, decision making and loops: Pascal's grammar pascal's types type definition case statement goto statement conditional loops. Part 5 Manipulating structured data sets and arrays: sets one-dimensional arrays searching and sorting passing array parameters to procedures and functions strings multi-dimensional arrays conformant array parameters. Part 6 Files: files in general files in pascal. Part 7 Records and variants: records arrays of records variants. Part 8 A second look at procedures and functions: subprograms as parameters recursion mutual recursion and the directive forward. Part 9 Manipulating dynamic data: pointers linked linear structures binary trees. Appendices: reserved symbols and words predefined identifiers ASCII table.

Towards a facility for lexically scoped, dynamic mutual recursion in Scheme

We propose a facility which allows unbounded associative structures, which we call Dynamic Mutually Recursive Structures (DMRS), in Scheme [1]. An important application is the creation of unbounded vectors and arrays. Another application is as the underpinnings of a global, dynamic letrec capability. A third application is the construction of memo-functions. Under this facility, DMRS elements are allocated space individually and not until they are side-effected. Thus, a DMRS can be sparse and waste little memory. In addition, the proposed facility removes some of the burdens of writing procedural specifications that are not relevant to functional specifications such as vector boundedness.

The Alonzo functional programming language

Alonzo is a programming language for specifying an output stream of characters as a function of a given input stream of characters. It is a non-strict language based on the untyped λ-calculus, and it has been enriched by adding syntax for local bindings and mutual recursion. Primitive data and their operators have been included along with strict vectors.

Predicate-transformer semantics of general recursion

We develop the semantics of a language with arbitrary atomic statements, unbounded nondeterminacy, and mutual recursion. The semantics is expressed in weakest preconditions and weakest liberal preconditions. Individual states are not mentioned. The predicates on the state space are treated as elements of a distributive lattice. The semantics of recursion is constructed by means of the theorem of Knaster-Tarski. It is proved that the law of the excluded miracle can be preserved, if that is wanted. The universal conjunctivity of the weakest liberal precondition, and the connection between the weakest precondition and the weakest liberal precondition are proved to remain valid. Finally we treat Hoare-triple methods for proving correctness and conditional correctness of programs.

Interpretations of recursion under unbounded nondeterminacy

A language is constructed that supports arbitrary atomic statements, composition, alternatives, and mutual recursion in the presence of unbounded nondeterminacy. The concept of interpretation is defined axiomatically. By operational means a standard interpretation is constructed, which is proved to be the smallest interpretation with respect to the Egli-Milner ordering. The corresponding weakest precondition and weakest liberal precondition are characterized as smallest and largest preparator functions. We characterize the interpretations which upon divergence cannot deliver unjustified meaningful values. These interpretations form a spectrum that ranges from standard semantics, over various forms of fair semantics, to the so-called friendly semantics where error is signalled only if divergence can become inevitable after finitely many steps. We determine the corresponding preparator functions.

The trouble with mutual recursion in Concurrent Euclid

The author relates how he squandered a day's work trying to bend a compiler to his needs, and how the resulting solution became equally bent. A working knowledge of Concurrent Euclid is not necessary to understand this paper.

A calculus of total correctness for communicating processes

A process communicates with its environment and with other processes by syncronized output and input on named channels. The current state of a process is defined by the sequences of messages which have passed along each of the channels, and by the sets of messages that may next be passed on each channel. A process satisfies an assertion if the assertion is at all times true of all possible states of the process. We present a calculus for proving that a process satisfies the assertion describing its intended behaviour. The following constructs are axiomatised: output; input; simple recursion; disjoint parallelism; channel renaming, connection and hiding; process chaining; nondeterminism; conditional; alternation; and mutual recursion. The calculus is illustrated by proof of a number of simple buffering protocols.

Reference counting can manage the circular invironments of mutual recursion

Reference counting can manage the circular invironments of mutual recursion

An alternative approach to mutual recursion in Algol 60 using restricted compilers

No abstract available.

Mutual recursion in Algol 60 using restricted compilers

The Elliott (I.C.L.) Algol 60 compiler contains a restriction on the sequence of declarations such that no identifier may be used before it is declared. This means that direct mutual recursion between procedures declared in the same blockhead is not possible.