71 research outputs found
Encoding Tight Typing in a Unified Framework
This paper explores how the intersection type theories of call-by-name (CBN) and call-by-value (CBV) can be unified in a more general framework provided by call-by-push-value (CBPV). Indeed, we propose tight type systems for CBN and CBV that can be both encoded in a unique tight type system for CBPV. All such systems are quantitative, i.e. they provide exact information about the length of normalization sequences to normal form as well as the size of these normal forms. Moreover, the length of reduction sequences are discriminated according to their multiplicative and exponential nature, a concept inherited from linear logic. Last but not least, it is possible to extract quantitative measures for CBN and CBV from their corresponding encodings in CBPV
Proofs and Refutations for Intuitionistic and Second-Order Logic
The ?^{PRK}-calculus is a typed ?-calculus that exploits the duality between the notions of proof and refutation to provide a computational interpretation for classical propositional logic. In this work, we extend ?^{PRK} to encompass classical second-order logic, by incorporating parametric polymorphism and existential types. The system is shown to enjoy good computational properties, such as type preservation, confluence, and strong normalization, which is established by means of a reducibility argument. We identify a syntactic restriction on proofs that characterizes exactly the intuitionistic fragment of second-order ?^{PRK}, and we study canonicity results
Using Rewrite Strategies for Efficient Functional Automatic Differentiation
Automatic Differentiation (AD) has become a dominant technique in ML. AD
frameworks have first been implemented for imperative languages using tapes.
Meanwhile, functional implementations of AD have been developed, often based on
dual numbers, which are close to the formal specification of differentiation
and hence easier to prove correct. But these papers have focussed on
correctness not efficiency. Recently, it was shown how an approach using dual
numbers could be made efficient through the right optimizations. Optimizations
are highly dependent on order, as one optimization can enable another. It can
therefore be useful to have fine-grained control over the scheduling of
optimizations. One method expresses compiler optimizations as rewrite rules,
whose application can be combined and controlled using strategy languages.
Previous work describes the use of term rewriting and strategies to generate
high-performance code in a compiler for a functional language. In this work, we
implement dual numbers AD in a functional array programming language using
rewrite rules and strategy combinators for optimization. We aim to combine the
elegance of differentiation using dual numbers with a succinct expression of
the optimization schedule using a strategy language. We give preliminary
evidence suggesting the viability of the approach on a micro-benchmark.Comment: to be published in FTfJP 202
The (In)Efficiency of interaction
Evaluating higher-order functional programs through abstract machines inspired by the geometry of the interaction is known to induce space efficiencies, the price being time performances often poorer than those obtainable with traditional, environment-based, abstract machines. Although families of lambda-terms for which the former is exponentially less efficient than the latter do exist, it is currently unknown how general this phenomenon is, and how far the inefficiencies can go, in the worst case. We answer these questions formulating four different well-known abstract machines inside a common definitional framework, this way being able to give sharp results about the relative time efficiencies. We also prove that non-idempotent intersection type theories are able to precisely reflect the time performances of the interactive abstract machine, this way showing that its time-inefficiency ultimately descends from the presence of higher-order types
Natural Colors of Infinite Words
While finite automata have minimal DFAs as a simple and natural normal form,
deterministic omega-automata do not currently have anything similar. One reason
for this is that a normal form for omega-regular languages has to speak about
more than acceptance - for example, to have a normal form for a parity
language, it should relate every infinite word to some natural color for this
language. This raises the question of whether or not a concept such as a
natural color of an infinite word (for a given language) exists, and, if it
does, how it relates back to automata.
We define the natural color of a word purely based on an omega-regular
language, and show how this natural color can be traced back from any
deterministic parity automaton after two cheap and simple automaton
transformations. The resulting streamlined automaton does not necessarily
accept every word with its natural color, but it has a 'co-run', which is like
a run, but can once move to a language equivalent state, whose color is the
natural color, and no co-run with a higher color exists.
The streamlined automaton defines, for every color c, a good-for-games
co-B\"uchi automaton that recognizes the words whose natural colors w.r.t. the
represented language are at least c. This provides a canonical representation
for every -regular language, because good-for-games co-B\"uchi automata
have a canonical minimal (and cheap to obtain) representation for every
co-B\"uchi language
A Recursive Approach to Solving Parity Games in Quasipolynomial Time
Zielonka's classic recursive algorithm for solving parity games is perhaps the simplest among the many existing parity game algorithms. However, its complexity is exponential, while currently the state-of-the-art algorithms have quasipolynomial complexity. Here, we present a modification of Zielonka's classic algorithm that brings its complexity down to , for parity games of size with priorities, in line with previous quasipolynomial-time solutions.</jats:p
- âŠ