Classify lattice knots.

Current blind classification and total costs

The original 105 eight-crossing cases now have 105 correct identifications, 0 incorrect and 0 unknown. Every original unknown was retried unchanged. The newer pilot has 20 correct, 0 incorrect and 4 unknown across 24 independently scrambled queries at nine through twelve crossings, each against all 2,977 prime bank references. This pilot covers eight predeclared query types and three seeds each; it does not exhaustively test all 2,977 types.

All failed retries remain in these totals, including the unsuccessful ten-minute attempt. The final original unknown was found using a generic fair portfolio of neutral move orderings, with identical orderings and aggregate budgets in both lanes. All lattice move locations remain unrestricted. Shared input preparation totals 654.08 seconds; independent stage audits total 357.26 seconds; new-stage artifact assembly/compression totals 16.70 seconds before final manifest writes. These common costs are separate from the lane totals. Brute-force unknowns prevent an equal-success speedup claim.

Full twelve-crossing-bank pilot · Final original-case retry · Immutable original experiment · Machine-readable totals.

Retry: 6 remaining unknowns at 60 seconds per query

Online GCTS: 3 correct / 0 incorrect / 3 unknown. Brute force: 0 correct / 0 incorrect / 6 unknown. The unchanged inputs are every marked unknown from the preceding immutable stage, against the same complete 35-reference bank. Both lanes run every selected case, even when the brute lane had additional earlier unknowns. No query was replaced or rescrambled.

Matched aggregate budgets: 60 seconds, 20,000 expansions, 200,000 live visited states, sixteen moves and 240 unit edges per query. All incident lattice face locations remain available. Both lanes use the same fair resumable DFS, neutral seed and exact inventory memoization. The marked lane starts empty and reuses only its own online proofs across query knot types. No invariant, knot-specific ordering, patch restriction, saved markings or construction path is supplied.

Cumulative original 105-case outcomes, retaining all previous retry work: marked: 102 correct / 0 incorrect / 3 unknown, 746.28 lane seconds, 3,281 search expansions and 1,244,028 proof/validation nodes; brute: 0 correct / 0 incorrect / 105 unknown, 1410.66 lane seconds, 16,187 search expansions and 0 proof/validation nodes. The brute lane’s other original unknowns have not been retried. Shared original preparation and every independent stage audit remain separate common costs.

Elapsed lane totals include the full reference graph, failed references and contours, exact cache warmup, online probes and activation/transfer validation, JS certificate replay, cold initialization and archival/checkpoints. Shared preparation: 0.00 seconds. Independent stage audit: 4.27 seconds. These are reported separately. Brute-force unknowns prevent an equal-success speedup claim.

Root markings exclude 203 reference choices under the finite horizon. Local child markings eliminate 234,660 of 241,164 base-legal options in complete extension graphs; root proofs have 1,695 applications learned on earlier queries of different evaluator knot types. Whole-discrepancy root proofs and local supports of at most 48 edges are distinct. Unknown probes supply no hard exclusion.

Marked unknowns: \(8_{19}\), seed 2, \(8_{14}\), seed 2, \(7_{2}\), seed 2. Independent Python checks 41 provenance movies, 3 scored paths, 2,097 extension proofs and 12,622 resolved cover labels, along with full bank coverage, fixed input selection, root composition and cost/catalog continuity.

Every input, outcome, cost and certificate · Proof archive part 1 · Independent stage audit · Contract and limitations.

This remains a declared point-valued graph-path adaptation of GCTS. The fixed projection and single-Reidemeister/routing author grammar remain inventory restrictions; no general lattice-isotopy completeness claim is made. Finite failures stay unknown. Arbitrary-input recognition, negative certificates, separate mirrors/composites and RL remain open.

Retry: 3 remaining unknowns at 180 seconds per query

Online GCTS: 2 correct / 0 incorrect / 1 unknown. Brute force: 0 correct / 0 incorrect / 3 unknown. The unchanged inputs are every marked unknown from the preceding immutable stage, against the same complete 35-reference bank. Both lanes run every selected case, even when the brute lane had additional earlier unknowns. No query was replaced or rescrambled.

Matched aggregate budgets: 180 seconds, 20,000 expansions, 200,000 live visited states, sixteen moves and 240 unit edges per query. All incident lattice face locations remain available. Both lanes use the same fair resumable DFS, neutral seed and exact inventory memoization. The marked lane starts empty and reuses only its own online proofs across query knot types. No invariant, knot-specific ordering, patch restriction, saved markings or construction path is supplied.

