16,430 research outputs found
Temporal Stream Logic: Synthesis beyond the Bools
Reactive systems that operate in environments with complex data, such as
mobile apps or embedded controllers with many sensors, are difficult to
synthesize. Synthesis tools usually fail for such systems because the state
space resulting from the discretization of the data is too large. We introduce
TSL, a new temporal logic that separates control and data. We provide a
CEGAR-based synthesis approach for the construction of implementations that are
guaranteed to satisfy a TSL specification for all possible instantiations of
the data processing functions. TSL provides an attractive trade-off for
synthesis. On the one hand, synthesis from TSL, unlike synthesis from standard
temporal logics, is undecidable in general. On the other hand, however,
synthesis from TSL is scalable, because it is independent of the complexity of
the handled data. Among other benchmarks, we have successfully synthesized a
music player Android app and a controller for an autonomous vehicle in the Open
Race Car Simulator (TORCS.
Robust Transmission in Downlink Multiuser MISO Systems: A Rate-Splitting Approach
We consider a downlink multiuser MISO system with bounded errors in the
Channel State Information at the Transmitter (CSIT). We first look at the
robust design problem of achieving max-min fairness amongst users (in the
worst-case sense). Contrary to the conventional approach adopted in literature,
we propose a rather unorthodox design based on a Rate-Splitting (RS) strategy.
Each user's message is split into two parts, a common part and a private part.
All common parts are packed into one super common message encoded using a
public codebook, while private parts are independently encoded. The resulting
symbol streams are linearly precoded and simultaneously transmitted, and each
receiver retrieves its intended message by decoding both the common stream and
its corresponding private stream. For CSIT uncertainty regions that scale with
SNR (e.g. by scaling the number of feedback bits), we prove that a RS-based
design achieves higher max-min (symmetric) Degrees of Freedom (DoF) compared to
conventional designs (NoRS). For the special case of non-scaling CSIT (e.g.
fixed number of feedback bits), and contrary to NoRS, RS can achieve a
non-saturating max-min rate. We propose a robust algorithm based on the
cutting-set method coupled with the Weighted Minimum Mean Square Error (WMMSE)
approach, and we demonstrate its performance gains over state-of-the art
designs. Finally, we extend the RS strategy to address the Quality of Service
(QoS) constrained power minimization problem, and we demonstrate significant
gains over NoRS-based designs.Comment: Accepted for publication in IEEE Transactions on Signal Processin
Towards an Effective Decision Procedure for LTL formulas with Constraints
This paper presents an ongoing work that is part of a more wide-ranging
project whose final scope is to define a method to validate LTL formulas w.r.t.
a program written in the timed concurrent constraint language tccp, which is a
logic concurrent constraint language based on the concurrent constraint
paradigm of Saraswat. Some inherent notions to tccp processes are
non-determinism, dealing with partial information in states and the monotonic
evolution of the information. In order to check an LTL property for a process,
our approach is based on the abstract diagnosis technique. The concluding step
of this technique needs to check the validity of an LTL formula (with
constraints) in an effective way.
In this paper, we present a decision method for the validity of temporal
logic formulas (with constraints) built by our abstract diagnosis technique.Comment: Part of WLPE 2013 proceedings (arXiv:1308.2055
Temporal Stream Algebra
Data stream management systems (DSMS) so far focus on
event queries and hardly consider combined queries to both
data from event streams and from a database. However,
applications like emergency management require combined
data stream and database queries. Further requirements are
the simultaneous use of multiple timestamps after different
time lines and semantics, expressive temporal relations between multiple time-stamps and
exible negation, grouping
and aggregation which can be controlled, i. e. started and
stopped, by events and are not limited to fixed-size time
windows. Current DSMS hardly address these requirements.
This article proposes Temporal Stream Algebra (TSA) so
as to meet the afore mentioned requirements. Temporal
streams are a common abstraction of data streams and data-
base relations; the operators of TSA are generalizations of
the usual operators of Relational Algebra. A in-depth 'analysis of temporal relations guarantees that valid TSA expressions are non-blocking, i. e. can be evaluated incrementally.
In this respect TSA differs significantly from previous algebraic approaches which use specialized operators to prevent
blocking expressions on a "syntactical" level
Abstract Diagnosis for Timed Concurrent Constraint programs
The Timed Concurrent Constraint Language (tccp in short) is a concurrent
logic language based on the simple but powerful concurrent constraint paradigm
of Saraswat. In this paradigm, the notion of store-as-value is replaced by the
notion of store-as-constraint, which introduces some differences w.r.t. other
approaches to concurrency. In this paper, we provide a general framework for
the debugging of tccp programs. To this end, we first present a new compact,
bottom-up semantics for the language that is well suited for debugging and
verification purposes in the context of reactive systems. We also provide an
abstract semantics that allows us to effectively implement debugging algorithms
based on abstract interpretation. Given a tccp program and a behavior
specification, our debugging approach automatically detects whether the program
satisfies the specification. This differs from other semiautomatic approaches
to debugging and avoids the need to provide symptoms in advance. We show the
efficacy of our approach by introducing two illustrative examples. We choose a
specific abstract domain and show how we can detect that a program is
erroneous.Comment: 16 page
Using Functional Programming to recognize Named Structure in an Optimization Problem: Application to Pooling
Branch-and-cut optimization solvers typically apply generic algorithms, e.g., cutting planes or primal heuristics, to expedite performance for many mathematical optimization problems. But solver software receives an input optimization problem as vectors of equations and constraints containing no structural information. This article proposes automatically detecting named special structure using the pattern matching features of functional programming. Specifically, we deduce the industrially-relevant nonconvex nonlinear Pooling Problem within a mixed-integer nonlinear optimization problem and show that we can uncover pooling structure in optimization problems which are not pooling problems. Previous work has shown that preprocessing heuristics can find network structures; we show that we can additionally detect nonlinear pooling patterns. Finding named structures allows us to apply, to generic optimization problems, cutting planes or primal heuristics developed for the named structure. To demonstrate the recognition algorithm, we use the recognized structure to apply primal heuristics to a test set of standard pooling problems
- …