An algorithm to simulate alternating Turing machine in signal machine

by   Dawood Hasanzadeh, et al.

Geometrical Computation as a new model of computation is the counterpart of Cellular Automata that has Turing computing ability. In this paper we provide an algorithm to simulate Alternating Turing Machine in the context of Signal Machine using techniques adopted from the features of Signal Machine to set up and manage the copies/branches of Alternating Turing Machine. We show that our algorithm can simulate Alternating Turing Machine in Signal Machine as same functionality as classic family of Turing Machines. Time complexity of the algorithm is linear as ordinary simulated Turing Machines. Depending on the computation tree space complexity is exponential order of d, where d is the depth of the computation tree.



There are no comments yet.


page 1

page 2

page 3

page 4


Are there intelligent Turing machines?

This paper introduces a new computing model based on the cooperation amo...

Analytic one-dimensional maps and two-dimensional ordinary differential equations can robustly simulate Turing machines

In this paper, we analyze the problem of finding the minimum dimension n...

A general architecture of oritatami systems for simulating arbitrary finite automata

In this paper, we propose an architecture of oritatami systems with whic...

Abstract Geometrical Computation 11: Slanted Firing Squad Synchronisation on Signal Machines

Firing Squad Synchronisation on Cellular Automata is the dynamical synch...

'Viral' Turing Machines, Computation from Noise and Combinatorial Hierarchies

The interactive computation paradigm is reviewed and a particular exampl...

An Intrinsically Universal Family of Signal Machines

Signal machines form an abstract and perfect model of collision computin...

How Relevant is the Turing Test in the Age of Sophisbots?

Popular culture has contemplated societies of thinking machines for gene...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Automata are machines that repetitively execute pre-determined instructions. Cellular Automata (CA) is a discrete model of computation consisting of a set of regular cells, each in one of the finite possible states such as on or off. The set of cells around each cell called its Neighborhood which determines the state of the cell. At the beginning () an initial state is assigned to each cell, after each time step a new generation of cells produces based on pre-determined Rules. These rules determine the new states of cells according to their current states and neighborhood’s states of each cell. The rules are fixed and apply to the whole grid simultaneously. The space-time diagram of CA is the integer numbers for the space and the natural numbers for the time.

Using Euclidean geometry for computation forms a new model of computation known as Abstract Geometrical Computation (AGC) which first introduced by Jerome Durand-Lose in 2003 [1]. AGC is an analog model of computation and the counterpart of (CA). As Durand-Lose mentions AGC does not just come ”out of the blue” because of its CA origins [2]. If we replace the integer and natural numbers by real and positive real numbers respectively, we gain the continuous model of AGC where cells/particles are dimensionless resulting the continuous time and space. In this structure dimensionless particles move forward/backward in the continuous space-time diagram with constant speeds. Movement of particles is along real numbers for the space and only upward for the time, indeed time is always upward and there is no way to move back on the time axes.

Consider the moving particles as Euclidean lines called signals; each signal is a sample of a meta-signal with constant speed where the number of meta-signals is finite. In fact a signal is a piece of information spreads on the space-time diagram for a certain purpose. A cross point forms when two (or more) signals collide/meet each other, which is called a collision. When signals collide, collision rules determine aftermath of that collision, e.g., what new signals should be produced instead of previous signals before the collision. If for the collision of some signals there is not a predefined collision rule, it called a blank collision and signals continue their path without any changes in direction and type. The described structure is called Signal Machine (SM) in the context of AGC. SM is composed of three main parts: meta-signals, their speeds and collision rules.

Since its introduction in 2003, some computations and simulations has been done in this model. It is proved turing-computing ability could be carried out through two-counter automata in SM model [2]. Conservative abstract geometrical computation [3, 4] is a model that can simulate any turing machine and decide any recursively enumerable problem by creating accumulation points. NP-complete problems such as SAT problem can be solved efficiently in SM [5]. For this purpose in a division process the space slices to shape a comb to solve the SAT problem. The time and space are bounded in this structure. In a massively parallel manner it is possible to solve Q-SAT problem too [6]. In [7] the writers proposed a particular generic machine to solve Q-SAT using Map/Reduce paradigm. As the proposed machine is modular it is possible to solve satisfiability variants such as SAT, #SAT and MAX-SAT.

