Linearization of the lambda-calculus and its relation with intersection type systems

2004 ◽  
Vol 14 (5) ◽  
pp. 519-546 ◽  
Author(s):  
MÁRIO FLORIDO ◽  
LUÍS DAMAS
Keyword(s):  
Programming Languages ◽  
Functional Programming ◽  
Type System ◽  
Lambda Calculus ◽  
Type Systems ◽  
Functional Programming Languages

In this paper we present a notion of expansion of a term in the lambda-calculus which transforms terms into linear terms. This transformation replaces each occurrence of a variable in the original term by a fresh variable taking into account non-trivial implications in the structure of the term caused by these simple replacements. We prove that the class of terms which can be expanded is the same of terms typable in an Intersection Type System, i.e. the strongly normalizable terms. We then show that expansion is preserved by weak-head reduction, the reduction considered by functional programming languages.

scholarly journals Coercions in a polymorphic type system

2008 ◽  
Vol 18 (4) ◽  
pp. 729-751 ◽  
Author(s):  
ZHAOHUI LUO
Keyword(s):  
Programming Languages ◽  
Functional Programming ◽  
Type System ◽  
Type Inference ◽  
Inference Algorithm ◽  
Functional Programming Languages ◽  
Polymorphic Type ◽  
And Function ◽  
Dependent Type

We incorporate the idea of coercive subtyping, a theory of abbreviation for dependent type theories, into the polymorphic type system in functional programming languages. The traditional type system with let-polymorphism is extended with argument coercions and function coercions, and a corresponding type inference algorithm is presented and proved to be sound and complete.

scholarly journals Using Vampire in Soundness Proofs of Type Systems

10.29007/22x6 ◽  
2018 ◽  
Author(s):  
Sylvia Grewe ◽  
Sebastian Erdweg ◽  
Mira Mezini
Keyword(s):  
Programming Languages ◽  
Type System ◽  
Lambda Calculus ◽  
Type Systems ◽  
Current Approach ◽  
Order Logic ◽  
First Order Logic ◽  
First Order ◽  
Domain Specific ◽  
Automated Proof

Type systems for programming languages shall detect type errors in programs before runtime. To ensure that a type system meets this requirement, its soundness must be formally verified. We aim at automating soundness proofs of type systems to facilitate the development of sound type systems for domain-specific languages.Soundness proofs for type systems typically require induction. However, many of the proofs of individual induction cases only require first-order reasoning. For the development of our workbench Veritas, we build on this observation by combining automated first-order theorem provers such as Vampire with automated proof strategies specific to type systems. In this paper, we describe how we encode type soundness proofs in first-order logic using TPTP. We show how we use Vampire to prove the soundness of type systems for the simply-typed lambda calculus and for parts of a typed SQL. We report on which parts of the proofs are handled well by Vampire, and what parts work less well with our current approach.

Uniqueness typing for functional languages with graph rewriting semantics

1996 ◽  
Vol 6 (6) ◽  
pp. 579-612 ◽  
Author(s):  
Erik Barendsen ◽  
Sjaak Smetsers
Keyword(s):  
Programming Languages ◽  
Functional Programming ◽  
Natural Deduction ◽  
Natural Extension ◽  
Type Systems ◽  
Higher Order ◽  
Functional Languages ◽  
Conventional System ◽  
Functional Programming Languages ◽  
Graph Rewriting

We present two type systems for term graph rewriting: conventional typing and (polymorphic) uniqueness typing. The latter is introduced as a natural extension of simple algebraic and higher-order uniqueness typing. The systems are given in natural deduction style using an inductive syntax of graph denotations with familiar constructs such as let and case.The conventional system resembles traditional Curry-style typing systems in functional programming languages. Uniqueness typing extends this with reference count information. In both type systems, typing is preserved during evaluation, and types can be determined effectively. Moreover, with respect to a graph rewriting semantics, both type systems turn out to be sound.

scholarly journals The Impact of the Lambda Calculus in Logic and Computer Science

1997 ◽  
Vol 3 (2) ◽  
pp. 181-215 ◽  
Author(s):  
Henk Barendregt
Keyword(s):  
Computer Science ◽  
Programming Languages ◽  
Functional Programming ◽  
Lambda Calculus ◽  
The Other ◽  
Functional Programming Languages ◽  
Other Hand ◽  
The One ◽  
The Impact

