programmable-matter | Mohammad Moshtaghi

Self-Organizing Particle Systems (SOPS)

Fri, 17 Feb 2023 00:00:00 +0000

Self-Organizing Particle Systems (SOPS) is an abstraction of programmable matter, a substance with the ability to change its physical properties (shape, density, conductivity, etc.) in a programmable fashion. In order for programmable matter to live up to the dream of being an all-purpose "bucket of stuff" deployable for any task at any scale, we need a rich toolbox of algorithmic primitives upon which we can program more complex behaviors. Although the eventual vision is to control a whole mass of programmable matter as a single entity, our toolbox of primitives should be defined at the level of individual "atoms" of programmable matter to enable arbitrary scalability. Thus, we must take a distributed computing approach to defining micro-scale behaviors that collectively induce macro-scale phenomena.

Towards this goal, self-organizing particle systems abstractly envision programmable matter as an ensemble of tiny computational units called particles. These particles are assumed to be very simple: they have very limited memory, no sense of orientation or direction, and only local movement and communication capabilities. Our formal model for these particle systems is the amoebot model, which provides a theoretical framework for developing and analyzing our distributed algorithms for particle systems.

The Canonical Amoebot Model: Algorithms and Concurrency Control

Fri, 17 Feb 2023 00:00:00 +0000

Invited Paper: Asynchronous Deterministic Leader Election in Three-Dimensional Programmable Matter

Wed, 04 Jan 2023 00:00:00 +0000

The Canonical Amoebot Model: Algorithms and Concurrency Control

Tue, 05 Oct 2021 18:20:00 +0200

The Canonical Amoebot Model: Algorithms and Concurrency Control

Mon, 04 Oct 2021 00:00:00 +0000

Algorithmic Foundations of Emergent Behavior in Analog Collectives

Wed, 14 Jul 2021 12:15:00 -0600

A Distributed, Stochastic Framework for Active Matter

Fri, 23 Apr 2021 00:00:00 +0000

We develop a theoretical framework for task-oriented active matter that combines distributed computing, stochastic processes, statistical physics, active matter physics, and robophysics. By harnessing phase changes from statistical physics in our formal modeling and algorithm design, we obtain robust and provable self-organizing behaviors. We then incorporate this theory into swarm robotics platforms, establishing tight analogies between (but not necessarily strict implementations of) the algorithms' rules and our robots' designs. This allows us to critically examine our theoretical algorithms' robustness to the errors and uncertainties of physical environments. Further, we can treat robot swarms as macro-scale active matter systems, studying the inter-robot dynamics as an analogy to particle interactions.

Programming Active Cohesive Granular Matter with Mechanically Induced Phase Changes

Fri, 23 Apr 2021 00:00:00 +0000

Simple Robots, Smart Algorithms: Meet the BOBbots. Dana Randall. Georgia Tech News Center, April 2021. (Also featured in EurekaAlert!).
Greater Than the Sum of Its Parts. Gary Werner. ASU FullCircle, April 2021. (Also featured in ASU News).

Collaborating in Motion: Distributed and Stochastic Algorithms for Emergent Behavior in Programmable Matter

Mon, 15 Mar 2021 09:00:00 -0700

Abstract

Our world is filled with systems of entities that collaborate in motion, both natural and engineered. These cooperative distributed systems are capable of sophisticated and surprising emergent behavior that arises from the comparatively simple interactions of their members. A model system for emergent collective behavior is programmable matter, a physical substance capable of autonomously changing its properties in response to user input or stimuli from its environment. This dissertation studies distributed and stochastic algorithms that control the local behaviors and interactions of individual modules of programmable matter to induce complex collective behavior at the macroscale. It consists of four parts.

In the first, a new distributed computing model of programmable matter called the canonical amoebot model is proposed. A key goal of the canonical amoebot model is to bring algorithmic theory closer to the physical realities of programmable matter hardware, especially with respect to concurrency and energy distribution. Two complementary protocols are presented that together can extend existing sequential, energy-agnostic algorithms for programmable matter to the more realistic concurrent, energy-constrained setting without sacrificing correctness, assuming the original algorithms satisfy certain conventions.

