6 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.
Diamonds are not forever: Liveness in reactive programming with guarded recursion
When designing languages for functional reactive programming (FRP) the main
challenge is to provide the user with a simple, flexible interface for writing
programs on a high level of abstraction while ensuring that all programs can be
implemented efficiently in a low-level language. To meet this challenge, a new
family of modal FRP languages has been proposed, in which variants of Nakano's
guarded fixed point operator are used for writing recursive programs
guaranteeing properties such as causality and productivity. As an apparent
extension to this it has also been suggested to use Linear Temporal Logic (LTL)
as a language for reactive programming through the Curry-Howard isomorphism,
allowing properties such as termination, liveness and fairness to be encoded in
types. However, these two ideas are in conflict with each other, since the
fixed point operator introduces non-termination into the inductive types that
are supposed to provide termination guarantees.
In this paper we show that by regarding the modal time step operator of LTL a
submodality of the one used for guarded recursion (rather than equating them),
one can obtain a modal type system capable of expressing liveness properties
while retaining the power of the guarded fixed point operator. We introduce the
language Lively RaTT, a modal FRP language with a guarded fixed point operator
and an `until' type constructor as in LTL, and show how to program with events
and fair streams. Using a step-indexed Kripke logical relation we prove
operational properties of Lively RaTT including productivity and causality as
well as the termination and liveness properties expected of types from LTL.
Finally, we prove that the type system of Lively RaTT guarantees the absence of
implicit space leaks