Recursive Types Research Articles

Parametric Compositional Data Types

In previous work we have illustrated the benefits that compositional data types (CDTs) offer for implementing languages and in general for dealing with abstract syntax trees (ASTs). Based on Swierstra's data types \'a la carte, CDTs are implemented as a Haskell library that enables the definition of recursive data types and functions on them in a modular and extendable fashion. Although CDTs provide a powerful tool for analysing and manipulating ASTs, they lack a convenient representation of variable binders. In this paper we remedy this deficiency by combining the framework of CDTs with Chlipala's parametric higher-order abstract syntax (PHOAS). We show how a generalisation from functors to difunctors enables us to capture PHOAS while still maintaining the features of the original implementation of CDTs, in particular its modularity. Unlike previous approaches, we avoid so-called exotic terms without resorting to abstract types: this is crucial when we want to perform transformations on CDTs that inspect the recursively computed CDTs, e.g. constant folding.

The marriage of bisimulations and Kripke logical relations

There has been great progress in recent years on developing effective techniques for reasoning about program equivalence in ML-like languages---that is, languages that combine features like higher-order functions, recursive types, abstract types, and general mutable references. Two of the most prominent types of techniques to have emerged are *bisimulations* and *Kripke logical relations (KLRs)*. While both approaches are powerful, their complementary advantages have led us and other researchers to wonder whether there is an essential tradeoff between them. Furthermore, both approaches seem to suffer from fundamental limitations if one is interested in scaling them to inter-language reasoning. In this paper, we propose *relation transition systems (RTSs)*, which marry together some of the most appealing aspects of KLRs and bisimulations. In particular, RTSs show how bisimulations' support for reasoning about recursive features via *coinduction* can be synthesized with KLRs' support for reasoning about local state via *state transition systems*. Moreover, we have designed RTSs to avoid the limitations of KLRs and bisimulations that preclude their generalization to inter-language reasoning. Notably, unlike KLRs, RTSs are transitively composable.

A Sound Type System for Typing Runtime Errors

Dynamically typed languages such as Scheme are widely adopted because of their rich expressiveness. However, there is the drawback that dynamic typing cannot detect runtime errors at compile time. In this paper, we propose a type system which enables static detection of runtime errors. The key idea of our approach is to introduce a special type, called the error type, for expressions that cause runtime errors. The proposed type system brings out the benefit of the error type with set-theoretic union, intersection and complement types, recursive types, parametric polymorphism and subtyping. While existing type systems usually ensure that evaluation never causes runtime errors for typed expressions, our system ensures that evaluation always causes runtime errors for expressions typed with the error type. Likewise, our system also ensures that evaluation never causes errors for expressions typed with any type that does not contain the error type. Under the usual definition of subtyping, it is difficult to syntactically prove the soundness of our type system. We redefine subtyping by introducing the notion of intransitive subtyping, and syntactically prove the soundness under the new definition.

Ordinal outlier detection based on recursive uniform partitioning

Outlier detection plays an important role in intelligent cyber systems, especially for fault-tolerant and adaptive ones. Traditional algorithms always need to evaluate distances or densities, which are very time-consuming. Considering the increasingly urgent demand for real-time application, during the past few years, various novel algorithms have been proposed. They are much faster, but less stable and less accurate. To cope with these problems, based on the core idea of ordinal optimization and the ‘few and different’ characteristics of outliers, by introducing the concept of outlier probability, we propose this ordinal outlier detection algorithm (OOD), which extracts outliers in terms of the order of being isolated in a recursive uniform data space partitioning process. It does not need any distance or density evaluation, and the complexity is reduced to O( n). Experiments show that the CPU time of OOD increases linearly with linearly growing data sets. Furthermore, compared with the recent iForest algorithm, OOD is about 30 times faster, with a 20–30% improvement in accuracy and in particular is much more stable. OOD also has good scalability, so it works well in high-dimensional data sets, which have a huge number of instances and irrelevant attributes.

Null dereference verification via over-approximated weakest pre-conditions analysis

Null dereferences are a bane of programming in languages such as Java. In this paper we propose a sound, demand-driven, inter-procedurally context-sensitive dataflow analysis technique to verify a given dereference as safe or potentially unsafe. Our analysis uses an abstract lattice of formulas to find a pre-condition at the entry of the program such that a null-dereference can occur only if the initial state of the program satisfies this pre-condition. We use a simplified domain of formulas, abstracting out integer arithmetic, as well as unbounded access paths due to recursive data structures. For the sake of precision we model aliasing relationships explicitly in our abstract lattice, enable strong updates, and use a limited notion of path sensitivity. For the sake of scalability we prune formulas continually as they get propagated, reducing to true conjuncts that are less likely to be useful in validating or invalidating the formula. We have implemented our approach, and present an evaluation of it on a set of ten real Java programs. Our results show that the set of design features we have incorporated enable the analysis to (a) explore long, inter-procedural paths to verify each dereference, with (b) reasonable accuracy, and (c) very quick response time per dereference, making it suitable for use in desktop development environments.

