21 research outputs found
Linear Logic by Levels and Bounded Time Complexity
We give a new characterization of elementary and deterministic polynomial
time computation in linear logic through the proofs-as-programs correspondence.
Girard's seminal results, concerning elementary and light linear logic, achieve
this characterization by enforcing a stratification principle on proofs, using
the notion of depth in proof nets. Here, we propose a more general form of
stratification, based on inducing levels in proof nets by means of indexes,
which allows us to extend Girard's systems while keeping the same complexity
properties. In particular, it turns out that Girard's systems can be recovered
by forcing depth and level to coincide. A consequence of the higher flexibility
of levels with respect to depth is the absence of boxes for handling the
paragraph modality. We use this fact to propose a variant of our polytime
system in which the paragraph modality is only allowed on atoms, and which may
thus serve as a basis for developing lambda-calculus type assignment systems
with more efficient typing algorithms than existing ones.Comment: 63 pages. To appear in Theoretical Computer Science. This version
corrects minor fonts problems from v
Unification and Logarithmic Space
We present an algebraic characterization of the complexity classes Logspace
and NLogspace, using an algebra with a composition law based on unification.
This new bridge between unification and complexity classes is inspired from
proof theory and more specifically linear logic and Geometry of Interaction.
We show how unification can be used to build a model of computation by means
of specific subalgebras associated to finite permutations groups. We then prove
that whether an observation (the algebraic counterpart of a program) accepts a
word can be decided within logarithmic space. We also show that the
construction can naturally represent pointer machines, an intuitive way of
understanding logarithmic space computing
Safe Recursion on Notation into a Light Logic by Levels
We embed Safe Recursion on Notation (SRN) into Light Affine Logic by Levels
(LALL), derived from the logic L4. LALL is an intuitionistic deductive system,
with a polynomial time cut elimination strategy.
The embedding allows to represent every term t of SRN as a family of proof
nets |t|^l in LALL. Every proof net |t|^l in the family simulates t on
arguments whose bit length is bounded by the integer l. The embedding is based
on two crucial features. One is the recursive type in LALL that encodes Scott
binary numerals, i.e. Scott words, as proof nets. Scott words represent the
arguments of t in place of the more standard Church binary numerals. Also, the
embedding exploits the "fuzzy" borders of paragraph boxes that LALL inherits
from L4 to "freely" duplicate the arguments, especially the safe ones, of t.
Finally, the type of |t|^l depends on the number of composition and recursion
schemes used to define t, namely the structural complexity of t. Moreover, the
size of |t|^l is a polynomial in l, whose degree depends on the structural
complexity of t.
So, this work makes closer both the predicative recursive theoretic
principles SRN relies on, and the proof theoretic one, called /stratification/,
at the base of Light Linear Logic
Logic Programming and Logarithmic Space
We present an algebraic view on logic programming, related to proof theory
and more specifically linear logic and geometry of interaction. Within this
construction, a characterization of logspace (deterministic and
non-deterministic) computation is given via a synctactic restriction, using an
encoding of words that derives from proof theory.
We show that the acceptance of a word by an observation (the counterpart of a
program in the encoding) can be decided within logarithmic space, by reducing
this problem to the acyclicity of a graph. We show moreover that observations
are as expressive as two-ways multi-heads finite automata, a kind of pointer
machines that is a standard model of logarithmic space computation
An Abstract Approach to Stratification in Linear Logic
We study the notion of stratification, as used in subsystems of linear logic
with low complexity bounds on the cut-elimination procedure (the so-called
light logics), from an abstract point of view, introducing a logical system in
which stratification is handled by a separate modality. This modality, which is
a generalization of the paragraph modality of Girard's light linear logic,
arises from a general categorical construction applicable to all models of
linear logic. We thus learn that stratification may be formulated independently
of exponential modalities; when it is forced to be connected to exponential
modalities, it yields interesting complexity properties. In particular, from
our analysis stem three alternative reformulations of Baillot and Mazza's
linear logic by levels: one geometric, one interactive, and one semantic
Unification and Logarithmic Space
We present an algebraic characterization of the complexity classes Logspace
and Nlogspace, using an algebra with a composition law based on unification.
This new bridge between unification and complexity classes is rooted in proof
theory and more specifically linear logic and geometry of interaction. We show
how to build a model of computation in the unification algebra and then, by
means of a syntactic representation of finite permutations in the algebra, we
prove that whether an observation (the algebraic counterpart of a program)
accepts a word can be decided within logarithmic space. Finally, we show that
the construction naturally corresponds to pointer machines, a convenient way of
understanding logarithmic space computation.Comment: arXiv admin note: text overlap with arXiv:1402.432
Unification and Logarithmic Space: Journal Version
Soumis au numéro spécial de LMCS pour RTA/TLCA 2014 ( http://www.lmcs-online.org/ojs/specialIssues.php?id=67 )We present an algebraic characterization of the complexity classes Logspace and NLogspace, using an algebra with a composition law based on unification. This new bridge between unification and complexity classes is rooted in proof theory and more specifically linear logic and geometry of interaction. We show how to build a model of computation in the unification algebra and then, by means of a syntactic representation of finite permutations in the algebra, we prove that whether an observation (the algebraic counterpart of a program) accepts a word can be decided within logarithmic space. Finally, we show that the construction naturally corresponds to pointer machines, an convenient way of understanding logarithmic space computation
Complete and tractable machine-independent characterizations of second-order polytime
The class of Basic Feasible Functionals BFF is the second-order counterpart
of the class of first-order functions computable in polynomial time. We present
several implicit characterizations of BFF based on a typed programming language
of terms. These terms may perform calls to non-recursive imperative procedures.
The type discipline has two layers: the terms follow a standard simply-typed
discipline and the procedures follow a standard tier-based type discipline. BFF
consists exactly of the second-order functionals that are computed by typable
and terminating programs. The completeness of this characterization
surprisingly still holds in the absence of lambda-abstraction. Moreover, the
termination requirement can be specified as a completeness-preserving instance,
which can be decided in time quadratic in the size of the program. As typing is
decidable in polynomial time, we obtain the first tractable (i.e., decidable in
polynomial time), sound, complete, and implicit characterization of BFF, thus
solving a problem opened for more than 20 years
A tier-based typed programming language characterizing Feasible Functionals
The class of Basic Feasible Functionals BFF is the type-2 counterpart of
the class FP of type-1 functions computable in polynomial time. Several
characterizations have been suggested in the literature, but none of these
present a programming language with a type system guaranteeing this complexity
bound. We give a characterization of BFF based on an imperative language
with oracle calls using a tier-based type system whose inference is decidable.
Such a characterization should make it possible to link higher-order complexity
with programming theory. The low complexity (cubic in the size of the program)
of the type inference algorithm contrasts with the intractability of the
aforementioned methods and does not overly constrain the expressive power of
the language