Advances in Mathematical Physics

Advances in Mathematical Physics / 2016 / Article

Research Article | Open Access

Volume 2016 |Article ID 5030593 |

Joost J. Joosten, Fernando Soler-Toscano, Hector Zenil, "Fractal Dimension versus Process Complexity", Advances in Mathematical Physics, vol. 2016, Article ID 5030593, 21 pages, 2016.

Fractal Dimension versus Process Complexity

Academic Editor: Joao Florindo
Received01 May 2016
Accepted29 Jun 2016
Published07 Sep 2016


We look at small Turing machines (TMs) that work with just two colors (alphabet symbols) and either two or three states. For any particular such machine and any particular input , we consider what we call the space-time diagram which is basically the collection of consecutive tape configurations of the computation . In our setting, it makes sense to define a fractal dimension for a Turing machine as the limiting fractal dimension for the corresponding space-time diagrams. It turns out that there is a very strong relation between the fractal dimension of a Turing machine of the above-specified type and its runtime complexity. In particular, a TM with three states and two colors runs in at most linear time, if and only if its dimension is 2, and its dimension is 1, if and only if it runs in superpolynomial time and it uses polynomial space. If a TM runs in time , we have empirically verified that the corresponding dimension is , a result that we can only partially prove. We find the results presented here remarkable because they relate two completely different complexity measures: the geometrical fractal dimension on one side versus the time complexity of a computation on the other side.

1. Part I: Theoretical Setting

In the first part of the paper, we will define the basic notions we work with. In particular, we will fix on a computational model: small Turing machines with a one-way infinite tape. For these machines, we will define the so-called space-time diagrams which are a representation of the memory state throughout time. For these diagrams, we will define a notion of fractal dimension. Next, some theoretical results are proven about this dimension.

1.1. Complexity Measures

Complexity measures are designed to capture complex behavior and quantify how complex, according to that measure, that particular behavior is. It can be expected that different complexity measures from possibly entirely different fields are related to each other in a nontrivial fashion. This paper explores the relation between two rather different but widely studied concepts and measures of complexity. On the one hand, there is a geometrical framework in which the complexity of spatiotemporal objects is measured by their fractal dimension. On the other hand, there is the standard framework of computational (resources) complexity where the complexity of algorithms is measured by the amount of time and memory they take to be executed.

The relation we have between both frameworks is as follows. We start in the framework of computations and algorithms and for simplicity assume that they can be modeled as using discrete time steps. Now, suppose we have some computer that performs a certain task on input . We can assign a spatiotemporal object to the computation corresponding to as follows.

We look at the spatial representation of the memory when starts on input . Next we look at : the spatial representation of the memory after one step in the computation and so forth for . Then, we “glue” these spatial objects together into one object by putting each output in time next to the other: . Each can be seen as a slice of of the memory at one particular time in the computation. This is why we call the space-time diagram of . It is of these spatiotemporal objects and in particular the limit of going to infinity that we can sometimes compute or estimate the fractal dimension that we shall denote by .

One can set this up in such a way that becomes a well defined quantity. Thus, we have a translation from the computational framework to the geometrical framework. Next, one can then investigate the relation between these two frameworks and, in particular, whether complex algorithms (in terms of time and space complexity) get translated to complex (in the sense of fractal dimension) space-time diagrams.

It is this main question that is being investigated in this paper. The computational model that we choose is that of Turing machines. In particular, we look at small one-way infinite Turing machines (TMs) with just two or three states and a binary tape alphabet.

For these particular machines, we define a notion of dimension along the lines sketched above. In exhaustive computer experiments, we compute the dimensions of all machines with at most three states. Among the various relations that we uncover is the notion that such a TM runs in at most linear time if the corresponding dimension is 2. Likewise, if a TM (in general) runs in superpolynomial time and uses polynomial space, we see that the corresponding dimension is 1.

Admittedly, the way in which fractal geometry measures complexity is not entirely clear and one could even sustain the view that fractal geometry entirely measures something else. Nonetheless, dimension is clearly related to degrees of freedom and as such related to an amount of information storage.

In [1], space-time diagrams of Turing machines and one-dimensional cellular automata were investigated in the context of algorithmic information theory. Notably, an incompressibility test on the space-time diagrams led to a classification of the behavior of CAs and TMs thereby identifying nontrivial behavior [2]. The same type of space-time diagrams was also investigated in connection to two other seminal measures of complexity [35] connected to Kolmogorov complexity, namely, Solomonoff’s algorithmic probability [2, 6] and Bennett’s logical depth [7, 8]. Interesting connections between fractal dimension and spatiotemporal parameters have also been explored in the past [911], delivering a range of applications in landscape analysis and even medicine in the study of time series.

The results presented in this paper were found by computer experiments and proven in part. To the best of our knowledge, it is the first time that a relation is studied between computational complexity and fractal geometry, of a nature as presented here.

Outline. The current paper is naturally divided into three parts. In the first part (Sections 1.21.4), we define the ideas and concepts and prove various theoretical results. In the second part, Sections 2.1-2.2, we describe our experiment and its results to investigate those cases where none of our theoretical results would apply. Finally, in the third part, we present a literature study where we mention various results that link fractal dimension to other complexity notions.

More in detail, in Section 1.2, we describe the kind of TMs we will work with. This paper can be seen as part of a larger project where the authors mine and study the space of small TMs. As such, various previous results and data sets could be reused in this paper and in Section 1.2 we give an adequate description of these used data sets and results.

In Section 1.3, we revisit the box-counting dimension and define a suitable similar notion of fractal dimension for TMs . We prove that in case runs in at most linear time in the size of the input. Next, in Section 1.4, we prove an upper and a lower bound for the dimension of Turing machines. The Upper Bound Conjecture is formulated to the effect that the proven upper bound is actually always attained. For special cases, this can be proved. Moreover, under some additional assumptions, this can also be proven in general. In our experiment, we test whether in our test space the sufficient additional assumptions were also necessary ones and they turn out to be so.

Section 2.1 describes how we performed the experiment, what difficulties we encountered, and how they were overcome, and also some preliminary findings are given. The main findings are presented in Section 2.2.

We conclude the paper with Section 3.1 where we present various results from the literature that link different notions of complexity to put our results within this panorama.

1.2. The Space of Small Turing Machines

As mentioned before, this paper forms part of a larger project where the authors exhaustively mine and investigate a set of small Turing machines. In this section, we will briefly describe the raw data that was used for the experiments in this paper and refer for details to the relevant sources.

