<< Chapter < Page | Chapter >> Page > |
The awkwardness stems from the fact that in English, ``eventually'', ``always'',and ``until'' are primitives. When we design a formal language to capture with these concepts,shouldn't we too include them as primitives? Having our formal representations reflect ournatural conceptions of problems is the first law of programming!
This is why we have decided to incur the overhead of defining a new language, LTL.Still, you have noticed that the semantics we've given are phrased in terms of `` ''. From a language designer's perspective, we might say thatLTL is a high-level language, and we give an interpreter for it written in first-order logic(over the domain of trace-indices).
Let's look at how to turn a natural-English specification intotemporal logic, and vice versa.
How might we express the common client/server relationship ``if there is a request ( ), then it will be serviced ( )''?
Hmm, that seems obvious: should do it, no? Alas, no. The problem is, the truth of thisformulawhich has no temporal connectives at allonly depends upon the trace's initial state, in this case, whether . This certainly doesn't match our intent, sincewe want the request and service to be able to happen at points in the future.Let's try again
Does the formula capture the English notion``if is true, then will be true''?
That's only a bit better: it does now allow the implication to hold in any state . But our intent is to allow the servicing to happen after the request . The formula as given only expresses``Whenever is true, then is also true at that moment.'' If and both hold at the same time (which wouldn't be surprising),then fails for that trace.
After more thought, we can get something which does arguably match our intent: . ``Whenever a request is made, a servicing willeventually happen.''
However, even this may not be what everybody wants. Some considerations:
Notification Switch
Would you like to follow the 'Model checking concurrent programs' conversation and receive update notifications?