Particle Computation:Designing Worlds to Control Robot Swarms with only Global Signals

Particle Computation:
Designing Worlds to Control Robot Swarms with only Global Signals

Aaron Becker Department of Computer Science, Rice University, Houston, TX 77005,,    Erik D. Demaine Computer Science and Artificial Intelligence Laboratory, MIT, Cambridge, MA 02139, USA,    Sándor P. Fekete Dept. of Computer Science, TU Braunschweig, Mühlenpfordtstr. 23, 38106 Braunschweig, Germany,    James McLurkin

Micro- and nanorobots are often controlled by global input signals, such as an electromagnetic or gravitational field. These fields move each robot maximally until it hits a stationary obstacle or another stationary robot. This paper investigates 2D motion-planning complexity for large swarms of simple mobile robots (such as bacteria, sensors, or smart building material).

In previous work we proved it is NP-hard to decide whether a given initial configuration can be transformed into a desired target configuration; in this paper we prove a stronger result: the problem of finding an optimal control sequence is PSPACE-complete. On the positive side, we show we can build useful systems by designing obstacles. We present a reconfigurable hardware platform and demonstrate how to form arbitrary permutations and build a compact absolute encoder. We then take the same platform and use dual-rail logic to build a universal logic gate that concurrently evaluates AND, NAND, NOR and OR operations. Using many of these gates and appropriate interconnects we can evaluate any logical expression.


I Introduction

Milli-, micro-, and nanorobots are capable of entering environments too small for their larger cousins. Swarms of these tiny robots may be ideal for targeted drug delivery, on-site micro construction, and minimally invasive surgery. An untethered swarm could reach areas deep in the body that traditional, robots and tooling cannot. These swarms are often controlled by an external, global electromagnetic field [1, 2, 3]. Motion planning for large robotic populations actuated by the same field in a tortuous environment is difficult.

We investigate the following basic problem: Given a map of an environment, such as the vascular network shown in Fig. 1, along with initial and goal positions for each robot, does there exist a sequence of inputs that will bring each robot to its goal position? In previous work [4], it was shown that this problem is at least NP-hard, by reduction to a 3SAT problem. In this paper we improve the analysis and show the problem is PSPACE-complete. This complexity result has some benefits: we show that we can design artificial environments capable of computation, and describe configurations of obstacles that result in useful robotic systems: absolute encoders, Boolean logic as shown in Fig. 2, and planar displays.


Ginheight=2.75in\OVP@calc \setkeysGinheight=2.75in, angle = 0\OVP@calc

Fig. 1: (Left) State of the art in controlling small objects by force fields: after feeding iron particles to T. pyriformis cells and magnetizing the particles with a permanent magnet, the cells are mobile robots that can be turned by changing the orientation of an external magnetic field [5]. All cells are steered by the same global field. (Right) A complex vascular network, forming a typical environment for the parallel control of small robots. Given such a network along with initial and goal positions of robots, is it possible to bring each robot to its goal position using a global control signal?                                                                                                                                    (Right image credit: Royce Bair/Flikr/Getty Images)

Ginwidth =\OVP@calc

Fig. 2: Schematic, diagram, and physical implementation of dual-rail logic gates. Each gate employs the same clock sequence , the four inputs correspond to , and the inputs are [1,1]. The top row is a universal logic gate whose four outputs are and, nand, or, nor. With input [1,1] the and and or outputs are set high. The middle row gate outputs the xor, xnor of the inputs and constants 1 and 0. The bottom row is a not gate and a connector. See the attached video at for a hardware demonstration.

We study this problem on a two-dimensional grid. We assume that robots cannot be individually controlled, but are all simultaneously given a message to travel in a given direction until they collide with an obstacle or another robot. This assumption corresponds to situations with limited-state feedback, or for robots that move at unpredictable speeds. Problems of this type are similar to sliding-block puzzles with fixed obstacles [6, 7, 8, 9], except that all robots receive the same control inputs.

I-a Problem Definition

