Semi-continuous Sized Types and Termination

This thesis proposes a novel way of performing type checking, whose results are incremental, depending on the provided local information. This new way of type checking is called co-contextual, where all context information of expressions, methods, classes, etc., is removed. Instead, we introduce corresponding structures using requirements. Standard type systems are translated to the co-contextual ones systematically using dualism as technique. Type systems play an important role to prevent execution errors from occurring during runtime. They are used to check programs statically for potential errors. Programs are type checked against a given set of rules. Depending on these rules programs are well-typed or not. The set of these rules is called typing rules. Each type rule associates types to the constructs of a program given a certain context. There can be different forms of contexts, depending on the features of the typed programming language. Functional languages use a typing context of variables and their types; object-oriented (OO) languages use additional class tables. Class tables are used for example to ensure that method and class declarations are well-typed. Type checking is performed top-down. While traversing the syntax tree of a program, typing contexts are extended with information on the expressions and their types. In case of OO, class tables are extended with clauses from class declarations, including the class members, i.e., fields, methods, or constructors. Contexts are passed through the nodes of the syntax tree in order to coordinate type checking between them. Therefore, while traversing the syntax tree top-down, the type checker creates dependencies between otherwise independent subexpressions. This way, it inhibits incrementalization and parallelization of type checking. That is, a change to a node of the syntax tree would require to redo the type check of the whole syntax tree. In this thesis a novel formulation of type systems is proposed, in order to remove dependencies between subexpressions. We propose a co-contextual formulation of typing rules that depends only on the local program constructs, e.g., expressions, methods, classes. The co-contextual typing rules have as conclusion a type and sets of requirements. That is, contexts and class tables are replaced by the dual concept of context and class table requirements. In addition, operations on contexts and class tables are replaced by new dual operations on requirements. The co-contextual type checker traverses a syntax tree bottom-up and merges context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. We derive co-contextual type checkers for functional and OO languages. As a representative of functional languages we consider PCF and extensions of it: records, parametric polymorphism, structural subtyping and let-polymorphism. Also, we investigate featherweight java (FJ) as the basis of OO languages and extensions of it: method overloading and generics. We build a1 co-contextual type checker for FJ enabling key features of OO languages: subtype polymorphism, nominal typing and implementation inheritance. The dualism between the co-contextual and contextual type systems preserves the correctness of the contextual calculus. That is, we prove the correctness of the co-contextual calculus via the equivalence between contextual type rules and their co-contextual formulations. We implemented an incremental type checker for PCF along with a performance evaluation showing that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly. Regarding FJ, we implemented a co-contextual type checker with incrementalization and compared its performance against javac on a number of realistic programs. Our performance evaluation shows significant speedups for the co-contextual type checker with incrementalization in comparison to javac.

Whereas dynamic typing enables rapid prototyping and easy experimentation, static typing provides early error detection and better compile time optimization. Gradual typing [26] provides the best of both worlds. This paper shows how to define and implement gradual typing in Dylan, traditionally a dynamically typed language. Dylan poses several special challenges for gradual typing, such as multiple return values, variable-arity methods and generic functions (multiple dispatch).In this paper Dylan is extended with function types and parametric polymorphism. We implemented the type system and aunification-based type inference algorithm in the mainstream Dylan compiler. As case study we use the Dylan standard library (roughly 32000 lines of code), which witnesses that the implementation generates faster code with fewer errors. Some previously undiscovered errors in the Dylan library were revealed.

Several negative results are proved about the ability to type-check queries in the only existing proposed standard for object-oriented databases. The first of these negative results is that it is not possible to type-check OQL queries in the type system underlying the ODMG object model and its definition language ODL. The second negative result is that OQL queries cannot be type-checked in the type system of the Java binding of the ODMG standard either. A solution proposed in this paper is to extend the ODMG object model with explicit support for parametric polymorphism (universal type quantification). These results show that Java cannot be a viable database programming language unless extended with parametric polymorphism. This is why type-checking OQL queries presents no problem for the type system of the C++ binding of the ODMG standard. However, a type system that is strictly more powerful than any of the type systems of the ODMG standard is required in order to properly type ordered collectgions and indices. The required form of polymorphism is bounded type quantification (constrained genericity) and even F-bounded polymorphism. A further result is that neither static nor the standard dynamic object-oriented type-checking is possible for Java OQL, in spite of the fact that Java OQL combines features of two strongly and mostly statically-typed languages. Contrary to one of the promises of object-oriented database technology, this result shows that the impedance mismatch does not disappear in the ODMG standard. A type-safe reflective technique is proposed for overcoming this mismatch.

