Checking Jane Street’s official route

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.

Score arithmetic before coordinates

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 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 a narrower task: realize each surviving order as a legal three-dimensional knight path. The score sequence no longer has to be guessed alongside the route.

A small arithmetic example shows why this helps. If the score before move 8 is 37, a downward move would require 37 ÷ 8 and is impossible under the integer-score rule. A level move yields 45; an upward move yields 296. This state is invented for the example; the private route is not asserted to pass through it. Arithmetic can reject the division before a coordinate is chosen, while the two remaining values still need a legal geometric realization.

The arithmetic pass is a relaxation of the puzzle; solving it still leaves the full route to find. It is allowed to retain schedules that geometry will later reject. Its safety depends on the opposite condition: every legal complete route must leave an arithmetic trace that survives. A smaller search is useful only while the reductions preserve the answer being sought.

Forced clues divide the search

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 private 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.

The distance test must remain a lower bound. A relaxed neighbor graph may allow tower choices or revisits that a completed route cannot use. Its distance is therefore optimistic: if even that distance is too large, the legal route cannot reach the target in time. It does not make a distance-feasible segment valid. Conversely, pruning with an over-restrictive graph could remove a real solution. The proof obligation is that every legal continuation is represented in the relaxation.

The route has to pass every rule

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; the search’s “found” flag cannot substitute for those checks.

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.

Certifying-computation research describes a producer supplying an output and witness for a checker to test against the input. Alkassar and colleagues’ formalization exposed a checker missing a necessary graph-membership condition. I take a concrete lesson from that example: reusing the search’s move routine can make two programs agree on the same wrong rule.

There is an important asymmetry between the claims. A fully checked route demonstrates feasibility under the modeled rules. It cannot show that a pruning rule never discarded a different valid route, that the solution is unique, or that no shorter route exists. Those claims would need additional certificates or an argument about the search space. I do not obtain them merely by validating that route.

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

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

The recorded 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. Reaching the last tower completes the route. The last path score belongs to that verified route, while the puzzle answer comes from a separate neighbor-sum calculation over the squares the knight never visited.

The path has 54 moves and recomputes to 33,609, matching Jane Street’s official July 2026 answer.

The official route has a downloadable checker

The October 23, 2026 public check makes a complete public route available to inspect. Codex transcribed the 55 visited squares, 13 shaded towers and printed scores from Jane Street’s official July solution image, using the original puzzle board for regions and clues. The certificate and Python checker use files A–H from left to right and ranks 1–8 from bottom to top; A1 is the start.

The standalone checker recomputes every three-dimensional move and score, compares all 12 clue recordings, checks one tower per region, and requires the route to stop when the last tower is first reached. The public fixture passes: 54 moves, K = 7 and tower completion at move 54. Eleven selected corruption checks reject damaged towers, coordinates, timing, scores and other constraints. These results concern the transcribed official route. They leave the private solver’s execution and coordinate match unchecked.

The final path score is 59,400. The puzzle answer is the sum below: 33,609 across nine unvisited squares. A visited score can contribute to more than one neighbor sum. E1’s 7,440 counts beside both D1 and F1; deduplicating that contribution would change the requested calculation. The full route audit and the bundle’s clue, board and neighbor tables expose the intermediate values.

The public check tests consistency between the transcribed certificate and the encoded rules. Independent review of the image transcription and rule interpretation would strengthen it.

The public-certificate check is implemented for the official route. Exporting and independently checking the private solver’s route remain unimplemented proposals.

python3 july_2026_knight_verifier.py
python3 check_negative_cases.py

The next verifier needs its own assumptions

The public-route certificate is downloadable. For my private solver, I would publish the region map, tower positions, path, K, timing interpretation, and answer calculation in a stable input record that a second checker can read directly, deriving its own coordinate and score logic from the puzzle instead of borrowing the search helpers. More randomized search would leave a common interpretation error untouched.

I would challenge a private-route checker with plausible wrong paths. An altered tower can leave the planar path unchanged while changing altitude and score. Inexact downward division, shifted clue timing, repeated squares, and continuation beyond tower completion should each fail for their own reasons. The public bundle rejects eleven named corruptions; small synthetic boards could exercise cases missing from that route.

A formal checker would be a stronger alternative for assurance about the encoded rules. It would still leave the translation of Jane Street’s prose into those rules to review. For the private solver, independently implemented certificate checking remains the immediate useful step: make its existing path portable before making a broader claim about the search.

A route someone else can check

Finding the route took a staged search. Explaining the private route should require much less machinery: the board, tower assignment, timing rule, and those 54 moves. The public-route bundle exposes a portable certificate and checker; the private route still needs that independent check. Uniqueness, optimality, and safe pruning concern the paths never taken. A checked route establishes the one that was.