Thanks to Santiago Cifuentes for reading and commenting on the draft.
Introduction
Sam Eisenstat’s paper on Condensation is very cool, but I found it pretty hard-going to read. There are already several nice explainers (Abram Demski's two posts, Daniel and Jeremy's post on Condensation and Natural Latents and Jan's Elementary Condensation). This post and its sequel will be a little different in that, the main substance (after the introductory sections) will be 'close readings' of the mathematical content of the paper, picking through important definitions and theorems, explaining them, giving some intuitions and going through examples. I find doing this kind of thing helpful when I'm trying to understand a new idea. I'll try to be fairly mathematically rigourous, yet much less formal than the paper. Whenever I give a definition or theorem, I'll try to add a note in brackets detailing the corresponding section in the paper.
I have spoken to several people who said that they found reading the paper hard. As a result, I have erred on the side of over-explaining rather than under-explaining, including examples rather than assuming they're obvious and repeating myself rather than assuming I was understood the first time I stated something. Because of this, this has ended up being pretty long and I have split it up into two (possibly more) posts. This first post contains:
- An intuitive motivation for condensation and why we might care about this for the purpose of AI safety.
- Definitions and examples of Random Variable Models and Latent Variable Models.
- Explanations of the scoring functions and some proofs of their properties
This post doesn't contain any of the main theorems, but the next post will contain proofs of the perfect condensation theorems. These will be much easier to state and prove once we have established the machinery and motivation in this post.
Prerequisites
This post is pretty self-contained, but you should have some basic mathematical maturity. You should know some basic set notation. Eg. if I write you should know what this means on the level of 'is a function which takes a pair of elements, one from set and one from set as inputs, and outputs an element from set ' and you should know that means 'the intersection of sets and '. You should have some basic familiarity with Shannon Entropy. Eg. you should know that for two random variables and , the conditional Shannon entropy is less than or equal to the Shannon entropy ie. . If you have some intuitions about how entropy relates to information, this will also be helpful (Alex's post on entropy is nice for this). Some knowledge of how Shannon entropy relates to encoding (eg. Shannon's Source Coding Theorem) will be helpful for intuitions but not essential. Familiarity with the formal definitions of probability spaces and random variables will also be helpful, but not strictly necessary, as I will introduce these concepts as we go.
We'll start now.
Condensation and Compression
The entropy of a random variable is related to how compressible it is. In particular, if we assign each outcome of the random variable a prefix-free code, then the expected value of the length of the optimal (ie. shortest) prefix-free encoding is close to the entropy of the variable [1].
If I have multiple random variables , (not necessarily i.i.d) and want to encode this string of outcomes, I can assign a codeword to each string of outcomes . Again, the joint entropy is a lower bound on the expected value of the length of strings in a prefix-free encoding. The lower is, the fewer bits we need to describe it (on average). Hence a low means that the variables are compressible: we can find a representation of the outcomes which is short (on average). Compression can come about by exploiting structure in the variables. For example, if and are highly correlated, then we can assign shorter codewords to the strings where and longer codewords to situations where they differ. As a result, encoding the joint variable normally requires fewer bits than encoding each of the individual variables and etc. This is reflected by the subbadditivity of entropy: .
More generally, we assign the shortest codewords to the most likely strings and we assign the longer codewords to the least likely strings. This means that, on average, the length of the codewords will be small. If we do this well, the expected value of the length of the codewords will equal (or be very close to) .
In this sense, assigning codewords to each string like this is the most efficient way to represent the data generated by . But it comes at cost. Namely, by encoding each string , it becomes harder to see what the individual values are without receiving information about all of them. Suppose you have encoded in this way, but I'm interested only in the value of . Then you'll have to send me the whole encoded string, then I have to decode the whole string, discovering the values of all the variables (including ones I don't care about like and ) just to find the value of . With efficient compression, almost by definition, it is often not possible to 'look inside' without decoding the whole thing.
As another analogy, suppose I have a folder on my computer containing one thousand pdfs. I could compress these all into a ZIP file which would be much smaller than the sum of the sizes of the individual pdfs. But suppose that you were interested in only a single one of these pdfs. Even though the ZIP file compressed my pdfs pretty efficiently, it would still be much more efficient to send you the single file you were interested in, rather than the whole ZIP folder, containing things you didn't care about.
Compressing all of the pdfs together in a ZIP file would be most efficient if you were going to ask me to send you all of the pdfs, and keeping them separate would be most efficient if I thought you were going to only ask for an individual pdf file. But what if I didn't know what you were going to ask for? All of the files, one of the files, or some subset of the files? Is there some compromise way of compressing the contents of the folder, while still maintaining easy access to subsets of the files? Is there some 'natural' way to organise the files such that anyone trying to solve the same problem would come up with the same file structure?
In Abram Demski's post, he uses the analogy of a worker at an information desk, who has to answer people's questions by giving them notebooks containing information. She wishes to find the most efficient way of storing this information throughout the notebooks so that she can answer any question with the shortest number of notebook pages. We can ask similar questions about the system of notebooks that she uses.
In the Condensation paper, Sam Eisenstat investigates these questions in the Shannon information setting. The 'world' or 'dataset' or 'set of possible questions' is represented by a Random Variable Model (RVM) which is essentially, a set of random variables . The 'data-structure' or 'world-model' or 'set of notebooks' is represented by a Latent Variable Model (LVM). This is a set of variables which 'contribute to' the random variables in the Random Variable Model. Some latent variables only contribute to small parts of the RVM, while others contribute to large numbers of variables in the RVM, corresponding to high-level 'global' structure in the RVM (don't worry, we'll explain properly what this means later on). For each subset of random variables, there will be some set of latent variables which fully 'explain' the random variables. If you want to know the values of some random variables, I can hand you the appropriate latent variables, and you can re-construct the correct answer. In the paper, Sam Eisenstat uses this framework to quantify what it would mean for a Latent Variable Model to succeed at this 'compressing-while-also-having-easy-access-to-sub-parts' task we gestured at in the previous few paragraphs. A Latent Variable Model is said to 'condense' (as opposed to 'compress') a random variable model if it succeeds at this task.
One of the main results of this paper is that if two different Latent Variable Models (call them and ) both condense the same random variable model 'well', then they are in some sense 'the same', meaning that we can translate between them. Variables in can be mapped onto (or 'interpreted as') variables in (and vice versa).
Why should we care?
One natural interpretation of a latent variable model is as a set of abstractions or concepts, which help compress certain parts or structures in the world (this is why the subtitle of the paper is 'a theory of concepts'). So the fact that we have a condition under which two models of the world might converge on the same set of abstractions (in that we can translate between them) is notable. This result broadly comes under the umbrella of Ontology Identification: the question of how agents (AIs or humans) internally represent the world. It is closely related to work on Natural Abstractions which asks whether, for a given dataset, there is a given 'natural' set of concepts or abstractions which most agents will converge on using. Since this work investigates these issues in the information-theoretic context, it is also closely related to Natural Latents (for more on this, see Daniel and Jeremy's post).
This[2] is interesting from an AI Safety perspective since it might allow us to understand what is going on in 'inscrutable' machine learning models (interpretability) and translate the goals of AI systems into chunks or concepts that we can study. We might want to try to construct AIs so that they use 'natural' abstractions to model the world, or we might want to prove that our AI systems converge on using natural abstractions by default. There might also be a sense in which certain natural abstractions are 'correct' if we can argue that they correspond to particularly efficient representations of the world. Additionally, our values are often defined in terms of the abstractions we use. If I value 'tulips', and I ask my AI to maximize the number of tulips, then I want to be sure that the AI has learned the same abstraction of tulips that I have.
If this 'compressing-while-also-having-easy-access-to-sub-parts' is a useful or natural thing for agents (humans or AIs) to do, it may turn out that they/we already do it. This would mean that we could apply Condensation results to world models in AIs and use them translate their contents into understandable/predictable concepts. Alternatively, we might want to use these facts to train AIs in ways which satisfy this 'compressing-while-also-having-easy-access-to-sub-parts' property which might make them more interpretable.
Ok, hopefully you are motivated. We'll now introduce the cast of characters. The main objects in the Condensation paper are Random Variable Models and Latent Variable Models, so we'll spend a while introducing these.
Doing Random Variables Properly
If you are a caveman like me, when someone says 'random variable' you think 'thing with a bunch of outcomes where each outcome has an associated probability (or probability density)'. For most purposes, this is fine, but the Condensation paper uses more formal language of random variables as functions on a sample space so we'll briefly recap this here. This section will mainly just be a list of fairly standard textbook definitions, if you think you know them all, do at least skim it to get a feel of how the notation will be used throughout the rest of the post.
A Sample Space is the set of all possible outcomes for some random process. This can be continuous, but in all the examples we consider it will be discrete and finite. Eg. if I toss two coins, the sample space might be .
An Event Space is the set of subsets of the sample space we would like to consider. It must be a sigma algebra, which very broadly means that it must 'carve up' the sample space in a nice way. We won't worry too much about the event space here, as we will almost always take it to be the powerset of (ie. the set of all subsets).
A Probability Measure is a map from the event space to a probability between 0 and 1. ie. . It must obey various intuitive axioms which allow it to represent a probability. For example (the probability of no outcome happening is zero) and (the probability of the union of all possible events is one).
Together the triple of sample space, event space, and probability measure is known as a Probability Space.
A Random Variable is a function which maps from the Sample Space to some set of outcomes , so we write . A random variable represents an object which in some way depends on some random process. To be a random variable the function must be 'well-behaved' (ie. measurable). This property won't be super important to us when we are considering the discrete random variables with -algebras that are the powerset, but its worth being aware of if you want to start using different -algebras or continuous variables. For example, a random variable on our sample space defined above might be 'the outcome of the first coin toss'. This function would map .
Normally, we write things like or to indicate 'the probability that random variable has outcome ' . Since is a probability measure you might be tempted to write to indicate 'the probability that random variable has outcome . Note that, in the way we have defined things here, this expression doesn't even make sense. The probability measure is defined on the event space not on the outcomes so is a meaningless expression. If is an outcome of and we want to express the probability of this outcome occurring, we would have to add up probabilities of all the outcomes in the sample space which lead to having outcome . We can write:
Going forward, I'll use to indicate 'the probability that random variable X has outcome ' and to refer to 'the distribution of outcomes of the random variable X' but note that both of these implicitly are defined through a probability measure which, most of the time will not be explicitly stated.
The Pullback of a Random Variable. Sometimes it is useful to re-define a random variable so that it lives in a different sample space. Let be a random variable defined on a sample space and let be part of a probability space . Now, consider a different probability space . If we want to define a version of that lives in , instead of , we can use the pullback.
To do this, we introduce a map which maps from to . The map must be probability preserving. This means that for all events , we have that (the probability of that event in space ) is equal to (the probability of the events in that get mapped to through ). We then compose and together to get a map from to . This map is itself a random variable, this time defined on . We call this new random variable the pullback of by and denote it . Note that by enforcing that is probability-preserving, the distributions of and are identical. Here's a simple example.
Consider our random variable from before. We had being a sample space containing the results of two coin tosses and mapped this sample space to , picking out only the result of the first coin toss. But now suppose we want to describe as living in a world with three coin tosses. We now have a new sample space
We can define a map from to as the map which throws away the last coin toss ie. etc. The pull back of by is which is just the function we get by first applying to an element from to get an element from and then applying to this element of to get a value in . So etc.
Random Variable Models and Latent Variable Models
Random Variable Models (RVMs) (Definition 4.1)
For our purposes, a random variable model is a set of random variables along with a sample space on which they are all defined. The subscripts are labels which come from an 'index set' . We'll assume that these random variables have a well-defined joint probability distribution ) from which the probabilities of any subset of them can be obtained. Sam Eisenstat uses the 'tuple builder' notation to treat multiple random variables as one 'string'. For example, suppose we only have three random variables in our model, so our index set can be written . Then we could denote the whole 'family' of random variables as:
We can refer to the whole Random Variable Model as a pair . As we stated earlier, this will live in probability space so there is an implicit probability measure in the background, generating the distribution but we won't write it in explicitly.
Latent Variable Models (LVMs) (Definition 4.2)
The first thing about Latent Variable Models is that they never exist in isolation. When we talk of a Latent Variable Model we are always talking about a Latent Variable Model associated with a particular Random Variable Model. Most of the time this will be implicit so its worth remembering. It's also worth remembering that you can have multiple different Latent Variable Models for the same Random Variable Model.
Once we have fixed a Random Variable Model , an associated Latent Variable Model (LVM) contains three things. First, a sample space . This may or may not be the same space as the sample space used for the RVM.
Next the LVM contains random variables defined on . We will call these 'latent variables'. We assign one latent variable to each subset of . If is a subset of , then is used to denote the variable assigned to the subset . Again, using the 'tuple builder' notation before, our complete 'joint' latent variable can be denoted where indicates the powerset of the index set (the '+' superscript indicates that we considering the powerset but not including the empty set). Using our example from before, if , then so
So: the LVM contains one latent variable for each subset of random variables in the RVM. As we'll see in just a moment, the subscript of the latent variable corresponds to the set of random variables which each latent variable 'contributes to'. So only contributes to random variable , whereas can represent information that is shared across both variables and Ideally, each latent variable contains only information that is used by the random variables indicated by its subscript, but we also allow for 'inefficient' latent variable models, where (say) also contains some extra information that doesn't contribute to or . More on this later.
Finally, the LVM contains an object which denotes the way in which the latent variables 'contribute to' or 'explain' the random variables[3]. To capture this, we introduce a probability-preserving map and the following condition which I'll quote from the paper
for each random variable the pullback is almost everywhere a function of the random variables such that and . In other words, is almost everywhere equal to for some measurable function from the product of the ranges of the random variables to the range of
what this means is that we can decompose into two stages. First, we take all the latent variables which have a subscript containing . Taken together, these map from to a tuple of Y-values. Then, there is some function , which takes these values and maps them to the range of [4].
In practice, what this means is that, if I tell you the values of all the variables for all the sets which contain , you can work out the value of (for all ).
For example, consider in our RVM. All of the latent variables that 'contribute' to are those with subscripts containing '2' so we look through our latent variables and find all of the appropriate variables. This gives us the tuple
If we use indicate the range of latent variable (so etc.) then this is a variable that maps to . Eisenstat's condition requires that there must be a function which we can apply to to get a value in the range of such that composing these two functions (, followed by ) gives us the same result as . In order for the condition to be satisfied, something similar must be the case for all , not just .
A way to think about this is that if I asked you the question 'What is the value of ?', you would be able to find the answer by looking at only the set ie. all of the latent variables which have a 2 somewhere in their subscript. In Abram Demski's analogy, the set is the set of 'notebooks' that are sufficient to recover the answer to 'what is the value of ?'
This might seem a bit heavy, but its actually pretty intuitive. We'll walk through a simple example to show what's going on.
Example
Let's consider a Random Variable Model on a sample space containing six coinflips: . An element in will take the form where each represents the result of one coinflip. For example corresponds to . We'll assume that these are fair coin tosses so our probability measure is uniform over and for all .
Our RVM will contain four random variables defined as follows.
So picks out the i-th toss and combines it with the (if ) or (if ).
Now, lets construct some Latent Variable Models for this Random Variable Model. To keep things simple we'll use the same sample spaces for both the LVM and RVM, so we'll take .
First, here's a silly/inefficient Latent Variable Model that still works. Lets set
In words: all latent variables are constant (ie. contain no information) except for which contains all the information about all of the coin tosses and every outcome. We'll call this LVM .
Let's check that this satisfies the conditions for a latent variable model. To do this, we'll have to identify the map and the functions such that each is equal to . Thankfully, this is straightforward. We'll set the map equal to the identity. Then, the pullback of is trivial so . Furthermore, we can say that each is a function of by simply setting equal to the i-th entry of the tuple of values of .
This is a valid latent variable model but notice that it is a very inefficient representation of its associated the Random Variable Model. Since all variables contain the values of all variables, this LVM fails to compress the RVM. Every time you want to get information about from the LVM, you have to read through (and then discard) all the extra irrelevant information about in the .
Again, returning to Abram Demski's analogy: if are all questions that the information desk worker could be asked, then one strategy she could use is to put all information about all the subjects into one big book and just hand that book to the person whenever they asked her anything. Regardless of which question they ask, this book will contain the answer. Its just an unfortunate fact about this filing system that the book will also contain a lot of other crap that they didn't ask about.
Can we construct a 'better' latent variable model? Based on the way that are related, an intuitive LVM suggests itself. Each coin toss (for ) contributes only to . This suggests the following set of latent variables. Furthermore, we can see that and share the coin toss and and share the coin toss . Let's set the following latent variables:
What about all the other latent variables ( ... etc.) ? We could set them to be anything we wanted since we already have what we need from the six latent variables defined above, but for simplicity, let's set them equal to constants and forget about them for the rest of the example.
Again, we set to be the identity, which gives us . Now, can we express as a function of ? Yes! We simply take the first bit from and the second bit from either or , depending on whether or . So:
Let's call this LVM . It seems intuitively like is 'better', or 'more natural' or more 'efficient' than the first model. If only there was some way of quantifying this...
Scoring Functions (Definition 4.3)
In our previous examples, the latent variable model (where contains all the information about all values) seemed inefficient. This is because the latent variable contained much more information than was needed to answer 'what is the value of ?'. Ideally, the values used to determine would only contain information that was relevant to determining , and no extra information. In the information desk analogy, the books given to answer the question should contain only information relevant to and nothing else.
Since the 'amount of information' carried by a random variable is captured by its entropy, a naive way to quantify the efficiency of a LVM for a particular is to add up the entropies of all the contributing latent variables. This is the intuition behind the simple score. The simple score for a latent variable model for random variable , in a RVM is given by
In the paper, Eisenstat goes a little further than this and defines the simple score not only for individual 's but also for sets of random variables. This is the full definition for the simple score for a latent variable model for a set :
ie. we sum over the entropies of all variables for 's that intersect with set of interest . For a set , the smaller the score is, the more 'efficient' the latent variable model is for describing that set. As we'll see in a later section, the smallest possible simple score for a variable is where but it will often be bigger.
For example, our model will have for all subsets . This will be larger than for all 's except . On the other hand, (our more 'efficient' latent variable model) has
This low value reflects the fact that the latent variables in do not contain unnecessary information and in this sense is a 'better' latent variable model than .
The simple score is fine as an intuition-builder, but there is an important element it misses out. Namely: we can use information about 'higher level' latents (eg ) to help us compress lower-level latents (eg or ). Again, using Abram Demski's notebook analogy: suppose higher level notebook (eg ) is a book about differential equations and the lower level notebooks and are about fluid dynamics and population dynamics respectively. We can assume that everyone reading the fluid mechanics book will also have access to the differential equations book (since, whenever we have to use to answer a question, we know we'll also be able to use ). This allows the fluid mechanics book to be shorter and more 'compressed' than it otherwise might be. For example, the differential equations book might introduce notational shorthand which is used to compress equations in the fluid mechanics book, or the fluid mechanics book might be able to refer to standard proofs which are present in the differential equations book, rather than writing them out in full.
As a result, we shouldn't really just sum the entropies of each latent variable. Instead, we should sum the conditional entropies of lower-level latents, conditional on the higher-level latents. Every time we invoke to answer a question, we know we are also going to invoke , and . More generally: every time we use a latent variable to answer a question, we know we are going to also use all of the other latent variables which contain as a subset. So, instead of using the entropy of , we can use the entropy of , conditional on all latent variables , where . Summing entropies in this way, as opposed to just to just summing over gives us the conditioned score for a latent variable in latent variable model :
Again, a more efficient LVM will have a smaller conditioned score. Notice that, in both and , the 'higher level' latent variables and the 'lower level' variables are independent, so conditioning on the higher level latent actually doesn't change anything. As a result, the simple scores and conditioned scores are equal ie. and for all . But note that in general this is not the case.
So far, all of our score are properties of the latent variable model for a particular set of random variables . Most of the time, this is what we will be concerned with, but it is possible to introduce a 'global' aggregate score, by averaging over all of the scores for each set A in the powerset of I. Sam Eisenstat does this in Definition 4.3, by introducing a weighted average simple score:
Where the weights capture how much we care about the score at the subset A. Without specifying details about the setup, there is no natural way to decide what these wieghts should be and aggregate scores of this kind are not considered for the rest of the paper, so you can forget about them for now. Going forward we will mainly be concerned either about the scores at individual A's or 'perfect condensations' where the scores are as low as they can possibly be at every set. We'll explain the concept of perfect condensation a bit more after proving some properties of the score.
Some useful properties of the scores
Here, we'll quickly prove a string of useful inequalities relating these scores. These are covered in Proposition 5.2 in the paper. In particular, we will prove:
where is the joint variable containing all of all latent variables whose indices intersect with the set ie. .
First, the simple score is always greater than the conditioned score. Since conditioning never increases entropy, we have that for all . Thus, every term in the sum comprising is less than every corresponding term in the sum for . Hence:
Second, the conditioned score is always greater than the entropy of the joint variable containing all sets which intersect with . As we just mentioned, this variable is denoted and can be expressed as using tuple builder notation. This proof is a bit hard to follow in the paper. I'll give a similar proof here which I think is a little simpler, but I'm not super happy with it.
Let's take all of the variables in and put a total ordering on them. The condition that we'll put on this ordering is that if . If neither or contains the other we'll use some tiebreak condition (eg. based on the numbers in the set indices). We can always do this. This ordering will result in the identity set variable being the highest in the ordering and the individual single index sets being the lowest in the ordering. Now, we'll re-label these variables according to their number in the ranking. We'll re-label each variable as where is the ranking in the ordering. will always be ranked first so it gets re-labelled . For example, if and , we could re-label in the following way (using the size of the numbers in the index sets as tiebreakers when we have two same-sized sets).
Now, by the entropy chain rule, we can write
Note that, by virtue of the ordering used, for each term in this sum, the entropy of will be conditioned on all variables corresponding to supersets of and additionally it may be conditioned on other variables corresponding to set of the same cardinality as which are not supersets. For example, in our example where , the term appearing in the sum would be
Now, we can compare each term in this sum produced by the chain rule to each term in the expression for . Note each sum will have a term for each with so we can pair corresponding terms. Each term in the chain rule sum can be matched by a term in the sum. The only difference will be that the chain rule terms may be conditioned on extra variables. For example the term in the sum will be whereas the corresponding term in the chain rule sum will be . Since conditioning cannot increase entropy, we will have that each term in the chain rule sum is less than or equal to each term in the sum and thus we have
Finally, by definition, we have that each is a deterministic function of all the latent variables with . Trivially, this also means that is a deterministic function of all variables with . As a result, we have for some function . Since passing a variable through a function cannot increase its entropy, we have:
Stringing our inequalities together, we have:
So: both and are lowerbounded by . When we have a latent variable model which satisfies for all , we say that the Latent Variable Model perfectly condenses the Random Variable Model, or that that the LVM is a perfect condensation (Definition 5.3 in the paper). Perfect condensation means that for any subset of random variables you can always reconstruct the value of those variables using the appropriate latent variables without those latent variables containing any extraneous information.
An important fact about perfect condensation is that a perfect condensation does not always exist. It is an ideal that is not achievable for many random variable models. Perfect condensation requires that shared information is exactly shared, like our example earlier, where the value of coin was exactly and deterministically shared between and . When the shared information between variables is noisy we cannot have a perfect condensation (for example: if two coin tosses share a bias, but are not exactly the same value, then the coins share information in a noisy way). We'll show why this is the case in the next post when we prove some properties of perfect condensation.
(We can also have simple-perfect condensation which is when a latent variable model which satisfies for all . Most of the interesting condensation results concern the conditioned score, so we won't consider the simple score much going forward except as an intuition-builder.)
One of the results of the paper (Theorem 5.15) tells us that if two different Latent Variable Models are both perfect condensations, then we can define functions which map between the latent variables of each one, showing their 'equivalence' or 'natural-ness'. Another theorem (Theorem 5.10) shows that perfect condensations must have a Bayes net-like structure. We'll prove these results in the next post.
- ^'Close to' here meaning 'within 1'. In particular, the number of bits required to encode a string made from N samplings of variable X approaches N H(X). The way I've stated this has some simplifications, see Shannon's Source coding theorem for more details.
- ^If you have a sense of deja-vu, this paragraph is repeated from my Natural Latents post. I found myself writing the paragraph and thinking 'I'm sure I've written something almost identical to this before' so I just copied it.
- ^This is one place where the paper gets a little confusing because the notion of 'contribution' is defined in two slightly different ways with different notation in Definition 3.2 and Definition 4.2 respectively. I'll use the version used in Definition 4.2 (the 'formal' definition), but don't be surprised if you read early parts of the paper and find a different notation. In particular Definition 3.2 includes the 'contribution relation' which says whether a latent variable 'contributes to' a particular random variable. We don't need this using the notation from Definition 4.2, since the subscript of tells us that it contributes to all the variables for .
- ^I am glossing over the 'almost everywhere' condition. This only becomes necessary when the sample spaces are continuous. We will only deal with discrete sample spaces, so for 'almost everywhere' you can just read 'everywhere'.