Timed Default Concurrent Constraint Programming
Vijay Saraswat1996, Journal of Symbolic Computation
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
Synchronous programming (Berry (1989)) is a powerful approach to programming reactive systems. Following the idea that \processes are relations extended over time" (Abramsky (1993)), we propose a simple but powerful model for timed, determinate computation, extending the closure-operator model for untimed concurrent constraint programming (CCP). In (Saraswat et al. 1994a) we had proposed a model for this called tcc| here we extend the model of tcc to express strong time-outs: if an event A does not happen through time t, cause event B to happen at time t. Such constructs arise naturally in practice (e.g. in modeling transistors) and are supported in synchronous programming languages. The fundamental conceptual di culty posed by these operations is that they are nonmonotonic. We provide a compositional semantics to the non-monotonic version of concurrent constraint programming (Default cc) obtained by changing the underlying logic from intuitionistic logic to Reiter's default logic. This allows us to use the same construction (uniform extension through time) to develop Timed Default cc as we had used to develop tcc from cc. Indeed the smooth embedding of cc processes into Default cc processes lifts to a smooth embedding of tcc processes into Timed Default cc processes. We identify a basic set of combinators (that constitute the Timed Default cc programming framework), and provide a constructive operational semantics (implemented by us as an interpreter) for which the model is fully abstract. We show that the model is expressive by de ning combinators from the synchronous languages. We show that Timed Default cc is compositional and supports the properties of multiform time, orthogonal preemption and executable speci cations. In addition, Timed Default cc programs can be read as logical formulas (in an intuitionistic temporal logic) | we show that this logic is sound and complete for reasoning about (in)equivalence of Timed Default cc programs. Like the synchronouslanguages, Timed Default cc programscan be compiled into nite state automata. In addition, the translation can be speci ed compositionally. This enables separate compilation of Timed Default cc programs and run-time tradeo s between partial compilation and interpretation. A preliminary version of this paper was published as (Saraswat et al. 1995). Here we present a complete treatment of hiding, along with a detailed treatment of the model.
Related papers
Default Timed Concurrent Constraint Programming (Extended Abstract)
1995
We extend the model of SJG94b] to express strong timeouts (and pre-emption): if an event A does not happen through time t, cause event B to happen at time t. Such constructs arise naturally in practice (e.g. in modeling transistors) and are supported in languages such as Esterel (through instantaneous watchdogs) and Lustre (through the \current" operator).
Default timed concurrent constraint programming
Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '95, 1995
We extend the model of [VRV94] to express strong time-outs (and pre-emption): if an event A does not happen through time t, cause event B to happen at time t. Such constructs arise naturally in practice (e.g. in modeling transistors) and are supported in languages such as ESTEREL (through instantaneous watchdogs) and LUSTRE (through the "current" operator). The fundamental conceptual difficulty posed by these operators is that they are non-monotonic. We provide a simple compositional semantics to the non-monotonic version of concurrent constraint programming (CCP) obtained by changing the underlying logic from intuitionistic logic to Reiter's default logic [Rei80]. This allows us to use the same construction (uniform extension through time) to develop Default Timed CCP (Default tcc) as we had used to develop Timed CCP (tcc) from CCP [VRV94]. Indeed the smooth embedding of CCP processes into Default cc processes lifts to a smooth embedding of tcc processes into Default tcc processes. Interesting tcc properties such as determinacy, multi-form time, a uniform pre-emption construct ("clock"), full-abstraction, and compositional compilation into automata are preserved. Default tcc thus provides a simple and natural (denotational) model capable of representing the full range of pre-emption constructs supported in ESTEREL, LUSTRE and other synchronous programming languages.
The expressivity of universal timed CCP
Proceedings of the 10th international ACM SIGPLAN conference on Principles and practice of declarative programming, 2008
The timed concurrent constraint programing model (tcc) is a declarative framework, closely related to First-Order Linear Temporal Logic (FLTL), for modeling reactive systems. The universal tcc formalism (utcc) is an extension of tcc with the ability to express mobility. Here mobility is understood as communication of private names as typically done for mobile systems and security protocols. This paper is devoted to the study of 1) the expressiveness of utcc and 2) its semantic foundations. As applications of this study, we also state 3) a noteworthy decidability result for the well-established framework of FLTL and 4) bring new semantic insights into the modeling of security protocols. More precisely, we show that in contrast to tcc, utcc is Turing-powerful by encoding Minsky machines. The encoding uses a monadic constraint system allowing us to prove a new result for a fragment of FLTL: The undecidability of the validity problem for monadic FLTL without equality and function symbols. This result refutes a decidability conjecture for FLTL from a previous paper. It also justifies the restriction imposed in previous decidability results on the quantification of flexible-variables. We shall also show that as in tcc, utcc processes can be semantically represented as partial closure operators. The representation is fully abstract wrt the input-output behavior of processes for a meaningful fragment of the utcc. This shows that mobility can be captured as closure operators over an underlying constraint system. As an application we identify a language for security protocols that can be represented as closure operators over a cryptographic constraint system.
Timed Context-Free Temporal Logics
Electronic Proceedings in Theoretical Computer Science, 2018
The paper is focused on temporal logics for the description of the behaviour of real-time pushdown reactive systems. The paper is motivated to bridge tractable logics specialized for expressing separately dense-time real-time properties and context-free properties by ensuring decidability and tractability in the combined setting. To this end we introduce two real-time linear temporal logics for specifying quantitative timing context-free requirements in a pointwise semantics setting: Event-Clock Nested Temporal Logic (EC NTL) and Nested Metric Temporal Logic (NMTL). The logic EC NTL is an extension of both the logic CaRet (a context-free extension of standard LTL) and Event-Clock Temporal Logic (a tractable real-time logical framework related to the class of Event-Clock automata). We prove that satisfiability of EC NTL and visibly model-checking of Visibly Pushdown Timed Automata (VPTA) against EC NTL are decidable and EXPTIME-complete. The other proposed logic NMTL is a context-free extension of standard Metric Temporal Logic (MTL). It is well known that satisfiability of future MTL is undecidable when interpreted over infinite timed words but decidable over finite timed words. On the other hand, we show that by augmenting future MTL with future context-free temporal operators, the satisfiability problem turns out to be undecidable also for finite timed words. On the positive side, we devise a meaningful and decidable fragment of the logic NMTL which is expressively equivalent to EC NTL and for which satisfiability and visibly model-checking of VPTA are EXPTIME-complete. * The work by Adriano Peron and Aniello Murano has been partially supported by the GNCS project Formal methods for verification and synthesis of discrete and hybrid systems and by Dept. project MODAL MOdel-Driven Analysis of Critical Industrial Systems.
Timed Temporal Logics for Abstracting Transient States
Proceedings of the 4th International Conference on Automated Technology For Verification and Analysis, 2006
In previous work, the timed logic TCTL was extended with an "almost everywhere" Until modality which abstracts negligible sets of positions (i.e. with a null duration) along a run of a timed automaton. We propose here an extension of this logic with more powerful modalities, in order to specify properties abstracting transient states, which are events that last for less than k time units. Our main result is that modelchecking is still decidable and PSPACE-complete for this extension. On the other hand, a second semantics is defined, in which we consider the total duration where the property does not hold along a run. In this case, we prove that model-checking is undecidable. evolve at the rate of time (as in timed automata), are sometimes not expressive enough, hybrid variables (with multiple slopes) have been considered. The resulting model of hybrid automata has been largely studied in the subsequent years [16]. However, while some decidability results could be obtained [3, 18], using stopwatches (i.e. variables with slopes 0 and 1) already leads to undecidability for the reachability problem [2]. Further research has thus been devoted to weaker models where hybrid variables are only used as observers, i.e. are not tested in the automaton and thus play no role during a computation. These variables, sometimes called costs or prices in this context can be used in an optimization criterium [3, 7, 8, 11] or as constraints in temporal logic formulas. For instance, the logic WCTL [12, 10], interpreted over timed automata extended with costs, adds cost contraints on modalities: it is possible to express that a given state is reachable within a fixed cost bound. Abstracting transient states. When practical examples are considered, the need for abstracting transient states often happens. For example, modeling the instantaneous changes of a variable may introduce artificial (and thus non pertinent) transient states in the model. This motivated the work in [9], where configurations with zero duration could be abstracted by introducing into TCTL the almost everywhere U a modality. However, this is not sufficient in some cases. Contribution. In this paper, we propose an extension of TCTL called TCTL ∆ , which brings out a powerful generalization of the results in [9]. We introduce a new modality U k , where k ∈ N is a parameter, in order to abstract events that do not last continuously for at least k time units (t.u). For example, AF 2 ≤100 alarm expresses that for any execution, the atomic proposition alarm becomes true before 100 t.u and will hold for at least 2 time units. One also could express the fact that an event a precedes an event b along any run, an event being actually considered iff it lasts for at least k time units: the formula ArequestP 3 grant states that along any run where grant has occurred for a duration greater than 3, a request has been emitted continusously for a duration greater than 3. We prove that model-checking for TCTL ∆ is still PSPACE-complete. While the analogous result for TCTL or the extended version of [9] relies on the standard notion of equivalent runs, we have to define a stronger form for this equivalence, in order to obtain the consistency of TCTL ∆-formulae on the regions of the timed automaton. Finally, we also consider a global semantics, called TCTL ∆ Σ , for which the global duration during which a property does not hold, is bounded by a fixed constant k. Although this semantics is more natural and uses only observer hybrid variables in the model, we prove that model-checking TCTL ∆ Σ is undecidable. Outline. Section 2 recalls the main features of timed automata model and gives definitions for the syntax and semantics of our extended logics. Sections 3 and 4 are devoted to the model-checking of TCTL ∆ and, in the last section, we show that model-checking the extended logic TCTL ∆ Σ is undecidable.
Foundations of timed concurrent constraint programming
Proceedings Ninth Annual IEEE Symposium on Logic in Computer Science, 1994
We develop a model for timed, reactive computation by extending the asynchronous, untimed concurrent constraint programming model in a simple and uniform way. In the spirit of process algebras, we develop some combinators expressible in this model, and reconcile their operational, logical and denotational character. We show how programs may be compiled into finite-state machines with loop-free computations at each state, thus guaranteeing bounded response time.
A Timed Concurrent Constraint Language
Information and Computation, 2000
We study a timed concurrent constraint language, called tccp, which is obtained by a natural timed interpretation of the usual ccp constructs: action-prefixing is interpreted as the next-time operator and the parallel execution of agents follows the scheduling policy of maximal parallelism. Additionally, tccp includes a simple primitive which allows one to specify timing constraints. We define the operational semantics of tccp by means of a transition system and we define a denotational model which is fully abstract with respect to the usual notion of observables (that is, the results of terminating computations). Moreover, we study the semantics and expressive power of the notion of maximal parallelism underlying the computational model of tccp: We define a fully abstract semantics for a sublanguage of tccp, called ccpm, which essentially is concurrent constraint programming, provided that we interpret the parallel operator in terms of maximal parallelism rather than of interleaving. We show that tccp is strictly more expressive than ccpm which, in its turn, is strictly more expressive than ccp.
On the expressive power of temporal concurrent constraint programming languages
2002
The tcc paradigm is a formalism for timed concurrent constraint programming. Several tcc languages differing in their way of expressing infinite behavior have been proposed in the literature. In this paper we study the expressive power of some of these languages. In particular, we show that: (1) recursive procedures with parameters can be encoded into parameterless recursive procedures with dynamic scoping, and viceversa. (2) replication can be encoded into parameterless recursive procedures with static scoping, and viceversa. (3) the languages from (1) are strictly more expressive than the languages from (2). Furthermore, we show that behavioral equivalence is undecidable for the languages from (1), but decidable for the languages from (2). The undecidability result holds even if the process variables take values from a fixed finite domain.
Linear Temporal Logics for Structured Context-Free Languages
2020
The need to extend traditional temporal logics to express and prove properties typical of stack-based formalisms led, among others, to CaRet and NWTL on Visibly Pushdown Languages (VPL). Such formalisms support, e.g., model checking of procedural programs and other context-free languages (CFL). To further and significantly extend their expressive power, we recently introduced the logic OPTL, based on Operator Precedence Languages (OPL) which cover a much wider subclass of CFL. In this communication we survey the latest developments of our work. We introduced a novel temporal logic, POTL, that redefines OPTL to be First-Order complete. Furthermore, POTL’s semantics is better connected to the typical treestructure of CFL while retaining the ability to reason about linear time. Besides the theoretical advancements, we are also moving steps toward the implementation of POTL model checking.
A framework for abstract interpretation of timed concurrent constraint programs
2009
Timed Concurrent Constraint Programming (tcc) is a declarative model for concurrency offering a logic for specifying reactive systems, i.e. systems that continuously interact with the environment. The universal tcc formalism (utcc) is an extension of tcc with the ability to express mobility. Here mobility is understood as communication of private names as typically done for mobile systems and security protocols. In this paper we consider the denotational semantics for tcc, and we extend it to a "collecting" semantics for utcc based on closure operators over sequences of constraints. Relying on this semantics, we formalize the first general framework for data flow analyses of tcc and utcc programs by abstract interpretation techniques. The concrete and abstract semantics we propose are compositional, thus allowing us to reduce the complexity of data flow analyses. We show that our method is sound and parametric w.r.t. the abstract domain. Thus, different analyses can be performed by instantiating the framework. We illustrate how it is possible to reuse abstract domains previously defined for logic programming, e.g., to perform a groundness analysis for tcc programs. We show the applicability of this analysis in the context of reactive systems. Furthermore, we make also use of the abstract semantics to exhibit a secrecy flaw in a security protocol. We have developed a prototypical implementation of our methodology and we have implemented the abstract domain for security to perform automatically the secrecy analysis.
The Railroad Crossing Problem: Towards semantics of timed algorithms and their model checking in high level languages
Lecture Notes in Computer Science, 1997
The goal of this paper is to analyse semantics of algorithms with explicit continuous time with further aim to find approaches to automatize model checking in high level, easily understandable languages. We give here a general notion of timed transition system and its formula representation that are sufficient to deal with some known examples of timed algorithms. We prove that the general semantics gives the same executions as direct, more intuitive interpretations of executions of algorithms. In a way, we try to give a general treatment of considerations of Yu.Gurevich and his co-authors concerning concrete Gurevich machines (called evolving algebras in [Gur95]), in particular, related to Railroad Crossing Problem [GH96]. Besides that we formalize specifications of this problem in a high level language which permits to rewrite directly natural language formulations, and to give a formal proof of correctness of the railroad crossing algorithm using rather a small amount of logical means, and this leads to hypotheses how automatize inference search.
On Continuous Timed Automata with Input-Determined Guards
Lecture Notes in Computer Science, 2006
We consider a general notion of timed automata with inputdetermined guards and show that they admit a robust logical framework along the lines of [6], in terms of a monadic second order logic characterisation and an expressively complete timed temporal logic. We then generalise these automata using the notion of recursive operators introduced by Henzinger, Raskin, and Schobbens [9], and show that they admit a similar logical framework. These results hold in the "pointwise" semantics. We finally use this framework to show that the real-time logic MITL of Alur et al [2] is expressively complete with respect to an MSO corresponding to an appropriate input-determined operator.
On Timed Scope-Bounded Context-Sensitive Languages
Lecture Notes in Computer Science, 2019
In (DLT 2016) we studied timed context sensitive languages characterized by multiple stack push down automata (MPA), with an explicit bound on number of stages where in each stage at most one stack is used (k-round MPA). In this paper, we continue our work on timed MPA and study a subclass in which a symbol corresponding to a stack being pushed in it must be popped within fixed number of contexts of that stack-scope-bounded push-down automata with multiple stacks (k-scope MPA). We use Visibly Push-down Alphabet and Event Clocks to show that timed k-scope MPA have decidable reachability problem; are closed under Boolean operations; and have an equivalent logical characterization.
Compositional timing-aware semantics for synchronous programming
2017 Forum on Specification and Design Languages (FDL), 2017
In this paper we propose a WCRT analysis technique for synchronous programs, executed as sequential or multithreaded code, based on formal power series in min-max-plus algebra. The algebraic model constitutes the first fully declarative timing-aware semantics of synchronous programs with arbitrary hierarchical control-flow structure. Under signal abstraction this model permits efficient compositional WCRT analyses based on structural boxes as the unit of composition. The algebraic model leads to a sound methodology to deal with the state space explosion arising from tick alignment of parallel composition by reduction to the maximum weighted clique problem.
On using temporal logic for refinement and compositional verification of concurrent systems
Theoretical Computer Science, 1995
A simple and elegant formulation of compositional proof systems for concurrent programs results from a refinement of temporal logic semantics. The refined temporal language we propose is closed under w-stuttering and, thus, provides a fully abstract semantics with respect to some chosen observation level w. This avoids incorporating irrelevant detail in the temporal semantics of parallel programs. Besides compositional verification, concurrent program design and implementation of a coarser-grained program by a finer-grained one, are easily practicable in the setting of the new temporal logic.
Towards an automata-theoretic counterpart of combined temporal logics
2001
In this paper, we define a new class of combined automata, called temporalized automata, which can be viewed as the automata-theoretic counterpart of temporalized logics, and show that relevant properties, such as closure under Boolean operations, decidability, and expressive equivalence with respect to temporal logics, transfer from component automata to temporalized ones. Furthermore, we successfully apply temporalized automata to provide the full secondorder theory of k-refinable downward unbounded layered structures with a temporal logic counterpart. Finally, we show how temporalized automata can be used to deal with relevant classes of reactive systems, such as granular reactive systems and mobile reactive systems.
On the expressiveness of timed coordination models
Scp, 2006
Although very simple and elegant, Linda-style coordination models lack the notion of time, and are therefore not able to precisely model real-life coordination applications. Nevertheless, industrial proposals such as TSpaces and JavaSpaces, inspired from Linda, have incorporated time constructs.
Notes on Timed Concurrent Constraint Programming
Lecture Notes in Computer Science, 2004
A constraint is a piece of (partial) information on the values of the variables of a system. Concurrent constraint programming (ccp) is a model of concurrency in which agents (also called processes) interact by telling and asking information (constraints) to and from a shared store (a constraint). Timed (or temporal) ccp (tccp) extends ccp by agents evolving over time. A distinguishing feature of tccp, is that it combines in one framework an operational and algebraic view from process algebra with a declarative view based upon temporal logic. Tccp has been widely used to specify, analyze and program reactive systems. This note provides a comprehensive introduction to the background for and central notions from the theory of tccp. Furthermore, it surveys recent results on a particular tccp calculus, ntcc , and it provides a classification of the expressive power of various tccp languages.
Temporal Logics, Automata, and Classical Theories for Defining Real-Time Languages
1999
Abstract A specification formalism for reactive systems defines a class of!-languages. We call a specification formalism fully decidable if it is constructively closed under boolean operations and has a decidable satisfiability nonemptiness problem. There are two important, robust classes of!-languages that are definable by fully decidable formalisms. The!-regular languages are definable by finite automata, or equivalently, by the Sequential Calculus.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.