A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2005; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
Light affine lambda calculus and polynomial time strong normalization

2007
*
Archive for Mathematical Logic
*

*Light*Linear Logic (LLL)

*and*its variant, Intuitionistic

*Light*

*Affine*Logic (ILAL), are logics of

*polynomial*

*time*computation. ... We then prove the polytime

*strong*

*normalization*theorem for this

*calculus*: any reduction strategy

*normalizes*a given λla term in a

*polynomial*number of reduction steps,

*and*indeed in

*polynomial*

*time*. ... We are deeply grateful to Professor Harry Mairson

*and*Professor Mitsuhiro Okada for useful comments

*and*stimulating discussions. ...

##
###
Light types for polynomial time computation in lambda calculus

2009
*
Information and Computation
*

We present a polymorphic type system for

doi:10.1016/j.ic.2008.08.005
fatcat:vtr4yo6kz5dsfp6qzoqe3szxte
*lambda**calculus*ensuring that well-typed programs can be executed in*polynomial**time*: dual*light**affine*logic (DLAL). ... DLAL has a simple type language with a linear*and*an intuitionistic type arrow,*and*one modality. It corresponds to a fragment of*light**affine*logic (LAL). ... LAL*and*reduction It was shown in [39] that*light**affine**lambda**calculus*admits*polynomial*step*strong**normalization*: the bound of Theorem 1 holds on the length of any reduction sequence of*light**affine*...##
###
Light types for polynomial time computation in lambda-calculus
[article]

2004
*
arXiv
*
pre-print

We propose a new type system for

arXiv:cs/0402059v2
fatcat:q2ricscan5giboyeygjk3j5pba
*lambda*-*calculus*ensuring that well-typed programs can be executed in*polynomial**time*: Dual*light**affine*logic (DLAL). ... DLAL has a simple type language with a linear*and*an intuitionistic type arrow,*and*one modality. It corresponds to a fragment of*Light**affine*logic (LAL). ... We are grateful to Paolo Coppola, Simone Martini*and*Ugo Dal Lago for their accurate reading*and*important suggestions. ...##
###
Light types for polynomial time computation in lambda-calculus

2004
*
Proceedings of the 19th Annual IEEE Symposium on Logic in Computer Science, 2004.
*

We propose a new type system for

doi:10.1109/lics.2004.1319621
dblp:conf/lics/BaillotT04
fatcat:vgv6qbozbffv7axhycotxzsjpa
*lambda*-*calculus*ensuring that well-typed programs can be executed in*polynomial**time*: Dual*light**affine*logic (DLAL). ... DLAL has a simple type language with a linear*and*an intuitionistic type arrow,*and*one modality. It corresponds to a fragment of*Light**affine*logic (LAL). ... We are grateful to Paolo Coppola, Simone Martini*and*Ugo Dal Lago for their accurate reading*and*important suggestions. ...##
###
An Embedding of the BSS Model of Computation in Light Affine Lambda-Calculus
[article]

2006
*
arXiv
*
pre-print

Given a fixed ring structure K we define an extension of Terui's

arXiv:cs/0608040v1
fatcat:zpyjpm7iafd6zfpvbytnuz3xqu
*light**affine**lambda*-*calculus*typed in LAL (*Light**Affine*Logic) with a basic type for K. ... We show that this*calculus*captures the*polynomial**time*function class FP(K): every typed term can be evaluated in*polynomial**time**and*conversely every*polynomial**time*BSS machine over K can be simulated ... In section 2 we recall*Light**affine*logic*and**light**affine**lambda*-*calculus**and*in section 3 the BSS model. ...##
###
Soft lambda-Calculus: A Language for Polynomial Time Computation
[chapter]

2004
*
Lecture Notes in Computer Science
*

We introduce Soft

doi:10.1007/978-3-540-24727-2_4
fatcat:xi3sw7bcd5dnrgqrm2x7pwkdda
*lambda*-*calculus*as a*calculus*typable in the intuitionistic*and**affine*variant of this logic. We prove that the (untyped) terms of this*calculus*are reducible in*polynomial**time*. ... It has been later simplified by Asperti into*Light**affine*logic ([3]) which allows Work partially supported by Action Spécifique CNRS Méthodes formelles pour la Mobilité*and*ACI Sécurité Informatique CRISS ... We wish to thank Marcel Masseron for the stimulating discussions we had together on Soft linear logic*and*which led to the present paper. ...##
###
Intersection Types for Light Affine Lambda Calculus

2005
*
Electronical Notes in Theoretical Computer Science
*

*Light*

*Affine*

*Lambda*

*Calculus*is a term

*calculus*for

*polynomial*

*time*computation ([12]). Some of the terms of

*Light*

*Affine*

*Lambda*

*Calculus*must however be regarded as errors. ... Intuitionistic

*Light*

*Affine*Logic (ILAL) types only terms without errors, but not all of them. ... Acknowledgement We have to thank Patrick Baillot for all his comments, remarks

*and*suggestions ; we do it here warmly. ...

##
###
Soft lambda-calculus: a language for polynomial time computation
[article]

