Linear time hierarchies for a functional language machine model

The constant speedup theorem, so well known from Turing machine based complexity theory, is shown false for a natural imperative programming language I that manipulates tree-structured data. This relieves a tension between general programming practice, where linear factors are essential, and complexity theory, where linear time changes are traditionally regarded as trivial. Specifically, there is a constant b such that for any a > 0 there is a set X recognizable in time a · b · n but not in time a · n. Thus LIN, the collection of all sets recognizable in linear time by deterministic I-programs, contains an infinite hierarchy ordered by constant coefficients. Constant hierarchies also exist for larger time bounds T (n), provided they are time-constructable. Second, a problem is exhibited which is complete for the nondeterministic linear time sets NLIN with respect to a natural notion of deterministic linear-time reduction. Third, Kleene’s Second Recursion Theorem in essence shows that for any program p defined with self-reference, there is an equivalent nonreflexive program q. This is proven for an extension I↑ of I. Further, q can be simulated by an I program at most constantly slower than p. Language I↑ allows calls to the language’s own interpretation function, and even to its running time function (without the usual high costs for nested levels of interpretation). The results all hold as well for a stronger language I allowing selective updating of tree-structured data. The results are robust in that classes LIN and NLIN are identical for I , Isu↑, Schonhage’s Storage Modification Machines, Knuth/Tarjan’s pointer machines, and successor RAMs [13,14,11]. where n is the size of the input. DIKU, Department of Computer Science, University of Copenhagen, Universitetsparken 1, DK-2100 Copenhagen East, Denmark, E-mail: neil@diku.dk. If the “more realistic and precise measure” of SMM computation time is used [13], and similarly for the other models.

Top-k-size keyword search on tree structured data

A database interface based on Montague's approachto the interpretation of natural language

The paper describes a fault tolerant model for a functional language parallel machine. The model is transparent to the user and ensures successful execution of programs in the presence of hardware failure. The model is based on data replication. It takes advantage of the properties of the functional languages. The recovery scheme can be carried out simultaneously on all processors and occurs while program execution is in progress. Thus normal execution suffers less performance degradation than with other approaches. >

The purpose of this paper is to demonstrate that first-order functional programs can be transformed into intensional programs of nullary variables, in a semantics preserving way. On the foundational side, the goal of our study is to bring new insights and a better understanding of the nature of functional languages. From a practical point of view, our investigation provides a formal basis for the tagging mechanism that is used in the implementation of first-order functional languages on dataflow machines.

Many important tasks and algorithms in computer science build on sorted trees. Typical examples are the translation of programs represented by syntax trees or the processing of (recursive) data structures following some XML schema. In purely functional programming, sorted trees are usually implemented by terms of recursive data types such that a term represents a tree node and the subterms represent its children. The drawback of this representation is that the context of a tree node is not accessible and has to be managed by different means, e.g., by additional arguments of the functions working on the tree.In this paper, we present a pattern for the realization of sorted trees that overcomes this drawback. The technique is fully declarative. In contrast to competing patterns for trees such as Zippers, it supports pattern matching on the tree data structure. Functions on tree nodes can be used to express the decoration of trees by attribute values in a flexible way. In particular, links between tree nodes can easily be defined and attributions can be modularized into phases with clear interfaces. Techniques adapted from the “Scrap your boilerplate” approach allow for the high-level specification of contextual constraints. We show how our approach can be realized in Haskell and discuss tool support.KeywordsType ClassTree NodeTree RepresentationFunctional ProgrammingSyntax TreeThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Futures are an elegant approach to expressing parallelism in functional programs. However, combining futures with imperative programming (as in C++ or in Java) can lead to pernicious bugs in the form of data races and deadlocks, as a consequence of uncontrolled data flow through mutable shared memory. In this paper we introduce the Known Joins (KJ) property for parallel programs with futures, and relate it to the Deadlock Freedom (DF) and the Data-Race Freedom (DRF) properties. Our paper offers two key theoretical results: 1) DRF implies KJ, and 2) KJ implies DF. These results show that data-race freedom is sufficient to guarantee deadlock freedom in programs with futures that only manipulate unsynchronized shared variables. To the best of our knowledge, these are the first theoretical results to establish sufficient conditions for deadlock freedom in imperative parallel programs with futures, and to characterize the subset of data races that can trigger deadlocks (those that violate the KJ property). From result 2), we developed a tool that avoids deadlocks in linear time and space when KJ holds, i.e., when there are no data races among references to futures. When KJ fails, the tool reports the data race and optionally falls back to a standard deadlock avoidance algorithm by cycle detection. Our tool verified a dataset of ∼2,300 student’s homework solutions and found one deadlocked program. The performance results obtained from our tool are very encouraging: a maximum slowdown of 1.06× on a 16-core machine, always outperforming deadlock avoidance via cycle-detection. Proofs of the two main results were formalized using the Coq proof assistant.

This paper is part of a research on static analysis in order to predict program resources and belongs to the implicit computational complexity line of research. It presents intrinsic characterizations of the classes of functions, which are computable in NCk, that is by a uniform, poly-logarithmic depth and polynomial size family of circuits, using first order functional programs. Our characterizations are new in terms of first order functional programming language and extend the characterization of NC1 in [9]. These characterizations are obtained using a complexity measure, the sup-interpretation, which gives upper bounds on the size of computed values and captures a lot of program schemas.

