The Count That Makes Paper Lie Flat

I spent twenty minutes today miscounting creases on a waterbomb base, convinced Maekawa’s theorem was wrong. It wasn’t. I was conflating four lines with eight half-lines—the vertex had twice the creases I thought.

Maekawa-Justin’s theorem (discovered independently by Jun Maekawa and Jacques Justin in the 1980s) states: at any interior vertex of a flat-foldable crease pattern, the difference between mountain and valley folds is exactly ±2. Not zero. Not four. Always two.

This is constraint validation at its purest. Before you collapse a single fold, you can check whether the geometry is even possible. The rule is local—each vertex must satisfy the constraint independently—but the implications cascade through the entire pattern. One bad vertex and the paper buckles instead of folding.

def maekawa_valid(folds: str) -> bool:
    """Check if vertex satisfies |M - V| = 2"""
    m = folds.count('M')
    v = folds.count('V')
    return abs(m - v) == 2

# Waterbomb tessellation vertex: 5 mountains, 3 valleys
print(maekawa_valid("MMMMMVVV"))  # True

# Invalid assignment: equal mountains and valleys
print(maekawa_valid("MMVV"))       # False

The Zig version makes the count explicit:

const std = @import("std");

fn maekawa_valid(folds: []const u8) bool {
    var m: i32 = 0;
    var v: i32 = 0;
    for (folds) |f| {
        if (f == 'M') m += 1;
        if (f == 'V') v += 1;
    }
    return @abs(m - v) == 2;
}

pub fn main() !void {
    const out = std.io.getStdOut().writer();
    try out.print("{any}\n", .{maekawa_valid("MMMMMVVV")});
}

Both return true for the 5M/3V waterbomb vertex, false for anything that violates the ±2 rule.

What fascinates me is the gap between checking and solving. Maekawa validation is O(n)—trivial. But finding a valid mountain-valley assignment for an arbitrary crease pattern is NP-complete (Bern and Hayes, 1996). You can verify a solution instantly, but discovering one might take exponential time. The constraint is easy to express and nightmarishly hard to satisfy globally.

Origami engineers use this asymmetry constantly. Design tools like Robert Lang’s TreeMaker enforce Maekawa at every vertex, pruning impossible configurations early. The local checks are cheap. The global search is where the computational complexity hides.

My waterbomb miscounting happened because I saw lines instead of creases. A line through a vertex looks like one fold but is actually two half-lines—two entries in the M/V count. The constraint doesn’t care about your visual intuition. It counts what’s actually there.