In the second part, stateful distributed algorithms that use amoebot memory and communication are presented for leader election, object coating, convex hull formation, and asynchronous hexagon formation. The first three algorithms are proven to have runtimes that are linear in the amoebot system size when assuming a simplified sequential setting. The final algorithm for hexagon formation is instead proven to be correct under unfair asynchronous adversarial activation, the most general of all adversarial activation models.

In the third part, the stochastic approach to self-organizing particle systems is presented. This approach combines distributed algorithms with ideas from statistical physics and Markov chain design to replace algorithm reliance on memory and communication with biased random decisions, requiring little to no memory and gaining inherent self-stabilizing and fault-tolerant properties. Using this stochastic approach, algorithms for compression, shortcut bridging, and separation are designed and analyzed.

Finally, a two-pronged approach to "programming" physical ensembles across scales is presented. This approach leverages the physics of local interactions to pair theoretical, algorithmic abstractions of self-organizing particle systems with experimental robot systems of active granular matter that intentionally lack digital computation and communication. We demonstrate how the behavior of robots whose design physically embodies salient features of an algorithm can be predicted by the algorithm’s theoretical analysis, treating the ensemble behaviors of phototaxing, aggregation, dispersion, and object transport.

Collaborating in Motion: Distributed and Stochastic Algorithms for Emergent Behavior in Programmable Matter

Mon, 15 Mar 2021 00:00:00 +0000

Abstract

The world is filled with systems of entities that collaborate in motion, both natural and engineered. These cooperative distributed systems are capable of sophisticated emergent behavior arising from the comparatively simple interactions of their members. A model system for emergent collective behavior is programmable matter, a physical substance capable of autonomously changing its properties in response to user input or environmental stimuli. This dissertation studies distributed and stochastic algorithms that control the local behaviors of individual modules of programmable matter to induce complex collective behavior at the macroscale. It consists of four parts.

In the first, the canonical amoebot model of programmable matter is proposed. A key goal of this model is to bring algorithmic theory closer to the physical realities of programmable matter hardware, especially with respect to concurrency and energy distribution. Two protocols are presented that together extend sequential, energy-agnostic algorithms to the more realistic concurrent, energy-constrained setting without sacrificing correctness, assuming the original algorithms satisfy certain conventions.

In the second part, stateful distributed algorithms using amoebot memory and communication are presented for leader election, object coating, convex hull formation, and hexagon formation. The first three algorithms are proven to have linear runtimes when assuming a simplified sequential setting. The final algorithm for hexagon formation is instead proven to be correct under unfair asynchronous adversarial activation, the most general of all adversarial activation models.

In the third part, distributed algorithms are combined with ideas from statistical physics and Markov chain design to replace algorithm reliance on memory and communication with biased random decisions, gaining inherent self-stabilizing and fault-tolerant properties. Using this stochastic approach, algorithms for compression, shortcut bridging, and separation are designed and analyzed.

Finally, a two-pronged approach to "programming" physical ensembles is presented. This approach leverages the physics of local interactions to pair theoretical abstractions of self-organizing particle systems with experimental robot systems of active granular matter that intentionally lack digital computation and communication. By physically embodying the salient features of an algorithm in robot design, the algorithm’s theoretical analysis can predict the robot ensemble’s behavior. This approach is applied to phototaxing, aggregation, dispersion, and object transport.

Bio-Inspired Energy Distribution for Programmable Matter

Thu, 07 Jan 2021 09:35:00 +0900

Bio-Inspired Energy Distribution for Programmable Matter

Tue, 05 Jan 2021 00:00:00 +0000

Summary

In short, individual bacterium that are metabolically stressed (lacking in nutrients) catalyze a wave of chemical signaling that inhibits the rest of the biofilm’s nutrient uptake. This allows more nutrients to flow to the stressed bacteria, effectively solving the energy distribution problem. We model energy constraints in the amoebot model by giving each particle a battery for storing energy that it can transfer to its neighbors or spend to perform actions. We assume at least one particle in the system has access to an external energy source from which it can harvest energy. The goal of our energy distribution algorithm is to coordinate the transfer of energy between particles so that all particles meet their actions’ energy demands and at least one particle can actually perform its action within a bounded amount of time. After some initial setup, our Energy-Sharing algorithm works in the following phases repeated by each particle individually:

Communication. Particles propagate “stress” and “inhibition” signals to communicate the energy states of starving particles throughout the system.
Sharing. Particles harvest energy they lack from an external source (if they have access to one) and transfer energy to neighbors that need it.
Usage. Particles that are not inhibited spend their stored energy to perform actions, participating in the collective behavior.

We prove that the Energy-Sharing algorithm allows the particle system to meet its energy demands every ${\cal O}(n)$ asynchronous rounds, where $n$ is the number of particles in the system. A simulation of the Energy-Sharing algorithm can be seen below, corresponding to Figure 2 in the paper. All particles are initially idle, with the exception of the root (with external energy access) shown with a gray/black ring. The setup phase establishes the spanning forest (or tree, in this case) rooted at particle(s) with energy access; a particle’s parent direction is shown as an arc. Since all particles start with empty batteries, stress flags (shown as red rings) quickly propagate throughout the system and inhibit flags soon follow. As energy is harvested by the root and shared throughout the system, some particles (shown with yellow rings) receive sufficient energy to meet the demand for their next action but remain inhibited from using it. This inhibition remains until all stressed particles in the system receive sufficient energy to meet their demands, at which point particles (shown with green rings) can reset their inhibit flags and use their energy. After using energy, these particles may again become stressed and trigger another stage of inhibition.

When communication of the stress/inhibit flags is disabled, the energy distribution strategy in Energy-Sharing fails (just as the bacterial biofilms fail to feed all bacteria when their signal relays are disabled). A simulation of this setting is shown below, corresponding to Figure 3 in the paper. Without the communication phase to inhibit particles from using energy while those that are stressed recharge, particles continuously share any energy they have with their descendants in the spanning forest. Thus, while the leaves of the spanning forest occasionally meet their energy demands(seen as the flickering darker green particles), even after 1000 rounds most particles have still not met their energy demand even once.

As an independent but supporting result, we present the Forest-Prune-Repair algorithm that enables a spanning forest of particles to self-repair in the presence of crash failures so long as the set of non-faulty particles remains connected and there is at least one non-crashed root. We prove that this algorithm stabilizes in a spanning forest rooted at root particles in at most ${\cal O}(m^2)$ asynchronous rounds, where $m$ is the number of particles that are severed from the spanning forest by crash failures.

The Energy-Sharing algorithm relies on an underlying spanning forest structure to communicate its stress/inhibition signals. However, if particles move as they often do in collective behaviors, this disrupts the communication structure. Thus, the Forest-Prune-Repair algorithm can be used as an underlying primitive in Energy-Sharing so that Energy-Sharing can be composed with existing amoebot model algorithms, extending them to consider energy constraints. Below is an example of Energy-Sharing composed with Basic Shape Formation, corresponding to Figure 5 in the paper.

Since Energy-Sharing meets the system’s energy demands every ${\cal O}(n)$ asynchronous rounds and Forest-Prune-Repair repairs any disruptions to the communication structure as particles move, a composed algorithm will not be impeded by the underlying energy distribution primitive, but may add significant overhead to its runtime. However, we observe reasonable performance in practice: for example, since hexagon formation terminates in ${\cal O}(n)$ rounds, our proven bounds suggest that the composed algorithm could terminate in time ${\cal O}(n^2)$ or worse but the graph below demonstrates an overhead that appears asymptotically sublinear. With the addition of more energy roots, the composed algorithm is dramatically faster, approaching the runtime achieved without energy constraints.

As a final, informal experiment, we performed a simulation where energy is used for reproduction, mimicking the bacterial biofilms we were inspired by. In our preliminary experiments, we obtain behavior that is qualitatively similar to the biofilm growth patterns observed by Liu and Prindle et al.; in particular, the use of communication and inhibition leads to an oscillatory growth rate. The simulation below corresponds to Figure 7 in the paper.

Convex Hull Formation for Programmable Matter

Sat, 04 Jan 2020 00:00:00 +0000

A Local Stochastic Algorithm for Separation in Heterogeneous Self-Organizing Particle Systems

Sat, 21 Sep 2019 09:00:00 -0400

A Local Stochastic Algorithm for Separation in Heterogeneous Self-Organizing Particle Systems

Fri, 20 Sep 2019 00:00:00 +0000

Simulation of Programmable Matter Systems Using Active Tile-Based Self-Assembly