1.2.1. The Model

A TM can be conceived as both a computational device and a dynamical system. In our studies, a TM is represented by a head moving over a tape consisting of discrete tape cells where the tape extends infinitely in one direction. In our pictures and diagrams, we will mostly depict the tape as extending infinitely to the left. Each tape cell can contain a symbol from an alphabet. Instead of symbols, we speak of colors and in the current paper we will work with just two colors: black and white.

The head of a TM can be in various states as it moves over the cells of the tape. We will refer to the collection of TMs that use states and symbols/colors as the -space of TMs. We will always enumerate the states from to and the colors from to . In this paper, we work with just two symbols so that we represent a cell containing a 0 with a white cell and a cell containing a 1 with a black cell.

A computation of a TM proceeds in discrete time steps. The tape content at the start of the computation is called the input. By definition, our TMs will always start with the head at the position of the first tape cell, that is, the tape cell next to the edge of the tape; in our pictures, this is normally the rightmost tape. Moreover, by definition, our TMs will always commence their computation in default start state .

A TM in space is completely specified by its transition table. This table tells what action the head should perform when it is in State at some tape cell and reads there some symbol . Such an action in turn consists of three aspects: changing to some state (possibly the same one); the head moving either one cell left or one cell right but never staying still; writing some symbol at (possibly the same symbol as before). Consequently, each -space consists of many different TMs. We number these machines according to Wolfram’s enumeration scheme [12, 13] which is similar to the lexicographical enumeration.

Clearly, each TM in space is also present in space for , by just not using the extra states since they are “inaccessible” from State 1. Many rules in a space are trivially equivalent in the computational sense up to a simple transformation of the underlying geometry, for example, by relabeling states by reflection or complementation, hence, for all identical purposes. In the literature, machines that have equivalents are sometimes called amphicheiral; we will sometimes refer to them as machine twins.

We say that a TM halts when the head “falls off" the tape on the right-hand side, in other words, when the head is at the rightmost position and receives an instruction to move right. The tape configuration upon termination of a computation is called the output.

We will refer to the input consisting of the first tape cells by black on an otherwise white tape as the input (this is in slight discrepancy with the convention in [14]). In this context, a function is a map sending an input to some output tape configuration. We call the function where the output is always identical to the input the tape identity function.

By Rice’s theorem, it is in principle undecidable if two TMs compute the same function. Nonetheless, for spaces with small, no universal computation is yet present [15, 16]. In [14], the authors completely classify the TMs in (3,2) space among the functions they compute, taking pragmatic approaches that possibly produce small errors to deal with undecidability and unfeasibility issues.

1.2.2. Space-Time Diagrams

As previously mentioned in this paper, a central role is played by the so-called space-time diagrams. A space-time diagram for some computation is nothing more but the joint collection of consecutive memory configurations. We have included a picture of space-time diagrams for a particular TM for inputs 1 to 14 in Figure 1.

Since these space-time diagrams are such a central notion to this paper, let us briefly comment on Figure 1. The top-row of each of these fourteen diagrams always represents the input tape configuration of the TM. We have chosen to depict the space-time diagrams of our TM on inputs 1 to 14. The rightmost cell in the diagram is actually not representing a tape cell. Rather it represents the end of the tape so that we depict it with a different color/grey-tone.

Remember that the computation starts with the head of the TM in State 1 in the rightmost cell. Each lower row represents the tape configuration of a next step in the computation. So, there can at most be one cell of different color between two adjacent rows in a space-time diagram. We see that this particular (2,2) TM with number 346 first moves over the tape input erasing it. Then, it gradually moves back to the edge of the tape writing alternatingly black and white cells to eventually fall of the tape, whence it terminates.

Clearly, these space-time diagrams define spatiotemporal objects by focusing on the black cells. We wish to measure the geometrical complexity of these spatiotemporal objects. Subsequently, we wish to see if there is a relation between this geometrical complexity and the computational complexity (space or time usage) of the TM in question.

In Section 1.3.2, we will see how to assign a measure of geometrical complexity to these space-time diagrams and call this measure the dimension of the TM. Various relations between computational complexity of a TM on the one hand and its dimension on the other hand can be proven. Other relations will be investigated via experiments.

1.2.3. On Our Coding Convention

Note that for this paper it is entirely irrelevant how to numerically interpret the output tape configuration whence we will refrain from giving such an interpretation. However, it has been a restrictive choice to represent our input in a unary way. That is to say, the notion of a function in our context only looks at a very restricted class of possible inputs: blocks of consecutive black cells for . The main reason why we do this is that if we do not do this, our functions all behave in a very awkward and highly undesirable way. In [14], this undesirable behavior is explained in the so-called Strips Theorem.

Basically, the Strips Theorem boils down to the following. Let us consider a TM in space on input and suppose is a terminating computation. If we number the cells on the tape by their distance to the edge, let be the largest cell number that is visited in the computation of . Clearly, any tape input that is equal to on the first cells but possibly different on the cells beyond will perform exactly the same computation and in this sense it is input-independent.

We have chosen our input-output convention in such a way to prevent the Strips Theorem. There are two undesirable side effects of our coding. Firstly, it is clear that any TM that runs in less than linear time actually runs in constant time. Secondly, the thus defined functions are very fast growing if we were to represent the output in binary. In particular, the tape identity represents an exponentially fast growing numerical function in this way.

A positive feature of our input convention is that the amount of symmetry present in the input coding facilitates various types of analysis and in particular automated function-completion seems to run more smoothly. Warning. A clear drawback of our convention is that one tends to think of the th input as the number . In the context of this paper, this would not be good practice since it would, for example, yield a linear primality test and factorization algorithm.

We will here describe an alternative way of representing the input and denote the representation by . This representation will be such that it avoids the Strips Theorem yet does not intrinsically entail exponential growth of the tape identity and similar functions in case we would interpret our output configuration in binary. Although we do not use nor explore the alternative input coding, we find it worth mentioning here and hope that future investigations can take up the new coding.

In order to represent the input according to , we first write the input in binary as with all but finitely many . Let us denote the cells on the tape by . Here, is the cell at the edge, is the cell immediately next to it, and so forth. For , let and otherwise. That is, is the number of digits in the binary expansion of .

For each , we will represent in in the canonical way: we set to be one/black whenever and we set to be zero/white otherwise. Moreover, we set all odd-labeled cells to be zero with the sole exception at cell that we define to be one/black.

