Andrei Romashchenko

Alexander Shen

Topological arguments for Kolmogorov complexity

We present several applications of simple topological arguments (such as non-contractibility of a sphere and similar results) to Kolmogorov complexity. It turns out that discrete versions of these results can be used to prove the existence of strings with prescribed complexity with O(1)-precision (instead of usual O(log n)-precision).

In particular, we improve an earlier result of M. Vyugin and show that for every n and for every string x of complexity at least n + O(log n) there exists a string y such that both C(x | y) and C(y | x) are equal to n + O(1). We also show that for a given tuple of strings x i (assuming they are almost independent) there exists another string y such that the condition y makes the complexities of all x i twice smaller with O(1)-precision.

.

Introduction

In this paper we discuss several applications of topological arguments in algorithmic information theory. The main notion of algorithmic information theory, the Kolmogorov (or algorithmic) complexity has a very simple definition 1 , but even some basic questions about it turn out to be very difficult. For example, we still do not know which linear inequalities are true for the Kolmogorov complexities of tuples of strings, though we know that they are the same as the inequalities for Shannon entropies and also for the sizes of subgroups of a finite group and their intersections (see [START_REF] Vereshchagin | Kolmogorov complexity and algorithmic randomness[END_REF]Chapter 10]).

Things could become even more complicated when we switch from universal statements (e.g., inequalities) to universal-existential statements. An example of such a statement: for every integer n and for every x of complexity at least 2n + O(1) there exists a string y such that both C(x | y) and C(y | x) are equal to n with O(1)-precision. This result was proved by M. Vyugin [START_REF] Vyugin | Information distances and conditional complexities[END_REF] using game technique developed by An. Muchnik (see [START_REF] Muchnik | Game interpretation of Kolmogorov complexity[END_REF][START_REF] Shen | Game arguments in computability theory and algorithmic information theory[END_REF] for some other examples of game arguments). Several other techniques to prove the existence of strings with given complexity properties were developed: one may use probabilistic method, and also some combinatorial techniques, in particular, on-line matching and expander-like constructions, see [START_REF] Vereshchagin | Kolmogorov complexity and algorithmic randomness[END_REF]Chapters 11,12,14] for examples. Still some basic questions remain open. For example, we do not know whether for every strings a 1 , . . . , a n there exists some string b that, being used as a condition, makes the complexity of each a i twice smaller, i.e., C(a i | b) = 0.5 C(a i ) + O(1) for every i.

In this paper we suggest one more technique which is quite different from the tools used before. It is applicable (as it seems) only in some rather special situations; however, when applicable, it provides results with maximal possible O(1)-precision. This approach is based on simple topological arguments. To explain what is meant by "topological arguments", let us start with a very simple example. Let us consider a string x that has Kolmogorov complexity n (we consider plain complexity C(x), but this does not matter for now). We want to prove that there exists a string y such that C(x | y) ≈ n/2. Let us start with y = x, when C(x | y) ≈ 0. Then, we delete bits of the string y (say, at the end) one by one until we get y = Λ (the empty string) and C(x | y) ≈ n. During the process, each time when one last bit of y is deleted, the conditional complexity C(x | y) changes by at most O(1), so it cannot cross the threshold n/2 without visiting O(1)-neighborhood of n/2.

Topological arguments of this type can be used in two (and more) dimensions, though they become less trivial. In what follows we provide several examples of this type.

Vyugin's result and its extensions

As we have said, M. Vyugin [START_REF] Vyugin | Information distances and conditional complexities[END_REF] showed that for every n and for every string x with C(x) ≥ 2n + O(1) there exists a string y such that both conditional complexities C(x | y) and C(y | x) are equal to n + O(1). One may say informally that y is "n bits apart from x in both directions".

