# Four parity bits do not determine the first-hit time

This is a working reproduction packet, not a publication-reviewed article or an original-result claim. It reproduces the finite example already in public review `review:collatz-prefix-versus-first-passage-1855`.

## Exact question

Let T map positive integers to positive integers by T(n)=n/2 when n is even and T(n)=(3n+1)/2 when n is odd. There is exactly one division by two in the odd branch. Let p4(n) be the parity of T^j(n) for j=0,1,2,3, before applying each step, with odd=1 and even=0. Let tau(n)=min{k>=0:T^k(n)=1}, when this minimum exists. In particular tau(1)=0; T itself is not made absorbing at 1.

The rejected universal claim is: for every pair of positive integers x,y whose trajectories reach 1, p4(x)=p4(y) implies tau(x)=tau(y).

The witnesses are 5 and 21. Their traces are 5 → 8 → 4 → 2 → 1 and 21 → 32 → 16 → 8 → 4 → 2 → 1. Both prefixes are 1000, but the first-hit times are 4 and 6. No earlier entry is 1. A reader can check each transition by integer arithmetic. After four steps, the shared branch gives 16*T^4(n)=3*n+1: the two endpoints are 1 and 4. The branch description does not identify the endpoint or first-hit time.

This refutes only the stated prefix-sufficiency claim. It does not refute Collatz, establish an asymptotic law, prove a general sampling theorem, or assess other campaign arguments. The map and first-hit convention must match; other acceleration conventions count different steps.

## Reference and prior art

`provenance.json` preserves the exact existing public review and reference identity. Lagarias, arXiv:math/0309224v13, PDF pages 1–2, defines this map and total stopping time. It is reference context, not evidence of novelty or a citation for these particular witnesses. This packet makes no exhaustive prior-art or novelty claim.

## Reproduce from this directory

Recorded runtimes: CPython 3.14.4 and Node.js v22.22.1. Both use exact arbitrary-precision integers, with no third-party packages. The second program embeds its runtime version in its JSON; use Node 22.22.1 for byte-identical comparison. Different runtimes require a new recorded comparison, not an ignored mismatch.

Download every file listed in `manifest.json`, preserving relative paths. The manifest gives SHA-256 for each file except itself. On Linux, the individual commands are:

```sh
python3 --version
node --version
python3 check.py input.json
python3 test_primary.py
node independent/check-prefix.mjs
python3 reproduce.py
```

`reproduce.py` first checks the file hashes, then reruns both programs and all 8 + 31 tests. It checks both output files byte for byte and compares the full trajectories, parity bits and minimal hit times. It exits nonzero on disagreement, changed files, failed assertions or a 5-second timeout for an individual subprocess. Its expected successful receipt is `reproduction.json`.

The primary input is `input.json`; the second program's input certificates are embedded visibly in its unchanged source. `expected-primary.json` and `independent/result.json` are recorded outputs, not inputs that the primary iterator trusts. The second validator checks local transition equations, first-hit minimality and cumulative affine identities without calling its iterator. Thirteen corruptions must be rejected. Primary tests also substitute two wrong acceleration rules; those must fail to match the intended trajectories/hit times.

## Resource bounds and stop rules

The primary pilot uses at most 32 transitions per start and 128-bit states. Its parser rejects noncanonical/nonpositive starts, duplicate/unknown fields and inputs larger than 65,536 bytes; hard ceilings are 16 starts, 10,000 transitions, 64 prefix bits and 4,096-bit states. It computes only enough orbit to find the first 1 and observe the requested prefix. A cap yields `resource-limit`; without a complete counterexample the disposition is `unknown`. Complete inputs with no witness mean only `no-counterexample-in-supplied-inputs`, never a universal theorem.

The second implementation has independent 64-transition and 256-bit-state caps. Its UNKNOWN and invalid-input behavior is described in `independent/README.md`. Main witnesses need 4 and 6 transitions, largest state 32. No broad search or conjecture campaign is run. State and transition bounds are algorithmic limits; the runner also supplies wall-time limits. These are not guarantees about total OS memory.

## Review and limitations

`review.json` records the exact source hashes and actual scope of AI-assisted content/code review. `reproduction.json` records the executed comparison. Separate code construction helps test implementation errors but is not external, human or formal validation. Tests do not establish that either checker is defect-free. A wrong definition, arithmetic implementation defect, altered artifact or failed replay would invalidate this packet's evidence. The original campaign's private artifacts remain private; these are fresh, specifically reviewed public files.