An important task in computer vision is the recognition of partially visible two-dimensional objects in a gray scale image. Recent works addressing this problem have attempted to match spatially local features from the image to features generated by models of the objects. However, many algo rithms are considerably less efficient than they might be, typ ically being O(IN) or worse, where I is the number offeatures in the image and N is the number of features in the model set. This is invariably due to the feature-matching portion of the algorithm. In this paper we discuss an algorithm that significantly improves the efficiency offeature matching. In addition, we show experimentally that our recognition algo rithm is accurate and robust. Our algorithm uses the local shape of contour segments near critical points, represented in slope angle-arclength space (θ-s space), as fundamental fea ture vectors. These feature vectors are further processed by projecting them onto a subspace in θ-s space that is obtained by applying the Karhunen-Loève expansion to all such fea tures in the set of models, yielding the final feature vectors. This allows the data needed to store the features to be re duced, while retaining nearly all information important for recognition. The heart of the algorithm is a technique for performing matching between the observed image features and the precomputed model features, which reduces the runtime complexity from O(IN) to O(I log I + I log N), where I and N are as above. The matching is performed using a tree data structure, called a kD tree, which enables multidi mensional searches to be performed in O(log) time.

In this paper we present the first investigation into the implementation of a Functional Hybrid Modelling language for non-causal modelling and simulation of physical systems. In particular, we present a simple way to handle connect constructs: a facility for composing model fragments present in some form in most non-causal modelling languages. Our implementation is realised as a domain-specific language embedded in Haskell. The method of embedding employs quasiquoting, thus demonstrating the effectiveness of this approach for languages that are not suitable for embedding in more traditional ways. Our implementation is available on-line, and thus the first publicly available prototype implementation of a Functional Hybrid Modelling language.

Design and development of large-scale automated systems (AS) is always associated with overcoming a large number of uncertainties, which structuring often through the using of practice standards and modeling at the Systems & Software Engineering. Methods of analysis of large systems (LS) involve their decomposition in the context of structural and/or functional paradigms, which allow us to consider the obtained components as objects for modelling: functional modelling, simulation etc. Design the automated control system (ACS) of region (SmartCity project) need to optimize the decisions. In this paper we propose the new methods of determining the parameters of project in terms of lack statistical information based on the simulation model.

An algorithm called the O-algorithm is introduced for automatic test program generation of microprocessors in a user environment. To eliminate redundant tests, a weight-digraph model is used to model the signal flow of the general microprocessors. Improved functional fault models of microprocessors are derived from the Turing machine model. The O-algorithm is then constructed on the basis of the signal flow model and functional fault models. Simulation has shown that the fault coverage is better than 97%.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Functional Hazard Assessment (FHA) is a key early-stage engineering process that supports the incorporation of safety in design by identifying the high-level functional hazards the system may encounter. Functional Hazard Assessment is often supported by models of system functionality that abstract system behavior at a functional level. However, diagramming languages and conventions used to create these abstractions are limited in what types of behavior they can coherently represent--often leaving out or misrepresenting the key behavioral interactions that cause hazardous conditions to propagate from one function to another. To resolve these limitations, this paper introduces the Functional Reasoning Design Language (FRDL), a formal modelling language for describing the functional elements of a system and their behavioral interactions. To demonstrate the use of FRDL, an autonomous rover system is analyzed using FRDL along with a traditional Failure/Fault Analyses Procedure to show how FRDL can improve understanding of hazardous behavior. The results of this demonstration highlight the potential for FRDL's more rigorous representation of system function to improve the hazard analysis process.

Abramov and Glück have recently introduced a technique called URA for inverting first order functional programs. Given some desired output value, URA computes a potentially infinite sequence of substitutions/restrictions corresponding to the relevant input values. In some cases this process does not terminate.In the present paper, we propose a new program analysis for inverting programs. The technique works by computing a finite grammar describing the set of all input that relate to a given output. During the production of the grammar, the original program is implicitly transformed using so-called driving steps. Whereas URA is sound and complete, but sometimes fails to terminate, our technique always terminates and is complete, but not sound. As an example, we demonstrate how to derive type inference from type checking.The idea of approximating functional programs by grammars is not new. For instance, the second author has developed a technique using tree grammars to approximate termination behaviour of deforestation. However, for the present purposes it has been necessary to invent a new type of grammar that extends tree grammars by permitting a notion of sharing in the productions. These dag grammars seem to be of independent interest.

Complex engineered systems can carry risk of high failure consequences, and as a result, resilience—the ability to avoid or quickly recover from faults—is desirable. Ideally, resilience should be designed-in as early in the design process as possible so that designers can best leverage the ability to explore the design space. Toward this end, previous work has developed functional modeling languages which represent the functions which must be performed by a system and function-based fault modeling frameworks have been developed to predict the resulting fault propagation behavior of a given functional model. However, little has been done to formally optimize or compare designs based on these predictions, partially because the effects of these models have not been quantified into an objective function to optimize. The work described herein closes this gap by introducing the resilience-informed scenario cost sum (RISCS), a scoring function which integrates with a fault scenario-based simulation, to enable the optimization and evaluation of functional model resilience. The scoring function accomplishes this by quantifying the expected cost of a design's fault response using probability information, and combining this cost with design and operational costs such that it may be parameterized in terms of designer-specified resilient features. The usefulness and limitations of using this approach in a general optimization and concept selection framework are discussed in general, and demonstrated on a monopropellant system design problem. Using RISCS as an objective for optimization, the algorithm selects the set of resilient features which provides the optimal trade-off between design cost and risk. For concept selection, RISCS is used to judge whether resilient concept variants justify their design costs and make direct comparisons between different model structures.