2003
*
arXiv
*
pre-print

We introduce Soft

arXiv:cs/0312015v1
fatcat:kyrtagxsybfe3gy27u4jayh7sm
*lambda*-*calculus*as a*calculus*typable in the intuitionistic*and**affine*variant of this logic. We prove that the (untyped) terms of this*calculus*are reducible in*polynomial**time*. ... Using these datatypes we examine the concrete expressivity of Soft*lambda*-*calculus*with the example of the insertion sort algorithm. ... Our Soft*lambda*-*calculus*is inspired from Terui's*Light**affine**lambda*-*calculus*([Ter01]), which is a*calculus*with a*polynomial*bound on reduction sequences that can be typed in*Light**affine*logic. ...##
###
Algebras and coalgebras in the light affine Lambda calculus

2015
*
SIGPLAN notices
*

Algebra

doi:10.1145/2858949.2784759
fatcat:ezlynnzdxrepfpxnj3qtddwj2q
*and*coalgebra are widely used to model data types in functional programming languages*and*proof assistants. ... Their use permits to better structure the computations*and*also to enhance the expressivity of a language or of a proof system. ... The*Light**Affine**Lambda**Calculus*The*Light**Affine**Lambda**Calculus*is the*affine*version of the*Light*Linear*Lambda**Calculus*[39]*and*provide a concrete syntax for Intuitionistic*Light**Affine*Logic [ ...##
###
Soft Linear Set Theory

2008
*
The Journal of Logic and Algebraic Programming
*

A formulation of naive set theory is given in Lafont's Soft Linear Logic, a logic with

doi:10.1016/j.jlap.2008.02.010
fatcat:jkg26rx7b5b5pixne4xi5m7cfq
*polynomial**time*cut-elimination. ... A novelty of this approach is the representation of the unary/binary natural numbers by two distinct sets (the safe naturals*and*the soft naturals). ... Acknowledgements I should like to thank Yves Lafont for some initial help,*and*Thomas Strahm for discussions on the work of Bellantoni*and*Cook. ...##
###
Light Logics and the Call-by-Value Lambda Calculus

2008
*
Logical Methods in Computer Science
*

In this paper we show that shifting from usual call-by-name to call-by-value

doi:10.2168/lmcs-4(4:5)2008
fatcat:li2b2uivfrc23lxtselbo6eszi
*lambda**calculus*allows regaining*strong*connections with the underlying logic. ... The so-called*light*logics have been introduced as logical systems enjoying quite remarkable*normalization*properties. ... This phenomenon has catastrophic consequences in the context of*Light**Affine*Logic, where*polynomial**time*bounds cannot be transferred from the logic to pure*lambda*-*calculus*[6] . ...##
###
Type inference for light affine logic via constraints on words

2004
*
Theoretical Computer Science
*

LAL provides a typing for

doi:10.1016/j.tcs.2004.08.014
fatcat:hewps5vkmvhtpcy42bmfgaol7q
*lambda*-*calculus*which guarantees that a well-typed program is executable in*polynomial**time*on any input. ...*Light**Affine*Logic (LAL) is a system due to Girard*and*Asperti capturing the complexity class P in a proof-theoretical approach based on Linear Logic. ... bound (using proof-nets or*light**affine**lambda*-*calculus*as intermediate language). ...##
###
Elementary Affine Logic and the Call-by-Value Lambda Calculus
[chapter]

2005
*
Lecture Notes in Computer Science
*

*Light*

*and*elementary linear logics have been introduced as logical systems enjoying quite remarkable

*normalization*properties. ... In this paper, we show that shifting from usual call-by-name to call-by-value

*lambda*

*calculus*allows to regain

*strong*connections with the underlying logic. ... This phenomenon has catastrophic consequences in the context of

*light*

*affine*logic, where

*polynomial*

*time*bounds cannot be transferred from the logic to pure

*lambda*-

*calculus*[1] . ...

##
###
From light logics to type assignments: a case study

2009
*
Logic Journal of the IGPL
*

Namely the typing assures the

doi:10.1093/jigpal/jzp019
fatcat:hrdmcpi7pbed3gsxd56tf7x4vy
*strong**normalization*in a number of steps*polynomial*in the size of the term,*and*moreover all*polynomial*functions can be computed by λ-terms that can be typed in the system ... Proofs of LLL*and*SLL characterize*polynomial**time*computations, while ELL characterizes elementary*time*computations. ... In Section 2, SLL is introduced, its*strong**normalization*in*polynomial**time*is proved*and*its PTIME completeness is recalled. ...##
###
Combining linear logic and size types for implicit complexity

2019
*
Theoretical Computer Science
*

a way that typed programs admit

doi:10.1016/j.tcs.2019.09.032
fatcat:wbzm7ll2dbe55lenvkvzv2bnqu
*polynomial**time*complexity. ... very*strong*... ... Elementary*Affine*Logic*and*Sizes We work on an elementary*affine**lambda**calculus*based on [24] without multithreading*and*side-effects, that we present here. ...
« Previous

*Showing results 1 — 15 out of 150 results*