4,400 research outputs found
Sublogarithmic uniform Boolean proof nets
Using a proofs-as-programs correspondence, Terui was able to compare two
models of parallel computation: Boolean circuits and proof nets for
multiplicative linear logic. Mogbil et. al. gave a logspace translation
allowing us to compare their computational power as uniform complexity classes.
This paper presents a novel translation in AC0 and focuses on a simpler
restricted notion of uniform Boolean proof nets. We can then encode
constant-depth circuits and compare complexity classes below logspace, which
were out of reach with the previous translations.Comment: In Proceedings DICE 2011, arXiv:1201.034
Non-deterministic Boolean Proof Nets
16 pagesInternational audienceWe introduce Non-deterministic Boolean proof nets to study the correspondence with Boolean circuits, a parallel model of computation. We extend the cut elimination of Non-deterministic Multiplicative Linear logic to a parallel procedure in proof nets. With the restriction of proof nets to Boolean types, we prove that the cut-elimination procedure corresponds to Non-deterministic Boolean circuit evaluation and reciprocally. We obtain implicit characterization of the complexity classes NP and NC (the efficiently parallelizable functions)
Branching-time model checking of one-counter processes
One-counter processes (OCPs) are pushdown processes which operate only on a
unary stack alphabet. We study the computational complexity of model checking
computation tree logic (CTL) over OCPs. A PSPACE upper bound is inherited from
the modal mu-calculus for this problem. First, we analyze the periodic
behaviour of CTL over OCPs and derive a model checking algorithm whose running
time is exponential only in the number of control locations and a syntactic
notion of the formula that we call leftward until depth. Thus, model checking
fixed OCPs against CTL formulas with a fixed leftward until depth is in P. This
generalizes a result of the first author, Mayr, and To for the expression
complexity of CTL's fragment EF. Second, we prove that already over some fixed
OCP, CTL model checking is PSPACE-hard. Third, we show that there already
exists a fixed CTL formula for which model checking of OCPs is PSPACE-hard. To
obtain the latter result, we employ two results from complexity theory: (i)
Converting a natural number in Chinese remainder presentation into binary
presentation is in logspace-uniform NC^1 and (ii) PSPACE is AC^0-serializable.
We demonstrate that our approach can be used to obtain further results. We show
that model-checking CTL's fragment EF over OCPs is hard for P^NP, thus
establishing a matching lower bound and answering an open question of the first
author, Mayr, and To. We moreover show that the following problem is hard for
PSPACE: Given a one-counter Markov decision process, a set of target states
with counter value zero each, and an initial state, to decide whether the
probability that the initial state will eventually reach one of the target
states is arbitrarily close to 1. This improves a previously known lower bound
for every level of the Boolean hierarchy by Brazdil et al
Program transformation for functional circuit descriptions
We model sequential synchronous circuits on the logical level by signal-processing programs in an extended lambda calculus Lpor with letrec, constructors, case and parallel or (por) employing contextual equivalence. The model describes gates as (parallel) boolean operators, memory using a delay, which in turn is modeled as a shift of the list of signals, and permits also constructive cycles due to the parallel or. It opens the possibility of a large set of program transformations that correctly transform the expressions and thus the represented circuits and provides basic tools for equivalence testing and optimizing circuits. A further application is the correct manipulation by transformations of software components combined with circuits. The main part of our work are proof methods for correct transformations of expressions in the lambda calculus Lpor, and to propose the appropriate program transformations
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
Programmability of Chemical Reaction Networks
Motivated by the intriguing complexity of biochemical circuitry within individual cells we study Stochastic Chemical Reaction Networks (SCRNs), a formal model that considers a set of chemical reactions acting on a finite number of molecules in a well-stirred solution according to standard chemical kinetics equations. SCRNs have been widely used for describing naturally occurring (bio)chemical systems, and with the advent of synthetic biology they become a promising language for the design of artificial biochemical circuits. Our interest here is the computational power of SCRNs and how they relate to more conventional models of computation. We survey known connections and give new connections between SCRNs and Boolean Logic Circuits, Vector Addition Systems, Petri Nets, Gate Implementability, Primitive Recursive Functions, Register Machines, Fractran, and Turing Machines. A theme to these investigations is the thin line between decidable and undecidable questions about SCRN behavior
- âŚ