Previous: Domain knowledge Up: Cover & differentiate Next: Modelling operations

Task knowledge

C&D combines and rules-out explanatory relations. The relations are indexed by symptoms they explain and constraints they introduce. C&D searches for a covering set of explanations by dividing the task into a covering step and a differentiate step. Cover takes a set of features (symptoms) and produces a set of theories (explanations) that seem applicable; differentiate tries to rule out elements of this set. The cover and the differentiate sub-tasks are not equally complex; the domain schemata support the cover task by a cover domain operation. Cover can therefore also be classified as a `primitive-inference-action' (PIA). The differentiate task is not directly supported by the domain ontology. It is therefore necessary to decompose this task.

1. cover-task(+Symptom, -Explanation*)

   There is a binary relation R(symptom, explanation) in the domain schema, S is a set of symptoms, E is a set of events. The goal of task cover is to create an explanation E for which holds: for each of the elements s of S and for each of the elements e of E, R(s, e) holds.

2. differentiate-task(+Symptom*, +Explanation*, -New-symptom*, -Refined-Explanation*)

   Differentiate is a task that takes a set S (the Symptoms), a set E (the original Explanations), and creates a set N (New symptoms), and a set F(the Refined Explanations).

   The goal of Differentiate-task (S, E, R, F) is to create a set N of New symptoms and a set NE of new explanations for which holds:

   0pt

3. sep 0pt

   • cover(S, E) holds.

   • cover(F, E) holds.

   • E a subset is of F.

   • If the result of the observation request is positive then should F cover N too.

   • If the result of the observation request is negative then R may not be part of either the required symptoms or the enabling symptom of an element of F.

Function structures can be defined at each level of task decomposition. Figure shows a function structure at the first level of decomposition.

Sub-tasks of differentiate are:

1. differ-task(+E:explanation*, +IS:symptom*, -R:request*). This task takes the explanations and searches for a set of differentiating symptoms. These symptoms are then requested to the test task. There are four different ways to do this;
   • By directly testable competing events. Some events are directly observable and can be passed directly as a request to the test sub-task.
   • By finding symptoms that rule out competing events. Different events have always some non-overlapping symptoms, testing these rule out at least one of the competing events.
   • By finding symptoms that form an enabling connection. Some competing events have associated enabling events. If the enabling events cannot be observed, then the competing event cannot be used in the explanation.
   • By using required symptoms of competing events. If the required event is not available then the competing event cannot be an explanation.

2. test-task(+R:request, -S:symptom). The test task checks whether a requested symptom is available.

3. infer-task(+E:explanation*, +Os:symptom*, +Ns:symptom*, -NE:explanation). The infer task takes the set of competing explanations, the original symptoms, the new symptom requested by the differ task and checked by the test task. Using this information infer tries to eliminate competing explanations and produces a new list of explanations (NE). There are different ways to do this:

   • If the requested symptom was not available and is as an `testable event' part of the competing events, then this competing event can be eliminated.

   • If a competing event does not cover the new symptom, then this event can be eliminated.

   • If the requested symptom was not available then the events that have this symptom as enabling connection can be removed.

   • If the requested symptom was not available then the events that have this symptom as required symptom can be eliminated.

Figure shows a function structure of C&D at a first level of decomposition.