# A Solomonoff Inductor Walks Into a Bar: Schelling Points for Communication

A Solomonoff inductor walks into a bar in a foreign land. (Stop me if you’ve heard this one before.) The bartender, who is also a Solomonoff inductor, asks “What’ll it be?”. The customer looks around at what the other patrons are having, points to an unfamiliar drink, and says “One of those, please.”. The bartender points to a drawing of the same drink on a menu, and says “One of those?”. The customer replies “Yes, one of those.”. The bartender then delivers a drink, and it matches what the first inductor expected.

What’s up with that?

The puzzle, here, is that the two Solomonoff inductors seemingly agree on a categorization - i.e. which things count as the Unnamed Kind Of Drink, and which things don’t, with at least enough agreement that the customer’s drink-type matches the customer’s expectations. And the two inductors reach that agreement *without* learning the category from huge amounts of labeled data - one inductor points at an instance, another inductor points at another instance, and then the first inductor gets the kind of drink it expected. Why (and when) are the two inductors able to coordinate on roughly the same categorization?

Most existing work on Solomonoff inductors, Kolmogorov complexity, or minimum description length can’t say much about this sort of thing. The problem is that the customer/bartender story is all about the *internal* structure of the minimum description - the (possibly implicit) “categories” which the two inductors use *inside* of their minimal descriptions in order to compress their raw data. The theory of minimum description length typically treats programs as black boxes, and doesn’t attempt to talk about their internal structure.

In this post, we’ll show one potential way to solve the puzzle - one potential way for two minimum-description-length-based minds to coordinate on a categorization.

Main Tool: Natural Latents for Minimum Description Length
=========================================================

Fundamental Theorem
-------------------

Here’s the main foundational theorem we’ll use. (Just the statement for now, more later.)

We have a set of n data points (binary strings) $\{x_i\}$, and a Turing machine TM. Suppose we find some programs/strings $\Lambda, \{\phi_i\}, \Lambda’, \{\phi_i’\}$ such that:

*   Mediation: $(\Lambda, \phi_1, …, \phi_n)$ is an approximately-shortest string such that (TM($\Lambda, \phi_i$) = $x_i$ for all $i$)
*   Redundancy: For all $i$, $(\Lambda’, \phi_i’)$ is an approximately-shortest string such that TM($\Lambda’, \phi_i’$) = $x_i$.[^d6fqlmasjj5]

Then: the K-complexity of $\Lambda’$ given $\Lambda, K(\Lambda’|\Lambda)$, is approximately zero - in other words, $\Lambda’$ is approximately determined by $\Lambda$, in a K-complexity sense.

(As a preview: later we’ll assume that both $\Lambda$ and $\Lambda’$ satisfy *both* conditions, so both $K(\Lambda’|\Lambda)$ *and* $K(\Lambda|\Lambda’)$ are approximately zero. In that case, $\Lambda$ and $\Lambda’$ are “approximately isomorphic” in the sense that either can be computed from the other by a short program. We’ll eventually tackle the customer/bartender puzzle from the start of this post by suggesting that $\Lambda$ and $\Lambda’$ each encode a summary of things in one category according to one inductor, so the theorem then says that their category summaries are “approximately isomorphic”.)

### The Intuition

What does this theorem mean intuitively?

Let’s start with the first condition: $(\Lambda, \phi_1, …, \phi_n)$ is an approximately-shortest string such that (TM($\Lambda, \phi_i$) = $x_i$ for all $i$). Notice that there’s a somewhat-trivial way to satisfy that condition: take $\Lambda$ to be a minimal description of the whole dataset $\{x_i\}$, take $\phi_i = i$, and then add a little bit of code to $\Lambda$ to pick out the datapoint at index $\phi_i$[^t0k8ih410e]. So TM($\Lambda, \phi_i$) computes all of $\{x_i\}$ from $\Lambda$, then picks out index $i$. Now, that might not be the *only* approximately-minimal description (though it does imply that whatever approximately-minimal $\Lambda, \phi$ we do use is approximately a minimal description for all of x). Conceptually, insofar as there’s information in $x_i$ which is irrelevant to all the other $x_j$’s, we could “move” that information from $\Lambda$ into $\phi_i$. But **any information which is relevant to more than one **$x_i$** has to be in **$\Lambda$.

Now let’s consider the second condition: for all $i$, $(\Lambda’, \phi_i’)$ is an approximately-shortest string such that TM($\Lambda’, \phi_i’$) = $x_i$. Again, there’s a somewhat-trivial way to satisfy the condition: take $\Lambda’$ to be empty, and $\phi_i’$ to be a minimal description of $x_i$. Again, that might not be the only approximately-minimal description. Conceptually, insofar as there’s information which is redundantly represented across *all* the $x_i$’s, that information can be “moved” into $\Lambda’$. But $\Lambda’$** can only contain information which is redundantly represented across all **$x_i$**’s**.

Put those two together, and we get a simple intuitive statement of the theorem: if $\Lambda$ contains *all* information which is relevant to more than one datapoint, and $\Lambda’$ contains *only* information which is redundantly represented across all datapoints, then $\Lambda$ contains all the information in $\Lambda’$.