Wed, 24 Jul 2019 00:00:00 +0000

Stochastic Algorithms for Programmable Matter

Wed, 03 Apr 2019 13:00:00 -0700

Computing by Programmable Particles

Sun, 13 Jan 2019 00:00:00 +0000

Self-Organizing Particle Systems: an Algorithmic Approach to Programmable Matter

Sun, 04 Nov 2018 16:00:00 +0900

A Stochastic Approach to Shortcut Bridging in Programmable Matter

Fri, 28 Sep 2018 00:00:00 +0000

Phototactic Supersmarticles

Tue, 25 Sep 2018 00:00:00 +0000

Smart Swarms Seek New Ways to Cooperate. Kevin Hartnett. Quanta Magazine, February 2018. (Also featured in ACM TechNews).

Brief Announcement: A Local Stochastic Algorithm for Separation in Heterogeneous Self-Organizing Particle Systems

Mon, 23 Jul 2018 00:00:00 +0000

Improved Leader Election for Self-Organizing Programmable Matter

Sun, 31 Dec 2017 00:00:00 +0000

On Your Marks, Get Set, Coat!

Mon, 11 Dec 2017 09:05:00 -0700

My first journal paper was published early last week, marking a milestone in the winding forest path that is my PhD. The paper has some nice ideas and results I’m proud of, but — regrettably — the writing style and level of mathematical rigor needed for publication can make it pretty hard to decipher for anyone not familiar with our niche of computer science. I’m of the opinion that ideas are only useful if people can understand them, so to that end I’m going to explain this paper in a way that’s a bit less formal and academic. With a little effort, I think we’ll both learn something new here. (And if it’s still all Greek to you, I’ll happily answer questions you leave in the comments).

The Nickel Version (TL;DR)

The paper (whose title is mathy and unimportant) is all about programming futuristic, sci-fi materials that don’t exist yet to coat other objects in even layers as (relatively) fast as possible.

The, Uh, Dollar(?) Version

Let’s take a look at the paper’s title (emphasis added): “On the Runtime of Universal Coating for Programmable Matter.”

Runtime is a word we use to talk about how fast an algorithm is. As in many other aspects of life, faster is better and more efficient. So this paper is about how fast “Universal Coating for Programmable Matter” is.

Programmable matter broadly describes any kind of physical material that can change itself as a reaction to what’s around it without human interaction. It’s a bit sci-fi, but imagine a future in which roads fill their own potholes and cracks after wear and tear, clothes heal themselves from fraying and holes, or artificial cells isolate and neutralize malignant tumors in the human body. It sounds crazy and is definitely out there, but that’s what we’re talking about here.

Universal Coating is the action we’re trying to do. In this context, we mean “coating” like a coat of paint; we want to cover something as evenly as possible. (Nobody likes a lumpy paint job). “Universal,” as a math word, means that a technique works in many/all cases. Here, we’re talking about a single approach to coating that works no matter what the object to be coated looks like. (Which is pretty cool).

So, all together, this paper is about analyzing the speed of a particular approach to using futuristic materials for coating any kind of object in nice, even layers. (Ok, so even the one sentence wrap up is a mouthful). Also, a big thank you to Annie Carson for the great illustrations!

So How Does It Work?

I’m really glad you asked. Actually, I’m really glad you’re still here after that heavy appetizer of an overview; hopefully it didn’t spoil your appetite before our main course, which starts right now! Take a look at a simulation of the Universal Coating algorithm over on our lab site, and keep it open for the rest of this section so you can refer back to it.

We need a bit of terminology before I explain what’s going on with all those dots and colors. There are two main “things” in this algorithm. Thing 1 is the object, which is the cluster of dots with black circles in the middle. We’re keeping things nice and simple in this example by making the object a hexagon, but it can be essentially any shape you want (“universal”, remember?). Thing 2 is the particle system, which are all the other dots that move around and change color. “Particle system” is just the term we use for the programmable matter stuff we talked about before: we’re trying to coat the object with these particles.

In really broad strokes, the algorithm can be broken down into four major steps:

