Recursive Types Research Articles

Statistical filtering of river survey and streamflow data for improving At-A-Station hydraulic geometry relations

Natural streams are characterized by variation in cross-section geometry, bed-slope, bed roughness, hydraulic slope, etc., along their channels resulting from several interacting features of the riverine system including the effects of discharge changes, geologic context, sediment load, etc. Quantitative and qualitative assessment of river flow dynamics requires sufficient knowledge of hydraulics and these geophysical variables. Average flow condition theory expressed as “At-A-Station” hydraulic geometry (AHG) relations are site-specific power-functions, relating the mean stream channel forms (i.e. water depth, top-width, flow velocity, and flow area) to discharge, have been studied since 50s. Establishing robust AHG relations requires pre-assessment of data quality by means of uncertainty analysis. Our paper introduces a recursive data filtering procedure to find both random and systematic errors in streamflow and river-survey data that can be used to produce robust and informative AHG relations. The method is first verified on synthetic data and then by experiments over: (1) real discharge-stage ratings provided by daily streamflow records of U.S. Geological Survey/National Water Information System dataset (USGS/NWIS), and (2) field river survey measurement data from USGS/NWIS. This produces robust AHG relations at 4472 monitoring stations across the U.S.

Type-Based Cost Analysis for Lazy Functional Languages

We present a static analysis for determining the execution costs of lazily evaluated functional languages, such as Haskell. Time- and space-behaviour of lazy functional languages can be hard to predict, creating a significant barrier to their broader acceptance. This paper applies a type-based analysis employing amortisation and cost effects to statically determine upper bounds on evaluation costs. While amortisation performs well with finite recursive data, we significantly improve the precision of our analysis for co-recursive programs (i.e. dealing with potentially infinite data structures) by tracking self-references. Combining these two approaches gives a fully automatic static analysis for both recursive and co-recursive definitions. The analysis is formally proven correct against an operational semantic that features an exchangeable parametric cost-model. An arbitrary measure can be assigned to all syntactic constructs, allowing to bound, for example, evaluation steps, applications, allocations, etc. Moreover, automatic inference only relies on first-order unification and standard linear programming solving. Our publicly available implementation demonstrates the practicability of our technique on editable non-trivial examples.

Interactive proofs in higher-order concurrent separation logic

When using a proof assistant to reason in an embedded logic -- like separation logic -- one cannot benefit from the proof contexts and basic tactics of the proof assistant. This results in proofs that are at a too low level of abstraction because they are cluttered with bookkeeping code related to manipulating the object logic. In this paper, we introduce a so-called proof mode that extends the Coq proof assistant with (spatial and non-spatial) named proof contexts for the object logic. We show that thanks to these contexts we can implement high-level tactics for introduction and elimination of the connectives of the object logic, and thereby make reasoning in the embedded logic as seamless as reasoning in the meta logic of the proof assistant. We apply our method to Iris: a state of the art higher-order impredicative concurrent separation logic. We show that our method is very general, and is not just limited to program verification. We demonstrate its generality by formalizing correctness proofs of fine-grained concurrent algorithms, derived constructs of the Iris logic, and a unary and binary logical relation for a language with concurrency, higher-order store, polymorphism, and recursive types. This is the first formalization of a binary logical relation for such an expressive language. We also show how to use the logical relation to prove contextual refinement of fine-grained concurrent algorithms.

Automatically generating the dynamic semantics of gradually typed languages

Many language designers have adopted gradual typing. However, there remains open questions regarding how to gradualize languages. Cimini and Siek (2016) created a methodology and algorithm to automatically generate the type system of a gradually typed language from a fully static version of the language. In this paper, we address the next challenge of how to automatically generate the dynamic semantics of gradually typed languages. Such languages typically use an intermediate language with explicit casts. Our first result is a methodology for generating the syntax, type system, and dynamic semantics of the intermediate language with casts. Next, we present an algorithm that formalizes and automates the methodology, given a language definition as input. We show that our approach is general enough to automatically gradualize several languages, including features such as polymorphism, recursive types and exceptions. We prove that our algorithm produces languages that satisfy the key correctness criteria of gradual typing. Finally, we implement the algorithm, generating complete specifications of gradually typed languages in lambda-Prolog, including executable interpreters.

Method for Detecting the Inside of Coke Drum Using Acoustic Signals

A distance and acoustic intensity reverberation (DAIR) physical model is developed that can be successfully applied to the signal processing of the hydraulic decoking process online monitoring. In this model, the transmission characteristics of acoustic signals generated by a moving sound source in a dynamic confined space are first analyzed using data recursion and correction according to the coordinate continuity in adjacent area and adjacent time. The results show that the nondetection zone of acoustic signals generated directly by the impact of water is eliminated, and the surface distribution of coke in the drum can be mapped in real time.

