# Algorithmic Patterns

> L-systems, cellular automata, agent-based modeling, swarm intelligence, reaction-diffusion, growth algorithms, packing algorithms, and nature-inspired computation for AEC design

- **Type:** Skill
- **Install:** `agentstack add skill-amanbh997-claude-skills-for-computational-designers-algorithmic-patterns`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Amanbh997](https://agentstack.voostack.com/s/amanbh997)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Amanbh997](https://github.com/Amanbh997)
- **Source:** https://github.com/Amanbh997/Claude-skills-for-Computational-Designers/tree/main/skills/algorithmic-patterns

## Install

```sh
agentstack add skill-amanbh997-claude-skills-for-computational-designers-algorithmic-patterns
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Algorithmic Patterns for AEC Design

## 1. Nature-Inspired Computation in AEC

### Why Biological Algorithms Matter for Design

For three and a half billion years, evolution has solved the optimization problems architects and engineers face daily: distributing material efficiently, creating structures that resist loads with minimal mass, organizing circulation for millions of agents, regulating temperature without mechanical systems, and generating complex forms from simple rules. Nature-inspired computation translates these solutions into programmable algorithms that transform AEC practice.

The fundamental insight is that complexity does not require complex instructions. A fern frond with thousands of precisely placed leaflets emerges from a recursive rule fitting in a single line of code. A termite mound maintaining two-degree temperature stability is built by agents following three local rules. An oak tree optimally distributing material to resist wind has no central controller -- it grows according to Wolff's law, depositing material where stress is highest.

### Emergence and Self-Organization

Emergence produces macro-scale patterns from micro-scale interactions without centralized control. In AEC, this challenges conventional top-down design, replacing it with local rules and boundary conditions that self-organize into coherent spatial configurations.

**Key properties of emergent systems:**
- **Nonlinearity** -- small changes in rules produce disproportionate changes in output
- **Feedback loops** -- positive feedback amplifies patterns, negative feedback stabilizes them
- **Decentralization** -- no single agent has global knowledge of the system
- **Adaptation** -- the system responds to environmental changes in real time
- **Robustness** -- local failures do not cascade to system-level collapse

The computational thesis underlying all algorithmic patterns is that irreducible complexity can emerge from reducible rules. Stephen Wolfram demonstrated this with elementary cellular automata: Rule 110, defined by 8 binary transitions, is Turing-complete. A one-dimensional grid of cells with two states and nearest-neighbor rules can compute anything computable. For AEC: a branching structure with thousands of unique members can be specified by 3-4 L-system rules; a facade with apparent randomness generated by a 2-state CA; an optimal circulation network by 10,000 agents following 3 flocking rules.

| Aspect | Top-Down (Traditional) | Bottom-Up (Algorithmic) |
|--------|----------------------|------------------------|
| Control | Centralized | Distributed |
| Specification | Global geometry | Local rules |
| Adaptability | Low (manual redesign) | High (rules adapt) |
| Scalability | Difficult | Inherent |
| Novelty | Limited by imagination | Generates unexpected solutions |

### Applications Across AEC

| Domain | Algorithm Class | Application |
|--------|----------------|-------------|
| Urban growth | Cellular automata, ABM | Land use simulation, sprawl prediction |
| Structural branching | L-systems, space colonization | Tree columns, dendritic roofs |
| Facade patterning | Reaction-diffusion, CA | Perforated screens, shading panels |
| Space planning | Agent-based, packing | Room layout, furniture arrangement |
| Material distribution | Topology optimization, DLA | Graded density structures |
| Circulation design | Ant colony, shortest path | Corridor networks, staircase placement |
| Acoustic design | Reaction-diffusion, fractal | Diffuser panel geometry |
| Thermal design | Swarm optimization | Ventilation opening placement |

---

## 2. L-Systems (Lindenmayer Systems)

### Formal Grammar

An L-system is a parallel rewriting system G = (V, w, P) where V is the alphabet, w is the axiom (initial string), and P is the production rules. Unlike Chomsky grammars, all rules apply simultaneously, modeling biological growth where cells divide concurrently.

### DOL-Systems (Deterministic, Context-Free)

Each variable has exactly one production rule; rules are context-independent.

**Algae (Lindenmayer's original):** `Alphabet: {A,B} | Axiom: A | Rules: A->AB, B->A`
String length follows the Fibonacci sequence: A, AB, ABA, ABAAB, ABAABABA.

**Koch Curve:** `Axiom: F | Rule: F->F+F-F-F+F | Angle: 90deg`
Fractal dimension log(5)/log(3) = 1.465.

**Sierpinski Triangle:** `Axiom: F-G-G | Rules: F->F-G+F+G-F, G->GG | Angle: 120deg`

**Dragon Curve:** `Axiom: FX | Rules: X->X+YF+, Y->-FX-Y | Angle: 90deg`

**Hilbert Curve:** `Axiom: A | Rules: A->-BF+AFA+FB-, B->+AF-BFB-FA+ | Angle: 90deg`

### Stochastic L-Systems

Multiple rules per predecessor with probabilities summing to 1:
```
F -> F[+F]F[-F]F    (p=0.33)
F -> F[+F]F          (p=0.33)
F -> FF-[-F+F+F]+[+F-F-F]  (p=0.34)
```
No two generated trees are identical, yet all share the same structural grammar. Critical for facades with varied but coherent panel geometries.

### Context-Sensitive L-Systems

Rules depend on adjacent symbols: `A  C -> D` (B becomes D only between A and C). AEC application: signal propagation along structural members -- stress information triggers material deposition only where neighbors indicate high stress.

### Parametric L-Systems

Symbols carry numerical parameters with guard conditions:
```
A(l,w) : l > 0.1 -> F(l) [+(30) A(l*0.7, w*0.8)] [-(30) A(l*0.7, w*0.8)]
A(l,w) : l  (terminal leaf)
```
Parameters 0.7 and 0.8 control child-to-parent ratios, mapping directly to Murray's law for biological branching.

### Turtle Interpretation

| Symbol | Action | Symbol | Action |
|--------|--------|--------|--------|
| `F` | Move forward, draw line | `[` | Push state (branch start) |
| `f` | Move forward, no draw | `]` | Pop state (branch end) |
| `+`/`-` | Turn left/right by delta | `&`/`^` | Pitch down/up (3D) |
| `\`/`/` | Roll left/right (3D) | `!` | Decrement diameter |

### Extended Grammars

**Binary Tree (2D):**
```
Axiom: 0
Rules: 1 -> 11, 0 -> 1[+0]-0
Angle: 45 degrees, Iterations: 7
```
Produces a symmetric binary tree with 128 terminal branches.

**Stochastic Shrub:**
```
Axiom: F
Rules: F -> FF+[+F-F-F]-[-F+F+F] (p=0.5), F -> FF-[-F+F]+[+F-F] (p=0.5)
Angle: 22.5 degrees, Iterations: 4
```

**3D Tree (with pitch and roll):**
```
A -> F(1)[&(30)B][/(120)&(30)B][/(240)&(30)B]
B -> F(0.8)[+(25)$C][--(25)$C]B
C -> F(0.5)[+(20)$C][--(20)$C]
```

**City Block Generator:**
```
X -> F[-X][+X]FX | F -> FF
Angle: 90 degrees
```
Generates recursive block subdivision resembling organic street networks.

**Column Capital (parametric, 3D):**
```
A(h,r) -> F(h,r) [+(60)&(40) B(h*0.3,r*0.6)] [+(180)&(40) B(h*0.3,r*0.6)] [+(300)&(40) B(h*0.3,r*0.6)]
B(h,r) : h > 0.05 -> F(h,r) [+(45)&(30) B(h*0.5,r*0.7)] [-(45)&(30) B(h*0.5,r*0.7)]
```

### AEC Applications

**Branching Structures:** Tree-columns in airports and stations (Stuttgart Airport, Sendai Mediatheque). A 5-rule L-system defines a column branching into 200+ terminal supports for a roof canopy.

**Root-Like Foundations:** Inverted L-system trees distributing loads through soil following optimized branching angles per Murray's law.

**Dendritic Circulation:** Corridor systems following L-system branching produce naturally navigable spaces with clear hierarchy.

**Fractal Facades:** Koch-curve-based facades provide increased surface area for shading while maintaining structural regularity.

### Implementation

**Python:**
```python
def l_system(axiom, rules, iterations):
    current = axiom
    for _ in range(iterations):
        current = "".join(rules.get(c, c) for c in current)
    return current
```
**Grasshopper:** String rewriting via text components, Anemone loop for iterations, turtle geometry components for line/curve generation, pipe/mesh for 3D visualization.

---

## 3. Cellular Automata (CA)

### 1D Elementary CA (Wolfram's 256 Rules)

A row of binary cells; next state depends on 3-cell neighborhood (8 configurations, 2^8 = 256 rules).

**Rule 30** (chaotic): Aperiodic, seemingly random from a single cell. Found on Conus textile shell.
**Rule 90** (Sierpinski): XOR of neighbors. Perfect for facade patterning -- regularity with complexity.
**Rule 110** (Turing-complete): Proved by Cook (2004). Generates gliders and spaceships. The simplest known universal computer.

### 2D Cellular Automata

**Game of Life (B3/S23):** Dead cell with 3 neighbors is born; alive cell with 2-3 survives; all others die. Produces gliders, oscillators, guns, and self-replicating patterns.

**Urban Growth (B3678/S2345678):** Compact blob growth mimicking suburban sprawl. Adjusting to B45/S2345 produces polycentric growth.

**Floor Plan Generator (B3/S1234):** From random initial conditions, produces room-like enclosed spaces connected by narrow passages.

### Neighborhoods

**Von Neumann (4):** Orthogonal patterns for rectilinear layouts. **Moore (8):** Organic, rounded patterns; standard for most 2D CA. **Extended Moore (24, radius 2):** Smoother boundaries for urban simulation. **Hexagonal (6):** Isotropic, no directional bias.

### State Transitions and Multi-State CA

**Binary (0/1):** Simplest case -- cell is active or inactive.

**Multi-state (0-N):** Enables gradient effects and functional zoning:
- State 0: empty / undeveloped
- State 1: residential low-density
- State 2: residential high-density
- State 3: commercial
- State 4: industrial
- State 5: park / green space

Transition rules encode zoning logic: residential adjacent to 3+ commercial cells transitions to mixed-use. Green space cells never transition (protected). Totalistic CA depends only on the sum of neighbor states; outer-totalistic (like Game of Life) depends on center state AND neighbor sum but not arrangement.

### 3D Cellular Automata

Cubic lattice with 6 (von Neumann), 18 (edge-sharing), or 26 (Moore) neighbors.

**Structural topology application:**
```
States: solid (1), void (0)
Initial: solid block
Rules: Death: solid cell with  void
       Birth: void cell with 8-12 solid neighbors -> solid
```
Produces porous, trabecular bone-like structures exportable as mesh for 3D printing or CNC fabrication.

### AEC Applications

**Urban Growth Simulation:** SLEUTH/DUEM models simulate decades of land-use change for infrastructure planning.
**Structural Topology:** Voxel rules remove low-stress material, approximating optimal distributions.
**Facade Patterns:** CA grid mapped to facade; cell states determine panel type. Rule 90 produces Sierpinski; Game of Life produces organic patterns.

**Python:**
```python
import numpy as np
from scipy.signal import convolve2d
def gol_step(grid):
    n = convolve2d(grid, np.array([[1,1,1],[1,0,1],[1,1,1]]), mode='same', boundary='wrap')
    return ((grid==0) & (n==3) | (grid==1) & ((n==2)|(n==3))).astype(int)
```

---

## 4. Agent-Based Modeling (ABM)

### Agent Architecture

An agent has: position (x,y,z), velocity, state variables (energy, type, memory), behavioral rules executed each timestep, perception radius, and communication mode (direct messaging or stigmergy).

**Environments:** Grid-based (simple collision, coarse simulations), continuous (realistic pedestrian/vehicle movement, requires KDTree spatial indexing), network-based (agents move along graph edges for transit simulation).

### Stigmergy

Indirect communication through environment modification. Agents deposit pheromone; it diffuses (Gaussian blur) and evaporates: `P(t+1) = P(t) * (1 - rho)`. Others sense gradients and bias movement toward high concentrations. This is how ant colonies find shortest paths -- and how pedestrians create desire lines.

### Flocking (Reynolds Boids)

Three rules applied each timestep:
- **Separation:** `force = sum((self.pos - neighbor.pos) / dist^2)` within separation_radius
- **Alignment:** `force = avg(neighbor.velocity) - self.velocity` within alignment_radius
- **Cohesion:** `force = centroid(neighbors) - self.pos` within cohesion_radius

Combined: `velocity += w1*sep + w2*ali + w3*coh; clamp(velocity, max_speed); pos += velocity*dt`

High w1 = dispersed; high w2 = parallel streams; high w3 = tight swarms; balanced = natural flocking.

### Ant Colony Optimization (ACO)

Path selection: `P(i->j) = (tau_ij^alpha * eta_ij^beta) / sum(tau_ik^alpha * eta_ik^beta)` where tau = pheromone, eta = 1/distance. Pheromone update: `tau = (1-rho)*tau + Q/L_k` for ants using edge.

**AEC:** Hospital corridor layout optimization. Nodes = rooms (ER, ICU, pharmacy). ACO minimizes total daily staff travel distance, producing a connectivity graph that informs spatial adjacency.

### Termite Mound Algorithms

Stigmergic construction: deposit material where pheromone is high; deposits emit pheromone; positive feedback creates pillars, arches, chambers. Translates to robotic construction agents building without centralized control.

### AEC Applications

**Pedestrian Flow:** Thousands of agents navigating stations/malls; identify bottlenecks, optimize door placement.
**Evacuation:** Social force model (Helbing) validates egress timeframes with body-compression physics.
**Urban Morphogenesis:** Developer/resident agents produce clustering, segregation, gentrification from individual decisions.
**Structural Placement:** Agents walking force-flow lines deposit material at convergences, reflecting principal stress trajectories.
**Adaptive Facades:** Each panel is an agent with sensors/actuators, coordinating shading with neighbors.

**Tools:** Quelea (Grasshopper real-time ABM), NetLogo (visual ABM platform), Mesa (Python framework integrating with compas/ladybug/honeybee).

---

## 5. Swarm Intelligence

### Particle Swarm Optimization (PSO)

```
v_i = w*v_i + c1*r1*(p_i - x_i) + c2*r2*(g - x_i)
x_i = x_i + v_i
```
w (inertia): 0.9 -> 0.4 over iterations. c1, c2 (cognitive/social): typically 2.0. r1, r2: random [0,1].
**AEC:** Optimize building orientation, WWR, shading angles via EnergyPlus fitness function. Converges in 50-200 iterations.

### ACO Pheromone Strategies

**Ant System:** All ants deposit; simple but slow. **Ant Colony System:** Best-ant-only with local decay; faster convergence. **MAX-MIN:** Bounded pheromone prevents premature convergence.
**AEC:** Pipe routing through ceiling cavities minimizing length while avoiding structural members.

### Bee Algorithm

Scout bees (random global search), employed bees (local exploitation), onlooker bees (quality-weighted roulette selection). Abandoned food sources trigger scouting.
**AEC:** Multi-objective optimization balancing energy performance, structural efficiency, daylight, and cost.

### Firefly Algorithm

Attractiveness: `beta(r) = beta_0 * exp(-gamma*r^2)`. Brighter fireflies attract dimmer ones; distance-dependent attraction clusters solutions around promising regions.
**AEC:** Structural member sizing -- each firefly is a set of beam/column cross-sections; brightness = low weight satisfying constraints.

| Criterion | PSO | ACO | Bee | Firefly |
|-----------|-----|-----|-----|---------|
| Continuous variables | Excellent | Poor | Good | Good |
| Discrete/combinatorial | Poor | Excellent | Good | Fair |
| Multi-objective | Fair | Fair | Good | Fair |
| Convergence speed | Fast | Moderate | Moderate | Slow |
| Best AEC use | Parametric opt. | Routing/layout | Multi-objective | Sizing opt. |

---

## 6. Reaction-Diffusion

### Turing Patterns

Two morphogens -- activator (slow diffusion, self-promoting) and inhibitor (fast diffusion, activator-suppressing) -- produce stable spatial patterns via short-range activation / long-range inhibition: spots, stripes, labyrinths, inverse spots. Found throughout biology: leopard spots, zebra stripes, seashell markings, fingerprints.

### Gray-Scott Model

```
du/dt = Du*laplacian(u) - u*v^2 + f*(1-u)
dv/dt = Dv*laplacian(v) + u*v^2 - (f+k)*v
```
Typical: Du=0.16, Dv=0.08. The (f,k) parameter space maps to distinct regimes:

| f | k | Pattern Type |
|---|---|-------------|
| 0.010 | 0.045 | Spots (mitosis) |
| 0.022 | 0.051 | Spots and stripes |
| 0.030 | 0.057 | Stripes / labyrinthine |
| 0.040 | 0.063

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Amanbh997](https://github.com/Amanbh997)
- **Source:** [Amanbh997/Claude-skills-for-Computational-Designers](https://github.com/Amanbh997/Claude-skills-for-Computational-Designers)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-amanbh997-claude-skills-for-computational-designers-algorithmic-patterns
- Seller: https://agentstack.voostack.com/s/amanbh997
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.