5,201 research outputs found
An infinite hierarchy induced by depth synchronization
AbstractDepth-synchronization measures the number of parallel derivation steps in a synchronized context-free (SCF) grammar. When not bounded by a constant the depth-synchronization measure of an SCF grammar is at least logarithmic and at most linear with respect to the word length. Languages with linear depth-synchronization measure and languages with a depth-synchronization measure in between logarithmic and linear are proven to exist. This gives rise to a strict infinite hierarchy within the family of SCF (and ET0L) languages
Synchronization and Control in Intrinsic and Designed Computation: An Information-Theoretic Analysis of Competing Models of Stochastic Computation
We adapt tools from information theory to analyze how an observer comes to
synchronize with the hidden states of a finitary, stationary stochastic
process. We show that synchronization is determined by both the process's
internal organization and by an observer's model of it. We analyze these
components using the convergence of state-block and block-state entropies,
comparing them to the previously known convergence properties of the Shannon
block entropy. Along the way, we introduce a hierarchy of information
quantifiers as derivatives and integrals of these entropies, which parallels a
similar hierarchy introduced for block entropy. We also draw out the duality
between synchronization properties and a process's controllability. The tools
lead to a new classification of a process's alternative representations in
terms of minimality, synchronizability, and unifilarity.Comment: 25 pages, 13 figures, 1 tabl
Spectral Simplicity of Apparent Complexity, Part I: The Nondiagonalizable Metadynamics of Prediction
Virtually all questions that one can ask about the behavioral and structural
complexity of a stochastic process reduce to a linear algebraic framing of a
time evolution governed by an appropriate hidden-Markov process generator. Each
type of question---correlation, predictability, predictive cost, observer
synchronization, and the like---induces a distinct generator class. Answers are
then functions of the class-appropriate transition dynamic. Unfortunately,
these dynamics are generically nonnormal, nondiagonalizable, singular, and so
on. Tractably analyzing these dynamics relies on adapting the recently
introduced meromorphic functional calculus, which specifies the spectral
decomposition of functions of nondiagonalizable linear operators, even when the
function poles and zeros coincide with the operator's spectrum. Along the way,
we establish special properties of the projection operators that demonstrate
how they capture the organization of subprocesses within a complex system.
Circumventing the spurious infinities of alternative calculi, this leads in the
sequel, Part II, to the first closed-form expressions for complexity measures,
couched either in terms of the Drazin inverse (negative-one power of a singular
operator) or the eigenvalues and projection operators of the appropriate
transition dynamic.Comment: 24 pages, 3 figures, 4 tables; current version always at
http://csc.ucdavis.edu/~cmg/compmech/pubs/sdscpt1.ht
Extending the Nested Parallel Model to the Nested Dataflow Model with Provably Efficient Schedulers
The nested parallel (a.k.a. fork-join) model is widely used for writing
parallel programs. However, the two composition constructs, i.e. ""
(parallel) and "" (serial), are insufficient in expressing "partial
dependencies" or "partial parallelism" in a program. We propose a new dataflow
composition construct "" to express partial dependencies in
algorithms in a processor- and cache-oblivious way, thus extending the Nested
Parallel (NP) model to the \emph{Nested Dataflow} (ND) model. We redesign
several divide-and-conquer algorithms ranging from dense linear algebra to
dynamic-programming in the ND model and prove that they all have optimal span
while retaining optimal cache complexity. We propose the design of runtime
schedulers that map ND programs to multicore processors with multiple levels of
possibly shared caches (i.e, Parallel Memory Hierarchies) and provide
theoretical guarantees on their ability to preserve locality and load balance.
For this, we adapt space-bounded (SB) schedulers for the ND model. We show that
our algorithms have increased "parallelizability" in the ND model, and that SB
schedulers can use the extra parallelizability to achieve asymptotically
optimal bounds on cache misses and running time on a greater number of
processors than in the NP model. The running time for the algorithms in this
paper is , where is the cache complexity of task ,
is the cost of cache miss at level- cache which is of size ,
is a constant, and is the number of processors in an
-level cache hierarchy
Model Checking Synchronized Products of Infinite Transition Systems
Formal verification using the model checking paradigm has to deal with two
aspects: The system models are structured, often as products of components, and
the specification logic has to be expressive enough to allow the formalization
of reachability properties. The present paper is a study on what can be
achieved for infinite transition systems under these premises. As models we
consider products of infinite transition systems with different synchronization
constraints. We introduce finitely synchronized transition systems, i.e.
product systems which contain only finitely many (parameterized) synchronized
transitions, and show that the decidability of FO(R), first-order logic
extended by reachability predicates, of the product system can be reduced to
the decidability of FO(R) of the components. This result is optimal in the
following sense: (1) If we allow semifinite synchronization, i.e. just in one
component infinitely many transitions are synchronized, the FO(R)-theory of the
product system is in general undecidable. (2) We cannot extend the expressive
power of the logic under consideration. Already a weak extension of first-order
logic with transitive closure, where we restrict the transitive closure
operators to arity one and nesting depth two, is undecidable for an
asynchronous (and hence finitely synchronized) product, namely for the infinite
grid.Comment: 18 page
Adiabaticity and spectral splits in collective neutrino transformations
Neutrinos streaming off a supernova core transform collectively by
neutrino-neutrino interactions, leading to "spectral splits" where an energy
E_split divides the transformed spectrum sharply into parts of almost pure but
different flavors. We present a detailed description of the spectral split
phenomenon which is conceptually and quantitatively understood in an adiabatic
treatment of neutrino-neutrino effects. Central to this theory is a
self-consistency condition in the form of two sum rules (integrals over the
neutrino spectra that must equal certain conserved quantities). We provide
explicit analytic and numerical solutions for various neutrino spectra. We
introduce the concept of the adiabatic reference frame and elaborate on the
relative adiabatic evolution. Violating adiabaticity leads to the spectral
split being "washed out". The sharpness of the split appears to be represented
by a surprisingly universal function.Comment: 20 pages, revtex, 13 figure
Computing with cells: membrane systems - some complexity issues.
Membrane computing is a branch of natural computing which abstracts computing models from the structure and the functioning of the living cell. The main ingredients of membrane systems, called P systems, are (i) the membrane structure, which consists of a hierarchical arrangements of membranes which delimit compartments where (ii) multisets of symbols, called objects, evolve according to (iii) sets of rules which are localised and associated with compartments. By using the rules in a nondeterministic/deterministic maximally parallel manner, transitions between the system configurations can be obtained. A sequence of transitions is a computation of how the system is evolving. Various ways of controlling the transfer of objects from one membrane to another and applying the rules, as well as possibilities to dissolve, divide or create membranes have been studied. Membrane systems have a great potential for implementing massively concurrent systems in an efficient way that would allow us to solve currently intractable problems once future biotechnology gives way to a practical bio-realization. In this paper we survey some interesting and fundamental complexity issues such as universality vs. nonuniversality, determinism vs. nondeterminism, membrane and alphabet size hierarchies, characterizations of context-sensitive languages and other language classes and various notions of parallelism
Spectral Simplicity of Apparent Complexity, Part II: Exact Complexities and Complexity Spectra
The meromorphic functional calculus developed in Part I overcomes the
nondiagonalizability of linear operators that arises often in the temporal
evolution of complex systems and is generic to the metadynamics of predicting
their behavior. Using the resulting spectral decomposition, we derive
closed-form expressions for correlation functions, finite-length Shannon
entropy-rate approximates, asymptotic entropy rate, excess entropy, transient
information, transient and asymptotic state uncertainty, and synchronization
information of stochastic processes generated by finite-state hidden Markov
models. This introduces analytical tractability to investigating information
processing in discrete-event stochastic processes, symbolic dynamics, and
chaotic dynamical systems. Comparisons reveal mathematical similarities between
complexity measures originally thought to capture distinct informational and
computational properties. We also introduce a new kind of spectral analysis via
coronal spectrograms and the frequency-dependent spectra of past-future mutual
information. We analyze a number of examples to illustrate the methods,
emphasizing processes with multivariate dependencies beyond pairwise
correlation. An appendix presents spectral decomposition calculations for one
example in full detail.Comment: 27 pages, 12 figures, 2 tables; most recent version at
http://csc.ucdavis.edu/~cmg/compmech/pubs/sdscpt2.ht
Adaptable processes
We propose the concept of adaptable processes as a way of overcoming the
limitations that process calculi have for describing patterns of dynamic
process evolution. Such patterns rely on direct ways of controlling the
behavior and location of running processes, and so they are at the heart of the
adaptation capabilities present in many modern concurrent systems. Adaptable
processes have a location and are sensible to actions of dynamic update at
runtime; this allows to express a wide range of evolvability patterns for
concurrent processes. We introduce a core calculus of adaptable processes and
propose two verification problems for them: bounded and eventual adaptation.
While the former ensures that the number of consecutive erroneous states that
can be traversed during a computation is bound by some given number k, the
latter ensures that if the system enters into a state with errors then a state
without errors will be eventually reached. We study the (un)decidability of
these two problems in several variants of the calculus, which result from
considering dynamic and static topologies of adaptable processes as well as
different evolvability patterns. Rather than a specification language, our
calculus intends to be a basis for investigating the fundamental properties of
evolvable processes and for developing richer languages with evolvability
capabilities
- …