Cumulative original 105-case outcomes, retaining all previous retry work: marked: 104 correct / 0 incorrect / 1 unknown, 1178.96 lane seconds, 6,189 search expansions and 1,285,132 proof/validation nodes; brute: 0 correct / 0 incorrect / 105 unknown, 1436.96 lane seconds, 21,259 search expansions and 0 proof/validation nodes. The brute lane’s other original unknowns have not been retried. Shared original preparation and every independent stage audit remain separate common costs.

Elapsed lane totals include the full reference graph, failed references and contours, exact cache warmup, online probes and activation/transfer validation, JS certificate replay, cold initialization and archival/checkpoints. Shared preparation: 0.00 seconds. Independent stage audit: 2.98 seconds. These are reported separately. Brute-force unknowns prevent an equal-success speedup claim.

Root markings exclude 102 reference choices under the finite horizon. Local child markings eliminate 439,779 of 453,590 base-legal options in complete extension graphs; root proofs have 601 applications learned on earlier queries of different evaluator knot types. Whole-discrepancy root proofs and local supports of at most 48 edges are distinct. Unknown probes supply no hard exclusion.

Marked unknowns: \(7_{2}\), seed 2. Independent Python checks 38 provenance movies, 2 scored paths, 1,017 extension proofs and 6,044 resolved cover labels, along with full bank coverage, fixed input selection, root composition and cost/catalog continuity.

Every input, outcome, cost and certificate · Proof archive part 1 · Independent stage audit · Contract and limitations.

This remains a declared point-valued graph-path adaptation of GCTS. The fixed projection and single-Reidemeister/routing author grammar remain inventory restrictions; no general lattice-isotopy completeness claim is made. Finite failures stay unknown. Arbitrary-input recognition, negative certificates, separate mirrors/composites and RL remain open.

Retry: 1 remaining unknowns at 600 seconds per query

Online GCTS: 0 correct / 0 incorrect / 1 unknown. Brute force: 0 correct / 0 incorrect / 1 unknown. The unchanged inputs are every marked unknown from the preceding immutable stage, against the same complete 35-reference bank. Both lanes run every selected case, even when the brute lane had additional earlier unknowns. No query was replaced or rescrambled.

Matched aggregate budgets: 600 seconds, 20,000 expansions, 200,000 live visited states, sixteen moves and 240 unit edges per query. All incident lattice face locations remain available. Both lanes use the same fair resumable DFS, neutral seed and exact inventory memoization. The marked lane starts empty and reuses only its own online proofs across query knot types. No invariant, knot-specific ordering, patch restriction, saved markings or construction path is supplied.

Cumulative original 105-case outcomes, retaining all previous retry work: marked: 104 correct / 0 incorrect / 1 unknown, 1778.99 lane seconds, 9,908 search expansions and 1,298,754 proof/validation nodes; brute: 0 correct / 0 incorrect / 105 unknown, 1440.88 lane seconds, 22,705 search expansions and 0 proof/validation nodes. The brute lane’s other original unknowns have not been retried. Shared original preparation and every independent stage audit remain separate common costs.

This stage additionally applies whole-window continuation proofs to child discrepancy components larger than 48 edges, using the existing root catalog and its 64-node/sixteen-horizon probes. Per-component maximum proved bounds compose only across disjoint face alphabets. These broader child constraints are reported separately from local transfer; all their learning/validation costs and evidence are in the root channel.

Elapsed lane totals include the full reference graph, failed references and contours, exact cache warmup, online probes and activation/transfer validation, JS certificate replay, cold initialization and archival/checkpoints. Shared preparation: 0.00 seconds. Independent stage audit: 2.32 seconds. These are reported separately. Brute-force unknowns prevent an equal-success speedup claim.

Root markings exclude 34 reference choices under the finite horizon. Local child markings eliminate 627,932 of 648,844 base-legal options in complete extension graphs; root proofs have 0 applications learned on earlier queries of different evaluator knot types. Whole-discrepancy root proofs and local supports of at most 48 edges are distinct. Unknown probes supply no hard exclusion.

