LuxiEdge / public evidence register

Inspect the result.
Keep the boundary.

Every claim is scoped to a named workload, environment, comparator, and evidence artifact.

Numerical infrastructure needs more than a repeatable answer. These records separate reproducibility, reference agreement, and measured performance. A result in one family is not evidence for another.

How to reproduce What this does not prove Public evidence index

01 / Financial / catastrophe risk

Oasis: repeatability and an exact-reference check.

Two distinct tests: ordinary public PiWind reruns, then a synthetic extreme-TIV stress case. Only the stress case was checked against an exact reference.

Workload: OasisPiWind, GUL / IL / RI, 10 samples. The stress case expands PiWind ×8 and scales TIVs to mix small and very large values.
Comparator: Stock oasislmf 2.5.8 defaults versus Luxi deterministic reduction. Stress-case ground-up portfolio totals are compared with an exact sum correctly rounded to float32.
Scope / environment: Linux x86-64 and Apple M1 Pro under Docker linux/arm64; not native macOS. Ordinary runs test 1, 2, and 4 workers. Evidence dated October 12, 2026.

Deterministic result: Stock defaults: 10 distinct hashes from 10 runs on 2 machines. Luxi: 1 hash.
Reference agreement / extreme TIV: Stock differs on 5,851 of 6,006 totals. Luxi differs on none.
Measured performance: No speed or energy claim is made here. These entries concern output stability and the stated exact-reference check.

Limits. Ordinary PiWind values were not checked against an exact reference. The extreme-TIV portfolio is synthetic, not a customer book; its exact check covers the 6,006 ground-up totals, not every output. The M1 extreme-TIV run at 4 workers ran out of Docker memory; the recorded M1 result uses 1 worker. This is not validation of Risk State Engine deployment.

Oasis report, hashes, scope, and stock reproduction commands Public Oasis artifacts

02 / GPU numerical primitives

Repeatable is not the same as correct.

The stock float32 GPU sums repeat on this input. The exact-reference comparison, not repeatability alone, reveals their error.

Workload: Sum 10 million synthetic float32 dollar values, against the correctly rounded exact total.
Comparator: Stock NVIDIA cuBLAS dot-with-ones, CuPy sum, and TensorFlow GPU reduce_sum, versus Luxi fixed-order Kahan with a float64 accumulator.
Scope / environment: NVIDIA L4, x86 CPU, and Apple Silicon arm64. Stock GPU methods ran 10 times on the L4. Evidence dated October 13, 2026.

Reference agreement: Stock float32: +$14,930.04 error.
Luxi exact path: $0.00 error.
Deterministic result: Luxi exact-path hash b952a970e4ad4440 matches on L4, x86, and Apple arm64.
Measured performance: No speed or energy claim. The exact fixed-order path is a correctness path, not the faster chunked GPU reduction.

Limits. Synthetic positive inputs and one GPU model. Stock float64 sums were exact on this data. The chunked Luxi path is a different result and is not exact; do not attach its timing to the $0.00-error path. The published power sampling does not resolve energy per sum.

GPU sum report and verification instructions Raw runs, summary, and verifier Input data release

03 / Orbital propagation

Named grids. Matching state bytes.

Cross-platform SGP4 evidence is tied to the published jax100 and starlink-382a419 grids, serialized states, and hashes. It is not a universal orbital-accuracy guarantee.

Workload: Luxi f64 SGP4 on jax100 and starlink-382a419, 29 epochs per satellite. WGS-72, AFSPC mode; published little-endian f64 positions and velocities.
Comparator: Byte comparison of the same Luxi state dumps across platforms. The report separately records comparisons with python-sgp4 2.25 and stock jaxsgp4; reference comparisons are not the cross-platform hash test.
Scope / environment: macOS arm64, Linux arm64, qemu Linux x86_64, and NVIDIA H100. Evidence dated October 10, 2026.

Deterministic result: jax100 and starlink-382a419 state bytes are identical on all four tested platforms.
Artifacts: Input grids, binary state dumps, per-platform records, SHA256SUMS, and Python checkers are public.
Measured performance: No speed or energy claim for this cross-platform SGP4 result.

Limits. The H100 build is near-earth only; no H100 deep-space claim. Linux x86_64 ran under qemu-user, not a native x86 host. Rejected starlink states are recorded as NaNs. The separate keplemon and Vallado checks in this pack ran on macOS only.

SGP4 report, environment, and limits Grids, state dumps, hashes, and checkers

04 / AI inference / internal measurement

Normal and deterministic modes, kept separate.