It is clear that avoids the Strips Theorem. Moreover, if we were to interpret the output as binary, the tape identity defines a function whose growth rate is only in the order of .

1.3. Fractal Dimensions

In this section, we will briefly recall the definition of and ideas behind the box-counting dimension which is a particular fractal dimension having the better computational properties whence better suited for applications. In Section 3.1, we relate the box dimension to various other notions of fractal dimension and in particular to the well-known Hausdorff dimension.

After revisiting the notion of box-counting dimension, we see how to apply these to Turing machines and their space-time diagrams.

1.3.1. Box Dimension

We will use the notion of box dimension. This notion of fractal dimension can be seen as a simplification of the well-known Hausdorff dimension (see [17] and our survey section, Section 3.1). The Hausdorff dimension is mathematically speaking more robust than the box dimension. However, the box dimension is easier to compute and is known to coincide with the Hausdorff dimension in various situations.

Let us briefly recall the definition of the box dimension and the main ideas behind it. The intuition is as follows. Suppose we have a mathematical object of bounded size whose “volume" we wish to estimate. For example, let us work with a space that has dimension large enough to embed our object . The idea now is to cover the object by boxes in and estimate the “volume” of as function of the total number of boxes needed to cover . Clearly, the number of boxes needed to cover depends on the size of the boxes used. Therefore, in the analysis, we will take along the parameter which denotes the length of the edge of the boxes used, and we will write the number of boxes needed to cover as .

If is a line, which is a one-dimensional object, the corresponding notion of “volume” is just the length of the line segment. To estimate the length , we clearly haveif this is well defined.

If is a plane, or more in general a two-dimensional manifold, the corresponding notion of “volume” is just the surface of the plane/manifold segment for which we haveif this is well defined.

Likewise, for a three-dimensional object, to estimate its volume, we would haveif this is well defined, and in general, for a -dimensional object, we would obtain

The idea behind the definition of the box dimension is to take (4) as a defining equation of dimension if this makes sense mathematically speaking. Thus, solving for in (4), we obtainThe last equality is justified in case is bounded as by assumption and is finite so that .

The reflections above form the main ideas behind the definition of box dimension that we will use in this paper.

Definition 1 (box dimension). Let be some spatiotemporal object that can be embedded in some ; let denote the minimal number of boxes of size needed to fully cover . The box dimension of is denoted by and is defined byin case this limit is well defined. In all other cases, one will say that is undefined.

1.3.2. Box Dimension for Space-Time Diagrams

Let us see how we can adapt the notion of box dimension to our space-time diagrams. The spatiotemporal figure that we wish to measure will be defined by the black cells in the space-time diagram. Clearly, for each particular input on which the TM halts, the corresponding space-time diagram is finite and has dimension : each black cell defines a piece of surface. It gets interesting when we consider limiting behavior of the TM on larger and larger inputs.

A First Attempt. Let be some TM and let denote the space-time diagram corresponding to TM on input if this is well defined, that is, if eventually halts on input which we will denote by τ(x)↓. The question is as follows: what is the sensible way to define the dimension of our TM ? It does not make much sense to define for a couple of reasons.

Firstly, might diverge on various inputs. We can easily bypass that by tacitly understanding as getting larger and larger among those for which τ(x)↓ demanding that there are infinitely many such . In case there are just finitely many on which converges, we could say that is undefined.

The second objection is more serious. As for each with τ(x)↓, we have that ; we see that all limits converge to the value 2 if they are well defined. This of course is highly undesirable. We can overcome this objection by scaling the length of each to some figure whose length has unit size. Thus, the black areas in become more and more fine-grained so that it seems to make sense to define .

A Second Attempt and Formal Definition. The new candidate has many good properties. However, for this new candidate, we again see two main objections.

The first objection is that need not exist at all and, even worse, is likely not to be well defined in most cases. We could try to remedy this by working with subsequences for which the limit is defined but it all seems very hairy.

The second objection is that this new definition seems hard to numerically approximate at first glance. We will see how to overcome the second objection which will yield to us automatically a solution to the first objection.

As we mentioned before, we cannot first approximate and then compute the corresponding as this would always yield the answer 2. However, what we can do is simultaneously approximate both and . There are a lot of choices in how we approximate and in how fast we approximate and how fast we approximate relatively to the approximation of .

There seems to be a canonical choice though. The approximation of the dimension is dependent on the size of the boxes. It seems very natural to take the size of our boxes to be exactly the size of one tape cell. The size of one tape cell is naturally determined by . Let us determine as dictated by . In order to facilitate our discussion, we first fix some notation.

Definition 2. For a TM and an input so that τ(x)↓, we denote by the amount of time steps needed on input to terminate. Likewise, denotes the amount of space cells used by the computation of on input . Thus, measures the distance between the edge of the tape and the furthest tape cell visited by the head during the computation.
We will sometimes write or even just if the context allows us to, similar for the space-usage function .

By the nature of our input-output protocol, there exist no TMs whose runtime is sublinear but not constant. Let us first concentrate on the TMs that run in at least linear time and deal with the constant time TMs later. If a TM halts in nonconstant time, the least it should do is read all the input, do some calculations, and then go back to the beginning of the tape. Thus, clearly , whence the scaling of the figure is best done by resizing the runtime to get length 1. Consequently, the size of scales to .

Recall that denotes the minimal number of boxes of size needed to cover the spatiotemporal object . Now that we have determined the size of , we can write instead of and it is clear that is just the number of black cells in the space-time diagram of on input . Thus, the second attempt of defining then translates to

In this definition, we could address the issue of undefinedness by replacing by or . Notwithstanding the theoretical correctness of this move, it seems hardly possible to sensibly compute or in the general setting.

In the current paper, however, we have only considered TMs with either two or three states and just two colors. It turned out that in this setting we could determine both and . In all cases that we witnessed where the limit (7) outright was not well defined, we were able to identify different subsequences where the limit (7) did converge so that we could choose to go with either or . It turns out that, in general, the lower the dimension, the more interesting the corresponding TM, so that we decided to work with .

For TMs with constant runtime, we know that only a constant number of cells will be visited and possibly changed color. For these TMs, the figure can only be sensibly scaled by using the input size. By doing so, we see that in the limit we just get a black line whose dimension is clearly equal to one. However, as we consider constant runtime TMs as a degenerate case so to say, we will for convenience define the dimension of such machines to be equal to 2. We do so in order to have them more like linear time TMs (see Lemma 4). All these considerations and reflections lead us to the following definition.