Marked unknowns: \(7_{2}\), seed 2. Independent Python checks 36 provenance movies, 0 scored paths, 417 extension proofs and 2,152 resolved cover labels, along with full bank coverage, fixed input selection, root composition and cost/catalog continuity.

Every input, outcome, cost and certificate · Proof archive part 1 · Independent stage audit · Contract and limitations.

This remains a declared point-valued graph-path adaptation of GCTS. The fixed projection and single-Reidemeister/routing author grammar remain inventory restrictions; no general lattice-isotopy completeness claim is made. Finite failures stay unknown. Arbitrary-input recognition, negative certificates, separate mirrors/composites and RL remain open.

Retry: 1 remaining unknowns at 900 seconds per query

Online GCTS: 1 correct / 0 incorrect / 0 unknown. Brute force: 0 correct / 0 incorrect / 1 unknown. The unchanged inputs are every marked unknown from the preceding immutable stage, against the same complete 35-reference bank. Both lanes run every selected case, even when the brute lane had additional earlier unknowns. No query was replaced or rescrambled.

Matched aggregate budgets: 900 seconds, 20,000 expansions, 200,000 live visited states, sixteen moves and 240 unit edges per query. All incident lattice face locations remain available. Both lanes use the same fair resumable DFS, neutral seed and exact inventory memoization. The marked lane starts empty and reuses only its own online proofs across query knot types. No invariant, knot-specific ordering, patch restriction, saved markings or construction path is supplied.

Cumulative original 105-case outcomes, retaining all previous retry work: marked: 105 correct / 0 incorrect / 0 unknown, 1791.06 lane seconds, 9,973 search expansions and 1,312,816 proof/validation nodes; brute: 0 correct / 0 incorrect / 105 unknown, 1445.11 lane seconds, 24,340 search expansions and 0 proof/validation nodes. The brute lane’s other original unknowns have not been retried. Shared original preparation and every independent stage audit remain separate common costs.

This stage additionally applies whole-window continuation proofs to child discrepancy components larger than 48 edges, using the existing root catalog and its 64-node/sixteen-horizon probes. Per-component maximum proved bounds compose only across disjoint face alphabets. These broader child constraints are reported separately from local transfer; all their learning/validation costs and evidence are in the root channel.

Both lanes use a fair portfolio of neutral move-order seeds 31, 73, 131, 197. Each reference retains one root candidate; all ordering/contour contexts share the same aggregate time, node and live-state limits. These are generic permutations, with no knot label or learned ordering policy.

Elapsed lane totals include the full reference graph, failed references and contours, exact cache warmup, online probes and activation/transfer validation, JS certificate replay, cold initialization and archival/checkpoints. Shared preparation: 0.00 seconds. Independent stage audit: 2.49 seconds. These are reported separately. Brute-force unknowns prevent an equal-success speedup claim.

Root markings exclude 34 reference choices under the finite horizon. Local child markings eliminate 10,857 of 11,324 base-legal options in complete extension graphs; root proofs have 0 applications learned on earlier queries of different evaluator knot types. Whole-discrepancy root proofs and local supports of at most 48 edges are distinct. Unknown probes supply no hard exclusion.

Marked unknowns: none. Independent Python checks 36 provenance movies, 1 scored paths, 441 extension proofs and 2,257 resolved cover labels, along with full bank coverage, fixed input selection, root composition and cost/catalog continuity.

Every input, outcome, cost and certificate · Proof archive part 1 · Independent stage audit · Contract and limitations.

This remains a declared point-valued graph-path adaptation of GCTS. The fixed projection and single-Reidemeister/routing author grammar remain inventory restrictions; no general lattice-isotopy completeness claim is made. Finite failures stay unknown. Arbitrary-input recognition, negative certificates, separate mirrors/composites and RL remain open.

Scaling pilot: full prime reference bank through 12 crossings

Online GCTS: 20 correct / 0 incorrect / 4 unknown. Brute force: 0 correct / 0 incorrect / 24 unknown. Every query is tested against all 2,977 prime reference types through twelve crossings. Queries cover the predeclared first and last corpus type at each crossing count nine through twelve, three independent eight-move scrambles each: 24 queries across eight types. These eight bank references are independently eight-move scrambled; the remaining 2,969 references use canonical embeddings. This is a representative query pilot against a complete bank, not exhaustive query testing of all 2,977 types.

