Knowledge Representation, Reasoning and Inte-gration Using ...

Knowledge Representation, Reasoning and Integration Using Temporal Logic with Clocks Mehmet A. Orgun, Chuchang Liu and Abhaya C. Nayak Abstract. Representation, reasoning about and integrating knowledge based on multiple time granularities in knowledge-based systems is important, especially when talking about events that take place in the real world. Formal approaches based on temporal logics have been successfully applied in many application domains of knowledgebased systems where the evolution of a system and its environment through time is central. This paper presents a methodology based on temporal logic to deal with knowledge based on multiple time granularities in knowledge-based systems. The temporal logic we consider is especially suitable for modelling events with different rates and/or scales of progress. The methodology includes an approach to the representation of timing systems, a method used for representing facts and rules in a knowledge-based system that involve multiple time granularities using temporal logic, and several deductive reasoning techniques. Mathematics Subject Classification (2000). Knowledge representation 68T30; Logic in artificial intelligence 68T27. Keywords. Multiple Granularity of Time, Temporal Logics, Temporal Knowledge Representation.

1. Introduction Time representation has played a central role in many applications in computer science research and applications where dynamic changes are essential, such as temporal database systems [10, 35, 46], concurrent and distributed systems [32, 30], hybrid systems [33], medical applications [3], multi-agent systems [31, 19], analysis of security protocols [8, 23], temporal reasoning [1, 42] and so on. In knowledge acquisition, representation and integration in knowledge-based systems, the representation of multiple time granularities [7, 18, 28, 37] has also appeared as one of the critical issues. In fact, especially when we are talking about the real world and the events that take place in it, there is often a The work presented in this article has been supported in part by The Australian Research Council and Macquarie University. Note that this paper is an extended and revised version of Orgun, Liu and Nayak[37].

2

Orgun, Liu and Nayak

need to deal with multiple time granularities (and also multiple time-lines) in a variety of knowledge-based systems, such as ecological modeling [34], medical expert systems [12] and planning systems [4] where we may need to consider how knowledge defined at different levels of time may be integrated. Many researchers have been studying aspects of multiple granularity of time in diverse areas of research in computer science and artificial intelligence [5]. Some events occur at irregular intervals, and it seems unnatural to force them all onto a prescribed notion of time. Doing so would lead to semantic mismatches. Ladkin [25] recognized that distinct granularities cannot be mixed, and developed an algebra where the granularity of the source time-stamps of events is considered. Wiederhold et al. [46] provide an algebra in which data with multiple granularities of time are converted to a uniform model of data based on time intervals. Such an approach requires interpolation of data with multiple granularities over intervals using a history operator H, based on certain assumptions. Dyreson and Snodgrass [16] extended SQL-92 to support mixed granularities with respect to a granularity lattice. In their approach, a granularity is a calendar-dependent partitioning of the time-line. They provided two operations, scale and cast, that move times within the granularity lattice. Plaice and Gagne [40] proposed to use non-standard real numbers and hence a dense set of instants, which allows for the use of two-levels of granularity of time (a discrete one and a dense one) in a temporal deductive database system. In order to express specific relations and properties among time units, Cukierman and Delgrande [13] define a hierarchical time unit structure, which is able to represent and reason about repeated (periodic) activities. In Euzenat’s algebraic approach [18], a pair of operators , upward (↑) and downward (↓), are proposed to convert qualitative time relationships from one granularity of time to another. Bettini et al. [7] define time granularities by temporal types and discuss data conversions among different granularities of time. Egidi and Terenziani [17] proposed an expressive symbolic approach to representing user-defined periodicities based on a lattice of classes of periodicities. Bettini and Mascetti [6] considered the representation of a time granularity to a minimal form so that the complexity of processing such information can be reduced. More recently, Dal Lago et al [14] proposed an alternative automaton-based approach, which can support infinite time granularities. Granularity of time is also a key issue in program specification and verification. For instance, reactive systems [32], including real-time systems, are usually subject to “hard” timing constraints, such as response time. Although timing constraints are usually defined in terms of a global time, the processes involved in such a system have their own local time. Hybrid systems [33] also exhibit similar characteristics with an underlying formalism based on phase transition systems that allow variables vary continuously over time. A process only “sees” local events, such as sending a message to and receiving a message from other processes through its buffers (in the case of asynchronous communication). That is, one process is not always defined at all the moments in time on the global clock. To describe such reactive and dynamic systems, it is more natural to use multiple granularity of time for modeling the behavior of processes and events. Temporal logics [43] can be used for reasoning about a dynamic world. They are in particular suitable for the description of timing properties of computational systems