This result was proved in [START_REF] Vyugin | Information distances and conditional complexities[END_REF] using a rather ingenious game argument. As we shall see in this paper, the condition C(x) ≥ 2n is much stronger than necessary; it is enough to assume only that C(x) ≥ n + c log n for some c. We present a proof of this theorem based on a simple topological argument. This topological proof can be applied unless C(x) is very large (Vyugin's game argument still seems to be necessary if C(x) is really big compared to n.)

Similar reasoning also allows us to construct y such that both complexities C(x | y) and C(y | x) have prescribed values with O(1)-precision, even if those two values are different. (This question was discussed in Vyugin's paper [START_REF] Vyugin | Information distances and conditional complexities[END_REF], but no positive result of this type was given there except for the already mentioned case m = n + O(1).) Again we need some restrictions that guarantee that prescribed values are not unreasonable large or small. Here is the exact statement.

Theorem 1. Let P be some polynomial. There exists a constant c such that for every string x and for all integers m, n such that Remark: Let us comment on the assumptions that appear in this statement. We want to obtain | C(x | y) -n| ≤ c. Since C(x | y) does not exceed C(x), we need to assume that C(x) is at least n.

• n + c log n ≤ C(x) ≤ P(n), • c log n ≤ m ≤ P(n),
The assumption in the theorem is a bit stronger: we assume a "safety margin" of logarithmic size and require C(x) ≥ n + c log n. We also require m and C(x) to be polynomially bounded.

Proof. Let p be the shortest description of x; it is a string of length C(x). Consider also an incompressible string z of length slightly greater than m, e.g., let |z| and C(z) be equal to 2m+O [START_REF] Bauwens | Short Lists with Short Programs in Short Time[END_REF]. Moreover, we take z independent from p, so C(z | p) is also 2m+O [START_REF] Bauwens | Short Lists with Short Programs in Short Time[END_REF]. (A randomly chosen z has these properties with probability close to 1, i.e., most strings of that length have the required properties.)

The string y is then constructed as (the encoding of) a pair (p , z ) where p and z are prefixes of p and z respectively; it remains to decide how long p and z should be. To show this, we note that the mapping is "continuous" in the sense that neighbor points in the domain (on the left, Fig. 1) are mapped into points at distance O(1) (on the right, Fig. 1). 2Indeed, C(u | v) changes only by O(1) if u or v is changed by adding or deleting the last bit. Consider a path A-B-C-D-A that goes counterclockwise around the rectangle on the left; as we shall see, the image path on the right will go clockwise (with logarithmic precision) around the rectangle and makes one turn around the point (n, m). Then we can continuously transform the path on the left into one point (since the rectangle is simply connected); if its image on the right never comes close to (n, m), we get a contradiction: the number of turns around (n, m) cannot change if the image does not come close to that point. This type of arguments is discussed later in Section 3, but for now an informal explanation could be sufficient. Imagine a fence on the left picture whose posts are the integer points on the path A-B-C-D-A, and the "image fence" on the right whose posts are images of the posts on the left. Both fences are polygonal closed curves whose vertices are posts; the distance between neighbor posts is 1 on the left and O(1) on the right. When we move one post on the left to the neighbour grid point, the fence on the left changes slightly, and the image fence also changes slightly (the image of the moving post changes its position by O(1)). In several steps we can shrink the fence on the left completely (moving all post to the same point); then the image fence also shrinks. But it is not possible if the posts on the right never come close to some point (n, m) that initially was inside the fence.

It remains to look closely at the path around the rectangle and its image; we need to check that indeed it makes a turn around (n, m). Note that our assumptions guarantee that log

C(x) = Θ(log n), so we write just O(log) having in mind O(log n) or O(log C(x)); note also that O(log m) ≤ O(log). • Point A: here y = (Λ, Λ), so C(y | x) = O(1) and C(x | y) = C(x) + O(1). Thus, the image is A = (C(x), 0) with O(1)-precision. • Edge A-B: here y = (p , Λ). Then C(y | x) = O(log) since C(p | x) = O(log C(x)) [the conditional complexity of a shortest description of x given x is O(log C(x))],
and the length of p can be described by O(log C(x)) bits, too. And C(x | y) is somewhere between 0 and • Point C: This analysis shows that the path on the right follows the trajectory A -B -C -D -A with O(log)-precision and therefore turns around the point (n, m) if this point is O(log)-far from the boundary of the rectangle, and this is exactly what our assumption guarantees. Theorem 1 is proven.

C(x) + O(1). So the image of A-B is in the O(log)-neighborhood of A -B . • Point B: here y = (p, Λ), so C(y | x) = O(log C(x)) and C(x | y) = O(1); the image is B = (0, 0) with O(log)-precision; the edge A-B is
here y = (p, z), so C(x | y) = O(1) and C(y | x) = O(log)+C(z | x) = 2m+O(log). So the image is C = (0, 2m) with O(log)-precision. • Edge C-D: here y = (p , z), so C(y | x) = 2m + O(log) and C(x | y) is between 0 and C(x) + O(log). • Point D: here y = (Λ, z), so C(y | x) = C(z | x)+O(1) = 2m+O(1) and C(x | y) = C(x | z) = C(x) + O(log)

Topological digression

Let us look more closely at the topological arguments we used. First let us recall the following basic topological result: the circle is not contractible. This means that the identity mapping id : S 1 → S 1 of a circle cannot be extended to a continuous mapping of a disc D 2 → S 1 . Another version of essentially the same result: the identity mapping of a circle S 1 is not homotopic (cannot be continuously transformed into) a constant mapping.

How these results are proved usually? The most intuitive argument uses the winding number, an integer representing the total number of times that curve travels counterclockwise around the point. For an identity mapping the winding number is 1, and for the constant mapping it is zero; therefore, these two curves are not homotopic (the continuous change in the curve should change the winding number continuously; since it is an integer, it does not change).

We can consider any point z inside the circle and consider the winding number with respect to z. The same argument then can be applied not only to mappings D 2 → S 1 but also to mappings D 2 → D 2 that do not cover z, since the winding number is well defined for those curves. In this way we get the following statement: every mapping F : D 2 → D 2 that extends the identity mapping of the circle, covers the entire disk. In fact, we do not need that F(z) is exactly z for z ∈ S 1 ; if F(z) is ε-close to z for z ∈ S 1 , then (for the same reasons) the image of F covers the entire D 2 except (maybe) the ε-zone near the boundary.

In Section 2 we used the discrete version of this argument (with a rectangle grid instead of a circle). One can define a winding number of a discrete path (sequence of points, or vertices of a polygonal line) assuming that vertices do not come close to the center point; this number is an integer and does not change if the vertices of the path are moved slightly (the change of the position of each point should be a small fraction of its distance to the center point).

More generally, many topological existence theorems have natural finite versions. For example, the famous Brouwer fixed-point theorem says that every continuous mapping F : I n → I n of a n-dimensional cube into itself has a fixed point. (One can speak about a disk or a simplex instead of a cube; all these bodies are homeomorphic.) The finite version replaces the cube by a rectangular grid G n = {0, 1, . . . , N} n ; if a mapping F : G n → G n is c-Lipschitz (increases distances at most c times), then there exists a point x ∈ G n such that F(x) is O(c)-close to x.

Note that one can reduce this discrete version of the fixed-point theorem to the standard continuous version by extending the mapping from the grid to a continuous mapping of the entire cube in R n to R n ; it can be done in a piecewise-affine way, so that the image of each unit cube belongs to the convex hull of the images of its vertices. Then we take a fixed point of the continuous mapping and use c-Lipschitz property to show that neighbor grid point changes its position only by O(1).

However, this reduction (from a discrete version of the fixed-point theorem to a continuous one) is a bit silly since the standard (elementary) proof of Brouwer's fixed point theorem reduces it to the discrete version, and the discrete statement is proved using Sperner's lemma. Anyway, we will use in the sequel several discrete version of elementary topological results and hope that the reader can easily reconstruct their proofs. Proof. First of all, note that this statement is easy to prove if instead of O(1)-precision we are satisfied with O(log C(a) + log C(b) + I(a : b))-precision. Indeed, consider the shortest descriptions p and q for a and b and then let y = (p , q ) where p is p without α last bits, q is q without β last bits. The strings p and q are incompressible, so C(p | p ) = α and C(q | q ) = β with O(log C(a)) and O(log C(b)) precision (respectively). Note also that the information distance between a and p is O(log C(a)), the information distance between b and q is O(log C(b)), so C(a | p ) and C(b | q ) are equal to α an β with the same precision. What happens if we add q (respectively p ) to the condition and consider C(a | (p , q )) and C(b | (p , q ))? Since q has logarithmic complexity given q and therefore logarithmic complexity given b, adding q to the condition changes the complexity of a at most by O(log C(b) + I(a : b)); similar statement is true for p , so we get the desired result.

Decreasing complexity by adding a condition

To get O(1)-precision, we need to combine the simple construction above with a topological argument similar to the proof of Theorem 1. Consider the shortest descriptions p and q for a and b. Then |p| = C(a) and |q| = C(b). For every pair (u, v) of integers such that 0 ≤ u ≤ |p| and 0 ≤ v ≤ |q| define y(u, v) as follows: y(u, v) = (p without u last bits, q without v last bits). In other terms, we consider the mapping Remark: This argument can be generalized easily to three (or more) dimensions. For example, let us consider three strings a, b, c that are almost independent. In this case we get a mapping of a three-dimensional box to itself which is "continuous" and is close to identity. Then a topological argument (based on the fact that identity mapping of the two-dimensional sphere S 2 is not homotopic to the constant mapping) shows that the image of this mapping covers (with O(1)-precision) the interior of the box.

(u, v) → (C(a | y(u, v)), C(b | y(u, v)).

It is defined on the rectangle

Combination with Muchnik's technique

For the case when a and b are dependent, the result of Theorem 2 looks rather weak. We can extent the area of pairs (α, β ) that can be covered, if we combine the topological technique with an argument based on Muchnik's result on conditional descriptions [START_REF] Muchnik | Conditional complexity and codes[END_REF]. Let us recall first Muchnik's result.

Proposition 3 (Muchnik). (a) Let x and y be arbitrary strings of length at most n. Then there exists a string p of length C(x | y) such that

• C(p | x) = O(log n) and • C(x | p, y) = O(log n).
(b) Consider a string x and a family of strings y 1 , . . . , y m ; assume that the number of strings and their lengths are bounded by some n. Then there exists a string p such that

• C(p | x) = O(log n) and
• for every j = 1, 2, . . . , m the complexity C(x | y j , p j ) is O(log n), where p j is a prefix of p having length C(x | y j ).

As usual, the constants in O(log n)-notation do not depend on n.

Remark: We cannot get rid of logarithmic terms in this theorem, i.e., we cannot obtain [START_REF] Bauwens | Short Lists with Short Programs in Short Time[END_REF]. However, in what follows we show that a combination of Muchnik's theorem with a topological argument can result in a statement with O(1)-precision.

C(p | x) = O(1) instead of C(p | x) = O(log n), see
The first part of the proposition says that the "information difference" between x and y ("information that is present in x but is missing in y") can be "materialized" as some string p. The second part of the proposition says that for several strings y 1 , . . . , y m one can choose the representatives of the information differences x \ y i to be prefixes of each other.

The string p provided by the first part of this Proposition is incompressible (with logarithmic precision). Since p and y together are enough to reconstruct the pair (x, y) and the sum of complexities of p and y is O(log n)-close to the complexity of this pair (due to Kolmogorov-Levin theorem about the complexity of a pair), the strings p and y are independent with logarithmic precision, i.e., I(p : y) = O(log n). In the second part the prefixes of p (that are actually used) are also incompressible, and y j has only O(log n) mutual information with the prefix of p that has length C(x | y j ). Now we use this result as a tool to improve Theorem 2 and get the following Theorem 4. For some constant c the following statement holds: for every two strings a, b of complexity at most n and for every integers α, β such that

• α ≤ C(a) -c log n, • β ≤ C(b) -c log n, • -C(a | b) + c log n ≤ β -α ≤ C(b | a) -c log n, there exists a string y such that | C(a | y) -α| ≤ c and | C(b | y) -β | ≤ c.
Remark. The conditions for α and β say that the point (α, β ) is inside the hexagon shown by Figure 2 below.

Proof. In the argument above we considered the shortest descriptions p and q for a and b, i.e., p and q were incompressible strings that contain the same information as a and b respectively. Now we need to choose these two strings p and q in a special way: their prefixes should be independent as much as possible and become dependent only if the total length of the two prefixes exceeds C(a, b). This can be done using Muchnik's result, and then we can use p and q in the same way as before.

We start by saying precisely what are the required properties of p and q.

Lemma 1. For all strings a and b of complexity at most n there exist strings p and q such that

• |p| = C(a); • |q| = C(b);
• the information distance between p and a is O(log n);

• the information distance between q and b is O(log n);

• if l ≤ |p|, m ≤ |q| and l + m = C(a, b), then I(p l : q m ) = O(log n) and the information distance between (a, b) and

(p l , q m ) is O(log n).
where p l , q m denote prefixes of strings p and q of length l and m respectively, and information distance between u and v is defined as

C(u | v) + C(v | u).
One can say that p and q present the same information as a and b in such a way that prefixes of p and prefixes of q are independent as much as possible -up to the point where they become too long to be independent, since the total amount of information is only C(a, b). In particular, if l = C(a | b), then the last requirement says that p l is independent with b (have logarithmic mutual information); all shorter prefixes of p are independent with b, too. One could note also that the information distance requirement is the consequence of independence: p l and q m are simple given (a, b), and if l + m = C(a, b), they together contains as much information as the pair (a, b) itself.

A technical remark: we use the exact equalities for lengths, not O(log n)-precision ones, as for the complexities. This does not really matter, since adding or deleting O(log n) bits changes all the complexities and information quantities by O(log n) only.

Proof of the lemma: Though a and b appear in the same way, our proof is non-symmetric: first we find one of the strings p and q (say, p) and then construct q using p.

First, we apply the Proposition 3 to get a string p that starts with the "difference" a \ b and then presents the rest of a . This means that

• |p| = C(a); • C(p | a) = O(log n); • C(a | p) = O(log n); • C(a | b, p ) = O(log n), where p is the prefix of p of length C(a | b).
For that we can apply the part (b) of this proposition to two strings: b and the empty string. Another option is to apply the part (a) to get the prefix of p and then add the conditional description of a given this prefix.

As we have mentioned, the strings p and b have almost no mutual information, i.e., their mutual information is O(log n). The same is therefore true for all shorter prefixes of p: they also have almost no mutual information with b.

Then, we apply Proposition 3, part (b), to construct a description of b using all prefixes of p as y 1 , . . . , y m . We get a string q such that

• |q| = C(b); • C(q | b) = O(log n); • C(b | q) = O(log n); • C(b | p l , q m ) = O(log n) for all l ≤ |p| and m ≤ |q| such that l + m = C(a, b).
Here p l and q m are prefixes of p and q of lengths l and m respectively; to see why the last requirement is provided by Proposition

C(b | p l ) ≤ C(b | p) + (|p| -l) = [C(b | p) + |p|] -l = C(a, b) -l = m
(all the equalities and inequalities are understood with O(log n) precision). It is now easy to see that the mutual information I(p l : q m ) for all l and m such that l + m = C(a, b) is O(log n), otherwise p l and q m would contain not enough information to reconstruct a and b. Now we are ready to finish the proof of Theorem 4, combining the argument used for Theorem 2 and Lemma 1. Let p and q be the strings provided by this Lemma. For every pair (l, m) of integers such that 0 ≤ l ≤ |p| and 0 ≤ m ≤ |q| we define y(l, m) = (first l bits of p, first m bits of q). This mapping is "continuous" (neighbor points are mapped into points at distance O(1)). Consider the path U-V -W -X 1 -X 2 -Y -Z-U that goes counterclockwise around the pentagon on Fig. 2 (left). We will show that the image path will (with logarithmic precision) go clockwise around the hexagon U -V -W -X -Y -Z -U on Fig. 2 Remark: Instead of the path U-W -X 1 -X 2 -Y -U we could take another path U-W -X 3 -Y -U. The shortcut X 1 -X 2 is equivalent to the longer path X 1 -X 3 -X 2 since all points of the triangle X 1 X 2 X 3 are mapped into O(log n)-neighborhood of X (if l + m ≥ C(a, b), then y(l, m) contains enough information to reconstruct both a and b).

From Theorem 4 it follows in particular that if C(a | b) and C(b | a) are not logarithmically negligible, one can cut by factor 2 the complexities of a and b by adding a condition. The problem for the case when C(a | b) and C(b | a) are both small is that the hexagon degenerates into a line, and we cannot apply our technique. In this case it is easy to cut the complexities by factor 2 with logarithmic precision, just by doing this for one string and noting that the other one is close to the first one, but we do not know whether the O(1)-result is true.

The 3-dimensional case

We have already briefly mentioned a 3-dimensional version of Theorem 2 at the end of Section 4. This result also can be improved using Muchnik's technique. In this section we explain this argument in some detail. Let us mention that Theorem 5 below looks not very impressive; we believe that a somewhat stronger version of this theorem can be proven with a similar technique (but now we cannot even formulate an exact statement as a conjecture).

Theorem 5. For some constant c the following statement holds: for every three strings x, y, z of length at most n and for every integers α, β , γ such that

  there exists a string y such that | C(x | y) -n| ≤ c and | C(y | x) -m| ≤ c.

  In other words, we have two parameters, |p | and |z |, and the space of the parameters is a rectangle of width C(x) and height 2m. Each point (|p |, |z |) in this rectangle determines y = (p , z ). So we can map each point (|p |, |z |) to the pair of integers (C(x | y), C(y | x)).We need to show that some point is mapped to a point that is O(1)-close to (n, m).

Figure 1 :

 1 Figure 1: Each pair in the left rectangle determines y = (p , z ) and is mapped into a pair C(x | y), C(y | x) in the right one.

  mapped into a path along A B going from A to B with O(log)-precision. • Edge B-C: here y = (p, z ), so C(y | x) is somewhere between 0 and 2m + O(log) [recall that the length of z is between 0 and 2m and can be described by O(log m) = O(log) bits; C(p | x) is also O(log)]. On the other hand, C(x | y) = O(1), since p determines x.

  since x and z have only logarithmic mutual information. So the image of D is D = (C(x), 2m) with O(log)-precision. • Edge D-A: here y = (Λ, z ), so C(y | x) is between 0 and 2m + O(log), and C(x | y) is C(x) + O(log) (note that z can have only O(log) bits of additional information compared to z).

Theorem 2 .

 2 Let a and b be two strings. They have some complexities C(a) and C(b). If a third string y is given, we can consider the conditional complexities C(a | y) and C(b | y) which are (in general) smaller that C(a) and C(b). Now the question: can we describe the pairs (C(a | y), C(b | y)) that can be obtained by choosing an appropriate value of y? We answer this question for the case when a and b have negligible mutual information. In this case the answer is simple: we can get an arbitrary pair (α, β ) such that 0 ≤ α ≤ C(a) and 0 ≤ β ≤ C(b) and α, β are not too close to the endpoints of the corresponding intervals (the distance is big compared to the logarithms of complexities and to the mutual information). For some constant c the following statement holds: for every two strings a, b and for every integers α, β such that • α, β ≥ c(log C(a) + log C(b) + I(a : b)); • α ≤ C(a)c(log C(a) + log C(b) + I(a : b)); • β ≤ C(b)c(log C(a) + log C(b) + I(a : b)), there exists a string y such that | C(a | y) -α| ≤ c and | C(b | y)β | ≤ c.

  As we have discussed, C(a | y(u, v)) and C(b | y(u, v)) are close to u and v respectively; the distance is O(log C(a) + log C(b) + I(a : b)).

  [0, C(x)] × [0, C(y)] and is close to the identity mapping; for each point (u, v) the distance between this point and its image is at most O(log C(a) + log C(b) + I(a : b)). This mapping is also continuous in the sense explained above. Now the topological argument (similar to the one used in Section 2) can be used to show that the image O(1)covers the rectangle except for O(log C(a) + log C(b) + I(a : b))-neighborhood of its boundary. Indeed, the image of the boundary of the rectangle makes a turn around every point inside the rectangle (and not too close to the boundary), and therefore all these points are O(1)-close to the image of this mapping.

  3, we note that C(b | p l ) does not exceed m = C(a, b)-l, because C(b | p) is equal to C(b | a) and only the missing bits of p should be reconstructed:

Figure 2 :

 2 Figure 2: Each pair of integers on the left determines y = (a l , b m ), which is mapped to a pair (C(a | y), C(b | y)) on the right.

  (right). This path makes a turn around the point (α, β ). Hence, point (α, β ) (more precisely, some point in O(1)-neighborhood of (α, β )) has a preimage (l, m) in the rectangle [0, C(a)] × [0, C(b)]. It remains to look closely at the path around the pentagon and its image. • m = 0 and l = 0 . . . C(a | b): the image goes along U -V with O(log n)-precision (recall that prefixes of p up to length C(a | b) are independent with b with the same precision; all the statements in this argument are understood in the same way); • m = 0 and l = C(a | b) . . . C(a): the image goes along V -W with O(log n)-precision; now the increase in p l means the same decrease in C(b| p l ). Indeed, for m = C(a, b)l we have C(b | p l ) = C(b, p l | p l ) = C(a, b | p l ) = |q m | = m.Indeed, since l ≥ C(a | b), then p l and b together are enough to reconstruct a, so the second equality is true. The third one holds because p l and q m are independent and (a, b) is informationally close to (p l , q m ). • l = C(a) and m = 0 . . . C(b | a): the image goes along W -X with O(log n)-precision. Indeed, y(l, m) now has full information about a; to compute C(b | y(l, m)) we note that y(k, l) is close to (a, q m ) and C(b | a, q m ) = C(a, b | a, q m ) = C(a, b) -C(a, q m ); recall that q m is simple given b and independent with a. • l = C(a)λ and m = C(b | a) + λ for λ = 0 . . . I(a : b): the image remains in O(log n)neighborhood of X . Indeed, we use prefixes p l and q m with l + m = C(a, b), and these prefixes are enough to reconstruct the pair (a, b). Note also that C(a) + C(b | a) and C(b) + C(a | b) are both equal to C(a, b), so the slope of the line is -1. The rest of the path is symmetric: • m = C(b) and l = C(a | b) . . . 0: the image goes along X -Y with O(log n)-precision; • l = 0 and m = C(b) . . . C(b | a): the image goes along Y -Z with O(log n)-precision; • l = 0 and m = C(b | a) . . . 0: the image goes along Z -U with O(log n)-precision; Thus, the path on in the image follows the trajectory U -V -W -X -Y -Z -U with O(log n)precision. Therefore it turns around the point (α, β ) if this point is O(log n)-far from the boundary of the hexagon, and this is exactly what our assumption guarantees.

•

  I(x : y, z) + c log n ≤ α ≤ C(x)c log n, • I(y : x, z) + c log n ≤ β ≤ C(y)c log n, • I(z : x, y) + c log n ≤ γ ≤ C(z)c log n,there exists a string s such that | C(x | s) -α| ≤ c, | C(y | s)β | ≤ c, and | C(z | s) -γ| ≤ c.

A better name would be Lipschitz continuity: if the distance between the images of neighbor grid points is bounded by c, then the distance between the images of arbitrary two points is at most c times bigger than the distance between the points itself (the distance is measured in l 1 -sense)

Acknowledgements. The authors are grateful to Laurent Bienvenu who suggested to write down this simple argument, Tarik Kaced, and all the colleagues in Escape/NAFIT/Kolmogorov seminar team. We thank the (anonymous) referee for a very detailed review that pointed out many inaccuracies and suggested several improvements.

Both authors work at the LIRMMSupported in part by RFBR 14-01-93107 grant. 1

Remark: The difference between Theorem 5 and the mentioned Remark at the end of Section 4 can be described as follows. In Section 4 we assumed that three strings x, y, z are almost independent: if all the dependencies are bounded by some number d, then the result can be obtained for points that are O(d)-inside the box of size C(x) × C(y) × C(z). Now we look at the situation more closely and note that the dependence between x, y, z do not make the general statement completely false but only shifts the lower bounds for α, β , γ. We prove this statement using Muchnik's technique.

Proof. First, we apply Muchnik's theorem on conditional descriptions and then improve the precision using a topological argument. Proposition 3 provides a string x of size and complexity C(x | y, z) + O(log n) that is simple given x, i.e., C(x | x) = O(log n), and with the pair (y, z), i.e., I(x : y, z) = O(log n). This x is a "difference" x \ (y, z). In a similar way we construct strings y = y \ (x, z) and z = z \ (x, y). It is easy to see that the triple x , y , z is independent (the complexity of the triple is equal to the sum of complexities) and the same is true for all prefixes (simple algorithmic transformations, like taking a prefix, can only decrease mutual information). Now for each triple (k, l, m) with

we consider the prefixes x k , y l , z m of strings x, y, and z having lengths k, l, and m respectively, the triple of strings

and the triple of numbers

The construction of x , y and z guarantees that F(k, l, m) is O(log n)-close to (k, l, m) for all triples (k, l, m) from the domain of F (described above). Let us check this property. The situation is symmetric, so we consider x and have to show that

Intuitively it looks plausible, since x k contains k bits of information from x while y l and z m are prefixes of strings y and z that are independent with x. The formal argument goes as follows. Using x k as a condition, we decrease the complexity of x by k (since x k is simple given x and is incompressible). Adding y l to the condition, we do not change the complexity, since y is independent with x (and therefore with x k , since x k is simple given x). And adding a condition that is independent with all other strings, we do not change the complexities. Finally, we have to use this observation once more: we add condition z m that is independent with the pair (x, y) and therefore also with x k and y l .

Thus, the mapping (k, l, m) → F(k, l, m) is defined on the parallelepiped