13 research outputs found

    LambdaY-Calculus With Priorities

    Get PDF
    International audienceThe lambdaY-calculus with priorities is a variant of the simply-typed lambda calculus designed for higher-order model-checking. The higher-order model-checking problem asks if a given parity tree automaton accepts the Böhm tree of a given term of the simply-typed lambda calculus with recursion. We show that this problem can be reduced to the same question but for terms of lambdaY-calculus with priorities and visibly parity automata; a subclass of parity automata. The latter question can be answered by evaluating terms in a simple powerset model with least and greatest fixpoints. We prove that the recognizing power of powerset models and visibly parity automata are the same. So, up to conversion to the lambdaY-calculus with priorities, powerset models with least and greatest fixpoints are indeed the right semantic framework for the model-checking problem. The reduction to lambdaY-calculus with priorities is also efficient algorithmically: it gives an algorithm of the same complexity as direct approaches to the higher-order model-checking problem. This indicates that the task of calculating the value of a term in a powerset model is a central algo-rithmic problem for higher-order model-checking

    Using models to model-check recursive schemes

    Get PDF
    We propose a model-based approach to the model checking problem for recursive schemes. Since simply typed lambda calculus with the fixpoint operator, lambda-Y-calculus, is equivalent to schemes, we propose the use of a model of lambda-Y-calculus to discriminate the terms that satisfy a given property. If a model is finite in every type, this gives a decision procedure. We provide a construction of such a model for every property expressed by automata with trivial acceptance conditions and divergence testing. Such properties pose already interesting challenges for model construction. Moreover, we argue that having models capturing some class of properties has several other virtues in addition to providing decidability of the model-checking problem. As an illustration, we show a very simple construction transforming a scheme to a scheme reflecting a property captured by a given model.Comment: Long version of a paper presented at TLCA 201

    Implicit Automata in Typed λ-Calculi I: Aperiodicity in a Non-Commutative Logic

    Get PDF

    Implicit Automata in Typed ?-Calculi I: Aperiodicity in a Non-Commutative Logic

    Get PDF

    A model for divergence insensitive properties of lambdaY-terms

    Get PDF
    A term of a simply typed λ-calculus with fixpoints can be considered as an abstraction of a higher-order functional program. The result of the computation of a term is its Böhm tree. Given a tree automaton describing a property of Böhm trees, we are interested in constructing a model recognizing the property, in a sense that the value of a term determines if its Böhm tree satisfies the property. We show how to construct models recognizing properties expressed by parity automata that cannot detect divergence. We call them Ω-blind parity automata, as the symbol Ω is used in Böhm trees to represent divergence; an automaton is Ω-blind when it has to accept Ω from every state. The models we construct resemble standard Scott models of latices of monotone functions, but application needs to be modified and the the fixpoint operator should be interpreted as a particular non-extremal fixpoint in a lattice

    On the Termination Problem for Probabilistic Higher-Order Recursive Programs

    Get PDF
    In the last two decades, there has been much progress on model checking of both probabilistic systems and higher-order programs. In spite of the emergence of higher-order probabilistic programming languages, not much has been done to combine those two approaches. In this paper, we initiate a study on the probabilistic higher-order model checking problem, by giving some first theoretical and experimental results. As a first step towards our goal, we introduce PHORS, a probabilistic extension of higher-order recursion schemes (HORS), as a model of probabilistic higher-order programs. The model of PHORS may alternatively be viewed as a higher-order extension of recursive Markov chains. We then investigate the probabilistic termination problem -- or, equivalently, the probabilistic reachability problem. We prove that almost sure termination of order-2 PHORS is undecidable. We also provide a fixpoint characterization of the termination probability of PHORS, and develop a sound (but possibly incomplete) procedure for approximately computing the termination probability. We have implemented the procedure for order-2 PHORSs, and confirmed that the procedure works well through preliminary experiments that are reported at the end of the article

    Doctor of Philosophy

    Get PDF
    dissertationIn the static analysis of functional programs, control- ow analysis (k-CFA) is a classic method of approximating program behavior as a infinite state automata. CFA2 and abstract garbage collection are two recent, yet orthogonal improvements, on k-CFA. CFA2 approximates program behavior as a pushdown system, using summarization for the stack. CFA2 can accurately approximate arbitrarily-deep recursive function calls, whereas k-CFA cannot. Abstract garbage collection removes unreachable values from the store/heap. If unreachable values are not removed from a static analysis, they can become reachable again, which pollutes the final analysis and makes it less precise. Unfortunately, as these two techniques were originally formulated, they are incompatible. CFA2's summarization technique for managing the stack obscures the stack such that abstract garbage collection is unable to examine the stack for reachable values. This dissertation presents introspective pushdown control-flow analysis, which manages the stack explicitly through stack changes (pushes and pops). Because this analysis is able to examine the stack by how it has changed, abstract garbage collection is able to examine the stack for reachable values. Thus, introspective pushdown control-flow analysis merges successfully the benefits of CFA2 and abstract garbage collection to create a more precise static analysis. Additionally, the high-performance computing community has viewed functional programming techniques and tools as lacking the efficiency necessary for their applications. Nebo is a declarative domain-specific language embedded in C++ for discretizing partial differential equations for transport phenomena. For efficient execution, Nebo exploits a version of expression templates, based on the C++ template system, which is a type-less, completely-pure, Turing-complete functional language with burdensome syntax. Nebo's declarative syntax supports functional tools, such as point-wise lifting of complex expressions and functional composition of stencil operators. Nebo's primary abstraction is mathematical assignment, which separates what a calculation does from how that calculation is executed. Currently Nebo supports single-core execution, multicore (thread-based) parallel execution, and GPU execution. With single-core execution, Nebo performs on par with the loops and code that it replaces in Wasatch, a pre-existing high-performance simulation project. With multicore (thread-based) execution, Nebo can linearly scale (with roughly 90% efficiency) up to 6 processors, compared to its single-core execution. Moreover, Nebo's GPU execution can be up to 37x faster than its single-core execution. Finally, Wasatch (the pre-existing high-performance simulation project which uses Nebo) can scale up to 262K cores

    The Effect of the 2018 Tariffs on European Wine

    Get PDF
    This paper estimates a vector autoregression model for average wine prices across U.S. cities to assess the impact of tariff changes on the U.K., France, Germany, and Spain after they were enacted in October 2019. It uses impulse response functions to gauge how a one-unit impulse in the per-liter duty rate may effect the average wine price in the U.S. and the quantity of wine from various exporters to the U.S. It finds that a one-unit impulse in the duty rate levied against the bloc of countries impacted by the tariff results in a fall in the quantity of wine imported from those countries and that wine from the bloc of countries is substituted with wine from the top three exporters not included in the bloc

    Using models to model-check recursive schemes

    Full text link
    corecore