[MUSIC] We'll use two formal contexts to store incompletely specified examples. For each object, the first one will record only attributes that the object definitely has, and the second one will record all the attributes the object might have. So these two contexts are defined over the same set of objects and attributes, and only the incidence relations, J+ and J?, are different. They must, however, be compatible: if the first context says that an object g has an attribute m, this view is shared by the second context. The reverse is not true: if g has m according to the second context, it only means that m is potentially an attribute of g, but we might not be sure whether this is indeed so. In this case, g will not have m in the first context, E+. These two contexts taken together are sometimes called a partial formal context. We can define three derivation operators in it. The first two, + and ?, are simply the derivation operators of the two constituent contexts. For example, g+ for an object g is the set of attributes g is known to have, and g? is the set of attributes g may have. As a shorthand, we'll use the third operator, –: g- is the complement to g?; in other words, it's the set of attributes g is known not to have. And this is how we modify the attribute exploration procedure to allow for incompletely specified counterexamples. The first thing is that the expert now provides two sets of attributes for each counterexample e: these are e+ and e-, the attributes e definitely has and those that it certainly doesn't have. These two sets are, of course, disjoint. We insert e into both parts of our partial context, but with different attributes: e+ for the context E+ and the compliment of e- for the context E?. The second modification concerns how we compute closures when we decide what questions to ask next. Actually, we don't compute closures anymore, because we don't have enough information to do this. Instead, for attribute subset A, we compute all the attributes that, considering all we know, may be in the closure of A. To do this, we look at the objects from A+, that is, at the objects that are known to have all attributes from A. And then we look at what they may have in common, that is, at attributes, the objects from A+ share in the context E?. Thus, we obtain the set A+?, and each attribute from this set can potentially be shared by all objects with attributes A. For every other attribute m, there is at least one object that definitely has all attributes from A and definitely doesn't have m; so we're sure that the implication “A implies m” doesn't hold. And for attributes from A+?, we don't know if they are implied by A, and so we have to ask the expert. The third thing that changes is what we do when the expert accepts a suggested implication. It might happen that this new implication can be used to decide about the attributes of the objects that are already in our database. We replace every object intent e+ by its closure with respect to the current implication set L, which now includes the new implication. If we did everything right at the previous steps, the new attributes that get added to e+ must all come from the attributes this object e has according to the second context, E?. But we may check if this is indeed the case, and, if not, we'll keep in mind that our expert might not be as reliable as we thought. Sometimes, after accepting a new implication, we not only can add an attribute to an object intent, but we can also exclude some other attributes. If we're not sure whether object e has attribute m, we tentatively add m to e+, compute the closure of the resulting set with the respect to all accepted implications, and check if what we get is a subset of e?. If not, then the object e cannot have the attribute m, since, otherwise, e would also have some attributes from e- about which we know that it doesn't have them. So we may safely remove m from e?, from the set of potential attributes of object e. So these are all the modifications we need. Let's look at how this works on a small example. [MUSIC]