Recursive Types Research Articles

On the Semantic Expressiveness of Iso- and Equi-Recursive Types

Recursive types extend the simply-typed lambda calculus (STLC) with the additional expressive power to enable diverging computation and to encode recursive data-types (e.g., lists). Two formulations of recursive types exist: iso-recursive and equi-recursive. The relative advantages of iso- and equi-recursion are well-studied when it comes to their impact on type-inference. However, the relative semantic expressiveness of the two formulations remains unclear so far. This paper studies the semantic expressiveness of STLC with iso- and equi-recursive types, proving that these formulations are equally expressive. In fact, we prove that they are both as expressive as STLC with only term-level recursion. We phrase these equi-expressiveness results in terms of full abstraction of three canonical compilers between these three languages (STLC with iso-, with equi-recursive types and with term-level recursion). Our choice of languages allows us to study expressiveness when interacting over both a simply-typed and a recursively-typed interface. The three proofs all rely on a typed version of a proof technique called approximate backtranslation. Together, our results show that there is no difference in semantic expressiveness between STLCs with iso- and equi-recursive types. In this paper, we focus on a simply-typed setting but we believe our results scale to more powerful type systems like System F.

Automatic differentiation for ML-family languages: Correctness via logical relations

Abstract We give a simple, direct, and reusable logical relations technique for languages with term and type recursion and partially defined differentiable functions. We demonstrate it by working out the case of automatic differentiation (AD) correctness: namely, we present a correctness proof of a dual numbers style AD code transformation for realistic functional languages in the ML-family. We also show how this code transformation provides us with correct forward- and reverse-mode AD. The starting point is to interpret a functional programming language as a suitable freely generated categorical structure. In this setting, by the universal property of the syntactic categorical structure, the dual numbers AD code transformation and the basic $\boldsymbol{\omega } \mathbf{Cpo}$ -semantics arise as structure preserving functors. The proof follows, then, by a novel logical relations argument. The key to much of our contribution is a powerful monadic logical relations technique for term recursion and recursive types. It provides us with a semantic correctness proof based on a simple approach for denotational semantics, making use only of the very basic concrete model of $\omega$ -cpos.

Stochastic representation for solutions of a system of coupled HJB-Isaacs equations with integral–differential operators

In this paper, we focus on the stochastic representation of a system of coupled Hamilton–Jacobi–Bellman–Isaacs (HJB–Isaacs (HJBI), for short) equations which is in fact a system of coupled Isaacs’ type integral-partial differential equation. For this, we introduce an associated zero-sum stochastic differential game, where the state process is described by a classical stochastic differential equation (SDE, for short) with jumps, and the cost functional of recursive type is defined by a new type of backward stochastic differential equation (BSDE, for short) with two Poisson random measures, whose wellposedness and a prior estimate as well as the comparison theorem are investigated for the first time. One of the Poisson random measures μ appearing in the SDE and the BSDE stems from the integral term of the HJBI equations; the other random measure in BSDE is introduced to link the coupling factor of the HJBI equations. We show through an extension of the dynamic programming principle that the lower value function of this game problem is the viscosity solution of the system of our coupled HJBI equations. The uniqueness of the viscosity solution is also obtained in a space of continuous functions satisfying certain growth condition. In addition, also the upper value function of the game is shown to be the solution of the associated system of coupled Isaacs’ type of integral-partial differential equations. As a byproduct, we obtain the existence of the value for the game problem under the well-known Isaacs’ condition.

Full Iso-Recursive Types

There are two well-known formulations of recursive types: iso-recursive and equi-recursive types. Abadi and Fiore [LICS 1996] have shown that iso- and equi-recursive types have the same expressive power. However, their encoding of equi-recursive types in terms of iso-recursive types requires explicit coercions. These coercions come with significant additional computational overhead, and complicate reasoning about the equivalence of the two formulations of recursive types. This paper proposes a generalization of iso-recursive types called full iso-recursive types. Full iso-recursive types allow encoding all programs with equi-recursive types without computational overhead. Instead of explicit term coercions, all type transformations are captured by computationally irrelevant casts, which can be erased at runtime without affecting the semantics of the program. Consequently, reasoning about the equivalence between the two approaches can be greatly simplified. We present a calculus called λ Fi µ , which extends the simply typed lambda calculus (STLC) with full iso-recursive types. The λ Fi µ calculus is proved to be type sound, and shown to have the same expressive power as a calculus with equi-recursive types. We also extend our results to subtyping, and show that equi-recursive subtyping can be expressed in terms of iso-recursive subtyping with cast operators.

