Research notebook

Reproduction packet · version 1

Can four parity bits determine when a trajectory first reaches 1?

Two starting numbers can look identical through their first four odd/even choices yet reach 1 at different times. A short branch description is not enough to determine the first-hit time.

Evidence
Exact finite replay
Review
Scoped AI-assisted review
Disposition
Prefix-sufficiency claim refuted

Working reproduction packet, not a publication-reviewed article. This is a finite counterexample to a precisely stated claim, not a new research discovery. Legacy articles keep their existing status.

The exact claim and its hypotheses

Domain
Positive integers. The universal claim compares pairs whose trajectories both reach 1.
Map
T(n) = n/2 for even n; T(n) = (3n + 1)/2 for odd n. The odd branch divides by two exactly once.
Parity prefix
p₄(n) records the parity of n, T(n), T²(n), T³(n), before each step. Odd = 1; even = 0.
First-hit time
τ(n) = min {k ≥ 0 : Tᵏ(n) = 1}, when a hit exists. Thus τ(1) = 0; the map itself is not made absorbing at 1.
Claim tested
For every such pair x,y, p₄(x) = p₄(y) implies τ(x) = τ(y).
Result kind
Finite counterexample; reproduction of an existing public notebook review.

The inspectable evidence

Exact trajectories through the first 1
StartTrajectoryp₄τ
55 → 8 → 4 → 2 → 110004
2121 → 32 → 16 → 8 → 4 → 2 → 110006

Every displayed transition follows the map, and no earlier entry is 1. The prefixes agree while the first-hit times differ, so this pair is sufficient to refute the universal prefix claim.

For the shared branch, 16T⁴(n) = 3n + 1. It gives endpoints 1 and 4. That explains why identical branch choices can lead to different arrival times.

Why it matters—and its limits

A statistic can capture the first few choices of a process without determining when that process reaches a target. A proposed estimate relying on that sufficiency needs a different argument or more information.

This check says nothing about whether every positive integer eventually reaches 1. It establishes no asymptotic law, validates no general sampling theorem and does not review the other campaign claims.

What could invalidate this evidence?

A mismatched map or step convention, an arithmetic defect, altered files, or a failed replay would invalidate the corresponding check. The programs deliberately test wrong acceleration rules and corrupted certificates. Passing tests does not prove software defect-free.

Provenance and prior art

Jeffrey C. Lagarias, The 3x+1 Problem: An Annotated Bibliography (1963–1999), arXiv:math/0309224v13, PDF pages 1–2, supplies the map and total-stopping-time convention. It is reference context, not a novelty claim or a citation for these particular witnesses.

The same example is already in the original public review. Its historical status is retained. This packet supplies fresh public programs, not the campaign’s private artifacts.

Exact original review excerpt
Under accelerated3x+1,5 and21 share parity prefix1000 but first hit1 after4 and6 steps. Thus cell(4,1) is not measurable with respect to the first4 parity bits, and the finite-residue sampling law does not directly establish first-passage-cell estimates. Other asymptotic cell claims remain unreviewed.

review:collatz-prefix-versus-first-passage-1855

No exhaustive historical search or novelty claim is made.

Reproduce the check

Download manifest.json and every listed file, preserving subdirectories. The two implementations have no third-party packages and need no network while running.

Recorded runtimes: CPython 3.14.4; Node.js v22.22.1. The Node output records its runtime, so use that exact Node version for byte-identical comparison. Changes require a new comparison, not ignoring a mismatch.

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

Expected result: exact agreement on the two full trajectories, prefixes 1000, and first-hit times 4 and 6. The runner checks file hashes, both recorded outputs, 8 primary tests and 31 second-implementation tests. It exits nonzero on a mismatch or timeout. Read the executed comparison receipt.

Caps and stopping rules

The primary pilot uses at most 32 transitions per start and 128-bit states. The second checker uses 64 transitions and 256-bit states. Main witnesses need only 4 and 6 transitions and reach a largest value of 32. Each runner subprocess has a five-second timeout. State/step caps are algorithmic bounds, not guarantees about OS memory.

An incomplete run is UNKNOWN, never proof of nontermination. A complete counterexample remains valid if another supplied run hits a cap. Complete inputs without a counterexample say only that no witness was found in those inputs. Invalid input is rejected. Full parser limits and commands.

Download files and inspect SHA-256 hashes

Review status and remaining obligations

AI-assisted reviewers checked the exact definitions, manual witness arithmetic, source convention and bounded checker behavior. The programs were rerun: all 8 primary and 31 separate-implementation tests passed, with the recorded outputs matching exactly. Read the scoped review record.

The second implementation was constructed from definitions without reading the primary checker. It also validates transition and cumulative affine identities separately from its own iterator. Both are AI-assisted work: this is not external, human or formal verification.

No claim is made about untested programs, larger searches, novelty or broader conjectures. More review should target a concrete uncertainty, not just add another agreeing opinion.

Cite this evidence version

Four parity bits: a reproducible counterexample. Research notebook. Public working reproduction, evidence sha256:c837a0cf9936b7a48717099966550dc08f6b1cb9cf35197e3bc2d398e285827f. https://research.muzz.in/results/collatz-prefix/releases/c837a0cf9936b7a48717099966550dc08f6b1cb9cf35197e3bc2d398e285827f/ (add your access date).

Versioned evidence page · Machine-readable status and version record · Publication and corrections policy

Type: reproduction. Verification: exact finite replay with scoped AI-assisted review. Publication: public working record. No external peer review or novelty claim.