We define and study parametric polymorphism for a type system with recursive, product, union, intersection, negation, and function types. We first recall why the definition of such a system was considered hard "when not impossible" and then present the main ideas at the basis of our solution. In particular, we introduce the notion of "convexity" on which our solution is built up and discuss its connections with parametricity as defined by Reynolds to whose study our work sheds new light.

In most algebraic specification frameworks, the type system is restricted to sorts, subsorts, and first‐order function types. This is in marked contrast to the so‐called model‐oriented frameworks, which provide higher‐order types, interpreted set‐theoretically as Cartesian products, function spaces, and power‐sets. This paper presents a simple framework for algebraic specifications with higher‐order types and set‐theoretic models. It may be regarded as the basis for a Horn‐clause approximation to the Z framework, and has the advantage of being amenable to prototyping and automated reasoning. Standard set‐theoretic models are considered, and conditions are given for the existence of initial reducts of such models. Algebraic specifications for various set‐theoretic concepts are considered.

Region-based type systems provide programmer control over memory management without sacrificing type-safety. However, the type systems for region-based languages, such as the ML-Kit or Cyclone, are relatively complicated, and proving their soundness is non-trivial. This paper shows that the complication is in principle unnecessary. In particular, we show that plain old parametric polymorphism, as found in Haskell, is all that is needed. We substantiate this claim by giving a type- and meaning-preserving translation from a variation of the region calculus of Tofte and Talpin to a monadic variant of System F with region primitives whose types and operations are inspired by (and generalize) the ST monad of Launchbury and Peyton Jones.

Our goal is to define a type of partial recursive functions in constructive type theory. In a series of previous articles, we studied two different formulations of partial functions and general recursion. We could obtain a type only by extending the theory with either an impredicative universe or with coinductive definitions. Here we present a new type constructor that eludes such entities of dubious constructive credentials. We start by showing how to break down a recursive function definition into three components: the first component generates the arguments of the recursive calls, the second evaluates them, and the last computes the output from the results of the recursive calls. We use this dissection as the basis for the introduction rule of the new type constructor. Every partial recursive function is associated with an inductive domain predicate; evaluation of the function requires a proof that the input values satisfy the predicate. We give a constructive justification for the new construct by interpreting it into the base type theory. This shows that the extended theory is consistent and constructive.

In spite of years of research toward a solution for the problem of extending Java with parametric polymorphism (genericity) the officially accepted solution already in its beta release allows violation of the Java type system and turns a type safe language into an unsafe one. The run-time type information in this release is incorrect which leads to major problems for the programmers relying on the Java reflective capabilities. We show that there are two basic reasons for these problems. The first one is that the idiom underlying this solution is provably incorrect. The second one is that the problem of extending Java with parametric polymorphism does not have a correct solution unless the Java Virtual Machine is extended to handle it properly. This paper elaborates the subtleties required by a correct implementation technique that includes representation of parametric classes in the standard Java class file format, representation of the instantiated parametric class objects, extensions of the Java Core Reflection to report type information about (instantiated) parametric classes, and the loading techniques required by this solution for extending Java with generics. Previous solutions for this problem are analyzed as well.

Small birth size is associated with reduced adult bone mass. We determined if antenatal betamethasone exposure, birth weight, or prematurity affects peak bone mass in 174 adults. Antenatal betamethasone exposure did not. Lower birth weight and prematurity predicted reduced adult height. Slower fetal growth rather than prematurity predicted lower bone mass, but this lower bone mass was appropriate for reduced adult height. Small size at birth is reported to be associated with lower bone mass in adulthood. However, previous studies have not distinguished the relative contributions of length of gestation and fetal growth to size at birth. Fetal exposure to excess glucocorticoids has been proposed as a core mechanism underlying the associations between birth size and later disease risk. Antenatal glucocorticoids are given to pregnant women at risk for preterm delivery for the prevention of neonatal respiratory distress syndrome in their infants. We determined the relationship of antenatal exposure to betamethasone, birth weight, and prematurity to peak bone mass and femoral geometry in the adult survivors of the first randomized trial of antenatal glucocorticoids. We studied 174 young adults (mean age, 31 years) whose mothers participated in a randomized trial of antenatal betamethasone. Mothers received two doses of intramuscular betamethasone or placebo 24 h apart. Two thirds of participants were born preterm (<37 weeks gestation). We measured indices of bone mass and size and derived estimates of volumetric density and bone geometry from DXA assessments of the lumbar spine, femur, and total body. There were no differences between betamethasone-exposed and placebo-exposed groups in any of the lumbar spine, femur, or total body DXA measures. There was no effect of antenatal betamethasone on adult height, although leg length was increased relative to trunk length (p = 0.002). A lighter birth weight (p <or = 0.001) and lower gestational age (p = 0.013) were associated with shorter stature (height Z scores) at age 31 years. Prematurity had no effect on peak bone mass or femoral geometry. However, lower birth weight, independent of gestational age, was associated with lower later bone mass (p < 0.001 for lumbar spine and total body, p = 0.003 for femoral neck BMC). These effects on bone mass were related to bone size and not to estimates of volumetric density. In the femur, lower birth weight, independent of gestational age, was associated with narrowing of the upper shaft and narrow neck regions. Antenatal betamethasone exposure does not affect peak bone mass or femoral geometry in adulthood. Birth weight and prematurity predict adult height, but it is slower fetal growth, rather than prematurity, that predicts lower peak bone mass. The lower peak bone mass in those born small is appropriate for their adult height.

