Results 1 
3 of
3
On the computational complexity of cutelimination in linear logic
 In Proceedings of ICTCS 2003, volume 2841 of LNCS
, 2003
"... Abstract. Given two proofs in a logical system with a confluent cutelimination procedure, the cutelimination problem (CEP) is to decide whether these proofs reduce to the same normal form. This decision problem has been shown to be ptimecomplete for Multiplicative Linear Logic (Mairson 2003). The ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
Abstract. Given two proofs in a logical system with a confluent cutelimination procedure, the cutelimination problem (CEP) is to decide whether these proofs reduce to the same normal form. This decision problem has been shown to be ptimecomplete for Multiplicative Linear Logic (Mairson 2003). The latter result depends upon a restricted simulation of weakening and contraction for boolean values in MLL; in this paper, we analyze how and when this technique can be generalized to other MLL formulas, and then consider CEP for other subsystems of Linear Logic. We also show that while additives play the role of nondeterminism in cutelimination, they are not needed to express deterministic ptime computation. As a consequence, affine features are irrelevant to expressing ptime computation. In particular, Multiplicative Light Linear Logic (MLLL) and Multiplicative Soft Linear Logic (MSLL) capture ptime even without additives nor unrestricted weakening. We establish hierarchical results on the cutelimination problem for MLL(ptimecomplete), MALL(coNPcomplete), MSLL(EXPTIMEcomplete), and for MLLL (2EXPTIMEcomplete). 1
Light Affine Set Theory: A Naive Set Theory of Polynomial Time
, 2004
"... In [7], a naive set theory is introduced based on a polynomial time logical system, Light Linear Logic (LLL). Although it is reasonably claimed that the set theory inherits the intrinsically polytime character from the underlying logic LLL, the discussion there is largely informal, and a formal ju ..."
Abstract

Cited by 11 (1 self)
 Add to MetaCart
In [7], a naive set theory is introduced based on a polynomial time logical system, Light Linear Logic (LLL). Although it is reasonably claimed that the set theory inherits the intrinsically polytime character from the underlying logic LLL, the discussion there is largely informal, and a formal justification of the claim is not provided sufficiently. Moreover, the syntax is quite complicated in that it is based on a nontraditional hybrid sequent calculus which is required for formulating LLL. In this paper, we consider a naive set theory based on Intuitionistic Light Affine Logic (ILAL), a simplification of LLL introduced by [1], and call it Light Affine Set Theory (LAST). The simplicity of LAST allows us to rigorously verify its polytime character. In particular, we prove that a function over {0, 1} ∗ is computable in polynomial time if and only if it is provably total in LAST.
ABSTRACT How Light Is Safe Recursion? Compositional Translations Between Languages of Polynomial Time
"... We investigate the relationship between two polynomial time languages: Bellantoni and Cook’s functional combinator language BC, and Girard’s Light Linear Logic LAL (as amended by Asperti). It is known that both languages characterize exactly the polynomial time functions. Despite this similarity, an ..."
Abstract
 Add to MetaCart
We investigate the relationship between two polynomial time languages: Bellantoni and Cook’s functional combinator language BC, and Girard’s Light Linear Logic LAL (as amended by Asperti). It is known that both languages characterize exactly the polynomial time functions. Despite this similarity, an open question has been to provide a compositional translation between the two languages: given a ptime function f described in a BC program pf,howcanwetranslate pf into an LALprogram? Compositionality means that the translation of a program is a function of the translation of its constituent parts. The construction of such a compiler is fundamentally an exercise in functional programming. The best known such translation, due to Murawski and Ong, compiles only the linear fragment BC, where some variables can only be referenced once. We show that this fragment can be evaluated in logspace. Next, we prove that extensions of their approach to the full BC language cannot provide a correct translation into LAL. In fact, any translation that interprets integers and primitive recursion via inductive type codings fails. Finally, we provide a correct, compositional translation between the two languages. For this translation we generalize Turing machine simulations into an SECD machine, realized in LAL.