The simulation of ordinary TMs is presented in [3] for classical computation; in this article Durand-Lose presents a model in SM to decide semi-decidable problems according to Black Hole model of computation. The size of a TM is an important issue that has been considered so far [8, 9]. In the context of SM this is addressed in [10], small signal machines, able to perform fully classical computation (TM) with regards to the number of meta-signals and collision rules are presented. Other types of TM like type-2 Turing machine (T2-TM) is presented in a mixed representation of real numbers plus an exact value in (-1, 1) [11] and reversible TM is simulated in [12]. If a construction be rational accumulation points coordinates, time and space, are computably enumerable numbers (c.e. numbers) and difference of two such numbers (d-c.e. numbers) respectively [13]. Accumulation points as a limit of a sequence of signals, with regard to the number of different present speeds is discussed in [14].

Alternating Turing Machine (ATM) is a generalization of Turing Machine which in a specified state may choose more than one on-going state and each state labelled by a universal or existential quantifier. In this article we focus on ATM in the context of AGC. Hence, an algorithm is introduced to simulate ATM in SM model directly. The idea is to set up a scaffold to start copy of the branches of ATM: when the copy initialization ends the computation starts to freezing to the right and left, then the pre-set unfreeze signal restarts the computation at both sides. Finally, when all the computations end, final results send to the result collector signal that is the answer of ATM.

Section 2 provides backgrounds and the formal definitions of SM, configuration, space-time diagram, SM techniques, TM and ATM. The copy initialization process, unfreezing, recovery, scaling of the computation, the process of collecting the results and time and space complexities are provided in section 3. Article ends by conclusion and future works in section 4.

2 Backgrounds

According to the continuous feature of signal machines they can compute and simulate CA computations and even more complex computations that CA can not afford like semi-decidable problems. SMs are kind of collision based computing where particle colliders are signals, collision rules run the collisions and therefore guide the computations.

2.1 Definitions

Definition 1

(Signal Machine) A Signal Machine (SM) is composed of three parts (M, S, R) where M defines a finite set of meta-signals, S is a mapping from M to which defines the speed of each meta-signal, and, R is a function from the subset of M (at least two meta-signals) into a subset of M which defines the collision rules of signals.

Signals are instances of meta-signals and there may be many signals in an initial configuration but the number of signals is finite. Signals have constant speeds and the collision rules determine what happens when two or more signals collide. A collision happens by at least two signals. Each rule is defined as a pair of (input meta-signals, output meta-signals). If there is not a rule for a collision, signals continue their way exactly as before of the collision. Time and space are continuous and the moving particles are dimensionless.

Definition 2

(Configuration) A Configuration (c) is a function maps (for rational machines) and (for real machines) to (Meta-signals and Rules) such that the set of all possible particles is finite i.e., all signals and collisions are isolated.

Definition 2 illustrates that there is a maximum countable number of signals and collisions. In fact we have a infinitive space that just a finite part of it is used to form a configuration. If we assume each mapping of the mentioned function is a line, we are talking about a one dimensional space.

Definition 3

(Space-Time Diagram) A space-time diagram is made of the exact choices that repeatedly performed by the machine. In each time step, a new configuration is added to the last one and the space time diagram evolves repeatedly. Time is always upward and the space is either positive or negative [13].

Figure 1: Space-time diagram with a simple example

Figure 1 shows a simple example of space-time diagram on the left, meta-signals and collision rules on the right. As we see the time scale is and the space scale is . Signal a starts in a negative real number position. There is four meta-signals and one sample of each one on the space-time diagram; signals a, d of speed 1, signal b of speed -1 and signal c of speed 0. when a collides b, according to the first collision rule signal d produces until it collides c, in this location by collision of d and c according to the second collision rule nothing produces, i.e., the collision is a void collision.

2.2 Turing Machine and Signal Machine

