Test a canonical eight-way second-level partition of the oversized 21182-profile depth-four internal orbit 1 using an optimized C++ record producer, with a separately implemented exhaustive Python count control.

checkpointed canonical pair-surplus augmentation

Compress labelled four-row prefixes to canonical residual multiplicity tables, then split an oversized internal-orbit chunk by a deterministic function of the canonical table before parent-rich materialization.

Hypothesis: Eight low-three-bit FNV-1a buckets of the canonical 70-entry residual table partition all 21182 orbit-1 profiles exactly once with every bucket at most 5000 records and thereby qualify a parent-rich clean/resume pilot.

Test: Materialize the first C++ bucket under the frozen cap and, on failure, independently enumerate the exact eight-bucket vector in Python; a single bucket above 5000 falsifies the proposed job shape.

One over-cap bucket is decisive against the proposed job shape. The independent exact enumeration excludes a serialization-only explanation and shows the structural low-bit collapse. Because no parent-rich union or terminal SAT/UNSAT certificate was validated, the evidence supports only tactical progress and a redirect.

• For all canonical depth-four profiles in internal orbit 1, the frozen low-three-bit FNV owner function has exact bucket counts [5204,0,5558,0,5246,0,5174,0].
• The proposed FNV8 partition cannot satisfy max_records_per_bucket=5000 because its maximum bucket contains 5558 profiles.
• The exact bucket vector sums to the independently retained orbit-1 canonical count 21182 and arises from 78278 raw residual multiplicity tables.

• python3 scripts/pair_surplus_depth4_orbit1_subchunks_v1.py ... --stop-after 3 --max-records-per-bucket 5000: stopped with AssertionError after C++ bucket 0 emitted 5204 records
• python3 checkers/check_pair_surplus_depth4_orbit1_fnv8_counts_v1.py --producer-bucket artifacts/epoch110-20260812/orbit1-fnv8-lowbits-bucket00.json --out artifacts/epoch110-20260812/orbit1-fnv8-count-control.json: PASS_INDEPENDENT_FNV8_COUNT_CONTROL
• computational-researcher harness experiment 20260812-061859-5a30ac: return code 0, 28.407 seconds, 38392 KiB peak child memory

• .proof-experiments/20260812-061734-5a76a4: C++ bucket 0 emitted 5204 records; wrapper rejected the over-cap bucket in 0.575 seconds.
• .proof-experiments/20260812-061859-5a30ac: independent Python exact enumeration returned [5204,0,5558,0,5246,0,5174,0] and PASS in 28.407 seconds.

checkers/check_pair_surplus_depth4_orbit1_fnv8_counts_v1.py independently enumerates all 78278 raw tables and 21182 canonical profiles and agrees with C++ bucket 0. It validates aggregate partition counts, not the unreviewed deletion-parent fields.

not_requested

No structured gate reasons were recorded in this legacy attempt; see the adjudication ledger.

Original model outcome

no_progress

Public classification

no_progress

None recorded.

• The exact low-three-bit FNV8 load vector on internal orbit 1 is [5204,0,5558,0,5246,0,5174,0].
  artifacts/epoch110-20260812/orbit1-fnv8-count-control.json, produced by exhaustive Python enumeration and agreeing with C++ bucket 0 · All canonical residual multiplicity tables of depth-four internal orbit index 1 · computed
• The FNV8 low-bit partition violates the 5000-record cap; its maximum is bucket 2 with 5558 profiles.
  Exact eight-bucket count receipt and predeclared cap · The frozen partition and cap only · computed
• All odd low-bit FNV buckets are necessarily empty for these multiplicity tables.
  The offset basis and multiplier are odd, so bit 0 after all XOR/multiply steps is 1 XOR (sum of multiplicity parities) = 1 XOR (11 mod 2) = 0. · All 70-byte nonnegative multiplicity tables with total multiplicity 11 under the frozen FNV-1a recurrence · proved

• Use the low three bits of FNV-1a-64 over the canonical 70-byte table as eight orbit-1 subchunks under max_records_per_bucket=5000.
  All 21182 canonical profiles of depth-four internal orbit 1 · Only even buckets are populated and the exact maximum is 5558. · artifacts/epoch110-20260812/orbit1-fnv8-count-control.json · A refined owner function using additional or better-mixed bits that independently splits the four populated classes and has exact maximum at most 5000.

• High-bit or mixed-bit canonical hash partition
  The low-bit failure is a parity artifact, while exact count-only preflight costs only about 28 seconds in Python and should be much faster in C++. · Compute exact load vectors for high three bits and one explicit mixed-bit projection without emitting records; accept only maximum at most 5000. · high · open
• Canonical residual-table prefix refinement
  A prefix decision is transparent and avoids arithmetic hash correlations, but its skew must be measured exactly. · Enumerate prefix frequency tables for orbit 1 and choose a deterministic refinement tree whose leaves are all at most 5000, then independently check exact union. · normal · open
• Constructive 30-cover search with a materially new generator
  A checked 30-block list remains the cheapest terminal certificate if a new mechanism can outperform prior UNKNOWN searches. · Do not rerun prior incidence seeds; first specify a new structural generator or neighborhood with a falsifiable short pilot. · normal · open

Objective: Qualify a balanced canonical second-level owner function for orbit 1 before any further record materialization.

First action: Run an exact count-only C++ and independent Python comparison for high-three-bit FNV and a canonical-prefix alternative over the same 21182 profiles.

Stop condition: Redirect immediately if implementations disagree, any bucket exceeds 5000, any owner is undefined/noncanonical, or the partition has unexplained degeneracy.

• Replace the low-bit partition with a count-only high-bit or canonical-prefix owner function and independently enumerate its exact orbit-1 load vector.
• Proceed to parent-rich clean/resume materialization only if the exact maximum load is at most 5000.
• After a passing orbit-1 stress pilot, obtain human approval for the revised full-ledger scope; do not submit the epoch-108 lab shape.
• Keep proof-producing PB cubes on hold until a pinned proof emitter and two independent replay paths are available.

• https://www.coveringrepository.com/systems.aspx?k=6&t=3&m=-1 ↗
• https://ljcr.dmgordon.org/cover/show_cover.php?v=15&k=6&t=3 ↗
• https://arxiv.org/abs/math/9502238 ↗

GPT-5.6 Sol principal investigator; two GPT-5.6 Terra delegates supplied advisory route reconnaissance only, and their agreement was not evidence. Deterministic tools: Python 3.12.3, g++ 13.3.0/C++17, exact integer enumeration, SHA-256, retained Burnside/minimum-image machinery, and the computational-researcher harness. The web backend was queried for the supplied direct sources but returned no new renderable content; the pre-acquired epoch-109 source audit was retained. No SAT/PB solver, CAS, proof assistant, cloud lab, external proof service, or human validator produced evidence.; orchestration: gpt-5.6-sol principal with gpt-5.6-terra delegates.

Duration

1335.5s

Review state

evidence receipt failure; not durable progress

Attempt ID

covering-c1563-20260812-062836-f281b6

No human review recorded.