Uncrossing the Threads, One Swap at a Time

Four bobbins, one suspicious crossing, and a strong temptation to pull everything apart. Today’s lace-making discovery: before undoing a mistake, it helps to know exactly what you did.

Following a lace pricking means coordinating bobbin pairs while pins support the growing work. For a tiny digital rehearsal, I labelled four bobbins ABCD and recorded a sequence of neighbouring swaps. This models their left-to-right order; it leaves the actual thread geometry to my increasingly patient hands.

Every swap is its own inverse. Exchange two neighbours twice and they return to their original positions. That makes a sequence reversible too: perform the same swaps in reverse order.

(defn swap-at [v i]
  (let [j (inc i)]
    (assoc v i (v j) j (v i))))
(defn replay [v moves]
  (if (empty? moves) v
      (recur (swap-at v (first moves)) (rest moves))))
(def moves [1 0 2 1])
(def woven (replay [\A \B \C \D] moves))
(println (apply str woven))
(println (apply str (replay woven (reverse moves))))

Clojure numbers positions from zero. Ada’s version starts at one, so its recorded positions shift accordingly:

with Ada.Text_IO; use Ada.Text_IO;
procedure Lace is
   B : String := "ABCD";
   Moves : constant array (Positive range 1 .. 4) of Positive :=
     (2, 1, 3, 2);
   procedure Swap (I : Positive) is
      T : constant Character := B (I);
   begin
      B (I) := B (I + 1); B (I + 1) := T;
   end Swap;
begin
   for I in Moves'Range loop Swap (Moves (I)); end loop;
   Put_Line (B);
   for I in reverse Moves'Range loop Swap (Moves (I)); end loop;
   Put_Line (B);
end Lace;

Both print CDAB, then ABCD. Repeating the forward sequence happens to work for some arrangements, but reversing the operation order is the general rule.

Reversible computation asks us to preserve enough information to recover an earlier input. A swap discards nothing; overwriting a bobbin label would. Here, recovery also depends on retaining the move sequence. Clojure constructs updated vectors, while Ada changes the string directly; reversibility belongs to the operations, independently of that storage choice.

The lace pillow supplies the limitation. Restoring bobbin order cannot restore thread tension, pin placement, or which thread passed over another. Those details never entered our model. The computer can faithfully undo what we recorded—and remain blissfully ignorant of the knot beside it.