AbstractOne of the most important contributions of A. Church to logic is his invention of the lambda calculus. We present the genesis of this theory and its two major areas of application: the representation of computations and the resulting functional programming languages on the one hand and the representation of reasoning and the resulting systems of computer mathematics on the other hand.

scholarly journals V: a language with extensible record accessors and a trait-based type system

2018 ◽  
Vol 25 (3) ◽  
pp. 89
Author(s):  
Arthur Giesel Vedana ◽  
Rodrigo Machado ◽  
Álvaro Freitas Moreira
Keyword(s):  
Programming Languages ◽  
Programming Language ◽  
Functional Programming ◽  
Type System ◽  
Functional Programming Languages ◽  
Functional Programming Language ◽  
Novel Approach ◽  
Type Traits

This article introduces the V language, a purely functional programming language with a novel approach to records.Based on a system of type traits, V attempts to solve issues commonly found when manipulating records in purely functional programming languages.

scholarly journals Mechanizing the metatheory of rewire

2019 ◽  
Author(s):  
◽  
Thomas N. Reynolds
Keyword(s):  
Programming Languages ◽  
Type System ◽  
Lambda Calculus ◽  
Equational Theory ◽  
Functional Languages ◽  
Functional Programming Languages ◽  
Type Safety ◽  
High Assurance ◽  
Hardware Description ◽  
Description Languages

The [lambda]-calculus provides a simple, well-established framework for research in functional programming languages that readily lends itself to the use offormal methods--that is, the use of mathematically sound techniques and supporting tools--to describe and verify properties of programming languages, as well. This is no coincidence. After all, the [lambda]-calculus formalizes the concept of effective computability, for all computable functions are definable in the untyped [lambda]-calculus, making it expressively equivalent torecursive functions. In software, the expressiveness of functional languages is considereda strength. Functional approaches to language design, however, needn't be limited to soft-ware. In hardware, the expressiveness of functional languages becomes a major obstacle to successful hardware synthesis, for the reason that such languages are usually capable of expressing general recursion. The presence of general recursion makes it possible to generate expressions that run forever, never producing a well-defined value. In this dissertation, we study two novel variants of the simply typed [lambda]-calculus, representing fragments of functional hardware description languages. The first variant extends the type system, using natural numbers representing time. This addition, though simple, is non-trivial. We prove that this calculus possesses bounded variants of type-safety and strong normalization. That is to say, we show that all well-typed expressions evaluate to values within a bound determined by the natural number index of their corresponding types. The second variant is a computational [lambda]-calculus that formalizes the core fragment of the hardware description language known as ReWire. We prove that the language has type-safety and is strongly normalizing -- the proof of strong normalizationis the first mechanized proof of its kind. We define an equational theory with respect to this language. This allows us to prove that the language has desirable security properties by construction. This work supports a full-edged, formal methodology for producing high assurance hardware.

scholarly journals Dynamic game semantics

2020 ◽  
pp. 1-60
Author(s):  
Norihiro Yamada ◽  
Samson Abramsky
Keyword(s):  
Programming Languages ◽  
Functional Programming ◽  
Operational Semantics ◽  
Dynamic Game ◽  
Standard Interpretation ◽  
Functional Programming Languages ◽  
Game Semantics ◽  
Wide Range ◽  
Cartesian Closed Categories ◽  
Cartesian Closed

Abstract The present work achieves a mathematical, in particular syntax-independent, formulation of dynamics and intensionality of computation in terms of games and strategies. Specifically, we give game semantics of a higher-order programming language that distinguishes programmes with the same value yet different algorithms (or intensionality) and the hiding operation on strategies that precisely corresponds to the (small-step) operational semantics (or dynamics) of the language. Categorically, our games and strategies give rise to a cartesian closed bicategory, and our game semantics forms an instance of a bicategorical generalisation of the standard interpretation of functional programming languages in cartesian closed categories. This work is intended to be a step towards a mathematical foundation of intensional and dynamic aspects of logic and computation; it should be applicable to a wide range of logics and computations.

Sign in / Sign up

Export Citation Format

Share Document