Definition 3 (box dimension of a Turing machine). Let be a TM that converges on infinitely many input values . In the case of τ(x)↓, let denote the number of black cells in the space-time diagram of on input and let denote the number of steps needed for to halt on .
We will define the box dimension of a TM and denote it by . In case is constant from some onwards, we define . Otherwise, we define

Note that our definition of dimension can readily be generalized to nonterminating computations. Also, restricting to computational models with discrete time steps is not strictly necessary.

1.3.3. Linear Time Turing Machines

For certain TMs , we can actually compute their box dimension. Let us reconsider TM 346 again whose space-time diagrams were displayed in Figure 1. Due to the extreme regularity in the space-time diagrams, we can see that TM 346 runs in linear time, that is to say, linear in the length of the representation of the input.

Thus, after scaling each space-time diagram so that the vertical time axis is rescaled to 1, we will always have a little surface in the shape of a black triangle in the scaled space-time diagram. The box dimension of a triangle is of course 2. We may conclude that (2,2-TM 346) . Of course the only important feature used here is the linear-time performance of 2,2-TM 346. We can summarize this observation in a lemma.

Lemma 4. Let be a TM that runs at most linear time. Then, .

Proof. We fix some TM that runs at most linear time. Our input/output convention is such that either is constant time or is linear time. In case runs in constant time, we have that by definition.
Let us consider the case that runs in linear time. It must be the case that the head goes all the way to the end of the tape input; if not, would run in constant time from some input onwards. Input is represented by consecutive black cells. In the worst case (the fewest amount of black cells), at all the first steps, the input is erased and replaced by a white cell as is the case in Figure 1.
However, runs in linear time, for example, for any , the machine runs at most many steps with . After scaling, the input will get size . Thus, in the worst case, the upper triangle has size which is independent of and thus nonvanishing. Clearly, the box dimension of a triangle of whatever size equals 2. Thus, as what we wanted to see.

1.4. The Space-Time Theorem and Applications

Above we saw that for linear time TMs we can actually compute the corresponding dimension. However, for nonlinear TMs, we can only prove an upper bound on the box dimension.

1.4.1. The Space-Time Theorem: An Upper Bound

Theorem 5 (Space-Time Theorem). For a given TM , let denote the amount of cells visited by on input , and let denote the amount of computation steps it took to terminate on input :

Proof. The box dimension is maximal in case all cells under consideration are black. This number is bounded above by . Plugging this in the definition of gives us our result:

As we will see, in all cases, the upper bound given by the Space-Time Theorem is actually attained in our experiment. It is unknown, however, whether it holds in general.

1.4.2. A Lower Bound

We first observe that for any Turing machine we have that . The main idea is that if there are too many white cells, then the Turing machine would enter a loop and either finish straightaway or never finish (we would like to thank an anonymous referee for suggesting this simple argument to us).

Theorem 6. The dimension for any Turing machine .

Proof. Let be the number of states of some fixed TM . It is clear that if we have a sequence of consecutive steps in a computation of where the tape is entirely white, then will enter a loop. Thus, for , in order to exhibit nontrivial behavior, we should have, modulo an additive constant, thatFor linear or constant time TMs , we had already observed in Lemma 4 that so we may assume that has superlinear runtime asymptotic behavior. But then, from (11), it follows that in the limit we have as was to be shown.

The method in proving the lower bound seems very crude: no blocks of consecutive entirely white tapes may occur. It seems that more in-depth analysis could yield sharper lower bounds.

1.4.3. The Asymptotic Conjectures

In Theorem 6, we proved . However, we conjecture that something stronger actually holds.

Conjecture 7 (space-time ratio conjecture). For each TM which runs in more than linear time, we have that .

In certain cases, the Space-Time Theorem (Theorem 5) and the lower bound as proved in Theorem 6 coincide.

Lemma 8. In case a TM uses polynomial space and runs superpolynomial time, one has that .
More in general, if for a TM we have that , then

Proof. By combining our general lower and upper bound as proven in Theorems 6 and 5, respectively, we see that

Lemma 8 shows us that, in certain cases, the upper bound as given in the Space-Time Theorem is actually attained. We will empirically verify that this is always the case in (3,2) space and conjecture that holds more in general.

Conjecture 9 (Upper Bound Conjecture). We conjecture that for each and each TM in space we have .

Thus, Lemma 8 provides a proof of the Upper Bound Conjecture in certain situations. For any TM that performs at most in linear time, we have also proven the Upper Bound Conjecture in Lemma 4. In Lemma 11, we will prove the Upper Bound Conjecture for some other situations too. In order to prove this, we first need an additional insight.

Lemma 10. For each TM , there is a constant with

Proof. Since is bounded above by (we observed this before in the proof of Theorem 5), we get that for each TM we have for each that . But then clearly is well defined and within the closed interval .

Lemma 11. In case , one can prove the Upper Bound Conjecture; that is,

Proof. We may assume that runs in at least linear time for, otherwise, the claim is proved by Lemma 4. Thus, . Our assumption gives us for some . Note that in this assumption we have a limit and not liminf so that any subsequence converges to the same limit. Consequently, we havewhich implies the Upper Bound Conjecture provided .

The following proposition provides an almost equivalent formulation of the Upper Bound Conjecture.

Proposition 12. For each TM , one has that ifthen the Upper Bound Conjecture holds.
Moreover, if the Upper Bound Conjecture holds uniformly for some TM , that is, , then .

Proof. If , we also have since for each . Consequently,For the other direction, we assume . Consequently,Using this identity , we see that for any subsequence we have thatConsequently,But since , the possibility cannot occur and we are done.

1.4.4. The Space-Time Theorem and versus

As usual, we denote by the class of problems that can be solved by a TM which uses an amount of time that is bounded by some polynomial applied to the size of the input (representing an instantiation of the particular problem).

Likewise, we denote by the class of problems so that any solution of this problem can be checked to be indeed a solution to this problem by a TM which uses an amount of time that is bounded by some polynomial applied to the size of the input. Here, in stands for nondeterministic. That is to say, a nondeterministic TM would run in polynomial time by just guessing the right solution and then checking that it is indeed a solution. It is one of the major open questions in (theoretical) computer science whether or not.

By we denote the class of problems that can be solved by a TM which uses an amount of memory space that is bounded by some polynomial applied to the size of the input. It is well known that . Thus, by Lemma 8, we can state a separation of and in terms of dimensions.

Let be some -complete problem. If for each Turing machine that decides we have that , then .

Clearly, this does not constitute a real strategy since, for one, in general it is undecidable whether [18].