Intuitively: imagine that $\Lambda$ is a pipe between $x_i$ and $x_j$, and the only way for information to move between $x_i$ and $x_j$ is through that pipe. Then if some information $\Lambda’$ is present in both $x_i$ and $x_j$, it must have gone through the pipe. It’s the same idea as [deterministic natural latents](https://www.lesswrong.com/posts/fJb8ryrMW5XfJaq7m/approximately-deterministic-natural-latents), but now in a minimum description length setting.

So that’s the idea. Now we’re ready for the actual math.

### Background: Working with Kolmogorov Complexity

We kicked around the word “approximation” a lot, in stating the theorem. Approximation in what sense?

When working with Kolmogorov complexity, a prototypical theorem looks like:

*   Take in the value of some K-complexity, $K(X|Y)$. That means assuming there exists a program of length $K(X|Y)$ which outputs $X$ on input $Y$. Call that program $F$ (for “function”).
*   Construct some other program $F’$ which either uses $F$ as a subroutine, or relies somehow on the existence of $F$. The length of the new program is either the length of $F$ (i.e. $K(X|Y)$) plus a little bit of new code, or just a little bit of new code. The theorem says the new code is small in a big-$O$ sense compared to the length of $F$ \- i.e. $O(1)$ or $O(\text{log} K(X|Y))$ is typical.

As an example: if $Y$ is a shortest program to compute $X$, then

$K(Y|X) \leq O($log $K(X))$ [^g89ph45edmr]

Here’s a rough sketch of the program of size $O($log $K(X))$ which outputs $Y$ on input $X$. The program will have $K(X)$ hardcoded (which takes $O($log $K(X))$ bits). It will also have hardcoded a number $k$, such that among inputless programs of size $K(X)$ which output $X$, $Y$ is the $k^{th}$ to halt. It turns out that there can’t be very many minimal programs (though we won’t prove that part here), so log $k \leq O($log $K(X))$. The program itself runs all programs of length $K(X)$ until the $k^{th}$ halts and returns $X$, then returns the $k^{th}$ program to halt and return $X$; that code requires only a constant number of bits to specify. So, the total size of the program is $O($log $K(X))$ bits.

That’s what the programs involved in prototypical K-complexity theorems tend to look like. The key idea to remember is that, wherever you see O(blah) terms, that usually means there’s some simple wrapper code of the relevant size.

### More Precise Statement of the Fundamental Theorem

We have a set of $n$ data points (binary strings) $\{x_i\}$, and a Turing machine TM. Suppose we find some programs/strings $\Lambda, \{\phi_i\}, \Lambda’, \{\phi_i’\}$ such that:

*   Mediation: len($\Lambda, \phi_1, …, \phi_n$) $\leq \epsilon +$ min$_{\Lambda, \phi_1, …, \phi_n}$ len($\Lambda, \phi_1, …, \phi_n$) subject to (TM($\Lambda, \phi_i$) = $x_i$ for all $i$)
*   Redundancy: For all $i$, len($\Lambda’, \phi_i’$) $\leq \epsilon’ +$min$_{\Lambda’, \phi_i’}$ len($\Lambda’, \phi_i’$) subject to TM($\Lambda’, \phi_i’$) = $x_i$.

Then: $O($$\epsilon + \epsilon’ +$log $K(x)$) $\geq K(\Lambda’|\Lambda)$.

The proof has been relegated to the appendix.

Implications: Minimality, Maximality, Isomorphism
-------------------------------------------------

When a string $\Lambda$ satisfies *both* the mediation and redundancy conditions over some strings $x_1, …, x_n$, we call $\Lambda$ a *natural latent* over $x_1, …, x_n$ (overloading our terminology for "natural latents" in the probabilistic setting). Equipped with the fundamental theorem, we can now carry over all the standard properties of [deterministic natural latents](https://www.lesswrong.com/posts/fJb8ryrMW5XfJaq7m/approximately-deterministic-natural-latents) in the probabilistic setting to natural latents in the minimum description length setting.

### Minimality

Suppose the string $\Lambda$ satisfies *both* the mediation and redundancy conditions over some strings $x_1 … x_n$:

*   Mediation: there exists $\phi_1, …, \phi_n$ such that $(\Lambda, \phi)$ has minimal length to within $\epsilon$ bits subject to ($\forall i$: TM($\Lambda, \phi_i$) = $x_i$).
*   Redundancy: For all $i$, there exists $\phi_i’$ such that ($\Lambda, \phi_i’$) has minimal length to within $\epsilon’$ bits subject to TM($\Lambda, \phi_i’$) = $x_i$.

Then  $\Lambda$ satisfies the mediation condition, and for any *other* string $\Lambda’$ which satisfies the mediation condition to within $\epsilon$ bits, the Fundamental Theorem tells us

$O(\epsilon + \epsilon’ +$ log $K(x_1, x_2)) \geq K(\Lambda|\Lambda’)$

i.e. there exists a short program to compute $\Lambda$ from $\Lambda’$. So $\Lambda$ is a “minimal” string which satisfies the mediation condition; it can be computed from any other via a short program.

### Maximality

Suppose, again, that the string $\Lambda$ satisfies *both* the mediation and redundancy conditions over some strings $x_1 … x_n$:

*   Mediation: there exists $\phi_1, …, \phi_n$ such that $(\Lambda, \phi)$ has minimal length to within $\epsilon$ bits subject to ($\forall i$: TM($\Lambda, \phi_i$) = $x_i$).
*   Redundancy: For all $i$, there exists $\phi_i’$ such that $(\Lambda, \phi_i’)$ has minimal length to within $\epsilon’$ bits subject to TM($\Lambda, \phi_i’$) = $x_i$.

Then $\Lambda$ satisfies the redundancy condition, and for any *other* string $\Lambda’$ which satisfies the redundancy condition to within $\epsilon’$ bits, the Fundamental Theorem tells us

$O(\epsilon + \epsilon’ +$ log $K(x_1, x_2)) \geq K(\Lambda’|\Lambda)$

i.e. there exists a short program to compute $\Lambda’$ from $\Lambda$. So $\Lambda$ is a “maximal” string which satisfies the redundancy condition; any other can be computed from $\Lambda$ via a short program.

### Isomorphism

Finally, suppose that *both* the string $\Lambda$ and the string $\Lambda’$ satisfy *both* mediation and redundancy to within $\epsilon$ and $\epsilon$’ bits, respectively. Then

$O(\epsilon + \epsilon’ +$ log $K(x_1, x_2)) \geq K(\Lambda|\Lambda’)$

and 

$O(\epsilon + \epsilon’ +$ log $K(x_1, x_2)) \geq K(\Lambda’|\Lambda)$

So either of the strings $\Lambda, \Lambda’$ can be computed from the other via a short program. In that sense, the two are “isomorphic”.

Main Takeaway
-------------

The main upshot which we’ll use in the next section is the isomorphism property, so we’ll restate it here in full.

Suppose the string $\Lambda$ satisfies *both* the mediation and redundancy conditions over some strings $x_1 … x_n$:

*   Mediation: there exists $\phi_1, …, \phi_n$ such that $(\Lambda, \phi)$ has minimal length to within $\epsilon$ bits subject to ($\forall i$: TM($\Lambda, \phi_i$) = $x_i$).
*   Redundancy: For all $i$, there exists $\phi_i’$ such that $(\Lambda, \phi_i’)$ has minimal length to within $\epsilon’$ bits subject to TM($\Lambda, \phi_i’$) = $x_i$.

Assume that $\Lambda’$ *also* satisfies both conditions:

*   Mediation: there exists $\phi_1, …, \phi_n$ such that $(\Lambda’, \phi)$ has minimal length to within $\epsilon$ bits subject to ($\forall i$: TM($\Lambda’, \phi_i$) = $x_i$).
*   Redundancy: For all $i$, there exists $\phi_i’$ such that $(\Lambda’, \phi_i’)$ has minimal length to within $\epsilon’$ bits subject to TM($\Lambda’, \phi_i’$) = $x_i$.

Intuitively, these say that both $\Lambda$ and $\Lambda’$ capture approximately *all* the information which is relevant to more than one $x_i$, and approximately *only* the information which is redundantly represented across all $x_i$.

Then:

$O(\epsilon + \epsilon’ +$ log $K(x_1, x_2)) \geq K(\Lambda|\Lambda’)$

$O(\epsilon + \epsilon’ +$ log $K(x_1, x_2)) \geq K(\Lambda’|\Lambda)$

In other words: a short program exists to compute $\Lambda$ from $\Lambda’$, and a short program exists to compute $\Lambda’$ from $\Lambda$.

Back to Solomonoff’s Bar
========================

Let’s talk about the problem faced by our two Solomonoff inductors - the customer and the bartender.

As a (very) simplified model, let’s say that they both start out with matching background models of what generally happens when one places an order in a bar - i.e. certain words are spoken, a liquid shows up in a container, all that jazz. We’ll assume that the two already break up the world into a bunch of individual instances of “drinks” (a pint on the bar over here, a glass on the table over there, …) all of which are observed by both inductors; that will be our most egregious simplification of the problem. We’ll call those individual drink-instances in the world $x_1, …, x_n$. The (very simplified) problem the two then face is how to categorize various physical instances of liquids-in-containers, such that when the customer asks for a drink in a certain category (i.e. “one of those” + pointing), they end up with the kind of drink they expected.

By contrast, what would be a *bad* outcome for the two? Well, maybe the bartender just categorizes drinks by booze content, and the customer just categorizes drinks by color, so the customer thinks they’re asking for a blue drink but the bartender thinks they’re asking for a drink with 10% alcohol content, and the customer unexpectedly-to-them ends up with a pink drink. That’s the sort of thing we want to avoid.

So the customer and the bartender face a coordination problem - both want the customer to not be surprised at their drink. And it’s a coordination problem in the [Schelling sense](https://www.lesswrong.com/posts/yJfBzcDL9fBHJfZ6P/nash-equilibria-and-schelling-points), insofar as the two will not be able to exchange anywhere near enough data to brute-force learn each others’ categorizations.

How can the two use the theorems here to coordinate on a choice of categorization, without exponentially huge amounts of communication? We’ll tackle the problem in two steps:

*   First, an even simpler problem in which there’s just one drink type, in order to illustrate what parts of the problem are handled by the isomorphism argument.
*   Second, the simplified customer/bartender problem itself, with multiple drink types.

### Even Simpler Subproblem: Just One Drink Type

Suppose there’s just one drink type - maybe this is soviet Russia, and a shot of vodka is the only option. We still have a version of the customer/bartender problem: they should both roughly agree on what a shot of vodka is. If the bartender prepares a thing which they think of as a shot of vodka, the customer should not receive a thing which they think of as, say, a giraffe.

Well, both inductors see $x_1, …, x_n$, which are all shot-of-vodka-instances. Suppose they both look for a natural latent over those instances, and both find one: $\Lambda$ for the customer, $\Lambda’$ for the bartender. Then we know that the two have found approximately-isomorphic strings.

Now, the bartender creates a new thing $x_{n+1}$, which is approximately-optimally compressed as passing a new incompressible string (i.e. noise) to the generator $\Lambda’$, just like the bartender models all the other $x_i$’s as having been generated. $\Lambda’$ is therefore natural over $x_1, …, x_{n+1}$. And since $\Lambda’$ is approximately isomorphic to $\Lambda$, $\Lambda$ is natural over $x_1, …, x_{n+1}$. So, when the customer receives their drink, they see that it’s approximately-optimally compressed by $\Lambda$ plus some incompressible noise, and it’s also approximately-optimally compressed *jointly* with $x_1, …, x_n$ by $\Lambda$ plus some incompressible noise. It is, in other words, basically what the customer expected.

So that’s the basic story. Now let’s kick it up a notch, and handle multiple drink-types.

Multiple Drink Types: Categorizing by Shared Natural Latent
-----------------------------------------------------------

Our two inductors both start out with the “data points” $x_1, …, x_n$, each of which is one physical instance of a drink. Then one obvious move is to look for a natural latent over these strings, or over various subsets of the strings.

In general, there’s no guarantee that any natural latent exists at all (to within reasonable approximation). And even if natural latents do exist over some subsets of the data points, they might have some complicated structure - e.g. maybe there’s a natural latent between $x_1$ and $x_2$ and another between $x_2$ and $x_3$ but those two have very different stuff in them, or maybe there’s hierarchical structure like e.g. a natural latent over the first half of the data and another over the second half and then a natural latent over those two natural latents, or ???. Most of those possibilities don’t look much like “categories of drinks”, at least not in a simple sense. But perhaps our intuitive notion of simple “categories” maps to a specific kind of natural latent structure?

Here’s a simple structure which seems like a decent fit.

Imagine that we have 8 drink-instances $x_1, …, x_8$. We find a natural latent $\Lambda_a$ between $x_1$ and $x_2$. On further investigation, we find that the same string $\Lambda_a$ is natural over all of $x_1, x_2, x_5$, and $x_7$.[^wlj1v527xs] Then we find another string $\Lambda_b$which is natural over $x_3$ and $x_4$, and a third string $\Lambda_c$ which is natural over $x_6$ and $x_8$. Finally, we find that the strings $\{x_1, x_2, x_5, x_7\}$ are independent[^e3etgasbafu] of the strings $\{x_3, x_4\}$ and all those are independent of the strings $\{x_6, x_8\}$.

We can summarize all that with the diagrams:

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfTAlFrgTL_PRy-BGU7_YcQoKFwqBpJY-42i5fndNRpF8oNk2sKOkO6-ZuAifyUzSl1xKqjbPNW9VE8NxlUohvmLyAtVtwlM4PKsD1SI0tCS79h-9ZKBWH1U3DA_FBDCFNEo257J4kbMd5VFPZ4mt5iwal_?key=25E-nomFZKUy3JsdoerTtA)

where we use the “$\bot$” symbol to denote naturality, and unconnected diagrams next to each other indicate independence.

In this case, it makes a lot of intuitive sense to view each of the three latents as a generator or specification for a certain category of drink. There is no compressible shared information across drinks in different categories, and $\Lambda_\alpha$ captures all-and-only the information shared across drinks with category $\alpha$, for each category $\alpha$.

*If* such $\Lambda$’s exist, how can the customer and bartender use them to solve their coordination problem?

Well, assume they’re both looking for $\Lambda$’s with this structure - i.e. they both want to partition the set of drinks such that there exists a nonempty natural latent over each subset, and independence[^0ehnie2ufuc] across subsets. If that’s possible at all, then the partition is unique: pairwise independent strings must go in different subsets, and pairwise non-independent strings must go in the same subset. (If we consider a graph in which each node is one of the strings $x_i$ and two nodes are connected iff they are non-independent, then the connected components of that graph must be the subsets of the partition.)[^hxe6qw2qr85]

With the partition nailed down, we next invoke uniqueness (up to isomorphism) of natural latents within each subset, i.e. the “isomorphism” result we proved earlier.[^138yre2v5jm]

As long as the customer and bartender are both looking for this kind of structure in the strings $x_1, …, x_n$, and the structure exists to be found in the strings, they will find the same partition (modulo approximation) and approximately isomorphic latents characterizing each class of drinks.

So the customer walks into the bar. They point at a drink - let’s say it’s $x_{7}$ \- and say “One of those, please.”. The bartender has $x_{7}$ in subset $a$, with generator $\Lambda_a$. Just to double check, they point to a picture of a drink also generated by $\Lambda_a$, and the customer confirms that’s the type of drink they want. The bartender generates a drink accordingly. And since the customer and bartender have approximately isomorphic $\Lambda_a$, the customer gets what they expected, to within reasonable approximation.

### Formal Specification

Both inductors look for

*   some strings $\Lambda_1, …, \Lambda_k$ (conceptually: $\Lambda_j$ encodes a generator for drink type $j$),
*   integers $c_1, …, c_n$ in $[1, …, k]$ (conceptually: the category of each drink-instance),
*   and bitstrings $\phi_1, …, \phi_n, \phi_1’, …, \phi_n’, \phi_1' ', …, \phi_n' '$ (conceptually: random noise encoding details of each drink-instance for each of the optimization problems)

such that

*   Mediation: $(\Lambda_{c^*}, \phi_{i: c_i = c^*})$ is minimal to within $\epsilon$ subject to ($\forall i$ s.t. $c_i = c^*$: TM($\Lambda_{c_i}, \phi_i$) = $x_i$)
*   Redundancy: For all $i$, $(\Lambda_{c_i}, \phi_i’)$ is minimal to within $\epsilon’$ subject to TM($\Lambda_{c_i}, \phi_i’$) = $x_i$
*   Independence across categories: $(\Lambda, \phi' ')$ is minimal to within $\epsilon' '$ subject to ($\forall i$: TM($\Lambda_{c_i}, \phi_i' '$) = $x_i$))

Note that all of these might be conditional on other background knowledge of the inductors - i.e. the Turing machine TM has access to a database full of all the other stuff the inductors know. However, they do need to condition only on things which they expect the other inductor to also know, since we’ve assumed the two inductors use the same Turing machine.[^4ncmhwg4l1x]

If you’ve been wondering why on Earth we would ever expect to find such simple structures in the complicated real world, conditioning on background knowledge is the main answer. Furthermore, our current best guess is that most of that background knowledge is also itself organized via natural latents, so that the customer and bartender can also coordinate on which knowledge to condition on.

Conclusion & Takeaways
======================

First, let’s recap the core theorem of this post.

Suppose that some string $\Lambda$ satisfies both the following conditions over strings $x_1 … x_n$ for a Turing machine TM:

*   Mediation: there exists $\phi_1, …, \phi_n$ such that $(\Lambda, \phi)$ has minimal length to within $\epsilon$ bits subject to ($\forall i$: TM($\Lambda, \phi_i$) = $x_i$).
*   Redundancy: For all $i$, there exists $\phi_i’$ such that $(\Lambda, \phi_i’)$ has minimal length to within $\epsilon’$ bits subject to TM($\Lambda, \phi_i’$) = $x_i$.

Further, suppose that some string $\Lambda’$ *also* satisfies those conditions over the same strings $x_1 … x_n$ and Turing machine TM. Then:

$O(\epsilon + \epsilon’ +$ log $K(x_1, x_2)) \geq K(\Lambda|\Lambda’)$

$O(\epsilon + \epsilon’ +$ log $K(x_1, x_2)) \geq K(\Lambda’|\Lambda)$

In other words: a short program exists to compute $\Lambda$ from $\Lambda’$, and a short program exists to compute $\Lambda’$ from $\Lambda$.

Conceptually, we imagine two different agents each look for approximately-best compressions in the same form as the mediation and redundancy conditions. One agent finds $\Lambda$, one finds $\Lambda’$. Then the two have found approximately isomorphic compressions.

Crucially, these are approximately isomorphic “parts of” compressions - i.e. they separate out “signal” $\Lambda$ from “noise” $\phi$, and the two agents approximately agree on what the “signal” and “noise” each have to say about the data. So, they’ll approximately agree on what it would mean to sample *new* data points with the same “signal” but different random “noise” - e.g. the new drink-instance which the bartender prepares for the customer.

Conceptually, both the questions we tackle here and the methods used to answer it are similar to our [semantics post](https://www.lesswrong.com/posts/RrQftNoRHd5ya54cb/towards-a-less-bullshit-model-of-semantics), with two big differences. First, we’re now working with minimum description length rather than generic Bayesian probability, which means everything is uncomputable but conceptually simpler. Second, our method here for “multiple drink types” was actually totally different and non-analogous to the [corresponding method](https://www.lesswrong.com/posts/RrQftNoRHd5ya54cb/towards-a-less-bullshit-model-of-semantics#Equivalence_Via_Naturality) in the semantics post, even though the two methods used similar low-level tools (i.e. natural latents).[^g1pmnsbfe] One item for potential future work is to transport the method used in the semantics post over to the minimum description length context, and the method used in this post over to the generic Bayesian context. Another potential item is to unify the two; intuitively they seem closely related.

Our main hope is that other people will be able to pick up these methods and use them to characterize other kinds of concepts which different minds are able to converge upon and communicate about. We’ve only just scratched the surface here.

Appendix: Proof of the Fundamental Theorem
==========================================

We’re going to use essentially the same diagrammatic proof as [Deterministic Natural Latents](https://www.lesswrong.com/posts/fJb8ryrMW5XfJaq7m/approximately-deterministic-natural-latents) (don’t worry, we don’t assume you’ve read that). Of course, now we’re working with Kolmogorov complexity, so we have a new interpretation of each diagram, and we’ll need to prove all the diagrammatic rules we need to use.

Interpretation & Manipulation of Diagrams
-----------------------------------------

Let’s start with an example diagram:

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfjOJbQbN7f2zLRadOfJKfAbm1sk6Qcz9ciG0LPGCZmIjUiQT6s_GDtQ7I-4VVGYTd6F_ekZjN6Bb3ZEqOWJB6rcOKG24pmkOal3aFtgULjxA7nR70aPF_YqOeOwwgPspVWrF_q2Gyfyz19WHbgsvm9wk5S?key=25E-nomFZKUy3JsdoerTtA)

We say that this diagram “holds for” three strings $X$, $Y$, and $Z$ iff

$\epsilon \geq K(X) + K(Y|X) + K(Z|X) - K(X, Y, Z)$

where $\epsilon$ will often be a big-$O$ term.

More generally, a diagram is a directed acyclic graph in which each node $i$ is a string $X_i$, along with an error term $\epsilon$. The diagram holds iff

$\epsilon \geq \sum_i K(X_i|X_{pa(i)}) - K(X)$

where $pa(i)$ denotes the parents of node $i$ in the graph.

Note that the same string can appear more than once! For instance, the diagram

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdq4UBmoInEQ2JLkAspxGIx67QxhX7cDLAgdoXoLR9sYOnAPR8vajb3NzWM5x82oiySQSXLHsPXofDtBl-PT91lM6T7MjC695Nsa9aPYPWz9wmU2_naDvE5GV4apP8XNIHp98iqKCzstrL4IiEUriqDHbof?key=25E-nomFZKUy3JsdoerTtA)

says that $\epsilon \geq K(X) + K(Y|X) + K(Y|X) - K(X, Y, Y)$. Using the [chain rule](https://en.wikipedia.org/wiki/Chain_rule_for_Kolmogorov_complexity), that simplifies to

$O(\text{log} K(X, Y)) + \epsilon \geq K(Y|X)$  
i.e. $Y$ has only logarithmic complexity given $X$ (assuming the log term dominates $\epsilon$). We’ll use diagrams like that one several times below, in order to indicate that one string has quite low complexity given another.

Now for some rules. We’ll need three:

*   The Dangly Bit Lemma
*   Re-Rooting of Markov Chains
*   Marginalization in Markov Chains

### The Dangly Bit Lemma

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcBdB7a2qROGHphqH9gXvpjlUtvHOj36ubO2guMSN7Ic51iqOLzUrVRnDznUdGnTpd__oPU38jpHnBSdgIllYaFpdgli5zIh21sYoBcxRavatDQXc18TppQTGCP2MOn4lszvqoaDRIhWAlP03TKrWoh4IvY?key=25E-nomFZKUy3JsdoerTtA)

If $Y \leftarrow X \rightarrow Y$ holds to within $\epsilon$ bits, and any other diagram $D$ involving $X$ holds to within $\epsilon’$ bits, then we can create a new diagram $D’$ which is identical to $D$ but has another copy of $Y$ (the “dangly bit”) as a child of $X$. The new diagram $D’$ will hold to within $\epsilon + \epsilon’$ bits.

+++ Proof (click to expand):

Assume the diagram $D$ is over $X$ and some other variables $Z$; it asserts that

$\epsilon’ \geq \sum_i K((X, Z)_i | (X, Z)_{pa(i)}) - K(X, Z)$

Since $Y \leftarrow X \rightarrow Y$ holds to within $\epsilon$ bits,

$O($log $K(X, Y) + \epsilon) \geq K(Y|X)$

(as shown in the previous section). Let’s add those two inequalities:

$\epsilon’ + O($log $K(X, Y) + \epsilon) \geq K(Y|X) + \sum_i K((X, Z)_i | (X, Z)_{pa(i)}) - K(X, Z)$

And since $K(X, Z) \leq K(X, Y, Z) + O(1)$, we can replace the $K(X, Z)$ term to get

$\epsilon’ + O($log $K(X, Y) + \epsilon) \geq K(Y|X) + \sum_i K((X, Z)_i | (X, Z)_{pa(i)}) - K(X, Y, Z)$

which is the inequality asserted by the new diagram D’.




+++

### Re-Rooting of Markov Chains

Suppose we have a “Markov chain” diagram $X_1 \leftarrow X_2 \leftarrow … \leftarrow X_k \rightarrow … \rightarrow X_{n-1} \rightarrow X_n$ to within $\epsilon$ bits. That diagram asserts

$\epsilon \geq K(X_k) + \sum_{i<k} K(X_i|X_{i+1}) + \sum_{i>k} K(X_i|X_{i-1}) - K(X)$

Then we can move the root node right one step to form the diagram $X_1 \leftarrow X_2 \leftarrow … \leftarrow X_{k+1} \rightarrow … \rightarrow X_{n-1} \rightarrow X_n$ to within $\epsilon + O($log $K(X_k, X_{k+1}))$ bits. Likewise for moving left one step.

+++ Proof (click to expand):

We’ll do the proof for moving right one step, the proof for moving left one step works the same way.

$\epsilon \geq K(X_k) + \sum_{i<k} K(X_i|X_{i+1}) + \sum_{i>k} K(X_i|X_{i-1}) - K(X)$

$= K(X_k) + K(X_{k+1}|X_k) + \sum_{i<k} K(X_i|X_{i+1}) + \sum_{i>k+1} K(X_i|X_{i-1}) - K(X)$

$\geq K(X_k, X_{k+1}|X_k) - O(1) + \sum_{i<k} K(X_i|X_{i+1}) + \sum_{i>k+1} K(X_i|X_{i-1}) - K(X)$

$\geq K(X_{k+1}) +K(X_k|X_{k+1})  - O(log K(X_k, X_{k+1})) + \sum_{i<k} K(X_i|X_{i+1}) + \sum_{i>k+1} K(X_i|X_{i-1}) - K(X)$

$= K(X_{k+1}) + \sum_{i<k+1} K(X_i|X_{i+1}) + \sum_{i>k+1} K(X_i|X_{i-1}) - K(X) - O(log K(X_k, X_{k+1}))$




+++

By applying this rule repeatedly, we can arbitrarily re-root a Markov chain diagram.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfdpAcn5gLS3CQo3oIr5SuzQB95fGox2LAqrYN75BNCHzcx9ClLCPPIA37JLa35eXAzC2iC8UM3-3HwHfa-zspoiv3zNoNHeJb26SQfN8C9C6HkHJPLlG9Ijn0QGvZTkQR3cNDY5aR5EdAug6jqHMmr7RM?key=25E-nomFZKUy3JsdoerTtA)

