# GPU_CORE-001 findings

Executed 2026-10-05. The bounded [GPU Core v0.1 specification](GPU_CORE_SPEC.md)
is implemented and verified on an NVIDIA GeForce RTX 5070. All 36 frozen scaling
cases and the control worker passed; the final artifact verifier passed all 37
attempts. Seven rational controls, ten CUDA numerical controls and five
purpose-specific quotient controls passed. This is exact reference checking plus
measured numerical parity, not interval certification or evidence of language
understanding. No product inference, diffusion setting or hosted service changed.

## Implementation and correctness

The research CLI exposes `operator-check`, `operator-experiment` and
`operator-verify`. Diagonal restriction maps use matrix-free coboundary, adjoint
and Laplacian operations, with fixed pairwise incidence reductions. Full integer
signatures refine action-labelled finite-state partitions; observation sufficiency
is checked separately from commutation. Graph arrays, maps, signals, outputs,
source and protocol are hashed. The verifier bounds archive shapes and sizes,
regenerates inputs and CPU references, and never executes archived source.

All scaling outputs matched the NumPy float64 reference with maximum absolute
error zero for these synthetic dyadic inputs. Each case retained ten warm outputs
with identical byte hashes (also matching its cold output). This is repeatability
within the recorded environment, not a cross-device guarantee. Signed inputs,
zero maps, isolated vertices, orientation, adjoint identities and a high-degree
cancellation case provide additional bounded controls.

Lost-context, collapsed-encoding, perturbed-transition and reordered-action cases
refined to 98 blocks. The constant-observation control legitimately retained one
block: collapse is acceptable only when it preserves the declared purpose. These
controls concern finite-state operations, not inferred human intent.

## Performance

The complete supervised batch took 822.593 seconds. Peak allocated GPU memory was
779.03 MiB; peak reserved memory was 806.00 MiB; peak process-tree RSS was 1894.53 MiB.
Torch 2.14.1+cu130 / CUDA 13.0 used deterministic algorithms with TF32 disabled.

The table includes every frozen case. GPU entries are median [minimum, maximum]
CUDA-event milliseconds from ten warm repetitions. CPU entries are one NumPy
float64 reference execution. The CPU and GPU use different algorithms and
precision; their ratio is not an isolated hardware speedup measurement. At small
sizes the CPU reference is often faster. Warm timings exclude graph preparation,
input persistence/hashing, transfers and validation. CUDA-event intervals can
include dispatch gaps and are not a sum of active kernel durations.

| Family | Edges | Channels | GPU warm ms, median [min, max] | CPU reference ms | Peak allocated MiB |
|---|---:|---:|---:|---:|---:|
| path | 1,000 | 1 | 1.046 [0.981, 1.173] | 0.086 | 0.11 |
| path | 1,000 | 4 | 1.053 [0.904, 1.409] | 0.214 | 0.23 |
| path | 1,000 | 16 | 0.983 [0.883, 1.550] | 0.958 | 0.77 |
| path | 10,000 | 1 | 1.705 [0.924, 3.650] | 0.376 | 1.24 |
| path | 10,000 | 4 | 0.909 [0.807, 1.100] | 2.029 | 2.38 |
| path | 10,000 | 16 | 1.019 [0.841, 1.227] | 7.234 | 7.71 |
| path | 100,000 | 1 | 1.109 [0.967, 1.378] | 3.312 | 12.24 |
| path | 100,000 | 4 | 2.507 [2.112, 5.593] | 21.633 | 23.68 |
| path | 100,000 | 16 | 1.349 [1.172, 9.862] | 67.007 | 77.22 |
| path | 1,000,000 | 1 | 1.706 [1.663, 13.174] | 46.175 | 127.29 |
| path | 1,000,000 | 4 | 4.065 [4.036, 69.156] | 229.975 | 244.14 |
| path | 1,000,000 | 16 | 6.894 [6.836, 7.086] | 877.629 | 779.03 |
| cycle | 1,000 | 1 | 0.681 [0.602, 0.769] | 0.109 | 0.11 |
| cycle | 1,000 | 4 | 0.725 [0.621, 1.003] | 0.230 | 0.23 |
| cycle | 1,000 | 16 | 0.643 [0.575, 0.743] | 0.491 | 0.77 |
| cycle | 10,000 | 1 | 1.253 [1.183, 1.529] | 0.378 | 1.23 |
| cycle | 10,000 | 4 | 0.743 [0.562, 0.853] | 1.734 | 2.38 |
| cycle | 10,000 | 16 | 0.659 [0.533, 0.838] | 7.103 | 7.71 |
| cycle | 100,000 | 1 | 0.651 [0.569, 2.229] | 5.921 | 12.24 |
| cycle | 100,000 | 4 | 0.833 [0.729, 3.179] | 20.858 | 23.68 |
| cycle | 100,000 | 16 | 6.862 [0.825, 9.076] | 66.255 | 77.22 |
| cycle | 1,000,000 | 1 | 1.449 [1.352, 14.680] | 46.743 | 127.29 |
| cycle | 1,000,000 | 4 | 4.012 [3.987, 69.064] | 256.406 | 244.14 |
| cycle | 1,000,000 | 16 | 6.728 [6.705, 194.911] | 909.215 | 779.03 |
| star | 1,000 | 1 | 1.080 [1.020, 1.210] | 0.105 | 0.11 |
| star | 1,000 | 4 | 1.315 [1.262, 1.394] | 0.222 | 0.23 |
| star | 1,000 | 16 | 2.816 [1.255, 4.070] | 0.548 | 0.71 |
| star | 10,000 | 1 | 1.203 [1.122, 1.337] | 0.370 | 1.28 |
| star | 10,000 | 4 | 1.470 [1.319, 1.653] | 1.737 | 2.43 |
| star | 10,000 | 16 | 1.413 [1.261, 1.606] | 7.458 | 7.54 |
| star | 100,000 | 1 | 1.330 [1.214, 1.635] | 3.446 | 12.48 |
| star | 100,000 | 4 | 1.622 [1.361, 5.313] | 21.261 | 23.92 |
| star | 100,000 | 16 | 7.779 [1.698, 9.460] | 67.452 | 73.09 |
| star | 1,000,000 | 1 | 13.468 [1.570, 13.849] | 46.589 | 126.74 |
| star | 1,000,000 | 4 | 4.377 [4.330, 62.249] | 223.253 | 243.77 |
| star | 1,000,000 | 16 | 6.913 [6.789, 7.027] | 866.835 | 718.66 |

