5,385 research outputs found
Proof Complexity of Systems of (Non-Deterministic) Decision Trees and Branching Programs
This paper studies propositional proof systems in which lines are sequents of decision trees or branching programs, deterministic or non-deterministic. Decision trees (DTs) are represented by a natural term syntax, inducing the system LDT, and non-determinism is modelled by including disjunction, ?, as primitive (system LNDT). Branching programs generalise DTs to dag-like structures and are duly handled by extension variables in our setting, as is common in proof complexity (systems eLDT and eLNDT).
Deterministic and non-deterministic branching programs are natural nonuniform analogues of log-space (L) and nondeterministic log-space (NL), respectively. Thus eLDT and eLNDT serve as natural systems of reasoning corresponding to L and NL, respectively.
The main results of the paper are simulation and non-simulation results for tree-like and dag-like proofs in LDT, LNDT, eLDT and eLNDT. We also compare them with Frege systems, constant-depth Frege systems and extended Frege systems
Proof complexity of positive branching programs
We investigate the proof complexity of systems based on positive branching
programs, i.e. non-deterministic branching programs (NBPs) where, for any
0-transition between two nodes, there is also a 1-transition. Positive NBPs
compute monotone Boolean functions, just like negation-free circuits or
formulas, but constitute a positive version of (non-uniform) NL, rather than P
or NC1, respectively.
The proof complexity of NBPs was investigated in previous work by Buss, Das
and Knop, using extension variables to represent the dag-structure, over a
language of (non-deterministic) decision trees, yielding the system eLNDT. Our
system eLNDT+ is obtained by restricting their systems to a positive syntax,
similarly to how the 'monotone sequent calculus' MLK is obtained from the usual
sequent calculus LK by restricting to negation-free formulas.
Our main result is that eLNDT+ polynomially simulates eLNDT over positive
sequents. Our proof method is inspired by a similar result for MLK by Atserias,
Galesi and Pudl\'ak, that was recently improved to a bona fide polynomial
simulation via works of Je\v{r}\'abek and Buss, Kabanets, Kolokolova and
Kouck\'y. Along the way we formalise several properties of counting functions
within eLNDT+ by polynomial-size proofs and, as a case study, give explicit
polynomial-size poofs of the propositional pigeonhole principle.Comment: 31 pages, 5 figure
Element Distinctness, Frequency Moments, and Sliding Windows
We derive new time-space tradeoff lower bounds and algorithms for exactly
computing statistics of input data, including frequency moments, element
distinctness, and order statistics, that are simple to calculate for sorted
data. We develop a randomized algorithm for the element distinctness problem
whose time T and space S satisfy T in O (n^{3/2}/S^{1/2}), smaller than
previous lower bounds for comparison-based algorithms, showing that element
distinctness is strictly easier than sorting for randomized branching programs.
This algorithm is based on a new time and space efficient algorithm for finding
all collisions of a function f from a finite set to itself that are reachable
by iterating f from a given set of starting points. We further show that our
element distinctness algorithm can be extended at only a polylogarithmic factor
cost to solve the element distinctness problem over sliding windows, where the
task is to take an input of length 2n-1 and produce an output for each window
of length n, giving n outputs in total. In contrast, we show a time-space
tradeoff lower bound of T in Omega(n^2/S) for randomized branching programs to
compute the number of distinct elements over sliding windows. The same lower
bound holds for computing the low-order bit of F_0 and computing any frequency
moment F_k, k neq 1. This shows that those frequency moments and the decision
problem F_0 mod 2 are strictly harder than element distinctness. We complement
this lower bound with a T in O(n^2/S) comparison-based deterministic RAM
algorithm for exactly computing F_k over sliding windows, nearly matching both
our lower bound for the sliding-window version and the comparison-based lower
bounds for the single-window version. We further exhibit a quantum algorithm
for F_0 over sliding windows with T in O(n^{3/2}/S^{1/2}). Finally, we consider
the computations of order statistics over sliding windows.Comment: arXiv admin note: substantial text overlap with arXiv:1212.437
Satisfiability Games for Branching-Time Logics
The satisfiability problem for branching-time temporal logics like CTL*, CTL
and CTL+ has important applications in program specification and verification.
Their computational complexities are known: CTL* and CTL+ are complete for
doubly exponential time, CTL is complete for single exponential time. Some
decision procedures for these logics are known; they use tree automata,
tableaux or axiom systems. In this paper we present a uniform game-theoretic
framework for the satisfiability problem of these branching-time temporal
logics. We define satisfiability games for the full branching-time temporal
logic CTL* using a high-level definition of winning condition that captures the
essence of well-foundedness of least fixpoint unfoldings. These winning
conditions form formal languages of \omega-words. We analyse which kinds of
deterministic {\omega}-automata are needed in which case in order to recognise
these languages. We then obtain a reduction to the problem of solving parity or
B\"uchi games. The worst-case complexity of the obtained algorithms matches the
known lower bounds for these logics. This approach provides a uniform, yet
complexity-theoretically optimal treatment of satisfiability for branching-time
temporal logics. It separates the use of temporal logic machinery from the use
of automata thus preserving a syntactical relationship between the input
formula and the object that represents satisfiability, i.e. a winning strategy
in a parity or B\"uchi game. The games presented here work on a Fischer-Ladner
closure of the input formula only. Last but not least, the games presented here
come with an attempt at providing tool support for the satisfiability problem
of complex branching-time logics like CTL* and CTL+
Tableaux for Policy Synthesis for MDPs with PCTL* Constraints
Markov decision processes (MDPs) are the standard formalism for modelling
sequential decision making in stochastic environments. Policy synthesis
addresses the problem of how to control or limit the decisions an agent makes
so that a given specification is met. In this paper we consider PCTL*, the
probabilistic counterpart of CTL*, as the specification language. Because in
general the policy synthesis problem for PCTL* is undecidable, we restrict to
policies whose execution history memory is finitely bounded a priori.
Surprisingly, no algorithm for policy synthesis for this natural and
expressive framework has been developed so far. We close this gap and describe
a tableau-based algorithm that, given an MDP and a PCTL* specification, derives
in a non-deterministic way a system of (possibly nonlinear) equalities and
inequalities. The solutions of this system, if any, describe the desired
(stochastic) policies.
Our main result in this paper is the correctness of our method, i.e.,
soundness, completeness and termination.Comment: This is a long version of a conference paper published at TABLEAUX
2017. It contains proofs of the main results and fixes a bug. See the
footnote on page 1 for detail
Pebbling, Entropy and Branching Program Size Lower Bounds
We contribute to the program of proving lower bounds on the size of branching
programs solving the Tree Evaluation Problem introduced by Cook et. al. (2012).
Proving a super-polynomial lower bound for the size of nondeterministic thrifty
branching programs (NTBP) would separate from for thrifty models
solving the tree evaluation problem. First, we show that {\em Read-Once NTBPs}
are equivalent to whole black-white pebbling algorithms thus showing a tight
lower bound (ignoring polynomial factors) for this model.
We then introduce a weaker restriction of NTBPs called {\em Bitwise
Independence}. The best known NTBPs (of size ) for the tree
evaluation problem given by Cook et. al. (2012) are Bitwise Independent. As our
main result, we show that any Bitwise Independent NTBP solving
must have at least states. Prior to this work, lower
bounds were known for NTBPs only for fixed heights (See Cook et. al.
(2012)). We prove our results by associating a fractional black-white pebbling
strategy with any bitwise independent NTBP solving the Tree Evaluation Problem.
Such a connection was not known previously even for fixed heights.
Our main technique is the entropy method introduced by Jukna and Z{\'a}k
(2001) originally in the context of proving lower bounds for read-once
branching programs. We also show that the previous lower bounds given by Cook
et. al. (2012) for deterministic branching programs for Tree Evaluation Problem
can be obtained using this approach. Using this method, we also show tight
lower bounds for any -way deterministic branching program solving Tree
Evaluation Problem when the instances are restricted to have the same group
operation in all internal nodes.Comment: 25 Pages, Manuscript submitted to Journal in June 2013 This version
includes a proof for tight size bounds for (syntactic) read-once NTBPs. The
proof is in the same spirit as the proof for size bounds for bitwise
independent NTBPs present in the earlier version of the paper and is included
in the journal version of the paper submitted in June 201
Quantified CTL: Expressiveness and Complexity
While it was defined long ago, the extension of CTL with quantification over
atomic propositions has never been studied extensively. Considering two
different semantics (depending whether propositional quantification refers to
the Kripke structure or to its unwinding tree), we study its expressiveness
(showing in particular that QCTL coincides with Monadic Second-Order Logic for
both semantics) and characterise the complexity of its model-checking and
satisfiability problems, depending on the number of nested propositional
quantifiers (showing that the structure semantics populates the polynomial
hierarchy while the tree semantics populates the exponential hierarchy)
- …