Qwen2-7B-Instruct on H100 SXM. Prompt processing and token generation have different tradeoffs. These September 25–26, 2026 comparisons have not been third-party validated.

Workload: Offline fixed batches. Long prompts: 2,048 × batch 16, 8,192 × 4, and 32,767 × 1. Generation: 1,024-token prompt, 256 greedy output tokens, batches 1, 16, and 64.
Comparators / environment: vLLM 0.25.1 default and batch-invariant modes; SGLang 0.5.19 normal fp16 and deterministic fp16 / bf16. Luxi c8 uses fp16 and FA3. One H100 SXM per run; vLLM and SGLang packs use different pods.

Deterministic result: Luxi logits and token-sequence hashes are bit-identical across the tested repeats and batch conditions, including separate gate processes on the two pods.
Reference check: Top token and ordered top-5 tokens match Hugging Face fp16 on tested prompts. This does not mean full-sequence identity. Published greedy-sequence checks include divergences.

Measured Luxi comparisons. All differences are relative to the named comparator in its own evidence pack.
Comparator	Prompts / 2k–32k	Generation
vLLM 0.25.1 Normal / default	3–7% faster 2–5% less GPU energy/token	Same speed 2–7% more GPU energy/token
vLLM 0.25.1 Deterministic / batch-invariant	Faster on every tested prompt cell; less GPU energy/token	1.5–2.7× faster 16–50% less GPU energy/token
SGLang 0.5.19 Deterministic / fp16 and bf16	1.18–1.24× faster 14–19% less GPU energy/token	1.21–2.86× faster Range spans the two precision modes
SGLang 0.5.19 Normal / fp16	1.3–4.6% faster 1.0–4.1% less GPU energy/token	About the same speed 1–7% more GPU energy/token

Measurement. Six metered runs per engine per cell. The public summaries include six-run medians; the vLLM headline tables in BENCHMARKS.md use means and its summary also reports medians. vLLM and deterministic SGLang comparisons use matched alternating blocks on the same GPU. Energy is NVML GPU-board energy from the total-energy counter, with no idle subtraction; not wall-plug or facility energy.

Normal SGLang was not interleaved with Luxi. It ran in a separate round immediately afterward, alternating with vLLM. Luxi versus normal SGLang compares back-to-back rounds, as recorded in TEST_SCOPE.md.

Version and environment limits. SGLang 0.5.19 was the last CUDA 12 release, not the newest SGLang. The vLLM and SGLang measurements use different H100 pods: do not mix absolute results across them. SGLang deterministic fp16 and bf16 use different matrix-multiply kernels; the combined range is not a single-precision result.

Correctness-only patch. A one-line tokenizer-manager None check enabled top-5 logprob requests. Kernels, scheduler, and model code were unmodified; speed runs do not request logprobs and do not exercise that patch.

Deployment limits. Offline fixed-batch harness, not production serving, live mixed-length traffic, or multi-GPU deployment. No measured lifecycle savings. Top-5 agreement is not full generated-sequence equality with Hugging Face. No third party has run or checked these comparisons.

Full test scope vLLM pack / methods and raw-run index vLLM summary SGLang pack / methods and raw-run index SGLang pre-run runbook SGLang six-run medians

Verification / public artifacts, not a private engine

How to reproduce

Reproduce the public checks and recompute reported summaries. This does not give you the proprietary Luxi reduction, propagator source, or benchmarked inference engine. The public demo server is not the engine behind the inference measurements.

Pin the evidence you inspect.
Clone LuxiDemo, record the commit, then read each pack's environment and limitations before running its checkers.
```
git clone https://github.com/RegularJoe-CEO/LuxiDemo.git
cd LuxiDemo
git rev-parse HEAD
```
Oasis: reproduce the stock drift.
The Oasis report provides the public model commit, stock 2.5.8 commands, and CSV hashing procedure. This stock reproduction needs no Luxi engine. The extreme-TIV exact-reference check is a separate test.
GPU sum: check the input, exact total, and hash.
Download data_f32.bin from the GPU sum release. In proofs/gpu-sum, run the published verifier with Python and NumPy:
```
bash verify.sh /path/to/data_f32.bin
```
This verifies the public data and exact-path hash; it does not re-run private GPU kernels.
SGP4: verify the published state artifacts.
From proofs/luxi-sgp4:
```
python3 scripts/check_sha256.py
shasum -a 256 states/jax100.bin states/starlink-382a419.bin
```
The README also lists reference-comparison checks and their dependencies. Artifact verification is not a new cross-platform propagator run.
Inference: rebuild the summaries from per-run rows.
Each pack README gives the exact csv_to_json.py, summary script, and cmp commands. Use the vLLM reproduction instructions or SGLang reproduction instructions. Inspect block logs, metadata, gates, and scope. This recomputes published measurements; it does not re-benchmark the private engine.

