28 research outputs found
Unary Pushdown Automata and Straight-Line Programs
We consider decision problems for deterministic pushdown automata over a
unary alphabet (udpda, for short). Udpda are a simple computation model that
accept exactly the unary regular languages, but can be exponentially more
succinct than finite-state automata. We complete the complexity landscape for
udpda by showing that emptiness (and thus universality) is P-hard, equivalence
and compressed membership problems are P-complete, and inclusion is
coNP-complete. Our upper bounds are based on a translation theorem between
udpda and straight-line programs over the binary alphabet (SLPs). We show that
the characteristic sequence of any udpda can be represented as a pair of
SLPs---one for the prefix, one for the lasso---that have size linear in the
size of the udpda and can be computed in polynomial time. Hence, decision
problems on udpda are reduced to decision problems on SLPs. Conversely, any SLP
can be converted in logarithmic space into a udpda, and this forms the basis
for our lower bound proofs. We show coNP-hardness of the ordered matching
problem for SLPs, from which we derive coNP-hardness for inclusion. In
addition, we complete the complexity landscape for unary nondeterministic
pushdown automata by showing that the universality problem is -hard, using a new class of integer expressions. Our techniques have
applications beyond udpda. We show that our results imply -completeness for a natural fragment of Presburger arithmetic and coNP lower
bounds for compressed matching problems with one-character wildcards
Extended Computation Tree Logic
We introduce a generic extension of the popular branching-time logic CTL
which refines the temporal until and release operators with formal languages.
For instance, a language may determine the moments along a path that an until
property may be fulfilled. We consider several classes of languages leading to
logics with different expressive power and complexity, whose importance is
motivated by their use in model checking, synthesis, abstract interpretation,
etc.
We show that even with context-free languages on the until operator the logic
still allows for polynomial time model-checking despite the significant
increase in expressive power. This makes the logic a promising candidate for
applications in verification.
In addition, we analyse the complexity of satisfiability and compare the
expressive power of these logics to CTL* and extensions of PDL
An extended direct branching algorithm for checking equivalence of deterministic pushdown automata
AbstractThis paper extends the direct branching algorithm of [25] for checking equivalence of deterministic pushdown automata. It does so by providing a technique called âhaltingâ for dealing with nodes with unbounded degree in the comparison tree. This may occur when a skipping step may be applied infinitely many times to a certain node, as a result of infinite sequences of Δ-moves.This extension allows the algorithm to check equivalence of two deterministic pushdown automata when none of them is real-time, but in a certain condition that properly contains a case where one of them is real-time strict
Bisimilarity of Pushdown Systems is Nonelementary
Given two pushdown systems, the bisimilarity problem asks whether they are
bisimilar. While this problem is known to be decidable our main result states
that it is nonelementary, improving EXPTIME-hardness, which was the previously
best known lower bound for this problem. Our lower bound result holds for
normed pushdown systems as well
Improving Programming Support for Hardware Accelerators Through Automata Processing Abstractions
The adoption of hardware accelerators, such as Field-Programmable Gate Arrays,
into general-purpose computation pipelines continues to rise, driven by recent
trends in data collection and analysis as well as pressure from challenging
physical design constraints in hardware. The architectural designs of many of
these accelerators stand in stark contrast to the traditional von Neumann model
of CPUs. Consequently, existing programming languages, maintenance tools, and
techniques are not directly applicable to these devices, meaning that additional
architectural knowledge is required for effective programming and configuration.
Current programming models and techniques are akin to assembly-level programming
on a CPU, thus placing significant burden on developers tasked with using these
architectures. Because programming is currently performed at such low levels of
abstraction, the software development process is tedious and challenging and
hinders the adoption of hardware accelerators.
This dissertation explores the thesis that theoretical finite automata provide a
suitable abstraction for bridging the gap between high-level programming models
and maintenance tools familiar to developers and the low-level hardware
representations that enable high-performance execution on hardware accelerators.
We adopt a principled hardware/software co-design methodology to develop a
programming model providing the key properties that we observe are necessary for success,
namely performance and scalability, ease of use, expressive power, and legacy
support.
First, we develop a framework that allows developers to port existing, legacy
code to run on hardware accelerators by leveraging automata learning algorithms
in a novel composition with software verification, string solvers, and
high-performance automata architectures. Next, we design a domain-specific
programming language to aid programmers writing pattern-searching algorithms and
develop compilation algorithms to produce finite automata, which supports
efficient execution on a wide variety of processing architectures. Then, we
develop an interactive debugger for our new language, which allows developers to
accurately identify the locations of bugs in software while maintaining support
for high-throughput data processing. Finally, we develop two new
automata-derived accelerator architectures to support additional applications,
including the detection of security attacks and the parsing of recursive and
tree-structured data. Using empirical studies, logical reasoning, and
statistical analyses, we demonstrate that our prototype artifacts scale to
real-world applications, maintain manageable overheads, and support developers'
use of hardware accelerators. Collectively, the research efforts detailed in
this dissertation help ease the adoption and use of hardware accelerators for
data analysis applications, while supporting high-performance computation.PHDComputer Science & EngineeringUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttps://deepblue.lib.umich.edu/bitstream/2027.42/155224/1/angstadt_1.pd
Characterizing Hardness in Parameterized Complexity
Parameterized complexity theory relaxes the classical notion of tractability and
allows to solve some classically hard problems in a reasonably efficient way. However, many problems of interest remain intractable in the context of parameterized
complexity. A completeness theory to categorize such problems has been developed
based on problems on circuits and Model Checking problems. Although a basic
machine characterization was proposed, it was not explored any further.
We develop a computational view of parameterized complexity theory based on
resource-bounded programs that run on alternating random access machines. We
develop both natural and normalized machine characterizations for the W[t] and
L[t] classes. Based on the new characterizations, we derive the basic completeness results in parameterized complexity theory, from a computational perspective. Unlike the previous cases, our proofs follow the classical approach for showing basic NP-completeness results (Cook's Theorem, in particular). We give new proofs of the Normalization Theorem by showing that (i) the computation of a resource-bounded program on an alternating RAM can be represented by instances of corre-
sponding basic parametric problems, and (ii) the basic parametric problems can be
decided by programs respecting the corresponding resource bounds. Many of the
fundamental results follow as a consequence of our new proof of the Normalization
Theorem. Based on a natural characterization of the W[t] classes, we develop new
structural results establishing relationships among the classes in the W-hierarchy, and the W[t] and L[t] classes.
Nontrivial upper-bound beyond the second level of the W-hierarchy is quite
uncommon. We make use of the ability to implement natural algorithms to show
new upper bounds for several parametric problems. We show that Subset Sum,
Maximal Irredundant Set, and Reachability Distance in Vector Addition Systems (Petri Nets) are in W[3], W[4], and W[5], respectively. In some cases, the new bounds result in new completeness results. We derive new lower bounds based on the normalized programs for the W[t] and L[t] classes.
We show that Longest Common Subsequence, with parameter the number of strings, is hard for L[t], t >= 1, and for W[SAT]. We also show that Precedence Constrained Multiprocessor Scheduling, with parameter the number of processors, is hard for L[t], t >= 1
Verification of Non-Regular Program Properties
Most temporal logics which have been introduced and studied in the past decades can be embedded into the modal mu-calculus. This is the case for e.g. PDL, CTL, CTL*, ECTL, LTL, etc. and entails that these logics cannot express non-regular program properties. In recent years, some novel approaches towards an increase in expressive power have been made: Fixpoint Logic with Chop enriches the mu-calculus with a sequential composition operator and thereby allows to characterise context-free processes. The Modal Iteration Calculus uses inflationary fixpoints to exceed the expressive power of the mu-calculus. Higher-Order Fixpoint Logic (HFL) incorporates a simply typed lambda-calculus into a setting with extremal fixpoint operators and even exceeds the expressive power of Fixpoint Logic with Chop. But also PDL has been equipped with context-free programs instead of regular ones.
In terms of expressivity there is a natural demand for richer frameworks since program property specifications are simply not limited to the regular sphere. Expressivity however usually comes at the price of an increased computational complexity of logic-related decision problems. For instance are the satisfiability problems for the above mentioned logics undecidable. We investigate in this work the model checking problem of three different logics which are capable of expressing non-regular program properties and aim at identifying fragments with feasible model checking complexity.
Firstly, we develop a generic method for determining the complexity of model checking PDL over arbitrary classes of programs and show that the border to undecidability runs between PDL over indexed languages and PDL over context-sensitive languages. It is however still in PTIME for PDL over linear indexed languages and in EXPTIME for PDL over indexed languages. We present concrete algorithms which allow implementations of model checkers for these two fragments.
We then introduce an extension of CTL in which the UNTIL- and RELEASE- operators are adorned with formal languages. These are interpreted over labeled paths and restrict the moments on such a path at which the operators are satisfied. The UNTIL-operator is for instance satisfied if some path prefix forms a word in the language it is adorned with (besides the usual requirement that until that moment some property has to hold and at that very moment some other property must hold). Again, we determine the computational complexities of the model checking problems for varying classes of allowed languages in either operator. It turns out that either enabling context-sensitive languages in the UNTIL or context-free languages in the RELEASE- operator renders the model checking problem undecidable while it is EXPTIME-complete for indexed languages in the UNTIL and visibly pushdown languages in the RELEASE- operator. PTIME-completeness is a result of allowing linear indexed languages in the UNTIL and deterministic context-free languages in the RELEASE. We do also give concrete model checking algorithms for several interesting fragments of these logics.
Finally, we turn our attention to the model checking problem of HFL which we have already studied in previous works. On finite state models it is k-EXPTIME-complete for HFL(k), the fragment of HFL obtained by restricting functions in the lambda-calculus to order k. Novel in this work is however the generalisation (from the first-order case to the case for functions of arbitrary order) of an idea to improve the best and average case behaviour of a model checking algorithm by using partial functions during the fixpoint iteration guided by the neededness of arguments. This is possible, because the semantics of a closed HFL formula is not a total function but the value of a function at some argument. Again, we give a concrete algorithm for such an improved model checker and argue that despite the very high model checking complexity this improvement is very useful in practice and gives feasible results for HFL with lower order fuctions, backed up by a statistical analysis of the number of needed arguments on a concrete example.
Furthermore, we show how HFL can be used as a tool for the development of algorithms. Its high expressivity allows to encode a wide variety of problems as instances of model checking already in the first-order fragment. The rather unintuitive -- yet very succinct -- problem encoding together with an analysis of the behaviour of the above sketched optimisation may give deep insights into the problem. We demonstrate this on the example of the universality problem for nondeterministic finite automata, where a slight variation of the optimised model checking algorithm yields one of the best known methods so far which was only discovered recently.
We do also investigate typical model-theoretic properties for each of these logics and compare them with respect to expressive power
Trace Inclusion for One-Counter Nets Revisited
One-Counter nets (OCN) consist of a nondeterministic finite control and a
single integer counter that cannot be fully tested for zero. They form a
natural subclass of both One-Counter Automata, which allow zero-tests and Petri
Nets/VASS, which allow multiple such weak counters.
The trace inclusion problem has recently been shown to be undecidable for
OCN. In this paper, we contrast the complexity of two natural restrictions
which imply decidability.
First, we show that trace inclusion between an OCN and a deterministic OCN is
NL-complete, even with arbitrary binary-encoded initial counter-values as part
of the input. Secondly, we show Ackermannian completeness of for the trace
universality problem of nondeterministic OCN. This problem is equivalent to
checking trace inclusion between a finite and a OCN-process
Automata theory and formal languages
These lecture notes present some basic notions and results on Automata Theory,
Formal Languages Theory, Computability Theory, and Parsing Theory. I prepared
these notes for a course on Automata, Languages, and Translators which I am
teaching at the University of Roma Tor Vergata. More material on these topics and
on parsing techniques for context-free languages can be found in standard textbooks
such as [1, 8, 9]. The reader is encouraged to look at those books.
A theorem denoted by the triple k.m.n is in Chapter k and Section m, and within
that section it is identified by the number n. Analogous numbering system is used
for algorithms, corollaries, definitions, examples, exercises, figures, and remarks. We
use âiffâ to mean âif and only ifâ.
Many thanks to my colleagues of the Department of Informatics, Systems, and
Production of the University of Roma Tor Vergata. I am also grateful to my stu-
dents and co-workers and, in particular, to Lorenzo Clemente, Corrado Di Pietro,
Fulvio Forni, Fabio Lecca, Maurizio Proietti, and Valerio Senni for their help and
encouragement.
Finally, I am grateful to Francesca Di Benedetto, Alessandro Colombo, Donato
Corvaglia, Gioacchino Onorati, and Leonardo Rinaldi of the Aracne Publishing Com-
pany for their kind cooperation