"Lives and times": The case for qualitative longitudinal research in anatomical sciences education.

Qualitative longitudinal research (QLR) focuses on changes in perceptions, interpretations, or practices through time. Despite longstanding traditions in social science, QLR has only recently appeared in anatomical sciences education (ASE). While some existing methodology papers guide researchers, they take a narrow view of QLR and lack specificity for ASE. This discursive article aims to (1) describe what QLR is and its benefits, its philosophies, methodologies and methods, considerations, and quality indicators, and (2) critically discuss examples of QLR in ASE. Underpinned by relativist ontology and subjectivist epistemology, time can be understood as fluid/subjective or fixed/objective. QLR is a flexible, creative, and exploratory methodology, often associated with other methodologies. Sampling is typically purposive, with repeated and recursive data collection methods, and complex three-strand analyses (themes, cases, and time), enabling cross-sectional and longitudinal analyses. QLR involves ethical, relationship, analytical, dissemination, and funding considerations. Key quality indicators relate to qualitative research as well as temporal aspects. Most of the nine ASE papers reviewed explored changes in anatomy learners, but few labeled their methodology as QLR. Just under half described their sampling as purposive, most employed pre-planned and standardized repeated interviews, analyzed their data cross-sectionally, and utilized qualitative data analysis software. Most cited the confirmability and transferability of their studies, but few cited credibility and dependability elements. Study timeframes and tempos were generally clear, but details of longitudinal retention/attrition were often lacking, and longitudinal data analysis was not often conducted. We therefore provide recommendations for the conduct of QLR in ASE.

Pipelines and Beyond: Graph Types for ADTs with Futures

Parallel programs are frequently modeled as dependency or cost graphs, which can be used to detect various bugs, or simply to visualize the parallel structure of the code. However, such graphs reflect just one particular execution and are typically constructed in a post-hoc manner. Graph types , which were introduced recently to mitigate this problem, can be assigned statically to a program by a type system and compactly represent the family of all graphs that could result from the program. Unfortunately, prior work is restricted in its treatment of futures , an increasingly common and especially dynamic form of parallelism. In short, each instance of a future must be statically paired with a vertex name. Previously, this led to the restriction that futures could not be placed in collections or be used to construct data structures. Doing so is not a niche exercise: such structures form the basis of numerous algorithms that use forms of pipelining to achieve performance not attainable without futures. All but the most limited of these examples are out of reach of prior graph type systems. In this paper, we propose a graph type system that allows for almost arbitrary combinations of futures and recursive data types. We do so by indexing datatypes with a type-level vertex structure , a codata structure that supplies unique vertex names to the futures in a data structure. We prove the soundness of the system in a parallel core calculus annotated with vertex structures and associated operations. Although the calculus is annotated, this is merely for convenience in defining the type system. We prove that it is possible to annotate arbitrary recursive types with vertex structures, and show using a prototype inference engine that these annotations can be inferred from OCaml-like source code for several complex parallel algorithms.

Enriched Presheaf Model of Quantum FPC

Selinger gave a superoperator model of a first-order quantum programming language and proved that it is fully definable and hence fully abstract. This paper proposes an extension of the superoperator model to higher-order programs based on modules over superoperators or, equivalently, enriched presheaves over the category of superoperators. The enriched presheaf category can be easily proved to be a model of intuitionistic linear logic with cofree exponential, from which one can cave out a model of classical linear logic by a kind of bi-orthogonality construction. Although the structures of an enriched presheaf category are usually rather complex, a morphism in the classical model can be expressed simply as a matrix of completely positive maps. The model inherits many desirable properties from the superoperator model. A conceptually interesting property is that our model has only a state whose “total probability” is bounded by 1, i.e. ‍does not have a state where true and false each occur with probability 2/3. Another convenient property inherited from the superoperator model is a ωCPO-enrichment. Remarkably, our model has a sufficient structure to interpret arbitrary recursive types by the standard domain theoretic technique. We introduce Quantum FPC , a quantum λ-calculus with recursive types, and prove that our model is a fully abstract model of Quantum FPC.

The Essence of Generalized Algebraic Data Types