Get all the particles oriented towards the object using something like follow-the-leader. In the simulation video (0:00–0:02), this is when they all turn yellow. If you start at any yellow particle and follow its pointer to the next particle and so on, you’ll always end up at the object.
Coat the object’s first layer. This happens insanely fast in the video (0:01–0:02) but there are actually a couple particles that turn red and fill in the few positions on the object’s first layer that weren’t already filled. You can see them if you pause the video and drag the slider back and forth around 0:01.
Decide on a position to be the start/end of each layer. Choosing this marker position plays a big role in helping the particles learn when one layer is finished so they can start forming the next one. In the video (0:02–0:07), this decision process is shown with the line segments around the object changing colors. At 0:07, the particle occupying the marker position turns a light grey color.
Coat the object in more layers one by one until all particles have been used. The video (0:08–0:20) shows this quite clearly, with finished particles turning green. The grey line of particles growing from the object towards the bottom are the particles from Step 3 which mark the start/end of each layer.

And that’s it! Perhaps as a point of pride, I have to mention that — although simple to describe — this algorithm is really involved. One of the main difficulties is that each particle runs this algorithm individually, so instead of Steps 1–4 happening nice and sequentially, they can actually all happen at once. And… yeah, it’s as chaotic as it sounds. The good news is that, in a previous paper, our group proved this algorithm always works, no matter what. Going forward, we’ll just take the fact that it works for granted.

(Quick) Get Your Coat!

I can’t remember how many times I got in the car to go somewhere as a kid only to be sent back inside to get a jacket. Mom never said the “quick” part, but it was definitely implied!

We’re going to shift our discussion to the real work of this new paper: proving that our Universal Coating algorithm runs reasonably fast. Let’s start with a motivating example for why you might do this kind of analysis:

Pretend there’s a secret technique for earning $1,000,000. Maybe it even comes with a guarantee that it will always work. We might get excited about something like that, or at least want to know more. But what if we found out that no one knew how long it would take to work? Or even worse, what if the fine print said it would take more days than the number of atoms in the universe? Well. We might still be waiting for our payout long after inflation turns a million dollars into pocket change, the cows come home, and the sun expands to consume the earth.

The lesson to be learned here: we need to know both that an algorithm works and that it won’t take a ridiculously long time. So how do we analyze the algorithm’s runtime? There’s often more than one way to crack that coconut, but the techniques can get pretty involved. Even getting a mastery over the most fundamental techniques can take the larger part of most undergraduate Computer Science (CS) programs. (Fun fact: this side of CS doesn’t even have to involve programming, contrary to the popular belief that CS people are a bunch of tech support code monkeys. Yes, I probably can fix your iPhone. No, I didn’t learn that in school.)

To explain both why analyzing our particular algorithm was nasty and how we ended up doing it, I’ll use a quick allegory. Imagine a race between two teams: Team Red and Team Blue. Team Red works like a machine: everyone comes to practice and trains hard, they perform well in events, and — most importantly — they run in perfect lock step, starting together and finishing together. Team Blue, on the other hand, is more about the individual effort. They also perform well in events, but have a mix of sprinters, endurance runners, runners who like to stop and smell the roses, and so on. Some of Team Blue’s runners end up finishing really fast, while others take longer.

Our particle systems are, essentially, Team Blue. We don’t make any assumptions about how fast each particle works relative to the others, and it’s entirely possible that a particle can suddenly go faster or slower than usual without following a pattern. This makes it hard to figure out when the last Blue runner (or particle) will cross the finish line. So, instead of directly analyzing our system (Team Blue), we proved two things:

Team Red — a simpler version of our particle systems where everyone progresses through the algorithm at the same rate — runs “fast”.
Team Blue (our particle system) always runs faster than Team Red.

Therefore, as a nice logical result, Team Blue also runs “fast”. In fact, it’s entirely possible it even runs really fast!

Good Job Out There, Get Some Water

As a recap, we have an algorithm for programmable matter which coats objects of all shapes and sizes. We showed that this algorithm always works in an older paper, and that it runs pretty fast in this new journal paper. This runtime analysis boiled down to showing that a simplified version of our particle system runs the algorithm quickly, and that the real particle system always runs it even faster. (For my CS people out there, we showed that the Universal Coating algorithm runs in $\mathcal{O}(n)$ asynchronous rounds with high probability, where $n$ is the number of particles in the system).

Thanks for reading, and feel free to comment with your thoughts, ideas, and questions!

