6,039 research outputs found
Untyped Recursion Schemes and Infinite Intersection Types
Abstract. A new framework for higher-order program verification has been recently proposed, in which higher-order functional programs are modelled as higher-order recursion schemes and then model-checked. As recursion schemes are essentially terms of the simply-typed lambda-calculus with recursion and tree constructors, however, it was not clear how the new framework applies to programs written in languages with more advanced type systems. To circumvent the limitation, this paper introduces an untyped version of recursion schemes and develops an in-finite intersection type system that is equivalent to the model checking of untyped recursion schemes, so that the model checking can be re-duced to type checking as in recent work by Kobayashi and Ong for typed recursion schemes. The type system is undecidable but we can obtain decidable subsets of the type system by restricting the shapes of intersection types, yielding a sound (but incomplete in general) model checking algorithm.
Saturation-Based Model Checking of Higher-Order Recursion Schemes
Model checking of higher-order recursion schemes (HORS) has recently been studied extensively and applied to higher-order program verification. Despite recent efforts, obtaining a scalable model checker for HORS remains a big challenge. We propose a new model checking algorithm for HORS, which combines two previous, independent approaches to higher-order model checking. Like previous type-based algorithms for HORS, it directly analyzes HORS and outputs intersection types as a certificate, but like Broadbent et al.\u27s saturation algorithm for collapsible pushdown systems (CPDS), it propagates information backward, in the sense that it starts with target configurations and iteratively computes their pre-images. We have implemented the new algorithm and confirmed that the prototype often outperforms TRECS and CSHORe, the state-of-the-art model checkers for HORS
Soft Contract Verification
Behavioral software contracts are a widely used mechanism for governing the
flow of values between components. However, run-time monitoring and enforcement
of contracts imposes significant overhead and delays discovery of faulty
components to run-time.
To overcome these issues, we present soft contract verification, which aims
to statically prove either complete or partial contract correctness of
components, written in an untyped, higher-order language with first-class
contracts. Our approach uses higher-order symbolic execution, leveraging
contracts as a source of symbolic values including unknown behavioral values,
and employs an updatable heap of contract invariants to reason about
flow-sensitive facts. We prove the symbolic execution soundly approximates the
dynamic semantics and that verified programs can't be blamed.
The approach is able to analyze first-class contracts, recursive data
structures, unknown functions, and control-flow-sensitive refinements of
values, which are all idiomatic in dynamic languages. It makes effective use of
an off-the-shelf solver to decide problems without heavy encodings. The
approach is competitive with a wide range of existing tools---including type
systems, flow analyzers, and model checkers---on their own benchmarks.Comment: ICFP '14, September 1-6, 2014, Gothenburg, Swede
Indexed linear logic and higher-order model checking
In recent work, Kobayashi observed that the acceptance by an alternating tree
automaton A of an infinite tree T generated by a higher-order recursion scheme
G may be formulated as the typability of the recursion scheme G in an
appropriate intersection type system associated to the automaton A. The purpose
of this article is to establish a clean connection between this line of work
and Bucciarelli and Ehrhard's indexed linear logic. This is achieved in two
steps. First, we recast Kobayashi's result in an equivalent infinitary
intersection type system where intersection is not idempotent anymore. Then, we
show that the resulting type system is a fragment of an infinitary version of
Bucciarelli and Ehrhard's indexed linear logic. While this work is very
preliminary and does not integrate key ingredients of higher-order
model-checking like priorities, it reveals an interesting and promising
connection between higher-order model-checking and linear logic.Comment: In Proceedings ITRS 2014, arXiv:1503.0437
Relational semantics of linear logic and higher-order model-checking
In this article, we develop a new and somewhat unexpected connection between
higher-order model-checking and linear logic. Our starting point is the
observation that once embedded in the relational semantics of linear logic, the
Church encoding of any higher-order recursion scheme (HORS) comes together with
a dual Church encoding of an alternating tree automata (ATA) of the same
signature. Moreover, the interaction between the relational interpretations of
the HORS and of the ATA identifies the set of accepting states of the tree
automaton against the infinite tree generated by the recursion scheme. We show
how to extend this result to alternating parity automata (APT) by introducing a
parametric version of the exponential modality of linear logic, capturing the
formal properties of colors (or priorities) in higher-order model-checking. We
show in particular how to reunderstand in this way the type-theoretic approach
to higher-order model-checking developed by Kobayashi and Ong. We briefly
explain in the end of the paper how his analysis driven by linear logic results
in a new and purely semantic proof of decidability of the formulas of the
monadic second-order logic for higher-order recursion schemes.Comment: 24 pages. Submitte
Using models to model-check recursive schemes
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
On the Termination Problem for Probabilistic Higher-Order Recursive Programs
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
Type-Based Termination, Inflationary Fixed-Points, and Mixed Inductive-Coinductive Types
Type systems certify program properties in a compositional way. From a bigger
program one can abstract out a part and certify the properties of the resulting
abstract program by just using the type of the part that was abstracted away.
Termination and productivity are non-trivial yet desired program properties,
and several type systems have been put forward that guarantee termination,
compositionally. These type systems are intimately connected to the definition
of least and greatest fixed-points by ordinal iteration. While most type
systems use conventional iteration, we consider inflationary iteration in this
article. We demonstrate how this leads to a more principled type system, with
recursion based on well-founded induction. The type system has a prototypical
implementation, MiniAgda, and we show in particular how it certifies
productivity of corecursive and mixed recursive-corecursive functions.Comment: In Proceedings FICS 2012, arXiv:1202.317
- …