# Selected Reproduction of the Unnumbered Finite-Search Groundwork

## Outcome

On 18 October 2026, the earlier finite-search verification runner was executed again in a temporary copy of the historical sources. It completed successfully. The output and generated receipts were read, and the two enumeration implementations were inspected for their domain, comparison direction, and exact-arithmetic bounds.

The reproduced finite result is:

> Among all 4,194,303 nonempty subsets of \(\{1,\ldots,22\}\), the set
> \(A_* = \{1,2,3,4,5,6,7,8,10,11,13,14,15,16,17,21\}\)
> uniquely minimizes \(K(A)/\sqrt{|A|}\), where \(K(A)=-\min_x\sum_{a\in A}\cos(ax)\).

The continuous depth of the winner satisfies the strict bounds

\[
2.4548327530<K(A_*)<2.4548327531.
\]

Its size is 16, so division by four converts those endpoints into bounds for the normalized ratio. Every competing set has an exact grid-derived lower bound for its true normalized depth at least

\[
\frac{24548327531}{40000000000}=0.613708188275,
\]

while the winner’s continuous certificate places its ratio strictly below that value. This establishes uniqueness **inside the finite universe**. It is not a theorem about unbounded frequencies and does not settle Chowla’s conjecture.

## Execution details

| Item | Value |
|---|---|
| Start time | 2026-10-18 16:07:22.989851 UTC |
| Local time at start | 2026-10-18 11:07:22.989851 America/Chicago |
| Python | 3.12.14 |
| NumPy | 2.3.5 |
| Platform reported by the runner | Linux x86_64, glibc 2.39 |
| Exit code | 0 |
| Wrapper wall time | 14.541225273002055 seconds |
| Runner-reported internal time | 14.467878341674805 seconds |
| Historical inputs | `evidence/history/previous_sources/` |
| Mutation policy | Copied sources into a private temporary directory; preserved historical files were not overwritten |

The exact command used was:

```text
/opt/codex/runtimes/codex-primary-runtime/dependencies/python/bin/python3 /tmp/chowla_groundwork_publication_5llxamkd/previous_sources/run_verification.py
```

The working directory was:

```text
/tmp/chowla_groundwork_publication_5llxamkd/previous_sources
```

That temporary path is an execution record, not a required installation path. To repeat the check elsewhere, copy the complete `history/previous_sources/` directory to a writable location, ensure Python and NumPy are available, and run `python3 run_verification.py` there. Do not use Python’s `-O` option: the verification code uses assertions. SciPy is unnecessary for this runner, although optional historical search programs may use it.

## What was actually checked

### Three continuous polynomial certificates

The runner rebuilt the cosine polynomials through the substitution \(y=\cos x\), checked rational negative witnesses, reconstructed Sturm sequences, and verified that the proposed upper-shift polynomials stay positive throughout \([-1,1]\). It then separately rebuilt Bernstein-subdivision positivity certificates for the same three stored examples.

| Stored input | Exact depth interval | Bernstein leaves | Maximum subdivision depth |
|---|---|---:|---:|
| `certificate_N6.json` | \((15918323293/10^{10},\ 7959161647/(5\cdot10^9))\) | 26 | 20 |
| `certificate_N11.json` | \((2627976599/1250000000,\ 21023812793/10^{10})\) | 26 | 19 |
| `certificate_N16.json` | \((2454832753/10^9,\ 24548327531/10^{10})\) | 29 | 19 |

These intervals are statements about continuous minima, not grid minima. The new receipt records the input hashes and the successful Sturm and Bernstein checks.

### First exhaustive comparison

The first implementation constructs certified upper bounds for cosine on a half-period grid using integer interval arithmetic and half-angle square roots. It uses 96 internal bits and rounds outward to a 40-bit fixed-point output. Subset sums are updated by Gray-code enumeration. Integer ceiling thresholds convert the winner’s strict upper ratio into a comparison for every possible subset size. The implementation explicitly checks that the largest possible fixed-point sum fits in signed 64-bit arithmetic.

All 4,194,303 nonempty subsets were considered. Only the eventual winner escaped the threshold that certifies every other set as worse. The 4,097 grid evaluations are used to produce **lower** bounds for the true depth of competitors; they are not assumed to locate each competitor’s continuous minimum.

### Second exhaustive comparison

The second implementation uses a different cosine construction: Machin’s formula yields rational bounds on \(\pi\), followed by alternating Taylor bounds for cosine. It independently verifies the winner’s polynomial through a closed coefficient formula and checks the stored Sturm identities. Subsets are enumerated through two direct 11-frequency subset-sum tables rather than Gray code.

Again, all 4,194,303 nonempty subsets were covered. One set survived the initial 513-point coarse grid, and the full 4,097-point check left that same winner. The output explicitly reports the finite domain, sole exception, winner, rational threshold, and enumeration method. Agreement was checked by the runner as well as by inspection of the generated receipts.

These are two computational implementations within one AI-assisted research project. They are not independent external laboratories, external peer review, or a formal proof-assistant derivation.

## Preserved reproduction outputs

- [Execution metadata](groundwork_reproduction_execution.json)
- [Full standard output](groundwork_reproduction_stdout.txt)
- [Standard error](groundwork_reproduction_stderr.txt), empty for this run
- [Combined verification receipt](groundwork_reproduction_receipt.json)
- [First exhaustive finite certificate](groundwork_reproduction_finite.json)
- [Second implementation’s result](groundwork_reproduction_independent.json)

The archived input scripts are [the runner](history/previous_sources/run_verification.py), [the first finite enumerator](history/previous_sources/compute/exact_grid.py), and [the second checker](history/previous_sources/counterexample/redteam_finite_check.py). Their input certificate files remain under `history/previous_sources/compute/`.

This is a selected reproduction of the unnumbered groundwork. It does not regenerate the missing approach-42 witnesses or imply that all ninety branches were freshly executed. The broader [provenance note](provenance_notes.md) and publication verification records retain those distinctions.