Matched aggregate budgets: 120 seconds, 5,000 expansions, 100,000 live visited states, sixteen moves and 240 unit edges per query. All incident lattice face locations remain available. Both lanes use the same fair resumable DFS, neutral seed and exact inventory memoization. The marked lane starts empty and reuses only its own online proofs across query knot types. No invariant, knot-specific ordering, patch restriction, saved markings or construction path is supplied.

Selected types: \(9_{1}\), \(9_{49}\), \(10_{1}\), \(10_{165}\), \(11a_{1}\), \(11n_{185}\), \(12a_{1}\), \(12n_{888}\). Neither their names, crossing counts, seeds, histories nor correct bank indices enter the search. Every query and reference is fixed before either lane runs.

This stage additionally applies whole-window continuation proofs to child discrepancy components larger than 48 edges, using the existing root catalog and its 64-node/sixteen-horizon probes. Per-component maximum proved bounds compose only across disjoint face alphabets. These broader child constraints are reported separately from local transfer; all their learning/validation costs and evidence are in the root channel.

Both lanes use a fair portfolio of neutral move-order seeds 31, 73, 131, 197. Each reference retains one root candidate; all ordering/contour contexts share the same aggregate time, node and live-state limits. These are generic permutations, with no knot label or learned ordering policy.

Elapsed lane totals include the full reference graph, failed references and contours, exact cache warmup, online probes and activation/transfer validation, JS certificate replay, cold initialization and archival/checkpoints. Shared preparation: 293.48 seconds. Independent stage audit: 320.22 seconds. These are reported separately. Brute-force unknowns prevent an equal-success speedup claim.

Root markings exclude 71,423 reference choices under the finite horizon. Local child markings eliminate 342,624 of 352,978 base-legal options in complete extension graphs; root proofs have 2,057,226 applications learned on earlier queries of different evaluator knot types. Whole-discrepancy root proofs and local supports of at most 48 edges are distinct. Unknown probes supply no hard exclusion.

Marked unknowns: \(11n_{185}\), seed 0, \(11n_{185}\), seed 2, \(11a_{1}\), seed 0, \(12n_{888}\), seed 2. Independent Python checks 32 provenance movies, 20 scored paths, 167,686 extension proofs and 1,904,681 resolved cover labels, along with full bank coverage, fixed input selection, root composition and cost/catalog continuity.

Every input, outcome, cost and certificate · Proof archive part 1 · Proof archive part 2 · Proof archive part 3 · Proof archive part 4 · Independent stage audit · Contract and limitations.

This remains a declared point-valued graph-path adaptation of GCTS. The fixed projection and single-Reidemeister/routing author grammar remain inventory restrictions; no general lattice-isotopy completeness claim is made. Finite failures stay unknown. Arbitrary-input recognition, negative certificates, separate mirrors/composites and RL remain open.

Blind classification: all 35 prime knots through eight crossings

Online GCTS: 99 correct, 0 incorrect, 6 unknown out of 105. Brute force: 0 correct, 0 incorrect, 105 unknown. Every input is tested against the complete shuffled bank of 35 independently scrambled lattice references. The solver receives only vertex arrays; knot names, crossing labels, correct reference indices, seeds and construction histories stay in the evaluator. A label is attached only after a full lattice move certificate passes replay.

Each bank reference and each query has eight independently sampled lattice moves, deeper than the earlier five-move experiment. Three fresh query seeds per type give 105 cases, with fixed seeded query and bank permutations and no discarded or replaced cases. Eight sampled moves do not imply eight minimum moves: this measures recognition of nearby, known scrambled representatives. The bank excludes the unknot, separately scored mirrors, composites and outside-bank queries.

The classifier now uses a generic resumable depth-first path search, scheduled round-robin across references, one complete expansion per turn. Both lanes use this same scheduler and neutral move seed. Contours increase through a sixteen-move horizon; proved root markings may skip impossible shorter contours. Every incident lattice face remains available throughout the knot. There is no small-patch restriction. The fixed projection \((11,13,17)\), single-Reidemeister/routing endpoint grammar and finite edge/arithmetic bounds remain declared inventory restrictions.

Matched aggregate limits per query are ten seconds, 5,000 expansions, 100,000 simultaneous visited states, sixteen moves and 240 unit edges. Time includes the complete reference graph, wrong-reference searches, failed contours, online proof probes, activation/transfer checks, cache warmup and JavaScript certificate replay. A deadline during verification leaves the query unknown. Atomic operations can slightly overrun the time boundary. Both workers start fresh; only the marked worker reuses its own newly proved catalog across the mixed types.