This paper presents AURA, a programming language for access control that treats ordinary programming constructs (e.g., integers and recursive functions) and authorization logic constructs (e.g., principals and access control policies) in a uniform way. AURA is based on polymorphic DCC and uses dependent types to permit assertions that refer directly to AURA values while keeping computation out of the assertion level to ensure tractability. The main technical results of this paper include fully mechanically verified proofs of the decidability and soundness for AURA's type system, and a prototype typechecker and interpreter.

In the present chapter we examine the connections between functional calculus and interpolation spaces. As an ‘appetiser’, in Section 6.1 we present two central ideas: a model describing the real interpolation spaces (X, D(A)) θ,p using the functional calculus and a theorem of Dore. In Section 6.2 we examine the first of these ideas, proving several representation results for the spaces (X, D(Aα)) θ,p . Then we introduce extrapolation spaces for injective operators (Section 6.3). With the help of these spaces in Section 6.4 we derive two fundamental results (Theorem 6.4.2 and Theorem 6.4.5) that lead to more characterisations of interpolation spaces by functional calculus (Section 6.5.1) and a generalisation of Dore’s theorem (Section 6.5.3). In Section 6.6 we establish all the common properties of fractional domain spaces as intermediate spaces: density, the moment inequality, reiteration. Moreover, we prove the intriguing fact that for an operator A ∈ BIP(X) the fractional domain spaces equal the complex interpolation spaces (Theorem 6.6.9). Finally we characterise growth conditions like supt≥1 ‖tθ B(t + A)−1‖ < ∞ in terms of interpolation spaces (Section 6.7).

The distinction of the semantic spaces of elements and types is common practice in practically all type systems. A few type systems, including some early ones, have been proposed whose semantic space has functions only, i.e., depending on the context functions may play element roles as well as type roles. All of these systems are either lacking expressive power, in particular, polymorphism, or they violate uniqueness of types. This work presents for the first time a function-based type system in which typing is a relation between functions and which is using an ordering of functions to introduce bounded polymorphism. The ordering is based on an infinite set of top objects, itself strictly linearly ordered, each of which characterizes a certain function space. These top objects are predicative in the sense that a function using some top object cannot be smaller than this object. The interpretation of proposition as types and elements as proofs remains valid and is extended by viewing the ordering between types as logical implication. The proposed system can be shown to satisfy confluence and subject reduction. Furthermore one can show that the ordering is a partial order, every set of expressions has a maximal element, and there is a (unique) minimal, logically strongest, type among all types of an element. The latter result implies an alternative notion of uniqueness of types. Strong normalisation is the deepest property and its proof is based on a well-founded relation defined over a subsystem of expressions without eliminators. Semantic abstraction of the objects involved in typing, i.e., to use functions in element as well as type roles in a relational setting, is the major contribution of function-based type systems. This work shows that dependent products are not necessary for defining type systems with bounded polymorphism, rather it presents a consistent system with bounded polymorphism and minimal types where typing is a relation between partially ordered functions.

In the light of the relation between the input and the output of the qualitative mapping units, this paper will give a Homomorphism relation between the Turing machine and the qualitative mapping unit, thus further prove the Homomorphism relation between the non-attribute-feedback multi-layer networks. Recursive function and Lambda Calculus are also reconstructed based on attitude theory.

The field theory of strings is developed using the functional calculus as a practical technique. A Schr\"odinger-type equation and its eigensolutions are derived in light-cone coordinates. Vertices and amplitudes are represented entirely in a Fock space of second-quantized functionals. Two different open-string interactions are explicitly investigated. The three- and four-string vertex functionals are calculated for arbitrary times and compared with the asymptotic expressions obtained by other authors. We discuss how more exotic string configurations can be incorporated into the theory and emphasize the utility of the functional calculus in describing these topologies.

A Type Inference System for FP Programs