### Marginalization in Markov Chains

Suppose the diagram $W \rightarrow X \rightarrow Y \rightarrow Z$ holds to within $\epsilon$ bits. Then $W \rightarrow Y \rightarrow Z$ holds to within $\epsilon + O($log $K(W, X, Y, Z))$ bits.

+++ Proof (click to expand):

$\epsilon \geq K(W) + K(X|W) + K(Y|X) + K(Z|Y) - K(W, X, Y, Z)$

$\geq K(W) + K(X|W) + K(Y|W, X) + K(Z|Y) - K(W, X, Y, Z) - O(1)$

$= K(Z|Y) - K(Z|W, X, Y) - O($log $K(W, X, Y, Z))$

$\geq K(Z|Y) - K(Z|W, Y) - O($log $K(W, X, Y, Z))$

$= K(W) + K(Y|W) + K(Z|Y) - K(W, Y, Z) - O($log $K(W, X, Y, Z))$

This proof also extends straightforwardly to longer Markov chains; that’s a good exercise if you’re looking for one.




+++

When working with a longer chain $X_1 \rightarrow … \rightarrow X_n$, note that reversing the direction of arrows in the Markov chain and further marginalization both also cost no more than $O($log $K(X))$, so we can marginalize out multiple variables and put the root anywhere for the same big-$O$ cost in the bounds.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXe-TbJEQZ6bx6dZ6Ar2qIntEBbm48wv9B-8gV9ZzZdsj57aVWZXeBWJxNPuGRYf_-7V9z-7N0QG-On4q-lI2obGboS8AitfLx78Bchfz4ZAQS4Rq1vke-M3ioXDL4XNoVqf4dwQywD1N6KOKw-Wm8vLRk7B?key=25E-nomFZKUy3JsdoerTtA)