Cold event intervals ranged from 14.023 to 16.643 seconds across separate workers with
separate caches. Million-edge, 16-channel workers took roughly 37 seconds including
setup and artifact persistence. The cycle case's 194.911 ms warm outlier is retained;
its cause has not been established. These results do not establish bounded
interactive latency. GPU execution/wait measurements overlap and must not be
summed as independent costs.

## Validation and provenance

- Final isolated CPU suite: **1,414 passed, 8 skipped, 27 subtests**. Skips cover
  absent SciPy/Ripser and six CUDA tests in the CPU environment.
- Focused designated GPU-environment suite: **67 passed**. The official run also
  exercised the final worker cache configuration on CUDA.
- `renigma math-check`: passed. Exact CLI controls: passed.
- Final `operator-verify`: integrity and CPU numerical replay passed for 37/37
  attempts. Verification does not re-execute CUDA or constitute independent
  scientific replication.
- One earlier development test failed because source changed during freezing;
  the guard correctly rejected it. Its log remains `focused-v1.txt`. It was not
  relabelled as passed. No official grid case failed or was omitted.

Local evidence root: `G:/RenigmaLLM_Artifacts/operator-validation/` contains
`full-final.txt`, `gpu-final.txt`, `math-final.json`, `exact-check.json`,
`verification.json`, `benchmark-summary.csv`, `benchmark-summary.json`,
`warm-scaling.png` and `delivery-receipt.json`. Generated artifacts remain local.

Frozen run: `G:/RenigmaLLM_Artifacts/operator-runs/operator-b71c2c677c9b/`.

| Identity | SHA-256 |
|---|---|
| Run receipt | `894f98e8f9c8375a5c5ffb62b23082961cdb6ff00fdb7db8afa4b90ae174c372` |
| Source fingerprint | `68955f77aae8330df189b004873d2f56217318751c96f2c99b6b7fb7a74cc40a` |
| Frozen protocol | `3c0ca82bc94c20314e2e3c629abd514bb407ac828151e19faf06a7e73eff58f3` |

Implementation commit: `7be7e72acb67f1db84c5f9f321b6d8fe06192591`.
Every recorded source-file hash was checked against this implementation. The run's
git metadata records parent `7abf80a` because the source was frozen before committing;
the archived bytes and source fingerprint, rather than that parent commit, identify
the evaluated implementation. Findings and descriptive plots were produced afterward.

The draft implementation is [PR #11](https://github.com/ZuluYokohama/renigma-operational-semantics/pull/11),
stacked on #10. CodeRabbit returned summary-only, seat-limited responses; no completed
CodeRabbit code review or independent replication is claimed. This delivery does
not merge the PR, change repository visibility or deploy the website.

## Next decision

Proceed to a separately frozen polynomial/heat-filter experiment with declared
spectral and approximation bounds. The current path/cycle/star and diagonal-map
study does not establish performance on arbitrary complexes, real comment graphs,
learned restrictions or semantic tasks. Higher-cell Hodge operators, stiff dynamics,
Kron reduction, interval certificates, WebGPU and reviewed episode-data integration
retain their separate gates. No novelty claim follows from these results.