Mechanized Undecidability of Higher-Order Beta-Matching
Abstract
Higher-order -matching is the following decision problem: given two simply typed -terms, can the first term be instantiated to be -equivalent to the second term? This problem was formulated by Huet in the 1970s and shown undecidable by Loader in 2003 by reduction from -definability.
The present work provides a novel undecidability proof for higher-order -matching, in an effort to verify this result by means of a proof assistant. Rather than starting from -definability, the presented proof encodes a restricted form of string rewriting as higher-order -matching. The particular approach is similar to Urzyczyn’s undecidability result for intersection type inhabitation.
The presented approach has several advantages. First, the proof is simpler to verify in full detail due to the simple form of rewriting systems, which serve as a starting point. Second, undecidability of the considered problem in string rewriting is already certified using the Coq proof assistant. As a consequence, we obtain a certified many-one reduction from the Halting Problem to higher-order -matching. Third, the presented approach identifies a uniform construction which shows undecidability of higher-order -matching, -definability, and intersection type inhabitation.
The presented undecidability proof is mechanized in the Coq proof assistant and contributed to the existing Coq Library of Undecidability Proofs.
Keywords and phrases:
lambda-calculus, simple types, undecidability, higher-order matching, mechanization, Coq2012 ACM Subject Classification:
Theory of computation Lambda calculusSupplementary Material:
Software (Source Code): https://github.com/uds-psl/coq-library-undecidability/Acknowledgements:
I sincerely thank the anonymous reviewers for their constructive suggestions.Editors:
Maribel FernándezSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Higher-order -unification in the simply typed -calculus is the following decision problem: given two simply typed -terms , is there a substitution such that the instance is -equivalent to the instance ? Undecidability of higher-order -unification was established by Huet [9] in the 1970s, raising the question whether -matching [10] (the right-hand side term does not contain free variables) is decidable111Dowek [5] gives a comprehensive overview over unification and matching problems for the -calculus.. An equivalent presentation of higher-order -matching (cf. Statman’s range question [17]) is: given a term typed by the simple type and a term typed by the simple type , is there a term typed by the simple type such that is -equivalent to ?
Decidability of higher-order -matching was answered negatively222Not to be confused with the positive answer by Stirling [18] for higher-order -matching. by Loader [13] by reduction from -definability. Loader introduces intricate machinery to formulate -matching constraints which specify arbitrary finite functions. Later, Joly [11] refined Loader’s result, shifting technical challenges to underlying variant of -definability. The intricate machinery renders verification of both approaches by means of a proof assistant quite challenging.
The present work presents a novel proof of the undecidability of higher-order -matching, which is mechanized using the Coq proof assistant [19]. The mechanization leaves no room for ambiguities and potential errors, complementing existing work on mechanized undecidability of higher-order -unification [16].
The presented proof is not based on -definability; rather, we consider a known rewriting problem in a restricted class of semi-Thue systems [20, Lemma 2] as a starting point. The specific rewriting problem, referred to as , is: given a collection of rewrite rules of shape , where are alphabet symbols, is there a non-empty sequence of s which can be transformed into a non-empty sequence of s? As a consequence of the different starting point, the presented proof is simpler to verify in full detail and yields a concise mechanization. The mechanization is incorporated into the existing Coq Library of Undecidability Proofs [8], alongside the existing mechanization333The (Turing machine) Halting Problem is easily presented as Problem [6, Lemma 3.3]. of undecidability of the problem .
The main inspiration for the novel approach in the present work is Urzyczyn’s undecidability proof for intersection type inhabitation [20]. Considering the relationship between the intersection type discipline and finite model theory [15], the approach in the present work has an additional benefit: it is uniformly applicable to prove undecidability of higher-order -matching, intersection type inhabitation, and -definability.
Paper organization.
The present work is structured as follows:
- Section 2:
-
Preliminaries for the simply typed -calculus, higher-order -matching, and simple semi-Thue systems (including the undecidable Problem ).
- Section 3:
-
Reduction from Problem to higher-order -matching.
- Section 4:
-
Overview over the mechanization in the Coq proof assistant.
- Section 5:
-
Applicability to intersection type inhabitation and -definability.
- Section 6:
-
Concluding remarks.
2 Preliminaries
In this section we fix preliminaries and basic notation, following standard literature [2].
Higher-order -Matching in the Simply Typed -Calculus
The syntax of untyped -terms is given in the following Definition 1.
Substitution of the term variable in the term by the term is denoted .As usual, term application associates to the left, and we may group consecutive -abstractions. We commonly refer to the term as .
The -equivalence relation is the reflexive, transitive, symmetric closure of .
In the simply typed -calculus we may assign to a term a simple type in type environment , written . Similarly to prior work [13], one ground atom in the construction of simple types suffices for the negative result in the present work. Definition 5 contains the rules (Var), (I), and (E) of the simple type system.
The arrow type constructor associates to the right.
Definition 4 (Type Environments).
The following Example 6 illustrates a type derivation in the simple type system.
Example 6.
Higher-order -matching is the following typed unification problem, for which only one side is subject to instantiation.
Problem 7 (Higher-order -Matching ()).
Undecidability of higher-order -matching is shown by Loader [13] using a reduction from a variant of -definability.
Theorem 8 ([13, Theorem 5.5]).
Higher-order -matching is undecidable.
For the remainder of the present work we use the term matching in order to refer to higher-order -matching. Since simply typed terms are strongly normalizing and -reduction is confluent [2], the it suffices in Problem 7 to consider terms in normal form.
Let us get familiar with matching by means of several illustrating examples. The following Example 9 illustrates a positive matching instance.
Example 9.
Consider the terms and , for which we have and .
The matching instance is solvable, including the solution .To be precise, we have the following two properties:
-
(Example 6)
-
We want to encode certain functional behavior as a matching instance. The following Example 10 shows a naive approach to such an encoding and its limitations.
Example 10.
Let us associate elements of the set with projections , , and respectively. For the term we have , , and . Therefore, realizes a finite function such that , , and .
Let be a simple type for which we have for . Consider the matching instance , where , and for which we have . The intended “meaning” of this matching instance is: starting with the element , repeatedly apply the function in order to construct the element .
One solution for this instance is the term for which we have:
This solution follows the intended meaning of the underlying representation, constructing the element . Another solution is , which utilizes .
Unfortunately, there are solutions to the above matching instance which behave differently. One such solution is , for which we also have . In this case, the element is constructed “ad hoc”, with no reference to the provided arguments. Another solution is the term . This solution exploits the exact representation of elements via projections, disregarding any intended meaning of the underlying representation.
In the above Example 10 we would like to exclude certain ad hoc solutions, in order to faithfully encode intended functional behavior. Towards this aim, a known technique how to restrict the shape of solutions is illustrated in the following Example 11.
Example 11 ([5, Proposition 3.4]).
Consider a term in normal form such that where is a term variable, and . By case analysis on we have that for some term in normal form. Furthermore, and . Therefore, the term is not an abstraction. By induction on the size of and case analysis of the normal form we have that or . Since the term contains exactly two -abstractions, it cannot be an ad hoc solution from Example 10.
Combining Example 10 with Example 11, we formulate in the following Example 12 a matching instance which faithfully encodes the desired functional behavior.
Example 12.
Let and where the term is from Example 10. We have
The matching instance combines the matching instance from Example 10 with the additional restriction from Example 11. Therefore, solutions such as and from Example 10 which follow the intended “meaning” of the underlying representation still solve . However, ad hoc solutions such as or from Example 10 do not solve because such solutions contain too many -abstractions.
Remark 13.
The following Remark 14 illustrates how the addition of -reduction would make the technique from Example 12 (as well as Loader’s approach) unsuitable.
Remark 14.
Example 11 demonstrates how to restrict the number of abstractions in solutions. However, in the presence of -reduction (contextual closure of ) this does not work, as shown below. Consider the terms , , , and from Example 11. The term solves the matching instance in Example 12 because:
In particular, -reduction allows for additional -abstractions in the solution, making the technique from Example 11 unsuitable.
The observation from Example 12 is generalized by Loader to encode arbitrary families of finite functions. This results in undecidability of higher-order -matching by reduction from a variant of -definability. Loader’s generalization is quite sophisticated, as it requires construction principles to restrict shapes of realizers of arbitrary higher-order finite functions. In the present work, we focus on a fragment which can be identified by inspection of intersection types occurring in the undecidability proof of intersection type inhabitation [20, 6] and their relationship to finite model theory [15]. This leads to a simpler undecidability proof and reveals a connection between matching, intersection type inhabitation, and -definability. The presented approach has similarities with Joly’s [11] refinement of Loader’s proof. Joly shifts the technical burden to a particular -definability problem, which then is simpler to handle. Instead, we avoid -definability altogether and use a rewriting problem in a restricted class of simple semi-Thue systems as a starting point.
Simple Semi-Thue Systems
A simple semi-Thue system (Definition 15) is a rewriting system of restricted shape, introduced by Urzyczyn [20] in order to show undecidability of intersection type inhabitation.
Definition 15 (Simple Semi-Thue System).
The reflexive, transitive closure of the rewriting relation for a given simple semi-Thue system is denoted . For arbitrary simple semi-Thue systems it is undecidable whether some non-empty sequence of s can be transformed into a non-empty sequence of s.
Theorem 17 ([6, Lemma 3.3]).
The following Example 18 illustrates a positive instance of Problem .
Example 18.
Let be a simple semi-Thue system over the alphabet . We have . As a side note, we have for .
Remark 19.
Problem is used as a starting point in a refinement [6, Lemma 4.4] of Urzyczyn’s undecidability result for intersection type inhabitation [20]. Undecidability of Problem is mechanized as part of Coq Library of Undecidability Proofs [8], making it a good starting point for further mechanized undecidability results.
3 Undecidability of Higher-order -Matching
In this section we develop our main result (Theorem 39): a reduction from the rewriting problem to higher-order -matching.
For the remainder of the section we fix the simple semi-Thue system with rules over the finite alphabet . Our approach is to construct simply typed terms which capture the two main aspects of the rewriting problem : the search for a sufficiently long starting sequence of s, and the individual rewriting steps to the desired sequence of s.
The remainder of the present section is structured as follows. First, we fix basic notation, encoding, and properties of the rewriting in the system . Second, we restrict the shape of potential solutions for the constructed matching instance, similarly to Example 11. Third, for solutions of restricted shape we capture the functional properties of the rewriting problem .
Notation
We introduce four additional symbols in extended alphabet . We represent an alphabet symbol as the projection typed by the simple type . The intended meaning of the additional symbols in the extended alphabet is as follows. The symbol marks the beginning of a word for word expansion, serves as symbol different from and for case analysis, serves as a constructible symbol, and serves as a non-constructible symbol.
For readability, we use the following case notation to match individual symbols.
Definition 20 (case).
For , distinct , and terms :
A particular term for , which we use commonly is:
We have , and the following Lemma 21 specifies the behavior of .
Lemma 21.
For such that we have and .
Syntactic Constraints
We identify the shape of “well-formed” terms, suitable to represent rewriting. In the following Definition 22 terms in the set capture consecutive rule application for a word of length , ending in the word (represented by ). The subterm (and ) for and indicates an application of the rule at position . Additionally, terms in the set capture consecutive increase of word length starting with , and initialization with s before rewriting (represented by for ). Specifically, the subterm introduces an additional bound variable in order to argue about rule application at position in the longer word. Consequently, terms in represent witnesses for an arbitrary expansion of a word starting with length , followed by initialization with s, and consecutive rule application (potentially ending in s).
Definition 22 (Sets , of Terms).
For , let and be the smallest sets of terms satisfying the following rules:
-
-
if then for and
-
if then for and
-
if then
-
if then
Remark 23.
Free variables occurring in terms in and are assigned simple types according to the following type environment , such that terms in and can be assigned the simple type .
Similarly to Example 11, we formulate typed terms (Definition 25) and -equivalence constraints characterizing members of (Lemma 27) and (Lemma 28).
Definition 25 (Typed Terms , , ).
We introduce substitutions and acting on the term variables , which occur in terms in and .
Definition 26 (Substitutions , ).
Proof.
Induction on the size of and case analysis of the normal form.
Proof.
Induction on the size of , case analysis of the normal form, and Lemma 27.
Proof.
Induction on the size of , case analysis of the normal form, and Lemma 28.
Example 30.
Assume over the alphabet from Example 18. Let and . We have and . In congruence with Theorem 29 we have:
While Theorem 29 only establishes “well-formedness”, the term has an intended meaning: An initial word of length is expanded twice (using ) to a word of length and initialized to s (using ). The introduced variables and are used to address positions in the longer word. The intended meaning of is that the first rule (using ) is applied at position (using ), followed by the second rule at position , and third rule at position accordingly. The resulting word contains only s (indicated by ). Overall, this corresponds to .
Semantic Constraints
We formulate typed terms (Definition 31) and -equivalence constraints characterizing word expansion (Lemma 36) and rewriting (Lemma 34). The presented terms are programs which realize the intended meaning (Example 30) of “well-formed” terms in and . Specifically, realizes word expansion, realizes initialization with s, realizes rule application, and controls the effect at position for rule application at position . A word of length is represented by right-hand sides of -equivalences.
Definition 31 (Typed Terms , , , ).
Similarly to substitutions and , we introduce the following substitution .
The following Example 33 illustrates how the term represents rule application.
Example 33.
Consider for symbols an application of the rule at position in order to rewrite the word to . Accordingly, we have:
- Position :
-
- Position :
-
- Position :
-
- Position :
-
The above observation is generalized for terms in in the following Lemma 34.
Proof.
Induction on the size of and case analysis using Definition 22.
The following Example 35 builds upon the previous Example 30 and illustrates the intended meaning (rewriting s to s) of a “well-formed” example term in .
Example 35.
Assume over the alphabet , and consider the term from Example 30. Replacing accordingly for and , we have the following -equivalences – .
Complementarily to word rewriting, the following Lemma 36 characterizes word expansion and initialization with s.
Proof.
Considering the general case for , induction on the size of and case analysis using Definition 22.
The following Example 37 complements the previous Example 35 and illustrates the intended meaning (word expansion and initialization with s) of a “well-formed” term in .
Example 37.
Assume over the alphabet , and consider the terms , , , and from Example 35. Proceeding bottom up, we have and the following -equivalences hold:
Additionally, , , and the following -equivalences hold:
In combination with the previous Example 35, the term represents word expansion up to length , followed by initialization with s, and rewriting to s.
Next, we combine syntactic and semantic constraints in the following key Lemma 38.
Proof.
The direction from left to right proceeds in two steps. First, by induction on the number of rewriting steps we construct a term (easy converse of Lemma 34). Second, by induction on we construct a term containing as a subterm (easy converse of Lemma 36). Then, the solution is .
The direction from right to left proceeds in two steps. First, by Theorem 29 we have for some . Second, by Lemma 36 and Lemma 34 we have for some .
Finally, we present the combination of constraints from the above Lemma 38 as a matching instance . This constitutes the main result of the present work.
Proof.
Given a simple semi-Thue system due to Lemma 38 there exists an such that iff the instance of higher-order -matching is solvable, where
Theorem 40.
††margin: Higher-order -matching (Problem 7) is undecidable.
Proof.
4 Mechanization
This section provides a brief overview over the mechanization of undecidability of higher-order -matching (Theorem 40) using the Coq proof assistant [19]. The mechanization is constructive (in the technical sense of axiom-free Coq) and spans approximately lines of code, consisting of the following parts:
The simple type system stlc is mechanized in HOMatching.v, borrowing the existing term definitions from the library [ ], for which variable binding is addressed via the unscoped de Bruijn approach [4]. The proposition stlc Gamma M t mechanizes that the term M is assigned the simple type t in the simple type environment Gamma.
Higher-order -matching is mechanized as the predicate HOMbeta: given terms F of type arr s t and N of type t, is there a simply typed term M of type s such that app F M is -equivalent (reflexive, symmetric, transitive closure of step) to N?
The proposition undecidable HOMbeta [ ] mechanizes the undecidability of the predicate HOMbeta, relying on the following library definition [7, Chapter 19]. A predicate p is undecidable, if existence of a computable decider for p implies recursive co-enumerability of the (Turing machine) Halting Problem.
Since the Halting Problem is recursively enumerable, decidability of p would imply decidability of the Halting Problem.
5 On Intersection Type Inhabitation and -Definability
We conclude the technical presentation with the following observation: the presented approach reducing Problem to higher-order -matching is easily transferred to intersection type inhabitation and -definability.
The following Remark 41 shows the structure of the corresponding finite model with respect to the present construction.
Remark 41.
Terms in Definition 31 realize certain finite functions as follows.
-
for realizes a member of the finite function family specified by the partial function table .
-
realizes a member of the family specified by .
-
realizes a member of the family specified by .
-
realizes a member of the family specified by .
The above specifications follow the intended meaning (Example 30) of the corresponding programs, when used in “well-formed” terms in and . For example, we have , in agreement with the above Remark 41.
Let us state the relationship between simple semi-Thue system rewriting, higher-order -matching, -definability, and intersection type inhabitation.
Proposition 42.
Given a simple semi-Thue system , one can construct simply typed terms and , an intersection type , and a finite function such that the following statements are equivalent:
-
1.
There exists an such that .
-
2.
The instance of higher-order -matching is solvable.
-
3.
The intersection type is inhabited.
-
4.
The finite function is -definable.
The presented approach shows . Of course, can be concluded from undecidability of intersection type inhabitation [20] and from undecidability of -definability [12], along with corresponding constructions. However, we make the following two observations regarding an alternative, uniform argument. First, based on Remark 23, the approach is easily adapted to show , such that the inhabitant is essentially a member of . This is already done in the existing mechanized reduction from Problem to intersection type inhabitation [ ]. Second, based on Remark 41, the approach can be adapted to show , such that the realizer is essentially a member of . This is further supported by the known correspondence between intersection type inhabitation (in the fragment at hand) and -definability [15].
6 Conclusion
The present work presents a new, mechanized proof of the undecidability of higher-order -matching. The mechanization is contributed to the existing Coq Library of Undecidability Proofs [8].
While the existing proofs by Loader [13] and by Joly [11] are each based on variants of -definability, the presented proof reduces a rewriting problem (Problem ) to higher-order -matching. As a result, the proof is simpler to verify in full detail and yields a concise mechanization. Additionally, undecidability of Problem is already mechanized, and is part of the Coq Library of Undecidability Proofs.
Besides the main technical result, we argue that the present approach is uniformly applicable to show undecidability of intersection type inhabitation and -definability. The former is already established and implemented as refinement [6] of Urzyczyn’s undecidability result [20]. The latter is an application of the known correspondence between intersection type inhabitation and -definability [15].
The order of a type is the maximal nesting depth of the arrow type constructor to the left, starting by . The present approach agrees with Loader’s result that -matching is undecidable at order . While Loader conjectures that order may suffice, neither Loader’s technique (as observed by Joly [11, Section 5]), nor the present approach are applicable at order . Constraining the shape of candidate solutions both in the present work as well as in Loader’s proof seems to necessitate order . While -matching at order is decidable [14], decidability at order remains an open question.
As pointed out in Remark 13, the presented approach might be adapted to scenarios beyond the simply typed -calculus. An interesting alternative to the simple type system is the Coppo-Dezani intersection type assignment system [3], which characterizes strong normalization [1]. Well-typedness in this system would allow for more solution candidates and require more effort with respect to syntactic constraints (cf. Section 3). It is reasonable to believe that higher-order -matching is undecidable in any type system for the -calculus which includes the simple type system.
Interaction with a proof assistant supported the conception of the present approach both at the intuitive and at the technical level. The infrastructure for the -calculus provided by the undecidability library served as an excellent starting point for the development. While proofs of the individual lemmas (cf. Section 3) in the development are quite simplistic, they involve exhaustive case analyses and are sensitive to the exact details of the underlying construction. Bookkeeping capabilities of the Coq proof assistant, proof automation based on auto and lia tactics, and quick adaptability to an evolving construction were of great benefit. Additionally, once all cases are covered, there is no room for doubt that the construction is correct. As a result, the proof was developed via interaction with the proof assistant prior to being transcribed into a traditional written format.
References
- [1] Roberto M. Amadio and Pierre-Louis Curien. Domains and lambda-calculi, volume 46 of Cambridge tracts in theoretical computer science. Cambridge University Press, 1998.
- [2] Hendrik Pieter Barendregt, Wil Dekkers, and Richard Statman. Lambda Calculus with Types. Perspectives in logic. Cambridge University Press, 2013. URL: http://www.cambridge.org/de/academic/subjects/mathematics/logic-categories-and-sets/lambda-calculus-types.
- [3] Mario Coppo and Mariangiola Dezani-Ciancaglini. An extension of the basic functionality theory for the lambda-calculus. Notre Dame Journal of Formal Logic, 21(4):685–693, 1980. doi:10.1305/ndjfl/1093883253.
- [4] Nicolaas Govert De Bruijn. Lambda calculus notation with nameless dummies, a tool for automatic formula manipulation, with application to the Church-Rosser theorem. In Indagationes Mathematicae (Proceedings), volume 75, pages 381–392. North-Holland, 1972.
- [5] Gilles Dowek. Higher-order unification and matching. In John Alan Robinson and Andrei Voronkov, editors, Handbook of Automated Reasoning (in 2 volumes), pages 1009–1062. Elsevier and MIT Press, 2001. doi:10.1016/B978-044450813-3/50018-7.
- [6] Andrej Dudenhefner and Jakob Rehof. Undecidability of intersection type inhabitation at rank 3 and its formalization. Fundam. Informaticae, 170(1-3):93–110, 2019. doi:10.3233/FI-2019-1856.
- [7] Yannick Forster. Computability in constructive type theory. Die Publikationen der UdS, 2021. doi:10.22028/D291-35758.
- [8] Yannick Forster, Dominique Larchey-Wendling, Andrej Dudenhefner, Edith Heiter, Dominik Kirst, Fabian Kunze, Gert Smolka, Simon Spies, Dominik Wehr, and Maximilian Wuttke. A Coq library of undecidable problems. In The Sixth International Workshop on Coq for Programming Languages (CoqPL 2020), 2020. URL: https://github.com/uds-psl/coq-library-undecidability.
- [9] Gérard P. Huet. The undecidability of unification in third order logic. Inf. Control., 22(3):257–267, 1973. doi:10.1016/S0019-9958(73)90301-X.
- [10] Gérard P. Huet. A unification algorithm for typed lambda-calculus. Theor. Comput. Sci., 1(1):27–57, 1975. doi:10.1016/0304-3975(75)90011-0.
- [11] Thierry Joly. On lambda-definability I: the fixed model problem and generalizations of the matching problem. Fundam. Informaticae, 65(1-2):135–151, 2005. URL: http://content.iospress.com/articles/fundamenta-informaticae/fi65-1-2-07.
- [12] Ralph Loader. The undecidability of -definability. In Logic, meaning and computation: Essays in memory of Alonzo church, pages 331–342. Springer, 2001.
- [13] Ralph Loader. Higher order beta matching is undecidable. Log. J. IGPL, 11(1):51–68, 2003. doi:10.1093/JIGPAL/11.1.51.
- [14] Vincent Padovani. Decidability of fourth-order matching. Mathematical Structures in Computer Science, 10(3):361–372, 2000. URL: http://journals.cambridge.org/action/displayAbstract?aid=44653.
- [15] Sylvain Salvati, Giulio Manzonetto, Mai Gehrke, and Henk Barendregt. Loader and Urzyczyn are logically related. In Artur Czumaj, Kurt Mehlhorn, Andrew M. Pitts, and Roger Wattenhofer, editors, Automata, Languages, and Programming - 39th International Colloquium, ICALP 2012, Warwick, UK, July 9-13, 2012, Proceedings, Part II, volume 7392 of Lecture Notes in Computer Science, pages 364–376. Springer, 2012. doi:10.1007/978-3-642-31585-5_34.
- [16] Simon Spies and Yannick Forster. Undecidability of higher-order unification formalised in Coq. In Jasmin Blanchette and Catalin Hritcu, editors, Proceedings of the 9th ACM SIGPLAN International Conference on Certified Programs and Proofs, CPP 2020, New Orleans, LA, USA, January 20-21, 2020, pages 143–157. ACM, 2020. doi:10.1145/3372885.3373832.
- [17] Richard Statman. Completeness, invariance and lambda-definability. J. Symb. Log., 47(1):17–26, 1982. doi:10.2307/2273377.
- [18] Colin Stirling. Decidability of higher-order matching. Log. Methods Comput. Sci., 5(3), 2009. URL: http://arxiv.org/abs/0907.3804.
- [19] The Coq Development Team. The Coq proof assistant, July 2023. doi:10.5281/zenodo.8161141.
- [20] Paweł Urzyczyn. Inhabitation of low-rank intersection types. In Pierre-Louis Curien, editor, Typed Lambda Calculi and Applications, 9th International Conference, TLCA 2009, Brasilia, Brazil, July 1-3, 2009. Proceedings, volume 5608 of Lecture Notes in Computer Science, pages 356–370. Springer, 2009. doi:10.1007/978-3-642-02273-9_26.