Proof of the Fundamental Theorem
--------------------------------

With all the foundations done, we’re now ready for the main proof. Here’s the full statement again:

We have a set of $n$ data points (binary strings) $\{x_i\}$, and a Turing machine TM. Suppose we find some programs/strings $\Lambda, \{\phi_i\}, \Lambda’, \{\phi_i’\}$ such that:

*   Mediation: len($\Lambda, \phi_1, …, \phi_n$) $\leq \epsilon +$min$_{\Lambda, \phi_1, …, \phi_n}$ len($\Lambda, \phi_1, …, \phi_n$) subject to (TM($\Lambda, \phi_i$) = $x_i$ for all $i$)
*   Redundancy: For all $i$, $(\Lambda’, \phi_i’) \leq \epsilon’ +$ min$_{\Lambda’, \phi_i’}$ len($\Lambda’, \phi_i’$) subject to TM($\Lambda’, \phi_i’$) = $x_i$.

Then: $O(\epsilon + \epsilon’ +$log $K(x)) \geq K(\Lambda’|\Lambda)$.

First, we’ll show that the mediation condition implies

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdeEZXYp84uZg5thlsXpb2zu8aJFfbpK2COUL8zBF9qCB0HVZVzabaSFYv-d4nbNrx-CNOJrU76s-r_q2YDPc3EYtng3tm31Pf0sS0NzXerSTQuehpczGqPLI9qhDpbR58v6G9V3XzCt3delkyKN7pmsDln?key=25E-nomFZKUy3JsdoerTtA)

