# Affine input ablation: exact public CPU evidence

AI generated the original Nodus experiment code and writing. The retained result
was executed once on the CPU, then reviewed from saved artifacts by a separate
internal AI agent. This is not external certification.

Across 18 correlated synthetic configurations, varying normalization weights alone
left omitted bias undetected; varying bias alone left omitted weight undetected.
Varying both rejected all six selected altered formulas in this grid.

| Altered formula | Identity | Weight only | Bias only | Both varied |
| --- | ---: | ---: | ---: | ---: |
| Omit all affine | 18/18 | 0/18 | 0/18 | 0/18 |
| Omit weight | 18/18 | 0/18 | 18/18 | 0/18 |
| Omit bias | 18/18 | 18/18 | 0/18 | 0/18 |
| Scalar affine | 18/18 | 0/18 | 0/18 | 0/18 |
| Apply affine twice | 18/18 | 0/18 | 0/18 | 0/18 |
| Affine before normalization | 18/18 | 0/18 | 0/18 | 0/18 |

Cells are altered-formula observations **accepted** by the pinned checker. Zero
means all 18 were observed rejected, not missing. All 72 copied-reference controls
passed. All 504 planned observations completed: 216 accepted (including controls),
288 rejected, zero errors, zero missing. This is one exposed development
normalization family, not 504 independent workloads.

## Inspect without running the experiment

The package is source and evidence, with no installed dependencies or binaries.

- `observed-cpu/public-result.json`: portable complete result, every output tensor,
  fixture/reference values, checker statistics, matrix, source hashes and limits.
- `observed-cpu/PLAN.json`, `events.jsonl`, `RESULT.json`: unchanged retained
  plan, append-only observations and full result.
- `affine_ablation.py` and `protocol.json`: unchanged experiment source and
  frozen protocol. The protocol's preparation-time status remains historical.
- `public-checker-bundle/`: exact 26-file public import bundle required by this
  runner, including unmodified SOL checker, source manifest, licenses and notices.
- `MANIFEST.json`: hashes of every other package file.
- `runtime-observed.json`: observed runtime and supplemental dependency metadata.
- `requirements-macos-observed.txt`: version constraints, **not** a wheel lock.
- `LICENSE-NODUS`: license for the new original Nodus runner, documentation,
  synthetic fixtures and outputs. Upstream files retain their own licenses.

Plan-only mode needs Python 3.12 and imports neither Torch nor the checker:

```sh
python3.12 -I -B affine_ablation.py --backend cpu
```

No numerical reproduction was performed while preparing this distribution.

The figure is also reproducible from the retained JSON. It requires Pillow
(separate from the experiment dependencies) and a regular/bold TrueType font:
`python tools/render_matrix.py observed-cpu/public-result.json --output figures`.
Use `--font` and `--bold-font` on hosts without the default macOS Arial paths.
This only redraws the labelled matrix; it does not import Torch or run the study.

## Reproduce the observed Mac CPU cohort

The observed environment was macOS 26.5.1 arm64, CPython 3.12.14, Torch 2.14.1 and
Pydantic 2.12.5, with one Torch CPU thread and deterministic algorithms enabled.
The runner checks those Python/package versions and Darwin/arm64; it records,
but does not enforce, the macOS point release. Its tensors are little-endian
float32 or float16; no GPU or model is required.

Use a separate existing Python environment with those exact versions. The included
constraints record the observed package versions and can guide installation from
official package indexes. We have not reconstructed or wheel-hash-locked this Mac
environment in this release, and do not claim its binary build is reproduced by
version strings alone. Do not silently use a newer Torch or pool another runtime
with this result.

The original run supplied Pydantic through a separate local dependency directory.
Portable instructions assume the listed dependencies are installed in the selected
environment itself, so `-I` can ignore ambient PYTHONPATH. No personal paths are
needed. Run the following from the extracted package root, using that environment's
Python executable. Change `cpu-reproduction-01` for each new attempt; never replace
the retained result.

```sh
python -I -B - <<'PY'
from pathlib import Path
import json
import subprocess
import sys
import time

name = "cpu-reproduction-01"
if Path(name).exists():
    raise SystemExit("Choose a new output directory")
started = time.monotonic()
record = {"direct_child_timeout_seconds": 210, "timeout": False}
with open(name + ".stdout", "xb") as out, open(name + ".stderr", "xb") as err:
    try:
        result = subprocess.run(
            [sys.executable, "-I", "-B", "affine_ablation.py", "--run",
             "--backend", "cpu", "--public-bundle", "public-checker-bundle",
             "--output", name],
            stdout=out, stderr=err, timeout=210, check=False)
        record["exit_code"] = result.returncode
    except subprocess.TimeoutExpired:
        # subprocess.run kills and waits for its direct child before raising.
        record.update(timeout=True, exit_code=None)
record["elapsed_wall_seconds"] = time.monotonic() - started
with open(name + ".process.json", "x") as out:
    json.dump(record, out, indent=2)
raise SystemExit(0 if record.get("exit_code") == 0 else 1)
PY
```

