17 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.
Lazy Abstraction-Based Controller Synthesis
We present lazy abstraction-based controller synthesis (ABCS) for
continuous-time nonlinear dynamical systems against reach-avoid and safety
specifications. State-of-the-art multi-layered ABCS pre-computes multiple
finite-state abstractions of varying granularity and applies reactive synthesis
to the coarsest abstraction whenever feasible, but adaptively considers finer
abstractions when necessary. Lazy ABCS improves this technique by constructing
abstractions on demand. Our insight is that the abstract transition relation
only needs to be locally computed for a small set of frontier states at the
precision currently required by the synthesis algorithm. We show that lazy ABCS
can significantly outperform previous multi-layered ABCS algorithms: on
standard benchmarks, lazy ABCS is more than 4 times faster
Flexible computational pipelines for robust abstraction based control synthesis
Successfully synthesizing controllers for complex dynamical systems and specifications often requires leveraging domain knowledge as well as making difficult computational or mathematical tradeoffs. This paper presents a flexible and extensible framework for constructing robust control synthesis algorithms and applies this to the traditional abstraction-based control synthesis pipeline. It is grounded in the theory of relational interfaces and provides a principled methodology to seamlessly combine different techniques (such as dynamic precision grids, refining abstractions while synthesizing, or decomposed control predecessors) or create custom procedures to exploit an application's intrinsic structural properties. A Dubins vehicle is used as a motivating example to showcase memory and runtime improvements.
Document type: Part of book or chapter of boo
Synthesizing Permissive Winning Strategy Templates for Parity Games
We present a novel method to compute \emph{permissive winning strategies} in
two-player games over finite graphs with -regular winning conditions.
Given a game graph and a parity winning condition , we compute a
\emph{winning strategy template} that collects an infinite number of
winning strategies for objective in a concise data structure. We use
this new representation of sets of winning strategies to tackle two problems
arising from applications of two-player games in the context of cyber-physical
system design -- (i) \emph{incremental synthesis}, i.e., adapting strategies to
newly arriving, \emph{additional} -regular objectives , and (ii)
\emph{fault-tolerant control}, i.e., adapting strategies to the occasional or
persistent unavailability of actuators. The main features of our strategy
templates -- which we utilize for solving these challenges -- are their easy
computability, adaptability, and compositionality. For \emph{incremental
synthesis}, we empirically show on a large set of benchmarks that our technique
vastly outperforms existing approaches if the number of added specifications
increases. While our method is not complete, our prototype implementation
returns the full winning region in all 1400 benchmark instances, i.e., handling
a large problem class efficiently in practice.Comment: CAV'2
On Abstraction-Based Controller Design With Output Feedback
We consider abstraction-based design of output-feedback controllers for
dynamical systems with a finite set of inputs and outputs against
specifications in linear-time temporal logic. The usual procedure for
abstraction-based controller design (ABCD) first constructs a finite-state
abstraction of the underlying dynamical system, and second, uses reactive
synthesis techniques to compute an abstract state-feedback controller on the
abstraction. In this context, our contribution is two-fold: (I) we define a
suitable relation between the original system and its abstraction which
characterizes the soundness and completeness conditions for an abstract
state-feedback controller to be refined to a concrete output-feedback
controller for the original system, and (II) we provide an algorithm to compute
a sound finite-state abstraction fulfilling this relation.
Our relation generalizes feedback-refinement relations from ABCD with
state-feedback. Our algorithm for constructing sound finite-state abstractions
is inspired by the simultaneous reachability and bisimulation minimization
algorithm of Lee and Yannakakis. We lift their idea to the computation of an
observation-equivalent system and show how sound abstractions can be obtained
by stopping this algorithm at any point. Additionally, our new algorithm
produces a realization of the topological closure of the input/output behavior
of the original system if it is finite-state realizable