The calculus of dependent lambda eliminations

AbstractModern constructive type theory is based on pure dependently typed lambda calculus, augmented with user-defined datatypes. This paper presents an alternative called the Calculus of Dependent Lambda Eliminations, based on pure lambda encodings with no auxiliary datatype system. New typing constructs are defined that enable induction, as well as large eliminations with lambda encodings. These constructs are constructor-constrained recursive types, and a lifting operation to lift simply typed terms to the type level. Using a lattice-theoretic denotational semantics for types, the language is proved logically consistent. The power of CDLE is demonstrated through several examples, which have been checked with a prototype implementation called Cedille.

Typed self-evaluation via intensional type functions

Many popular languages have a self-interpreter, that is, an interpreter for the language written in itself. So far, work on polymorphically-typed self-interpreters has concentrated on self-recognizers that merely recover a program from its representation. A larger and until now unsolved challenge is to implement a polymorphically-typed self-evaluator that evaluates the represented program and produces a representation of the result. We present F ω μ i , the first λ-calculus that supports a polymorphically-typed self-evaluator. Our calculus extends F ω with recursive types and intensional type functions and has decidable type checking. Our key innovation is a novel implementation of type equality proofs that enables us to define a versatile representation of programs. Our results establish a new category of languages that can support polymorphically-typed self-evaluators.

Higher order symbolic execution for contract verification and refutation

AbstractWe present a new approach to automated reasoning about higher-order programs by endowing symbolic execution with a notion of higher-order, symbolic values. To validate our approach, we use it to develop and evaluate a system for verifying and refuting behavioral software contracts of components in a functional language, which we callsoft contract verification. In doing so, we discover a mutually beneficial relation between behavioral contracts and higher-order symbolic execution. Contracts aid symbolic execution by providing a rich language of specifications serving as a basis of symbolic higher-order values; the theory of blame enables modular verification and leads to the theorem thatverified components can't be blamed; and the run-time monitoring of contracts enablessoftverification whereby verified and unverified components can safely interact. Conversely, symbolic execution aids contracts by providing compile-time verification and automated test case generation from counter-examples to verification. This relation between symbolic exuection and contracts engenders a virtuous cycle encouraging the gradual use of contracts.Our approach is able to analyze first-class contracts, recursive data structures, unknown functions, and control-flow-sensitive refinements of values, which are all idiomatic in dynamic languages. It makes effective use of off-the-shelf solvers to decide problems without heavy encodings. Counterexample search is sound and relatively complete with respect to a first-order solver for base type values and counter-examples are reported as concrete values, including functions. Therefore, it can form the basis of automated verification and bug-finding tools for higher-order programs. The approach is competitive with a range of existing tools—including type systems, flow analyzers, and model checkers—on their own benchmarks. We have built a prototype to analyze programs written in Racket and report on its effectiveness in verifying and refuting contracts.

재귀 타입과 합집합 타입을 위한 코인덕션 서브타이핑

귀납법과 코인덕션은 모두 컴퓨터 과학 분야에서 사용되는 중요한 증명 기법이다. 귀납법은 컴퓨터 과학 분야 학부 과정에서 기본적으로 가르치는 기법이며, 상대적으로 잘 알려지고 컴퓨터과학 분야전반에 걸쳐 잘 쓰이고 있다. 반면에 코인덕션은 귀납법에 비해 많은 사람들에게 다소 어렵고 친숙하지 않은 개념이다. 본 논문에서는 재귀 타입과 합집합 타입을 포함하는 간단한 타입 언어에 대해 서브타입 시스템을 정의하고, 정의한 시스템의 추이성을 증명함으로써 코인덕션에 대해 소개한다. 이를 통해, 코인덕션에 대한 이해도를 높이고, 동시에 재귀 타입과 다양한 타입 요소가 있을 때 서브타입 시스템을 정의하는 방법에 대한 기초를 제공한다.

History matching of channel reservoirs using ensemble Kalman filter with continuous update of channel information

Ensemble Kalman filter (EnKF) has been widely studied due to its excellent recursive data processing, dependable uncertainty quantification, and real-time update. However, many previous works have shown poor characterization results on channel reservoirs with non-Gaussian permeability distribution, which do not satisfy the Gaussian assumption of EnKF algorithm. To meet the assumption, normal score transformation can be applied to ensemble parameters. Even though this preserves initial permeability distribution of ensembles, it cannot provide reliable results when initial reservoir models are quite different from the reference one. In this study, an ensemble-based history matching scheme is suggested for channel reservoirs using EnKF with continuous update of channel information. We define channel information which consists of the facies ratio and the mean permeability of each rock face. These are added to the ensemble state vector of EnKF and updated recursively with other model parameters. Using the updated channel information, ensemble parameters are retransformed after each assimilation step. The proposed method gives better characterization results in case of using even poorly designed initial ensemble members. The method also alleviates overshooting problem of EnKF without further modifications of EnKF algorithm. The methodology is applied to channel reservoirs with extreme non-Gaussian permeability distribution. The result shows that the updated models can find channel pattern successfully and the uncertainty range is decreased properly to make a reasonable decision. Although initial channel information of the ensemble members shows big difference with the real one, it can be updated to follow the reference.

