Suppose we have a system which produces observable variables over time. We can see some inputs and outputs of the system, but we cannot look inside. The system is a black box to us. How do we find out how the system generates its output? TimeSleuth is a tool that helps with that.

TimeSleuth can discover temporal relationships that may be causal or acausal. It allows the user to discover relationships between the observed variables, such that one may be able to use the values of certain variables to predict the values of other variables, and thus learn (or model) how the system works. It can detect relationships between values at the same instance, or at different time steps.

As a very simple example, suppose a mother allows her child to play outside sometimes, and not at other times. It may be interesting to see how the system (mother) makes such a decision. If we can collect values for three variables, as in the table below, then maybe we can discover rules that govern the system:

Outlook Temperature Play?
Sunny 23 Yes
Cloudy 10 No

In this simple case, a possible rule would be: if Outlook = Sunny, then Play = Yes (this is an instantaneous rule). In this rule Temperature is an irrelevant variable.

But what if how the system behaves depends on the past (or future) conditions? As an example, suppose we are observing variables v1, v2, and v3, and the true relationship between the variables is:

if previous value of v1 = 3, then the current value of V3 = true (this is a causal rule)
or
if the next value of V2 = 8, then the current value of V3 = false (this is an acausal rule).

It may seem counter-intuitive to refer to a future value to predict the present. All is explained in TimeSleuth papers.

If a system is goverend by temporal (non-instantaneous) rules, then no amount of looking at the data generated at each instance will be enough to reveal the rules! This is where TimeSleuth can help. It considers temporal possibilities, and generates temporal rules that can use past or future observations to predict the current value of a variable.

TimeSleuth is written mainly in Java, and implements the Temporal Investigation Method for Enregistered Record Sequences (TIMERS) algorithm. TimeSleuth works as follows:

  1. Pre-processes sequential data by placing events from differnt time steps together
  2. Uses a modified version of C4.5 to discover rules that apply to the data
  3. Helps the user interpret the results as signifying temporal or causal relationships.

TimeSleuth is also a visualization tool for decision rules, and can convert decision rules to Prolog statements.

You can download TimeSleuth and use it for free. The paper Generation and Interpretation of Temporal Decision Rules provides a rather complete overview of how the system works. More papers on TIMERS and TimeSleuth can be found on my Publications page.

For a general introduction to temporality and causality you can read A Brief Introduction to Temporality and Causality.