Turing Machine (TM) is one of the abstract classical models of computation which temporary stores the inputs on a tape. Addition to the tape, TM is defined by a set of states, a finite set of symbols, transition function and the head. The tape is made of cells, each cell is capable of holding just one symbol of the defined alphabet. The read-write head traverses the tape and in every step reads the cell symbol, according to it’s transition function writes the exchange and goes to the left or right.

Officially, a TM is defined by TM = (, , , , #, ) where Q is a finite set of states, is the initial state, is a finite set of symbols, is the head, # is blank symbol and is the transition function. Here we are not going to have a detailed study on TMs, the reader is referred to [15].

As showed in [2] the model of Signal Machine has the power of Turing-Computation. The Turing-Computation power of signal machine is proved by simulating any two-counter automaton. Therefore signal machine is a model of computation has at least Turing-Computing capability.

The simulation of different types of TM is presented in [10, 11, 13, 16]. The simulation of ordinary TM is as follows: some signals of speed zero encode the symbols on the tape and a signal of non-zero speed guides the left-right movements of the head, defining the state of machine [10].

Figure 2 shows the simulation of TM in SM. Left shows the transitions of TM on the tape and right shows the SM equivalent simulation. Signal is the initial state of TM. One can guess the collision rules easily from Figure 2. Signals x and y provide the possibility of tape extension. Head signals (q) have speed 1 (left to right) and -1 (right to left). Signal # shows the blank symbol or border of computation. The final result (final state of TM), , diffuses to the left of computation.

Figure 2: Ordinary TM computation (a) TM transitions (b) Equivalent SM

2.3 Signal Machine Techniques

In this part we introduce some useful techniques of SM introduced before in the literature. The idea of our algorithm is based on these techniques and we use them to set up a structure to simulate ATM in SM. These techniques include computing the middle of any computation, freezing and unfreezing of a computation and scaling of computation. However we will change and modify these techniques to gain our objectives later.

Middle of Computation

Proposition 1

(Middle of Computation) Middle of a computation can be easily computed by propagating three signals, two with the same absolute values of speeds (3x and -3x) and the third with 1/3 speed of the other two, i.e., 1x.

Figure 3: Computing the middle

The computation of the middle is some times necessary, e.g,. in [7] the middle indefinitely computed to shape a scaffold for solving SAT problem. Figure 3 shows the details of computing the middle of any computation. Meta signals, speeds, collision rules and initial configuration are listed on the right. At the beginning, four signals shape the initial configuration then according to the collision rules the middle of computation will be marked by Middle signal. Obviously, location of Middle is , exactly the middle of computation.

Freezing and Unfreezing

Proposition 2

(Freezing/Unfreezing) By adding a new meta-signal, f, with a speed greater than any present one it is possible to redirect the computation signals so that by occurring a collision between f and any computation signal, say c, f is reproduced and c is replaced by a constant speed signal. Unfreezing is the opposite [16].

Figure 4 illustrates the freezing/unfreezing operation. The speed of freezer is greater than all computation signals and the speed of the frozen signals (the area between the parallel dark red lines) is less than freezer speed. Depending on the speed of freezer it is possible to conduct the computation to the left (positive speed) or right (negative speed). As collisions are just simply points, they will be frozen and unfrozen by freezer and unfreezer signals respectively. The computation goes ahead normally above the unfreezer. The freezing and freezer signals have to be parallel to accurately recall the computation after freezing. Translation part shows the frozen parallel signals (Figure 4), colliding to the unfreezer the computation restarts, in fact the translation area is a delay to stop the computation for a special purpose like conduct the computation signals.

Figure 4: Freezing/Unfreezing operation

Scaling the Computation

Proposition 3

(Scaling the Computation) A frozen computation can be redirected and therefore scaled according to this idea that the unfreezing signal has a smaller speed [16].

Figure 5: Scaling operation

Figure 5 shows scaling operation of any computation: up-going computation is redirected twice to gain a scaled computation. Signal a freezes the computation by directing it to the left for the first time, signal b redirects the computation and signal c recovers the scaled computation.

In the contraction area the computation signals will be frozen and ready to be contracted to gain an optionally scaled computation depending on speed of signal b. Signal c unfreezes the contracted signals as usual and the rest of the computation, scaled down, goes ahead above signal c.

After these preliminaries, in the coming sections we introduce the TMs, ATMs and related simulations.

2.4 Alternating Turing Machine

Alternating Turing Machine (ATM) is a Non-Deterministic TM, introduced by Chandra and Stockmeyer [17] and Kozen [18] in 1976. In 1981 in an article named Alternation [19] they, together, made a comprehensive introduction to ATM.

An ATM is defined exactly as TM but with two extra special states, denoted by and . In state machine accepts the input if and only if at least one of the successors accepts. In state the machine accepts the input if and only if all of the successors accept.

Figure 6 shows a schematic example of an ATM. In the configuration tree each node is labeled with a possible configuration of the machine. Each edge is a transition from machine’s current configuration to the reachable ones. Since the final result is given when the root’s computation finishes, and the root’s computation depends on it’s descendants and so on, the final result is determined recursively. ATM accepts the computation on a specified input if and only if the root of the computation tree is accepted.

Figure 6: Computation tree of an ATM

It is obvious a non-deterministic turing machine is an ATM with only states. In a configuration with only one child the node accepts if and only if its child accepts. In Figure 6, accepts if and only if one of the five paths to the terminal nodes (leaves) is acceptable.

Before addressing the algorithm, we need to know the states and transition table of our ATM. Figure 7 shows the transition state of an ATM that decides a boolean string if having zeros divisible by two and three. The numbers inside the circles indicate the names of states; 1 for and so on. and are the final states: if ATM stops on both of these two states the final answer is Yes and the number of zeros of the string is divisible by two and three. For example strings 1011000100 and 000000 are acceptable and strings 0110011 and 0000000 are not acceptable by this machine.

Figure 7: State transition of ATM for two and three divisible number of zeros
: { , } #
, ,,
, , , , , #,
, , , , , #,
, , ,, ,#,
,, , , ,#,
,, ,, , #,
,, , , , ,
, , , , , ,
, , , , , ,
, , , , , ,
Table 1: Transition table of ATM with two final states and

As Figure 7 shows the upper and the lower branches compute divisibility by two and three respectively. Machine starts in an initial configuration, at first because zero is divisible by two and three, both branches are in final states and . By reading each cells content if it was zero machine changes it’s state. Notice that the quantifier of where the computation branches is universal, means both branches must return Yes value for a string to be accepted.

Table 1 shows the transition function of Figure 7. When the machine encounters the # sign at the end of the string, decides it, if it was in states or returns and respectively, otherwise it returns and respectively.

Now we are ready to represent the simulation of ATM in SM. To do this, as in ordinary TM we start normally until the machine needs to branch or copy itself. The algorithm is given step by step in the next coming sections.

3 Simulation of ATM by SM

The main issue of simulation is to manage the copies or branches of ATM. At first we handle the copy initialization to reach the pre-defined on-going states by a presented structure. After that when whole computation freezes to the desired directions, unfreezing operation starts by adding two special unfreezer signals added to the right and left of the computation (proposition 2). The freezing/unfreezing operation, here, is different because of the intrinsic complexity of the structure. Unfreezing makes the branches restart their computations. Final answer of ATM is given by a signal called result collector where retrieves the results of each computation.

Coming subsections present the mentioned steps in details; subsections 3.1 - 3.5 respectively provide the copy initialization, computation recovery, collecting the results, the whole simulation and finally the complexity of the algorithm.

3.1 Computation Copy Initializing

The middle of computation can be simply computed (Proposition 1). Computing the middle helps to freeze/unfreeze the computation accurately. Suppose the machine needs to be copied when the head of machine is on a cell in the middle of computation; as we will see later for orderly freeze/unfreeze signals it is necessary to start from a corner, hence the middle helps to do this accurately.

There should be a structure to initialize the copy operation when it is time to copy the configuration, i.e., machine is in a state that needs to branch. Figure 8 provides such a structure. The structure is different from an ordinary copy (in fact freeze) structure.

Figure 8: Structure of copy

The copy structure, as in Figure 8, the first action is to compute the middle; this is done by sending M1 and M2

signals from the left. Notice that these two signals as they may be needed in any moment must have the highest speed between the rest of signals. Signal

a from both sides is the boundary of computation.

Suppose at the beginning copy operation should be initialized e.g., the second row of Table 1 for . Signal CI is sent as Copy Initiator; when it collides the Middle, MR and ML are sent with opposite equal speeds to the right and left of the computation respectively. MR and ML reach to the boundaries simultaneously as the amount of their speed is equal (but opposite) and they sent from the middle of computation (see Figure 8).

When MR and ML collide the boundaries, Toggle Left and Toggle Right are generated again with opposite equal speeds. These signals are supposed to freeze the computation to the left and right respectively. Tha reason of intentionally conversion of signal Middle to RC, meaning Result Collector, will be noticed soon.

Toggle signals act as a mirror to reflect coming signals to the desired directions. Let us divide the configuration into three parts: the part (signal Middle), the part which is from signal Middle to the right boundary (signal a) and the part which is from signal Middle to the left boundary (signal a). These three parts should freeze to both left and right sides. The important tip here is every signal has to be frozen two times, so when a signal meets the first Toggle, freezes to the left (or right) and it has to be continued to be frozen by the second Toggle. This is true for and parts.

Figure 9 shows the described freezing operation. The and possible signals showed by Gray and dark Red respectively. Focus on the part of configuration; when signals collide the first Toggle which is Toggle Right, the color of signals changes to be continued (copied) and the signals freeze to the right. When the continued signals collide the second Toggle which is Toggle Left, they only freeze to the left. Freezing operation of the part is the same as the part but by opposite speeds.

Figure 9: Freezing the configuration to the left and right

Notice that signals Toggle Right and Toggle left reach the at the same time and Middle directly freezes to both sides when it collides them both; in fact has no need to be copied. About the boundary signal a, freezes and continues at the same time with generation of the first toggle in both sides.

3.2 Unfreezing, Computation Recovery and Scaling

After freezing configuration to the both sides it is time to recover it. For this purpose we need four signals, three for locating a point to send the forth signal and recover the configuration. The first three signals must have a speed more than any configuration signal, to be able to collect all frozen signals and no signal left because of low speed. Figure 10 shows such a structure.

Figure 10: The process of recovery and scale for right frozen configuration

According to Figure 10 signals Rec1, Rec2, Rec3 and final recovering signal named Recall are used to recover the configuration. As mentioned before, if point , that is the recovering start point, be higher than the first frozen signal a because of low speed, then a is not recoverable. Signal Racall starts to unfreeze any frozen signal encounters from point and by colliding the second boundary, a, disappears.

Signals Rec1 and Rec2 are sent from point , that is exactly the same point that MR and ML were sent to generate Toggle signals. In fact the recovery operation has been started at the same time that Toggle’s were going to generate. Thus we can be sure the frozen signals are recoverable. It is worth mentioning that the recovery operation does not affect/conflict the freezing operation; the reason is that the speed of recovering signals is a little more than the freezing related ones.

Scaling the configuration (shrink or even stretch) is done when we recover the frozen signals by Recall. The more speed of Recall, the higher is scaling and the narrower is new configuration, i.e., the configuration shrinks more. In Figure 10 right configuration scaled by about 3/4 of origin configuration, as well as for the left configuration.

Taken together, when CI collides Middle, seven signals generate: one for continuing Middle as RC, two for generating Toggle Left and Toggle Right, two for finding location of point to generate Recall and two for generating left counterpart of . Signal CI-R is the continuation of computations were in the origin configuration, now transferred to the right to compute one of the branches. It has a counterpart, CI-L, will be mentioned in the next section.

3.3 Collecting the Results

In general the purpose of copying a configuration is to branch the computations and at the end collect the results of the branches to decide a certain problem. For this, two important questions should be taken into account: the first is that how to restart the computations? and the second is that how to collect the results of new configurations and retrieve the final answer of machine? In this section we discuss these two questions and offer the final operation giving the final result.

Signals CI-R and CI-L are representative of one of the states that machine wanted to go (Table 1). For example as it showed in Table 1 when the machine arrives to sign , wants to transit to states and ; therefore signals CI-R and CI-L can be continuation of or . Thus computation goes on with CI-R in the right computation and CI-L in the left computation. We at first know the copy initiator state (here ), thus when it is time to recover computations, in each branch we recover one of the desired states (here or ).

Figure 11: Collecting final results

Now we suppose all computations have reached their final states and have an answer to offer. To illustrate this consider the results, shown in Figure 11 which shows two computations gained their final results; the right side shows computation of the machine that restarted computing by and the left side shows the same with . Signal RC is the signal which generated instead of Middle. The collision between final result of left computation and RC generates RC1 to show that one of results retrieved, then RC1 collides the final result of right computation and RC2 generates as the final result of all computations which is the answer of machine for an input string. If machine accepts the string the answer is Yes and if rejects the string the answer is No.

Note that Figure 11 shows only one step of collecting operation. Left and right computations may have sub-branches that will be hierarchically collected to offer the final answer.

3.4 ATM and SM

In this section we discuss the aforementioned scaffolds on an ATM. Figure 7 and Table 1 are the state transition and transition table of an ATM respectively. As mentioned in section 2.2 this ATM decides a boolean string having the number of zeros divisible by both two and three.

Figure 12 shows the simulating of an ATM in SM that decides input 000000 having the number of zeros divisible by two and three; the final answer of this computation is Yes. For convenient eight points in Figure 12 highlighted to show the simulation steps. At first we should find the middle of computation; this is done in point . The point is where a signal send to collide Middle and start the copy operation; after this collision in point , seven signals generate. The points and generated to restrain frozen signals by sending a recovering signal. In points and the location of the head, i.e., the possible states are recovered.

Point is a strategic point for collecting the final results, when we used Middle to freeze the configuration then there is no need for it to be continued. But we need an extra signal to collect the coming results, so we replace Middle with a special signal, All-M1-2, which shows the origin configuration () has a universal quantifier, waiting for it’s answers.

Figure 12: Corresponding SM of the ATM with input 000000 and final answer Yes

We use a standard to determine this kind of signal’s names for transparency. This standard has three parts: first part determines the quantifier type, second part defines which sub-machine demanded for copy and third part defines the number of copies. Therefore All-M1-2 reveals sub-machine with a universal quantifier is waiting for it’s two pending results.

When the illustrated machine in Figure 12 retrieves first result from the left, the collector signal All-M1-2 transits to All-M1-a1 to signal retrieving the first result, at last by retrieving the last result from right transits to All-M1-a2 and returns the final answer Yes for the specified string 000000.

3.5 Complexity

Space-time diagram can be viewed as a network consisting of a Directed Acyclic Graph (DAG) with nodes (collisions) and links (signals). Therefore time complexity is defined as longest path or maximal number of sequence of collisions in the network and called collisions depth. Accordingly space complexity is the number of pairwise un-related signals [7].

For ordinary TM the space complexity is : two meta-signal for every state that goes to the left and right of the computation, signals for encoding the tape symbols and five signals to handle the tape enlargement i.e. signals x, y, z, z’ and #. z’ is counterpart of z that is not shown in Figure 2. Therefore the space complexity is . Because one collision happens in each time step regardless of the enlargement collisions, time complexity of TM is linear i.e. .

Considering Figure 6, the tree of computation which each node is a computation on its own could branch to at most where d is the depth of computation tree. Space complexity of ATM is . Time complexity of ATM, maximal sequential collisions, is linear as same as ordinary TM: . Depth of computation, d, depends on number of branches which depends on special states. If there be m special states like in Table 1, each of which branch to k branches, then d = m + 1 and the computation tree has leaves should be considered in the complexities.

4 Conclusion and future works

We show how to simulate ATM in the context of AGC using characteristics of this geometrical model of computation (SM). Manipulation of the SM techniques allows making a structure to perform the proceedings of ATM. The simulation goes by applying modified techniques to shape the desired structure. All simulation steps is presented as an algorithm.

The time and space complexity of our algorithm is calculated according to the ordinary TM. As all branches perform the computations simultaneously, regardless a bit of delay of copy operation, the time complexity of ATM is the same as ordinary TM. Space complexity of simulated ATM is depending on, d, the depth of computation tree e.g., it is exponential order of d.

Finding a better equivalent SM to an ATM is an effort we do not know about it yet. There may be better SMs for simulating ATMs. Two dimensional (2D) simulating as in CA and SM has its own limitations compelling the simulation to the more complex situation. Three dimensional (3D) simulations may provide faster results and it is worth of consideration. Therefore testing and simulating of many problems including types of TMs may be considered in future researches.


  • [1] Durand-Lose, Jérôme. Calculer géométriquement sur le plan-machines à signaux. Ph.D. disseration, Université Nice Sophia Antipolis, 2003.
  • [2] Durand-Lose, Jérôme. Abstract geometrical computation: Turing-computing ability and undecidability. In New Computational Paradigms, pp. 106–116. Springer, 2005.
  • [3] Durand-Lose, Jérôme. Abstract geometrical computation for black hole computation. In Machines, computations, and universality, pp. 176–187. Springer, 2004.
  • [4] Durand-Lose, Jérôme. Abstract geometrical computation 1: embedding black hole computations with rational numbers. Fundamenta Informaticae, 74(4):491–510, 2006.
  • [5] Duchier, Denys, Durand-Lose, Jérôme, and Senot, Maxime. Fractal parallelism: Solving sat in bounded space and time. In Algorithms and Computation, pp. 279–290. Springer, 2010.
  • [6] Duchier, Denys, Durand-Lose, Jérôme, and Senot, Maxime. Massively parallel automata in euclidean space-time. In Self-Adaptive and Self-Organizing Systems Workshop (SASOW), 2010 Fourth IEEE International Conference on, pp. 104–109. IEEE, 2010.
  • [7] Duchier, Denys, Durand-Lose, Jérôme, and Senot, Maxime. Computing in the fractal cloud: modular generic solvers for sat and q-sat variants. In Theory and Applications of Models of Computation, pp. 435–447. Springer, 2012.
  • [8] Baiocchi, Claudio. Three small universal turing machines. In Machines, Computations, and Universality, pp. 1–10. Springer, 2001.
  • [9] Kudlek, Manfred. Small deterministic turing machines. Theoretical Computer Science, 168(2):241–255, 1996.
  • [10] Durand-Lose, Jérôme. Abstract geometrical computation 4: small turing universal signal machines. Theoretical Computer Science, 412(1):57–67, 2011.
  • [11] Durand-Lose, Jérôme. Abstract geometrical computation 5: embedding computable analysis. Natural Computing, 10(4):1261–1273, 2011.
  • [12] Durand-Lose, Jerome. Abstract geometrical computation 6: a reversible, conservative and rational based model for black hole computation. International Journal of Unconventional Computing, 8(1):33–46, 2012.
  • [13] Durand-Lose, Jérôme. Abstract geometrical computation 7: geometrical accumulations and computably enumerable real numbers. Natural Computing, 11(4):609–622, 2012.
  • [14] Becker, Florent, Chapelle, Mathieu, Durand-Lose, Jérôme, Levorato, Vincent, and Senot, Maxime. Abstract geometrical computation 8: Small machines, accumulations and rationality. arXiv preprint arXiv:1307.6468, 2013.
  • [15] Linz, Peter. An introduction to formal languages and automata. Jones & Bartlett Publishers, 2011.
  • [16] Durand-Lose, Jérôme. Abstract geometrical computation 3: Black holes for classical and analog computing. Natural computing, 8(3):455–472, 2009.
  • [17] Chandra, Ashok K and Stockmeyer, Larry J. Alternation. In Foundations of Computer Science, 1976., 17th Annual Symposium on, pp. 98–108. IEEE, 1976.
  • [18] Kozen, Dexter. On parallelism in turing machines. In Foundations of Computer Science, 1976., 17th Annual Symposium on, pp. 89–97. IEEE, 1976.
  • [19] Hopcroft, J, Chandra, Ashok K, Kozen, Dexter C, and Stockmeyer, Larry J. Alternation. J. Assoc. Comput. Mach., 28:114, 1981.