Temporal Knowledge Representation

3

such as reactive and hybrid systems [32, 33, 30]; and even as executable systems on their own right [20, 21, 22, 36]. However, many temporal logics proposed for specifying and verifying reactive and concurrent systems, such as the logic of Manna and Pnueli [32] and the Temporal Logic of Actions (TLA) [26], do not provide support for time representation at multiple levels of granularity. Combi and Rossato [11] propose a formal framework based on a linear temporal logic allowing the expression of temporal trends which involve multiple granularities. However in their approach multiple granularities are handled within the object language explicitly. Their approach does not include a deductive reasoning component either. Liu and Orgun [28, 30] proposed a linear-time temporal logic called Temporal Logic with Clocks (TLC) which can be used to deal with multiple granularity of time implicitly. TLC grew out of the work of Orgun and Wadge [38, 39, 45] in temporal logic programming. Their underlying temporal logic is based on a uniform, linear and discrete time model, whereas in TLC, all formulae are allowed to be defined on local clocks, representing time-lines at multiple granularities. Therefore, in TLC, events with different rates of progress and also with multiple lines of evolution can be specified and reasoned about by the use of temporal operators and specialized inference rules. It is therefore flexible in describing the behavior of those systems where granularity of time needs to be considered, such as that in reactive and distributed systems [30]. In this paper, we present a methodology based on TLC to deal with the representation and integration of knowledge based on multiple time granularities in knowledgebased systems. In earlier work, Liu and Orgun [29] considered embedding a timing systems (of clocks representing granularities of time) into an executable subset of TLC which lacks its full deductive power; their approach also requires transforming a timing system into a standard form in which all the clocks associated with events in TLC are represented by sub-sequences of a global clock. In our framework, we combine the notion of timing systems that characterize a set of clocks of varying rates and/or granularity of progress with the full deductive reasoning power of TLC in a seamless way. There is also no need to transform a timing system into a standard form and full deductive capability of TLC is made available to the user by providing several special reasoning techniques. In the sequel, we first propose an approach to the representation of timing systems through local clocks, give a formal definition of timing systems, and present the proof system of TLC such that it is suitable for reasoning in TLC bound on a particular timing system. We then classify the facts and rules representing knowledge in a knowledge-based system for a dynamic system and present a method for expressing and reasoning about the knowledge involving multiple time granularities. We also propose a technique for reasoning about knowledge in a knowledge-based system. Since modelling time-related properties is essential in medical applications [3], we demonstrate how TLC can be used for representing and reasoning about knowledge for a simplified medical scenario. The paper is organized as follows. Section 2 gives a brief introduction to TLC, including semantics of formulas and an axiomatic proof system. Section 3 presents timing systems based on local clocks, and discusses the proof system of TLC bound on a timing system. Section 4 discusses knowledge representation and reasoning techniques in knowledge-based systems involving multiple granularities of time. We classify the facts

4


and rules representing knowledge in a knowledge-based system and present a method for expressing and reasoning about the knowledge based on specialised inference rules of TLC. Section 5 concludes the paper with a brief summary and outlines directions for future work.

2. Temporal logic TLC In this section, we give a brief introduction to the temporal logic TLC, including the notion of clocks, its syntax, semantics, axioms and inference rules. In TLC, each predicate symbol is assigned a local clock, and all formulas can be clocked in terms of the clocks of predicate symbols appearing in them through a clock calculus. 2.1. Clocks The notion of a clock plays an essential role in TLC as each formula of the logic is defined on a local clock (a sequence of time-instants). The time model of TLC goes back to Caspi and Halbwachs [9] who proposed a model of events, in which there is a global time-line, but it is the actual events that define time. Events are simply time-stamped with their dates of occurrence. Definition 2.1. The global clock gck is the sequence of natural numbers, i.e., gck = h0, 1, 2, 3, . . .i. A local clock is a subsequence of the global clock, that is, a strictly increasing sequence of natural numbers, either finite ht0 ,t1 ,t2 , . . . ,tn i or infinite: ht0 ,t1 ,t2 , . . .i. In particular, the global clock gck and the empty clock, denoted by hi, are also local clocks. Let C K be the set of all clocks and v be an ordering relation on the elements of C K defined as follows: for any ck1 , ck2 ∈ C K , ck1 v ck2 if and only if for all t ∈ ck1 we have that t ∈ ck2 , where t ∈ cki denotes the fact that t is an element on the clock cki . It is easy to show that (C K , v) is a complete lattice. Therefore, we can define def

ck1 u ck2 = g.l.b.{ck1 , ck2 } def

