[SOUND] [MUSIC] In attribute exploration, we have some large context for which we want to compute implications and, maybe, the concept lattice. This large context may even be infinite, that is, it may contain infinitely many objects, but we assume that the attribute set is finite and, therefore, the concept lattice and the implication basis are also finite. This context is our exploration domain. We start with a sample of objects from this domain. They form our initial subcontext, which will grow during the exploration, but will always remain finite. Initially, it may even be empty. We compute implications valid in this subcontext and ask an oracle, or a domain expert, or ourselves, if these implications are valid in general, that is, in the large context that we explore, in our domain. If an implication is not valid in general, we ask the expert to provide a counterexample to it, an object (and the set of its attributes) that violates this implication. We then add it to our subcontext. The particular algorithm that we'll study goes through valid implications one by one, and, to minimize the number of questions, it considers only implications from the canonical basis of the current subcontext. But other exploration strategies are also possible. When we ask about the validity of an implication, what type of query is it? It turns out that we may consider it as superset query: when we ask if A implies B, what we really ask is whether every set satisfying all the implications of our context is also a model of the implication "A implies B". In other words, we ask if the set of models of the implication "A implies B" is a superset of the set of models of all the implications valid in our context. This is the pseudocode of the basic version of attribute exploration, and if you remember anything about how we compute the canonical basis, it should look familiar. Indeed, it is almost the same algorithm. The difference is that, when we discover a new valid application, we cannot immediately add it to the basis, because it may be valid only in our current subcontext, but not in the entire context. We have to ask the expert about it. Here, the domain context is (G, M, I) and its current subcontext is (E, M, J). We the denote the derivation operators in this context by I and J, respectively. Note that we don't have direct access to (G, M, I). The algorithm receives only (E, M, J) as input, but it may get additional information about (G, M, I) from the domain expert. In the pseudocode, the lines that use information from the expert are labeled with stars. The first labeled line is where we ask if the implication "A implies A^JJ" valid in the current of subcontext (E, M, J) is also valid in the domain context (G, M, I). Indeed, this is the same as asking if A^II, the closure of A in (G, M, I), is equal to the closure of A in (E, M, J). If so, we add the implication and compute the next set closed under the updated implication set, the next intent or pseudo-intent of our current subcontext. If not, we ask the expert to provide a counterexample, an object that has all attributes from A, but not all attributes from A^JJ. This object is added to the (E, M, J) and this makes A^JJ smaller and closer to A^II, the true closure of A in the domain context. It may happen that A becomes closed as a result, in which case we compute the next closed set. Otherwise, we ask again about the validity of the implication "A implies A^JJ", but this time A^JJ is smaller than it was at the previous iteration. When the algorithm terminates (and it is easy to see that it will at some point), our subcontext (E, M, J) will be representative of the domain in some very precise sense: it will satisfy exactly the same implications. This is because, by this moment, we'll have included into it counterexamples to all invalid implications. So its canonical basis L will also be the canonical basis of the domain context (G, M, I). We have computed the canonical basis of the domain context, even though we haven't probably seen the entire context. Also, remarkably, in the end of the exploration, the concept lattice of (E, M, J) will have the same structure and the same concept intents as that of the domain context. [SOUND] [MUSIC]