This paper considers direct encodings of generalized algebraic data types (GADTs) in a minimal suitable lambda-calculus. To this end, we develop an extension of System F ω with recursive types and internalized type equalities with injective constant type constructors. We show how GADTs and associated pattern-matching constructs can be directly expressed in the calculus, thus showing that it may be treated as a highly idealized modern functional programming language. We prove that the internalized type equalities in conjunction with injectivity rules increase the expressive power of the calculus by establishing a non-macro-expressibility result in F ω , and prove the system type-sound via a syntactic argument. Finally, we build two relational models of our calculus: a simple, unary model that illustrates a novel, two-stage interpretation technique, necessary to account for the equational constraints; and a more sophisticated, binary model that relaxes the construction to allow, for the first time, formal reasoning about data-abstraction in a calculus equipped with GADTs.

Unboxed Data Constructors: Or, How cpp Decides a Halting Problem

We propose a new language feature for ML-family languages, the ability to selectively unbox certain data constructors, so that their runtime representation gets compiled away to just the identity on their argument. Unboxing must be statically rejected when it could introduce confusion, that is, distinct values with the same representation. We discuss the use-case of big numbers, where unboxing allows to write code that is both efficient and safe, replacing either a safe but slow version or a fast but unsafe version. We explain the static analysis necessary to reject incorrect unboxing requests. We present our prototype implementation of this feature for the OCaml programming language, discuss several design choices and the interaction with advanced features such as Guarded Algebraic Datatypes. Our static analysis requires expanding type definitions in type expressions, which is not necessarily normalizing in presence of recursive type definitions. In other words, we must decide normalization of terms in the first-order λ-calculus with recursion. We provide an algorithm to detect non-termination on-the-fly during reduction, with proofs of correctness and completeness. Our algorithm turns out to be closely related to the normalization strategy for macro expansion in the cpp preprocessor.

Mutually Iso-Recursive Subtyping

Iso-recursive types are often taken as a type-theoretic model for type recursion as present in many programming languages, e.g., classes in object-oriented languages or algebraic datatypes in functional languages. Their main advantage over an equi-recursive semantics is that they are simpler and algorithmically less expensive, which is an important consideration when the cost of type checking matters, such as for intermediate or low-level code representations, virtual machines, or runtime casts. However, a closer look reveals that iso-recursion cannot, in its standard form, efficiently express essential type system features like mutual recursion or non-uniform recursion. While it has been folklore that mutual recursion and non-uniform type parameterisation can nicely be handled by generalising to higher kinds, this encoding breaks down when combined with subtyping: the classic “Amber” rule for subtyping iso-recursive types is too weak to express mutual recursion without falling back to encodings of quadratic size.We present a foundational core calculus of iso-recursive types withdeclaredsubtyping that can express both inter- and intra-recursion subtyping without such blowup, including subtyping between constructors of higher or mixed kind. In a second step, we identify a syntactic fragment of this general calculus that allows for more efficient type checking without “deep” substitutions, by observing that higher-kinded iso-recursive types can be inserted to “guard” against unwanted β-reductions. This fragment closely resembles the structure of typical nominal subtype systems, but without requiring nominal semantics. It has been used as the basis for a proposed extension of WebAssembly with recursive types.

The uniform Kruskal theorem: between finite combinatorics and strong set existence.

The uniform Kruskal theorem extends the original result for trees to general recursive data types. As shown by Freund, Rathjen and Weiermann(Freund, Rathjen, Weiermann 2022 Adv. Math. 400, 108265 (doi:10.1016/j.aim.2022.108265)), it is equivalent to [Formula: see text]-comprehension, over [Formula: see text] with the ascending descending sequence principle ([Formula: see text]). This result provides a connection between finite combinatorics and abstract set existence. The present article sheds further light on this connection. Firstly, we show that the original Kruskal theorem is equivalent to the uniform version for data types that are finitely generated. Secondly, we prove a dichotomy result for a natural variant of the uniform Kruskal theorem. On the one hand, this variant still implies [Formula: see text]-comprehension over [Formula: see text] extended by the chain antichainprinciple ([Formula: see text]). On the other hand, it becomes weak when [Formula: see text] is removed from the base theory. This article is part of the theme issue 'Modern perspectives in Proof Theory'.

Complete Solution of the LSZ Model via Topological Recursion