ck1 t ck2 = l.u.b.{ck1 , ck2 } where ck1 , ck2 ∈ C K , g.l.b. stands for “the greatest lower bound” and l.u.b. for “the least upper bound” under the relation v. In short, the g.l.b. of two clocks can be obtained by taking the common elements in both the clocks; and the l.u.b. of two clocks can be obtained by merging them. Given a local clock cki = ht0 ,t1 ,t2 , . . .i, we define the rank of tn on cki to be n, written (n) as rank(tn , cki ) = n. Inversely, we write tn = cki , which means that tn is that moment in time on cki whose rank is n. 2.2. Clocked Formulas TLC extends the language of first-order logic with two basic temporal operators, first and next, which refer to the initial and the next moment in time with respect to given clocks. These operators are those of the temporal logic programming language Chronolog proposed by Orgun and Wadge[38], which in turn were borrowed from the dataflow language Lucid invented by Ashcroft and Wadge [2, 44].


5

TLC formulas are constructed by the following rules: - Any formula of first-order logic is a formula of TLC; - if A is a formula, so are first A and next A. Predicate symbols can be used to represent events which may run on clocks of different rates and/or granularities of progress. So, we use a clock assignment to assign a local clock to each predicate symbol. A clock assignment ck is a map from the set of predicate symbols to the set of clocks. The clock associated with a predicate symbol p is denoted by ck(p) ∈ C K . When our knowledge about a particular application involves multiple granularities of time, we need an effective way of combining and/or integrating such knowledge in meaningful ways. This can be achieved by extending the notion of a clock assignment to formulas representing such knowledge. For any formula A, its local clock over a given clock assignment is defined based on its syntactic structure and the clocks of predicate symbols appearing in it. Note that the clock of a given formula does not contain any moments that are on the clock of at least one of the predicate symbols appearing in it; in other words, no new moments are created. Definition 2.2. Let A be a formula and ck a clock assignment. The local clock associated with A, denoted as ckA , is defined inductively as follows: - If A is an atomic formula of the form p(x1 , . . . , xn ), then ckA = ck(p). - If A = ¬B, first B or (∀x)B then ckA = ckB . - If A = B ∧C, then ckA = ckB u ckC . - If A = next B, then (1) ckA = ht0 ,t1 , . . . ,tn−1 i when ckB = ht0 ,t1 , . . . ,tn i is non-empty and finite; (2) ckA = ckB when ckB is infinite or empty. By the definition of local clocks of formulas, it is easy to show that, for the derived connectives ∨, → and ↔, we have ckB∨C = ckB u ckC , ckB→C = ckB u ckC and ckB↔C = ckB u ckC ; for the quantifier ∃, we have ck(∃x)B = ckB . The following lemma can be proven by induction on the structure of formulas: Lemma 2.1. [30] Let A be a formula and ck a clock assignment. Then ckA ∈ C K (i.e., every formula of TLC can be clocked). Note that the clock derivation given above (taking the common elements of each clock involved) is one of many possibilities. It simplifies the determination of the truth values of formulas from the values of subformulas. If for instance we took the l.u.b of clocks, then we could resolve the value of a given formula by adopting the idea of (1) the most recent tick (unbounded into the past) or (2) the nearest tick (unbounded into the past and future); other ideas are also possible. Difference choices of clock derivations will naturally result in different instances of TLC and in different ways of integrating knowledge. This aspect of our approach would allow us to tailor a particular TLC for a particular application domain. 2.3. Semantics The semantics of formulas with logical connectives are defined in the usual way, but with respect to local clocks [28]. A formula is defined only over the moments in time

6


appearing on its clock over a given clock assignment. Therefore, for a given moment in time, the value of the formula can be true, false or undefined, depending on the local clock associated with it by the clock calculus. Below we only give the meaning of temporal operators. Further details can be found in the literature [30]: (0)

- For any t ∈ ckA , |=ckA ,t first A if and only if |=ckA ,t0 A, where t0 = ckA . - For any t ∈ cknext A , |=ckA ,t next A if and only if |= (i+1) A, where i = rank(t, ckA ). ckA ,ckA

Table 1 gives an intuitive explanation of the semantics for the two basic temporal operators. Formula Truth value ϕ T T F F T F T F ... first ϕ T T T T T T T T . . . next ϕ T F F T F T F . . . . . . Time t0 t1 t2 t3 t4 t5 t6 t7 . . . TABLE 1. Interpretation of temporal operators (ϕ is a formula; T represents value true and F value false)

