Papers for

program analysis teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Call-by-value evaluation precisely measured and linked to program termination

A Quantitative Interpretation of Useful Call-by-Value

Abstract: In this work, we present the first semantic interpretation of useful call-by-value evaluation through a non-idempotent intersection type system called U. One first contribution of this paper is a characterisation of termination of useful call-by-value evaluation via U-typability. That is, a term is typable in system U if and only if it terminates in the useful call-by-value strategy. As a second contribution, we show that system U provides a quantitative interpretation for useful call-by-value evaluation, offering exact step-count information for program evaluation. Even though the specification of the operational semantics of useful evaluation is highly complex, system U is notably simple. As far as we know, system U is one of the scarce quantitative type systems capturing exactly the substitution step-count for variables and abstractions in an open call-by-value strategy. Our third contribution is a termination-equivalence result between standard call-by-value, which may perform erasing reductions, and useful call-by-value, which is non-erasing. To establish this result, we introduce a non-erasing restriction of standard call-by-value, a refinement that serves as an intermediate calculus bridging standard and useful call-by-value. We show that all three calculi have the same termination behaviour, and hence induce the same observational equivalence.

Thu 29 OctLogic in Computer Science
The gist
Some programs stop running (terminate), and others keep going forever. This paper shows a way to tell exactly which programs stop when evaluated with a certain method called useful call-by-value. The authors create a simple system that can count exactly how many steps it takes to run a program using this method. They also prove that different evaluation methods with subtle rules about erasing parts of programs behave the same in terms of whether programs stop or not. This helps us better understand how programs run and when they finish.
Open → 2610.40154v1

Pattern-based tree transformations type-checking made decidable

Type-Checking for Pattern-Based Tree Transformations

Abstract: We introduce and study pattern-based tree transformations. As an illustrating example, consider a source pattern $(x \cdot y) + (x \cdot z)$ and a target pattern $x \cdot (y + z)$ as a pair. This source pattern matches any expression $e$ of the form $(e_1 \cdot e_2) + (e_1 \cdot e_3)$ (by substituting $x$ with $e_1$, $y$ with $e_2$, and $z$ with $e_3$) and the pair transforms it into the expression $e_1 \cdot (e_2 + e_3)$ as dictated by the target pattern. Note that in this example, the set of expressions that match the source pattern is not a regular tree language. We propose a model of tree transformations given by a finite representation of a (possibly infinite) set of such (source pattern, target pattern) pairs. The expressive power of this model comes at the cost of undecidability of checking equivalence. Nevertheless, we show that the type-checking problem is decidable for our model of pattern-based tree transformations. The type-checking problem asks whether applying a given transformation to trees having a given regular property (type) preserves the property. Our decision procedure is by a reduction to the emptiness problem of alternating tree automata.

Thu 8 OctFormal Languages and Automata TheoryComputation and Language
The gist
The paper deals with a way to change tree-structured data by matching and rewriting patterns, like turning parts of a math expression into a simpler form. The authors look at complicated patterns that can match many trees, even infinitely many, which makes checking if two transformations are the same impossible. However, they found that you can still decide if a transformation always keeps certain tree properties intact, which helps ensure safe changes to data structures. They do this by converting the problem into one related to special tree automata, a kind of computational model.
Open → 2610.11337v1