In previous work the author has introduced a lambda calculus SLR with modal and linear types which serves as an extension of Bellantoni-Cook's function algebra BC to higher types. It is a step towards a functional programming language in which all programs run in polynomial time. In this paper we develop a semantics of SLR using BCK-algebras consisting of certain polynomial-time algorithms. It will follow from this semantics that safe recursion with arbitrary result type built up from N and ( as well as recursion over trees and other data structures remains within polynomial time. In its original formulation SLR supported only natural numbers and recursion on notation with first order functional result type. 1 Introduction In [10] and [11] we have introduced a lambda calculus SLR which generalises the Bellantoni-Cook characterisation of PTIME [2] to higher-order functions. The separation between normal and safe variables which is crucial to the Bellantoni-Cook system has been achieved...

Abstract not found

More than being just a tool for expressing algorithms, a well-designed programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore of importance to understand how such choices effect the expressibility of programming languages. The paper pursues the very low complexity programs by presenting a first-order function algebra BC # that captures exactly LF, the functions computable in logarithmic space. This gives insights into the expressiveness of recursion. Moreover, it can be useful for the automatic analysis of programs' resource usage and the separation of complexity classes. The important technical features of BC # are (1) a separation of variables into safe and normal variables where recursion can only be done over the latter; (2) linearity of the recursive call; and (3) recursion with a variable step length (course-of-value recursion). Unlike formulations LF via Turin Machines, BC # makes no references to outside resource measures, e.g., the size of the memory used. This appears to be the first such characterization of LF-computable functions (not just predicates). The proof that all BC #-programs can be evaluated in LF is of separate interest to programmers: it trades space for time and evaluates recursion with at most one recursive call without a call stack.

) Kazushige Terui 3 Abstract Light Linear Logic (LLL) of [Gir95] characterizes the polytime functions through a careful handling of structural inference rules of logic. Based on this purely logical approach, we give a characterization of the polyspace functions. Our logical system is an extension of Intuitionistic Light Affine Logic (ILAL) of [Asp98], a variant of LLL with full (unrestricted) weakening. We introduce the notion of split terms and enrich ILAL by allowing a !- box to be formed from a split term. The resulting system, called Intuitionistic Polyspace Affine Logic, precisely characterizes the polyspace functions. 1 Introduction Linear Logical Approach to Computational Complexity. Over the past few decades, a considerable number of studies have been made on logical characterizations of computational complexity classes, aiming at giving an inherent (machine-independent) account on computational complexity from the logical point of view. Among those, Light Linear Logic (LL...

Higher-Order Linear Rami ed Recurrence (HOLRR) is a linear (ane) -calculus | every variable occurs at most once | extended with a recursive scheme on free algebras. Two simple conditions on type derivations enforce both polytime completeness and a strong notion of polytime soundness on typeable terms. Completeness for PTIME holds by embedding Leivant's rami ed recurrence on words into HOLRR. Soundness is established at all types | and not only for rst order terms. Type connectives are limited to tensor and linear implication.

2 DIAL∀l µ l 4 2.1 The dual typing system............................ 4 2.2 Data structures and notations......................... 5