Recursive Calls Research Articles

Agenda control for heterogeneous reasoners

As artificial intelligence techniques are maturing and being deployed in large applications, the problem of specifying control and reasoning strategies is regaining attention. Complex AI systems tend to comprise a suite of modules, each of which is capable of solving a different aspect of the overall problem, and each of which may incorporate a different reasoning paradigm. The orchestration of such heterogeneous problem solvers can be divided into two subproblems: (1) When and how are various reasoning modes invoked? and (2) How is information passed between various reasoning modes? In this paper, we explore some solutions to this problem. In particular, we describe a logic programming system that is based on three ideas: equivalence of declarative and operational semantics, declarative specification of control information, and smoothness of interaction with non-logic-based programs. Meta-level predicates are used to specify control information declaratively, compensating for the absence of procedural constructs that usually facilitate formulation of efficient programs. Knowledge that has been derived in the course of the current inference process can at any time be passed to non-logic-based program modules. Traditional SLD inference engines maintain only the linear path to the current state in the SLD search tree: formulae that have been proved on this path are implicitly represented in a stack of recursive calls to the inference engine, and formulae that have been proved on previous, unsuccessful paths are lost altogether. In our system, previously proved formulae are maintained explicitly and therefore can be passed to other reasoning modules. As an application example, we show how this inference system acts as the knowledge representation and reasoning framework of Pret––a program that automates system identification.

An efficient scheme for accepting recursive method calls in object‐oriented concurrent programming

AbstractWith object‐oriented concurrent programming languages that perform mutual exclusion at the level of objects, deadlock can easily occur due to recursive method calls. We propose a transparent mechanism to programmers called the Key/Lock method, which enables recursive method calls by eliminating recursion deadlock. The Key/Lock method assigns keys, which are uniquely associated with exclusive methods, to messages and especially accepts messages to which these keys are appended. This technique, which can reduce the overhead that accompanies message transmission and reception compared with conventional research techniques, is particularly effective when there are numerous thread branches. We incorporated the Key/Lock method in the concurrent programming language SR and performed performance evaluations to verify the effectiveness of this technique. © 2003 Wiley Periodicals, Inc. Syst Comp Jpn, 34(14): 101–109, 2003; Published online in Wiley InterScience (www.interscience.wiley.com). DOI 10.1002/scj.1226

Generalized Coiteration Schemata

Coiterative functions can be explained categorically as final coalgebraic morphisms, once coinductive types are viewed as final coalgebras. However, the coiteration schema which arises in this way is too rigid to accommodate directly many interesting classes of circular specifications. In this paper, building on the notion of T-coiteration introduced by the third author and capitalizing on recent work on bialgebras by Turi-Plotkin and Bartels, we introduce and illustrate various generalized coiteration patterns. First we show that, by choosing the appropriate monad T, T-coiteration captures naturally a wide range of coiteration schemata, such as the duals of primitive recursion and course-of-value iteration, and mutual coiteration. Then we show that, in the more structured categorical setting of bialgebras, T-coiteration captures guarded coiterations schemata, i.e. specifications where recursive calls appear guarded by predefined algebraic operations.

Deterministic finite automata with recursive calls and DPDAs

We study deterministic finite automata (DFA) with recursive calls, that is, finite sequences of component DFAs that can call each other recursively. DFAs with recursive calls are akin to recursive state machines and unrestricted hierarchic state machines. We show that they are language equivalent to deterministic pushdown automata (DPDA).

There and back again

We present a programming pattern where a recursive function traverses a data structure---typically a list---at return time. The idea is that the recursive calls get us there (typically to a base case) and the returns get us back again while traversing the data structure . We name this programming pattern of traversing a data structure at return time "There And Back Again" (TABA).The TABA pattern directly applies to computing a symbolic convolution. It also synergizes well with other programming patterns, e.g., dynamic programming and traversing a list at double speed. We illustrate TABA and dynamic programming with Catalan numbers. We illustrate TABA and traversing a list at double speed with palindromes and we obtain a novel solution to this traditional exercise.A TABA-based function written in direct style makes full use of an Algol-like control stack and needs no heap allocation. Conversely, in a TABA-based function written in continuation-passing style, the continuation acts as a list iterator. In general, the TABA pattern saves one from constructing intermediate lists in reverse order.