In this paper, to make TLC more expressive, we extend it with two basic temporal modalities 2 (always) and 3 (sometime). It is however important to note that the readings of the modalities are relative to the clocks of the given formulas, for instance, 2A means that A is always true on its own clock. The formal definition of the semantics of the modalities is given below. - For any t ∈ ckA , |=ckA ,t 2 A if and only if |=ckA ,s A for all s ∈ ckA . - For any t ∈ ckA , |=ckA ,t 3 A if and only if there exists a moment, say s ∈ ckA , such that |=ckA ,s A. In many applications, we may also need to model statements where the notion of modalities is relative to present. Therefore we also introduce different versions of the temporal necessity (and possibility) modalities, that is, the modalities “from now on” and “sometime in the future”. The formal definition of the semantics of these modalities is given below. - For any t ∈ ckA , |=ckA ,t A if and only if |=ckA ,s A for all s ∈ ckA where s ≥ t. + A if and only if there exists a moment, say s ∈ ckA , such - For any t ∈ ckA , |=ckA ,t 3 that |=ckA ,s A where s ≥ t. As is the case for modal logics, the possibility modalities can also be defined as the duals of the necessity modalities: def

3 A = ¬2¬ A + A def 3 = ¬¬A Therefore we may regard the necessity modalities among the primitive operators of TLC, and this simplifies the proof system (see below).


7

Note that the clock of a formula of the form 2 A or A is the clock of A, that is, ck2 A = ckA and ck A = ckA ). 2.4. Proof system The proof system for TLC consists of a set of axioms and a set of inference rules. Apart from the axioms of first-order logic and substitution (universal instantiation), TLC also has the following axioms and inference rules, which are related to the temporal operators and clock assignment. Below, the notation ` A denotes the fact that A is a theorem of TLC. All theorems of the form ` A hold on the local clock associated with the formula A, i.e., ckA , under any given clock assignment ck. They do not necessarily hold on an arbitrary clock. In other words, ` A means `ckA A, i.e., A is a theorem that holds on the local clock ckA for any clock assignment ck. Let 5 be either first or next and 4 be either 2 or . Axioms. A1. ` first (first A) ↔ first A. A2. ` next (first A) ↔ first A, when ckA is infinite. A3. ` 5(¬A) ↔ ¬(5A). A4. ` 5(∀x)(A) ↔ (∀x)(5A). (0) (0) A5. ` first (A ∧ B) ↔(first A)∧(first B), when ckA = ckB . A6. ` next (A ∧ B) ↔ (next A)∧(next B), when ckA = ckB . A7. ` 44 A ↔ 4 A. A8. ` first 2 A ↔ 2 A. A9. ` next 2 A ↔ 2 A, when ckA is infinite. A10. ` 4(A ∧ B) ↔ (4A ∧ 4B), when ckA = ckB . A1 and A2 say that initial truths persist. A3 says that the temporal operators commute with ¬ (in other words, temporal operators are self-dual). A4 stipulates that the values of individual variables range over extensions (data values), not intensions (time-varying values). It is an instance of the so-called Barcan formula combined with its converse [24]. A5 and A6 state that the temporal operators commute with ∧ under certain conditions. A7, A8 and A9 say that temporal necessities persist. A10 states that the temporal modalities commute with ∧ under certain conditions. Inference rules. We have the following rules for basic temporal operators: R1. If ` A → B and ` A, then ` B, when ckA = ckB . R2. If ` A, then ` first A, when ckA is non-empty. R3. If ` A, then ` next A, when cknextA is non-empty. IR. If ` first A, ` A → next A, then ` A. RN. If ` A, then ` 2 A and ` A . R1 is Modus Ponens (MP). R2 and R3 say that temporal operators can be introduced under certain conditions. IR (Induction Rule) is a form of a temporal operator elimination rule. RN (Rule of Necessitation) introduces temporal modalities. We assume that the rules of inference given above are extended to consider the notion of deducibility from a set of formulas. For instance, now R2 reads “if Γ ` A, then Γ ` first A”. We also introduce another well-known rule into our system:

8


CR. If A ` B, B ` C, then A ` C. This is the so-called cut rule. There are no local clock conditions attached to the cut rule and therefore it will play an important role in reasoning about properties based on multiple granularities. The presentation of an axiomatic system for TLC begs the question whether it is complete with respect to the given semantic scheme, that is, it axiomatizes the semantics scheme and the flow of time pictured above. We omit the detailed discussion on the completeness and soundness results of TLC due to space limitations, however, we refer the reader to Liu [27] for more details. The correctness (soundness) of the axioms and the rules is straightforward. Therefore we state the following result without proof. Lemma 2.2. [27] The axioms A1–A10 and the rules R1–R3, IR, RN and CR are valid with respect to the semantics scheme for TLC.

