Null Refinement Transport
Project the transmission into the null space of the receiver's knowledge, and send only what survives the projection.
A transport primitive. Not a codec. Not a compression algorithm. A new way for two endpoints to negotiate what actually needs to be transmitted.
- The core idea
- Problem statement
- Mathematical foundation
- The belief covariance
- Protocol design
- Domain models
- Industry applications
- Empirical results
- Limitations
- Installation and usage
- Project structure
- Roadmap
Your machines transmit states when they should transmit corrections. The sender shouts the answer into a wire. It never asks: what does the other side already believe?
NRT formalises a different primitive. Before transmitting, the sender asks:
- What does the receiver currently believe?
- In which directions is the receiver most uncertain?
- What is the minimum correction to bring that uncertainty below a declared threshold?
The transmission is that correction — and nothing more.
When a packet is lost in transit, the sender does not retransmit a copy. It recomputes the correction against the receiver's current belief state, which has since evolved. The retransmission is always smaller than the original. It is never a repeat.
Transfer terminates when the receiver's residual uncertainty falls below
Shannon's channel capacity theorem defines the maximum reliable bit rate for a channel. It does not define which bits to transmit. Classical transport protocols transmit all bits, in order. This is optimal only when the receiver has zero prior knowledge.
In practice, the receiver almost always has partial knowledge:
- A video decoder holds the previous frame — 95% of the next frame is predictable.
- An inference server receiving a model update holds the previous checkpoint.
- An IoT node receiving a telemetry correction holds a physics-based prediction of the next reading.
- A game client has just rendered frame
$N$ — it knows what hasn't changed. - A database replica holds a previous snapshot — most records are unchanged.
In every such case, the optimal transmission is the divergence between the receiver's current belief and the truth, expressed in the receiver's basis of maximum uncertainty. Current protocols pay the cost of the full data. They should pay the cost of the divergence.
Note
NRT is not a compression algorithm. It does not reduce file sizes. It reduces the number of bits that must be transmitted by exploiting what the receiver already knows. With no prior knowledge, it behaves identically to progressive transfer. With a good prior, it may transmit nothing at all.
Let
- An estimate
$\hat{\mathbf{X}}^{(t)} \in \mathbb{R}^{m \times n}$ — its current best reconstruction - A Kronecker-structured belief covariance
$\Sigma_{L} \otimes \Sigma_{R}$ , where$\Sigma_{L} \in \mathbb{R}^{m \times m}$ encodes uncertainty over row directions and$\Sigma_{R} \in \mathbb{R}^{n \times n}$ encodes uncertainty over column directions
The residual at round
Eigendecompose each covariance factor:
The combined uncertainty over outer-product directions $\mathbf{u}{i} \mathbf{v}{j}^{\top}$ is:
A large
The scalar correction for direction
NRT transmits the top-$k$ directions sorted by
After applying a correction, the receiver projects out that direction from its covariance:
That direction's uncertainty drops to zero permanently.
Important
This is the critical distinction from SVD-based progressive transfer. SVD of the residual prioritises directions of highest variance in the data. NRT prioritises directions of highest uncertainty in the receiver. These coincide only when
Transfer terminates when:
When a correction packet is lost, the sender recomputes against the receiver's current belief state
The retransmission is always at most as large as the original, and in practice smaller. It is never a copy.
The covariance
Zero prior — receiver has no knowledge:
All directions are equally uncertain. NRT degenerates to transmitting corrections in order of magnitude — equivalent to residual SVD. This is the correct degenerate case: NRT is never worse than progressive transfer with no prior.
Spectral prior — receiver has the top-$p$ SVD components of
Known directions have
Tip
The covariance does not need to be exact. A diagonal approximation or top-$k$ eigenvectors is sufficient for most applications. The protocol degrades gracefully with a coarser covariance model.
Sender Receiver
│ │
│──── HELLO (ε, shape, domain) ──────► │
│◄─── SEED (Σ_L, Σ_R, X̂ hash) ────── │ receiver declares its covariance
│ │
│ [if residual already < ε → DONE] │ zero bytes transmitted
│ │
│──── REFINE (round=1, frames) ──────► │ top-k directions by λ_ij
│◄─── ACK (residual_norm, stop?) ───── │ receiver reports current error
│ │
│──── REFINE (round=2 …) ────────────► │
│◄─── STOP ─────────────────────────── │ ε satisfied
[round_idx : uint32] belief epoch this correction targets
[u_i : float32[m]] left eigenvector of Σ_L
[v_j : float32[n]] right eigenvector of Σ_R
[c_ij : float32] scalar correction u_i^T R v_j
[lambda_ij : float32] uncertainty of this direction at send time
[is_final : uint8] 1 if sender believes ε is satisfied
[round_idx : uint32]
[residual : float32] receiver's current relative error
[stop : uint8] 1 = sufficient, 0 = continue
NRT is domain-agnostic at the transport layer. The covariance model is domain-specific. The table below shows how
| Domain | Receiver's prior | Covariance structure | What gets transmitted |
|---|---|---|---|
| Video / live media | Previous frame(s) | Motion-compensated temporal residual; high |
Changed pixels, motion anomalies |
| Cloud gaming / XR | Just-rendered frame | Per-region uncertainty from game state delta | New geometry, explosions, UI changes |
| Satellite / aviation | Previous message + link model | High |
Fresh corrections, not retransmit copies |
| IoT / telemetry | Physics-based prediction (Kalman) | Innovation covariance |
Sensor anomalies, deviations from model |
| ML model distribution | Previous checkpoint | Spectral prior: |
Weight deltas, new capacity |
| Database replication | Previous snapshot | High |
Changed records only |
| Medical imaging | Previous scan | Anatomical prior from registered image | Lesion changes, diagnostic regions |
| CDN / file sync | Previous version | Block-level hash prior | Changed content blocks |
Note
The domain model defines the prior. The transport primitive is identical across all domains. A single NRT implementation supports all use cases by swapping the covariance constructor.
Video frames are approximately 95% predictable from the previous frame. Today, codecs (H.264, H.265, AV1) exploit this at the application layer with inter-frame prediction. NRT exposes this as a transport primitive — domain-agnostically, without requiring codec-level integration. The receiver's covariance is constructed from the decoded previous frame; the sender transmits only the motion-residual components the receiver cannot predict.
Affected: Netflix, YouTube, every CDN, Zoom, Teams, all broadcast infrastructure.
The client has just rendered frame
Affected: cloud gaming platforms (GeForce Now, Xbox Cloud), VR/AR streaming, remote desktop (RDP, Citrix).
Satellite uplinks are expensive, high-latency, and loss-prone. Every retransmission wastes scarce capacity. Under NRT, a lost packet triggers a fresh correction against the receiver's current belief — which is smaller than the original because other corrections have since arrived. Effective throughput increases without changing the physical link.
Affected: Starlink, Viasat, aviation Wi-Fi (Gogo, Panasonic), maritime connectivity, deep-space mission uplinks.
Factory sensors, energy grid monitors, and fleet telemetry generate highly predictable time-series data. A Kalman filter running at the receiver defines the innovation covariance
Affected: industrial automation, energy grid management, vehicle fleet telemetry, smart building systems.
Model checkpoints are approximately low-rank and close to previous checkpoints. An inference server holding checkpoint
Affected: model distribution at scale (Meta, Google, Anthropic), federated learning gradient exchange, distributed training coordination.
A radiologist reviewing a follow-up scan holds the previous scan as a prior. The patient's anatomy is largely unchanged. NRT transmits full fidelity only in regions of clinical change, compressing stable anatomy. The receiver's covariance is built from image registration against the prior scan.
Affected: PACS systems, radiology workflows, remote diagnosis on constrained hospital links.
Benchmark: 32×32 structured matrix (rank-5 signal + noise), 4,096 bytes raw.
| Prior | Rounds | Bytes sent | % of raw | Converged |
|---|---|---|---|---|
| Zero (no knowledge) | 6 | 6,432 | 157.0% | ✓ |
| Spectral prior, top 10% known | 1 | 1,072 | 26.2% | ✓ |
| Spectral prior, top 30% known | 0 | 0 | 0.0% | ✓ |
| Spectral prior, top 50% known | 0 | 0 | 0.0% | ✓ |
0-byte cases: receiver's prior already satisfies $\varepsilon$. Transfer terminates before a single byte is sent.
| Channel condition | Rounds | Converged |
|---|---|---|
| Clean (0% loss) | 6 | ✓ |
| 10% packet loss | 6 | ✓ |
| 30% packet loss | 6 | ✓ |
Retransmissions are fresh corrections, not copies. Convergence is unaffected.
Warning
Benchmark results use synthetic structured data. Zero-prior transfer costs 157% of raw due to per-frame eigenvector overhead — NRT is not efficient for small matrices without a prior. Real-world gains are proportional to prior quality and data size. Domain-specific validation is required for each application.
Caution
NRT is a research prototype (v0.1). All results are from simulated sessions. No real network transport exists. Domain-specific implementations are not yet built.
Covariance overhead. Each correction frame carries eigenvectors $\mathbf{u}{i} \in \mathbb{R}^{m}$ and $\mathbf{v}{j} \in \mathbb{R}^{n}$ alongside the scalar
Covariance calibration. Performance depends on
Synchronisation. Both endpoints must maintain consistent belief state. Floating-point non-determinism across heterogeneous hardware can cause divergence. Production use requires deterministic arithmetic or periodic covariance snapshots for resynchronisation.
Structured data only. For encrypted payloads, random data, or data without low-rank structure, NRT adds overhead with no benefit. The domain model must be appropriate to the data.
Prior art. NRT draws on Wyner–Ziv coding (1976), Slepian–Wolf distributed source coding (1973), information geometry (Amari, 1980s), and semantic communication research (active since ~2019). The contribution is a concrete protocol design: Kronecker belief covariance, per-direction uncertainty ordering, covariance update rules, and
git clone https://github.com/userFRM/nrt.git
cd nrt
pip install -r requirements.txtRequirements: numpy>=1.24, scipy>=1.10, pytest>=7.0 (tests only)
from nrt.session import NRTSession
from nrt.models import spectral_prior
from nrt import NRTConfig
import numpy as np
data = np.load("checkpoint.npy")
prior = spectral_prior(previous_data, keep_fraction=0.20)
result = NRTSession().run(data, prior=prior, config=NRTConfig(epsilon=0.02))
print(f"{result.rounds} rounds · {result.total_bytes} bytes · {result.compression_ratio:.1%} of raw")python3 -m pytest tests/ -v # 13 testsnrt/
├── nrt/
│ ├── __init__.py NRTConfig, CorrectionFrame, RefinementPacket, SessionResult
│ ├── belief.py BeliefState — Σ_L⊗Σ_R covariance, eigenbasis, covariance updates
│ ├── models.py Prior constructors — zero_prior(), spectral_prior()
│ ├── sender.py NRTSender — corrections ordered by λ_ij, retransmit()
│ ├── receiver.py NRTReceiver — apply(), is_sufficient()
│ └── session.py NRTSession — full protocol simulation, optional packet loss
└── tests/
├── test_covariance.py covariance structure, known-direction exclusion, updates
├── test_convergence.py monotone convergence, ε-termination, zero-prior degenerate
├── test_prior.py spectral prior acceleration, monotone prior improvement
└── test_retransmit.py norm bound, not-a-copy, convergence under 30% loss
The current codebase is the protocol core. Domain-specific implementations are the next layer.
| Priority | Item |
|---|---|
| High | Video domain model — temporal prior from previous frame, motion-region covariance |
| High | IoT domain model — Kalman innovation covariance as NRT prior |
| High | Real UDP transport layer with ACK-driven covariance exchange |
| Medium | Cloud gaming domain model — game-state-aware per-region covariance |
| Medium | Block-diagonal covariance approximation for large matrices |
| Medium | Belief state reconciliation protocol (floating-point divergence) |
| Low | Medical imaging domain model — registered image prior |
| Low | Formal convergence rate analysis as function of covariance spectrum |
Apache 2.0. See LICENSE.
NRT — March 2026