We prove that the Langmann-Szabo-Zarembo (LSZ) model with quartic potential, a toy model for a quantum field theory on noncommutative spaces grasped as a complex matrix model, obeys topological recursion of Chekhov, Eynard and Orantin. By introducing two families of correlation functions, one corresponding to the meromorphic differentials $\omega_{g,n}$ of topological recursion, we obtain Dyson-Schwinger equations that eventually lead to the abstract loop equations being, together with their pole structure, the necessary condition for topological recursion. This strategy to show the exact solvability of the LSZ model establishes another approach towards the exceptional property of integrability in some quantum field theories. We compare differences in the loop equations for the LSZ model (with complex fields) and the Grosse-Wulkenhaar model (with hermitian fieldss) and their consequences for the resulting particular type of topological recursion that governs the models.

Exact Recursive Probabilistic Programming

Recursive calls over recursive data are useful for generating probability distributions, and probabilistic programming allows computations over these distributions to be expressed in a modular and intuitive way. Exact inference is also useful, but unfortunately, existing probabilistic programming languages do not perform exact inference on recursive calls over recursive data, forcing programmers to code many applications manually. We introduce a probabilistic language in which a wide variety of recursion can be expressed naturally, and inference carried out exactly. For instance, probabilistic pushdown automata and their generalizations are easy to express, and polynomial-time parsing algorithms for them are derived automatically. We eliminate recursive data types using program transformations related to defunctionalization and refunctionalization. These transformations are assured correct by a linear type system, and a successful choice of transformations, if there is one, is guaranteed to be found by a greedy algorithm.

Stochastic differential games with random coefficients and stochastic Hamilton–Jacobi–Bellman–Isaacs equations

In this paper, we study a class of zero-sum two-player stochastic differential games with the controlled stochastic differential equations and the payoff/cost functionals of recursive type. As opposed to the pioneering work by Fleming and Souganidis [Indiana Univ. Math. J. 38 (1989) 293–314] and the seminal work by Buckdahn and Li [SIAM J. Control Optim. 47 (2008) 444–475], the involved coefficients may be random, going beyond the Markovian framework and leading to the random upper and lower value functions. We first prove the dynamic programming principle for the game, and then under the standard Lipschitz continuity assumptions on the coefficients, the upper and lower value functions are shown to be the viscosity solutions of the upper and the lower fully nonlinear stochastic Hamilton–Jacobi–Bellman–Isaacs (HJBI) equations, respectively. A stability property of viscosity solutions is also proved. Under certain additional regularity assumptions on the diffusion coefficient, the uniqueness of the viscosity solution is addressed as well.

Data Layout from a Type-Theoretic Perspective

The specifics of data layout can be important for the efficiency of functional programs and interaction with external libraries. In this paper, we develop a type-theoretic approach to data layout that could be used as a typed intermediate language in a compiler or to give a programmer more control. Our starting point is a computational interpretation of the semi-axiomatic sequent calculus for intuitionistic logic that defines abstract notions of cells and addresses. We refine this semantics so addresses have more structure to reflect possible alternative layouts without fundamentally departing from intuitionistic logic. We then add recursive types and explore example programs and properties of the resulting language.

Data reduction via multi-label prototype generation

A very common practice to speed up instance based classifiers is to reduce the size of their training set, that is, replace it by a condensing set, hoping that their accuracy will not worsen. This can be achieved by applying a Prototype Selection or Generation algorithm, also referred to as a Data Reduction Technique. Most of these techniques cannot be applied on multi-label problems, where an instance may belong to more than one classes. Reduction through Homogeneous Clustering (RHC) and Reduction by Space Partitioning (RSP3) are parameter-free single-label Prototype Generation algorithms. Both are based on recursive data partitioning procedures that identify homogeneous clusters of training data, which they replace by their representatives. This paper proposes variations of these algorithms for multi-label training datasets. The proposed methods generate multi-label prototypes and inherit all the desirable properties of their single-label versions. They consider clusters that contain instances that share at least one common label as homogeneous clusters. It is shown via an experimental study based on nine multi-label datasets that the proposed algorithms achieve good reduction rates without negatively affecting classification accuracy.

Recursive Subtyping for All