Model Checking Erlang Programs – Abstracting Recursive Function Calls

We present an approach for the verification of Erlang programs using abstract interpretation and model checking. In previous work we defined a framework for data abstraction for Erlang. An abstract operational semantics for this framework preserves all paths of the standard operational semantics. Hence, the abstraction is safe for all properties that have to hold on all paths of a system, like properties in LTL. The proof can be automated with model checking if the abstract operational semantics is a finite transition system. But finiteness cannot be guaranteed because of non-tail recursive function calls. Even for finite domain abstract interpretations we get infinite state systems and model checking is undecidable. In this paper we formalize an abstraction of the control-flow. It replaces the recursive calls in non-tail positions by jumps to the last call of the same function. The corresponding returns are replaced by jumps to the possible return points.We have implemented this approach as a prototype and are able to prove properties like mutual exclusion or the absence of deadlocks and lifelocks for some Erlang programs.

Rep-tiles with Woven Horns

Rep-tiles with Woven Horns

There and Back Again

We present a programming pattern where a recursive function traverses a data structure--typically a list--at return time. The idea is that the recursive calls get us there (typically to a base case) and the returns get us back again <em>while traversing the data structure</em>. We name this programming pattern of traversing a data structure at return time ``There And Back Again'' (TABA).<br /> <br />The TABA pattern directly applies to computing a symbolic convolution. It also synergizes well with other programming patterns, e.g., dynamic programming and traversing a list at double speed. We illustrate TABA and dynamic programming with Catalan numbers. We illustrate TABA and traversing a list at double speed with palindromes and we obtain a novel solution to this traditional exercise.<br /> <br />A TABA-based function written in direct style makes full use of an Algol-like control stack and needs no heap allocation. Conversely, in a TABA-based function written in continuation-passing style, the continuation acts as a list iterator. In general, the TABA pattern saves one from constructing intermediate lists in reverse order.<br /><br />See also BRICS-RS-05-3.

A predicative analysis of structural recursion

We introduce a language based upon lambda calculus with products, coproducts and strictly positive inductive types that allows the definition of recursive terms. We present the implementation (foetus) of a syntactical check that ensures that all such terms are structurally recursive, i.e. recursive calls appear only with arguments structurally smaller than the input parameters of terms considered. To ensure the correctness of the termination checker, we show that all structurally recursive terms are normalizing with respect to a given operational semantics. To this end, we define a semantics on all types and a structural ordering on the values in this semantics and prove that all values are accessible with regard to this ordering. Finally, we point out how to do this proof predicatively using set based operators.

There and Back Again

We illustrate a variety of programming problems that seemingly require two separate list traversals, but that can be efficiently solved in one recursive descent, without any other auxiliary storage but what can be expected from a control stack. The idea is to perform the second traversal when returning from the first.<br /> <br />This programming technique yields new solutions to traditional problems. For example, given a list of length 2n or 2n+1, where n is unknown, we can detect whether this list is a palindrome in n+1 recursive calls and no heap allocation.

Model Checking Erlang Programs – Abstracting the Context-Free Structure

We present an approach for the verification of Erlang programs using abstract interpretation and model checking. In previous work we defined a framework for abstract interpretations for Erlang. In this framework it is guaranteed, that the abstract operational semantics preserves all paths of the standard operational semantics. We consider properties that have to hold on all paths of a system, like properties in LTL. If these properties can be proven for the abstract operational semantics, then they also hold for the Erlang program. The proof can be automated with model checking if the abstract operational semantics is a finite transition system. But finiteness cannot be guaranteed because of non-tail recursive function calls. Even for finite domain abstract interpretations we get infinite state systems and model checking is undecidable. In this paper we define an abstraction of the control–flow. It replaces recursive calls in non–tail positions by jumps to the last call of the same function. The corresponding returns are replace by jumps to the possible return points.We have implemented this approach as a prototype and are able to prove properties like mutual exclusion or the absence of deadlocks and lifelocks for some Erlang programs.