Loop Extended Symbolic Execution on List Manipulating Programs

Current symbolic execution is challenged by its ability to deal with loops. The case gets worse for loops manipulating recursive data structures. In this paper, we extend classic symbolic execution techniques for error detection of programs manipulating lists in loops. The idea is to enhance the symbolic execution with the utilization of quantitative aspect of the shape, and to construct the exit state of the loop. The exit state is constrained by a set of numeric constraints containing normal symbolic variables in programs and instrumented symbolic variables on the shapes. A prototype tool has been implemented and experiments are conducted on some commonly used list manipulating programs.

Acceleration of Recursive Data Sorting over Tree-based Structures

The main objective of this paper is to evaluate and improve FPGA-based digital circuits, which implement recursive specifications.Recursive sorting algorithms over binary trees are considered as a case study to evaluate and demonstrate new techniques and theiradvantages. Since recursive calls are not directly supported by hardware description languages, they are implemented using the model ofa hierarchical finite state machine (HFSM). The paper presents analysis and comparison of alternative and competitive techniques fordescribing recursive algorithms in hardware. The experimental results demonstrate that the proposed innovations allow to achieve betterperformance. Obviously, the results of this paper are not limited to recursive sorting alone. They have a wider scope and can be appliedeffectively to numerous systems that implement recursive algorithms over tree-based data structures. Ill. 8, bibl. 10, tabl. 2 (in English;abstracts in English and Lithuanian).http://dx.doi.org/10.5755/j01.eee.113.7.612

Differential constraints for bounded recursive identification with multivariate splines

The ability to perform online model identification for nonlinear systems with unknown dynamics is essential to any adaptive model-based control system. In this paper, a new differential equality constrained recursive least squares estimator for multivariate simplex splines is presented that is able to perform online model identification and bounded model extrapolation in the framework of a model-based control system. A new type of linear constraints, the differential constraints, are used as differential boundary conditions within the recursive estimator which limit polynomial divergence when extrapolating data. The differential constraints are derived with a new, one-step matrix form of the de Casteljau algorithm, which reduces their formulation into a single matrix multiplication. The recursive estimator is demonstrated on a bivariate dataset, where it is shown to provide a speedup of two orders of magnitude over an ordinary least squares batch method. Additionally, it is demonstrated that inclusion of differential constraints in the least squares optimization scheme can prevent polynomial divergence close to edges of the model domain where local data coverage may be insufficient, a situation often encountered with global recursive data approximation.

Logical Step-Indexed Logical Relations