and the redundancy condition implies

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdsRrHPr1ajiwUzYW2RDNdz2HyifDckJfs501GLSZ0Em9mR5eTWRSdHYKGzyQw_Nx_Z0khNWBouy3aJHCuAnm9DBRBrikEoUp19bM6_T_bve2Tdj3qA23wgosKEfy2bGqoYUlM1KZ602SCD84HXZ6tC9vo?key=25E-nomFZKUy3JsdoerTtA)

Following those two parts of the proof, the rest will proceed graphically.

### Mediation -> Graph

Note that the mediation condition can always be satisfied to within $O(n$ log $n)$[^r5kcoa2ols9] by taking $\Lambda$ to be a shortest program for $x$ plus $O(1)$ code to index into the result at position $\phi_i$, and taking $\phi_i = i$. So: 

1: If $(\Lambda, \phi)$ are to be minimal to within $\epsilon$, they must satisfy len($\Lambda, \phi$) $\leq K(x) + \epsilon + O($log $K(x))$[^6wudf6f8az7]

Furthermore, for $(\Lambda, \phi)$ to be minimal to within $\epsilon$ for *anything*: 

2: $(\Lambda, \phi)$  must themselves be incompressible to within that same $\epsilon$: len($\Lambda, \phi$) $\leq K(\Lambda, \phi) + \epsilon + O($log $K(\Lambda, \phi))$ = $K(x) + \epsilon + O($log $K(x))$. As a corollary, $\Lambda$ and $\phi$ must individually be incompressible to within that same bound or else together they couldn’t be minimal either.