2. Part II: Experimental Setting

In this second part of the paper, we describe the experiment we have performed to empirically test whether the theoretical results also hold in cases that do not satisfy the necessary requirements for the theoretical results to be applied.

2.1. The Experiment

We have already proven on purely theoretical grounds that there is a relation between runtimes and fractal dimension of the space-time diagrams. However, our theoretical results only apply to a restricted class of TMs.

In the experiment, we wanted also to study the fractal dimension of the space-time diagrams in cases where our theoretical results do not apply. Moreover, guided by the first outcomes of our experiment, we formulated the Upper Bound Conjecture (Conjecture 9) and gathered data as to investigate if the conjecture holds in (3,2) space.

2.1.1. Slow Convergence

For TMs that run in at most linear time, we have proven in Lemma 4 that . Our aim is to use computer experiments to compute the box dimension of all TMs where is not predicted by any theoretical result.

A substantial complication in this project is caused by the occurrence of logarithms in the definition of . As a consequence, increase in precision of requires exponentially larger inputs. This makes direct brute-force computation unfeasible. As an example, let us consider 2,2-TM 346 again whose space-time diagrams we saw in Figure 1. By Lemma 4, we know that the box dimension of this Turing machine equals two. However, Figure 2 shows us how slow the rate of convergence is.

Our way out here is to apply numerical and mathematical analysis to the functions involved so that we can retrieve their limit behavior. In particular, we were interested in three different functions.

As before, for a TM we denote by the amount of time steps needed for to halt on input ; by we denote the number of black cells in the space-time diagram of on input and by the distance between the edge of the tape and the furthest cell visited by on input .

With these functions and knowledge of their asymptotic behavior, we can compute the corresponding dimension and the upper bound . The functions are guessed by looking at large enough initial sequences of their outcomes in a mechanized fashion. The few cases that cannot be done in a mechanized version were analyzed by hand.

It is important to bear in mind this process and the fact that we work with guesses that can be wrong in principle. For example, if we speak of a TM that performs in time of order , this means in this paper that, by definition, after applying our particular analyzing process, was classified as an time performer. It may well be that in reality needs exponential time. However, there are strong indications that our guessing process is rather accurate [14, 19].

2.1.2. Methodology

In this section, we will describe the steps that were performed in obtaining our results. Basically, the methodology consists of the following steps:(1)Each TM that lives in 2,2 space also occurs in (3,2) space so for the final results it suffices to focus on this data set. The TMs that diverge on all inputs were removed from the initial list of 2 985 984 TMs in the (3,2) space, since for them the dimension is simply not defined. For the remaining TMs, we erased all diverging inputs from the sequence to which we were to apply our analysis. Since we are only interested in limit behavior of any subsequences, this does not alter our final results.We isolated the TMs for which there is no theorem that predicts the corresponding dimension. By Lemmas 4 and 8, this means that we only needed to pay attention to those TMs which use more than linear time. Moreover, we also removed all simultaneous EXP-time and PSPACE performers to finally end up with a collection of TMs. The distribution of the resulting collection is summarized in Table 1.In addition, there are 1 792 TMs that perform in exponential time and linear space, but clearly they needed no further analysis since we know on theoretical grounds that their corresponding dimension is 1. All other machines in (3,2) space were very simple in terms of time computational complexity; that is, they perform at most in linear time.(2)Per TM , we determined/guessed its function corresponding to the space usage of on input . Although this guessing was already performed in [14], we decided to redo the process. The main reasons to do this were a new release of our analyzing tool Mathematica together with the fact that the authors had obtained new insights into how to best perform the analysis. Our results coincided in large part with the ones obtained in [14] but also showed minor discrepancies.(3)Per TM , we determined its function corresponding to the time usage of on input .(4)Per TM , we determined its function corresponding to the number of black cells in the space-time diagram of on input .(5)Per TM , we computed .(6)Per TM , we computed its dimension as .(7) Per TM , we compared its dimension to its theoretical upperbound which we computed separately.(8) Per TM , we computed and .

Boxes RuntimeSpaceMachines


2.1.3. Alternating Convergent Behavior

Some of the Turing machines possessed alternating asymptotic behavior. This has been already observed in [14]. Typically, the alternation reflects modular properties of the input like being odd or even or of the number of states.

The differences between the alternating subsequences can be rather drastic though. The most extreme example we found is reflected in Figure 3.

Figure 3 shows the space-time diagrams for TM with number 1 728 529 for inputs 1 to 7. For convenience, we have changed the orientation of the diagrams so that time “goes from left to right” instead of going from “top to bottom.”

This machine runs in linear time for even inputs and exponential time for odd inputs. The runtime is given byThe number of black cells in the space-time diagram exhibits the same behavior. Note, however, that the space that uses is linear in the size of the input and in particular the amount of tape cells used is equal to the size of the output.

Moreover, we note that the sequence of outputs is of a very simple and regular nature. The outputs can be grouped in series of two, where the output on input consecutive black cells is equal to the output on input consecutive black cells. So, in a sense this TM incorporates two different algorithms to compute this output: one in linear time and the other in exponential time.

We have found alternating sequences of periodicities 2, 3, and 6. Like we noted in [14], the periodicity typically reflects either the number of states, the number of colors, or a divisor of their product. Figure 4 shows an example of TM number 1 159 345 whose corresponding box-counting sequence has periodicity six.

In Figure 4(a) we show the points on the vertical axis plotted against the input . In Figure 4(b) we estimated a fit from below.

This alternating behavior reflects the richness of what we sometimes refer to as the microcosmos of small Turing machines. It is this alternating behavior that complicated analyzing the data set in a straightforward automated fashion.

2.1.4. Determining the Important Functions

In this section, we would mainly like to stress that most of the computational effort for this paper has actually been put into determining/guessing the functions ,  , and and computing the corresponding limits.

As may have become manifest from the previous section, it is hard to automatically guess perfect matches for these functions in case there is alternating behavior present. Finally, we could deal with all functions in a satisfactory way. Notwithstanding our confidence, it is good to bear in mind that all classifications provided in this paper are given the current methodology.

