v1.0.2

Changed

• Package renamed on PyPI to aura-splat (the name aura-core is taken by an
  unrelated project); import name stays aura. First PyPI release.
• Added CITATION.cff; repository archiving enabled on Zenodo (DOI minted per release).

v1.0.1

Fixed

• Isotonic calibrator: pool tied covariates before PAVA. src/aura/calibration.py
  did not pre-pool equal confidence values, so on duplicate covariates the fit was not
  L2-optimal (e.g. returned 0.5 instead of 0.333 on a [0,1,0] tie). Now pre-pools
  ties before the pool-adjacent-violators pass. The paper's published ECE/AUC are
  unchanged — real-data ties shift ECE by < 1e-6, below the reported 4-dp
  precision, and the figure reproduce-checks still pass bit-exactly. Regression test added.

Added

• Public API surface exported from aura.__init__: IsotonicConfidenceCalibrator,
  conformal_prune_certificate, certified_lod_plan, and related symbols.
• CLI error boundaries: main() wraps dispatch, emitting aura: error: … with exit 1
  on bad input (AURA_DEBUG=1 re-raises); glTF .bin buffer round-trip decode test.
• matplotlib/imageio/pillow moved to the dev extra; CI installs .[dev].

Changed

• Certified LOD — Bonferroni over the non-trivial levels only (tighter, still valid).
  The certified LOD ladder (src/aura/lod.py) previously split α over all K levels
  (α' = α/K = 0.025), but the full-keep (f = 1.00) level is a deterministic
  statement (ε = 0, nothing pruned, no interval) that consumes no error budget. By the
  union bound only the R = K−1 = 3 non-trivial random levels need correcting, so
  α' = α/R = α/3 ≈ 0.0333. This is strictly tighter — the family-wise 1−α = 0.9
  guarantee is unchanged, but every non-trivial ε_k shrinks slightly (e.g. Truck@10%
  0.3342 → 0.3340, Room@10% 0.4432 → 0.4429). Regenerated outputs/lod_certified.json
  through experiments/lod_certified_eval.py; all 16 bounds still hold (12 non-trivial
  • 4 trivial) on the disjoint eval halves, zero violations. Propagated to the paper
    (Table 6, Fig 9, family-wise paragraph), README, docs/P4_CERTIFIED_LOD.md, REPRODUCE.md,
    the certified_lod publication gate (now checks α' = α/R), and the LOD unit tests.

AURA v1.0.0

[1.0.0] — 2026-07-05

Scoped v1.0.0 release with documented limitations. The calibrated-confidence trust
layer — the load-bearing contribution — is complete and honestly bounded; the items the
release does not close (a full 8-scene true-3DGS control, external reproduction, the
UBS-6D arm, and the demo/metadata carriers) are documented as open, not implied done,
in the README's "v1.0 Known Limitations" section. This release folds the B2 true
gsplat-3DGS control result and freezes the P0→P2 + CPU-ladder work into a citable version.

Added (v1.0.0)

• B2 — true gsplat-3DGS MCMC control (Truck). A genuine gsplat-3DGS control
  (simple_trainer.py mcmc, cap_max=1e6, 30k steps, every-8th-view split) at a matched
  1M-carrier budget on Truck, replacing the frozen-β DBS ablation for that one scene. Result
  (outputs/gsplat_control.json, now committed via git add -f): true gsplat-3DGS 25.94 dB
  (final@30k) vs frozen-β control 25.96 vs adaptive Beta 26.39 — the typed-carrier win
  holds against real 3DGS (+0.45 dB), and the frozen-β control lands within 0.03 dB of
  true 3DGS, so it was not artificially weak. Honest bound: Truck only (1/8 scenes); the
  other seven scenes and the +0.80 dB 8-scene mean remain frozen-control numbers, and UBS-6D
  was not built. New reproducible figure assets/b2_gsplat_control_truck.png
  (experiments/make_b2_gsplat_control_figure.py, reads the JSON verbatim).
• Version bump 0.7.0.dev0 → 1.0.0 (pyproject.toml, src/aura/__init__.py, README,
  paper); PyPI development-status classifier Alpha → Beta (honest for a documented-limitations
  preview release).
• README "Road to v1.0" rewritten to "v1.0 Known Limitations"; the "gsplat-control"
  naming collision resolved — the frozen-β/fixed-Gaussian control (8/8 scenes) is now named
  distinctly from the true gsplat-3DGS MCMC control (Truck, 1/8).

Added (v0.3→v0.7 CPU ladder, landed 2026-07-03)

• Certified LOD / streaming (src/aura/lod.py, aura lod-plan, docs/P4_CERTIFIED_LOD.md):
  carriers stream in descending calibrated confidence with K published stopping
  levels, each carrying a distribution-free bound on discarded reliability mass at
  Bonferroni α/K (family-wise 1−α). All 16 bounds hold on disjoint eval halves
  (outputs/lod_certified.json). Finding: isotonic plateaus make τ-rounding unsafe —
  τ is stored at full precision.
• SPZ v4 export (src/aura/spz.py, aura export-spz): pure-numpy NGSP
  reader/writer cross-validated bit-exact against the reference C++
  (nianticlabs/spz @ bb0efad; harness preserved at
  experiments/spz_reference_crossval.cc); confidence rides as a
  .spz.confidence.npz sidecar (v4 has no per-splat channel).
• BVH batched ray query (src/aura/bvh.py, docs/P5_BVH_RAY_QUERY.md):
  median-split BVH whose leaf AABBs provably superset the isotropic hit test ⇒
  exact parity with brute force (0 mismatches incl. 300 rays on the real truck
  asset); batched API + build-once streaming handle; 0.39% node visits / 7.2%
  carriers per ray on the truck.
• Carrier maturity contract (carriers.py, gate carrier_registry_honesty):
  every carrier type declares trained / demo / metadata; a trained claim
  requires committed calib_<scene>.json evidence. Hybrid neural routing is now an
  explicit provenance-annotated Gaussian fallback (fallback:gaussian +
  RuntimeWarning), never silent; prism.make_neural_footprint is quarantined
  behind enable_experimental=True.
• Codebook semantics (src/aura/codebook.py, docs/P6_CARRIER_REGISTRY_AND_CODEBOOK.md):
  K-entry k-means codebook + uint8/16 per-carrier indices; O(K·d + N)
  open-vocabulary fan-out; real truck DINOv2 features compress 1.53 GB → 1.05 MB at
  k=64 (recon rel-err 0.319). Feature distillation into the shipped asset stays
  GPU-gated.
• Publication gates content-checked (publication.py): 11 existence checks →
  17 gates that parse committed artifacts and enforce numeric thresholds;
  trained-asset probes return explicit unverified/requires_gpu instead of
  passing. Split guard (split_guard.py) makes the historical P0 eval-leak
  class mechanically impossible (including the Truck-certificate-back-at-1.00
  fingerprint).
• CI (.github/workflows/ci.yml): CPU suite on Python 3.11/3.12 on every
  push/PR; gpu / local_data pytest markers.
• REPRODUCE.md: verified, CPU-only, bit-for-bit reproduction of the
  calibration / certificate / LOD results from a fresh clone (the
  reliability_*.npz inputs are now committed, ~23 MB).
• Relight decision protocol (docs/P7_RELIGHT_DECISION.md,
  experiments/relight_benchmark_harness.py): pre-registered promote-or-descope
  rule for the v0.8 inverse-rendering attempt; TensoIR/Stanford-ORB harness with a
  CI-tested smoke mode. Relight module docstring corrected to preview-stage.
• USD confidence primvar: custom:aura:confidence → idiomatic
  primvars:aura:confidence (vertex interpolation) with a legacy fallback reader.
• AURA preprint updated to this state (17 pp; publishes at v1.0, owner decision).

Known limitations at v1.0 (documented open, not closed)

• B2 true gsplat-3DGS control is Truck-only (1/8); the 8-scene mean stays a
  frozen-control number; UBS-6D arm not built.
• Garden native 17.4 MP render-loss label rendered at half resolution (OOMs under
  concurrent GPU load); v0.7b gabor real-training attempt not landed (registry stays scoped
  to two trained carriers); v0.8 relighting stays a preview by its pre-registered
  promote-or-descope rule (not attempted at bar).
• Ray query is a CPU-BVH parity result, not a GPU wall-clock match to 3DGRT/3DGUT.
• No external reproduction; no P3 independent re-captures (four single-capture scenes).
• Established honest negatives (kept, not defects): adaptive per-carrier β does not beat
  a good global β; cross-family mix-routing never beats the best single family.
  See the README "v1.0 Known Limitations" section for the full list.

AURA v0.2.0 — calibrated, certified confidence (P0→P2)

AURA (Adaptive Unified Radiance Asset) v0.2.0 — the first tagged release.

AURA turns posed captures into a typed, queryable, engine-ready radiance asset. It
keeps the fast Gaussian / DBS-Beta renderers where they are strong and adds the
asset layer they do not provide: a calibrated, certified per-carrier confidence
that travels with the asset. This release consolidates the P0→P2 development arc
that hardened that killer property, plus a full presentation pass.

This is a research preview with an explicit honest boundary: every claim is backed
by a committed artifact, negatives are kept, and there is no official-leaderboard
SOTA claim anywhere in this repo.

Highlights — calibration + certificate hardened

• P0 killer property. Per carrier, a calibrated confidence c ∈ [0,1] (carriers
  reported at confidence p are reliable ≈ p of the time) plus a distribution-free
  split-conformal pruning certificate: drop everything below τ, losing at most ε
  reliability mass at confidence 1−α. Validated on four real scenes (Truck +
  Mip-NeRF 360 Garden/Kitchen/Room). Isotonic calibration drops ECE ~300–900×;
  calibrated-confidence pruning lands within 1–4% of the oracle ceiling and beats
  opacity at every budget (opacity sits at or below random). Survives an
  occlusion-aware reliability label. The value ships as _AURA_CONFIDENCE in the
  KHR_gaussian_splatting GLB and as a confidence vendor channel in the OpenUSD
  26.03 splat schema.
• P1 cross-scene transfer. A single calibrator transfers across scenes:
  selection/pruning AUC transfers within ±0.0004 on all 24 off-diagonal scene pairs
  (rank-invariant), absolute calibration ECE degrades gracefully (transferred ~0.008
  colour / ~0.026 depth on average — still 1–2 orders below the uncalibrated ~0.54),
  and the certificate stays valid when a small local conformal split is kept on the
  target. Deployment recipe: ship one calibrator + a small per-scene conformal set.
  The certificate's selective regime is mapped on all four scenes × both labels
  (onset ε* 0.47–0.62).
• P2 full resolution + a render-loss label. The P0 story holds at full resolution
  (full-res is at or slightly above the 0.25 control on every scene — not a low-res
  artifact) and survives a render-grounded reliability label measured from the actual
  alpha-composited render via exact blend-weight attribution, with honestly weaker
  margins (the export-time feature predicts the render-loss label at r ≈ 0.66–0.81 vs
  the proxy's 0.92–0.98; the oracle gap widens to ~6–13%; calibrated confidence still
  beats opacity on every scene).
• Presentation. README rewritten front-to-back with four result figures that
  regenerate from committed data (experiments/make_hardening_figures.py): the
  reliability diagram (raw vs calibrated), selection curves vs oracle/opacity, the
  cross-scene transfer ECE heatmap, and the colour-proxy vs render-loss comparison —
  plus the certified-pruning sweep animation.

The honest correction

P2 fixes a P0 evaluation leak: P0 trained on all frames, so its "held-out"
reliability views had been seen in training. On the clean, genuinely held-out split
the absolute numbers are slightly lower and honest — the Truck colour pruning
certificate that P0 reported as keeping 100% of carriers at ε=0.6 certifies keeping
77% on the clean split (1.00 → 0.77). All conclusions are stated relative to each
run's own oracle ceiling and to opacity, which is what transfers. The typed-carrier
Beta quality result (+0.33 dB on Truck, mean +0.80 dB) remains labelled as a
reproduction of Deformable Beta Splatting (arXiv:2501.18630) against a frozen-β
control — not an AURA novelty.

Unchanged

• The public Python/CLI API.
• The .aura package format + carriers.npz sidecar.
• The KHR_gaussian_splatting GLB and OpenUSD 26.03 exports (the calibrated
  confidence rides the existing vendor channels).

This is an additive, backward-compatible release: v0.2.0 hardens and documents the
P0 confidence property; it does not change how assets are built, packaged, or
exported.

Open items

• Garden native render-loss label needs an idle GPU. Garden's 17.4 MP
  rasterization OOMs on a loaded machine, so P2 renders that one label at half
  resolution (the carriers themselves are trained at native full resolution). A
  native full-res render-loss pass is pending an idle GPU.
• P3 independent re-captures. The reliability story is validated on four scenes
  and two labels; independent scenes / re-captures would harden it further.

Full per-change history: CHANGELOG.md. Deep-dives: docs/P0_CALIBRATED_CONFIDENCE.md,
docs/P1_CROSS_SCENE.md, docs/P2_FULLRES_RENDERLOSS.md. Licensed MIT.

v0.1.0 — research preview: calibrated, certified splat confidence

[Unreleased]

P0 killer property — calibrated, certified, exported per-carrier confidence (2026-07-01 → 2026-07-02)

The successor axis a bare 3DGS/DBS splat lacks: a per-carrier confidence a
downstream engine can trust and prune against with a guarantee. Answers audit
blocker B1 (no demonstrated killer property) and major M3 (confidence was an
uncalibrated heuristic).

Added

• Calibration module src/aura/calibration.py (CPU / numpy, 10 tests):
  • IsotonicConfidenceCalibrator (PAVA) — monotone map from the raw multi-view
    heuristic to a calibrated reliability.
  • conformal_prune_certificate — distribution-free split-conformal risk control
    (Hoeffding UCB on retained-set unreliability): the most-inclusive threshold τ
    that keeps mean unreliability ≤ ε at confidence 1−α.
  • selection_quality_curve — downstream demonstrator (retained reliability across
    pruning budgets).
  • attach_calibrated_confidence — replaces the heuristic value with the calibrated
    one and flags confidence_calibrated=True.
• aura calibrate-confidence <package> <reliability.npz> CLI, wiring the
  calibrated value into export so it ships as the _AURA_CONFIDENCE vendor
  attribute in the KHR_gaussian_splatting GLB.
• Occlusion-aware reliability label (--label depth_aware): a per-block
  front-surface z-buffer counts a carrier only in held-out views where it is the
  visible front surface, fixing the interior-occlusion false-low of the colour label.
• OpenUSD 26.03 schema export: write_usd_gaussian_splat / aura export-usd --schema emits the official UsdVolParticleField3DGaussianSplat schema
  (usd-core 26.05) with a confidence vendor channel; 3 round-trip tests. Closes
  audit item E6/P2 (USD preview previously predated the official schema).
• Experiment drivers experiments/per_carrier_reliability.py and
  experiments/calibrate_confidence.py; per-scene reports
  outputs/calib_<scene>{,_depth}.json.
• Authoritative write-up docs/P0_CALIBRATED_CONFIDENCE.md and the four-scene
  figure assets/p0_selection_auc.png (+ its generator
  experiments/make_p0_selection_auc_figure.py).

Changed

• Corrected reliability estimator: the robust observed-colour centre is now a
  masked nanmedian over each carrier's observed held-out views, replacing an
  earlier sentinel-median that poisoned carriers seen in fewer than half the views.
  Required for the occlusion-aware label; it supersedes the earlier (2026-07-01)
  Truck/Garden colour figures but leaves the headline conclusion unchanged.
• README gains a P0 "Calibrated Confidence (killer property)" section; the Current
  Status table now reads "validated on 4 real scenes".

Validated (four real scenes)

Truck (129k carriers), Garden (Mip-NeRF-360 outdoor, 120k), Kitchen (indoor, 120k),
Room (indoor, 107k):

• The export-time train-view colour-agreement feature predicts held-out
  reliability r = 0.91–0.98 on all four; the shipped view-count heuristic is
  uninformative (|r| ≤ 0.13).
• Isotonic calibration drops ECE from 0.46–0.59 to 0.0006–0.0016 (~300–900×).
• Selection AUC (mean retained reliability across pruning budgets): calibrated
  confidence 0.58–0.72, within 1–4% of the oracle ceiling, beating opacity
  (0.37–0.53, at or below random) at every budget; at a 10%-keep budget calibrated
  retains 0.77–0.90 vs opacity's 0.31–0.49.
• The property survives the occlusion-aware label (within 1–9% of oracle;
  corr 0.75–0.97).

---

Research preview — pre-release, under active development. Full history: CHANGELOG.md.