On the Runtime of Universal Coating for Programmable Matter

Tue, 28 Nov 2017 00:00:00 +0000

Opening Paths to Progress with Programmable Materials. Joe Kullman. ASU Now, March 2017. (Also featured in ACM TechNews).

A Stochastic Approach to Shortcut Bridging in Programmable Matter

Fri, 06 Oct 2017 13:00:00 -0500

Image of Eciton army ants forming a shortcut bridge is reproduced with permission from Reid et al. (PNAS, 2015).

A Stochastic Approach to Shortcut Bridging in Programmable Matter

Thu, 24 Aug 2017 00:00:00 +0000

Image of Eciton army ants forming a shortcut bridge is reproduced with permission from Reid et al. (PNAS, 2015).

Local Stochastic Algorithms for Compression and Shortcut Bridging in Programmable Matter

Fri, 28 Jul 2017 14:05:00 -0500

Convex Hull Formation for Programmable Matter

Fri, 28 Jul 2017 13:40:00 -0500

A Markov Chain Algorithm for Compression in Self-Organizing Particle Systems

Mon, 25 Jul 2016 00:00:00 +0000

SSS 2020 Report 2: Compression of programmable matter. Laurent Feuilloley. Discrete Notes, November 2020.
Opening Paths to Progress with Programmable Materials. Joe Kullman. ASU Now, March 2017. (Also featured in ACM TechNews).
A Creeping Model of Computation. Dick Lipton and Ken Regan. Gödel’s Lost Letter and P=NP, September 2016.

Compression in Self-Organizing Particle Systems

Tue, 31 May 2016 00:00:00 +0000

Compression in Self-Organizing Particle Systems

Wed, 06 Apr 2016 11:00:00 -0700

programmable-matter | Mohammad Moshtaghi

Self-Organizing Particle Systems (SOPS)

The Canonical Amoebot Model: Algorithms and Concurrency Control

Invited Paper: Asynchronous Deterministic Leader Election in Three-Dimensional Programmable Matter

The Canonical Amoebot Model: Algorithms and Concurrency Control

The Canonical Amoebot Model: Algorithms and Concurrency Control

Algorithmic Foundations of Emergent Behavior in Analog Collectives

A Distributed, Stochastic Framework for Active Matter

Programming Active Cohesive Granular Matter with Mechanically Induced Phase Changes

Related Press

Collaborating in Motion: Distributed and Stochastic Algorithms for Emergent Behavior in Programmable Matter

Abstract

Collaborating in Motion: Distributed and Stochastic Algorithms for Emergent Behavior in Programmable Matter

Abstract

Bio-Inspired Energy Distribution for Programmable Matter

Bio-Inspired Energy Distribution for Programmable Matter

Summary

Convex Hull Formation for Programmable Matter

A Local Stochastic Algorithm for Separation in Heterogeneous Self-Organizing Particle Systems

A Local Stochastic Algorithm for Separation in Heterogeneous Self-Organizing Particle Systems

Simulation of Programmable Matter Systems Using Active Tile-Based Self-Assembly

Stochastic Algorithms for Programmable Matter

Computing by Programmable Particles

Self-Organizing Particle Systems: an Algorithmic Approach to Programmable Matter

A Stochastic Approach to Shortcut Bridging in Programmable Matter

Phototactic Supersmarticles

Related Press

Brief Announcement: A Local Stochastic Algorithm for Separation in Heterogeneous Self-Organizing Particle Systems

Improved Leader Election for Self-Organizing Programmable Matter

On Your Marks, Get Set, Coat!

The Nickel Version (TL;DR)

The, Uh, Dollar(?) Version

So How Does It Work?

(Quick) Get Your Coat!

Good Job Out There, Get Some Water

On the Runtime of Universal Coating for Programmable Matter

Related Press

A Stochastic Approach to Shortcut Bridging in Programmable Matter

A Stochastic Approach to Shortcut Bridging in Programmable Matter

Local Stochastic Algorithms for Compression and Shortcut Bridging in Programmable Matter

Convex Hull Formation for Programmable Matter

A Markov Chain Algorithm for Compression in Self-Organizing Particle Systems

Related Press

Compression in Self-Organizing Particle Systems

Compression in Self-Organizing Particle Systems