We will here briefly describe how we proceeded to guess our functions. The methodology is fairly similar to that performed in [14]. However, for this project, we used newer tools and a slightly more sophisticated methodology which accounts for possible differences from [14]. Schematically, the guessing process can be split into the following steps:(1)We collected the sequences for time usage and space usage from the TM data set as described in Section 1.2 of this paper.(2)These sequences and are only given for the first 21 different inputs. We used an initial segment of 15 elements of these sequences to guess in an automated fashion the corresponding function that allegedly generates this sequence. In some cases, the beginning of the sequence (up to three elements) was removed because the beginning did not match the general pattern that only occurred later on in the sequence. If we would leave the first values, Mathematica was no longer able to find the general pattern. The guessing process was done in Mathematica versions 8 and 9 using the FindSequenceFunction as built-in in this software. In some cases, FindSequenceFunction came with a solution; in other cases, it did not. The function FindSequenceFunction does various standard numerical and algebraic analyses on the sequences but also checks for obvious recurrence patterns. The function, built-in into the computer algebra system Mathematica, takes a sequence of integer values to define a function that yields a sequence which coincides on the first values.FindSequenceFunction finds results in terms of a wide range of integer functions such as sums and series coefficients, as well as implicit solutions to difference equations using early elements in the list to find candidate functions, and then validates the predicted function by looking at later elements.(3)Thus, we obtain two lists: a list of TMs where we found a guess and a list where we did not find any guess. From the initial list of 528 runtime sequences, we could not guess 11, and from the 167 space sequences, we could not guess 15. Note that this number need not be equal since TMs from various different functions had the same space sequence.Moreover, 288 runtime sequences and 85 space sequences in were alternators. Mathematica guessed the right function using terms like . However, in computing , we manually split those sequences into, for example, an even and an odd part, to obtain the corresponding limits.(4)We performed a check on our guesses as collected in by applying the guessed function to inputs 16–21. In almost all cases, our guess turned out to be predictive and coincided with the real values. For those few cases where there was a discrepancy between the guesses and the actual values, we made a new guess based on a larger initial segment, now consisting of the first 18 elements, and then testing it once more on new real values. Finally, we were able to guess and successfully check all of the sequences, both space and time usage, in .(5)From the list , we deleted all complexities for which we knew the dimension on theoretical grounds so as to obtain a list .(6)For the TMs in , we used the supercomputing resources of CICA (Andalusian Center for Scientific Computing) to compute the corresponding sequences with a C++ TM simulator. To reduce the computational effort, for each set of equivalent TMs (up to a geometrical transformation, such as state mirroring), only one representative was run. We applied the guessing process as described above for and also to to come up with corresponding functions.(7) For the sequences in , we applied a semimanual process. Basically, there were three different procedures that we applied so as to find solutions also in for the sequences ,  , and .(a)In most of the cases, there was alternating behavior present. We could read off the periodicity from looking at graphs as, for example, in Figure 4. Sometimes, looking directly at the space-time diagrams was more informative. In all of these cases but one, we finally did find functions for the subsequences using our methodology as described above. As splitting the sequences into 2, 3, or 6 alternating ones reduces the length of the input sequence of FindSequenceFunction, we run in some cases 40 or 60 more inputs with the C++ simulator to end up with a sufficiently large data set.One alternating TM did not succumb to this methodology. This was TM 582 263 whose treatment is included in Section 2.2.3. We run this TM for 35 inputs with the simulator and observed that clearly converges to a constant, one for each subsequence, so we approximated by which was enough for the log-limit without knowing the exact value of .(b) In some cases, the regularity was not obvious to Mathematica but was evident when looking at space-time diagrams and/or the binary expansion of the output. In these cases, we could manage by just feeding our insight into Mathematica in that we let it work, for example, on the binary expansion of the sequences.(c) In some cases, the recurrences were just too complicated for Mathematica version 8. In these cases, we carefully studied the space-time diagrams analyzing what kind of recurrences were present. Then, the observed recurrences were fed into FindSequenceFunction where we let FindSequenceFunction find out the exact nature and coefficients of the corresponding recurrences. One such example concerns the TM that produces the largest possible outputs in (3,2) space: the so-called Busy Beaver as detailed in Section 2.2.2.(8) After having successfully (allegedly) found the functions , , and , we could compute the values for and . In most cases, a simple limit sufficed. For alternating behavior, we had to select most of the times the subsequences by hand so as to end up with the value. For some alternating sequences, the value could just be obtained by combining on the one hand of (as depicted in Figure 4) or , respectively, and on the other hand .

2.2. Most Salient Results of the Experiment

In this section, we will present the main results of our investigations. The space of TMs which employ only 2 colors and 2 states is clearly contained in (3,2) space. However, we find it instructive to dedicate first a section to the findings in (2,2) space. Apart from the first section, all other results in this section refer to our findings in (3,2) space.

2.2.1. Findings in (2,2) Space

In (2,2) space, there was a total of 74 different functions. Of these functions, only 5 of them where computed by some superlinear time TMs. Note that this does not mean that all TMs computing this function performed in superlinear time. For example, the tape identity has many constant time performing TMs that compute it but also some exponential time performing TMs that compute it.

In total, in (2,2) space, there are only 7 TMs that run in superpolynomial time. Three of them run in EXP-time, all computing the tape identity. The other four TMs compute different functions. These functions do roughly compute a function that doubles the tape input (see Figure 5).

All these four TMs perform in quadratic time and linear space. We computed the dimension for these functions and all turned out to have dimension . We observe that this is exactly the upper bound as predicted by the Space-Time Theorem. We saw this phenomenon in (3,2) space as well.

The only three exponential time performers used linear space so by Lemma 8 we already know that the dimension of those TMs should be one. This has been checked also in Mathematica. The check was not really performed to check our theoretical results; rather, the check was used as a test case for our analyzing software.

We saw that a TM in (2,2) space runs in superpolynomial time if and only if its dimension equals 1. This observation is no longer valid in (3,2) space though.

2.2.2. Exponential Space and the Busy Beaver

In the remainder of this section, we will focus on the TMs in (3,2) space. That space contains 2 985 984 many different TMs which compute 3 886 different functions. Almost all TMs used at most linear space for their computations. The only exception to this was when the TM used exponential space. Curiously enough, in (3,2) space, there was no space usage in between linear and exponential space.

In [20], one can see an overview of the EXP-space performing TMs. For most of these TMs, it was not too hard to find an explicit formula for the space usage. An example is TM with number 683 863 whose corresponding space usage isThe space-time diagrams for TM 683 863 contained sufficiently much regularity so that Mathematica could guess the corresponding functions. For various other EXP-space performers, we had to help Mathematica by suggesting to it what kind of recursion it should look for. This occurred also with the so-called Busy Beaver.

