Slice-Level Capacity Loss Overview

• Slice-level capacity loss is the reduction in achievable system capacity caused by partitioning resources into discrete segments, leading to measurable performance penalties.
• It arises from practical constraints such as finite signal constellations, block fading limitations, and non-ideal resource allocation in network slicing and deep learning.
• Recent studies show that applying optimization techniques like random sampling and closed-loop reinforcement learning can mitigate these losses and improve system efficiency.

Slice-level capacity loss refers to the reduction in achievable system capacity caused by partitioning resources or signal spaces into discrete, bounded, or non-ideal “slices.” This phenomenon arises across wireless communication, signal processing, network slicing, deep learning, and hardware design domains whenever the ideal (often continuous, unconstrained) resource allocation is replaced by finite, discrete sets due to practical, architectural, or scheduling constraints. Slice-level capacity loss is rigorously studied in the context of constrained signaling, delay-limited fading channels, universal sub-Nyquist sampling, neural network expressivity, and resource isolation in 5G/6G networks.

1. Channel Constraints and Dense Signal Constellations

In high-SNR complex-valued additive noise channels, slice-level capacity loss is prominently manifested when signal constellations are restricted to bounded sets (“slices”) instead of the unconstrained complex plane. The classical Gaussian channel capacity

$$C_\mathbb{C}(P, \sigma) = \log\frac{P}{\sigma^2} + \log(\pi e) - h(W) + o(1)$$

is achieved when inputs are allowed to take any value under a second-moment constraint. Enforcing a bounded support $S$ (e.g., finite-size QAM or PSK), the supremum over input distributions

$$C_S(P, \sigma) = \sup_{X \in S,\, \mathbb{E}[|X|^2] \leq P} I(X; Y)$$

results in asymptotic capacity loss as $\sigma \to 0$:

$$L = \log(P) + \log(\pi e) - \log\left(\int_S e^{-\lambda |x|^2} dx\right) - \lambda P$$

with $\lambda$ set by the imposed moment constraint. For square constellations (as used in most practical systems), this yields a limiting power loss of $1.53$ dB ($L = \log(\pi e/6)$) (Koch et al., 2012). Notably, while the loss approaches this value for densely-packed (large cardinality) constellations, any fixed, finite constellation suffers even greater loss as noise vanishes, diverging due to quantization. The mathematical framework generalizes to arbitrary constellation shapes and noise distributions, indicating the universality of slice-level loss under bounded support constraints.

2. Delay-Limited Channels and Worst-Case Expected Capacity Loss

In block-fading channels, the “slice-level” analogy appears when coding is limited to a single coherence block—effectively forming channel slices indexed by the fading state. The achievable expected rate (over fading distribution) $C_\text{exp}(F_G, 1)$ falls short of the ergodic capacity $C_\text{erg}(F_G) = \mathbb{E}_G[\log(1+G)]$, resulting in quantifiable slice-level losses:

• Additive gap: $$A(F_G,1) = C_\text{erg}(F_G) - C_\text{exp}(F_G, 1)$$
• Multiplicative gap: $$M(F_G,1) = C_\text{erg}(F_G) / C_\text{exp}(F_G, 1)$$

The worst-case additive loss for $K$ fading states is $\log K$ nats, and the worst-case multiplicative loss is $K$ (Yoo et al., 2012). These results characterize the penalty intrinsic to delay constraints: inability to “average” over random channel slices. Extensions include multiuser and dirty-paper channels, highlighting fundamental slice-level penalties across scenarios.

3. Minimax Capacity Loss in Universal Sub-Nyquist Sampling

When spectrum is partitioned into $n$ subbands (“slices”) but the occupancy pattern is unknown and sampling is channel-blind, universal samplers suffer a rate loss compared to optimally matched samplers. The minimax slice-level capacity loss is formalized as

$L = \inf_Q \max_{s \in \binom{[n]}{k}} L_s^Q$

where $L_s^Q$ quantifies loss per active subband set. As $n$ and SNR grow, the loss obeys

$$L/(W/2) \approx \frac{1}{2} \mathcal{H}(\beta) - \frac{1}{2}\alpha\mathcal{H}(\beta/\alpha), \quad \text{for }\alpha \geq \beta$$

with $\alpha = m/n$ (undersampling factor) and $\beta = k/n$ (sparsity), and $\mathcal{H}(\cdot)$ the binary entropy function (Chen et al., 2013). Gaussian random sampling matches this minimax loss with high probability by ensuring near-equidistribution over slices, demonstrating the effectiveness of randomization in mitigating slice-level information loss.