More precisely, we consider the following scenario, which we call GlobalControl-ManyRobots:

  1. Initially, the planar square grid is filled with some unit-square robots (each occupying one cell of the grid) and some fixed unit-square blocks.

  2. All robots are commanded in unison: the valid commands are “Go Up” (), “Go Right” (), “Go Down” (), or “Go Left” (). The robots all move in the commanded direction until they hit an obstacle or another robot. A representative command sequence is . We call these global commands force-field moves. We assume we know the maximum dimension of the workspace and issue each command long enough for the robots to reach their maximum extent.

  3. The goal is to get each robot to its specified position.

The algorithmic decision problem GlobalControl-ManyRobots is to decide whether a given configuration is solvable. This problem is computationally difficult: we prove PSPACE-completeness in Section IV. While this result shows the richness of our model (despite the limited control over the individual parts), it also constitutes a major impediment for constructive algorithmic work.

This makes developing algorithmic tools that enable global control by uniform commands important. In Sections III and V, we develop several positive results. The underlying idea is to construct artificial obstacles (such as walls) that allow arbitrary rearrangements of a given two-dimensional robot swarm.

Our paper is organized as follows. After a discussion of related work in Section II, we describe how to arrange obstacles to encode matrix permutations in Section III. This result allows us to create useful devices including absolute encoders and matrix displays. Arbitrary matrix permutations also provides the machinery needed for our result on the problem complexity in Section IV. In Section V we describe how to implement Boolean algebra, which is enabled by using dual-rail logic. We present our hardware implementation for both matrix permutations and Boolean algebra in Section VI, and end with concluding remarks in Section VII. All code is available online [10, 11].

Ii Related Work

One recent development is the ability to design, produce, and control robots at the micro and nanoscale. These mobile robots allow a wide range of possible applications, e.g., targeted drug delivery, micro and nanoscale construction, and Lab-on-a-Chip test devices. Because (1) the physics of motion at low Reynold’s number nanoscale environments requires overcoming a considerable amount of resistance, and (2) capacity to store energy for computation, communication and motion control shrinks with the third power of object size, it is clear that classical approaches based on individual motion control cannot be applied.

Instead of individual actuation, a global field is used to control many small agents. An example is using the global magnetic field from an MRI to guide magneto-tactic bacteria through a vascular network to deliver payloads at specific locations [1], and recent work using electromagnets to steer a magneto-tactic bacterium through a micro-fabricated maze [2].

Ii-1 Large Robot Populations

Due to the efforts of roboticists, biologists, and chemists (e.g. [12, 13, 14]), it is now possible to make and field very large () populations of simple robots. With large populations come two fundamental challenges: (1) how to perform state estimation for the robots, and (2) how to control these robots.

Traditional approaches often assume independent control signals for each robot, but each additional independent signal requires bandwidth and engineering. These bandwidth requirements grow at . Using independent signals becomes more challenging as the robot size decreases. At the molecular scale, there is a bounded number of modifications that can be made. Especially at the micro- and nanoscales it is not practical to encode autonomy in the robots. Instead, the robots are controlled and interacted with using global control signals.

More recently, robots have been constructed with physical heterogeneity so that they respond differently to a global, broadcast control signal. Examples include scratch-drive microrobots, actuated and controlled by a DC voltage signal from a substrate [15]; magnetic structures with different cross-sections that could be independently steered [16]; MagMite micro-robots with different resonant frequencies and a global magnetic field [17]; and magnetically controlled nanoscale helical screws constructed to stop movement at different cutoff frequencies of a global magnetic field [18].