Boundaries / read before extrapolating

What this does not prove

No universal determinism or accuracy guarantee. Named inputs, serialization, platforms, versions, and tested configurations define each result. Hash equality alone is not an accuracy check.
No transferred performance claim. Oasis, exact GPU sums, and SGP4 entries here make no speed or energy claims. Inference ratios apply only to the named engine mode, workload, and pod.
No production-serving or lifecycle-savings evidence. The inference speed tests are offline fixed batches. Avoided re-runs, re-validation, operational cost, and full-system energy savings were not measured.
No full-sequence Hugging Face identity from top-5 agreement. Greedy sequences can diverge; the gates and TEST_SCOPE document the boundaries.
No third-party validation of current inference comparisons. Earlier TestFort reports concern different builds and workloads. They do not validate September's vLLM or SGLang results.
No public private-engine reproduction. Public artifacts support inspection, reference checks, and recomputing summaries. Downloadable demos do not supply the benchmarked engine.

Sources / start with the scope

Public evidence index

The repository is the source of record. Start with the overview, then inspect methods and raw artifacts in the relevant family.

README / overview BENCHMARKS / inference comparisons TEST_SCOPE / tested and untested proofs / numerical artifacts evidence / measurement packs

Access / demos and receipt checks

Downloads and receipt verification

LuxiBook is the public option-book demonstration and includes LuxiSize, a position-sizing CLI. Neither is the September inference benchmark engine or a public Risk State Engine release.

Download LuxiBook LuxiSize demo LuxiBook product page Request an evaluation

Legacy numerical REST demo releases Historical LuxiBook v0.2.1 receipt matrix

Verify a receipt signature yourself.

The JSON payload is the signed plaintext. The receipt carries an Ed25519 signature and public key. An internally consistent signature does not authenticate a specific machine: pin a key you already trust with --expect-pubkey <hex>.

Download verify_receipt.py Inspect verifier on GitHub

Inspect the standalone Python signature check

Requires cryptography. This checks internal signature consistency only; use the published verifier with a trusted pinned key for origin verification.

# pip install cryptography
import base64, json
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
from cryptography.exceptions import InvalidSignature

with open("receipt.json") as f:
    data = json.load(f)

# Receipt blob: 5-byte header + 32-byte public key + 64-byte signature
s = data["receipt"][len("lxq2_"):]
raw = base64.urlsafe_b64decode(s + "=" * ((-len(s)) % 4))
pubkey = Ed25519PublicKey.from_public_bytes(raw[5:37])
try:
    pubkey.verify(raw[37:], data["payload"].encode())
    print("PASS: signature valid")
except InvalidSignature:
    print("FAIL: signature invalid")

Release-file checksums detect changed download bytes. Output hashes identify computation bytes. Signed receipts bind a payload to a key. These are different checks, not interchangeable proof of numerical correctness.

Historical evidence

December 2025: TestFort independent seven-function numerical-engine evaluation (PDF). Not validation of Risk Runtime, LuxiBook, or September inference.
23 July 2026: TestFort packed-prefill report (PDF) · Evidence pack. One H100; different build, not September validation.
7 August 2026: Internal matched prefill · Milestone evidence.
7 August 2026: Absolute prefill. No matched comparator; not Llama 3.1 evidence.
Historical TRADE: 7B-class sustain · 12-layer Flash comparison · CUDA research. Not current serving evidence.
Historical long-context scaling. Not generated-token performance.
Null-space audit · Single-layer baseline · 11 July 2026 sustain protocol.
LuxiBook demo · Downloads and receipts. Separate from Risk State Engine.
Research · Current inference evidence. Historical decode work is separate.
Evidence boundaries; each pack retains its own scope.

Inspect the result.Keep the boundary.

Oasis: repeatability and an exact-reference check.

Repeatable is not the same as correct.

Named grids. Matching state bytes.

Normal and deterministic modes, kept separate.

How to reproduce

Pin the evidence you inspect.

Oasis: reproduce the stock drift.

GPU sum: check the input, exact total, and hash.

SGP4: verify the published state artifacts.

Inference: rebuild the summaries from per-run rows.

What this does not prove

Public evidence index

Downloads and receipt verification

Historical evidence

Inspect the result.
Keep the boundary.