Asymptotic normality of recursive algorithms via martingale difference arrays

We propose martingale central limit theorems as an tool to prove asymptotic normality of the costs of certain recursive algorithms which are subjected to random input data. The recursive algorithms that we have in mind are such that if input data of size N produce random costs L_N, then L_N=^D L_n+ L_N-n+R_N for N ≥ n_0≥ 2, where n follows a certain distribution P_N on the integers \0, \ldots ,N\ and L_k =^D L_k for k≥ 0. L_n, L_N-n and R_N are independent, conditional on n, and R_N are random variables, which may also depend on n, corresponding to the cost of splitting the input data of size N (into subsets of size n and N-n) and combining the results of the recursive calls to yield the overall result. We construct a martingale difference array with rows converging to Z_N:= [L_N - E L_N] / [√Var L_N]. Under certain compatibility assumptions on the sequence (P_N)_N≥ 0 we show that a pair of sufficient conditions (of Lyapunov type) for Z_N → ^DN(0,1) can be restated as a pair of conditions regarding asymptotic relations between three sequences. All these sequences satisfy the same type of linear equation, that is also the defining equation for the sequence (E L_N)_N≥ 0 and thus very likely a well studied object. In the case that the P_N are binomial distributions with the same parameter p, and for deterministic R_N, we demonstrate the power of this approach. We derive very general sufficient conditions in terms of the sequence (R_N)_N≥ 0 (and for the scale R_N=N^α a characterization of those α ) leading to asymptotic normality of Z_N.

Automatic Parallelization of Recursive Procedures

Parallelizing compilers have traditionally focussed mainly on parallelizing loops. This paper presents a new framework for automatically parallelizing recursive procedures that typically appear in divide-and-conquer algorithms. We present compile-time analysis, using powerful, symbolic array section analysis, to detect the independence of multiple recursive calls in a procedure. This allows exploitation of a scalable form of nested parallelism, where each parallel task can further spawn off parallel work in subsequent recursive calls. We describe a runtime system which efficiently supports this kind of nested parallelism without unnecessarily blocking tasks. We have implemented this framework in a parallelizing compiler, which is able to automatically parallelize programs like quicksort and mergesort, written in C. For cases where even the advanced compile-time analysis we describe is not able to prove the independence of procedure calls, we propose novel techniques for speculative runtime parallelization, which are more efficient and powerful in this context than analogous techniques proposed previously for speculatively parallelizing loops. Our experimental results on an IBM G30 SMP machine show good speedups obtained by following our approach.

Recursion Removal/Introduction by Formal Transformation: An Aid to Program Development and Program Comprehension

The transformation of a recursive program to an iterative equivalent is a fundamental operation in computer science. In the reverse direction, the task of reverse engineering (analysing a given program in order to determine its specification) can be greatly ameliorated if the program can be re-expressed in a suitable recursive form. However, the existing recursion removal transformations, such as the techniques discussed by Knuth [1] and Bird [2], can only be applied in the reverse direction if the source program happens to match the structure produced by a particular recursion removal operation. In this paper we describe a much more powerful recursion removal and introduction operation which describes its source and target in the form of an action system (a collection of labels and calls to labels). A simple, mechanical restructuring operation can be applied to a great many iterative programs, which will put them in a suitable form for recursion introduction. Our transformation generates strictly more iterative versions than the standard methods, including those of Knuth and Bird [1, 2]. With the aid of this theorem we prove a (somewhat counterintuitive) result for programs that contain sequences of two or more recursive calls: under a reasonable commutativity condition, ‘depth-first’ execution is more general than ‘breadth-first’ execution. In ‘depth-first’ execution, the execution of each recursive call is completed, including all sub-calls, before execution of the next call is started. In ‘breadth-first’ execution, each recursive call in the sequence is partially executed but any sub-calls are temporarily postponed. This result means that any breadth-first program can be reimplemented as a corresponding depth-first program, but the converse does not hold. We also treat the case of ‘random-first’ execution, where the execution order is implementation dependent. For the more restricted domain of tree searching we show that a ‘breadth-first’ search is the most general form. We also give two examples of recursion introduction as an aid to formal reverse engineering.