Recursive types and bounded quantification are prominent features in many modern programming languages, such as Java, C#, Scala or TypeScript. Unfortunately, the interaction between recursive types, bounded quantification and subtyping has shown to be problematic in the past. Consequently, defining a simple foundational calculus that combines those features and has desirable properties, such as decidability , transitivity of subtyping, conservativity and a sound and complete algorithmic formulation has been a long time challenge. This paper presents an extension of kernel ‍ F ≤ , called F ≤ µ , with iso-recursive types. F ≤ is a well-known polymorphic calculus with bounded quantification. In F ≤ µ we add iso-recursive types, and correspondingly extend the subtyping relation with iso-recursive subtyping using the recently proposed nominal unfolding rules. We also add two smaller extensions to F ≤ . The first one is a generalization of the kernel ‍ F ≤ rule for bounded quantification that accepts equivalent rather than equal bounds. The second extension is the use of so-called structural folding/unfolding rules, inspired by the structural unfolding rule proposed by Abadi, Cardelli, and Viswanathan [1996]. The structural rules add expressive power to the more conventional folding/unfolding rules in the literature, and they enable additional applications. We present several results, including: type soundness; transitivity and decidability of subtyping; the conservativity of F ≤ µ over F ≤ ; and a sound and complete algorithmic formulation of F ≤ µ . Moreover, we study an extension of F ≤ µ , called F ≤≥ µ , which includes lower bounded quantification in addition to the conventional (upper) bounded quantification of F ≤ . All the results in this paper have been formalized in the Coq theorem prover.

Step-Indexed Logical Relations for Countable Nondeterminism and Probabilistic Choice

Developing denotational models for higher-order languages that combine probabilistic and nondeterministic choice is known to be very challenging. In this paper, we propose an alternative approach based on operational techniques. We study a higher-order language combining parametric polymorphism, recursive types, discrete probabilistic choice and countable nondeterminism. We define probabilistic generalizations of may- and must-termination as the optimal and pessimal probabilities of termination. Then we define step-indexed logical relations and show that they are sound and complete with respect to the induced contextual preorders. For may-equivalence we use step-indexing over the natural numbers whereas for must-equivalence we index over the countable ordinals. We then show than the probabilities of may- and must-termination coincide with the maximal and minimal probabilities of termination under all schedulers. Finally we derive the equational theory induced by contextual equivalence and show that it validates the distributive combination of the algebraic theories for probabilistic and nondeterministic choice.

Formalizing CCS and π-calculus in Guarded Cubical Agda

Dependent type theories with guarded recursion have shown themselves suitable for the development of denotational semantics of programming languages. In particular, Ticked Cubical Type Theory (TCTT) has been used to show that, for guarded labeled transition systems (GLTS), interpretation into the denotational semantics maps bisimilar processes to equal values. In fact the two notions are proved equivalent, allowing one to reason about equality in place of bisimilarity.We extend that result to the Calculus of Communicating Systems (CCS) and the π-calculus. For the latter, we pick early congruence as the syntactic notion of equivalence between processes, showing that denotational models based on guarded recursive types can handle the dynamic creation of channels that goes beyond the scope of GLTSs.Hence we present fully abstract denotational models for CCS and the early π-calculus, formalized as an extended example for Guarded Cubical Agda: a novel implementation of Ticked Cubical Type Theory based on Cubical Agda.

Arithmetic thinking as the basis of children's generative number concepts

Predominant psychological theories of number acquisition posit that children acquire natural number concepts as they acquire the successor principle, or the knowledge that every natural number is succeeded by another natural number that is exactly-one more than it. However, exactly how children acquire the successor principle remains largely unexplained. Recently developed ideas within this family of theories posit that an abstract recursive successor function is acquired from the recursive structure of number words; however, the types of recursion underlying the successor function and number words are distinctively different (one is a self-referential function and the other is a self-embedded structure), making it difficult to theorize how one type triggers the acquisition of another. Moreover, our analysis of the literature questions if the knowledge about the successor principle is even empirically measurable. Here, we argue that number acquisition is a process of understanding a generative rule that governs the system of natural numbers and point out that the successor principle is not the only generative rule that governs the natural number system. We propose an alternative hypothesis that generative number concepts emerge from children's realization about how the combinatorial rules of numerals allow arithmetic (specifically additive and multiplicative) representations of quantity. Importantly, under addition and multiplication—which are historically rooted in concatenation and grouping of physical objects—natural numbers are mathematically closed. As a corollary, the system of infinitely generative natural numbers is conceptualized. This new theoretical framework allows the construction of novel empirical questions and testable hypotheses based on the formalized rules of numerical syntax and numeration systems, and therefore opens a new avenue for studying later stages of children's acquisition of number concepts.