3. Timing Systems & TLC Human activities heavily relate to calendar time and various clock units. In order to effectively describe and reason about knowledge-based systems that involve multiple time granularities, we introduce the notion of timing systems. A timing system consists of a set of local clocks, in which a certain time unit is attached to each local clock. Such a timing system can stand for a multiple time granularity system. Thus, TLC bound on a specific timing system may in particular be suitable for a specific class of applications of knowledge-based systems involving multiple time granularities. 3.1. Attaching a Time Unit to a Local Clock Below, we propose a method to attach a time unit to a local clock, which leads to a different way for classifying time units. Time units are used for measuring time intervals. A time unit is represented by lengths of a class of time intervals which have some common properties, and it is identified by a unique identifier. For example, day, week, month and year are time units. The classification method of time units can be based on the “absolute” lengths of intervals of their instances. Usually, time units can be classified into two types: constant units, such as day and week, and non-constant units, such as month and year. In the following, we represent common time units, such as second, minute, hour, day, week, month, year as s, mi, h, d, w, mo, y respectively. For any local clock, we assume that there is a corresponding time axis, which represents the set consisting of all real numbers with the usual ordering relation does not include 13 and 14. We also need to note that, if formulae A and B involve different time units, we may not be able to use a single formula, such as A ∧ B, to represent “both A and B are true”. As an example, consider the following fact: - John has an operation on the first work-day and stays in the hospital in the first week (week 0). The fact can be expressed by the set of formulas as follows: {first has op(john), first stays hos(john)} However, because the clocks assigned to the predicates stays hos and has op are different, we cannot rewrite the set as a single formula such as first has op(john)∧ first stays hos(john) or first (has op(john)∧stays hos(john)). In the general case, facts (and also rules) defined over the same local clock may be considered as a knowledge base on their own right, and inference rules (and rules defined through deducibility relations below) provide the necessary reasoning capability to make the integration of knowledge from those knowledge bases possible. 4.3. Rules Rules can be represented by implications, deducibility relations, and inference rules. We now discuss how different types of rules can be employed in knowledge representation and reasoning. Rules Represented by Implications. A rule represented by implication has the form of A → B, where A and B are formulas and ckA = ckB . For example, we may have a rule of the following form: takes(X,Y) → blood pre(X,normal) which actually means that, if a patient X takes tablets Y , then his/her blood pressure remains normal. The following implication represents the rule that if Dr Zhang operates on any work day, he takes the day off on the next work day. does op(zhang) → next day off(zhang) Rules Represented by Deducibility Relations. When ckA 6= ckB , we cannot use the implication A → B to represent the rule “if A is true, then B is also true”. In such cases, we may use the notion of deducibility from a set of formulae to represent such rules, i.e., Γ ` A, where A is a formula and Γ = {A1 , . . . , An } is a set of formulae. The rule is read as “if ` A1 , . . . ,and ` An , then ` A”, which means that, if A1 is true at all moments in time on ckA1 , . . ., and An is true at all moments in time on ckAn , then A is true at all moments in time on ckA . However, we should note that a form of the deduction theorem “if A ` B, then ` A → B” does not in general hold in TLC [27], because, as mentioned before, A and B may be defined on different clocks. For instance, the following rule can only expressed as a deducibility relation.


15

- If the blood pressure of a patient is normal for seven consecutive days, then he/she will leave hospital on the next work-day. Using a deducibility relation, the rule can be expressed as: 2 blood pre(X,normal) ` first next(n) leaves hos(X) where n = rank(s, ck2 ) and s = min{ i | i ∈ ck2 & i ≥ t + 7}. Inference Rules. These rules are applied to answer queries. They can also be represented by deducibility relations. For instance, inference rule R2 can be represented as “A ` first A”. In TLC, because of the introduction of timing systems, we need to provide inference rules that are used for reasoning about knowledge that involve different granularities of time. For example, consider the following knowledge: - If John stays in the hospital at the first week, then he stays in the hospital on the first work day. - If John has an operation in the first week, then he has an operation on some day between work days 1 and 5. There is no easy way to represent this knowledge using TLC formulas; so we may need to introduce special problem-oriented inference rules. Such rules can be classified into four types. Let formulae A and B be associated with hckA , xA i and hckB , xB i respectively, and UA be the time unit of hckA , xA i and UB the time unit of hckB , xB i, and UA < UB . Then we may have rules as follows: PR1. PR2. PR3. PR4.

2 A ` first next(n) B 3 A ` first next(n) B first next(n) B ` 2 A first next(n) B ` 3 A