Hierarchical finite-state machines and their use for digital control

This paper discusses the behavioral description, logic synthesis, and practical use of control units modeled as hierarchical finite-state machines with virtual states. The technique considered here provides a natural mechanism for top-down decomposition and enables us to develop any complex control algorithm step-by-step, where, at each stage, we are only dealing with a particular level of abstraction. Within any level, the specification encapsulates the control data and functions and allows recursive calls. Finally, the approach enables control units to be designed such that they incorporate new properties such as flexibility and extensibility. The primary functional components of a control algorithm can be reused in future applications.

How many recursive calls does a recursive function make?

The calculation of the Fibonacci sequence using recursion gives rise to an interesting question: How many times does a recursive function call itself? This paper presents one way to examine this question using difference equations with initial conditions, or discrete dynamical systems (DDS). We show that there is a linear relationship between the Fibonacci numbers themselves and the number of recursive calls. This relationship generalizes to any type of DDS of second-order, and DDS of higher-order.

An empirical study of the 4-valued Kripke-Kleene and 4-valued well-founded semantics in random propositional logic programs

We empirically investigated the difficulty of finding stable models for logic programs using backtracking, by trying to identify what makes random instances easy or hard. Additionally, we empirically investigated the effectiveness of the 4dvalued Kripke–Kleene semantics (4KK) and the 4dvalued welldfounded semantics (4WF) in the Niemela and Simons’ backtracking algorithm, smodels, for finding stable models. We studied the behavior of 4KK and 4WF in a parameterized distribution of random propositional logic programs of fixed ruledlength k. In all of our experiments, 4KK and 4WF (both modified to extend an input partial truth assignment) were computed with respect to a fixed percentage of proposition letters (randomly chosen) initially assigned TRUE and a fixed percentage (randomly chosen) initially assigned FALSE. There exists a region, R, in the parameter space of our distribution where smodels required a large number of recursive calls to determine if programs generated in this region have any stable models. Hence, the “hardest” programs for smodels to determine if a stable model exists lie in R. Additionally, there exists a subregion of R where smodels made significantly fewer recursive calls when using 4WF as a pruning technique than when using 4KK. To gain a deeper insight into the causes for the “hardness” of programs in R and the differences between 4WF and 4KK as pruning techniques in smodels, we examined more closely the behavior of 4KK and 4WF. There exists a region in which a very small percentage of inconsistent models were produced by both 4KK and 4WF, thereby providing very little information useful for smodels to immediately backtrack. This region roughly corresponded to the above region where smodels required a large number of recursive calls. Also, there exists a region in which both 4KK and 4WF produced a high percentage of inconsistent models, thereby providing information useful for smodels to immediately backtrack.

The Difficulty of Using Procedures with the Recursive Call

The Difficulty of Using Procedures with the Recursive Call

How good are branching rules in DPLL?

The Davis-Putnam-Logemann-Loveland algorithm is one of the most popular algorithms for solving the satisfiability problem. Its efficiency depends on its choice of a branching rule. We construct a sequence of instances of the satisfiability problem that fools a variety of “sensible” branching rules in the following sense: when the instance has n variables, each of the “sensible” branching rules brings about Ω(2 n 5 ) recursive calls of the Davis-Putnam-Logemann-Loveland algorithm, even though only O(1) such calls are necessary.

Comparisons in Hoare's Find Algorithm

We study the number of comparisons in Hoare's Find algorithm. Using trivariate generating functions, we get an explicit expression for the variance of the number of comparisons, if we search for the jth element in a random permutation of n elements. The variance is also asymptotically evaluated under the assumption that j is proportional to n. Similar results for the number of passes (recursive calls) are given, too.