This paper takes a different approach. We assume a population of approximately identical planar robots (which could be small particles) and one global control signal that contains the direction all robots should move. In an open environment, this system is not controllable because the robots move uniformly—implementing any control signal translates the entire group identically. However, an obstacle-filled workspace allows us to break symmetry. We showed that if we can command the robots to move one unit distance at a time, some goal configurations have easy solutions [19]. Given a large free space, we have an algorithm showing that a single obstacle is sufficient for position control of robots (video of position control: However, this result required incremental position control of the group of robots, i.e. the ability to advance them a uniform fixed distance. This is a strong assumption, and one that we relax in this work.

Ii-2 Computational Particles

Amorphous computing [20] studies how computational particles distributed on a surface can be used to produce computational engines. In a similar manner, we show how to construct logic gates to perform computation in our system, when activated by a global signal.

Another related area of research is Single Instruction Multiple Data (SIMD) parallel algorithms [21]. In this model, multiple processors are all fed the same instructions to execute, but they do so on different data. This model has some flexibility, for example allowing command execution selectively only on certain processors and no operations (NOPs) on the remaining processors.

Our model is actually more extreme: the robots all respond in effectively the same way to the same instruction. The only difference is their location, and which obstacles or robots will thus block them. In some sense, our model is essentially Single Instruction, Single Data, Multiple Location.

Ii-3 Computational Geometry: Robot Box-Pushing

Many variations of block-pushing puzzles have been explored from a computational complexity viewpoint, with a seminal paper proving NP-hardness by Gordon Wilfong in 1991 [22]. The general case of motion-planning when each command moves robots a single unit in a world composed of even a single robot and both fixed and moveable squares is in the complexity class PSPACE-complete [23].

The “move to maximal extent” motion model we employ is motivated by physical realities where, due to uncertainties in sensing, control application, and robot models, precise quantified movements in a specified direction is not possible, but the input can be applied for a long period of time and be guaranteed that the robots will move to their fullest extent. Lewis uses this model to reduce uncertainty in state estimation[24]. Maximal extent movement is common in games, including Ricochet Robots [25], Atomix [9], and PushPush [6]. In these games the robots move to their full extent with each input, but each robot can be actuated individually. The complexity of the problem with global inputs to all robots has remained an open problem.

Iii Matrix Permutations

This section investigates a construction problem. Given the GlobalControl-ManyRobots constraints in I-A, what types of control are possible and economical if we are free to design the environment?

First, we describe an arrangement of obstacles that implement an arbitrary matrix permutation in four commands. Then we provide efficient algorithms for sorting matrices, and finish with potential applications.

Iii-a Designing Workspace for a Single Permutation

A matrix is a 2D array of robots (each possibly a different color). For an matrix and a matrix , of equal total size , a matrix permutation assigns each element in a unique position in . Figs. 3 and 4 show constructions that execute matrix permutations of size and , respectively. For simplicity of exposition, we assume henceforth that all matrices are squares.


Fig. 3: (Top) Matrix permutation for =15. Black cells are obstacles, white cells are free, and colored discs are individual robots. The world has been designed to permute the robots between ‘A’ into ‘b’ every four steps: . (1) The staggered obstacles on the left spread the matrix vertically, (2) the scattered obstacles on the right permute each element, and (3) the staggered obstacles along the bottom reform each row, which are collected by (4). (bottom) Hardware demonstration of a reconfigurable, gravity-fed manipulator that can rearrange (permute) arrays of colored spheres. The demonstration converts ‘A’ to ‘b’, but can be reprogrammed by switching the black stoppers to enable any array permutation. See video at
Theorem 1

Any matrix permutation can be executed by a set of obstacles that transforms matrix into matrix in just four moves. For robots, the arrangement requires space, obstacles, and time, where is robot speed in units/s.


Refer to Figure 3 for an example. Matlab code implementing this is available at [11]. The move sequence is . We identify the bottom left workspace square as (0,0), place the bottom-left robot at (1,1), and label the starting configuration from 1 to bottom-to-top, left-to-right. We also assign these indices to the corresponding entries in .

(Move 1) for to , place an obstacle at (): We place obstacles, one for each column, spaced vertically units apart, such that moving spreads the robot array into a staggered vertical line. Each robot now has its own row, and are arranged index to from bottom to top.

(Move 2) for to , let be the row and column for robot in . Place an obstacle at (): We place obstacles to stop each robot during the move . Each robot has its own row and can be stopped at any column by its obstacle. We leave an empty column between each obstacle to prevent collisions during the next move.

(Move 3) for to , place an obstacle at :. Moving arranges the robots into their desired rows. These rows are spread in a staggered horizontal line.

(Move 4) for to , place an obstacle at : Moving stacks the staggered rows into the desired permutation, and returns the array to the initial position.

By reapplying the same permutation enough times, we can return to the original configuration. The permutation shown in Fig. 3 returns to the original image in 2 cycles. For a two-color image, we can always construct a permutation that resets in 2 cycles. We construct an involution, a function that is its own inverse, using cycles of length two that transpose two robots. This technique does not extend to images with more than two colors.

Iii-B Physical Absolute Encoders and Animations

As shown in Fig. 3, a permutation gadget allows us to design a display that is hard-coded with a set of pictures. A potential practical application uses these permutations as a physical absolute encoder or as a pseudo-random number generator. In an absolute encoder the current arrangement of robots serves as a unique representation of how many rotations have taken place. These applications exploit the fact that these physical permutations are cyclic, and that we can design the cycle length. Applying the CW circular movements in succession moves all the robots through one permutation.

The cycle length is the least common multiple of the permutation cycles in the transformation . Given robots, we want to partition the set of permutation cycles in such a way that the sum and maximizes .

This cycle length grows rapidly. For instance, using robots, we can partition the robots into cycles of length {2, 3, 5, 7, 11, 13, 17, 19, 23}, see Fig. LABEL:fig:MatrixPermuteEncoder. The is 223,092,870. See [26] for a more in-depth look at the growth of the maximum cycle length as a function of .





Fig. 4: (a) Using a permutation gadget as an absolute encoder. Cycle length increases rapidly as the number of robots increases, and the current arrangement of robots uniquely represents how many rotations have taken place. (b) An obstacle arrangement to permute a 1010 matrix in four moves , with a cycle length over 200 million. The first 6 permutations are shown at left with each cycle a different color.

Iii-B1 Animations

It would be useful if we could design permutations to generate sequences of images, e.g. “R”, “o”, “b”, “o”, “t”. Surprisingly, there are sequences of just three images that cannot be constructed with a single permutation. Consider the three 5-robot arrangements , , . Though permutations between any two exist, there is no single permutation that can generate all three. In fact, no single permutation can generate all possible permutations of the given robots. For the example in Fig. LABEL:fig:MatrixPermuteEncoder, with 100 robots, 9 painted black and the rest white, the maximum cycle length we can generate is of length , but for permutations of length with repeated elements , the total number of permutations is

For the example above, there are permutations possible.

Iii-B2 Reversible Permutations

The permutations generators shown in Fig. LABEL:fig:MatrixPermuteEncoder are one-way devices. Attempting to drive them in reverse allows some robots to escape the obstacle region. It is possible to insert additional obstacles to encode an arbitrary permutation when run in reverse, at a cost of additional obstacles and requiring an area in worst case rather than . An example is shown in Fig. 5. Here, we encode the base permutation in the CW direction and in the CCW direction . Repeated application of these two base permutations can generate any permutation, when used in a manner similar to Bubble Sort.



Fig. 5: The obstacles above generate the base permutation in the CW direction and in the CCW direction . These can be applied repeatedly to Bubble Sort the matrix and generate any desired permutation.

Iii-C Designing a Workspace for Arbitrary Permutations

There are various ways in which we can exploit Theorem 1 in order to generate larger sets of (or even all) possible permutations. There is a tradeoff between the number of introduced obstacles and the number of moves required for realizing a permutation. We quote these theorems from [4], as they will be used in our PSPACE-proof. We start with obstacle sets that require only a few moves.

Lemma 2

Any permutation of objects can be generated by the two base permutations and . Moreover, any permutation can be generated by a sequence of length at most that consists of and .


See Fig. 5. Similar to Bubble Sort, we use two nested loops of . Each move consists of performing once, and when appropriate.

This allows us to establish the following result.

Theorem 3

We can construct a set of obstacles such that any arrangement of pixels can be rearranged into any other arrangement of the same pixels, using at most force-field moves.

Iv Complexity

In previous work [4], we showed that the problem GlobalControl-ManyRobots is computationally intractable in a particular sense: given an initial configuration of movable robots and fixed obstacles, it is NP-hard to decide whether any robot can be moved to a specified location. It was left as an important open problem whether an even stronger hardness result applies. In the following, we resolve this problem by proving PSPACE-completeness.

Theorem 4

GlobalControl-ManyRobots is PSPACE-complete: given an initial configuration of (labeled) movable robots and fixed obstacles, it is PSPACE-complete to compute a shortest sequence of force-field moves to achieve another (labeled) configuration.


The proof is largely based on a complexity result by Jerrum [27], who considered the following problem: Given a permutation group, specified by a set of generators, and a single target permutation which is a member of the group, what is the shortest expression for the target permutation in terms of the generator? This problem was shown in [27] to be PSPACE-complete, even when the generator set consists of only two permutations, say, and .

As shown in the previous Section III, we can realize any matrix permutation of a square arrangement of robots by a set of obstacles, such that this permutation is carried out by a quadruple of force-field moves. We can combine the sets of obstacles for the two different permutations and , such that is realized by going through a clockwise sequence , while is realized by a counterclockwise sequence . We now argue that a target permutation of the matrix can be realized by a minimum-length sequence of force-field moves, if and only if can be decomposed into a sequence of a total of applications of permutations and , where .

The “if” part is easy: simply carry out the sequence of permutations, each realized by a (clockwise or counterclockwise) quadruple of force-field moves. For the “only if” part, suppose we have a shortest sequence of force-field moves to achieve permutation , and consider an arbitrary subsequence that starts from the base position in which the robots form a square arrangement in the lower left-hand corner. It is easy to see that a minimum-length sequence cannot contain two consecutive moves that are both horizontal or both vertical: these moves would have to be be in opposite directions, and we could shorten the sequence by omitting the first move. Furthermore, by construction of the obstacle set, the first move must be or . Now it is easy to check that the choice of the first move determines the next three ones: must be followed by ; similarly, must be followed by . Any other choice for moves 2–4 would produce a longer overall sequence, or destroy the matrix by leading to an arrangement from which no recovery to a square matrix is possible. Therefore, the overall sequence can be decomposed into clockwise or counterclockwise quadruples. As described, each of these quadruples represents either or , so can be decomposed into applications of permutations and . This completes the proof.

Note that the result also implies the existence of solutions of exponential length, which can occur with polynomial space. Binary counters are particular examples of such long sequences that are useful for many purposes.

V Particle Logic









Fig. 6: Variable gadgets that execute by a sequence of moves. The th choice sets the variable to true or false by putting the robot in a separate column. This selection move is shown in blue. Each gadget responds to the th choice but ignores all others, letting us make several copies of the same variable by making multiple gadgets with the same . Above =4, and the input causes to produce (true, false, true, false). Robots arrive at their output ports at exactly the same time.

In our previous work [4] we showed that with only fixed obstacles and robots that move maximally in response to an input, we can construct a variety of logic elements. These include variable gadgets that enable setting multiple copies of up to variables to be true or false, (Fig. 6), -input or, and and gates. Unfortunately, we cannot build not gates because our system of robots and obstacles is conservative—we cannot create a new robot at the output when no robot is supplied to the input. A not gate is necessary to construct a logically complete set of gates. To do this, we rely on a form of dual-rail logic, where both the state and inverse ( and ) of each signal are propagated throughout the computation. Dual-rail logic is often used in low-power electronics to increase the signal to noise ratio without increasing the voltage [28]. With dual-rail logic we can now construct the missing not gate, as shown in Figs. LABEL:fig:reversibleNOT and LABEL:fig:onewayNOT. The command sequence inverts the input. By adding one-way valves we can ignore any superfluous commands. Note that regardless of the command sequence, all robots arrive at their output ports at exactly the same time.










Ginwidth=\OVP@calcA=0,  B=0A=0,  B=1A=1,  B=0A=1,  B=1


Ginwidth=\OVP@calcA=0,  B=0A=0,  B=1A=1,  B=0A=1,  B=1

Fig. 7: Dual-rail gadgets using cycle .

We now revisit the or and and gates of [4] using dual-rail logic and the four inputs . Surprisingly, with the gate in Fig. LABEL:fig:ANDdiagram we can simultaneously compute and, nand, or and nor. using the same command sequence as the not gate. Outputs can be piped for further logic using the interconnections in Figs. LABEL:fig:reversibleConnect and LABEL:fig:onewayConnect. Unused outputs can be piped into a storage area and recycled for later use.

These gates are reminiscent of the Fredkin gate, a three-bit gate that swaps the last two bits if the first bit is 1 [29]. They are conservative, in that the number of input and output 1’s and 0’s are unchanged. They also form a universal set. Unlike the Fredkin gate, our gate is kinematic rather than dynamic, making it robust to noise and self-synchronizing – at the end of every move the robots are in a known state, and will not move until we apply another input. However, unlike the Fredkin gate, our and/nand/or/nor gate is not reversible.

Dual-rail devices open up new opportunities, including xor and xnor gates, which are not conservative using single-rail logic. This gate, shown in Fig. 2 also outputs a constant 1 and 0.

With an and and xor we can compactly construct a half-adder. We are hindered by an inability to construct a fan-out device that produces multiple copies of an input. Instead, we must take any logical expression and create multiple copies of each input. For example, a half-adder requires only one xor and one and gate, but our particle computation requires two A and two B inputs.

To make our gate robust to input sequences that deviate from , we can create caves that act as one-way valves, as shown in Figs. LABEL:fig:onewayNOT and LABEL:fig:onewayConnect. After an input, the robot is at the left end of a horizontal corridor. By placing a 1-unit cave at the rightmost end of the corridor we can latch the input—moving right inserts the robot into a cave that can only be exited by an input. Similarly, by placing a 1-unit cave above the leftmost end of the corridor, a input inserts the robot into a cave that can only be exited by an input.

Vi hardware demonstrations

Fig. 8 shows our scale prototype of a reconfigurable GlobalControl-ManyRobots environment, using 1.27 diam steel and nylon bearings as our robots and a naturally-occuring gravity field as the control field. The prototype is a 6161 cm square sheet of 2 cm thick medium-density fiberboard (MDF), with a lattice grid of hemispherical-profile, 1.27 cm grooves milled at 1.27 cm spacing in the and directions. At the intersection of each set of orthogonal grooves is a 4 mm diameter hole. We can then insert plastic-headed thumb screws with 1.27 cm diam heads (McMaster #91185A444) to serve as obstacles. The prototype is centered and glued on top of a 2020 cm square section of MDF. Pushing down on any top board edge tilts the entire prototype or , and the bearings roll until they hit an obstacle or another bearing. The companion video illustrates this prototype configured to create a permutation that converts ‘A’ to ‘b’ under the command sequence , also shown in Fig. 3.

We have also configured the prototype to generate the dual-rail universal Boolean gate in Fig. 2 and the logical interconnects of Fig. LABEL:fig:reversibleConnect, see the accompanying video. The long open paths in the permutation arrangement often lead to errors when bearings pop off their proper paths. The enclosed mazes of the logic gates are more reliable and we have not recorded any errors.



Fig. 8: Gravity-fed hardware implementation of GlobalControl-ManyRobots. Bottom left is a matrix permutation for changing ‘A’ to ‘b’, top left is a combination and, nand, or, nor gate, and top right is a not gate. See

Vii Conclusions

We analyzed the problem of steering many robots with uniform inputs in a 2d environment containing obstacles. We introduced dual-rail particle logic computation, and designed environments that can efficiently perform matrix operations on groups of robots in parallel—our matrix permutation requires only four moves for any number of robots. These matrix operations enabled us to prove the general motion planning problem PSPACE-complete.

There remain many interesting problems to solve. We are motivated by practical challenges in steering micro-robots through vascular networks, which are common in biology. Though some are two-dimensional, including the leaf example in Fig. 1 and endothelial networks on the surface of organs, many of these networks are three dimensional. Magnetically actuated systems are capable of providing 3D control inputs, but control design poses additional challenges.

The paper investigated a subset of control in which all robots move maximally. Future work should investigate more general motion—what happens to our complexity proof if we can move all the robots a discrete distance, or along an arbitrary curve? We also abstracted important practical constraints e.g., ferromagnetic objects tend to clump in a magnetic field, and most magnetic fields are not perfectly uniform.

Using dual-rail logic, we are limited to conservative logic. We cannot create new robots, so logic such as a multi-bit adder require exponentially increasing numbers of inputs. Generating fan-out gates seems to require additional flexibility in our problem definition, because conservation rules are violated. Some way of encoding an order of precedence is needed so that a reversible operation on robot can affect robot . Possible approaches use non-unit size components–either 21 robots, or 0.51 obstacles.

Finally, our research has potential applications in micro-construction and nano-assembly. These applications require additional theoretical analysis to model heterogeneous objects and objects that bond when forced together, e.g., MEMS components and molecular chains.


We acknowledge the helpful discussion and motivating experimental efforts with T. pyriformis cells by Yan Ou and Agung Julius at RPI and Paul Kim and MinJun Kim at Drexel University. Ricardo Marquez and Artie Shen assisted with photography and the hardware platform. This work was supported by the National Science Foundation under CPS-1035716.


  • [1] A. Chanu, O. Felfoul, G. Beaudoin, and S. Martel, “Adapting the clinical MRI software environment for real-time navigation of an endovascular untethered ferromagnetic bead for future endovascular interventions,” Magn Reson Med, vol. 59, no. 6, pp. 1287–1297, Jun. 2008.
  • [2] I. S. M. Khalil, M. P. Pichel, B. A. Reefman, O. S. Sukas, L. Abelmann, and S. Misra, “Control of magnetotactic bacterium in a micro-fabricated maze,” in IEEE International Conference on Robotics and Automation, Karlsruhe, Germany, May 2013, pp. 5488–5493.
  • [3] D. de Lanauze, O. Felfoul, J.-P. Turcot, M. Mohammadi, and S. Martel, “Three-dimensional remote aggregation and steering of magnetotactic bacteria microrobots for drug delivery applications,” The International Journal of Robotics Research, 11 2013. [Online]. Available:
  • [4] A. Becker, E. D. Demaine, S. P. Fekete, G. Habibi, and J. McLurkin, “Reconfiguring massive particle swarms with limited, global control,” in Algorithms for Sensor Systems, ser. Lecture Notes in Computer Science, P. Flocchini, J. Gao, E. Kranakis, and F. Meyer auf der Heide, Eds.   Springer Berlin Heidelberg, 2014, pp. 51–66. [Online]. Available:
  • [5] A. Becker, Y. Ou, and A. Julius, “Feedback control of many magnetized tetrahymena pyriformis cells by exploiting phase inhomogeneity,” in IEEE Int. Rob. and Sys., 2013.
  • [6] E. D. Demaine, M. L. Demaine, and J. O’Rourke, “PushPush and Push-1 are NP-hard in 2D,” in Proceedings of the 12th Annual Canadian Conference on Computational Geometry (CCCG),, Aug. 2000, pp. 211–219.
  • [7] M. Hoffmann, “Motion planning amidst movable square blocks: Push-* is NP-hard,” in Canadian Conference on Computational Geometry, Jun. 2000, pp. 205–210.
  • [8] R. A. Hearn and E. D. Demaine, “PSPACE-completeness of sliding-block puzzles and other problems through the nondeterministic constraint logic model of computation,” arXiv:cs/0205005, vol. cs.CC/0205005, 2002. [Online]. Available:
  • [9] M. Holzer and S. Schwoon, “Assembling molecules in ATOMIX is hard,” Theoretical Computer Science, vol. 313, no. 3, pp. 447–462, 2 2004. [Online]. Available:
  • [10] A. Becker. (2013, July) “Drive Magnetic Micro Robots through a 2D Vascular Network.” MATLAB Central File Exchange. [Online]. Available:
  • [11] ——. (2014, Feb.) “Particle Computation: Permute an array of particles with 4 global moves.” MATLAB Central File Exchange. [Online]. Available:
  • [12] M. Rubenstein, C. Ahler, and R. Nagpal, “Kilobot: A low cost scalable robot system for collective behaviors,” in IEEE Int. Conf. Rob. Aut., May 2012, pp. 3293–3298.
  • [13] Y. Ou, D. H. Kim, P. Kim, M. J. Kim, and A. A. Julius, “Motion control of magnetized tetrahymena pyriformis cells by magnetic field with model predictive control,” Int. J. Rob. Res., vol. 32, no. 1, pp. 129–139, Jan. 2013.
  • [14] P.-T. Chiang, J. Mielke, J. Godoy, J. M. Guerrero, L. B. Alemany, C. J. Villagómez, A. Saywell, L. Grill, and J. M. Tour, “Toward a light-driven motorized nanocar: Synthesis and initial imaging of single molecules,” ACS Nano, vol. 6, no. 1, pp. 592–597, Feb. 2011.
  • [15] B. R. Donald, C. G. Levey, I. Paprotny, and D. Rus, “Planning and control for microassembly of structures composed of stress-engineered MEMS microrobots,” The International Journal of Robotics Research, vol. 32, no. 2, pp. 218–246, 2013. [Online]. Available:
  • [16] S. Floyd, E. Diller, C. Pawashe, and M. Sitti, “Control methodologies for a heterogeneous group of untethered magnetic micro-robots,” Int. J. Robot. Res., vol. 30, no. 13, pp. 1553–1565, Nov. 2011.
  • [17] D. Frutiger, B. Kratochvil, K. Vollmers, and B. J. Nelson, “Magmites - wireless resonant magnetic microrobots,” in IEEE Int. Conf. Rob. Aut., Pasadena, CA, May 2008.
  • [18] K. E. Peyer, L. Zhang, and B. J. Nelson, “Bio-inspired magnetic swimming microrobots for biomedical applications,” Nanoscale, 2013.
  • [19] A. Becker, G. Habibi, J. Werfel, M. Rubenstein, and J. McLurkin, “Massive uniform manipulation: Controlling large populations of simple robots with a common input signal,” in IEEE Int. Rob. and Sys., Oct. 2013.
  • [20] H. Abelson, J. Beal, and G. J. Sussman, “Amorphous computing,” MIT, MA 02139 USA, Tech. Rep. MIT-CSAIL-TR-2007-030, Jun. 2007. [Online]. Available:
  • [21] F. T. Leighton, Introduction to Parallel Algorithms and Architectures: Arrays, Trees, Hypercubes.   Morgan Kaufmann, 1991.
  • [22] G. Wilfong, “Motion planning in the presence of movable obstacles,” Annals of Mathematics and Artificial Intelligence, vol. 3, no. 1, pp. 131–150, 1991.
  • [23] D. Dor and U. Zwick, “Sokoban and other motion planning problems,” Computational Geometry, vol. 13, no. 4, pp. 215–228, 1999.
  • [24] J. S. Lewis and J. M. O’Kane, “Planning for provably reliable navigation using an unreliable, nearly sensorless robot,” The International Journal of Robotics Research, vol. 32, no. 11, pp. 1342–1357, 2013. [Online]. Available:
  • [25] B. Engels and T. Kamphans, “On the complexity of Randolph’s robot game,” Rheinische Friedrich-Wilhelms-Universität Bonn Institut für Informatik I, University of Cologne, Germany, Tech. Rep., 2005.
  • [26] M. Deléglise and J.-L. Nicolas, “Maximal product of primes whose sum is bounded,” ArXiv e-prints, Jul. 2012.
  • [27] M. R. Jerrum, “The complexity of finding minimum-length generator sequences,” Theoretical Computer Science, vol. 36, pp. 265–289, 1985.
  • [28] R. Zimmermann and W. Fichtner, “Low-power logic styles: CMOS versus pass-transistor logic,” Solid-State Circuits, IEEE Journal of, vol. 32, no. 7, pp. 1079–1090, 1997.
  • [29] E. Fredkin and T. Toffoli, “Conservative logic,” International Journal of Theoretical Physics, vol. 21, no. 3-4, pp. 219–253, 1982. [Online]. Available:
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description