where we assume that t ∈ ckB (of course, we also have t ∈ ckA ), n = rank(t, ckB ) and (n+1) s = max{k|k ∈ ckA & k < ckB }. Sample Proof. To obtain new knowledge, we need to perform deductive reasoning by applying inference rules and the knowledge we have obtained at those earlier stages. The knowledge which can be represented as facts or rules of implications can be directly derived by the proof system of TLC. The knowledge expressed as deducibility rules can be derived through sequent calculus. For example, suppose we have the assumption (which is an instance of the inference rule PR1): 2 blood pre(X,normal) ` first next(n) leaves hos(X) where n = rank(s, ck2 ) and s = min{i|i ∈ ck2 & i ≥ t + 7}. To prove the rule 2 takes(john,Y) ` first next(n) leaves hos(john), we start with the given assumption: 2 blood pre(X,normal) ` first next(n) leaves hos(X). (1)

16


We substitute variable X in (1) by term john (X is assumed to be universally quantified so it can be substituted by any term): 2 blood pre(john,normal) ` first next(n) leaves hos(john). (2) We also have the following assumption: takes(X,Y) → blood pre(X,normal).

(3)

Again we substitute variable X in (3) by term john (again, variables X and Y are universally quantified): takes(john,Y)→blood pre(john,normal).

(4)

By repeated applications of rules R2 and R3 to (4), we obtain: 2 (takes(john,Y)→blood pre(john,normal)).

(5)

Then we apply axioms A3–A6 to (5) in various ways to obtain: 2 takes(john,Y)→ 2 blood pre(john,normal).

(6)

We can now use the deduction theorem on (6) because we have the same local clock for both the antecedent and consequent of the formula: 2 takes(john,Y)` 2 blood pre(john,normal).

(7)

By applying the cut rule CR to (2) and (7), we finally obtain the desired result: 2 takes(john,Y) ` first next(n) leaves hos(john).

(8)

5. Concluding Remarks We have presented a methodology for knowledge representation, reasoning and integration to deal with multiple time granularities in knowledge-based systems. It includes an approach to the representation of timing systems through local clocks, and a method for representing facts and rules in knowledge-based systems involving multiple time granularities. An advantage of our approach is that it is based on temporal logic TLC with deductive capability based on sequent calculus. Since there is already a defined executable subset of TLC [28], the approach would benefit from executable specifications of knowledge bases using (clocked) temporal resolution. However, clocked temporal resolution will need to be extended with a method for determining the correct moments in time over which resolution inference steps may be defined. Future work may include other clock derivation techniques and also other temporal modalities inspired by fielded applications, leading to various other TLC suitable for use as a modelling, reasoning and knowledge integration tool. We also plan to study different types of timing systems and executable subsets of TLC bound on a timing system to deal with multiple time granularities in such applications as safety-critical and security-critical systems [15], and multi-agent systems [31] where different agents may be naturally defined on clocks of different rates of progress and/or granularity. We will also consider branching time models such as that in the Cactus language [41] which extends foundational work on Chronolog [38, 45] to branching time temporal logics. Further work may


17

also involve the investigation of user-defined symbolic periodicities [17] (loosely speaking, local clocks) and whether such periodicities can also be used as local clocks when TLC is bound on a particular timing system.

Acknowledgements The work presented in this paper has been supported in part by The Australian Research Council (ARC). Thanks are due to two anonymous referees for their constructive comments and suggestions that helped improve this paper.