Classically speaking, the Busy Beaver function outputs on input the longest time that any TM with states runs when executed on a two-way infinite tape with empty input [21]. In analogy, in the context of this paper, we will call a TM a Busy Beaver whenever, for each TM , there is some value so that for all we have . The equivalent machines 599 063 and 666 364 are the Busy Beavers in the (3,2) space. They compute the largest runtime, space, and boxes sequences. They also produce the longest output strings. For the remainder of this section, we will denote the Busy Beaver TM by . As mentioned, there are of course two actual TMs that compute the Busy Beaver but they have the exact same behavior and we will not distinguish between them.

Figure 6 shows the execution of machine 666 364 for inputs 1 to 3. The diagrams have been rotated to save space. As one can see, the series of outputs is very regular and so is the sequence of cells used by the computation. Nonetheless, Mathematica did not find a recurrence between the consecutive values. This was due to a minor error term.

That is, if one looks at the amounts of used cells for consecutive inputs and their differences, then modulo a small error term, there is a clear tendency. Let denote the number of consecutive black input cells. Looking at the ratio between consecutive values helped us to isolate the disturbing difference term (Table 2).



So, ignoring the exact nature of the error term, the recurrence equation for the space is given in the following:where is a function that takes values in . When we forced Mathematica to focus on the error term, it came up with the exact recurrence relation where + + + after defining .

The runtime depends on the space and we found the following recurrence relation for it:Finally, by close inspection on the space-time diagrams, we could guide Mathematica to look for specific kind of recurrences to finally come up with

Using these recurrence equations, we could finally compute the limits. We computed the limits by both standard methods on limits of recurrence relations and employing Mathematica and both methods gave the same answers to the effect that all simultaneous EXP-time and EXP-space TMs in (3,2) space have fractal dimension .

2.2.3. The Space-Time Theorem Revisited

One of our most important empirical findings is that the upper bound as given by the Space-Time Theorem is actually always attained in (3,2) space. Moreover, we found two related empirical facts for (3,2) space. We mention them in this section.

Finding 0. For all TMs in (3,2) space, we found that . More in particular, we found that for each TM in (3,2) space which performed in superlinear time we haveAnd we conjecture that this holds in general for TMs with a larger number of states.

Finding 1. For all TMs in (3,2) space, we found thatand we conjectured in the Upper Bound Conjecture 9 that this holds in general for TMs with a larger number of states.

In Proposition 12, we saw that a sufficient condition for the Upper Bound Conjecture to hold is that but it is not known if this is also a necessary condition. The following finding is related to this.

Finding 2. For all TMs in (3,2) space, we found that

In Lemma 11, it was shown that is a sufficient condition for the Upper Bound Conjecture to hold but it is not known if it is also necessary. The following finding is related to this.

Finding 3. For all TMs in (3,2) space, we found thatif this limit was well defined. Thus, in particular, we found that . Moreover, we found that only limited amounts of numbers were attained as limits of this quotient. The values found in for are1/9, 1/6, 7/30, 1/4, 5/18, 5/16, 1/3, 3/8, 8/21, 7/18, 5/12, 3/7, 4/9, 7/15, 1/2, 5/9, 9/16, 2/3, 3/4, 7/9, 1. It is possible that a few other limit values exist but were not found by the way we computed the functions generating .

For two of the EXP-space performers, we could not find the boxes function. These TMs were 582 263 (and their twin machine), whose execution for inputs 1 to 6 is shown in Figure 7. This TM possesses alternating behavior with periodicity two. For these two machines, we used Lemma 10 to settle the computation of .

For the sequences of even number of consecutive black input cells, we found that the fraction tended to 0.31 whereas for the odd number of consecutive black input cells we saw it tended to 0.11. The exact value of the fraction is of course irrelevant in the computation of the limit that determines .

Finding 4. For all TMs in (3,2) space, we found that if and only if the TM ran in superpolynomial time using polynomial space. We suspect that this equivalence holds no longer true in higher spaces, that is, spaces for .

Finding 5. For all TMs in (3,2) space, we found that if and only if the TM ran in at most linear time. It is unknown if this equivalence holds true in higher spaces. Part of it holds in general (Lemma 4): if runs in at most linear time, then .

2.2.4. Richness in the Microcosmos of Small Turing Machines

The authors have explored the space of small Turing machines before. On occasion, they have been so much impressed by the rich structures present there that they came to speak of the microcosmos of small Turing machines. For this paper, we had to mine (3,2) space even further and at some point were surprised to be surprised once more.

In particular, Figure 8 shows a very curious phenomenon that we call symmetric performers. There turned out to be a pair of different TMs so that the space-time diagram on every even input of the one machine is the exact symmetric image of the space-time diagram of the other TM on the same input.

Of course, this can only happen in case the TM computes the tape identity since the input must equal the output in order to yield a symmetric image. At first, one might be tempted to think that this phenomenon is bound to occur since we can define for each TM its reversed machine : replace each instruction by its canonical reversal:where changes to and vice versa. However, note that both machines start in State 1 so that this imposes already a strong condition on possible solutions of symmetric performers.

Let us denote by and a pair of symmetric performers. It is clear that if a TM terminates on input , it does so in an even number of steps: for each computation where the head moves one to the left (the end of the tape is on the right by our convention), there must be a step where the machine moves one step to the right. In particular, for symmetric performers that terminate in many steps on input , we have that if the tape configuration at step differs from the tape configuration at step in , then the head position in step on is the same as the head position in step on .

Indeed, it comes as a surprise that all these constraints can be met in (3,2) space, if only just for the even inputs.

3. Part III: A Brief Literature Survey

In the third and final part of the paper, we will try to locate our results within the landscape of known theoretical results that link fractal dimensions to other notions of complexity.

3.1. Relations between Fractal Dimensions and Other Notions of Complexity: An Incomplete Survey of the Literature

In this paper, we have worked with a variant of box-counting dimension and with space and time complexity for processes implemented on Turing machines. These are just some out of a myriad of different complexity measures in the literature. Since eventually the notion of being complex or not is relative to a framework and the ultimate framework in which all these complexity notions can be embedded in is our own cognitive system, on philosophical grounds, one can expect relations between the various a priori unrelated complexity notions (see [22, 23]). And, indeed, in the literature, we find various relations between different notions of complexity.

In this final section, we wish to place our results in the context of other results in the literature that link different complexity notions. Our point of departure will be fractal dimensions and possible relations to complexity notions of a computational nature.