Domain	Slice Constraint	Loss Metric
Additive channel coding	Bounded support set	Power/rate loss; dB/nats
Block fading channels	One-block coding	Additive/multiplicative rate gap
Sub-Nyquist sampling	Unknown subband occupancy	Minimax entropy-based rate loss

4. Neural Network Capacity Thresholds

Slice-level capacity loss is rigorously defined in neural networks via two dimensions:

• Lossless Memory (LM) dimension: The largest number of random points that can be perfectly memorized. $D_{\text{LM}} = |\text{NN}|$ (number of parameters in bits).
• MacKay (MK) dimension: The number of points for which, among random labelings, only 50% can be fit; $D_{\text{MK}} = 2|\text{NN}|$ (Friedland et al., 2017).

Experiments confirm linear scaling: as dataset size exceeds $D_{\text{LM}}$, slice-level loss arises—first as gradual degradation (MK regime), later as catastrophic forgetting. These findings establish predictive boundaries for expressivity and memorization, with direct applications to benchmarking architecture efficiency and setting limits for experimental design.

5. Resource Slicing and Capacity Loss in Network Slicing

Network slicing, pivotal in 5G and beyond, incurs capacity loss when finite resources (CPU, bandwidth, RBs) are partitioned among slices with differing QoS, isolation, or delay constraints. Models enforce:

• CPU constraint: $\sum_{i \in V_F} g^i \leq \sum_{u \in V_S} r_u$
• Bandwidth constraint: $$\sum_{(i,j) \in E_F} g^{ij} \leq \sum_{(u,v) \in E_S} r_{uv}$$
• Delay constraint: $$\sum_{(i,j)\in E_F} \sum_{(u,v)\in E_S,u\neq v} (f^{ij}_{uv} g^{ij} L_{uv}) + \sum_{i\in V_F} \alpha^i \leq d_{E2E}$$

Choice of isolation parameter ($K_{rel}$) balances reliability versus utilization. Stringent allocation and isolation constraints mitigate capacity loss but can under-utilize available resources (Sattar et al., 2018, Ndikumana et al., 2022). Optimizations via auctions (VCG), closed-loop RL, and multi-objective metaheuristics are employed to manage slice-level losses dynamically and maximize overall efficiency (Alauthman et al., 5 Oct 2025).

6. Advanced Slicing in Deep Learning and Data Processing Architectures

Beyond core resource and channel slicing, modern methods introduce slicing within neural architectures and inference scheduling:

• Model slicing uses an adjustable “slice rate” $r$ to dynamically activate subsets of parameters, enabling elastic capacity management ($\text{Cost} \approx r^2 C_0$) while mitigating performance loss via group residual learning and implicit distillation (Cai et al., 2019).
• Slice-based learning allocates additional capacity (specialized experts, residual attention modules) to application-critical data “slices,” directly improving performance on rare or safety-critical subsets (Chen et al., 2019).
• Hardware accelerators (Panacea) further exploit asymmetric quantization and compress/high-skip frequent nonzero slices, dramatically improving hardware efficiency and throughput via run-length encoding and co-optimization techniques (Kam et al., 13 Dec 2024).

In distributed LLM training and inference, fine-grained slice packing (SlimPack) and slice-level scheduling (SCLS) enable load-balanced, memory-efficient operation by decomposing variable-length tasks or generations, asymmetrically optimizing forward/backward partitioning, and jointly scheduling slices for maximal parallel utilization (Liu et al., 30 Sep 2025, Cheng et al., 19 Jun 2024).

7. Implications, Generalizability, and Future Directions

Slice-level capacity loss unifies the observable penalties from discretization, bounded support, delay, partitioning, and adaptive scheduling across diverse domains:

• In channel coding, rate/power loss quantifies the penalty for using finite constellations or signal spaces, generalizing to arbitrary shapes and noise models at high SNR.
• In communications networks (including slicing for 5G/6G or dynamic resource allocation), losses are bounded by optimization formulas—auction mechanisms, two-level closed loops, or metaheuristic strategies—tailored to the QoS characteristics (eMBB, URLLC, mMTC).
• In neural and inference architectures, capacity thresholds and slicing techniques precisely delineate expressivity and efficiency, permitting flexible trade-offs for resource-aware applications.
• In hardware and deep learning, algorithm–hardware co-design exploits bit-level compressibility of slices for energy savings without accuracy loss.

Across all domains, slice-level loss is strongly sensitive to the structure of constraints, the distribution of states/slices, and the adaptation strategies employed. Results are general at asymptotic (high SNR, large cardinality) regimes, but finite-system behaviors may deviate, requiring further research into hybrid optimization, real-time adaptation, and non-asymptotic performance guarantees. This area remains fundamental to the interplay between theoretical limits and practical system design in communications, networking, machine learning, and hardware acceleration.