Verifying a 54-move exact search.

Tower placement changes both moves and scores

Each board square has a two-dimensional coordinate, but the tower decision gives it an altitude of either zero or one. A legal move therefore has absolute coordinate differences {0, 1, 2} across x, y, and z. The same planar jump can be legal or illegal depending on whether one endpoint is a tower.

The score creates a second dependency. At move n, staying at the same altitude adds n, moving up multiplies by n, and moving down requires exact divisibility by n before dividing. Because clue scores occur only on scheduled moves, the route must satisfy geometry, score arithmetic, clue timing, and tower placement at the same time.

The knight must stop when it has visited all 13 towers. A route that continues afterward is invalid even if every move is legal. The verifier checks the first point of completion rather than assuming that reaching every tower is sufficient.

Reject impossible score schedules before searching the board

After move 18, the puzzle says scores are recorded every K moves for some larger K, but the wording admits two natural timing interpretations. The retained search evaluates both. For each mode it tries K values from 4 upward while the required clue schedule still fits inside the board-length bound.

The first reduction ignores board geometry entirely. A dynamic program tracks score, altitude, which nonzero clue scores have already been consumed, and the order in which those scores could appear on scheduled moves. Every transition applies the exact add, multiply, or divisible-only divide rule. If a scheduled move does not produce one of the remaining clue values, that state dies immediately.

The surviving states specify arithmetic-consistent clue orders. Geometry then has one narrower job: realize those orders as legal three-dimensional knight paths, rather than guess the score sequence and route together.

Search between forced clues, then reconcile the segments

Once a clue order and schedule are fixed, consecutive clue states provide a start square, end square, start score, end score, and exact number of moves between them. The retained solver searches those intervals as segments instead of exploring every 54-move route from the start.

Before recursion, it precomputes the board’s knight-neighbor graph and shortest-path distances. During a segment search, a branch is dropped if the target clue is farther away than the number of moves remaining. It also rejects repeated squares, early visits to other nonzero clue squares, impossible score transitions, and conflicting tower assignments inside a region.

Stitching carries global square status, tower commitments, and completed regions from one segment to the next. An internally valid segment is rejected if it contradicts an earlier one. Local pruning can therefore stay aggressive without overwriting global constraints.

Recompute the route from its coordinates

The verifier receives the board regions, clue dictionary, recovered K and schedule mode, tower placements, and path coordinates. It reconstructs the moves and raises an error on the first broken rule; a “found” flag from the search carries no weight.

It checks the 8-by-8 region map, the twelve five-square regions plus the one four-square region, one valid tower location per region, the required starting square, uniqueness of every visited square, and every three-dimensional knight delta. It then recomputes the full score path, including exact divisibility on downward moves.

Next it checks that each scheduled recording lands on the correct clue square with the correct score, that no nonzero clue is reached off schedule, and that all towers are first completed on the final move rather than earlier. Only after those checks does it calculate the answer by summing the scores of orthogonally adjacent visited squares around each unvisited square.

The verifier is separate, but not formally independent: the search reuses some of its coordinate and score-transition helpers. A second implementation derived from the puzzle statement, or a certificate checked without shared helpers, would reduce the risk of both programs accepting the same interpretation error.

{
  "K": 7,
  "schedule_mode": "natural_after_18",
  "path_length": 54,
  "answer": 33609
}

K = 7 fixes the schedule; neighbor sums give the answer

The retained reconstruction uses the natural “after move 18” interpretation with K = 7. The recorded clue moves are 0, 3, 6, 9, 12, 15, 18, 25, 32, 39, 46, and 53. The route then makes move 54 onto the last tower. That distinction is useful: the last path score is part of the verified route, while the puzzle answer comes from a separate neighbor-sum calculation over the squares the knight never visited.

The retained path has 54 moves and produces 33,609 after the neighbor sums are recomputed. Jane Street’s official July 2026 solution independently publishes the same final answer. That corroborates the numerical result; it does not establish that Jane Street inspected this implementation, this search strategy, or this verifier.

The useful review questions concern the route: which branches arithmetic rejects before geometric search, how tower and score state survive stitching, and which checks can be repeated without trusting the search that produced it. The number 33,609 alone answers none of those questions.

Remove shared assumptions from the next verifier

The retained package reconstructs and checks one solution. The next improvement is a second verifier written from the puzzle statement, without shared score or coordinate helpers. That would reduce the chance of an interpretation bug surviving both search and verification.

Second, I would add property tests around move legality, score transitions, schedule generation, and answer recomputation. Third, I would emit a compact solution certificate with the path, tower placements, K, schedule mode, and a content hash so another implementation could validate the same artifact deterministically.

These additions would make the result easier to audit rather than make the search faster. Once the solver has an answer, independent checks offer more value than another optimization that merely finds the same answer sooner.

Publish the checkable route alongside the answer

The evidence consists of the puzzle specification, an explicit 54-move path, recomputed scores and clues, tower completion, and the neighbor-sum calculation. Jane Street’s published solution confirms 33,609, but does not validate my code. A second verifier built without shared helpers would strengthen the retained result.

Sources

1. Jane Street — July 2026 puzzle: ‘Pent-Up’ Frustration 3 / Knight Moves 7

   Verified Sep 15, 2026

2. Jane Street — July 2026 official solution

   Verified Sep 15, 2026

3. Jane Street — puzzle archive

   Verified Sep 15, 2026

Supporting material

• Jane Street July 2026 puzzle

  The original puzzle statement, including the 13 regions, towers, three-dimensional knight moves, scoring rules, and changing clue schedule.

• Jane Street official solution

  Jane Street’s published July 2026 solution, including the solved path graphic and final answer of 33,609.

• Technical competition dossier

  A compact public record of the solver, reconstruction approach, and verifier boundary.

Read next