Total lane time includes cold model construction and inter-query proof archival/checkpoint overhead through the final snapshot. Common input preparation took 360.60 seconds. Subsequent independent replay took 24.98 seconds; neither common preparation nor external replay is hidden in one lane. Brute-force unknowns prevent an equal-success speedup claim.

The marked lane additionally performs 1,164,830 relaxed-cover and capacity probe/validation nodes, including full activation checks; brute force performs 0. These cheap proof nodes are accounted separately from geometric search expansions, and their elapsed cost is already included in the totals. JavaScript certificate replay contributes 7.21 seconds in the marked lane.

Marked unknowns: \(8_{19}\), seed 2, \(8_{14}\), seed 2, \(7_{2}\), seed 2, \(8_{17}\), seed 2, \(8_{12}\), seed 2, \(8_{8}\), seed 2. The complete results preserve their reasons and all attempted work. All 35 types have positive identifications on at least two independent query seeds, with ten- to sixteen-move recovered paths. The recovered paths use routing and Reidemeister I/II moves; this run does not exercise type III.

What the markings actually prune

The root learner additionally probes whole finite edge-discrepancy components, up to 480 edges, against every touching face, with sixteen-move cover budgets and 64 probe nodes. This relaxed cover is a necessary condition for a lattice path. Proved negative cover labels compile to incompatible \(m\)-values on the complete reference-choice graph; they exclude 3,569 reference candidates within the declared horizon. These are global root-window proofs, separate from the child learner's local supports of at most 48 edges and 512-node probes. Neither proof assigns a knot name or proves inequivalence.

Within expanded marked states, local extension markings eliminate 274,326 of 285,353 base-legal move options in completed extension graphs, leaving 11,027; capacity markings reject 154,677 raw options before full author resolution. The full marked run expands 1,737 nodes, versus 13,104 without markings. These counters distinguish within-state pruning from fewer visited states; they do not attribute the combined classifier benefit solely to local transfer. Both catalogs start empty, validate new labels once and retain immutable evidence. Root proofs have 39,114 applications learned on earlier queries, including 37,720 across different evaluator knot types; labels are used only to measure that transfer afterward. Unknown probes create no hard exclusions.

This is a point-valued graph-path adaptation of GCTS, with complete forward/reverse candidate incidence. It is not a global space-time tiling or the reference neighboring-pair/corona learner. The generic driver sees opaque keys and point values, while the author adapter and independent verifier define legal lattice moves. RL and cluster proposals are still unimplemented.

Coverage across seeds and types

Independent Python verifies all 140 scramble movies, 99 scored identification movies, 20,030 newly learned extension proofs and 152,759 resolved cover labels. It rebuilds the full face alphabets and checks root discrepancy composition, catalog continuity, reference-bank coverage, seed coverage and cost accounting. Any finite failure remains unknown. General lattice-isotopy completeness, arbitrary-input recognition, negative certificates and twelve-crossing classification remain open.

Every input, reference, outcome, cost and certificate · All online proof events, compressed JSONL · Independent audit and per-type scores · Algorithm contract, controls and gaps · Benchmark harness · Independent verifier.

node scripts/prepare-blind-knots.mjs --directory=/tmp/knot-blind35
node scripts/benchmark-blind-lattice-knots.mjs --directory=/tmp/knot-blind35 --lane=marked
node scripts/benchmark-blind-lattice-knots.mjs --directory=/tmp/knot-blind35 --lane=brute
python3 scripts/finalize-blind-knot-report.py /tmp/knot-blind35
python3 scripts/verify-blind-lattice-knots.py research/knot-classifier/lattice-blind-benchmark.json

The selected formulation: lattice move paths with GCTS markings

The classifier searches the graph of exact lattice embeddings. A node is a whole knot; an edge is a checked reversible lattice move. The pair-search implementation uses bidirectional search from both endpoints and joins two parent paths; the newer blind-bank benchmark above uses fair resumable depth-first contours. This directly matches the equivalence question and does not require filling a space-time volume. A verified path can still be rendered as a knot movie.