The runner's 180-second limit is cooperative between operations. The recipe adds
a 210-second timeout for its direct trusted Python child; it is not a general
process-tree sandbox or provider-cleanup system. Your host remains yours to manage.
Retain stdout/stderr and the process receipt. If interrupted, confirm that the
child is terminated before using `--summarize`; a requested slot without a retained
completion is unknown, not a rejection. No automatic retry is included.

After a terminated attempt, the offline summary command imports no Torch:

```sh
python -I -B affine_ablation.py --summarize --output cpu-reproduction-01
```

## Linux is a separate reproduction cohort

The unchanged runner also admits Linux CPython 3.12 with **Torch 2.9.0+cu130**
and Pydantic 2.12.5. This is a different runtime, not the observed Mac result.
No Linux or CUDA execution of the 504-slot grid is included here. Results must be
retained and reported separately; the earlier single-fixture T4 experiment does
not confirm this larger cohort.

An existing public, exact 30-wheel Linux x86_64/glibc>=2.28 lock is available at:
https://data.nodus-compute.ai/assets/lab-research-affine-cuda-runtime-lock.tar.gz
Its hash and installer command are recorded in `runtime-observed.json`.
It downloads about 2.74 GB of pinned compressed wheels, with additional unpacked
disk space required. No wheels were downloaded for this package.

After extracting that lock, its existing installer takes:
`sh runtime-lock/install_runtime.sh /absolute/path/to/python3.12 /absolute/path/to/new-runtime`.
Use the resulting Python for the same CPU command above. A CUDA experiment needs
separate hardware/driver and bounded-execution preparation; it is not required to
inspect or reproduce the published CPU finding.

## Exactly what was checked

Three shapes (1x8, 4x64, 4x127), two dtypes (float32, float16) and three seeds
(7, 42, 2026) form 18 configurations. Each fixture uses one CPU generator with the
frozen draw order x, weight perturbation, bias perturbation. Those exact draws are
reused across identity, weight-only, bias-only and both-varied regimes.

The reference is eager `layer_norm(x, (N,), eps=1e-5)`, then multiplication by
weight, then addition of bias, each in the selected dtype. This is not asserted
bit-identical to fused affine LayerNorm or an independent real-arithmetic oracle.
The positive control is `reference.clone()`.

The unmodified public `compute_error_stats` helper converts to float32 and applies
the fixed 0.01 absolute / 0.01 relative tolerance with at least 99% matched
elements, no separate maximum-error cap, and its nonfinite/all-zero checks.
This is not ordinary `torch.allclose`. See the exact checker and protocol.

All inputs and formulas are original synthetic development material. An omitted
term with its parameter held at identity is equivalent on that restricted slice:
its acceptance is a coverage blind spot, not an incorrect value on that fixture.
The selected six formulas and seeds do not estimate defect prevalence or prove
exhaustive coverage. There is no full SOL dataset/evaluator, generated-kernel
judge, held-out task, model, training, CUDA-performance or provider result.

## Credit and licenses

Original report: **zzw4257**, https://github.com/NVIDIA/SOL-ExecBench/issues/25
Nodus reproduction: https://github.com/NVIDIA/SOL-ExecBench/issues/25#issuecomment-6734823293
Prior scoped result: https://data.nodus-compute.ai/blog/identity-inputs-hide-normalization-errors

Upstream public source: NVIDIA/SOL-ExecBench at
`a9fa0804c793d438e70850c33fe34426e66d53dd`.
The checker import closure is unchanged. `upstream/LICENSE` and
`upstream/THIRD_PARTY_NOTICES.txt` are preserved exactly. The bundle also contains
historical original-input patch/reproduction files because its frozen manifest
requires them; the new ablation does not execute that input generator or the old
CUDA experiment. Do not run `public-checker-bundle/run_validation.py` for this study.

The frozen source manifest contains non-secret historical workspace provenance
paths; they are not runtime dependencies. No private corpus, protected judge,
confirmation source, account credentials or customer material is included.