Appel and McAllester's "step-indexed" logical relations have proven to be a simple and effective technique for reasoning about programs in languages with semantically interesting types, such as general recursive types and general reference types. However, proofs using step-indexed models typically involve tedious, error-prone, and proof-obscuring step-index arithmetic, so it is important to develop clean, high-level, equational proof principles that avoid mention of step indices. In this paper, we show how to reason about binary step-indexed logical relations in an abstract and elegant way. Specifically, we define a logic LSLR, which is inspired by Plotkin and Abadi's logic for parametricity, but also supports recursively defined relations by means of the modal "later" operator from Appel, Melli\`es, Richards, and Vouillon's "very modal model" paper. We encode in LSLR a logical relation for reasoning relationally about programs in call-by-value System F extended with general recursive types. Using this logical relation, we derive a set of useful rules with which we can prove contextual equivalence and approximation results without counting steps.

Volatility Forecasting and the Business Cycle: Evidence from the European Monetary Union

Using a recursive modeling approach and data from the Euro area, the following paper analyzes the counter-cyclicity, stock price volatility is believed to demonstrate with respect to the state of the economy. It further tests whether such interdependence is exploitable for volatility forecasting. The sound contribution of this paper is the extension of the in-sample to an out-of-sample analysis. We deliver robust results that greatly challenge the theory of straight and clear-cut link between stock price variability and the state of the economy on an ex ante and ex post basis. Compared with the forecasting ability of an GJR-GARCH-Model, of the implied and historical volatility, the prediction power of macroeconomic and financial information on stock price volatility is practically deprived by the results presented. These underline the information load already incorporated in market prices and stand in line with the efficient-market hypothesis.

Identification of Building Envelope Overall Coefficient of Heat Transfer Using Recursive Least Squares Algorithm

This paper introduces the methodology and procedures of identification of overall coefficient of heat transfer (U-factor) of building envelopes using recursive least squares algorithm and dynamic heat transfer data. Application this method to three types of typical to examine the correctness and feasibility of this method. The following conclusions can be obtained: 1) Identification of U-factor of building envelopes using recursive least squares algorithm is feasible for engineering purpose, the identified U-factor can be near to its real value; 2)The testing periods can be much shorter than the steady testing; 3)The identification error is associated with the thermal inertia. The error is larger as the thermal inertia of building envelope is large within the same testing circumstances.

Proofs, Programs, Processes

The objective of this paper is to provide a theoretical foundation for program extraction from inductive and coinductive proofs geared to practical applications. The novelties consist in the addition of inductive and coinductive definitions to a realizability interpretation for first-order proofs, a soundness proof for this system, and applications to the synthesis of non-trivial provably correct programs in the area of exact real number computation. We show that realizers, although per se untyped, can be assigned polymorphic recursive types and hence represent valid programs in a lazy functional programming language such as Haskell. Programs extracted from proofs using coinduction can be understood as perpetual processes producing infinite streams of data. Typical applications of such processes are computations in exact real arithmetic. As an example we show how to extract a program computing the average of two real numbers w.r.t. the binary signed digit representation.

On equal [formula omitted]-terms

We consider the rewrite system R μ with μ x . M → μ M [ x : = μ x . M ] as its single rewrite rule, where the signature consists of the variable binding operator commonly denoted by μ , first-order symbols, which in this paper are restricted to a binary function symbol F , and possibly some constant symbols. This kernel system denoting recursively defined objects occurs in several contexts, e.g. it is the framework of recursive types, with F as the function type constructor. For general signatures, this rewriting system is widely used to represent and manipulate infinite regular trees. The main concern of this paper is the convertibility relation for μ -terms as given by the μ -rule, in particular, its decidability. This relation is sometimes called weak μ -equality, in contrast with strong μ -equality, which is given by the equality of the possibly infinite tree unwinding of μ -terms. While strong equality has received much attention, the opposite is the case for weak μ -equality. We present three alternative proofs for decidability of weak μ -equality. The first two proofs build upon an ingenious proof method of Cardone and Coppo. Prior to that, we prepare the way by an analysis of α -conversion. We then give a decidability proof in an ‘ α -free’ manner, essentially treating μ -terms as first-order terms, and next, a proof in higher-order style, employing α -equivalence classes and viewing R μ as a higher-order rewriting system. The third decidability proof is also derived in an α -free manner, exploiting the regular nature of the set of μ -reducts, enabling an appeal to the theory of tree automata. We conclude with additional results concerning decidability of reachability, and upward-joinability of μ -reduction, and of convertibility by α -free μ -reduction.

Algebraic Specialization of Generic Functions for Recursive Types

Defining functions over large, possibly recursive, data structures usually involves a lot of boilerplate. This code simply traverses non-interesting parts of the data, and rapidly becomes a maintainability problem. Many generic programming libraries have been proposed to address this issue. Most of them allow the user to specify the behavior just for the interesting bits of the structure, and provide traversal combinators to “scrap the boilerplate”. The expressive power of these libraries usually comes at the cost of efficiency, since runtime checks are used to detect where to apply the type-specific behavior.In previous work we have developed an effective rewrite system for specialization and optimization of generic programs. In this paper we extend it to also cover recursive data types. The key idea is to specialize traversal combinators using well-known recursion patterns, such as folds or paramorphisms. These are ruled by a rich set of algebraic laws that enable aggressive optimizations. We present a type-safe encoding of this rewrite system in Haskell, based on recent language extensions such as type-indexed type families.

The impact of higher-order state and control effects on local relational reasoning

Reasoning about program equivalence is one of the oldest problems in semantics. In recent years, useful techniques have been developed, based on bisimulations and logical relations, for reasoning about equivalence in the setting of increasingly realistic languages - languages nearly as complex as ML or Haskell. Much of the recent work in this direction has considered the interesting representation independence principles enabled by the use of local state, but it is also important to understand the principles that powerful features like higher-order state and control effects disable . This latter topic has been broached extensively within the framework of game semantics, resulting in what Abramsky dubbed the "semantic cube": fully abstract game-semantic characterizations of various axes in the design space of ML-like languages. But when it comes to reasoning about many actual examples, game semantics does not yet supply a useful technique for proving equivalences. In this paper, we marry the aspirations of the semantic cube to the powerful proof method of step-indexed Kripke logical relations . Building on recent work of Ahmed, Dreyer, and Rossberg, we define the first fully abstract logical relation for an ML-like language with recursive types, abstract types, general references and call/cc. We then show how, under orthogonal restrictions to the expressive power our language - namely, the restriction to first-order state and/or the removal of call/cc - we can enhance the proving power of our possible-worlds model in correspondingly orthogonal ways, and we demonstrate this proving power on a range of interesting examples. Central to our story is the use of state transition systems to model the way in which properties of local state evolve over time.

Generic multiset programming with discrimination-based joins and symbolic Cartesian products

This paper presents GMP, a library for generic, SQL-style programming with multisets. It generalizes the querying core of SQL in a number of ways: Multisets may contain elements of arbitrary first-order data types, including references (pointers), recursive data types and nested multisets; it contains an expressive embedded domain-specific language for specifying user-definable equivalence and ordering relations, extending the built-in equality and inequality predicates; it admits mapping arbitrary functions over multisets, not just projections; it supports user-defined predicates in selections; and it allows user-defined aggregation functions. Most significantly, it avoids many cases of asymptotically inefficient nested iteration through Cartesian products that occur in a straightforward stream-based implementation of multisets. It accomplishes this by employing two novel techniques: symbolic (term) representations of multisets, specifically for Cartesian products, for facilitating dynamic symbolic computation, which intersperses algebraic simplification steps with conventional data processing; and discrimination-based joins, a generic technique for computing equijoins based on equivalence discriminators, as an alternative to hash-based and sort-merge joins. Full source code for GMP in Haskell, which is based on generic top-down discrimination (not included), is included for experimentation. We provide illustrative examples whose performance indicates that GMP, even without requisite algorithm and data structure engineering, is a realistic alternative to SQL even for SQL-expressible queries.

Stage-by-stage guaranteeing innovation planning

The paper is devoted to further developments in the theory of designing new multipurpose technical systems. We introduce a better model of gradually refining information on uncertain factors in various stages of the system's lifecycle. We account for the uncertainties' influence not only on the optimality criterion, but also on the control admissibility set. The general constructions of a recursive Bellman type procedure, together with the generalized best guaranteed result principle, are accompanied by the analytic solution of an illustrative example.

Realisability semantics of parametric polymorphism, general references and recursive types

We present a realisability model for a call-by-value, higher-order programming language with parametric polymorphism, general first-class references, and recursive types. The main novelty is a relational interpretation of open types that include general reference types. The interpretation uses a new approach to modelling references.The universe of semantic types consists of world-indexed families of logical relations over a universal predomain. In order to model general reference types, worlds are finite maps from locations to semantic types: this introduces a circularity between semantic types and worlds that precludes a direct definition of either. Our solution is to solve a recursive equation in an appropriate category of metric spaces. In effect, types are interpreted using a Kripke logical relation over a recursively defined set of worlds.We illustrate how the model can be used to prove simple equivalences between different implementations of imperative abstract data types.

Multiplierless Recursive Algorithm Using Ramanujan Ordered Numbers

A special class of recursive multiplierless transforms for computing Discrete Cosine Transform (DCT) is introduced. DCT computation requires evaluation of cosine angles which are multiples of 2π/N. The proposed algorithm uses Ramanujan ordered number of degree-2 which is represented as 2−1 + 2−m. Thus the cosine functions can be computed by shifts and adds, employing Chebyshev type of recursion. With this algorithm, the floating-point multiplication is completely eliminated, and hence, the multiplierless algorithm can be implemented using shifts and additions only. The orthogonality of the recursive DCT kernel is well maintained through matrix factorization to reduce the computational complexity. The inherent parallel structure yields simpler programming and hardware implementation and provides additions and shifts which is very much less complex when compared to other recent multiplierless algorithms.

Reservoir Characterization Using an EnKF and a Non-parametric Approach for Highly Non-Gaussian Permeability Fields

An inverse scheme is developed for reservoir characterization using ensemble Kalman filter (EnKF) and non-parametric approach. EnKF has been studied by many researchers due to its novelties on recursive data processing, easy access to parallel processing, and quantifying uncertainties on its results. However, previous studies have shown poor characterization results with non-Gaussian permeability distributions. In this study, non-parametric approach is used to characterize permeability distribution with strong non-Gaussian characteristics. Normal score transformation is utilized to satisfy the Gaussian assumption of EnKF in the assimilation step. From the analyses of initial ensembles effects with non-Gaussian distributions, initial ensembles with higher similarity to the reference distribution would give more successful characterization results than those of less similarity. Additional improvement in reservoir characterization results is obtained by using normal score transformation.