The engine sees opaque keys, complete candidate domains and point values. At each state there is one choice point, with unit \(t\) for every move. Seam \(m\)-values encode opaque endpoint agreement. Online local extension failures produce proved failed-budget \(m\)-values; boundary disagreement removes candidates through the point/candidate graph. Unknown probes add no exclusions. These are real candidate markings in a declared graph-path adaptation. Space-time exact tiling and the reference neighboring-tile/corona learner remain separate formulations.

No knot name, invariant, crossing label, ancestor, scramble history or preferred move type enters search. The author adapter and independent verifier define legal lattice moves. Every incident face throughout the knot remains available under the existing fixed-projection grammar and finite edge bounds. Learned profiles are validated once and kept immutable, preserving the earlier transfer-cost improvement.

Testing a different tree scheduler

Balanced scheduling expands the shallower breadth-first wave. Adaptive scheduling expands the smaller pending frontier, with depth breaking ties. Each wave retains complete layer enumeration and shortest-prefix bookkeeping. As the two radii grow, any allowed path within their sum crosses both retained balls, so changing which side expands preserves bounded path existence. This is a specialized graph scheduler; the reference tiling generation rule is not claimed.

The four-lane pilot uses two unchanged existing pairs: \(3_{1}\), seed 0, and the harder \(8_{1}\), seed 1. Both endpoints have five independently sampled lattice moves. Each lane starts fresh; marked lanes reuse only their own newly learned catalog across the two types. All four lanes share horizons zero through ten, a 120-second aggregate query budget, 5,000 expanded nodes, 200,000 live states, 240 unit edges, complete move inventories and the same neutral seed. No cases are replaced. Times include repeated horizons, probes, validation, memoization warmup and JavaScript certificate verification.

Both marked schedulers identify both pairs, with eight- and ten-move certificates. Adaptive scheduling saves five expansions on the trefoil and saves none on the harder eight-crossing pair; their total times are essentially equal. This pilot establishes no marked identification advantage, so balanced bidirectional search remains the pair-search default. Adaptive brute force spends less total time before reaching its limits, while both pairs remain unknown. GCTS is the effective pruning mechanism on these cases. Brute-force unknowns provide no equal-success timing comparison.

The generic scheduler tests cover 1,536 exhaustive graph/budget/marking combinations against an independent reachability oracle. An asymmetric control uses 54 expansions with balanced scheduling and four with adaptive scheduling; that demonstrates a possible benefit, rather than a knot-specific performance claim. Independent Python replay checks 8 spatial movies and 1,567 resolved local proof labels in 0.32 seconds after the timed runs.

The larger earlier result remains 18 identified independent pairs through eight crossings. This two-case scheduler pilot does not expand recognition coverage. The newer blind-bank benchmark above extends recognition coverage with deeper scrambles; mirrors, composites, arbitrary inputs and twelve-crossing scaling remain acceptance gates. RL, if added, should propose validated move clusters with complete base-move fallback.

Four-lane evidence and certificates · Path-search formulation, proof scope and gaps · Generic scheduler tests · Reproduction harness.

Nontrivial identifications through eight crossings

The repeated transfer-validation bottleneck is removed. Each new local rule is checked against its complete incident-face alphabet, every resolved label and its stencil before activation; its nested evidence is then frozen in a private native catalog. Read-only views and sealed configuration prevent replacement. Normal transfer checks neither scan the catalog nor replay proofs. An explicit full-audit mode remains available. Once-only proof validation costs are included below.

The enlarged comparison uses 18 unchanged pairs from the earlier 105-pair matrix: the first prime reference at each crossing count from three through eight, with all three original seed pairs. Both endpoints still have five independently sampled lattice moves. No seed or endpoint is replaced. Every incident face throughout each knot is available, with no move-support patch. The fixed regular projection and single-Reidemeister endpoint grammar are unchanged.

Both lanes use exact query-local memoization of full signed-diagram endpoint maps and the same generic increasing-horizon schedule. They try horizons zero through ten, advancing only after complete finite exhaustion. Aggregate bounds are 5,000 expanded nodes and 60 seconds per initial query; the live-state limit is 200,000 per horizon. Remaining marked unknowns receive matched 120-second retries in both lanes. All failed first-attempt and repeated-horizon costs remain charged. No knot label, invariant, scramble history or construction route enters search.