References [1] J. Allen. Maintaining knowledge about temporal intervals. Communications of the ACM, 26:832–43, 1983. [2] E. A. Ashcroft and W. W. Wadge. Lucid – a formal system for writing and proving programs. SIAM Journal on Computing, 5:336–54, September 1976. [3] J C. Augusto. Temporal reasoning for decision support in medicine. Artificial Intelligence in Medicine, 33(1):1–24, 2005. [4] S. Badaloni and M. Berati. Hybrid temporal reasoning for planning and scheduling. In Proceedings of the Third International Workshop on Temporal Representation and Reasoning (TIME’96), pages 104–110, Florida, USA, May 1996. IEEE Computer Society Press. [5] C. Bettini , S. G. Jajodia , S. X. Wang. Time Granularities in Databases, Data Mining and Temporal Reasoning. Springer-Verlag New York, Inc., Secaucus, NJ, 2000. [6] C. Bettini and S. Mascetti. An efficient algorithm for minimizing time granularity periodical representations. In 12th International Symposium on Temporal Representation and Reasoning (TIME 2005), 23-25 June 2005, Burlington, Vermont, USA, pages 20–25. IEEE Computer Society, 2005. [7] C. Bettini, S. X. Wang, and S. Jajodia. A general framework and reasoning models for time granularity. In Proceedings of the Third International Workshop on Temporal Representation and Reasoning (TIME’96), pages 104–110, Florida, USA, May 1996. IEEE Computer Society Press. [8] C. Caleiro, L. Vigan`o, and D. A. Basin. Metareasoning about security protocols using distributed temporal logic. Electr. Notes Theor. Comput. Sci., 125(1):67–89, 2005. [9] P. Caspi and N. Halbwachs. A functional model for describing and reasoning about time behaviour of computing systems. Acta Informatica, 22:595–627, 1986. [10] J. Chomicki. Temporal query languages: A survey. In D.M. Gabbay and H.J. Ohlbach, editors, Proc. of ICTL’94: First International Conference on Temporal Logic, volume 827 of LNAI, pages 506–534, Gustav Stresemann Institut, Bonn, Germany, July 1994. Springer-Verlag. [11] C. Combi and R. Rossato. Representing trends and trend dependencies with multiple granularities. In 13th International Symposium on Temporal Representation and Reasoning (TIME 2006), 15-17 June 2006, Budapest, Hungary, pages 3–10. IEEE Computer Society, 2006. [12] C. Combi, F. Pinciroli, and G. Pozzi. Managing different time granularities of clinical information by an interval-based temporal data model. Methods of Information in Medicine, 34:458–74, 1995.

18


[13] D. Cukierman and J. Delgrande. A language to express time intervals and repetition. In Proceedings of the Second International Workshop on Temporal Representation and Reasoning (TIME’95), pages 41–48, Florida, USA, 1995. [14] U. Dal Lago, A. Montanari and G. Puppis. Compact and tractable automaton-based representations of time granularities. Theor. Comput. Sci., Vol. 373, 1-2 (Mar. 2007), 115-141. [15] N. Durgin, J. Mitchell, and D. Pavlovic. A compositional logic for proving security properties of protocols. Journal of Computer Security, 11(2003):677–721. [16] C. E. Dyreson and R. T. Snodgrass. Temporal granularity. In R. T. Snodgrass, editor, The TSQL2 Temporal Query Language, pages 347–383. Kluwer Academic Press, 1995. [17] L. Egidi and P. Terenziani. Orthogonal Operators for user-defined symbolic periodicities. In Proceedings of 11th International Conference, Artificial Intelligence: Methodology, Systems, and Applications, pages 137–147, LNAI 3192, Springer-Verlag, 2004. [18] J. Euzenat. An algebraic approach to granularity in time representation. In Proceedings of the Second International Workshop on Temporal Representation and Reasoning (TIME’95), pages 147–154, Florida, USA, 1995. IEEE Computer Society Press. [19] M. Fisher. Temporal development methods for agent-based systems. Autonomous Agents and Multi-Agent Systems, 10(1):41–66, 2004. [20] M. Fisher and R. Owens. An introduction to executable modal and temporal logics. In M. Fisher and R. Owens, editors, Executable Modal and Temporal Logics. Lecture Notes in Artificial Intelligence Vol. 897, pages 1–20, Springer-Verlag, 1995. [21] D. M. Gabbay. Modal and temporal logic programming. In A. Galton, editor, Temporal Logics and Their Applications, pages 197–237. Academic Press, 1987. [22] M. Gergatsoulis. Temporal and modal logic programming languages. In A. Kent and J. G. Williams (Executive Editors), Encyclopedia of Microcomputers, Volume 27, Supplement 6, pages 393–408, Marcel Dekker, Inc. New York, 2001. [23] J. W. Gray and J. McLean. Using temporal logic to specify and verify cryptographic protocols. In Proceedings of the 8th IEEE Workshop on Computer Security Foundations (March 13 - 15, 1995). CSFW. IEEE Computer Society, Washington, DC, page 108. [24] P. Jackson and H. Reichgelt. A general proof method for modal predicate logic. In P. Jackson, H. Reichgelt, and F. van Harmelen, editors, Logic-Based Knowledge Representation, pages 177–228. MIT Press, 1989. [25] P. Ladkin. The Logic of Time Representation. PhD thesis, University of California, Berkeley, California, USA, 1987. [26] L. Lamport. The temporal logic of actions. ACM Transactions on Programming Languages and Systems, 16(3):872–923, 1994. [27] C. Liu. Clocked Temporal Logic Programming. PhD thesis, Macquarie University, Sydney, NSW, Australia, 1998. [28] C. Liu and M. A. Orgun. Dealing with multiple granularity of time in temporal logic programming. Journal of Symbolic Computation, 22:699–720, 1996. [29] C. Liu and M. A. Orgun. Embedding a Timing System in TLC. In L. Khatib and R. Morris (editors), Proc. of The Fifth International Workshop on Temporal Representation and Reasoning (TIME’98), May 16–17, 1998, Sanibel Island, Florida. IEEE Computer Society Press, pp.105–112.


19

[30] C. Liu and M. A. Orgun. Verification of reactive systems using temporal logic with clocks. Theoretical Computer Science, Vol.220(2) pp.377-408, 1999. [31] C. Liu, M. Ozols, and M. A. Orgun. A temporalised belief logic for specifying the dynamics of trust for multi-agent systems. In Advances in Computer Science - ASIAN 2004, Higher-Level Decision Making, 9th Asian Computing Science Conference, Proceedings, LNCS, 3321, pages 142–156. Springer, 2004. [32] Z. Manna and A. Pnueli. The Temporal Logic of Reactive and Concurrent Systems. SpringerVerlag, 1992. [33] Z. Manna and H. B. Spima. Deductive verification of hybrid systems using STeP. Hybrid Systems: Computation and Control. LNCS 1386, Springer-Verlag, April 1998. [34] E. Mota,M. Haggith, A. Smaill and D. Robertson. Time granularity in simulation of models of ecological systems. In Proceedings of IJCAI-95 Workshop on Executable Temporal Logics, pages 77–94. Montreal, Canada, 1995. [35] M. A. Orgun. Incorporating an implicit time dimension into the relational model and algebra. RAIRO Theoretical Informatics and Applications, 30(3):231–260, 1996. [36] M. A. Orgun and W. Ma. An overview of temporal and modal logic programming. In D. M. Gabbay and H. J. Ohlbach, editors, Proc. of ICTL’94, First International Conference on Temporal Logic, Bonn, Germany, July 1994. LNAI Vol.827, pages 445–479. Springer-Verlag. [37] M. A. Orgun, C. Liu and A. Nayak. Representation and integration of knowledge based on multiple granularity of time using temporal logic. In D. Zhang, T. M. Khoshgoftaar and J. B. D. Joshi (eds), Proceedings of The 2006 IEEE International Conference on Information Reuse and Integration (IEEE IRI-2006), Sep 16–18, 2006, Waikoloa, Hawaii, USA, IEEE Systems, Man, and Cybernetics Society (SMC), pp.256–261. [38] M. A. Orgun and W. W. Wadge. Theory and Practice of Temporal Logic Programming”. In Fari˜nas del Cerro, L. and Penttonen, M. (editors), Intensional Logics for Programming, Oxford University Press, pages 23–50, 1992. [39] M. A. Orgun and W. W. Wadge. Extending temporal logic programming with choice predicates non-determinism. Journal of Logic and Computation, 4(6):877–903, 1994. [40] J. Plaice and J-R. Gagne. A non-standard temporal deductive database system. Journal of Symbolic Computation, 22(5 & 6):649–664, 1996. [41] P. Rondogiannis, M. Gergatsoulis, and T. Panayiotopoulos. Branching-time logic programming: the language Cactus and its applications. Computer Languages, 24(3):155–178, 1999. [42] F. Sadri. Three approaches to temporal reasoning. In A. Galton, editor, Temporal Logics and their Applications, pages 121–168. Academic Press, 1987. [43] J. van Benthem. Temporal logic. In D. M. Gabbay, C. J. Hogger, and J. A. Robinson, editors, Handbook of Logic in Artificial Intelligence and Logic Programming, volume 4. Oxford University Press, 1993. [44] W. W. Wadge and E. A. Ashcroft. Lucid, the Dataflow Programming Language. Academic Press, 1985. [45] W. W. Wadge. Tense logic programming: a respectable alternative. In Proceedings of the 1988 International Symposium on Lucid and Intensional Programming, pages 26–32, Sidney, B.C., Canada, April 7-8 1988. [46] G. Wiederhold, S. Jajoida, and W. Litwin. Dealing with granularity of time in temporal databases. In R. Andersen, J. A. Bubenko, and A . Sølvberg, editors, Advanced Information

20

Orgun, Liu and Nayak Systems Engineering: Proceedings of the Third International Conference CAiSE’91, pages 124–140, Trondheim, Norway, May 1991. Springer-Verlag.

Mehmet A. Orgun Department of Computing Macquarie University Sydney, NSW 2109, Australia e-mail: [email protected] Chuchang Liu C3I Division Defence Science and Technology Organisation PO Box 1500, Edinburgh, SA 5111, Australia e-mail: [email protected] Abhaya C. Nayak Department of Computing Macquarie University Sydney, NSW 2109, Australia e-mail: [email protected]