14,290 research outputs found
Minimizing Tree Automata for Unranked Trees
International audienceAutomata for unranked trees form a foundation for XML schemas, querying and pattern languages. We study the problem of efficiently minimizing such automata. We start with the unranked tree automata (UTAs) that are standard in database theory, assuming bottom-up determinism and that horizontal recursion is represented by deterministic finite automata. We show that minimal UTAs in that class are not unique and that minimization is NP-hard. We then study more recent automata classes that do allow for polynomial time minimization. Among those, we show that bottom-up deterministic stepwise tree automata yield the most succinct representations
Optimal Hierarchical Layouts for Cache-Oblivious Search Trees
This paper proposes a general framework for generating cache-oblivious
layouts for binary search trees. A cache-oblivious layout attempts to minimize
cache misses on any hierarchical memory, independent of the number of memory
levels and attributes at each level such as cache size, line size, and
replacement policy. Recursively partitioning a tree into contiguous subtrees
and prescribing an ordering amongst the subtrees, Hierarchical Layouts
generalize many commonly used layouts for trees such as in-order, pre-order and
breadth-first. They also generalize the various flavors of the van Emde Boas
layout, which have previously been used as cache-oblivious layouts.
Hierarchical Layouts thus unify all previous attempts at deriving layouts for
search trees.
The paper then derives a new locality measure (the Weighted Edge Product)
that mimics the probability of cache misses at multiple levels, and shows that
layouts that reduce this measure perform better. We analyze the various degrees
of freedom in the construction of Hierarchical Layouts, and investigate the
relative effect of each of these decisions in the construction of
cache-oblivious layouts. Optimizing the Weighted Edge Product for complete
binary search trees, we introduce the MinWEP layout, and show that it
outperforms previously used cache-oblivious layouts by almost 20%.Comment: Extended version with proofs added to the appendi
Using Hashing to Solve the Dictionary Problem (In External Memory)
We consider the dictionary problem in external memory and improve the update
time of the well-known buffer tree by roughly a logarithmic factor. For any
\lambda >= max {lg lg n, log_{M/B} (n/B)}, we can support updates in time
O(\lambda / B) and queries in sublogarithmic time, O(log_\lambda n). We also
present a lower bound in the cell-probe model showing that our data structure
is optimal.
In the RAM, hash tables have been used to solve the dictionary problem faster
than binary search for more than half a century. By contrast, our data
structure is the first to beat the comparison barrier in external memory. Ours
is also the first data structure to depart convincingly from the indivisibility
paradigm
Generalized Fragmentation Functions for Fractal Jet Observables
We introduce a broad class of fractal jet observables that recursively probe
the collective properties of hadrons produced in jet fragmentation. To describe
these collinear-unsafe observables, we generalize the formalism of
fragmentation functions, which are important objects in QCD for calculating
cross sections involving identified final-state hadrons. Fragmentation
functions are fundamentally nonperturbative, but have a calculable
renormalization group evolution. Unlike ordinary fragmentation functions,
generalized fragmentation functions exhibit nonlinear evolution, since fractal
observables involve correlated subsets of hadrons within a jet. Some special
cases of generalized fragmentation functions are reviewed, including jet charge
and track functions. We then consider fractal jet observables that are based on
hierarchical clustering trees, where the nonlinear evolution equations also
exhibit tree-like structure at leading order. We develop a numeric code for
performing this evolution and study its phenomenological implications. As an
application, we present examples of fractal jet observables that are useful in
discriminating quark jets from gluon jets.Comment: 37+18 pages, 24 figure
Improved Bounds for Drawing Trees on Fixed Points with L-shaped Edges
Let be an -node tree of maximum degree 4, and let be a set of
points in the plane with no two points on the same horizontal or vertical line.
It is an open question whether always has a planar drawing on such that
each edge is drawn as an orthogonal path with one bend (an "L-shaped" edge). By
giving new methods for drawing trees, we improve the bounds on the size of the
point set for which such drawings are possible to: for
maximum degree 4 trees; for maximum degree 3 (binary) trees; and
for perfect binary trees.
Drawing ordered trees with L-shaped edges is harder---we give an example that
cannot be done and a bound of points for L-shaped drawings of
ordered caterpillars, which contrasts with the known linear bound for unordered
caterpillars.Comment: Appears in the Proceedings of the 25th International Symposium on
Graph Drawing and Network Visualization (GD 2017
On intervals in some posets of forests
A nice factorization is given for the characteristic polynomials of intervals
in some posets of leaf-labeled forests of rooted binary trees.Comment: 14 pages, 5 figure
Left Recursion in Parsing Expression Grammars
Parsing Expression Grammars (PEGs) are a formalism that can describe all
deterministic context-free languages through a set of rules that specify a
top-down parser for some language. PEGs are easy to use, and there are
efficient implementations of PEG libraries in several programming languages.
A frequently missed feature of PEGs is left recursion, which is commonly used
in Context-Free Grammars (CFGs) to encode left-associative operations. We
present a simple conservative extension to the semantics of PEGs that gives
useful meaning to direct and indirect left-recursive rules, and show that our
extensions make it easy to express left-recursive idioms from CFGs in PEGs,
with similar results. We prove the conservativeness of these extensions, and
also prove that they work with any left-recursive PEG.
PEGs can also be compiled to programs in a low-level parsing machine. We
present an extension to the semantics of the operations of this parsing machine
that let it interpret left-recursive PEGs, and prove that this extension is
correct with regards to our semantics for left-recursive PEGs.Comment: Extended version of the paper "Left Recursion in Parsing Expression
Grammars", that was published on 2012 Brazilian Symposium on Programming
Language
- …