220 research outputs found
Towards Strong Normalization for Dependent Object Types (DOT)
The Dependent Object Types (DOT) family of calculi has been proposed as a new theoretic foundation for Scala and similar languages, unifying functional programming, object oriented programming and ML-style module systems. Following the recent type soundness proof for
DOT, the present paper aims to establish stronger meta-theoretic properties. The main result is a fully mechanized proof of strong normalization for D_<:, a variant of DOT that excludes recursive functions and recursive types. We further discuss techniques and challenges for adding recursive types while maintaining strong normalization, and demonstrate that certain variants of recursive self types can be integrated successfully
A GNN Based Approach to LTL Model Checking
Model Checking is widely applied in verifying complicated and especially
concurrent systems. Despite of its popularity, model checking suffers from the
state space explosion problem that restricts it from being applied to certain
systems, or specifications. Many works have been proposed in the past to
address the state space explosion problem, and they have achieved some success,
but the inherent complexity still remains an obstacle for purely symbolic
approaches. In this paper, we propose a Graph Neural Network (GNN) based
approach for model checking, where the model is expressed using a B{\"u}chi
automaton and the property to be verified is expressed using Linear Temporal
Logic (LTL). We express the model as a GNN, and propose a novel node embedding
framework that encodes the LTL property and characteristics of the model. We
reduce the LTL model checking problem to a graph classification problem, where
there are two classes, 1 (if the model satisfies the specification) and 0 (if
the model does not satisfy the specification). The experimental results show
that our framework is up to 17 times faster than state-of-the-art tools. Our
approach is particularly useful when dealing with very large LTL formulae and
small to moderate sized models
Towards Strong Normalization for Dependent Object Types (DOT) (Artifact)
This artifact provides the fully mechanized proof of strong normalization for D_{<:}a variant of (Dependent Object Types) DOT (Rompf & Amin, 2016) that excludes recursive functions and recursive types. The intersection type and recursive self type are further integrated, moving towards DOT. The key proof idea follows the method of Girard (Girard, 1972) and Tait (Tait, 1967)
Recommended from our members
Collapsing towers of interpreters
Given a tower of interpreters, i.e., a sequence of multiple interpreters interpreting one another as input programs, we aim to collapse this tower into a compiler that removes all interpretive overhead and runs in a single pass. In the real world, a use case might be Python code executed by an x86 runtime, on a CPU emulated in a JavaScript VM, running on an ARM CPU. Collapsing such a tower can not only exponentially improve runtime performance, but also enable the use of base-language tools for interpreted programs, e.g., for analysis and verification. In this paper, we lay the foundations in an idealized but realistic setting.
We present a multi-level lambda calculus that features staging constructs and stage polymorphism: based on runtime parameters, an evaluator either executes source code (thereby acting as an interpreter) or generates code (thereby acting as a compiler). We identify stage polymorphism, a programming model from the domain of high-performance program generators, as the key mechanism to make such interpreters compose in a collapsible way.
We present Pink, a meta-circular Lisp-like evaluator on top of this calculus, and demonstrate that we can collapse arbitrarily many levels of self-interpretation, including levels with semantic modifications. We discuss several examples: compiling regular expressions through an interpreter to base code, building program transformers from modi ed interpreters, and others. We develop these ideas further to include reflection and reification, culminating in Purple, a reflective language inspired by Brown, Blond, and Black, which realizes a conceptually infinite tower, where every aspect of the semantics can change dynamically. Addressing an open challenge, we show how user programs can be compiled and recompiled under user-modified semantics.Parts of this research were supported by ERC grant 321217, NSF awards 1553471 and 1564207, and DOE award DE-SC0018050
Fubini's Theorem for Daniell Integrals
We show that in the theory of Daniell integration iterated integrals may
always be formed, and the order of integration may always be interchanged. By
this means, we discuss product integrals and show that the related Fubini
theorem holds in full generality. The results build on a density theorem on
Riesz tensor products due to Fremlin, and on the Fubini-Stone Theorem.Comment: 9 pages, version, as to appear in Archiv der Mathemati
Building-Blocks for Performance Oriented DSLs
Domain-specific languages raise the level of abstraction in software
development. While it is evident that programmers can more easily reason about
very high-level programs, the same holds for compilers only if the compiler has
an accurate model of the application domain and the underlying target platform.
Since mapping high-level, general-purpose languages to modern, heterogeneous
hardware is becoming increasingly difficult, DSLs are an attractive way to
capitalize on improved hardware performance, precisely by making the compiler
reason on a higher level. Implementing efficient DSL compilers is a daunting
task however, and support for building performance-oriented DSLs is urgently
needed. To this end, we present the Delite Framework, an extensible toolkit
that drastically simplifies building embedded DSLs and compiling DSL programs
for execution on heterogeneous hardware. We discuss several building blocks in
some detail and present experimental results for the OptiML machine-learning
DSL implemented on top of Delite.Comment: In Proceedings DSL 2011, arXiv:1109.032
- …