The Primitive Registry

Send the Information-Bottleneck minimal sufficient statistic for a declared downstream task and its distortion measure (accuracy/perceptual/effect) instead of byte-exact reconstruction — the strongest honest way to 'get past lossless' for AI traffic, because the effective source entropy is genuinely lower under a task-sufficient measure (stays inside Shannon RD).

Carry a payload over a co-trained joint source-channel mapping that degrades smoothly with link quality (no cliff effect), trading a bounded fidelity loss for continued delivery under adverse/variable channels and tight latency budgets — the DeepJSCC operating regime where separation is not tight.

Attach a declared fidelity level (lossless / task-sufficient / perceptual-generative) plus matched encoder-decoder identity and domain to every stream, so a receiver refuses or downgrades when content falls outside the trained task or when bit-exactness is actually required. Typed as a linear-logic proposition so a mismatch fails to typecheck.

Use a learned entropy model over semantic latents to spend more channel uses on informative content and less on predictable content (NTSCC-style variable-rate JSCC), aligning bandwidth to semantic importance rather than uniform bit budget.

Transmit a compact semantic descriptor (segmentation map / prompt / sparse latent) and synthesize a perceptually faithful reconstruction at the receiver, with a mandatory fidelity-vs-perception flag warning that unmodeled detail is generated, not delivered — never counting a decoder's hallucinated detail as received information.

Consume a pre-shared correlation resource to lift throughput above the channel's own unassisted capacity ceiling, with the advantage growing as the channel gets noisier. The consumed resource is metered explicitly, so the gain is never mistaken for a free capacity increase.

Compose two individually-useless (zero-capacity) or individually-lossy links/sources so their joint use carries information neither can alone — encoding quantum superadditivity/superactivation, which has no classical Shannon analog, as a first-class operator.

Reframe a point-to-point link as measure-in-the-middle at a zero-trust rendezvous node, converting linear loss/rate-vs-distance scaling into square-root scaling (the TF/MDI-QKD move) without granting the node any trust.

Establish shared secrets whose security rests on physical/mathematical impossibility (no-cloning, monogamy, Bell violation) rather than computational hardness, with eavesdropping self-revealing as physical disturbance — paired with device-independent certification of untrusted hardware from correlation statistics alone.

Address a target by both direction AND distance (a focal point) rather than direction alone, enabling discrimination of items that share one coordinate — the near-field beamfocusing analogue for precise retrieval/routing, and the reason a pure-LoS channel can carry rank > 1.

Push matrix-style computation (precoding, transforms, estimation) into the transport medium so it happens during propagation, offloading the central processor — the stacked-intelligent-metasurface analogue of computing inside the channel. Reshapes the effective channel; per-stream Shannon capacity is unchanged.

Run N independent streams over one shared substrate so aggregate throughput = N x per-stream limit. Encodes the honest SDM lesson explicitly: you multiply channels, you never beat the per-channel bound — scaling is parallelism, not a loophole.

Emit an unbounded incremental-redundancy stream from a fixed payload (spinal-hash / SPARC style) and let the receiver stop as soon as it decodes, converting a fixed rate-vs-reliability choice into an adaptive 'take what the link needs' contract with ACK feedback — the legitimate 'bent question' that operates against the higher feedback-aware curve.

Score any encode/decode pipeline against its meta-converse and RCU achievability bounds at the ACTUAL finite budget (n, error target) rather than against asymptotic capacity, exposing real remaining slack instead of a misleadingly small 'gap to capacity.' The anti-hype instrument for the whole coding stack.

A channel typed by a linear-logic proposition and used exactly once; its two endpoints must be dual (or coherent, for multiparty), so mismatched or dropped protocols fail to typecheck before any code runs. The substructural core (no silent copy/discard) that makes messages behave like real resources.

Express a protocol translation or version-adapter as a functor, so it provably preserves identities and composition (F(g.f)=F(g).F(f)) — guaranteeing behavior-preserving substitution and safe refinement, with the honest caveat that lawfulness holds only once the functor laws are actually discharged.

Retrieve a record from a shared store without revealing which record was requested — single-server lattice PIR (SimplePIR/YPIR) for cold reads, Piano-style client-preprocessing for repeated sublinear reads. Reframes privacy as retrieval-privacy (a different quantity than the trilemma's who-talks-to-whom).

Route the large fixed parallel linear transform of a workload to a fast cheap approximate channel while keeping state, nonlinearity, and control in the slow reliable channel — the photonic-tensor-core-plus-electronic-control split, generalized. Honors Miller's limit: match each sub-operation to the substrate that is cheap at it, never pretend optics does logic or RAM.