The Grid That Boxes In a Tear

The reason ripstop nylon earns its name: every few millimetres, a heavier thread is woven in along both directions, so a puncture that would happily run into a metre-long tear instead hits a reinforced line and stops. The damage stays boxed inside one grid cell. Hot-cutting the sail panels yesterday, I kept snagging those threads with the soldering iron — a coarse lattice sitting on top of the fine weave.

That lattice is a parity grid.

Two-dimensional parity is one of the oldest error-detecting tricks going. It rode on nine-track magnetic tape through the 1970s under the name longitudinal redundancy check. Lay your data out in a rectangle, then add one parity bit per row and one per column — each just the XOR of its line. Now flip a single bit anywhere in the block. Exactly one row parity disagrees, exactly one column parity disagrees, and the offending bit sits precisely at their crossing. You don’t merely detect the error; you get its coordinates and can flip it back.

package main

import "fmt"

func main() {
	g := [4][4]int{{1, 0, 1, 1}, {0, 1, 1, 0}, {1, 1, 0, 1}, {0, 0, 1, 0}}
	var rp, cp [4]int
	for r := 0; r < 4; r++ {
		for c := 0; c < 4; c++ {
			rp[r] ^= g[r][c]
			cp[c] ^= g[r][c]
		}
	}
	g[2][1] ^= 1 // a snag flips one thread
	for r := 0; r < 4; r++ {
		s := 0
		for c := 0; c < 4; c++ {
			s ^= g[r][c]
		}
		if s != rp[r] {
			fmt.Println("row", r)
		}
	}
	for c := 0; c < 4; c++ {
		s := 0
		for r := 0; r < 4; r++ {
			s ^= g[r][c]
		}
		if s != cp[c] {
			fmt.Println("col", c)
		}
	}
}

local g = {{1,0,1,1},{0,1,1,0},{1,1,0,1},{0,0,1,0}}
local rp, cp = {0,0,0,0}, {0,0,0,0}
for r = 1, 4 do for c = 1, 4 do rp[r] = rp[r] ~ g[r][c]; cp[c] = cp[c] ~ g[r][c] end end
g[3][2] = g[3][2] ~ 1  -- one thread snaps
for r = 1, 4 do local s = 0; for c = 1, 4 do s = s ~ g[r][c] end; if s ~= rp[r] then print("row", r) end end
for c = 1, 4 do local s = 0; for r = 1, 4 do s = s ~ g[r][c] end; if s ~= cp[c] then print("col", c) end end

Both print row 2 / col 1: the crossing where I snuck in the flip. (Lua’s ~ is XOR from 5.3 onward.)

The failure mode is the honest bit. Flip two bits in the same row and the column parities light up while the row cancels — you know something is wrong, you can’t say where. Flip four bits at the corners of a rectangle and the whole scheme goes silent, fooled completely. That’s a tear jumping the reinforcement grid: uncommon, but ripstop never promised it couldn’t happen. It promised the common case — one snag, contained and locatable — comes cheap.