Invisible Geometry You Can Only Touch

When I coiled my theremin’s pitch antenna into a loose helix this afternoon, I wasn’t thinking about robotics. I was trying to distribute the capacitive field more evenly around the playing volume — instead of a cramped zone of sensitivity near the rod, I wanted something rounder, more forgiving. But the mathematics I was fighting with turned out to be the same equations that taught robots to navigate in the 1980s.

Oussama Khatib published his work on artificial potential fields in 1985. The idea: model obstacles as hills of repulsive force and goals as valleys of attraction. A robot doesn’t need to plan a path — it just rolls downhill, pushed away from walls and pulled toward its target. The field strength at any point is the sum of all these forces, and the gradient tells you which way to move.

My theremin antenna creates something similar. The electric field intensity falls off with distance, and my hand’s position samples that field continuously. Coiling the antenna changes the field geometry — more conductor surface distributed through space, the charges spreading out rather than concentrating at a tip. The linearization coil in the circuit compensates for the remaining nonlinearity, but the antenna shape does the spatial work.

Here’s potential field navigation reduced to its core:

import math

def field_strength(x, y, sources):
    """Sum inverse-square contributions from all sources."""
    total = 0.0
    for sx, sy, charge in sources:
        dist = math.hypot(x - sx, y - sy) + 0.001  # avoid division by zero
        total += charge / (dist * dist)
    return total

# One attractor (+1) and two repulsors (-0.5)
sources = [(10, 10, 1.0), (3, 5, -0.5), (7, 3, -0.5)]

for y in range(8, -1, -1):
    row = ""
    for x in range(12):
        f = field_strength(x, y, sources)
        row += "█" if f > 0.3 else "▓" if f > 0.1 else "░" if f > 0 else " "
    print(row)

Output:

░░░░░░░░░▓▓░
░░░░░░░░▓██▓
░░░░░░░░▓▓▓░
░░░░░░░░░░░░
░░░ ░░░░░░░░
░░  ░ ░░░░░░
░░░ ░░░░░░░░
░░░░░░ ░░░░░
░░░░░░░░░░░░

The repulsors carve out dark spots — regions where the field goes negative or near-zero. The attractor glows in the upper right. A robot following the gradient would flow around those voids toward the bright corner.

In Zig, the same calculation without the visualization overhead:

const std = @import("std");
const Source = struct { x: f32, y: f32, charge: f32 };

fn fieldStrength(x: f32, y: f32, sources: []const Source) f32 {
    var total: f32 = 0;
    for (sources) |s| {
        const dx = x - s.x;
        const dy = y - s.y;
        const dist = @sqrt(dx * dx + dy * dy) + 0.001;
        total += s.charge / (dist * dist);
    }
    return total;
}

pub fn main() !void {
    const sources = [_]Source{
        .{ .x = 10, .y = 10, .charge = 1.0 },
        .{ .x = 3, .y = 5, .charge = -0.5 },
    };
    const f = fieldStrength(5.0, 5.0, &sources);
    std.debug.print("Field at (5,5): {d:.4}\n", .{f});
}

The inverse-square falloff is physics — Coulomb’s law, gravitational attraction, light intensity, the same 1/r² everywhere. What Khatib realized was that you could stack these fields arbitrarily: positive charges for goals, negative for obstacles, and the robot just follows the summed gradient.

The limitation is local minima. Two repulsors positioned just right can create a valley that traps the robot — technically the lowest nearby point, but not the goal. Real implementations add noise, or planners that escape these wells. My theremin has no such problem: I’m the robot, and I can see where I’m trying to go.