Semantic subtyping for imperative object-oriented languages

Semantic subtyping is an approach for defining sound and complete procedures to decide subtyping for expressive types, including union and intersection types; although it has been exploited especially in functional languages for XML based programming, recently it has been partially investigated in the context of object-oriented languages, and a sound and complete subtyping algorithm has been proposed for record types, but restricted to immutable fields, with union and recursive types interpreted coinductively to support cyclic objects. In this work we address the problem of studying semantic subtyping for imperative object-oriented languages, where fields can be mutable; in particular, we add read/write field annotations to record types, and, besides union, we consider intersection types as well, while maintaining coinductive interpretation of recursive types. In this way, we get a richer notion of type with a flexible subtyping relation, able to express a variety of type invariants useful for enforcing static guarantees for mutable objects. The addition of these features radically changes the defi- nition of subtyping, and, hence, the corresponding decision procedure, and surprisingly invalidates some subtyping laws that hold in the functional setting. We propose an intuitive model where mutable record val- ues contain type information to specify the values that can be correctly stored in fields. Such a model, and the correspond- ing subtyping rules, require particular care to avoid circularity between coinductive judgments and their negations which, by duality, have to be interpreted inductively. A sound and complete subtyping algorithm is provided, together with a prototype implementation.

Type soundness for dependent object types (DOT)

Scala’s type system unifies aspects of ML modules, object- oriented, and functional programming. The Dependent Object Types (DOT) family of calculi has been proposed as a new theoretic foundation for Scala and similar expressive languages. Unfortunately, type soundness has only been established for restricted subsets of DOT. In fact, it has been shown that important Scala features such as type refinement or a subtyping relation with lattice structure break at least one key metatheoretic property such as environment narrowing or invertible subtyping transitivity, which are usually required for a type soundness proof. The main contribution of this paper is to demonstrate how, perhaps surprisingly, even though these properties are lost in their full generality, a rich DOT calculus that includes recursive type refinement and a subtyping lattice with intersection types can still be proved sound. The key insight is that subtyping transitivity only needs to be invertible in code paths executed at runtime, with contexts consisting entirely of valid runtime objects, whereas inconsistent subtyping contexts can be permitted for code that is never executed.

Insuring wind energy production

Abstract This paper presents an insurance contract that the supplier of wind energy may subscribe in order to immunize the production of electricity against the volatility of the wind speed process. The other party of the contract may be any dispatchable energy producer, like gas turbine or hydroelectric generator, which can supply the required energy in case of little or no wind. The adoption of a stochastic wind speed model allows the computation of the fair premium that the wind power supplier has to pay in order to hedge the risk of inadequate output of electricity at any time. Recursive type equations are obtained for the prospective mathematical reserves of the insurance contract and for their higher order moments. The model and the validity of the results are illustrated through a numerical example.

Fuzzy probabilistic data association filter and its application to single maneuvering target

The fuzzy recursive least squares-probabilistic data association (FRLS-PDA) filter is presented for tracking single maneuvering target in cluttered situations with unknown process noises. In the proposed filter, the association probabilities of the current valid measurements belonging to a motion target are calculated by the probabilistic data association (PDA) algorithm. Then these probabilities are used to weight the valid measurements for generating a fused measurement, which is applied to determine the maneuvering characteristics of the moving target in real time including the current measurement residual and heading change. According to the above characteristics calculated, the fuzzy recursive least squares (FRLS) filter is used to estimate the current state of the target. The proposed filter can provide the advantage of the FRLS filter, which relaxes the restrictive assumptions of motion models of a maneuvering target. Moreover, it can realize single maneuvering target tracking in cluttered situations. The performance of the FRLS-PDA filter is evaluated by two experiments with the simulation data and real data, and it is found to be better than those of the PDA filter, IMM-PDA filter, fuzzy adaptive α-β filter, and FRLS filter in tracking accuracy.

Talking bananas: structural recursion for session types