Marked totals include 0.354 seconds of learning probes, 0.704 seconds of once-only activation validation, 6.734 milliseconds of transfer checks and 21.099 seconds of JavaScript certificate verification. Marked graphs remove 1,036,378 of 1,083,819 legal candidates (95.62%). Different stages start fresh native models and transfer only within that stage; restarting and relearning are included in these costs.

These are positive pair identifications, including eight-crossing movies, with independent spatial endpoint replay. When brute force remains unknown, total-cost differences establish solved-versus-unknown behavior rather than an equal-success speedup factor. This enlarged experiment covers six representative types, not all 35 types at the larger budget; the complete earlier matrix remains below. Reference-bank selection, separate mirrors, composites, general isotopy completeness and twelve-crossing scaling remain open.

Independent replay verifies 62 lattice movies and 20,791 resolved local labels, in 2.57 seconds after the timed runs. Inputs are reused, so no new scramble-generation cost is charged; the original common cost was 292.77 seconds. Query times include every repeated construction and cache warmup.

All stages, bounds, proof catalogs and spatial certificates · Immutable-cache and algorithm contract · Reproduction harness · Independent verifier.

node scripts/benchmark-lattice-escalation.mjs
node scripts/benchmark-lattice-escalation.mjs --retry-report=research/knot-classifier/lattice-escalation-benchmark.json --max-ms=120000 --directory=/tmp/knot-escalation-retry --output=/tmp/knot-escalation-retry.json
node tests/test_knot_lattice_cached.mjs
python3 scripts/verify-lattice-escalation.py research/knot-classifier/lattice-escalation-benchmark.json

Earlier six-second matrix: all prime types through eight crossings

All 35 corpus prime types through eight crossings were tested with three predetermined seed pairs per type: 105 queries, five independent lattice moves per endpoint, and no discarded cases. Walk length is not minimum move distance. Every incident lattice face remains available throughout both knots; no move-support patch is imposed. The search receives only endpoint vertices. Labels, common ancestors and scramble histories stay in the evaluator.

Measured result: brute force identifies 0 queries and leaves 105 unknown; the marking lane identifies 0 and leaves 105 unknown. No case produces a certificate in both lanes, so this experiment establishes no equal-success timing speedup. Each query has the same bounds: ten moves, 240 unit edges, 200 expanded nodes, 30,000 stored states and six seconds including learning and transfer replay. Local probes have a 512-node limit; unfinished probes remain unresolved. Atomic operations may overrun the deadline; the maximum measured overrun is 16.94 milliseconds.

The marked lane starts with an empty model, then retains its in-memory local proof catalog across all seeds and knot types. Full incident-face alphabets, every resolved proof label and assigned stencil values are checked before transfer. No archived assignments are loaded. Time-interrupted samples remain unconstrained; interrupted transfer validation leaves the whole query unknown.

Actual marked candidate graphs remove 215,539 of 241,495 legal candidates (89.25%). Across completed state domains, mean available choices are 140.55 for brute force and 14.83 with markings. These averages cover different visited states. Expanded nodes are 3,231 / 1,855; branching states are 3,126 / 1,750. At a fixed time limit, fewer processed branches can also reflect learning overhead; candidate elimination is evidence of pruning, not by itself a speedup.

Total query cost is 630.29 seconds unmarked and 630.37 seconds marked. The latter includes 0.816 seconds of local proof searches and 123.422 seconds of transfer replay. Peak resident memory is 333.7 / 320.0 MiB. Common input generation took 292.77 seconds; independent archive verification took 8.17 seconds and replayed 210 spatial movies plus 45,789 resolved proof labels. Both extra costs are reported separately from query times.

Classification scope: this tests positive equivalence of supplied endpoint pairs across every prime reference type through eight crossings. It does not test blind reference-bank selection or negative pairs. Composite knots, separate mirror cases, the unknot, RL and a complete decision procedure remain open. The fixed regular projection and single-Reidemeister endpoint grammar remain declared restrictions; only move locations are unrestricted. An unknown query is never reported as inequivalent. All 105 construction witnesses are independently checked, even when the search cannot recover a movie.

Every input, seed, outcome, cost, new proof and certificate · Benchmark bounds and conformance scope · Reproduction harness · Independent verifier.

node scripts/benchmark-lattice-through8.mjs
node tests/test_knot_lattice_budgets.mjs
python3 scripts/verify-lattice-through8.py research/knot-classifier/lattice-through8-benchmark.json