Additionally note that $\phi_i$ (plus some constant-size wrapper code) specifies $x_i$ given $\Lambda$, so:

3: $K(x_i |\Lambda) \leq len(\phi_i) + O($log len($\phi_i$)) = len($\phi_i$) $+ O($log K(X_i | \\Lambda))

Now we put all that together.  (2) $\Lambda$ is incompressible to within $\epsilon + O($log $K(x))$ and (1) $\Lambda$, $\phi$ together are a shortest-to-within $\epsilon + O($log $K(x))$ program for $x$:

$K(\Lambda, x) \geq$ len($\Lambda$) $+ \sum_i$ len($\phi_i$) $- O(\epsilon +$log $K(x))$

and:

$\geq K(\Lambda) + \sum_i K(x_i | \Lambda) - O(\epsilon +$log$K(x))$

since \\Lambda specifies $\Lambda$ and (3) $\phi_i$ specifies $x_i$ given $\Lambda$.

### Redundancy -> Graph

Lemma: suppose $Y$ is a minimal-to-within $\epsilon + O($log $K(x))$ program which outputs $X$. Then by the [chain rule](https://en.wikipedia.org/wiki/Chain_rule_for_Kolmogorov_complexity)

$K(X, Y) = K(X|Y) + K(Y) + O($log $K(X, Y)) \leq 0 + K(X) + \epsilon + O($log $K(X))$

Applying the chain rule in the other order:

$K(X, Y) = K(Y|X) + K(X) + O($log $K(X, Y)) = K(Y|X) + K(X) + O($log $K(X))$

Equating and canceling, we find

$K(Y|X) \leq \epsilon + O($log $K(X))$

Note that $(\Lambda’, \phi_i’)$ together are a minimal-to-within $\epsilon + O($log $K(x))$  program for $x_i$, so by the previous lemma:

$K(\Lambda’ | x_i) \leq K(\Lambda’, \phi_i’ | x_i) + O($log $K(\Lambda’)) \leq \epsilon + O($log $K(x_i))$

Thus:

![](https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/b4472332726db3f91a963071bcfcdb5668da0727f0f67ee4.png)

### The Graphical Part

From here, we just directly carry over the proof from [Deterministic Natural Latents](https://www.lesswrong.com/posts/fJb8ryrMW5XfJaq7m/approximately-deterministic-natural-latents), using the lemmas and bounds proven in this appendix.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXd43x56Qpj-dPeyoqtnqr_DfzrdYb9qJmdUAu2Hy2HOjLGo5v_Gt5ZqmVr3-Np3obZBO2gzL0EwDv0LkmrmMLqTS-39koszlQoIBIZkik2SioByxXcfUScGsAkmCsBgn4FsaD6gqgvEZRlq1X40yz7-OHSc?key=25E-nomFZKUy3JsdoerTtA)

That completes the proof.

[^d6fqlmasjj5]: Note that the quantifiers have importantly different scopes between these two conditions. 

[^t0k8ih410e]: Note that we’re mainly interested in the case where individual datapoints are large/rich. The \(O(n \text{log} n)\) overhead from the indexing is fine, since it doesn’t scale with the complexity of the individual datapoints. 

[^g89ph45edmr]: Read \(K(Y|X)\) in this exampleas the length of the shortest program which, given \(X\) as input, returns the shortest program for computing \(X\) 

[^wlj1v527xs]: Aside: if a string is natural over some strings y_1, …, y_n, then it’s also natural over any subset consisting of two or more of those strings. 

[^e3etgasbafu]: Independent in the minimum description sense, i.e. length of joint shortest description is approximately the sum of lengths of separate shortest descriptions 

[^0ehnie2ufuc]: Reminder again that this is independence in the minimum description length sense, i.e. length of joint shortest description is approximately the sum of lengths of separate shortest descriptions 

[^hxe6qw2qr85]: Note that we haven’t talked about how approximation plays with uniqueness of the partition, if there’s ambiguity about how “approximately unique” different strings are. 

[^138yre2v5jm]: We have established that the uniqueness of natural latents in each subset plays well with approximation. Furthermore, note that the uniqueness proof of a natural latent can use any two data points over which the latent is natural, ignoring all others. So the natural latent string itself is in some sense quite robust to classifying a small number of data points differently, as long as there are plenty of points in each class, so we typically expect a little variation in different agents' partitions to be fine. 

[^4ncmhwg4l1x]: We can allow for different Turing machines easily by incorporating into \(\epsilon\), \(\epsilon’\) the bit-cost to simulate one machine using the other. That’s not a focus in this post, though. 

[^g1pmnsbfe]: Here we search for a natural latent (in the compression sense) across subsets of data points. In the semantics post, we looked for natural latents (in the bayesian sense) across features of individual data points. 

[^r5kcoa2ols9]: Note that this has \(O(1)\) dependence on \(K(x)\). 

[^6wudf6f8az7]: The \(O(\)log \(K(x))\) term is to allow for the possibility that the lengths of the strings need to be passed explicitly. This is a whole thing when dealing with K-complexity. Basically we need to include an \(O(\)log \(K(x))\) error term in everything all the time to allow for passing string-lengths. If you really want all the details on that, go read the K-complexity book.