680 research outputs found
The Algebraic Intersection Type Unification Problem
The algebraic intersection type unification problem is an important component
in proof search related to several natural decision problems in intersection
type systems. It is unknown and remains open whether the algebraic intersection
type unification problem is decidable. We give the first nontrivial lower bound
for the problem by showing (our main result) that it is exponential time hard.
Furthermore, we show that this holds even under rank 1 solutions (substitutions
whose codomains are restricted to contain rank 1 types). In addition, we
provide a fixed-parameter intractability result for intersection type matching
(one-sided unification), which is known to be NP-complete.
We place the algebraic intersection type unification problem in the context
of unification theory. The equational theory of intersection types can be
presented as an algebraic theory with an ACI (associative, commutative, and
idempotent) operator (intersection type) combined with distributivity
properties with respect to a second operator (function type). Although the
problem is algebraically natural and interesting, it appears to occupy a
hitherto unstudied place in the theory of unification, and our investigation of
the problem suggests that new methods are required to understand the problem.
Thus, for the lower bound proof, we were not able to reduce from known results
in ACI-unification theory and use game-theoretic methods for two-player tiling
games
Semantic subtyping for objects and classes
In this paper we propose an integration of structural subtyping with boolean
connectives and semantic subtyping to define a Java-like programming language
that exploits the benefits of both techniques. Semantic subtyping is an approach
for defining subtyping relation based on set-theoretic models, rather than syntactic
rules. On the one hand, this approach involves some non trivial mathematical
machinery in the background. On the other hand, final users of the language need
not know this machinery and the resulting subtyping relation is very powerful and
intuitive. While semantic subtyping is naturally linked to the structural one, we
show how our framework can also accommodate the nominal subtyping. Several
examples show the expressivity and the practical advantages of our proposal
First-order theory of subtyping constraints
We investigate the first-order theory of subtyping constraints. We show that the first-order theory of non-structural subtyping is undecidable, and we show that in the case where all constructors are either unary or nullary, the first-order theory is decidable for both structural and non-structural subtyping. The decidability results are shown by reduction to a decision problem on tree automata. This work is a step towards resolving long-standing open problems of the decidability of entailment for non-structural subtyping
On Satisfiability of Nominal Subtyping with Variance
Nominal type systems with variance, the core of the subtyping relation in object-oriented programming languages like Java, C# and Scala, have been extensively studied by Kennedy and Pierce: they have shown the undecidability of the subtyping between ground types and proposed the decidable fragments of such type systems. However, modular verification of object-oriented code may require reasoning about the relations of open types. In this paper, we formalize and investigate the satisfiability problem for nominal subtyping with variance. We define the problem in the context of first-order logic. We show that although the non-expansive ground nominal subtyping with variance is decidable, its satisfiability problem is undecidable. Our proof uses a remarkably small fragment of the type system. In fact, we demonstrate that even for the non-expansive class tables with only nullary and unary covariant and invariant type constructors, the satisfiability of quantifier-free conjunctions of positive subtyping atoms is undecidable. We discuss this result in detail, as well as show one decidable fragment and a scheme for obtaining other decidable fragments
Using higher-order contracts to model session types
Session types are used to describe and structure interactions between
independent processes in distributed systems. Higher-order types are needed in
order to properly structure delegation of responsibility between processes.
In this paper we show that higher-order web-service contracts can be used to
provide a fully-abstract model of recursive higher-order session types. The
model is set-theoretic, in the sense that the meaning of a contract is given in
terms of the set of contracts with which it complies.
The proof of full-abstraction depends on a novel notion of the complement of
a contract. This in turn gives rise to an alternative to the type duality
commonly used in systems for type-checking session types. We believe that the
notion of complement captures more faithfully the behavioural intuition
underlying type duality.Comment: Added definitions of m-closed terms, of 'dual', and a discussion to
show the problems of the complement functio
Higher-order subtyping and its decidability
AbstractWe define the typed lambda calculus FÏ⧠(F-omega-meet), a natural generalization of Girard's system FÏ (F-omega) with intersection types and bounded polymorphism. A novel aspect of our presentation is the use of term rewriting techniques to present intersection types, which clearly splits the computational semantics (reduction rules) from the syntax (inference rules) of the system. We establish properties such as Church-Rosser for the reduction relation on types and terms, and strong normalization for the reduction on types. We prove that types are preserved by computation (subject reduction), and that the system satisfies the minimal types property. We define algorithms for type checking and subtype checking. The development culminates with the proof of decidability of typing in FÏâ§, containing the first proof of decidability of subtyping of a higher-order lambda calculus with subtyping
Predicate Abstraction for Linked Data Structures
We present Alias Refinement Types (ART), a new approach to the verification
of correctness properties of linked data structures. While there are many
techniques for checking that a heap-manipulating program adheres to its
specification, they often require that the programmer annotate the behavior of
each procedure, for example, in the form of loop invariants and pre- and
post-conditions. Predicate abstraction would be an attractive abstract domain
for performing invariant inference, existing techniques are not able to reason
about the heap with enough precision to verify functional properties of data
structure manipulating programs. In this paper, we propose a technique that
lifts predicate abstraction to the heap by factoring the analysis of data
structures into two orthogonal components: (1) Alias Types, which reason about
the physical shape of heap structures, and (2) Refinement Types, which use
simple predicates from an SMT decidable theory to capture the logical or
semantic properties of the structures. We prove ART sound by translating types
into separation logic assertions, thus translating typing derivations in ART
into separation logic proofs. We evaluate ART by implementing a tool that
performs type inference for an imperative language, and empirically show, using
a suite of data-structure benchmarks, that ART requires only 21% of the
annotations needed by other state-of-the-art verification techniques
- âŠ