Neither is the current section self-contained nor do we pretend to give an exhaustive overview of the literature. Rather, we will try to provide sufficient pointers so that this section at least can serve as a point of departure for a more exhaustive and self-contained study.

3.1.1. Box-Counting Dimension within the Landscape of Topological and Fractal Dimensions

In this paper, we decided to work with a variant of box-counting dimension since this has many desirable computational properties and applications. Let us first see where box-counting dimension fits into the landscape of various versions of fractal and other dimensions.

Edgar divides geometrical dimensions in two main groups, topological and fractal dimensions (see [24]). Topological dimensions are invariants of topological spaces in that they are invariant under homeomorphisms. Moreover, topological dimensions have integer values although some versions allow transfinite (ordinal) values too.

The most basic of all topological dimensions is the so-called cover dimension, also called Lebesgue dimension. In order to describe this dimension, we need some additional notions.

The order of a family of sets is ≤n by definition when any of the sets have empty intersection. We denote this by . We say that when but not . Thus, for example, if any two sets in have empty intersection, the order of is 0.

The cover dimension of a set is , we write , whenever each open covering of has a refinement of order . Thus, for example, a collection of two separate points in has cover dimension 0 since we can separate the points by two disjoint opens. Likewise, any line-like space admits an open cover of order 1; that is, any intersection of three different opens is empty. Similarly, we can cover a planar set by open tiles where each row of tiles is shifted to the right, for example, with respect to the adjacent rows of tiles. This collection of tiles has order two since any collection of four different ones of such open tiles will be empty.

Fractal dimensions on the other hand can have noninteger values. In a sense, the fractal dimension of some object is an indication of how close is to some integer-valued dimensional space. Dimension in integer-valued dimensional spaces in a sense expresses degrees of freedom and as such this provides us with an information theoretical focus on dimension. More common is the geometrical focus on (fractal) dimension as, for example, expressed by Falconer [25]: “Roughly, dimension indicates how much space a set occupies near to each of its points."

The most fundamental and most common notion of fractal dimension is that of Hausdorff dimension [17] which was introduced already in 1919 building forth upon ideas of Carathéodory from 1914 [26].

In order to relate our box-counting dimension to the more common Hausdorff dimension, we will outline the definition and some basic properties of Hausdorff dimension.

For a subset of some metric space, we can consider countable open coverings of and defineHere, denotes the usual diameter of as the supremum of distances between any two points in . The infimum is taken over all that are countable open -covers of . This means that the diameters of the open sets in our cover do not exceed . It is essential that we may take the diameters of the open sets in our cover to vary and in particular we can choose them as small as convenient. Next, we defineThe main theorem about these is that there is a unique so that(i) for ;(ii) for .

This unique is called the Hausdorff dimension of : . As mentioned, this dimension was introduced in 1919 by Hausdorff [17] and the main theory was later developed mainly by Besicovitch and his students [2731] so that [17] Mandelbrot often speaks of Hausdorff-Besicovitch dimension.

The Hausdorff dimension comes with a natural dual dimension called packing dimension. Although the notion of packing dimension is natural and related to the Hausdorff dimension, it was only introduced about sixty years later by Tricot Jr. [32] and Sullivan [33].

The main idea behind packing dimension of some spatiotemporal object is to somehow measure the volume of disjoint balls one can find so that the center of these balls lies within . As with the case of Hausdorff dimension, one parametrizes this concept with the target dimension :Since is not a measure (this is easy to see by considering countable dense sets of some with positive dimension), one applies a standard trick which transforms this into a measure by defining Here, the infimum is taken over countable collections of sets so that . The main theorem of this notion shows that packing dimension is in a sense dual to Hausdorff dimension: There is a unique so that (i) for ;(ii) for .

This unique is called the packing dimension of and we write . It is not hard to see that packing dimension is an upper bound to Hausdorff dimension; that is, .

A fundamental property that is not hard to prove of the dimensions we have seen so far is that . Mandelbrot defines a fractal to be any set with . However, this notion of fractal is often considered (also by Mandelbrot himself) a notion of fractal that is too broad, since it admits “true geometric chaos." Taylor proposes (see [34]) to denote by fractals only Borel sets for which .

We can now see how box-counting dimensions (or box dimensions for short) naturally fit the scheme of fractal dimensions we have seen above. In particular, the box dimension is like Hausdorff dimension only that we now cover the spatial object by balls/boxes of fixed size rather than by balls of flexible size not exceeding some maximum value .

Alternatively and equivalently, in order to define the box dimension, we can divide space into a regular mesh with mesh size and count how many cells are hit by a set . Then, we define and .

Again, there is a cut-off value so that for and for . This cut-off value is given bywhich is close to the notion we started out with in this paper in Definition 1. Inspired by this cut-off value, we define

In case , we call this the box-counting dimension: which now exactly coincides with Definition 1. One can easily show that box dimension always provides an upper bound to Hausdorff dimension. Moreover, box dimension has many desirable computational properties thereby being amenable for computer applications.

Notwithstanding the good computational behavior, box dimension has various undesirable mathematical properties: in particular, a countable union of measure zero sets can have positive box dimension. For example, one can show that in with the standard topology we have which is of course highly undesirable.

Mathematically, this undesirable properties can be impaired with the same trick that was applied to the packing dimension by defining modified box dimension as

But, of course, by doing so, we would lose all the good computational properties. In general, we have thatand it is known that none of the inequalities can be replaced by equalities. However, we note that, under Taylor’s definition of fractal, the first four dimensions collapse and modified box dimension is an equivalent of Hausdorff dimension and indeed the modified box-counting dimension is a natural quantity to consider.

Moreover, if has a lot of self-similarity, then modified box-counting dimension is actually equal to the plane box-counting dimension.

Proposition 13. Let be compact so that for any open set we have ; then, .

So, in various situations, box counting coincides with Hausdorff dimension. The most famous example is probably that this equality holds for the Mandelbrot set. In addition, there are various other situations where box-counting and Hausdorff dimension coincide [35, 36].

3.1.2. Computability Properties of Fractals

As a first link between fractals and computability properties, we want to mention that of various fractal objects one has studied the computational complexity.

Probably the most famous examples of fractals are Julia sets and the corresponding “roadmap Mandelbrot set.” Let us briefly recall some basic definitions. By we denote the filled Julia set of a function defined on the complex numbers. This set is defined as the set of values in the domain of on which iterating on does not diverge. That is,By , the Julia set of , we denote the boundary of . Following Chong [37], we can consider with and . Using this notation, the corresponding Julia sets are denoted by .

One can express that