Session types provide static guarantees that concurrent programs respect communication protocols. We give a novel account of recursive session types in the context of GV, a small concurrent extension of the linear λ-calculus. We extend GV with recursive types and catamorphisms, following the initial algebra semantics of recursion, and show that doing so naturally gives rise to recursive session types. We show that this principled approach to recursion resolves long-standing problems in the treatment of duality for recursive session types. We characterize the expressiveness of GV concurrency by giving a CPS translation to (non-concurrent) λ-calculus and proving that reduction in GV is simulated by full reduction in λ-calculus. This shows that GV remains terminating in the presence of positive recursive types, and that such arguments extend to other extensions of GV, such as polymorphism or non-linear types, by appeal to normalization results for sequential λ-calculi. We also show that GV remains deadlock free and deterministic in the presence of recursive types. Finally, we extend CP, a session-typed process calculus based on linear logic, with recursive types, and show that doing so preserves the connection between reduction in GV and cut elimination in CP.

Fully abstract compilation via universal embedding

A fully abstract compiler guarantees that two source components are observationally equivalent in the source language if and only if their translations are observationally equivalent in the target. Full abstraction implies the translation is secure : target-language attackers can make no more observations of a compiled component than a source-language attacker interacting with the original source component. Proving full abstraction for realistic compilers is challenging because realistic target languages contain features (such as control effects) unavailable in the source, while proofs of full abstraction require showing that every target context to which a compiled component may be linked can be back-translated to a behaviorally equivalent source context. We prove the first full abstraction result for a translation whose target language contains exceptions, but the source does not. Our translation---specifically, closure conversion of simply typed λ-calculus with recursive types---uses types at the target level to ensure that a compiled component is never linked with attackers that have more distinguishing power than source-level attackers. We present a new back-translation technique based on a shallow embedding of the target language into the source language at a dynamic type. Then boundaries are inserted that mediate terms between the untyped embedding and the strongly-typed source. This technique allows back-translating non-terminating programs, target features that are untypeable in the source, and well-bracketed effects.

Join inverse categories and reversible recursion

Recently, a number of reversible functional programming languages have been proposed. Common to several of these is the assumption of totality, a property that is not necessarily desirable, and certainly not required in order to guarantee reversibility. In a categorical setting, however, faithfully capturing partiality requires handling it as additional structure. Recently, Giles studied inverse categories as a model of partial reversible (functional) programming. In this paper, we show how additionally assuming the existence of countable joins on such inverse categories leads to a number of properties that are desirable when modeling reversible functional programming, notably morphism schemes for reversible recursion, a †-trace, and algebraic ω-compactness. This gives a categorical account of reversible recursion, and, for the latter, provides an answer to the problem posed by Giles regarding the formulation of recursive data types at the inverse category level.

Recursions and asymptotics of intersection numbers

We establish the asymptotic expansion of certain integrals of [Formula: see text] classes on moduli spaces of curves [Formula: see text], when either the [Formula: see text] or [Formula: see text] goes to infinity. Our main tools are cut-join type recursion formulae from the Witten–Kontsevich theorem, as well as asymptotics of solutions to the first Painlevé equation. We also raise a conjecture on large genus asymptotics for [Formula: see text]-point functions of [Formula: see text] classes and partially verify the positivity of coefficients in generalized Mirzakhani’s formula of higher Weil–Petersson volumes.

Type Soundness for Path Polymorphism

Path polymorphism is the ability to define functions that can operate uniformly over arbitrary recursively specified data structures. Its essence is captured by patterns of the form xy which decompose a compound data structure into its parts. Typing these kinds of patterns is challenging since the type of a compound should determine the type of its components. We propose a static type system (i.e. no run-time analysis) for a pattern calculus that captures this feature. Our solution combines type application, constants as types, union types and recursive types. We address the fundamental properties of Subject Reduction and Progress that guarantee a well-behaved dynamics. Both these results rely crucially on a notion of pattern compatibility and also on a coinductive characterisation of subtyping.

Polymorphic type inference for machine code

For many compiled languages, source-level types are erased very early in the compilation process. As a result, further compiler passes may convert type-safe source into type-unsafe machine code. Type-unsafe idioms in the original source and type-unsafe optimizations mean that type information in a stripped binary is essentially nonexistent. The problem of recovering high-level types by performing type inference over stripped machine code is called type reconstruction, and offers a useful capability in support of reverse engineering and decompilation. In this paper, we motivate and develop a novel type system and algorithm for machine-code type inference. The features of this type system were developed by surveying a wide collection of common source- and machine-code idioms, building a catalog of challenging cases for type reconstruction. We found that these idioms place a sophisticated set of requirements on the type system, inducing features such as recursively-constrained polymorphic types. Many of the features we identify are often seen only in expressive and powerful type systems used by high-level functional languages. Using these type-system features as a guideline, we have developed Retypd: a novel static type-inference algorithm for machine code that supports recursive types, polymorphism, and subtyping. Retypd yields more accurate inferred types than existing algorithms, while also enabling new capabilities such as reconstruction of pointer const annotations with 98% recall. Retypd can operate on weaker program representations than the current state of the art, removing the need for high-quality points-to information that may be impractical to compute.