Algorithmic Patterns

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:

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:

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
• Source: Amanbh997/Claude-skills-for-Computational-Designers
• License: MIT

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