Paper deep dive
Service-Induced Congestion in Memory-Constrained LLM Serving
Ruicheng Ao, Jing Dong, Gan Luo, David Simchi-Levi
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 95%
Last extracted: 6/20/2026, 6:15:49 AM
Summary
The paper identifies 'service-induced congestion' in LLM serving, where the progressive growth of the Key-Value (KV) cache during autoregressive decoding creates endogenous memory pressure. The authors develop a discrete-time dynamical model to show that under continuous batching, homogeneous workloads often lead to unstable eviction-free equilibria and converge to worst-case limit cycles with up to 50% throughput loss. Conversely, they prove that workload heterogeneity (specifically coprime decoding lengths) can desynchronize completion events and stabilize the system. The research proposes two mitigation strategies: rate-limited admission and request mixing.
Entities (8)
Relation Signals (5)
Service-Induced Congestion → causes → Eviction
confidence 100% · When memory capacity is exceeded, systems must evict active requests
KV Cache → consumes → GPU Memory
confidence 100% · The KV cache must reside in GPU high-bandwidth memory (HBM) for fast attention computation.
LLM Serving → utilizes → KV Cache
confidence 100% · In large language model (LLM) serving, each request accumulates persistent graphics processing unit (GPU) memory during service as its key–value (KV) cache grows
Continuous Batching → induces → Service-Induced Congestion
confidence 90% · The interaction among admission, memory growth, and eviction under continuous batching... gives rise to a new form of service-induced congestion.
Heterogeneity → stabilizes → LLM Serving
confidence 90% · heterogeneity in decoding lengths can help sustain throughput... coprime decoding lengths stabilize the eviction-free equilibrium
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:In large language model (LLM) serving, each request accumulates persistent graphics processing unit (GPU) memory during service as its key-value cache grows with every generated token. Under high concurrency, aggregate memory usage therefore increases endogenously over time: the service process itself creates future capacity pressure. When memory capacity is exceeded, systems evict active requests, discarding cached state and restarting them later, which wastes computation and reduces throughput. We develop a discrete-time dynamical model of memory-constrained LLM inference that captures admission, memory growth, and eviction under continuous batching. In the saturated-input regime, the system admits both eviction-free fixed points and limit cycles with evictions. For homogeneous workloads, we show that the eviction-free equilibrium is unstable and that, except for a Lebesgue-measure-zero exact-capture set, the system converges to a unique worst-case limit cycle that is asymptotically stable outside this exceptional set, with throughput losses as large as 50%. For heterogeneous workloads, we prove a stability criterion in the two-class common-input setting and explain how the survival-polynomial mechanism generalizes to multiple classes and heterogeneous-input lengths. Under an input-dominated scaling regime, coprime decoding lengths stabilize the eviction-free equilibrium, while non-coprime lengths create synchronized modes that drive instability. These results characterize when workload heterogeneity desynchronizes completions and helps stabilize memory-constrained serving. More broadly, we identify service-induced congestion as a structural instability mechanism and derive scheduling design principles for sustaining high throughput.
Tags
Links
- Source: https://arxiv.org/abs/2606.15555v1
- Canonical: https://arxiv.org/abs/2606.15555v1
Trouble viewing inline? Open PDF directly →
Full Text
298,801 characters extracted from source content.
Expand or collapse full text
Service-Induced Congestion in Memory-Constrained LLM Serving Ruicheng Ao Institute for Data, Systems, and Society, Massachusetts Institute of Technology, Cambridge, MA 02139. Email: aorc@mit.edu. Jing Dong Columbia Business School, Columbia University, New York, NY 10027. Email: jing.dong@gsb.columbia.edu. Gan Luo School of Mathematical Sciences, Peking University, Beijing, China. Email: luogan@stu.pku.edu.cn. David Simchi-Levi Institute for Data, Systems, and Society, Massachusetts Institute of Technology, Cambridge, MA 02139. Email: dslevi@mit.edu. Abstract In large language model (LLM) serving, each request accumulates persistent graphics processing unit (GPU) memory during service as its key–value cache grows with every generated token. Under high concurrency, aggregate memory usage therefore increases endogenously over time: the service process itself creates future capacity pressure. When memory capacity is exceeded, systems must evict active requests, i.e., discarding their cached state and restarting them later, which wastes computation and reduces throughput. This progressive consumption of resources gives rise to a new form of service-induced congestion. In this work, we develop a discrete-time dynamical model of memory-constrained LLM inference that captures the interaction among admission, memory growth, and eviction under continuous batching. In the saturated-input regime, the system admits both eviction-free fixed points and limit cycles with evictions. For homogeneous workloads, we show that the eviction-free equilibrium is unstable under standard batching dynamics and that, except for a Lebesgue-measure-zero exact-capture set, the system converges to a unique worst-case limit cycle that is asymptotically stable outside this exceptional set, where throughput losses can be as large as 50%. For heterogeneous workloads, we prove a sharp stability criterion in the two-class common-input setting and explain how the survival-polynomial mechanism generalizes to multiple classes and heterogeneous-input lengths. Under an input-dominated scaling regime, coprime decoding lengths stabilize the eviction-free equilibrium, while non-coprime lengths create synchronized modes that drive instability. This result characterizes when workload heterogeneity desynchronizes completion events and helps stabilize the system around the eviction-free equilibrium. More broadly, we identify service-induced congestion as a structural instability mechanism in memory-constrained systems and offer scheduling design principles for sustaining high throughput. Keywords: large language model serving; memory constraints; continuous batching; dynamical systems; admission control 1 Introduction Large language models (LLMs) now serve as shared online services that must handle high request volumes under strict latency and reliability requirements (Yu et al., 2022; Kwon et al., 2023). These models generate text using autoregressive decoding. Given an input context, the model produces text one token at a time; each newly generated token is appended to the context and used to condition subsequent token generation. Internally, this process requires storing intermediate attention activations from previous tokens, known as the key–value (KV) cache. In particular, at each transformer layer, every token produces a key and a value vector, and the collection of these vectors for all prior tokens is cached and reused during decoding. This avoids recomputing attention over the full prefix at each step, reducing the per-token computational complexity from quadratic to linear in the sequence length. However, the KV cache grows linearly with the number of generated tokens, resulting in a progressively increasing graphics processing unit (GPU) memory footprint during inference. As such, inference for a single request is not a one-shot computation but a sequence of decoding steps that create, update, and retain request-specific state. This behavior contrasts with traditional stateless inference workloads such as image classification or fixed-length embedding generation, where each request is processed in a single forward pass. For example, in an image classification service, an input image is mapped to a label through one feedforward evaluation of the neural network, after which all intermediate activations can be discarded. In LLM serving, by contrast, a request accumulates internal state across many decoding steps and continuously occupies GPU memory throughout its lifetime. Requests therefore consume not only compute capacity but also persistent memory capacity, making memory a first-class scheduling constraint. Another important characteristic of LLM inference is that modern serving systems do not process requests one at a time. A single decoding step uses only a small fraction of a GPU’s available compute. To achieve high throughput, systems advance many requests concurrently, sharing compute across them. This high concurrency keeps the GPU well utilized, but it also means that the memory states of many requests coexist in the GPU memory. In many practical serving regimes, GPU memory becomes the binding constraint, especially under high concurrency and long-context workloads. In modern agentic and retrieval-augmented deployments, the input context may include conversation history, retrieved documents, uploaded files, tool outputs, and other application state, so the initial context itself can be large and heterogeneous across requests (Lewis et al., 2020; Yao et al., 2023; Schick et al., 2023; Zheng et al., 2024). Production systems therefore treat memory pressure and memory-induced preemption as explicit scheduling concerns: vLLM implements swapping and recomputation for evicted KV caches (Kwon et al., 2023), SGLang employs least-recently-used (LRU) eviction for its radix-tree cache (Zheng et al., 2024), and FastServe (Wu et al., 2023) and TensorRT-LLM (NVIDIA, 2023) schedule preemptively to manage memory overflow. Unlike compute resources, which can be time-shared across requests, GPU memory cannot be safely overcommitted. When aggregate memory usage exceeds capacity, the system must evict in-progress requests, discarding previously accumulated computation, which reduces effective throughput. This memory-driven behavior differs qualitatively from congestion in classical queueing models. In most classical formulations, a job occupies a fixed amount of capacity throughout its lifetime, whether that capacity represents a server, bandwidth, or memory. LLM requests, in contrast, consume increasing capacity: even when a request’s total decoding length is known at admission, its memory footprint grows monotonically during service. A request that fits in memory at admission may become infeasible solely because it continues to run. In this context, eviction is not merely an implementation artifact or rare failure mode. Under sustained load, it becomes unavoidable because memory state grows during service. Service itself therefore creates future capacity pressure, giving rise to a new form of congestion. This structural difference fundamentally changes the role of admission decisions, creating an inherent tension between protecting the system from future memory overflow and maintaining high utilization. A naive myopic admission policy checks only current KV-cache usage: it admits a new request whenever the instantaneous footprint fits within available memory, without reserving capacity for future growth. Such locally feasible decisions can create synchronized memory peaks later, triggering eviction cascades that discard accumulated computation and collapse throughput. At the other extreme, overly conservative policies that reserve memory for worst-case future growth can also perform poorly. Excessive reservation suppresses concurrency and leaves substantial GPU capacity idle, a phenomenon widely observed in practice (Kwon et al., 2023; Zhong et al., 2024). The central challenge is thus how to balance memory protection against utilization when capacity consumption evolves during service. To analyze these dynamics formally, we introduce a discrete-time queueing system in which jobs have known total sizes but resource footprints grow during service. The resulting model departs from classical queues with fixed per-job capacity consumption and reveals phenomena absent from traditional settings, including multiple equilibria and eviction-driven throughput loss. We first analyze the homogeneous workload case, and then study the heterogeneous setting. Near homogeneous workloads arise naturally in schema-constrained LLM applications, such as binary decisions, tool-routing outputs, or fixed-format responses, where requests from the same application have nearly identical decoding budgets (Zheng et al., 2024; Schick et al., 2023; OpenAI, 2024). For example, an evaluation or moderation pipeline may ask the model to return a fixed schema with a small enumerated field, such as answer: yes or answer: no, creating many requests with nearly identical generation lengths. We show that homogeneous workloads are prone to synchronized memory growth, which can lead to memory peaks and throughput collapse, whereas some form of heterogeneity in decoding lengths can help sustain throughput by desynchronizing memory growth across requests. Our analysis also provides an analytical basis for studying congestion and efficiency in stateful artificial intelligence (AI) services where resource consumption evolves during service. 1.1 Contributions We formalize LLM serving with KV-cache memory as a discrete-time dynamical system that captures the interaction among admission, memory growth, and eviction (Section 2). The model isolates a congestion mechanism absent from classical queueing dynamics: resource consumption increases progressively during service. We characterize the long-run behavior of the system in a saturated-input regime, where admission is constrained only by memory feasibility. This regime isolates the intrinsic congestion effects induced by progressive memory growth, independent of stochastic arrival fluctuations, and reveals the fundamental stability limit imposed by the serving architecture itself. For homogeneous job sizes, we provide a general stability characterization of the eviction cascade (Theorem 2, Section 3). For jobs with decode length l1l_1, the dynamics admit an eviction-free fixed point and eviction-level limit cycles, including a maximal-eviction cycle. We show that under the baseline continuous batching policy, the eviction-free fixed point is unstable and intermediate eviction-level cycles are also unstable. More generally, after a support pattern is fixed, the only obstruction to further collapse is the balanced case in which the normalized masses of all live positions are equal; any imbalance forces another support loss. The maximal-eviction limit cycle is the unique cycle that is asymptotically stable outside the Lebesgue-measure-zero exact-capture set on the memory boundary, and its basin contains all memory-boundary initial states except for that set: within each fixed set of occupied stages, only initial states that land exactly on a nonmaximal balanced orbit avoid convergence to this worst-case limit cycle. The resulting throughput losses approach 50% when decoding lengths are large relative to input lengths, compared with the eviction-free equilibrium. The analysis also develops techniques that may be of independent interest for studying discrete-time service systems with growing resource requirements. These techniques combine imbalance-amplification arguments, support-loss analysis, and cycle-stability analysis to characterize the stability or instability of different equilibrium regimes. For heterogeneous job sizes, we establish a sharp stability criterion governed by number-theoretic structure under a large-input scaling (Theorem 3, Section 4). The formal theorem is stated and proved for the two-class common-input setting: the eviction-free equilibrium is asymptotically stable if and only if the two decoding lengths are coprime. Appendix B then explains how the same linear-recurrence and root-structure argument generalizes to multiple classes and heterogeneous-input lengths. The underlying mechanism is synchronization: when decoding lengths share a common divisor, completion events align periodically, producing persistent oscillatory modes that drive the system into eviction. When they are coprime, completion phases drift relative to one another, desynchronizing memory release and damping perturbations. Thus, heterogeneity stabilizes the system only when it breaks arithmetic synchronization; not all diversity is beneficial. Technically, the proof combines linear recurrence theory and spectral analysis. By linearizing the eviction-free dynamics, we obtain a finite-order recurrence for admission perturbations whose characteristic polynomial encodes the decoding lengths. Under the large-input scaling, the roots of this polynomial can be characterized and reveal the stability structure. Service-induced congestion can lead to eviction, which in turn causes throughput degradation and increased latency. This observation motivates treating eviction-free operation as a performance target. Guided by our theoretical analysis, we propose two policies to achieve it: rate-limited admission when the eviction-free equilibrium is unstable, and request mixing for heterogeneous systems (Section 5). The former regulates concurrency through admission control, while the latter uses routing diversification to mitigate synchronization. Together, these policies provide practical guidance for memory-aware LLM serving systems. Simulation experiments are consistent with the theoretical mechanisms and illustrate the practical impact of the proposed policies (Section 6). A model-based simulator suggests that, under stochastic arrivals, the open system exhibits an empirical transition near the worst-cycle throughput identified in the saturated-input analysis: in our runs, baseline admission accumulates backlog once the arrival rate exceeds the worst-cycle throughput, even if it remains below the nominal eviction-free equilibrium throughput. We then use Vidur, a high-fidelity LLM inference serving simulator, together with real-GPU experiments, to show that practical batching, scheduling, and memory-accounting dynamics are consistent with the same synchronization mechanism. Request mixing reduces synchronized completions and improves performance even when mixing only partially reduces the common periodicity. Rate-limited admission (using the analytically derived eviction-free admission rate as a per-iteration cap) mitigates eviction cascades while keeping the system close to full utilization. This approach can also yield substantial latency improvements. 1.2 Related Work LLM serving systems. Efficient LLM inference has motivated a growing literature on batching, memory management, and scheduling. Yu et al. (2022) introduce continuous batching, or iteration-level scheduling, which allows new requests to enter an active batch between decoding iterations and substantially improves GPU utilization. This batching paradigm is now central to modern serving systems, but it also creates the high-concurrency regime in which many requests simultaneously maintain growing KV caches. Memory management has therefore become a first-order concern. Kwon et al. (2023) propose PagedAttention to reduce KV-cache fragmentation and enable flexible memory sharing across requests. NVIDIA TensorRT-LLM (NVIDIA, 2023) similarly supports in-flight batching and paged KV-cache management. Zheng et al. (2024) introduce RadixAttention, which reuses KV-cache states through a radix-tree structure that exploits shared prefixes across requests. FastServe (Wu et al., 2023) focuses on scheduling, using token-level preemption and a skip-join multi-level feedback queue to improve responsiveness under load. Other systems improve efficiency by restructuring the prefill-decode workflow: Agrawal et al. (2023) use chunked prefill, and Zhong et al. (2024) and Patel et al. (2023) separate or specialize resources across prefill and decode phases. These works provide mechanisms for efficient LLM serving under memory constraints. Our work is complementary: rather than proposing another memory-management primitive, we analyze the system-level dynamics induced by growing KV caches under continuous batching. We show that locally feasible admission can create future memory pressure, leading to eviction cascades and throughput loss when aggregate demand approaches capacity. A recent stream of work applies stochastic modeling and online optimization to LLM inference scheduling. Li et al. (2025) establish throughput optimality for a broad class of work-conserving scheduling policies in both standard LLM inference and AI-agent workloads, highlighting work conservation as a central design principle for high-throughput serving. Mitzenmacher and Shahout (2025) survey emerging queueing-theoretic questions in LLM inference, including dynamic KV-cache memory footprints, output-length uncertainty, and preemption. Most closely related to our work, Ao et al. (2025) formulate LLM inference as a multi-stage online scheduling problem with memory constraints and derive fluid-guided threshold policies. Complementary online-optimization perspectives are developed by Jaillet et al. (2025), who study online scheduling under KV-cache constraints, and Chen et al. (2025), who address output-length prediction uncertainty and provide logarithmic competitive guarantees. Recent work also studies routing and load balancing for LLM serving systems; see, for example, Bari et al. (2025), Chen et al. (2026), Lin et al. (2026), and Zhang et al. (2024). Our work takes a different perspective from this literature. We characterize the qualitative behavior of the baseline continuous-batching dynamics near the memory boundary. We show that the feedback between admission, memory growth, and eviction creates a structural failure mode that is not visible from standard throughput or feasibility arguments. Queueing theory. Conceptually, our work is related to queueing models in which congestion affects service capacity, resource availability, or admission decisions. Queueing models with state-dependent service rates capture settings where congestion changes the effective processing capacity of the system, such as service slowdowns under high load (Dong et al., 2015; Delasay et al., 2019; Wu et al., 2022). Bandwidth-sharing and processor-sharing models study how a fixed service capacity is divided among concurrent jobs flows (Massoulié and Roberts, 2002; Zwart and Boxma, 2000; Gupta and Zhang, 2022). A related stream on admission control regulates congestion by restricting entry into capacity-constrained systems through tolls, finite waiting room, or dynamic policies (Naor, 1969; Stidham, 1985; Yoon and Lewis, 2004; Ayhan, 2022; Cohen et al., 2024; Peng, 2024). These works capture important forms of state-dependent congestion and resource sharing, but they typically treat an admitted job’s resource requirement as fixed during service. In LLM serving, by contrast, each admitted request continues to accumulate KV-cache memory during service, so an admission that is feasible at the current time can create future memory overflow. Our modeling approach also connects to fluid and stability analyses of queueing networks, which use deterministic approximations to characterize congestion and performance when the system operates near or above capacity (Dai, 1995; Whitt, 2006; Bassamboo and Randhawa, 2010; Chan et al., 2014; Bramson et al., 2021). Our model shares this goal, but the mechanism is different: the memory state evolves through discrete decoding iterations, and the interaction between stage advancement, admission, and eviction creates synchronization effects. As a result, the system may admit multiple equilibria, including periodic limit-cycle behavior. 2 Model 2.1 Background: How LLM Inference Uses GPU Memory Before the formal model, we summarize the inference mechanics that create memory pressure. An LLM generates text one token at a time, where a token is the atomic unit of text (roughly a word or word fragment). Each request arrives with an input context whose length varies across requests. The model first reads the entire input context in a single pass (the prefill phase) and then enters the decoding phase, producing one output token per iteration. Because each new token depends on all preceding tokens (autoregressive generation), the model must store a pair of key and value vectors per layer for every token processed so far, collectively called the KV cache. This cache lets the model attend efficiently: without it, the model would reprocess the entire generated sequence at every step. The KV cache must reside in GPU high-bandwidth memory (HBM) for fast attention computation. HBM is orders of magnitude smaller than system random-access memory (RAM) and, unlike disk-backed virtual memory, cannot be overcommitted: if the aggregate KV cache of all active requests exceeds capacity, the system must evict some requests. In practice, eviction removes a request from the active batch and discards its KV cache, forcing the system to recompute the cache later (Kwon et al., 2023; NVIDIA, 2023). Crucially, each request’s KV cache grows with every generated token. A request that fits in memory at admission may no longer fit several tokens later. Modern LLM servers use continuous batching to exploit GPU parallelism (Yu et al., 2022; Kwon et al., 2023; Agrawal et al., 2023). Rather than serving one request to completion before starting the next, the server processes many requests simultaneously. In each iteration, all active requests advance by one decoding step, while new requests may be admitted and completed ones retired. Batching is essential for high throughput because a single decoding step typically occupies only a small fraction of the GPU’s parallel compute capacity. Advancing many requests in parallel amortizes per-step overheads and keeps GPU cores busy. However, batching also means that every active request maintains its own KV cache in GPU memory. Total memory usage scales with the number of concurrent requests, making memory exhaustion inherent to high-throughput operation. 2.2 System Model Consider a single GPU with a memory capacity of M tokens serving a stream of heterogeneous requests. Each request arrives with an input context of length l0l_0 and requires l1l_1 decoding tokens; both l0l_0 and l1l_1 can vary across requests. We abstract away the prefill phase and focus on the decoding stage, where the KV cache grows over time and drives memory pressure. This is justified by disaggregated or prefill-specialized serving architectures studied in recent systems (Agrawal et al., 2023; Zhong et al., 2024; Patel et al., 2023): prefill runs on separate hardware, and the resulting KV cache is transferred to the decoding GPU via high-bandwidth interconnects (e.g., NVLink). The transfer is fast relative to decoding iteration time, so the decoding GPU sees each new request as arriving with its input length KV cache already in place. At decoding stage j∈0,…,l1−1j∈\0,…,l_1-1\, the request occupies l0+1+jl_0+1+j tokens of GPU memory, consisting of the input context, the j tokens generated so far, and one additional token reserved for the next decoding step. For analytical tractability, we group requests into K≥1K≥ 1 classes by their input and decoding lengths: class-k requests have input length l0,kl_0,k and decoding length l1,kl_1,k. Throughout, we assume deterministic lengths within each class to isolate the effect of memory growth on stability. We also assume the GPU memory capacity satisfies M>maxkl0,k+l1,kM> _k\l_0,k+l_1,k\, so that even the largest request can be processed in isolation. In practice, GPU memory is typically much larger than the footprint of a single request, allowing many requests to be served concurrently. In simulations, we assume class-k requests arrive as independent Poisson processes with rate λk _k. Let Qn=(Q1n,…,QKn)Q^n=(Q^n_1,…,Q^n_K) denote the queue of waiting requests at time n, and let Xn=(xk,jn:k∈[K],j∈0,…,l1,k−1)X^n= (x^n_k,j:k∈[K],\ j∈\0,…,l_1,k-1\ ) denote the vector of active request mass by class and decoding stage. A class-k request at stage j occupies wk,j=l0,k+1+jw_k,j=l_0,k+1+j tokens of GPU memory. We adopt the convention wk,l1,k=0w_k,l_1,k=0: a request that completes its final decoding step releases all memory. The total memory usage at time n, corresponding to the post-decoding (one-step-ahead) state, is Mn=∑k=1K∑j=0l1,k−1wk,jxk,jn.M^n= _k=1^K _j=0^l_1,k-1w_k,j\,x^n_k,j. At each iteration n, the system evolves as follows. 1. Execute. Every active request advances one decoding stage and generates one token. Class-k requests at their final stage (j=l1,k−1j=l_1,k-1) complete and leave the system, releasing their memory. Define the post-execution state and the corresponding memory usage as x~k,jn=xk,j−1n,j=1,…,l1,k−1,0,j=0, and M~n=∑k=1K∑j=0l1,k−1wk,jx~k,jn respectively. x^n_k,j= casesx^n_k,j-1,&j=1,…,l_1,k-1,\\[4.0pt] 0,&j=0, cases and M^n= _k=1^K _j=0^l_1,k-1w_k,j\, x^n_k,j respectively. 2. Arrive. New requests arrive and join the waiting queue: Qn←Qn+AnQ^n← Q^n+A^n, where An=(A1n,…,AKn)A^n=(A^n_1,…,A^n_K). (We do not specify the arrival process at this stage; this will be addressed later.) 3. Evict. Each surviving request grew by one token during execution. If the post-execution memory exceeds capacity, M~n>M, M^n>M, the system evicts active requests until feasibility is restored (M~n≤M M^n≤ M). Evicted requests forfeit their KV cache and re-enter the queue. Evictions follow a least-progressed-first (LPF) rule: requests at smaller (earlier) stages are evicted before those at larger (later) stages, regardless of class. If LPF partially evicts a stage containing multiple classes, it removes each class in proportion to its occupancy within that stage. Let X^n X^n denote the resulting active state after eviction. 4. Admit. Requests from QnQ^n are admitted into stage 0 subject to the memory constraint: ∑k,jwk,jx^k,jn+∑kwk,0akn≤M, _k,jw_k,j\, x^n_k,j+ _kw_k,0\,a^n_k≤ M, where akna^n_k is the number of class-k requests admitted at time n, and each admission consumes wk,0=l0,k+1w_k,0=l_0,k+1 tokens of memory. (We do not specify how requests are selected from the queue at this stage; this will be addressed later.) Admitted requests enter at stage 0, and the remaining requests stay waiting in the queue. The resulting state after admission defines Xn+1X^n+1 and Qn+1Q^n+1. The sequence above defines one decoding iteration. Completions occur when class-k requests at stage j=l1,k−1j=l_1,k-1 advance and leave the system during the execution step. Let DnD^n denote the number of completions at time n. The throughput is T¯=limN→∞1N∑n=0NDn T= _N→∞ 1N _n=0^ND^n whenever the limit exists. This per-iteration completion rate reflects the degree of concurrency sustained by the active batch; in the saturated-input regime formalized below, it isolates the memory-limited throughput. When iteration duration is approximately constant under sustained continuous batching, T¯ T also approximates wall-clock throughput, but our analysis is stated entirely in completions per iteration. This LPF rule captures a common design principle in LLM serving systems under memory pressure: when preemption or recomputation is needed, schedulers often preserve requests that have already made more decoding progress and remove younger or less-progressed work first (Kwon et al., 2023; NVIDIA, 2023). In the homogeneous continuous-batching model, arrival order and decode progress are aligned, so evicting the latest admitted requests is equivalent to evicting the least-progressed requests. We therefore use LPF as a decode-progress-aware abstraction of such preemption behavior. The rule prioritizes retaining later-stage requests, while abstracting away system-specific recovery costs such as prefill recomputation, swapping, or prefix-cache reuse. The baseline system employs no admission control beyond a one-step memory feasibility check: requests are admitted whenever their anticipated memory footprint (including reserved space for the next decoding step) fits within the available GPU memory. In particular, the admission decision does not reserve capacity for the future growth of KV caches. This greedy policy reflects common practice in existing serving systems (Kwon et al., 2023; NVIDIA, 2023) and isolates the mechanisms that drive throughput loss. Section 5 builds on our analysis to develop improved admission policies. Example 1 (Protocol trace). Consider a single class of requests (K=1K=1) with l0=2l_0=2, l1=3l_1=3, and memory capacity M=24M=24. Stage weights are wj=l0+1+jw_j=l_0+1+j, j=0,1,2j=0,1,2, so stage-0, stage-11, and stage-22 requests occupy 33, 44, and 55 tokens of memory, respectively. We trace two consecutive iterations starting from Xn=(x0n,x1n,x2n)=(1,1,2)X^n=(x^n_0,x^n_1,x^n_2)=(1,1,2) and Qn=8Q^n=8, and assume An=5A^n=5 and An+1=0A^n+1=0. Iteration n. 1. Execute. The two stage-22 requests complete, while the remaining requests advance one stage. The post-execution state becomes X~n=(0,1,1) X^n=(0,1,1), with memory usage M~n=4+5=9 M^n=4+5=9. 2. Arrive. Five new requests arrive, increasing the queue length to Qn←8+5=13Q^n← 8+5=13. 3. Evict. Since M~n=9≤24 M^n=9≤ 24, no eviction occurs. 4. Admit. Each stage-0 request requires w0=3w_0=3 tokens of memory. The feasibility condition 9+3a≤249+3a≤ 24 implies a≤5a≤ 5, so the system admits a=5a=5 requests. Then, Xn+1=(5,1,1)X^n+1=(5,1,1), with memory usage Mn+1=5⋅3+4+5=24M^n+1=5· 3+4+5=24, and queue length Qn+1=13−5=8Q^n+1=13-5=8. Iteration n+1n+1. 1. Execute. The single stage-22 request completes, while the remaining requests advance one stage, yielding X~n+1=(0,5,1) X^n+1=(0,5,1). The resulting memory usage is M~n+1=0⋅3+5⋅4+1⋅5=25>24 M^n+1=0· 3+5· 4+1· 5=25>24. 2. Arrive. No new requests arrive, so the queue length remains Qn+1←Qn+1+An+1=8+0=8Q^n+1← Q^n+1+A^n+1=8+0=8. 3. Evict. Since M~n+1>24 M^n+1>24, the system evicts requests until feasibility is restored. Under LPF, requests at smaller stages are evicted first. Evicting one stage-11 request frees w1=4w_1=4 tokens, reducing memory to 25−4=21≤2425-4=21≤ 24. The post-eviction state is therefore X^n+1=(0,4,1) X^n+1=(0,4,1), and the evicted request rejoins the queue, giving Qn+1←8+1=9Q^n+1← 8+1=9. 4. Admit. After eviction, 24−21=324-21=3 tokens of memory remain available. Since each stage-0 admission requires 33 tokens, the system admits a=1a=1 request. The resulting state is Xn+2=(1,4,1)X^n+2=(1,4,1), with memory usage Mn+2=1⋅3+4⋅4+1⋅5=24M^n+2=1· 3+4· 4+1· 5=24, and Qn+2=9−1=8Q^n+2=9-1=8. This trace illustrates how admission decisions that are feasible at the time they are made can nevertheless lead to memory overflow in the subsequent iteration. 2.3 Equilibria and Stability We consider a saturated-input regime in which enough waiting work is always available, so admission is never demand-constrained. Formally, we replace the exogenous arrival process by an effectively infinite backlog, so that the admission decision at time n is constrained only by GPU memory feasibility. This decouples memory-driven throughput limits from the stochastic arrival process, isolating the maximum sustainable throughput imposed by memory growth and eviction. This is a theoretical abstraction, not a literal description of day-to-day operation. Real systems may move in and out of this regime. Nevertheless, operators strive to keep GPU memory utilized, since idle capacity represents wasted capital (Kwon et al., 2023; NVIDIA, 2023). The memory-constrained regime therefore reveals the fundamental limits that memory growth imposes on performance. Numerical experiments in Section 6 confirm that these insights extend beyond this idealized regime. In the saturated-input regime, the queue never empties, so admissions depend only on the current active state XnX^n, the memory constraint M, and the specified class-selection rule. In the single-class model this rule is automatic; in the multi-class analysis it is fixed by the proportional-admission convention in Section 4. We therefore take XnX^n as the system state. Under these conventions, the dynamics reduce to a deterministic map Xn+1=F(Xn).X^n+1=F(X^n). (1) Our objective is to characterize the macroscopic structure of this map, e.g., its equilibrium behaviors and their dependence on job sizes. Throughout the theoretical analysis in Sections 3 and 4, we use a continuous deterministic formulation in which the state variables xk,jnx^n_k,j represent nonnegative request masses. Admission and LPF eviction are interpreted in the same continuous state space: the admission rule can fill available memory exactly, and when LPF reaches a partially occupied stage, it may remove a proportional amount of request mass from that stage. We call ℬ:=X≥0:∑k=1K∑j=0l1,k−1wk,jxk,j=MB:= \X≥ 0:\ _k=1^K _j=0^l_1,k-1w_k,jx_k,j=M \ the memory boundary. We use the calligraphic symbol ℬB for this boundary; ordinary symbols such as B are reserved for matrices and other local objects. In the saturated-input continuous model, post-admission states lie on ℬB, and the stability statements below are interpreted relative to the induced memory-boundary dynamics. This is the dynamical system to which the equilibrium and stability results apply. The numerical experiments in Section 6 examine finite-request stochastic behavior separately. For the discrete-time dynamical system (1), two classes of long-run behaviors can arise. Definition 1 (Fixed point). A fixed point is a state X∗X^* satisfying F(X∗)=X∗F(X^*)=X^*. In our model, a fixed point is a steady regime: the number of requests at each stage, total memory usage, and throughput all remain constant, with no eviction. Definition 2 (Limit cycle). A limit cycle of period p≥2p≥ 2 is a sequence X1∗,…,Xp∗X_1^*,…,X_p^* where F(Xi∗)=Xi+1∗for i=1,…,p−1,F(Xp∗)=X1∗,F(X_i^*)=X_i+1^* i=1,…,p-1, F(X_p^*)=X_1^*, and p is the smallest positive integer for which this property holds. We refer to both fixed points and limit cycles as equilibria. For a limit cycle of period p, the throughput reduces to T¯=1p∑i=1p∑k=1K(Xi∗)k,l1,k−1, T= 1p _i=1^p _k=1^K(X_i^*)_k,l_1,k-1, where (Xi∗)k,l1,k−1(X_i^*)_k,l_1,k-1 denotes the mass of class-k requests at its final stage in the iith state of the cycle. For a fixed point, T¯=∑k=1KXk,l1,k−1∗ T= _k=1^KX^*_k,l_1,k-1. We further distinguish equilibria by their stability. Let ∥⋅∥\|·\| denote a norm on the state space. For a limit cycle X1∗,…,Xp∗X_1^*,…,X_p^*, define the cycle set =X1∗,…,Xp∗C=\X_1^*,…,X_p^*\ and dist(X,):=minY∈‖X−Y‖dist(X,C):= _Y \|X-Y\|. Definition 3 (Stability). A fixed point X∗X^* is said to be: • Stable if for every ϵ>0ε>0 there exists δ>0δ>0 such that for any X0X^0 satisfying ‖X0−X∗‖<δ\|X^0-X^*\|<δ, ‖Xn−X∗‖<ϵ\|X^n-X^*\|<ε for all n. • Asymptotically stable if it is stable and there exists δ>0δ>0 such that for any X0X^0 satisfying ‖X0−X∗‖<δ\|X^0-X^*\|<δ, limn→∞‖Xn−X∗‖=0 _n→∞\|X^n-X^*\|=0. A limit cycle =X1∗,…,Xp∗C=\X_1^*,…,X_p^*\ is said to be: • Stable if for every ϵ>0ε>0 there exists δ>0δ>0 such that for any X0X^0 satisfying dist(X0,)<δdist(X^0,C)<δ, dist(Xn,)<ϵdist(X^n,C)<ε for all n≥0n≥ 0. • Asymptotically stable if it is stable and there exists δ>0δ>0 such that for any X0X^0 satisfying dist(X0,)<δdist(X^0,C)<δ, limn→∞dist(Xn,)=0 _n→∞dist(X^n,C)=0. For a limit cycle, stability requires convergence to the orbit C, not to a single point. In particular, asymptotic stability implies that there exists an integer shift τ∈0,…,p−1τ∈\0,…,p-1\ such that ‖Xn−X(n+τ)modp∗‖→0.\|X^n-X_(n+τ) p^*\|→ 0. In Sections 3 and 4, the stability notions are applied to the induced memory-boundary dynamics on ℬB. Some of our results involve nongeneric exact-capture exceptions. For these statements, we use the same stability definition relative to an exceptional set. Specifically, given a set ℰE of initial states, a limit cycle C is asymptotically stable outside ℰE if the conditions above hold for every initial state satisfying dist(X0,)<δdist(X^0,C)<δ and X0∉ℰX^0 . In addition, ℰE is a relative Lebesgue-measure-zero subset of the relevant memory-boundary faces. 3 Structural Instability of the Homogeneous System We begin with a homogeneous system in which every request has input length l0l_0 and decoding length l1l_1. Dropping the class superscript, write wj=l0+1+jw_j=l_0+1+j for the memory footprint at stage j. 3.1 Eviction-Free Dynamics and Fixed Point Consider one iteration starting from state Xn=(x0n,…,xl1−1n)X^n=(x^n_0,…,x^n_l_1-1) with total memory usage Mn=M^n=M. During the Execute step, every stage-j request advances to stage j+1j+1 and increases its memory footprint by one token. Requests at the final stage j=l1−1j=l_1-1 complete and depart, releasing their entire footprint, i.e., wl1−1=l0+l1w_l_1-1=l_0+l_1. The net memory freed by the execute step equals (l0+l1)xl1−1n−∑j=0l1−2xjn(l_0+l_1)\,x^n_l_1-1- _j=0^l_1-2x^n_j. In the saturated-input regime, the system converts all freed memory into new stage 0 requests, each costing w0=l0+1w_0=l_0+1 tokens. Therefore, the number of newly admitted (stage 0) requests at the start of iteration n+1n+1 satisfies the balance relation (l0+1)x0n+1=(l0+l1)xl1−1n−∑j=0l1−2xjn.(l_0+1)\,x^n+1_0=(l_0+l_1)\,x^n_l_1-1- _j=0^l_1-2x^n_j. (2) For j=0,1,…,l1−2j=0,1,…,l_1-2, stage advancement gives xj+1n+1=xjnx^n+1_j+1=x^n_j. Combining these relations yields a linear update Xn+1=BXnX^n+1=B\,X^n where B=[α⋯αβ10⋯00⋮⋱⋮00⋯10],α=−1l0+1,β=l0+l1l0+1.B= bmatrixα&α&·s&α&β\\ 1&0&·s&0&0\\ && && \\ 0&0&·s&1&0 bmatrix, α= -1l_0+1,\;\;β= l_0+l_1l_0+1. (3) The first row encodes the balance equation; subsequent rows encode the stage shift. The coefficient β>1β>1 captures a fundamental asymmetry: a completing request frees β admission slots. Note that when l1≫l0l_1 l_0, β is large and each completion can trigger a disproportionate admission burst. Solving F(X∗)=X∗F(X^*)=X^* on the memory boundary yields the eviction-free fixed point. Let ∈ℝl11 ^l_1 denote the all-ones vector. Since α(l1−1)+β=1α(l_1-1)+β=1, we have B=B1=1, and hence any fixed point must be of the form X∗=x∗X^*=x^*1. Imposing M=∑j=0l1−1(l0+1+j)x∗M= _j=0^l_1-1(l_0+1+j)x^* yields x∗=2Ml1(2l0+l1+1).x^*= 2Ml_1(2l_0+l_1+1). (4) At X∗X^*, each stage holds x∗x^* requests, memory remains at capacity M with no eviction, and throughput equals x∗x^* completions per iteration. 3.2 Equilibria with Eviction The fixed point X∗X^* is not the only equilibrium. When memory overflows, the dynamics admit periodic regimes in which some stages remain empty at every iteration. For an integer i∈0,1,…,l1−1i∈\0,1,…,l_1-1\, we say the system is at eviction level i at time n if exactly i coordinates of XnX^n equal zero and the remaining l1−il_1-i coordinates are strictly positive. In particular, level 0 corresponds to eviction-free operation (no empty stages). An eviction-level-i limit cycle is a periodic orbit X1,…,Xp\X_1,…,X_p\ such that every state on the orbit has exactly i empty coordinates. Example 2 (Example equilibria). Consider l0=2l_0=2, l1=3l_1=3, memory capacity M=24M=24. The system admits three equilibria corresponding to eviction levels i=0,1,2i=0,1,2. Eviction level 0. The fixed point is X∗=(2,2,2)X^*=(2,2,2) and achieves throughput x∗=2x^*=2. Eviction level 11. At eviction level 11, the system admits the period-33 limit cycle (7213,2413, 0)→(0,4813,2413)→(2413, 0,4813)→(7213,2413, 0), ( 7213,\, 2413,\,0 )\;→\; (0,\, 4813,\, 2413 )\;→\; ( 2413,\,0,\, 4813 )\;→\; ( 7213,\, 2413,\,0 ), with throughput (24/13+48/13)/3≈1.85(24/13+48/13)/3≈ 1.85. Note that eviction occurs on the first transition. Eviction level 22. At eviction level 2, the system admits the period-3 limit cycle (8,0,0)→(0,6,0)→(0,0,245),(8,0,0)\;→\;(0,6,0)\;→\; (0,0, 245 ), with throughput 8/58/5, corresponding to a 20%20\% reduction from the fixed-point throughput x∗x^*. Remark 1. For l1≥4l_1≥ 4, limit cycles at a given eviction level i, 2≤i≤l1−22≤ i≤ l_1-2, need not be unique. Stage j is said to be occupied if it contains at least one active request. Different configurations of occupied stages can produce distinct periodic orbits with different throughputs. Figure 1 illustrates this landscape. For a fixed eviction level, some cycles concentrate all occupied stages into a single contiguous block of stage indices, while others distribute occupied stages as evenly as possible around the pipeline. Appendix A.3 shows that, among fixed-relative-support periodic cycles with the same number of occupied stages, these two gap geometries form the throughput envelope: contiguous-block configurations achieve the lowest throughput, whereas as-evenly-spaced configurations achieve the highest throughput (Propositions 6–8). Equivalently, for the cycled equilibria described by a fixed set of relative live positions, the predecessor-gap vector gives a general parametrization, and the contiguous and as-evenly-spaced gap vectors give the lower and upper throughput bounds within that equilibrium class. Figure 1: Throughput landscape across eviction levels for l0=2l_0=2, l1=12l_1=12. The contiguous-block family (Proposition 6) gives the lower-throughput envelope at each level; the as-evenly-spaced gap family (Proposition 8) gives the upper-throughput envelope. All fixed-relative-support periodic cycle throughputs at the same eviction level lie between these two curves. Both envelopes coincide at level 0 (x∗x^*, the eviction-free optimum) and level l1−1l_1-1 (cl1−1c_l_1-1, the worst case). The gap widens at intermediate levels, reaching 16% of x∗x^* at level 8. At the maximal eviction level i=l1−1i=l_1-1, exactly one stage is active at each iteration, whose size saturates the memory constraint. The resulting cycle has the form (Mw0,0,…,0)→(0,Mw1,0,…,0)→⋯→(0,…,0,Mwl1−1). ( Mw_0,0,…,0 )→ (0, Mw_1,0,…,0 )→·s→ (0,…,0, Mw_l_1-1 ). The corresponding throughput equals T¯l1−1:=Ml1(l0+l1). T_l_1-1:= Ml_1(l_0+l_1). The maximal-eviction cycle leads to the lowest throughput among all equilibria: Lemma 1 (Worst-case throughput). Let C be any limit cycle and let T¯() T(C) denote its throughput. T¯()≥T¯l1−1=Ml1(l0+l1). T(C)≥ T_l_1-1= Ml_1(l_0+l_1). Moreover, equality holds if and only if C is the maximal-eviction cycle (i.e., eviction level l1−1l_1-1). We define the worst-case throughput ratio as T¯l1−1x∗=l1(2l0+l1+1)/2l1(l0+l1)=2l0+l1+12(l0+l1). T_l_1-1x^*= l_1(2l_0+l_1+1)/2l_1(l_0+l_1)= 2l_0+l_1+12(l_0+l_1). This ratio lies in (1/2,1)(1/2,1). It decreases with the decoding length l1l_1 and increases with the input length l0l_0. The ratio approaches 1/21/2 as l1/l0→∞l_1/l_0→∞. 3.3 Eviction Cascade Although the eviction-free fixed point X∗X^* achieves the maximum throughput, it is unstable. Baseline admission amplifies any small imbalance across stages, eventually triggering eviction. Once eviction begins, the system does not return to eviction-free operation; instead, it cascades through regimes with progressively more empty stages and settles into the worst-case limit cycle at eviction level l1−1l_1-1. This eviction cascade is formalized in the following theorem. Theorem 2 (Baseline Instability). For a fixed decoding length l1≥2l_1≥ 2, in the saturated-input continuous model, the system admits an eviction-free fixed point, a maximal-eviction limit cycle at eviction level l1−1l_1-1, and, when l1≥3l_1≥ 3, intermediate eviction-level limit cycles. The stability and basin structure under baseline admission are as follows. 1. The eviction-free fixed point is not stable. 2. Eviction-level-i limit cycles, for i=1,…,l1−2i=1,…,l_1-2, are not stable. Let ℰE denote the set of memory-boundary initial states whose trajectories are captured exactly by a nonmaximal balanced orbit; equivalently, there exists a finite time after which the trajectory lies on either the eviction-free fixed point or an intermediate balanced limit cycle. Within the relative interior of each fixed support face of ℬB, i.e., after fixing which coordinates are zero and which are positive, the set ℰE has relative Lebesgue measure zero. 3. The maximal-eviction limit cycle, at eviction level l1−1l_1-1, is asymptotically stable outside ℰE. Its basin of attraction contains every memory-boundary initial state except those whose trajectories are captured exactly by a nonmaximal balanced orbit. The exceptional set ℰE has relative Lebesgue measure zero within each such fixed support face of the memory boundary. The instability is driven by an amplification mechanism, captured by the spread Gn:=maxjxjn−minjxjn.G^n:= _jx^n_j- _jx^n_j. (5) Before any eviction happens (i.e., before any stage occupancy has reached zero), the stage shift preserves all non-final coordinates in XnX^n, up to the deterministic relabeling of stages. For the final and first stage, rewrite the memory balance equation in (2) as x0n+1=xl1−1n+∑j=0l1−1(xl1−1n−xjn)l0+1x^n+1_0=x^n_l_1-1+ _j=0^l_1-1(x^n_l_1-1-x^n_j)l_0+1 (6) Let xavgn=l1−1∑j=0l1−1xjnx_avg^n=l_1^-1 _j=0^l_1-1x^n_j. Then if xl1−1n≤xavgnx^n_l_1-1≤ x_avg^n, x0n+1≤xl1−1nx^n+1_0≤ x^n_l_1-1. If xl1−1n>xavgnx^n_l_1-1>x_avg^n, x0n+1>xl1−1nx^n+1_0>x^n_l_1-1. Thus, GnG^n is non-decreasing. Moreover, whenever an extremal cohort reaches the final stage, the spread grows strictly. If the current minimum occupies the final stage, then every term xl1−1n−xjnx^n_l_1-1-x^n_j in (6) is nonpositive and at least one term is at most −Gn-G^n. Hence x0n+1≤xl1−1n−Gnl0+1.x^n+1_0≤ x^n_l_1-1- G^nl_0+1. The old maximum is preserved by the shift, so the spread increases by at least Gn/(l0+1)G^n/(l_0+1). Similarly, if the current maximum occupies the final stage, then x0n+1≥xl1−1n+Gnl0+1,x^n+1_0≥ x^n_l_1-1+ G^nl_0+1, while the old minimum is preserved, and the spread again increases by at least Gn/(l0+1)G^n/(l_0+1). Thus, if an eviction-free trajectory with G0>0G^0>0 persisted, following a current maximum or minimum around the pipeline would force repeated positive spread increments. If that extremum is replaced before reaching the final stage, the replacement is already a strict renewal of the same extremum; the formal proof in Lemma A.2 handles this bookkeeping through the running maximum. Since the memory constraint bounds every stage occupancy by M/(l0+1)M/(l_0+1), these repeated increments cannot continue forever. Therefore the eviction-free regime must break down in finite time: the first memory overflow triggers LPF eviction, creating the first eviction-induced support loss and moving the trajectory to the next lower live-support level. After support loss, the physical-stage spread is no longer the right object, because eviction changes which physical stages carry mass. We therefore switch to a relative-position representation on a circular pipeline. In this representation, live positions move deterministically around the circle, and once a relative position becomes empty, it never revives. We then sample the dynamics only at block-end times. An eviction block is a consecutive sequence of iterations in which evictions occur but no live position completes; the corresponding block-end is the first subsequent iteration in which a live position completes and new requests are admitted. Sampling at block-ends reduces the post-support-loss dynamics to a lower-dimensional iterative map. Lastly, we measure imbalance using a normalized block-end spread, where each live mass is divided by the predecessor gap, which is the number of stages from the previous live position. The normalization makes the mass more comparable because positions with larger gaps accumulate more mass during eviction. Under the normalized spread, the same amplification mechanism holds: unless the normalized live masses are exactly balanced, the block-end dynamics amplify imbalance and eliminate at least one additional live position after finitely many updates. The trajectory then moves to a lower-dimensional support face, where the same argument applies recursively (see Appendix A for more details). Since empty relative positions never revive, support losses form a finite cascade. Every trajectory not lying exactly on, or landing exactly on, a balanced intermediate cycle eventually reaches the single-live-position regime, namely the maximal-eviction cycle. Such exact capture is nongeneric, requiring the normalized live masses to satisfy a collection of exact linear equalities. At the maximal-eviction level, the memory boundary and LPF eviction damp perturbations within one pipeline cycle, so the maximal-eviction cycle is asymptotically stable outside the exact-capture set. Example 3 (Instability spiral). Consider the system with l0=2l_0=2, l1=3l_1=3, and memory capacity M=24M=24 (same as Example 1). The eviction-free equilibrium has x∗=2x^*=2. We perturb this equilibrium by increasing stage 0 slightly, by 12 12. Specifically, we start from X0=(52, 2,1710)X^0= ( 52,\,2,\, 1710 ). The balance equation (2) yields the following eviction-free trajectory: n Xn=(x0n,x1n,x2n)X^n=(x^n_0,x^n_1,x^n_2) GnG^n 0 (52, 2,1710) ( 52,\,2,\, 1710 ) 45 45 1 (43,52, 2) ( 43,\, 52,\,2 ) 76 76 2 (3718,43,52) ( 3718,\, 43,\, 52 ) 76 76 3 (8227,3718,43) ( 8227,\, 3718,\, 43 ) 4627 4627 4 (85162,8227,3718) ( 85162,\, 8227,\, 3718 ) 407162 407162 5 (544243,85162,8227) ( 544243,\, 85162,\, 8227 ) 407162 407162 6 (60371458,544243,85162) ( 60371458,\, 544243,\, 85162 ) 2636729 2636729 n XnX^n (approx.) level event 77 (0, 3.20, 2.24)(0,\;3.20,\;2.24) 11 first eviction 1010 (0, 2.67, 2.66)(0,\;2.67,\;2.66) 11 second eviction 1313 (0, 1.56, 3.55)(0,\;1.56,\;3.55) 11 third eviction 1616 (0, 0, 4.80)(0,\;0,\;4.80) 22 second position dies 1717 (8, 0, 0)(8,\;0,\;0) 22 worst-case cycle begins 1818 (0, 6, 0)(0,\;6,\;0) 22 ⋯·s 1919 (0, 0, 4.8)(0,\;0,\;4.8) 22 ⋯·s At iteration n=6n=6, the execute step shifts the state to X~6=(0,x06,x16)=(0,60371458,544243) X^6=(0,\,x^6_0,\,x^6_1)= (0,\, 60371458,\, 544243 ), whose post-execution memory usage is M~6=4x06+5x16=20234729>24. M^6=4x^6_0+5x^6_1= 20234729>24. LPF evicts from the least-progressed occupied stage (stage 1), reducing it by e=(M~6−24)/4=13691458e=( M^6-24)/4= 13691458 and leaving no slack for admission: X7=(0,778243,544243)X^7= (0,\, 778243,\, 544243 ). This is the first eviction (see also Figure 6). Continuing from X7=(0,778243,544243)X^7=(0,\, 778243,\, 544243), the system enters eviction level 11 (one empty stage per iteration). Over the next nine iterations, LPF evictions progressively deplete the second live position. At n=16n=16, the system enters the maximal-eviction cycle (8,0,0)→(0,6,0)→(0,0,4.8)(8,0,0)→(0,6,0)→(0,0,4.8), which repeats stably with throughput T¯2=8/5 T_2=8/5, a 20% reduction from x∗=2x^*=2. Figure 6 in Appendix A visualizes the growing oscillation and first eviction in this example. Above all, the instability is structural: baseline admission converts each completion burst into a disproportionate admission pulse (β>1β>1), and progressive memory growth amplifies these pulses as they propagate through the pipeline. The pulses eventually synchronize all requests at a single stage, triggering maximal eviction. 4 Multi-Class Systems and Structural Stability Real LLM workloads are heterogeneous: short chat completions, long code-generation sessions, and multi-turn reasoning chains coexist on the same GPU pool, each with different input and decoding lengths. Variation in decoding lengths can desynchronize completions and mitigate the eviction cascades identified in Section 3. As we show in this section, whether this desynchronization is strong enough to stabilize the system depends on the arithmetic structure of the decoding lengths. 4.1 Multi-Class Model and Large-Input Regime Consider K≥2K≥ 2 request classes with decoding lengths l1,1<l1,2<⋯<l1,Kl_1,1<l_1,2<·s<l_1,K and arrival proportions p1,…,pKp_1,…,p_K (∑k=1Kpk=1 _k=1^Kp_k=1, and pk>0p_k>0 for k=1,…,Kk=1,…,K). Each class k has input length l0,kl_0,k. As before, we focus on the saturated-input regime: the waiting queue is never empty, and admission is constrained only by memory. Because the backlog is effectively infinite, the system must specify how request classes are selected for admission. We impose the natural proportion constraint that xk,0n=pk∑h=1Kxh,0nx^n_k,0=p_k _h=1^Kx^n_h,0. This constraint separates memory dynamics from class-selection effects. To isolate the structural effects of heterogeneous decoding lengths, we analyze an input-dominated asymptotic regime. Specifically, we consider a sequence of systems in which the decoding lengths remain fixed, while input lengths and total memory scale proportionally: l0,k=rkL,M=cL,L→∞,l_0,k=r_kL, M=c\,L, L→∞, (7) where r1,…,rK>0r_1,…,r_K>0 and c>0c>0 are fixed constants. This scaling preserves non-degenerate concurrency while making per-stage memory costs nearly constant across stages. Indeed, for a class k request at stage j, wk,j=l0,k+1+j=rkL(1+O(1/L))w_k,j=l_0,k+1+j=r_kL (1+O(1/L) ), so the relative variation in memory usage across decoding stages vanishes as L grows. In this limit, the dominant source of dynamics is not the precise stage-dependent memory weight, but the timing of request completions, which is determined by the interaction among the decoding lengths. This regime also reflects an input-dominated setting common in modern LLM serving. In retrieval-augmented and agentic workflows, the input context can include retrieved documents, uploaded files, interaction histories, tool outputs, and other application state (Lewis et al., 2020; Yao et al., 2023; Schick et al., 2023; Zheng et al., 2024), while individual decoding outputs may span only tens to a few hundred tokens. It is worth noting that large inputs also attenuate the amplification mechanism observed in the homogeneous model. There, eviction cascades are driven by the memory gradient across stages: a completion releases wl1−1=l0+l1w_l_1-1=l_0+l_1 tokens of memory while admissions consume only w0=l0+1w_0=l_0+1, yielding amplification factor β=wl1−1/w0=1+O(l1/l0)β=w_l_1-1/w_0=1+O(l_1/l_0). Thus, when inputs dominate memory usage, the stage-to-stage memory gradient becomes small, and eviction cascades cause smaller throughput losses. The eviction-free fixed point nevertheless remains unstable for every finite l0l_0, and eviction cascades can still occur. In the heterogeneous setting, we use the large-input regime to remove the confounding effect of stage-dependent memory weights and expose the role of completion timing. The limiting dynamics are then governed by the arithmetic structure of the decoding lengths, leading to the gcd(l1,1,…,l1,K) (l_1,1,…,l_1,K)-based dichotomy derived below. The numerical experiments in Section 6 confirm that these structural insights persist at finite input lengths, including regimes where the homogeneous throughput loss is substantial. We first characterize the eviction-free equilibrium. In the saturated-input regime with proportion constraint, an eviction-free fixed point is one in which: 1) No request is evicted before completing decoding; 2) Memory is exactly saturated; 3) Admissions occur at a constant rate x∗x^* per iteration; and 4) The composition of active jobs reflects the proportions pkp_k. At such a state, each class-k job occupies stages 0,…,l1,k−10,…,l_1,k-1, and there are pkx∗p_kx^* jobs in each active stage of class k. Memory balance therefore requires ∑k=1Kpkx∗∑j=0l1,k−1(l0,k+1+j)=M. _k=1^Kp_kx^* _j=0^l_1,k-1(l_0,k+1+j)=M. Define the total lifetime memory footprint of a class-k job as Ck=∑j=0l1,k−1(l0,k+1+j)=l1,k(l0,k+l1,k+12).C_k= _j=0^l_1,k-1(l_0,k+1+j)=l_1,k\! (l_0,k+ l_1,k+12 ). Then, the eviction-free admission rate is x∗=M∑k=1KpkCk.x^*= M _k=1^Kp_kC_k. (8) At this fixed point, every iteration admits x∗x^* new jobs, completes x∗x^* jobs, and maintains a constant occupancy profile across decoding stages. As before, a central question is whether this eviction-free fixed point is dynamically stable, which we study next. 4.2 Heterogeneity, Synchronization, and Stability Unlike the homogeneous case, heterogeneity introduces additional structure that can fundamentally alter system dynamics. Requests of different classes are completed at different speeds due to the heterogeneous decoding lengths, so their completion times may or may not align over repeated iterations. Such alignment (or lack thereof) determines whether memory-release bursts synchronize and trigger eviction cascades. To understand when heterogeneity mitigates eviction-induced instability, we study perturbations around the eviction-free fixed point. In the saturated-input regime, the admission and execution rules define a deterministic discrete-time dynamical system. In the eviction-free regime under proportional admissions, aggregate admission perturbations satisfy a recurrence that describes how small imbalances propagate. Let Δn:=x0n+1−x0n ^n:=x^n+1_0-x^n_0 denote the change in aggregate stage-0 admissions at iteration n. A class-k request admitted m iterations ago occupies l0,k+1+ml_0,k+1+m memory tokens if l1,k>ml_1,k>m. Thus, conservation of total memory in the eviction-free regime gives the linearized recurrence ∑m=0l1,K−1(∑k:l1,k>mpk(l0,k+1+m))Δn−m=0. _m=0^l_1,K-1 ( _k:l_1,k>mp_k(l_0,k+1+m) ) ^n-m=0. (9) The outer sum ranges over possible lags, while the inner sum includes exactly the request classes that remain active at that lag. The equality to zero enforces that total memory remains at capacity when no eviction occurs. By standard linear recurrence theory (Elaydi, 2005), perturbations are linear combinations of modes znz^n, where z is a root of the characteristic polynomial F(z)=∑m=0l1,K−1(∑k:l1,k>mpk(l0,k+1+m))zl1,K−1−m.F(z)= _m=0^l_1,K-1\! ( _k:\,l_1,k>mp_k\,(l_0,k+1+m) )\,z^l_1,K-1-m. (10) Each root corresponds to one perturbation mode: modes with |z|<1|z|<1 decay, while modes with |z|>1|z|>1 grow. Thus the linear stability of the eviction-free equilibrium is determined by whether all roots lie inside the unit circle. Under the scaling (7), dividing F by L and sending L→∞L→∞ gives the limiting polynomial A(z)=∑m=0l1,K−1(∑k:l1,k>mpkrk)zl1,K−1−m,A(z)= _m=0^l_1,K-1\! ( _k:\,l_1,k>mp_k\,r_k )\,z^l_1,K-1-m, whose coefficients depend only on the decoding lengths, arrival proportions, and input-length ratios. Let R=∑k=1KpkrkR= _k=1^Kp_k\,r_k. Rearranging gives (1−z)A(z)=−Rzl1,K+∑k=1Kpkrkzl1,K−l1,k.(1-z)\,A(z)\;=\;-R\,z^l_1,K\;+\; _k=1^Kp_k\,r_k\,z^l_1,K-l_1,k. (11) Interestingly, the arithmetic structure of the decoding lengths determines whether the limiting polynomial has non-trivial root-of-unity modes on the unit circle. The key quantity is the greatest common divisor of the decoding lengths. The following theorem formalizes this dichotomy. We state the formal theorem for the two-class common-input case. Both classes are perpetually backlogged, have fixed admission proportions p∈(0,1)p∈(0,1) and q=1−pq=1-p, and share a common input length l0l_0. LPF eviction is applied by decoding stage, and when a partially evicted stage contains both classes, each class is removed in proportion to its occupancy within that stage. The dynamics are the continuous-mass saturated-input memory-boundary dynamics of Section 2. Theorem 3 (Greatest Common Divisor (GCD) Stability Condition). Consider two request classes with common input length l0l_0, decoding lengths l1,1<l1,2l_1,1<l_1,2, and admission proportions p and 1−p1-p. Let g=gcd(l1,1,l1,2)g= (l_1,1,l_1,2). In the saturated-input continuous model, for all sufficiently large l0l_0: 1. If g>1g>1, then the eviction-free equilibrium is linearly unstable: the nonzero eigenvalues, equivalently the roots of F, consist of g−1g-1 unstable roots with modulus |z|=1+Θ(1/l0)|z|=1+ (1/l_0) and l1,2−gl_1,2-g stable roots; the full stage-state map also has one zero eigenvalue. Consequently, any sufficiently small perturbation with nonzero projection onto the unstable eigenspace leaves the local region where LPF eviction is inactive in finite time. 2. If g=1g=1, then the eviction-free equilibrium is globally asymptotically stable: from any feasible initial active state in the saturated-input continuous model, the system converges to the eviction-free fixed point. Appendix B proves the theorem and explains how the same linear-recurrence and root-structure argument generalizes to K-class and heterogeneous-input systems. In particular, Lemma 15 proves the exact unstable/stable root count in the non-coprime case, and Lemma 16 turns the unstable eigenmodes into the finite-exit conclusion. We highlight the main spectral mechanism here. Let i denote the imaginary unit, i.e., i2=−1i^2=-1. When g>1g>1, the limiting polynomial A(z)A(z) has roots at all non-trivial g-th roots of unity. To see this, consider zj=e2πij/g=cos(2πj/g)+isin(2πj/g)z_j=e^2π ij/g= (2π j/g)+i (2π j/g) for j=1,…,g−1j=1,…,g-1, which are non-trivial g-th roots of unity, i.e., zjg=1z_j^g=1 and zj≠1z_j≠ 1. Since g divides every decoding length l1,kl_1,k, we have zjl1,K−l1,k=1z_j^l_1,K-l_1,k=1 for all k, which further implies (1−zj)A(zj)=−R+R=0.(1-z_j)A(z_j)=-R+R=0. Because zj≠1z_j≠ 1, it follows that A(zj)=0A(z_j)=0. Thus, the non-trivial g-th roots of unity generate unit-circle modes of the limiting linearized dynamics, independently of the input-length ratios rkr_k. For the formal two-class common-input theorem, the finite-l0l_0 characteristic polynomial is an O(1/l0)O(1/l_0) perturbation of the limiting polynomial. Appendix B verifies the required nondegeneracy and shows that each unit-circle root of A perturbs to a nearby finite-l0l_0 root with outward displacement of order O(1/l0)O(1/l_0), so these modes satisfy |z|=1+Θ(1/l0)>1|z|=1+ (1/l_0)>1. The K-class and heterogeneous-input generalization uses the same root-of-unity mechanism with weighted survival coefficients; the drift constants depend on the class weights, but the synchronization mechanism is unchanged. When g=1g=1, there are no non-trivial common roots of unity. In this case, the same polynomial representation, together with a triangle-inequality argument, shows that all roots lie strictly inside the unit circle. For the formal two-class common-input theorem, the Lyapunov argument in Appendix B proves global convergence to the eviction-free equilibrium. The dichotomy reflects the synchronization structure of completion events. When g>1g>1, completion times share a common period g, so memory releases occur in synchronized bursts. These bursts reinforce periodic oscillations and, for generic local perturbations, push the trajectory out of the region where the eviction-free linearization applies. When g=1g=1, completion times occupy different phases of the cycle. Memory is released more evenly over time, which damps oscillations and stabilizes the eviction-free equilibrium. In the heterogeneous non-coprime case, the instability can be “milder” than in the homogeneous system. By Theorem 3, only the g−1g-1 modes associated with g-periodic oscillations are unstable, while the remaining modes are damped. These synchronized modes cause generic local perturbations to exit the no-eviction neighborhood. Appendix Section B.10 complements this local result by constructing an explicit two-class non-coprime instance in which the post-exit dynamics settle into a period-g limit cycle with recurrent evictions. Example 4 (Coprime decode lengths: convergence). Let K=2K=2 with l1,1=2l_1,1=2, l1,2=3l_1,2=3, common input length l0,1=l0,2=l0=50l_0,1=l_0,2=l_0=50, arrival proportions p1=p2=1/2p_1=p_2=1/2, and M=518M=518. This gives the eviction-free equilibrium admission x∗=4x^*=4. With r1=r2=1r_1=r_2=1, the closed form (11) yields A(z)=z2+z+12,A(z)=z^2+z+ 12, whose roots are z=(−1±i)/2z=(-1 )/2, so |z|=1/2≃0.707|z|=1/ 2 0.707. Since gcd(2,3)=1 (2,3)=1, all roots lie strictly inside the unit circle, and perturbations decay geometrically. Figure 2(a) illustrates this behavior: starting from a 25%25\% over-admission (x00=5x^0_0=5), the system converges to x∗x^* within 2%2\% by iteration 88. Intuitively, no oscillation period can synchronize completions of both classes. A period-2 fluctuation in admissions propagates through class-1 completions (delay 22) but is phase-shifted by class-2 completions (delay 33), causing oscillatory modes to interfere destructively. Example 5 (Non-coprime decode lengths: divergence). Let K=2K=2 with l1,1=2l_1,1=2, l1,2=4l_1,2=4, common input length l0,1=l0,2=l0=50l_0,1=l_0,2=l_0=50, and arrival proportions p1=p2=1/2p_1=p_2=1/2. Setting M=626M=626 again yields x∗=4x^*=4. Because gcd(2,4)=2 (2,4)=2, the limiting polynomial A(z)A(z) places a root at z=−1z=-1 on the unit circle. For finite l0=50l_0=50, perturbation analysis shows that this root moves outside the unit circle to |z|≃1.019|z| 1.019. Figure 2(b) shows the resulting dynamics: the same initial perturbation now produces oscillations whose amplitude grows over time. The instability arises from period-2 synchronization. Both class-1 (delay 22) and class-2 (delay 44) completions echo a period-2 fluctuation in admissions, reinforcing the oscillation rather than damping it. Figure 2: Admission trajectories for two multi-class systems (l0=50l_0=50, p=q=1/2p=q=1/2, x∗=4x^*=4, starting at x0(0)=5x_0^(0)=5). (a) Coprime decode lengths (lA=2l_A=2, lB=3l_B=3): the limiting polynomial A(z)=z2+z+12A(z)=z^2+z+ 12 has roots with modulus |z|≈0.72|z|≈ 0.72; the perturbation decays to within 2% of x∗x^* by iteration 8. (b) Non-coprime decode lengths (lA=2l_A=2, lB=4l_B=4, gcd=2 =2): A(z)A(z) has a root at z=−1z=-1 (the non-trivial second root of unity), which drifts to |z|≈1.02|z|≈ 1.02 for finite l0l_0 (Theorem 3); oscillations grow geometrically (dashed envelope), driving the system toward eviction. Both trajectories are computed from the finite-l0l_0 recurrence (9). Remark 2 (Invariance to input-length ratios). The GCD synchronization condition depends only on the decoding lengths l1,1,…,l1,Kl_1,1,…,l_1,K and is invariant to the input-length ratios r1,…,rKr_1,…,r_K and admission proportions p1,…,pKp_1,…,p_K. Intuitively, in the input-dominated regime the input lengths affect the amount of memory carried by each cohort but not the periodic timing of completions. Consequently, the existence of synchronized unit-circle modes is determined by the arithmetic relationship among the decoding lengths. Formally, whether the limiting polynomial has non-trivial root-of-unity modes on the unit circle only depends on the greatest common divisor of the decoding lengths. The remaining roots, and therefore the contraction rates and the leading constants that determine the size of finite-L corrections and the rate at which the asymptotic regime is approached, still depend on rkr_k and pkp_k. 4.3 Finite Input length and Stability Threshold Theorem 3 characterizes stability in the input-dominated limit. We now ask how large the input length must be for a finite system to inherit the coprime stability predicted by that limit. This quantifies the “sufficiently large” input requirement in Theorem 3. For clarity, we focus on two request classes with a common input length l0l_0, coprime decoding lengths: l1,1<l1,2l_1,1<l_1,2, gcd(l1,1,l1,2)=1 (l_1,1,l_1,2)=1, and arrival proportions p and 1−p1-p. Let ρ∞:=max|α|:A(α)=0 _∞:= \|α|:A(α)=0\ be the spectral radius of the limiting polynomial (11). Under the coprime condition, Theorem 3 implies ρ∞<1 _∞<1. For finite l0l_0, however, the roots of the characteristic polynomial drift outward. Write ε:=(l0+l1,2)−1 :=(l_0+l_1,2)^-1 and let ρ(ε)ρ( ) denote the spectral radius of the corresponding characteristic polynomial. At the threshold scale ε=O(l1,2−3) =O(l_1,2^-3), the perturbation expansion gives ρ(ε)=ρ∞(1+ε)+O(l1,2ε2).ρ( )= _∞(1+ )+O\! (l_1,2 ^2 ). (12) This implies that finite input length erodes the spectral gap created by coprime decoding lengths. To first order, stability, i.e., ρ(ε)<1ρ( )<1, requires ρ∞(1+ε)<1,or equivalently(l0+l1,2)(1−ρ∞)≳1. _∞(1+ )<1, equivalently (l_0+l_1,2)(1- _∞) 1. Define the minimum stable input length by l0,min:=minl0∈ℤ≥0:ρ((l0+l1,2)−1)<1.l_0, := \l_0 _≥ 0:ρ ((l_0+l_1,2)^-1 )<1 \. Here stability refers to Schur stability of the finite-l0l_0 linearized recurrence, i.e., all roots lie strictly inside the unit disk. We next characterizes how this threshold scales with the decoding lengths. Proposition 4 (Finite-input stability threshold). Fix p∈(0,1)p∈(0,1). In the two-class common-input setting above, consider a coprime sequence with l1,2→∞l_1,2→∞ and l1,1/l1,2→θ∈[0,1)l_1,1/l_1,2→θ∈[0,1). Then the minimum stable input length satisfies l0,min∼((1−p)+pθ)32π2p(1−p)l1,23.l_0, ((1-p)+pθ)^32π^2p(1-p)\,l_1,2^3. (13) Proposition 4 shows that coprimality is an asymptotic stabilizing force, but it may require large inputs to be visible at finite scale. The reason is that the limiting spectral gap shrinks cubically with the longer decoding length. Thus, when decoding lengths are long, the input length needed for the coprime system to become stable scales as l1,23l_1,2^3. Interestingly, the prefactor also has operational meaning: stability is harder to achieve when the two decoding lengths are close, θ≃1θ 1, or when the workload mix is highly imbalanced, p≃0p 0 or p≃1p 1. In both cases, the desynchronizing effect of heterogeneity is weak. The proof in Appendix B combines four ingredients: the finite-input spectral-drift expansion for the two dominant root branches, whose simplicity is verified there for every fixed p∈(0,1)p∈(0,1), the cubic limiting spectral-gap estimate, the no-stable-islands lemma that rules out earlier stable windows, and the resulting stability-threshold corollary. For any fixed coprime pair, the exact finite threshold can be computed by finding the roots of the finite-l0l_0 characteristic polynomial. Figure 3 compares these numerical thresholds with the asymptotic prediction in (13). The figure is consistent with the outward spectral drift and the cubic scaling of the finite-input stability threshold. Figure 3: Finite-l0l_0 spectral radius for coprime pairs (p=1/2p=1/2). (a) Spectral radius ρ(l0)ρ(l_0) of the characteristic polynomial F(z)F(z) as l0l_0 increases, for four coprime pairs (l1(1),l1(2))(l_1^(1),l_1^(2)). Each curve converges to the limiting value ρ∞ _∞ (dashed line at ρ=1ρ=1). The pair (2,7)(2,7) requires l0≥15l_0≥ 15 to enter the stable regime. (b) Minimum input length l0minl_0 for all eigenvalues to lie inside the unit circle (l1(1)=2l_1^(1)=2). The log-log fit is consistent with the Θ((l1(2))3) ((l_1^(2))^3) scaling proved in Corollary 26. 5 Eviction-Aware Control Policies Theorems 2 and 3 uncover a single structural source of instability of the eviction-free equilibrium: positive feedback between memory release and admission under progressive memory growth. How this feedback manifests depends on workload composition. In homogeneous systems, it emerges as admission pulses that amplify through the decoding pipeline; in heterogeneous systems, under the large input scaling, arithmetic synchronization determines whether those pulses reinforce or dissipate. Based on these insights, in this section, we propose eviction-aware control policies. The policies below are intentionally stylized. Each targets a specific manifestation of the underlying feedback mechanism and illustrates how the structural insights developed earlier translate into concrete design principles. They are not intended as complete production schedulers, but rather as minimal interventions that mitigate eviction at its structural source. 5.1 Rate-Limited Admission The instability results above identify a common mechanism across homogeneous workloads, non-coprime heterogeneous workloads, and coprime workloads below the finite-input stability threshold: transient over-admission. When aggregate admission ana^n exceeds the eviction-free sustainable rate, the excess mass enters the decoding pipeline, and its memory footprint grows over subsequent stages. The resulting amplification can push the system into eviction and even initiate a support-loss cascade. A natural remedy is therefore to cap aggregate admission at the eviction-free equilibrium rate. Under proportional class admission, the policy admits an=min(Qn,Sn∑kpk(l0,k+1),x∗),akn=pkan,a^n= \! (Q^n,\, S^n _kp_k(l_0,k+1),\,x^* ), a_k^n=p_ka^n, where x∗x^* is the eviction-free equilibrium admission rate derived in Sections 3 and 4, Qn:=∑kQknQ^n:= _kQ_k^n is the aggregate waiting demand, Sn:=M−∑k,jwk,jx^k,jnS^n:=M- _k,jw_k,j x^n_k,j is the GPU memory available after execution and eviction at iteration n. The denominator ∑kpk(l0,k+1) _kp_k(l_0,k+1) is the stage-0 memory consumed by one aggregate unit of proportional admissions. Thus the middle term is the largest aggregate admission that can be placed without violating the memory constraint. This cap removes the admission pulses that drive the instability while preserving the eviction-free throughput whenever sufficient demand and memory are available. The no-over-admission property is immediate from the definition. During the first few iterations, evictions may still occur because requests admitted before the cap was imposed can continue to grow in memory. After at most l1l_1 iterations in the single-class system, all such pre-policy requests have either completed or been evicted; from that point on, every active cohort was admitted under the cap and therefore cannot exceed the eviction-free profile. The analogous transient bound is maxkl1,k _kl_1,k in the multi-class setting. Our analysis is conducted in the saturated-input regime, where a backlog of requests is always available for admission. In practice, systems rarely operate persistently in this regime. Instead, demand is typically below capacity, although fluctuations and temporary surges may occasionally push the system toward saturation. Nevertheless, the analysis identifies the critical admission boundary that mitigates eviction once the system approaches capacity. The proposed policy adapts naturally to non-saturated conditions. When demand is low (Qn<x∗Q^n<x^*), the threshold is non-binding and requests are admitted immediately, preserving low latency. In particular, the policy does not require waiting to accumulate a large batch of requests, which would unnecessarily increase latency. When demand surges and the system approaches saturation, the rate cap activates automatically and limits admissions to the sustainable rate x∗x^*, mitigating admission pulses and the eviction cascades they would otherwise trigger. 5.2 Request Mixing for Heterogeneous Systems When heterogeneous request classes are available, Theorem 3 suggests a complementary control mechanism that operates at the routing level. Rather than assigning requests to GPUs arbitrarily or grouping identical requests together, the system can route requests so that each GPU processes a diversified mixture of decoding lengths whose greatest common divisor equals one. The motivation follows directly from the instability mechanism identified earlier. In non-coprime systems, decoding completions synchronize at multiples of g=gcd(l1,1,…,l1,K)g= (l_1,1,…,l_1,K), producing periodic bursts of memory release that amplify admission fluctuations and trigger eviction. By contrast, when the decoding lengths assigned to a GPU are coprime, completion events occur at desynchronized phases, smoothing memory release over time. Serving systems such as vLLM and SGLang show that batching structure and cache locality are central to efficient LLM serving (Kwon et al., 2023; Zheng et al., 2024). In deployments that route similar request classes to the same device for these reasons, specialization can concentrate workloads with identical or commensurate decoding lengths, creating precisely the synchronization conditions that lead to eviction cycles. Our analysis does not imply that requests with drastically different decoding lengths must be mixed. Stability can often be improved through mild diversification: assign together request classes with comparable decoding lengths but avoid nontrivial common periods among their lengths. Such routing preserves most of the batching and memory-efficiency benefits of specialization while reducing the synchronization of completion events that drives eviction-induced instability. 5.3 Design Implications The structural results above suggest several practical guidelines for the design and monitoring of memory-constrained LLM serving systems. Arithmetic structure as a stability diagnostic. The stability of the system depends critically on the arithmetic structure of decoding lengths. When requests assigned to a GPU share a common divisor, completion events can synchronize and trigger eviction cycles. In contrast, mixtures of coprime decoding lengths naturally desynchronize completions and stabilize the eviction-free equilibrium under the model conditions. Monitoring the effective greatest common divisor of active workloads therefore provides a model-informed structural diagnostic for eviction risk. Engineering stability through mild diversification. Stability can often be improved by adding modest heterogeneity to decoding lengths. For example, if service-level agreements define discrete output-length tiers such as 128,256,512\128,256,512\, all of which share gcd=128 =128, small adjustments (e.g., 127,255,509\127,255,509\) restore coprimality and remove the exact GCD resonance in the input-dominated model. At finite input lengths, such adjustments mitigate arithmetic synchronization but do not by themselves guarantee stability; the finite-input threshold in Section 4.3 still matters. This provides a practical low-overhead design lever. Operational practices that route similar request classes to dedicated GPUs can improve batching efficiency and cache locality. At the same time, incorporating a modest level of diversification in the requests assigned to each GPU can enhance system stability by mitigating the synchronization of completion events that leads to eviction cycles. This suggests that efficient and stable operation can often be achieved by balancing specialization with mild heterogeneity in decoding lengths. Eviction as an early warning signal. The transition from zero eviction to persistent eviction is a structural transition (Theorem 2), rather than a gradual degradation. Once the sustainable admission rate is exceeded, the system can converge to an eviction-driven limit cycle with sustained throughput loss. Persistent eviction therefore can serve as an indicator that the system is operating beyond the eviction-free operating region predicted by the model. From a control perspective, this observation also highlights the importance of admission regulation. Monitoring eviction rates provides a practical signal for when admission should be moderated to remain within the eviction-free operating region. Policies such as the rate-limited admission rule described above can then act as safeguards, mitigating transient demand surges that would otherwise push the system into an eviction cycle. 6 Numerical Experiments The experiments examine whether the stability mechanisms identified in the deterministic saturated-input model persist in more realistic serving environments. We first use a model-based simulator, implemented directly from the memory and admission dynamics in Section 2, to test whether stochastic arrivals in the non-saturated-input regime exhibit the corresponding empirical queue-growth transition near the worst-cycle throughput. We then use Vidur, a high-fidelity LLM inference serving simulator, together with real-GPU experiments, to test whether practical serving-system dynamics are consistent with the synchronization mechanism. Across these settings, request mixing reduces synchronized completions, and rate-limited admission reduces eviction cascades. Vidur is a validated large-scale LLM-serving simulator whose reported latency and throughput errors are below 5% relative to real systems (Agrawal et al., 2024). Unless otherwise noted, the Vidur experiments use the Sarathi scheduler (Agrawal et al., 2023), Meta-Llama-3-8B, and a single NVIDIA A100 GPU. Sarathi greedily admits pending requests whenever memory is available. Our rate-limited variant adds a per-iteration admission cap based on the eviction-free admission rate. When the resident KV cache later exceeds capacity, Vidur records an eviction event: the affected request loses its current KV cache and must be recomputed from prefill. We apply the same LPF eviction priority as in the model and interpret these events as the serving-system counterparts of model evictions. For real-GPU hardware, we run SGLang (Zheng et al., 2024), which uses continuous batching and therefore aligns with the model’s per-iteration dynamics, on an NVIDIA A800 80 GB GPU with Qwen2.5-1.5B-Instruct. Appendix D provides additional model-based, Vidur, and real-GPU experiment details. 6.1 Model-based simulation under open arrivals In this section, we evaluate the discrete-time model under different load levels. We build a simulator that follows model dynamics in Section 2 and replaces the saturated-input assumption with a Poisson arrival process. We vary the arrival rate λ, interpreted as the average number of new requests arriving per period, and examine the resulting system dynamics. The saturated-input analysis suggests the following open-arrival numerical validation under baseline admission. Recall that T¯l1−1 T_l_1-1 denotes the throughput associated with the worst-case limit cycle, while x∗x^* denotes the throughput associated with the eviction-free equilibrium. Since T¯l1−1<x∗ T_l_1-1<x^*, there exists a nontrivial interval of arrival rates between these two values. Loads in this interval would appear sustainable if one only considered the eviction-free equilibrium, since they remain below x∗x^*. However, in the saturated-input model that equilibrium is unstable, and the dynamics are attracted to the asymptotically stable maximal-eviction cycle, which can sustain only T¯l1−1 T_l_1-1 requests per period. We therefore test whether the same throughput bottleneck appears as queue growth under stochastic arrivals. The open-arrival simulations are consistent with this mechanism. We treat a run as empirically stable when the waiting queue remains small and shows no sustained upward drift over the simulation horizon. When λ<T¯l1−1λ< T_l_1-1, evictions are transient and the waiting queue stays small. When λ>T¯l1−1λ> T_l_1-1, even if λ<x∗λ<x^*, the simulated system settles around the worst-cycle throughput T¯l1−1 T_l_1-1, while excess arrivals accumulate and the waiting queue grows. Figure˜4 shows this transition directly, where QnQ^n denotes the number of waiting requests at iteration n. For loads below T¯l1−1 T_l_1-1, the throughput is equal to λ and QnQ^n remains close to zero. For loads above T¯l1−1 T_l_1-1, including those in the interval (T¯l1−1,x∗)( T_l_1-1,x^*), throughput is equal to T¯l1−1 T_l_1-1. The system experiences persistent evictions and a growing QnQ^n. Thus, in this simulated open-arrival setting, baseline admission begins to accumulate backlog before the nominal eviction-free capacity is reached. Figure 4: Open-system behavior under Poisson arrivals in the model-based simulator. With M=2000M=2000, l0=10l_0=10, and l1=40l_1=40, the worst-cycle service rate is T¯l1−1=1.00 T_l_1-1=1.00, while the eviction-free fluid optimum is x∗=1.64x^*=1.64. (a) Throughput departs from the lossless line once λ crosses T¯l1−1 T_l_1-1, despite λ<x∗λ<x^*. (b) Evictions per iteration and mean queue length QnQ^n are negligible below T¯l1−1 T_l_1-1, then become positive above it. (c) A raw sample path at λ=1.40∈(T¯l1−1,x∗)λ=1.40∈( T_l_1-1,x^*) shows persistent evictions and growing QnQ^n. Detailed settings and additional GCD simulations appear in Appendix D. 6.2 Mixing In this subsection, we analyze the effect of request mixing. Although Theorem 3 is derived in the large-input limit and gives a sharp stabilization criterion for the two-class common-input setting when the combined decoding lengths are coprime, the underlying mechanism suggests a broader phenomenon. Routing need not eliminate common periodicity completely in order to improve performance. By pooling request classes with different decoding lengths, mixed routing reduces decoding-length homogeneity within each serving pool, which weakens the synchronization of completions. Any reduction in synchronization can weaken the completion pulses that drive large memory-release and memory-growth cycles, thereby reducing the likelihood of eviction cascades. We therefore expect request mixing to remain beneficial in broader serving settings, even when the combined decoding lengths are not coprime or the input length is not large enough. We first test this mechanism in Vidur. For these fixed-workload Vidur and real-GPU experiments, requests are generated according to the stated class proportions and submitted at a sufficiently high rate at the beginning of the run. The system therefore maintains a persistent waiting queue, and the scheduler admits from that queue whenever memory is available. This construction approximates the saturated-input regime analyzed in the theory; stochastic open-arrival behavior is studied separately in Section˜6.1 and Appendix D. Table 1 reports the Vidur results for two main configurations, each consisting of two request classes. In the first configuration, the decoding lengths are 20 and 21, so mixing makes the combined decoding lengths coprime. In the second configuration, the decoding lengths are 100 and 125. Mixing does not eliminate common periodicity in this case: the combined GCD remains 25. However, this common period is substantially smaller than the periodicity induced when each class is served in isolation. For each configuration, we compare segregated serving, where the two request classes are served separately on two devices, with mixed serving, where the same two-device budget serves the pooled workload. The workload size, input length, scheduler, and hardware budget are held fixed within each comparison; only the routing of request classes is changed. SegAvg denotes the average across the two segregated devices. We report the number of evictions, request-level mean latency, and throughput measured as completed requests per second. In the coprime configuration, mixing nearly eliminates evictions over the experiment horizon, a 94.2% reduction, and improves both latency and throughput. In the partial-GCD configuration, the reduction in evictions is smaller, but we still see mixing leads to fewer evictions, lower mean latency, and higher throughput. Appendix D contains the corresponding model-based simulation figures, Vidur memory figures, and additional mixing configuration results. Table 1: Request mixing with 20k requests and common input length l0=512l_0=512. Holding the workload, scheduler, and two-device budget fixed, both coprime (GCD=1=1) and non-coprime (GCD=25=25) mixed configurations have fewer evictions, lower latency, and higher throughput. Configuration GCD Evictions Latency (s) Throughput Value Improv. Value Improv. (req/s) Node 1 20 908 — 107.8 — 91.7 Node 2 21 931 — 114.1 — 87.0 SegAvg — 919 — 111.0 — 89.3 Mixed 1 53 –94.2% 95.1 –14.3% 105.8 Node 1 100 3296 — 367.9 — 27.3 Node 2 125 4121 — 473.4 — 21.2 SegAvg — 3708 — 420.6 — 24.2 Mixed 25 2449 –34.0% 390.4 –7.2% 25.6 Note. SegAvg is the average of the two segregated devices. Mixed uses the same two-device budget with the request classes pooled. Throughput is completed requests per second. The same pattern appears in experiments on real GPU hardware. Table˜2 reports the number of evictions, mean latency, and throughput in one such study. Node 1 serves an equal mix of two request classes with decoding lengths 55 and 1010 (GCD=5=5); Node 2 serves an equal mix of two request classes with decoding lengths 66 and 1212 (GCD=6=6); the mixed configuration pools all four request classes, with decoding lengths l1∈5,6,10,12l_1∈\5,6,10,12\ in equal proportions, giving GCD=1=1. The comparison again uses the same workload size, input length, scheduler, and two-GPU budget: segregated routing assigns one configuration to each GPU, while mixed routing serves the pooled workload on the same two GPUs. Relative to the average of the two segregated configurations (Nodes 1 and 2), mixing reduces evictions by 97.7%, lowers mean latency by 18.2%, and increases request throughput by 30.5%. The time-series diagnostics in Appendix D further demonstrate that the segregated configurations produce periodic eviction bursts, while mixing suppresses them throughout the run. Table 2: Request mixing on real GPU hardware with 6060k requests and common input length l0=300l_0=300. Mixed routing (GCD=1=1) nearly eliminates evictions over the experiment horizon and improves latency and throughput relative to the segregated average, with the workload, scheduler, and two-GPU budget held fixed. Configuration GCD Evictions Latency (s) Throughput Value Improv. Value Improv. (req/s) Node 1 5 422 — 5.44 — 2,731 Node 2 6 372 — 5.52 — 3,264 SegAvg — 397 — 5.48 — 2,998 Mixed 1 9 −-97.7% 4.48 −-18.2% 3,911 Note. SegAvg is the average of the two segregated GPUs. Mixed uses the same two-GPU budget with all request classes pooled. Throughput is completed requests per second. 6.3 Rate-limited admission Greedy admission fails because it reacts only to current memory feasibility and ignores the future KV cache growth generated by newly admitted requests. Rate-limited admission addresses this problem by using x∗x^*, the eviction-free equilibrium admission/completion rate, as a per-iteration admission cap. This cap is large enough to keep the system operating near the nominal eviction-free capacity, avoiding an overly conservative policy that leaves GPU capacity idle. At the same time, it prevents the persistent overshoot that would trigger eviction cascades. The Vidur experiment in Table˜3 uses decoding lengths l1∈100,125,200,250l_1∈\100,125,200,250\ and an arrival rate of 300 requests per second. Baseline admission accepts every request that fits in currently available memory, which leads to periodic memory overflow and eviction cascades as KV caches grow. Rate-limited admission instead imposes a per-iteration cap of five new requests. Because Vidur implements an integer per-cycle admission cap rather than the continuous admission rate in the fluid model, we select this cap by a grid search over 1,2,…,10\1,2,…,10\, guided by the equilibrium rate x∗x^*. This rate-limited admission eliminates evictions over the experiment horizon, lowers mean latency by 18.9%, and increases throughput by 28.3%. Table 3: Rate-limited admission. The workload has 20k requests, common input length l0=512l_0=512, decoding lengths l1∈100,125,200,250l_1∈\100,125,200,250\, and arrival rate 300 req/s. The integer admission cap is selected from 1,…,10\1,…,10\. Scheduler Evictions Latency (s) Throughput (req/s) Sarathi 2,232 234.2 42.7 Sarathi + rate-limited admission 0 189.9 54.8 Improvement −-100.0% +18.9% +28.3% The sample path in Figure˜5 makes the mechanism visible. Under Sarathi, memory repeatedly rises above the capacity line, and each overflow is resolved through forced evictions. Under rate-limited admission, memory remains in a narrow band near capacity without crossing it over the experiment horizon. Figure 5: Rate-limited admission stabilizes memory dynamics in the Vidur run. Greedy admission exceeds the M=100%M=100\% capacity line in 25.2% of scheduling cycles and incurs 2,232 evictions. Rate-limited admission keeps memory below capacity and eliminates eviction over this horizon. 7 Conclusion This paper develops a discrete dynamical model for memory-constrained LLM serving systems in which requests consume increasing memory during service. This progressive KV-cache accumulation, absent from classical fixed-resource queueing models, creates a feedback loop among admission, memory growth, and eviction that can destabilize highly utilized systems. Our analysis identifies two main mechanisms. First, in homogeneous systems, small imbalances in admission propagate through the decoding pipeline, are amplified by memory growth, and eventually trigger eviction cascades. Except for exceptional balanced orbits, the system is attracted to the maximal-eviction limit cycle, which can incur substantial throughput loss. Second, in heterogeneous systems, stability is governed by synchronization. In the formal two-class common-input setting, and through the extension argument for multiple classes and heterogeneous-input lengths, coprime decoding lengths desynchronize memory release and stabilize the eviction-free equilibrium under the input-dominated scaling, whereas non-coprime lengths allow synchronized completion peaks that generate persistent oscillatory modes. These results show that congestion in LLM serving is not only arrival-driven: it can be induced by the service process itself. The proposed policies, rate-limited admission and request mixing, demonstrate that the mechanisms identified by the theory are actionable. By regulating admission intensity or breaking synchronization across request types, simple interventions can mitigate eviction, improve throughput, and keep the system close to efficient operation. A natural direction for future research is to incorporate stochastic decoding lengths. The deterministic-length model studied here isolates the mechanisms of memory growth and synchronization, but real LLM outputs are variable and only partially predictable at admission. This uncertainty may affect stability in two opposing ways: random variation can desynchronize completions and damp eviction cycles, while long-tail outputs can create unexpected memory pressure and push the system toward overflow. Extending the analysis to random service horizons would clarify how output-length uncertainty shifts stability boundaries and how admission policies should balance utilization against residual length risk. References Agrawal et al. (2023) Amey Agrawal, Ashish Panwar, Jayashree Mohan, Nipun Kwatra, Bhargav S Gulavani, and Ramachandran Ramjee. SARATHI: Efficient llm inference by piggybacking decodes with chunked prefills. arXiv preprint arXiv:2308.16369, 2023. Agrawal et al. (2024) Amey Agrawal, Nitin Kedia, Jayashree Mohan, Ashish Panwar, Nipun Kwatra, Bhargav S. Gulavani, Ramachandran Ramjee, and Alexey Tumanov. Vidur: A large-scale simulation framework for llm inference. In Proceedings of Machine Learning and Systems, volume 6, 2024. Ao et al. (2025) Ruicheng Ao, Gan Luo, David Simchi-Levi, and Xinshang Wang. Optimizing llm inference: Fluid-guided online scheduling with memory constraints. arXiv preprint arXiv:2504.11320, 2025. Ayhan (2022) Hayriye Ayhan. Optimal admission control in queues with abandonments. Operations Research Letters, 50(6):712–718, 2022. Bari et al. (2025) Agrim Bari, Parikshit Hegde, and Gustavo de Veciana. Optimal scheduling algorithms for llm inference: Theory and practice. Proceedings of the ACM on Measurement and Analysis of Computing Systems, 9(3):1–43, 2025. Bassamboo and Randhawa (2010) Achal Bassamboo and Ramandeep S Randhawa. On the accuracy of fluid models for capacity sizing in queueing systems with impatient customers. Operations research, 58(5):1398–1413, 2010. Bramson et al. (2021) Maury Bramson, Bernardo D’Auria, and Neil Walton. Stability and instability of the maxweight policy. Mathematics of Operations Research, 46(4):1611–1638, 2021. Chan et al. (2014) Carri W Chan, Galit Yom-Tov, and Gabriel Escobar. When to use speedup: An examination of service systems with returns. Operations Research, 62(2):462–482, 2014. Chen et al. (2025) Zixi Chen, Yinyu Ye, and Zijie Zhou. Adaptively robust llm inference optimization under prediction uncertainty. arXiv preprint arXiv:2508.14544, 2025. Chen et al. (2026) Zixi Chen, Tianci Bu, Chendong Song, Xin Lu, Yinyu Ye, and Zijie Zhou. A universal load balancing principle and its application to large language model serving. arXiv preprint arXiv:2601.17855, 2026. Cohen et al. (2024) Asaf Cohen, Vijay Subramanian, and Yili Zhang. Learning-based optimal admission control in a single-server queuing system. Stochastic systems, 14(1):69–107, 2024. Dai (1995) Jim G Dai. On positive harris recurrence of multiclass queueing networks: a unified approach via fluid limit models. The Annals of Applied Probability, 5(1):49–77, 1995. Delasay et al. (2019) Mohammad Delasay, Armann Ingolfsson, Bora Kolfal, and Kenneth Schultz. Load effect on service times. European Journal of Operational Research, 279(3):673–686, 2019. Dong et al. (2015) Jing Dong, Pnina Feldman, and Galit B Yom-Tov. Service systems with slowdowns: Potential failures and proposed solutions. Operations Research, 63(2):305–324, 2015. Elaydi (2005) Saber N Elaydi. An Introduction to Difference Equations. Springer, 3rd edition, 2005. Gupta and Zhang (2022) Varun Gupta and Jiheng Zhang. Approximations and optimal control for state-dependent limited processor sharing queues. Stochastic Systems, 12(2):205–225, 2022. Jaillet et al. (2025) Patrick Jaillet, Jiashuo Jiang, Konstantina Mellou, Marco Molinaro, Chara Podimata, and Zijie Zhou. Online scheduling for llm inference with kv cache constraints. arXiv preprint arXiv:2502.07115, 2025. Kwon et al. (2023) Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E Gonzalez, Hao Zhang, and Ion Stoica. Efficient memory management for large language model serving with pagedattention. In Proceedings of the 29th Symposium on Operating Systems Principles, pages 611–626, 2023. Lewis et al. (2020) Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. Retrieval-augmented generation for knowledge-intensive NLP tasks. In Advances in Neural Information Processing Systems, volume 33, pages 9459–9474, 2020. Li et al. (2025) Yueying Li, Jim Dai, and Tianyi Peng. Throughput-optimal scheduling algorithms for llm inference and ai agents. arXiv preprint arXiv:2504.07347, 2025. Lin et al. (2026) Ruihan Lin, Zezhen Ding, Zean Han, and Jiheng Zhang. Large-scale llm inference with heterogeneous workloads: Prefill-decode contention and asymptotically optimal control. arXiv preprint arXiv:2602.02987, 2026. Massoulié and Roberts (2002) Laurent Massoulié and James Roberts. Bandwidth sharing: objectives and algorithms. IEEE/ACM Transactions on Networking, 10(3):320–328, 2002. Mitzenmacher and Shahout (2025) Michael Mitzenmacher and Rana Shahout. Queueing, predictions, and llms: Challenges and open problems. arXiv preprint arXiv:2503.07545, 2025. Naor (1969) P Naor. The regulation of queue size by levying tolls. Econometrica, 37(1):15–24, 1969. NVIDIA (2023) NVIDIA. Tensorrt-llm: A tensorrt toolbox for optimized large language model inference. https://github.com/NVIDIA/TensorRT-LLM, 2023. OpenAI (2024) OpenAI. Introducing structured outputs in the api. OpenAI Blog, 2024. Patel et al. (2023) Pratyush Patel, Esha Choukse, Chaojie Zhang, Aashaka Shah, Íñigo Goiri, Saeed Maleki, and Ricardo Bianchini. Splitwise: Efficient generative LLM inference using phase splitting. arXiv preprint arXiv:2311.18677, 2023. Peng (2024) Xiaoshan Peng. Admission control to queueing systems with arrival forecast information. Available at SSRN 4917786, 2024. Schick et al. (2023) Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. In Advances in Neural Information Processing Systems, volume 36, 2023. Stidham (1985) Shaler Stidham, Jr. Optimal control of admission to a queueing system. IEEE Transactions on Automatic Control, 30(8):705–713, 1985. Whitt (2006) Ward Whitt. Fluid models for multiserver queues with abandonments. Operations research, 54(1):37–54, 2006. Wu et al. (2023) Bingyang Wu, Yinmin Zhong, Zili Zhang, Shengyu Liu, Fangyue Liu, Yuanhang Sun, Gang Huang, Xuanzhe Liu, and Xin Jin. Fast distributed inference serving for large language models. arXiv preprint arXiv:2305.05920, 2023. Wu et al. (2022) Chenguang Wu, Achal Bassamboo, and Ohad Perry. When service times depend on customers’ delays: A relationship between two models of dependence. Operations Research, 70(6):3345–3354, 2022. Yao et al. (2023) Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. ReAct: Synergizing reasoning and acting in language models. In International Conference on Learning Representations, 2023. Yoon and Lewis (2004) Seunghwan Yoon and Mark E Lewis. Optimal pricing and admission control in a queueing system with periodically varying parameters. Queueing Systems, 47(3):177–199, 2004. Yu et al. (2022) Gyeong-In Yu, Joo Seong Jeong, Geon-Woo Kim, Soojeong Kim, and Byung-Gon Chun. Orca: A distributed serving system for transformer-based generative models. In OSDI, 2022. Zhang et al. (2024) Wenxin Zhang, Santiago R Balseiro, Robert Kleinberg, Vahab Mirrokni, Balasubramanian Sivan, and Bartek Wydrowski. Distributed load balancing with workload-dependent service rates. arXiv preprint arXiv:2411.17103, 2024. Zheng et al. (2024) Lianmin Zheng, Liangsheng Yin, Zhiqiang Xie, Chuyue Sun, Jeff Huang, Cody Hao Yu, Shiyi Cao, Christos Kozyrakis, Ion Stoica, Joseph E Gonzalez, Clark Barrett, and Ying Sheng. SGLang: Efficient execution of structured language model programs. In Advances in Neural Information Processing Systems, 2024. Zhong et al. (2024) Yinmin Zhong, Shengyu Liu, Junda Chen, Jianbo Hu, Yibo Zhu, Xuanzhe Liu, Xin Jin, and Hao Zhang. Distserve: Disaggregating prefill and decoding for goodput-optimized large language model serving. arXiv preprint arXiv:2401.09670, 2024. Zwart and Boxma (2000) AP Zwart and Onno J. Boxma. Sojourn time asymptotics in the m/g/1 processor sharing queue. Queueing systems, 35(1):141–166, 2000. Appendix A Proof of Theorem 2 We prove Theorem 2: under baseline admission at the memory boundary, the eviction-free fixed point and all intermediate eviction-level cycles are unstable, while the level-(l1−1)(l_1-1) maximal-eviction cycle is asymptotically stable on the memory boundary outside the exact nonmaximal capture set. Its basin contains every memory-boundary initial state except those captured exactly by a nonmaximal balanced orbit. Within each fixed set of occupied stages, this exceptional set has Lebesgue measure zero. Figure 6: Instability trajectory for l0=2l_0=2, l1=3l_1=3, M=24M=24, starting from a small perturbation (δ0=0.5 _0=0.5) above the equilibrium x∗=2x^*=2. (a) The admission count xn(0)x_n^(0) oscillates with geometrically growing amplitude (spectral radius |z|=5/3≈1.29|z|= 5/3≈ 1.29). After 7 iterations, the required admission turns negative—memory is exhausted by surviving requests alone—triggering eviction. (b) The spread Gn=maxjxn(j)−minjxn(j)G_n= _j\x_n^(j)\- _j\x_n^(j)\ is monotonically non-decreasing. The spread’s inevitable growth drives the system to eviction regardless of the perturbation direction. A.1 Stability Analysis We split the proof into a pre-eviction stage, where the state is described by physical stages, and a post-eviction stage, where the correct state description is a block-end sampled chain of relative positions. Definition (Eviction-free spread). In the eviction-free regime, define Gn:=maxjxjn−minjxjn.G^n:= _jx^n_j- _jx^n_j. Write x¯n:=maxjxjn,x¯n:=minjxjn. x^n:= _jx^n_j, x^n:= _jx^n_j. Lemma A.1 (Monotonicity before eviction). Under the saturated-input continuous model of Theorem 2, while a memory-boundary trajectory remains eviction-free, Gn+1≥GnG^n+1≥ G^n. The proof is deferred to Appendix C. Lemma A.2 (Finite-time eviction-free breakdown and first support loss). Assume l1≥2l_1≥ 2. Under the saturated-input continuous model of Theorem 2, for a non-fixed memory-boundary initial state with G0>0G^0>0, the trajectory cannot remain eviction-free forever. The first memory overflow triggers an LPF eviction; in the relative-position representation below, this creates the first eviction-induced support loss and moves the trajectory to the next lower live-support level. In particular, the eviction-free fixed point is unstable. The proof is deferred to Appendix C. After the first eviction-induced support loss, physical-stage indices lose their tracking power: eviction reshuffles which stages carry mass at each iteration. The right coordinate system tracks relative positions in the circular pipeline, samples the state only at block-ends (the iterations where live positions complete), and normalizes masses by predecessor gaps (the number of stages each live position absorbs). Relative positions. Fix labels P0,…,Pl1−1P_0,…,P_l_1-1 on the circular pipeline. At time n, position PrP_r occupies stage r+n(modl1)r+n l_1. Let zrnz^n_r denote the mass carried by PrP_r at n, so xjn=z(j−n)modl1n.x^n_j=z^n_(j-n) l_1. When a cohort completes and the released memory funds a new admission at stage 0, the new stage-0 mass inherits the completing cohort’s label. Thus, the labels track relative cohorts rather than physical stage indices. Lemma A.3 (Irreversibility of lost positions). Under the saturated-input continuous model of Theorem 2, if zrn0=0z^n_0_r=0 for some position PrP_r, then zrn=0z^n_r=0 for every n≥n0n≥ n_0. The proof is deferred to Appendix C. Define the live set as Ln:=r:zrn>0.L_n:=\r:z^n_r>0\. (14) Once a relative position becomes empty, it never revives: when that dead position later cycles back to stage 0, it carries no mass and therefore frees no completion memory, while the surviving positions continue to grow their footprints. No new mass enters the dead position. Hence Ln+1⊆LnL_n+1 L_n, and the live set can only shrink. Eviction blocks and block-ends. Consider a trajectory with m=|Ln|≥2m=|L_n|≥ 2 live positions. Within each period of l1l_1 iterations, the dynamics decompose into two phases. An eviction block is a maximal contiguous run of iterations during which eviction removes excess requests but no completions occur (i.e., only dead positions pass stage l1−1l_1-1). The block-end is the first iteration after the eviction block in which a live position completes and new requests are admitted. At block-end, the live/dead pattern returns to the same configuration it had at the previous block-end, making block-ends the natural sampling points for the dynamics (Figure 7a). Example 6 (Block decomposition). Consider the adjacent level-2 orbit for l0=2l_0=2, l1=4l_1=4, M=63M=63: (17,3,0,0)→(0,12,3,0)→(0,0,9,3)→(3,0,0,9)→(17,3,0,0).(17,3,0,0)→(0,12,3,0)→(0,0,9,3)→(3,0,0,9)→(17,3,0,0). The transitions n=0→1→2n=0→ 1→ 2 form the eviction block: at each step, execute-and-shift produces a memory overshoot corrected by evicting from the most recently admitted stage (55 requests at n=0→1n=0→1, then 33 at n=1→2n=1→2). No completions occur because only dead positions pass stage 33. The block-ends are n=2n=2 and n=3n=3, where live positions complete and new requests enter. At n=2n=2 (live stages 2,3\2,3\): predecessor gaps g=(3,1)g=(3,1), masses (9,3)(9,3), normalized masses u=(9/3, 3/1)=(3,3)u=(9/3,\,3/1)=(3,3), spread Gsc=0G^sc=0. At n=3n=3 (live stages 0,3\0,3\): gaps swap to g=(1,3)g=(1,3), masses (3,9)(3,9), normalized u=(3/1, 9/3)=(3,3)u=(3/1,\,9/3)=(3,3), spread Gsc=0G^sc=0. The orbit is balanced. Figure 7: Block decomposition for the level-2 adjacent orbit (l0=2l_0=2, l1=4l_1=4, M=63M=63). (a) The orbit consists of an eviction block (n=0→2n=0→ 2), during which eviction removes excess requests but no completions occur, followed by a renewal phase (n=2→0n=2→ 0) in which completions free memory and new requests are admitted. The block-end phases (green borders) are the states immediately after the eviction block settles. (b) At each block-end, the predecessor gap νr _r counts the stages between consecutive live positions. The normalized mass ur=yr/νru_r=y_r/ _r adjusts for these gaps; when all normalized masses agree (Gsc=0G^sc=0), the orbit is balanced. Predecessor gaps. Fix an interval over which the live-position set is unchanged, with m≥2m≥ 2 live positions listed in circular order as r0,…,rm−1r_0,…,r_m-1. The predecessor gap of the h-th live position is gh:=(rh−rh−1)modl1,h=0,…,m−1,g_h:=(r_h-r_h-1) l_1, h=0,…,m-1, with indices modulo m. Thus ghg_h is the number of service stages crossed from the previous live position to the current one, with wrap-around modulo l1l_1. In particular, gh≥1g_h≥ 1 and ∑hgh=l1 _hg_h=l_1. Write Sh:=∑t=0hgtS_h:= _t=0^hg_t for the cumulative gap. At a block-end, the h-th live position occupies physical stage Sh−1S_h-1, so the live positions sit at stages g0−1,g0+g1−1,…,l1−1.g_0-1, g_0+g_1-1, …, l_1-1. The oldest live position is ym−1y_m-1; it sits at the final stage l1−1l_1-1 and is about to complete. A block-end sampled state is described by the live-mass vector Y=(y0,…,ym−1)Y=(y_0,…,y_m-1). Here yhy_h is the number of requests located at the h-th live position in the circular ordering, equivalently, the mass at physical stage Sh−1S_h-1. At stage Sh−1S_h-1, each request occupies l0+Shl_0+S_h tokens. The memory boundary in these coordinates is therefore M=∑h=0m−1(l0+Sh)yh.M= _h=0^m-1(l_0+S_h)y_h. (15) Proposition A.4 (Exact block-end map). Starting from a block-end sampled state Y=(y0,…,ym−1)Y=(y_0,…,y_m-1), the next state of the embedded block-end chain, conditional on the same support pattern, is Y′=(y0′,…,ym−1′)Y =(y _0,…,y _m-1) with yh+1′=yh,h=0,…,m−2,y _h+1=y_h, h=0,…,m-2, and y0′=(l0+l1)ym−1−gm−1∑h=0m−2yhl0+gm−1.y _0= (l_0+l_1)y_m-1-g_m-1 _h=0^m-2y_hl_0+g_m-1. (16) Proof. The next sampling epoch occurs after exactly gm−1g_m-1 physical iterations. At the current block-end, the oldest live position Pm−1P_m-1 sits at stage l1−1l_1-1. After one execute step it completes, releasing (l0+l1)ym−1(l_0+l_1)y_m-1 tokens. Meanwhile, every other live position advances one stage, increasing total memory by one token per request, while dead positions passing through stage l1−1l_1-1 release no memory. The system then admits a new batch at stage 0 and traverses gm−1−1g_m-1-1 pure-evict iterations, until the next live position reaches the final stage. We record the fixed-support induction used in this block. After the initial completion/admission step, let ata_t be the mass of the newly admitted batch after it has aged to stage t, for t=0,…,gm−1−1t=0,…,g_m-1-1. The other live masses are y0,…,ym−2y_0,…,y_m-2 and occupy stages Sh+tS_h+t. For t<gm−1−1t<g_m-1-1, no live position reaches stage l1−1l_1-1: the next live position is gm−1g_m-1 stages behind the completed one, so only dead positions pass the final stage during these intermediate iterations. Hence the only memory change before eviction is the one-token footprint growth of the current live masses. The newly admitted batch is always the least-progressed occupied stage, since its stage is t+1t+1 while the old live masses are at stages Sh+t+1>t+1S_h+t+1>t+1. If LPF ever reached an old live stage, it would first have exhausted the newly admitted batch, so the new relative position would be absent at the next block-end. This contradicts the fixed-support branch. Hence, conditional on the support pattern remaining unchanged, LPF trims a fractional amount from the new batch, stops before exhausting it, and does not touch any old live mass. After each such trim the state returns to the memory boundary, so there is no admission during the pure-evict block. This proves by induction that the old non-final live masses are copied unchanged and only the new coordinate changes. The old non-final live masses shift one slot in circular order: yh+1′=yh,h=0,…,m−2.y _h+1=y_h, h=0,…,m-2. In the new sampled state, every live stage has advanced by gm−1g_m-1 positions. The live stages are therefore gm−1−1,gm−1+g0−1,…,l1−1,g_m-1-1, g_m-1+g_0-1, …, l_1-1, with memory weights l0+gm−1l_0+g_m-1, l0+gm−1+g0l_0+g_m-1+g_0, …, l0+l1l_0+l_1. The new boundary equation is M=(l0+gm−1)y0′+∑h=0m−2(l0+gm−1+Sh)yh.M=(l_0+g_m-1)y _0+ _h=0^m-2(l_0+g_m-1+S_h)y_h. Subtracting the old boundary (15) eliminates the constant terms and yields (l0+gm−1)y0′=(l0+l1)ym−1−gm−1∑h=0m−2yh,(l_0+g_m-1)y _0=(l_0+l_1)y_m-1-g_m-1 _h=0^m-2y_h, which is (16). □ Normalized masses. Define the normalized mass of position i by ui:=yi/gi.u_i:=y_i/g_i. (17) This normalization accounts for the length of the predecessor gap: a live position preceded by more dead stages absorbs more memory growth during the eviction block, so uiu_i measures mass per unit gap (Figure 7b). Corollary A.5 (Normalized block-end map). In normalized coordinates, the embedded update is uh+1′=uh,h=0,…,m−2,u _h+1=u_h, h=0,…,m-2, and u0′=um−1+∑h=0m−2gh(um−1−uh)l0+gm−1.u _0=u_m-1+ _h=0^m-2g_h(u_m-1-u_h)l_0+g_m-1. (18) Proof. After rotation, the gap vector becomes (gm−1,g0,g1,…,gm−2)(g_m-1,g_0,g_1,…,g_m-2), so gh+1′=ghg _h+1=g_h for h=0,…,m−2h=0,…,m-2 and g0′=gm−1g _0=g_m-1. The shift relation yh+1′=yhy _h+1=y_h gives uh+1′=yh/gh+1′=yh/gh=uhu _h+1=y_h/g _h+1=y_h/g_h=u_h. For the new admission, dividing (16) by g0′=gm−1g _0=g_m-1 and substituting yh=ghuhy_h=g_hu_h yields (18). □ Next, define the block-end spread as Gsc:=maxiui−miniui.G^sc:= _iu_i- _iu_i. (19) Lemma A.6 (Spread monotonicity on a fixed support pattern). Let Gsc(Y):=maxhuh−minhuhG^sc(Y):= _hu_h- _hu_h be the block-end sampled spread. Then Gsc(Y′)≥Gsc(Y).G^sc(Y )≥ G^sc(Y). Moreover, if Gsc(Y)>0G^sc(Y)>0 and the oldest normalized coordinate um−1u_m-1 is an extremum, then the inequality is strict. The proof is deferred to Appendix C. Corollary A.7 (Strict growth within bounded time). Fix a support pattern with m≥2m≥ 2. If Gsc(Y)>0G^sc(Y)>0 and the support pattern does not change, then GscG^sc strictly increases at least once every m sampled steps. Proof. Take a coordinate attaining either the current maximum or the current minimum. Under the sampled dynamics, old coordinates shift one slot older at each sampled step. Hence, unless strict growth has already occurred, that extremal coordinate reaches the oldest slot m−1m-1 within at most m−1m-1 sampled steps. The following sampled step is then covered by Lemma A.6 and forces strict growth. □ Lemma A.8 (Finite-time support loss on a fixed pattern). Fix a support pattern with m≥2m≥ 2 and suppose Gsc(Y0)>0G^sc(Y_0)>0 at the initial sampled state. Then the fixed-support regime cannot persist: in the physical LPF dynamics, some live coordinate reaches zero, and the support strictly shrinks, within finitely many sampled steps. The proof is deferred to Appendix C. Theorem A.1 (Position-tracking cascade). Under the saturated-input continuous model of Theorem 2, every memory-boundary trajectory either stays exactly on, or is captured exactly by, a periodic orbit of some eviction level, or eventually reaches the level-(l1−1)(l_1-1) maximal-eviction cycle. In particular, every trajectory that is not captured by an intermediate periodic orbit cascades to maximal eviction. Lemma A.9 below shows that these exact nonmaximal capture sets are of Lebesgue measure zero within each fixed set of occupied stages on the memory boundary. Proof. By Lemma A.2, every non-equilibrium eviction-free trajectory leaves the eviction-free regime in finite time; equivalently, memory overflow forces an LPF eviction and moves the trajectory to the next lower live-support level. Now fix an interval on which the live-position set is constant and has size m≥2m≥ 2. By Lemma A.3, dead positions do not revive. Therefore the trajectory on this interval is governed by the exact block-end sampled chain above. If Gsc=0G^sc=0 at one sampled phase, then all normalized coordinates are equal. Equation (18) preserves this equality, so the entire sampled chain remains balanced. More explicitly, if uh=cu_h=c for all h, then yh=cghy_h=cg_h; after each block-end update the gap vector and the mass vector rotate together, and after one full circuit of the m live positions the block-end sampled state returns to itself. Proposition A.4 and the fixed-support induction in its proof determine the intervening physical iterations uniquely from the block-end state. Hence the balanced sampled chain lifts to the corresponding eviction-level-(l1−m)(l_1-m) periodic orbit of the physical iteration map. Suppose instead that Gsc>0G^sc>0 on the sampled chain. Since uh∈[0,M/(l0+1)]u_h∈[0,\,M/(l_0+1)], the sampled coordinates remain bounded. Lemma A.8 shows that the fixed-support regime cannot persist: recurrent evictions drive some live coordinate to zero in finite time, moving the trajectory to the next lower live-support level. Each such support loss strictly decreases the number of live positions, and Lemma A.3 rules out revival. After finitely many reductions, either the trajectory lands exactly on a balanced intermediate periodic orbit, or only one live position remains. When m=1m=1, the memory boundary forces the deterministic cycle (Mw0,0,…,0)→(0,Mw1,0,…,0)→⋯→(0,…,0,Mwl1−1), ( Mw_0,0,…,0 )→ (0, Mw_1,0,…,0 )→·s→ (0,…,0, Mw_l_1-1 ), which is the maximal-eviction cycle. □ Lemma A.9 (Nonmaximal exact-capture sets have Lebesgue measure zero). For each nonempty I⊆0,…,l1−1I \0,…,l_1-1\, let ℬI:=x∈ℝ+l1:xj>0for j∈I,xj=0for j∉I,∑j=0l1−1wjxj=MB_I:= \x _+^l_1:x_j>0\ for j∈ I,\ x_j=0\ for j∉ I, _j=0^l_1-1w_jx_j=M \ be the relative interior of a memory-boundary face, equipped with (|I|−1)(|I|-1)-dimensional Lebesgue measure on its affine hull. The set of initial states in ℬIB_I whose trajectory is captured in finite time by a nonmaximal balanced orbit has relative Lebesgue measure zero. For |I|=1|I|=1, this set is empty. Consequently, within each fixed set of occupied stages on the memory boundary, the nonmaximal exact-capture set has Lebesgue measure zero. Viewed as a subset of ℝl1R^l_1, it also has Lebesgue measure zero. The proof is deferred to Appendix C. Lemma A.10 (Local absorption by the maximal-eviction cycle). Let Cr:=Mwrer,r=0,…,l1−1,C_r:= Mw_re_r, r=0,…,l_1-1, be the states of the level-(l1−1)(l_1-1) maximal-eviction cycle, where ere_r is the rrth coordinate vector and wr=l0+1+rw_r=l_0+1+r, and write max:=C0,…,Cl1−1C_ :=\C_0,…,C_l_1-1\. Let ℰE be the exact-capture set from Theorem 2: the set of memory-boundary initial states whose trajectories are captured in finite time by the eviction-free fixed point or by an intermediate balanced limit cycle. For every ϵ>0ε>0, there exists δ>0δ>0 such that every memory-boundary trajectory with dist(X0,max)<δ,X0∉ℰ,dist(X^0,C_ )<δ, X^0 , satisfies dist(Xn,max)<ϵfor all n≥0,dist(X^n,C_ )<ε all n≥ 0, and reaches maxC_ in finite time. Consequently, maxC_ is asymptotically stable outside ℰE in the sense of Definition 3. The proof is deferred to Appendix C. The exceptional set is not empty. For example, with l0=2l_0=2, l1=3l_1=3, M=24M=24, and w=(3,4,5)w=(3,4,5), the state X0=(4813,2413,7265)X^0= ( 4813, 2413, 7265 ) satisfies the memory boundary and maps in one iteration to (0,4813,2413), (0, 4813, 2413 ), which lies on the level-1 balanced cycle (0,4813,2413)→(2413,0,4813)→(7213,2413,0)→(0,4813,2413). (0, 4813, 2413 )→ ( 2413,0, 4813 )→ ( 7213, 2413,0 )→ (0, 4813, 2413 ). Lemma A.2 already proves part (1) of Theorem 2. Theorem A.1 gives part (2): if C is an eviction-level-i orbit with 1≤i≤l1−21≤ i≤ l_1-2, then its block-end sampled representative has Gsc=0G^sc=0, but any sufficiently small perturbation that makes the normalized sampled masses unequal produces Gsc>0G^sc>0, and Theorem A.1 then forces another support loss. So intermediate cycles are not stable. Figure 8 illustrates the full cascade for Example 3 (l0=2l_0=2, l1=3l_1=3, M=24M=24). The three phases are visible: (i) growing oscillation in the eviction-free regime (n=0n=0–66), (i) intermittent evictions of increasing severity as the system cascades through levels (n=7n=7–1616), and (i) convergence to the stable level-22 cycle (n≥17n≥ 17) with throughput c2=8/5c_2=8/5 per iteration. Figure 8: Full cascade trajectory for Example 3 (l0=2l_0=2, l1=3l_1=3, M=24M=24). Starting from δ0=0.5 _0=0.5 above equilibrium, the system passes through three phases: (i) growing oscillation in the eviction-free regime (n=0n=0–66), (i) intermittent evictions of increasing severity (#1–#4) as the system cascades through levels (n=7n=7–1616), and (i) convergence to the stable level-22 cycle (n≥17n≥ 17) with throughput c2=1.6c_2=1.6 per iteration. Higher decoding lengths: l1=4l_1=4. With l0=2l_0=2, l1=4l_1=4, and M=48M=48 (weights w=[3,4,5,6]w=[3,4,5,6], x∗=8/3x^*=8/3), the cascade exhibits four phases (Figure 9): (i) growing oscillation (n=0n=0–88), (i) level-1 evictions at n=9,13n=9,13, (i) level-2 and level-3 evictions at n=17,20,21n=17,20,21, and (iv) convergence to the stable level-33 cycle (n≥22n≥ 22) with throughput c3=2c_3=2, a 25%25\% loss relative to x∗x^*. The additional decoding stage creates a richer transient: the system traverses two intermediate eviction levels before reaching the worst case. Figure 9: Full cascade trajectory for l0=2l_0=2, l1=4l_1=4, M=48M=48 (weights w=[3,4,5,6]w=[3,4,5,6], x∗=8/3x^*=8/3). Starting from δ0=0.5 _0=0.5 above equilibrium, the system passes through four phases: (i) growing oscillation in the eviction-free regime (n=0n=0–88), (i) level-1 evictions at n=9,13n=9,13 (n=9n=9–1616), (i) level-2 and level-3 evictions at n=17,20,21n=17,20,21 (n=17n=17–2121), and (iv) convergence to the stable level-33 cycle (n≥22n≥ 22) with throughput c3=2c_3=2 per iteration—a 25% loss from x∗=8/3x^*=8/3. Cycle multiplicity at intermediate levels. A qualitatively new phenomenon for l1≥4l_1≥ 4 is that intermediate eviction levels admit multiple distinct periodic orbits with different throughputs; see Figure 1 in Section 3 for an illustration. At level-2 (two stages empty per cycle), two orbit families coexist: an opposite (maximally separated) orbit (period 2, throughput =12/5=12/5, 90% of x∗x^*) and an adjacent orbit (period 4, throughput =16/7=16/7, 86% of x∗x^*). Both are unstable, and the baseline cascade bypasses them to the worst-case level-3 cycle (c3=2c_3=2, 75% of x∗x^*). Corollary A.11 (Stability of the maximal-eviction cycle). The level-(l1−1)(l_1-1) maximal-eviction cycle is asymptotically stable outside ℰE. Its basin contains every memory-boundary state outside ℰE, and ℰE has relative Lebesgue measure zero within each fixed set of occupied stages on the memory boundary. The eviction-free fixed point and all intermediate balanced limit cycles are unstable in the sense of Definition 3. Proof. Theorem A.1 shows that every memory-boundary trajectory outside ℰE reaches the single-live-position regime in finite time. Once m=1m=1, the memory boundary fixes the unique live mass at each phase, so the trajectory follows the maximal-eviction cycle. This proves the stated basin. Lemma A.9 proves the relative-measure-zero claim for ℰE, and Lemma A.10 supplies the local stability and convergence quantifiers required by Definition 3. Finally, Lemma A.2 proves instability of the eviction-free fixed point, and Theorem A.1 proves instability of intermediate balanced cycles by showing that arbitrarily small off-balanced perturbations force another support loss. □ A.2 Summary The proof establishes: 1. The eviction-free spread GnG^n is non-decreasing (Lemma A.1). 2. For non-equilibrium initial conditions (G0>0G^0>0), the maximum x¯n x_n grows by at least G0/(l0+1)G^0/(l_0+1) each time it reaches stage l1−1l_1-1, while GnG^n remains bounded by M/(l0+1)M/(l_0+1). This contradiction forces the eviction-free regime to break down in finite time; the resulting LPF eviction creates the first support loss and moves the trajectory to the next lower live-support level (Lemma A.2). 3. After the first eviction, relative-position tracking becomes the right state description. Lemma A.3 shows that once a position reaches zero it never revives, and Proposition A.4 gives the exact block-end sampled map on any fixed support pattern. 4. On the block-end sampled chain, the normalized spread GscG^sc is non-decreasing (Lemma A.6) and strictly increases within bounded time whenever it is positive (Corollary A.7). Thus the only obstruction to further cascade is landing exactly on a balanced intermediate periodic orbit; otherwise recurrent evictions drive another live position to zero in finite time and move the trajectory to the next lower live-support level (Theorem A.1). 5. The level-(l1−1)(l_1-1) cycle is asymptotically stable on the memory boundary outside the exact nonmaximal capture set. Its basin contains every memory-boundary initial state except those captured exactly by a nonmaximal balanced orbit; within each fixed set of occupied stages, the excluded set has Lebesgue measure zero. All other periodic orbits are unstable. This completes the proof of Theorem 2. ∎ A.3 Representative Equilibrium Families The cascade argument above applies to any fixed support pattern: unless the normalized live masses are balanced, the support shrinks again in finite time. The following propositions are complementary. They characterize the throughput envelope of the cycled equilibria that remain on a fixed relative support pattern. For such equilibria, the predecessor-gap vector gives a general parametrization: contiguous-block gap vectors attain the lower-throughput endpoint, while as-evenly-spaced gap vectors attain the upper-throughput endpoint; the exactly evenly-spaced cycles are the divisor case used in the discussion in Section 3. Proposition 5 (Two-stage cycles (eviction level l1−2l_1-2)). Assume l1≥2l_1≥ 2 and M≥wl1−1=l0+l1M≥ w_l_1-1=l_0+l_1. At eviction level l1−2l_1-2 (exactly two occupied stages at each iteration), the dynamics admit an explicit adjacent limit cycle of period l1l_1 whose throughput is T¯adj=Mwl1−12−w0wl1−2. T_adj= Mw_l_1-1^2-w_0w_l_1-2. (20) If, in addition, l1l_1 is even with l1=2dl_1=2d, the dynamics admit an explicit opposite (maximally separated) limit cycle of period d with throughput T¯opp=Md(wd−1+wl1−1). T_opp= Md\,(w_d-1+w_l_1-1). (21) Proposition 6 (Contiguous-block cycles (most imbalanced)). Fix an eviction level i∈0,1,…,l1−1i∈\0,1,…,l_1-1\ and define ci:=M(i+1)wi+∑j=i+1l1−1wj.c_i\;:=\; M(i+1)w_i+ _j=i+1^l_1-1w_j. (22) When i=0i=0, we have c0=x∗c_0=x^* (the eviction-free fixed point throughput). When i=l1−1i=l_1-1, cl1−1=M/[l1wl1−1]c_l_1-1=M/[l_1w_l_1-1] (the maximal-eviction throughput). For every i≥1i≥ 1, the execute-evict-admit map admits an eviction-level-i limit cycle whose time-averaged throughput equals cic_i and whose occupied stages form a contiguous block at every iteration. Moreover, cii=0l1−1\c_i\_i=0^l_1-1 is strictly decreasing: ci>ci+1,i=0,1,…,l1−2.c_i>c_i+1, i=0,1,…,l_1-2. (23) Proposition 7 (Evenly spaced cycles (most balanced)). Let k∈2,3,…,l1k∈\2,3,…,l_1\ be a divisor of l1l_1 and write l1=kdl_1=kd. There exists an eviction-level-(l1−k)(l_1-k) limit cycle with k occupied stages per iteration whose occupied stage indices are evenly spaced by d. Its throughput equals T¯bal(k)=Md∑q=1kwqd−1. T_bal(k)= Md _q=1^kw_qd-1. (24) Moreover, T¯bal(k) T_bal(k) is strictly increasing in k (and hence strictly decreasing in the eviction level l1−kl_1-k). Proposition 8 (Fixed-support gap-vector throughput envelope). Fix a fixed-relative-support periodic orbit and a block-end representative with m∈1,…,l1m∈\1,…,l_1\ live positions. Equivalently, consider a cycled equilibrium whose live relative positions rotate without changing their predecessor-gap pattern. If m=1m=1, set g0=l1g_0=l_1. If m≥2m≥ 2, let g0,…,gm−1g_0,…,g_m-1 be its predecessor gaps. Then gh∈ℤ>0g_h _>0, ∑hgh=l1 _hg_h=l_1, and the orbit’s time-averaged throughput is T¯(g)=Ml0l1+12(l12+∑h=0m−1gh2). T(g)= Ml_0l_1+ 12 (l_1^2+ _h=0^m-1g_h^2 ). (25) Consequently, among fixed-relative-support periodic orbits with m live positions, throughput is minimized by the contiguous-block gap vector, up to cyclic rotation, (l1−m+1,1,…,1)(l_1-m+1,1,…,1), and is maximized by any as-evenly-spaced gap vector. Equivalently, if l1=am+rl_1=am+r with a≥1a≥ 1 and 0≤r<m0≤ r<m, the maximizing gap vector has r gaps equal to a+1a+1 and m−rm-r gaps equal to a, up to permutation of the gaps. The lower endpoint is the contiguous-block throughput cl1−m=Ml0l1+12(l12+(l1−m+1)2+m−1),c_l_1-m= Ml_0l_1+ 12 (l_1^2+(l_1-m+1)^2+m-1 ), and the upper endpoint is T¯even(m)=Ml0l1+12(l12+r(a+1)2+(m−r)a2). T_even(m)= Ml_0l_1+ 12 (l_1^2+r(a+1)^2+(m-r)a^2 ). When m divides l1l_1, T¯even(m) T_even(m) equals the evenly-spaced throughput T¯bal(m) T_bal(m) in Proposition 7. Note that, across levels, the ordering need not be monotone: a cycle at a higher eviction level can outperform one at a lower level when the lower-level cycle clusters its active stages into consecutive positions. Example 7 (Cross-level non-monotonicity). Let l0=2l_0=2, l1=10l_1=10, so wj=3+jw_j=3+j. 1. Contiguous-block, level 4 (six occupied stages in positions 0–55). By Proposition 6, c4=M5w4+∑j=59wj=M5⋅7+(8+9+10+11+12)=M85.c_4= M5\,w_4+ _j=5^9w_j= M5· 7+(8+9+10+11+12)= M85. 2. Balanced, level 5 (five occupied stages at positions 1,3,5,7,91,3,5,7,9; k=5k=5, d=2d=2). By Proposition 7, T¯bal(5)=M2(w1+w3+w5+w7+w9)=M2(4+6+8+10+12)=M80. T_bal(5)= M2(w_1+w_3+w_5+w_7+w_9)= M2(4+6+8+10+12)= M80. Since c4=M/85<M/80=T¯bal(5)c_4=M/85<M/80= T_bal(5), the level-4 cycle achieves lower throughput despite having one more occupied stage. Contiguous clustering concentrates requests in adjacent heavy stages (5w4=355w_4=35 dominates the denominator), while even spacing samples stages of mixed weight (w1=4w_1=4 through w9=12w_9=12), yielding a smaller memory-time total. Proof of Proposition 5. We construct each orbit and verify that it is invariant under the execute-evict-admit map. Adjacent orbit. Define b:=T¯adjb:= T_adj as in (20) and set ar:=M−wr+1bwr,r=0,1,…,l1−2,al1−1:=M−w0bwl1−1=(l1−1)b,a_r:= M-w_r+1bw_r, r=0,1,…,l_1-2, a_l_1-1:= M-w_0bw_l_1-1=(l_1-1)b, where the last equality uses wl1−1=w0+l1−1w_l_1-1=w_0+l_1-1. Consider the length-l1l_1 orbit with states Xr=(0,…,0,ar⏟stage r,b⏟stage r+1, 0,…,0),r=0,1,…,l1−2,Xl1−1=(b⏟stage 0, 0,…,0,al1−1⏟stage l1−1).X_r=(0,…,0,\; a_r_stage r,\; b_stage r+1,\;0,…,0), r=0,1,…,l_1-2, X_l_1-1=( b_stage 0,\,0,…,0,\, a_l_1-1_stage l_1-1). Each XrX_r saturates memory: wrar+wr+1b=Mw_ra_r+w_r+1b=M (and w0b+wl1−1al1−1=Mw_0b+w_l_1-1a_l_1-1=M). For r=0,…,l1−3r=0,…,l_1-3, applying Execute to XrX_r produces two nonzero stages r+1r+1 and r+2r+2 with values (ar,b)(a_r,b). Because ar>ar+1a_r>a_r+1, the post-execute memory exceeds M and LPF evicts from stage r+1r+1 until it equals ar+1a_r+1, yielding exactly Xr+1X_r+1 and leaving no slack for admission. At r=l1−2r=l_1-2, Execute completes the b requests at stage l1−1l_1-1 and shifts al1−2a_l_1-2 to stage l1−1l_1-1, leaving post-execute memory wl1−1al1−2<Mw_l_1-1a_l_1-2<M. No eviction occurs and admission fills stage 0 with M−wl1−1al1−2w0=b, M-w_l_1-1a_l_1-2w_0=b, where the equality is equivalent to the definition of b in (20). This yields Xl1−1X_l_1-1. Finally, applying Execute to Xl1−1X_l_1-1 completes the al1−1a_l_1-1 requests at stage l1−1l_1-1 and shifts b to stage 1; no eviction occurs and admission fills stage 0 with (M−w1b)/w0=a0(M-w_1b)/w_0=a_0, returning to X0X^0. Hence X0,…,Xl1−1\X^0,…,X_l_1-1\ is a limit cycle. Only Xl1−2X_l_1-2 and Xl1−1X_l_1-1 have a nonzero final stage, so the total completions over one period are b+al1−1=b+(l1−1)b=l1b+a_l_1-1=b+(l_1-1)b=l_1b, yielding T¯adj=b T_adj=b. Opposite orbit (even l1=2dl_1=2d). Let b:=M/(wd−1+wl1−1)b:=M/(w_d-1+w_l_1-1) and define ar:=M−wr+dbwr,r=0,1,…,d−1.a_r:= M-w_r+dbw_r, r=0,1,…,d-1. Consider the d-periodic orbit with states Yr=(0,…,0,ar⏟stage r, 0,…,0,b⏟stage r+d, 0,…,0),r=0,1,…,d−1.Y_r=(0,…,0,\; a_r_stage r,\;0,…,0,\; b_stage r+d,\;0,…,0), r=0,1,…,d-1. Each YrY_r lies on the memory boundary since wrar+wr+db=Mw_ra_r+w_r+db=M. For r=0,…,d−2r=0,…,d-2, Execute shifts (ar,b)(a_r,b) to stages (r+1,r+d+1)(r+1,r+d+1); since ar>ar+1a_r>a_r+1, memory overflows and LPF evicts from stage r+1r+1 until it equals ar+1a_r+1, producing Yr+1Y_r+1 with no slack for admission. At r=d−1r=d-1, the batch b is at the final stage l1−1=2d−1l_1-1=2d-1 and completes under Execute; the remaining batch ad−1=ba_d-1=b shifts to stage d. Post-execute memory is wdb<Mw_db<M, so no eviction occurs and admission fills stage 0 with a0=(M−wdb)/w0a_0=(M-w_db)/w_0, producing Y0Y_0. Thus Y0,…,Yd−1\Y_0,…,Y_d-1\ is a limit cycle. Exactly b requests complete over d iterations, giving T¯opp=b/d T_opp=b/d, which is (21). □ Proof of Proposition 6. Fix i and write k:=l1−ik:=l_1-i for the number of occupied stages. Let b:=cib:=c_i as in (22). Define a length-l1l_1 orbit X0,…,Xl1−1\X^0,…,X_l_1-1\ as follows. For r=0,1,…,i−1r=0,1,…,i-1, set Xr=(0,…,0,ar⏟stage r,b⏟stages r+1,…,r+k−1, 0,…,0),X_r=(0,…,0,\; a_r_stage r,\; b_stages r+1,…,r+k-1,\;0,…,0), where ara_r is chosen so that XrX_r lies on the memory boundary: wrar+b∑j=r+1r+k−1wj=M.w_ra_r+b _j=r+1^r+k-1w_j=M. (26) For r=i,i+1,…,l1−1r=i,i+1,…,l_1-1, define XrX_r as the cyclic shift of a length-k contiguous block with one larger leading entry: Xr=(b⏟stages 0,…,r−i−1, 0,…,0,(i+1)b⏟stage r,b⏟stages r+1,…,l1−1).X_r=( b_stages 0,…,r-i-1,\,0,…,0,\; (i+1)b_stage r,\; b_stages r+1,…,l_1-1). (Equivalently, XrX_r has support r,r+1,…,l1−1,0,1,…,r−i−1\r,r+1,…,l_1-1,0,1,…,r-i-1\, a contiguous block of length k in cyclic order.) Each XrX_r saturates memory by construction: for r<ir<i this is (26), and for r≥ir≥ i it follows from (22). We now verify invariance under the execute-evict-admit map. Case 1: r<ir<i. The block r,…,r+k−1\r,…,r+k-1\ does not include the final stage l1−1l_1-1, so no completion occurs. After Execute, ara_r shifts to stage r+1r+1 and the b-mass shifts to stages r+2,…,r+kr+2,…,r+k, giving post-execute memory wr+1ar+b∑j=r+2r+kwj=(wrar+b∑j=r+1r+k−1wj)+ar+(k−1)b>M.w_r+1a_r+b _j=r+2^r+kw_j= (w_ra_r+b _j=r+1^r+k-1w_j )+a_r+(k-1)b>M. Since r+k≤l1−1r+k≤ l_1-1, the post-execute support is contained in stages r+1,…,r+k\r+1,…,r+k\ and LPF evicts only from stage r+1r+1 until feasibility is restored. The resulting stage-r+1r+1 value is exactly ar+1a_r+1 (defined by (26) with r+1r+1), producing Xr+1X_r+1 with no slack for admission. Case 2: i≤r≤l1−2i≤ r≤ l_1-2. Stage l1−1l_1-1 is occupied by b and completes under Execute. The total number of active requests in XrX_r equals (i+1)b+(k−1)b=l1b(i+1)b+(k-1)b=l_1b, so (l1−1)b(l_1-1)b survive. Since wl1−1=w0+l1−1w_l_1-1=w_0+l_1-1, the post-execute memory is M+(l1−1)b−wl1−1b=M−w0b<M.M+(l_1-1)b-w_l_1-1b=M-w_0b<M. No eviction occurs and admission fills the slack w0bw_0b with exactly b new stage-0 requests, yielding Xr+1X_r+1. Case 3: r=l1−1r=l_1-1. Stage l1−1l_1-1 holds (i+1)b(i+1)b and completes under Execute. The remaining stages 1,…,k−11,…,k-1 each contain b, so the post-execute state has memory b∑j=1k−1wj<Mb _j=1^k-1w_j<M and admission fills stage 0 with a0=M−b∑j=1k−1wjw0,a_0= M-b _j=1^k-1w_jw_0, which equals the value defined by (26) at r=0r=0. This returns to X0X^0 and closes the orbit. Over one period, the final stage holds b for l1−i−1l_1-i-1 iterations (r=i,…,l1−2r=i,…,l_1-2) and (i+1)b(i+1)b for one (r=l1−1r=l_1-1). The total completions therefore equal (l1−i−1)b+(i+1)b=l1b,(l_1-i-1)b+(i+1)b=l_1b, so T¯=b=ci T=b=c_i. Finally, to prove (23), the denominator in (22) satisfies ((i+2)wi+1+∑j=i+2l1−1wj)−((i+1)wi+∑j=i+1l1−1wj)=(i+1)(wi+1−wi)=i+1>0, ((i+2)w_i+1+ _j=i+2^l_1-1w_j )- ((i+1)w_i+ _j=i+1^l_1-1w_j )=(i+1)(w_i+1-w_i)=i+1>0, so ci+1<cic_i+1<c_i. □ Proof of Proposition 7. Let b:=M∑q=1kwqd−1.b:= M _q=1^kw_qd-1. For r=0,1,…,d−1r=0,1,…,d-1, define ar:=M−b∑q=1k−1wr+qdwr,Yr=(0,…,0,ar⏟stage r, 0,…,0,b⏟stages r+d,r+2d,…,r+(k−1)d, 0,…,0),a_r:= M-b _q=1^k-1w_r+qdw_r, Y_r=(0,…,0,\; a_r_stage r,\;0,…,0,\; b_stages r+d,r+2d,…,r+(k-1)d,\;0,…,0), where indices are in 0,…,l1−1\0,…,l_1-1\ and r+(k−1)d≤l1−1r+(k-1)d≤ l_1-1 since r≤d−1r≤ d-1. Each YrY_r lies on the memory boundary by construction. The sequence arr=0d−1\a_r\_r=0^d-1 is strictly decreasing. Since wr+qd=wr+qdw_r+qd=w_r+qd, ar=M−b∑q=1k−1(wr+qd)wr=M−bdk(k−1)2wr−(k−1)b,a_r= M-b _q=1^k-1(w_r+qd)w_r= M-bd k(k-1)2w_r-(k-1)b, which decreases strictly with wr=w0+rw_r=w_0+r. For r=0,…,d−2r=0,…,d-2, Execute shifts (ar,b,…,b)(a_r,b,…,b) to stages (r+1,r+1+d,…,r+1+(k−1)d)(r+1,r+1+d,…,r+1+(k-1)d). Because ar>ar+1a_r>a_r+1, memory overflows and LPF evicts from the lowest occupied stage r+1r+1 until it equals ar+1a_r+1, yielding exactly Yr+1Y_r+1 with no slack for admission. At r=d−1r=d-1, stage l1−1=(d−1)+(k−1)dl_1-1=(d-1)+(k-1)d holds b and completes. Since b=M/∑q=1kwqd−1b=M/ _q=1^kw_qd-1, the boundary condition implies ad−1=ba_d-1=b. The remaining k−1k-1 batches all have size b and shift to stages d,2d,…,(k−1)d,2d,…,(k-1)d, producing post-execute memory b∑q=1k−1wqd<Mb _q=1^k-1w_qd<M. No eviction occurs and admission fills stage 0 with a0=M−b∑q=1k−1wqdw0,a_0= M-b _q=1^k-1w_qdw_0, returning to Y0Y_0. Thus Y0,…,Yd−1\Y_0,…,Y_d-1\ is a limit cycle with throughput b/db/d, which is (24). To prove monotonicity in k, substitute wqd−1=w0+qd−1w_qd-1=w_0+qd-1 and d=l1/kd=l_1/k into (24): d∑q=1kwqd−1=d(k(w0−1)+dk(k+1)2)=l1(w0−1)+l122k+1k.d _q=1^kw_qd-1=d (k(w_0-1)+d k(k+1)2 )=l_1(w_0-1)+ l_1^22 k+1k. The right-hand side is strictly decreasing in k because (k+1)/k(k+1)/k decreases with k, so T¯bal(k) T_bal(k) is strictly increasing in k. □ Proof of Proposition 8. If m=1m=1, the single predecessor gap is g0=l1g_0=l_1, and the memory boundary gives y0=M/(l0+l1)y_0=M/(l_0+l_1) at the block-end representative. This mass completes once every l1l_1 iterations, so the throughput is M/[l1(l0+l1)]M/[l_1(l_0+l_1)], which agrees with (25). Hence assume m≥2m≥ 2. The block-end representative of a periodic orbit with a fixed relative support pattern must be balanced. Otherwise Gsc>0G^sc>0, and Lemma A.8 would force another support loss in finite time, contradicting periodicity with m live positions. Thus all normalized live masses are equal: uh=yhgh=c,h=0,…,m−1.u_h= y_hg_h=c, h=0,…,m-1. Thus yh=cghy_h=cg_h. With Sh=∑t=0hgtS_h= _t=0^hg_t, the memory-boundary equation (15) gives M=∑h=0m−1(l0+Sh)yh=c(l0l1+∑h=0m−1ghSh).M= _h=0^m-1(l_0+S_h)y_h=c (l_0l_1+ _h=0^m-1g_hS_h ). During the block that begins with oldest live mass ym−1=cgm−1y_m-1=cg_m-1, exactly gm−1g_m-1 physical iterations elapse before the next block-end, and cgm−1cg_m-1 requests complete at the beginning of that block. Over one full circuit of block-end transitions, the elapsed physical time is ∑hgh=l1 _hg_h=l_1, and the total completed mass is ∑hcgh=cl1 _hcg_h=cl_1. Hence the time-averaged throughput of the periodic orbit is c. This also makes the l1l_1-step closure equations explicit. Let (g(s),y(s))(g^(s),y^(s)) denote the s-th block-end representative along the orbit. Corollary A.5 and the balance relation yh=cghy_h=cg_h give g(s+1)=(gm−1(s),g0(s),…,gm−2(s)),y(s+1)=(cgm−1(s),cg0(s),…,cgm−2(s)).g^(s+1)=(g^(s)_m-1,g^(s)_0,…,g^(s)_m-2), y^(s+1)=(cg^(s)_m-1,cg^(s)_0,…,cg^(s)_m-2). After m block-end transitions, these equations return both the gap vector and the live-mass vector to their initial order. The total elapsed physical time over those m block-end transitions is ∑hgh=l1 _hg_h=l_1, so the physical stage labels also return to their initial positions. Thus the block-end representative satisfies the same closure condition as the physical l1l_1-step cycle. It remains to simplify the denominator. Since ∑h=0m−1ghSh=∑h=0m−1∑t=0hghgt=12((∑h=0m−1gh)2+∑h=0m−1gh2)=12(l12+∑h=0m−1gh2), _h=0^m-1g_hS_h= _h=0^m-1 _t=0^hg_hg_t= 12 ( ( _h=0^m-1g_h )^2+ _h=0^m-1g_h^2 )= 12 (l_1^2+ _h=0^m-1g_h^2 ), we obtain (25). For fixed m, the denominator in (25) is increasing in ∑hgh2 _hg_h^2. Among positive integer vectors with sum l1l_1, the sum of squares is maximized by making one gap as large as possible and all others equal to one: ∑hgh2≤(l1−m+1)2+(m−1), _hg_h^2≤(l_1-m+1)^2+(m-1), with equality exactly at cyclic permutations of (l1−m+1,1,…,1)(l_1-m+1,1,…,1). This is the contiguous-block support geometry, and substituting this value into (25) gives cl1−mc_l_1-m. The sum of squares is minimized when the gaps differ by at most one. Indeed, if two gaps satisfy ga≥gb+2g_a≥ g_b+2, replacing them by ga−1g_a-1 and gb+1g_b+1 preserves the total sum and decreases the squared sum by ga2+gb2−(ga−1)2−(gb+1)2=2(ga−gb−1)>0.g_a^2+g_b^2-(g_a-1)^2-(g_b+1)^2=2(g_a-g_b-1)>0. Iterating this balancing operation yields r gaps equal to a+1a+1 and m−rm-r gaps equal to a, where l1=am+rl_1=am+r. This proves the upper endpoint T¯even(m) T_even(m). Such a gap vector defines an as-evenly-spaced support pattern on the circular pipeline. For any positive gap vector, the balanced state yh=cghy_h=cg_h satisfies uh≡cu_h≡ c, so the normalized block-end map in Corollary A.5 preserves the balanced representative after rotation. The fixed-support induction in Proposition A.4 then lifts this balanced block-end orbit to the physical LPF dynamics. The closure equations are also satisfied: after one block-end transition the gap vector is cyclically rotated, after m block-end transitions it returns to its original order, and the elapsed physical time is ∑h=0m−1gh=l1 _h=0^m-1g_h=l_1. Thus every live position has advanced by one full pipeline cycle, so the physical state returns to the original state and the balanced block-end orbit is a physical limit cycle. When r=0r=0, all gaps are equal to a=l1/ma=l_1/m, which is exactly the evenly-spaced family in Proposition 7. □ A.4 Worst-Case Limit Cycle This subsection remains within the saturated-input continuous model of Theorem 2: state coordinates are nonnegative request masses, and a partial LPF eviction may trim an arbitrary submass of a stage because requests within the same stage are indistinguishable. The proof of Lemma 1 relies on the following continuous accounting identity, which we call the waste decomposition. Let W=∑j=0l1−1wj=l1(2l0+l1+1)/2W= _j=0^l_1-1w_j=l_1(2l_0+l_1+1)/2 denote the total memory-time cost required to process a request through all l1l_1 decoding stages. Over a limit cycle of period p, the memory constraint implies ∑jwjxjn=M _jw_jx^n_j=M for each iteration n. Summing this identity over the p iterations of the cycle and decomposing the total memory-time usage by completed mass versus evicted mass yields pM=pT¯()W+E(),pM=p\, T(C)\,W+E(C), (27) where E()≥0E(C)≥ 0 denotes the total memory-time consumed by requests that are eventually evicted. Rearranging gives T¯()=x∗−E()pW, T(C)=x^*- E(C)pW, where x∗=M/Wx^*=M/W is the throughput of the eviction-free fixed point. Thus, any limit cycle with eviction satisfies T¯()<x∗ T(C)<x^*. The throughput loss relative to the fixed point is proportional to the waste E()E(C). The maximal-eviction cycle maximizes this waste, since requests move through the decoding pipeline as a single synchronized batch and eviction trims the batch at every stage. This regime yields throughput T¯l1−1=M/[l1(l0+l1)] T_l_1-1=M/[l_1(l_0+l_1)]. The proof of Lemma 1 is deferred to Appendix C. Appendix B Proof of Theorem 3: GCD Stability Condition and Extensions Under the LPF convention in Section 2.2 and the proportional admission convention in Section 4, Theorem 3 is stated for the two-class common-input normalization, where the mechanism is most transparent and the complete proof can be written without additional notation. This case contains the essential ideas of the argument: the scalar cohort recurrence, the limiting survival polynomial, the unit-circle/root-of-unity characterization, the finite-input root perturbation, and the Lyapunov argument for global stability. Sections B.8 and B.9 then discuss the corresponding K-class and heterogeneous-input extensions through the appropriate cohort reductions and weighted survival polynomials. In the two-class common-input setting, (i) if gcd(l1,1,l1,2)>1 (l_1,1,l_1,2)>1, the eviction-free equilibrium is unstable; (i) if gcd(l1,1,l1,2)=1 (l_1,1,l_1,2)=1, the system converges globally to equilibrium from any feasible initial active state in the saturated-input model. Lemma 9 (Entry into the proportional-cohort manifold). Consider the continuous saturated-input multi-class dynamics under per-iteration proportional admission akn=pkana_k^n=p_ka^n and proportional within-stage LPF eviction. Let d=maxkl1,kd= _kl_1,k. Starting from any feasible active state, after at most d iterations the state lies on the proportional-cohort manifold: for every cohort age j, there is an aggregate cohort mass yjn≥0y_j^n≥ 0 such that xk,jn=pkyjnfor all classes k with l1,k>j,xk,jn=0for l1,k≤j.x_k,j^n=p_ky_j^n all classes k with l_1,k>j, x_k,j^n=0 l_1,k≤ j. This manifold is forward invariant. The proof is deferred to Appendix C. For the global-convergence statement, Lemma 9 allows us to start without loss of generality from the proportional-cohort manifold. Proof roadmap. Sections B.1–B.2 derive the two-class common-input admission recurrence, its characteristic polynomial, and the leading-order decomposition that separates the limiting survival polynomial from the finite-input correction. Sections B.3–B.7 analyze the limiting roots and show how the finite-input correction moves the root-of-unity modes. Sections B.5–B.6 prove local and global stability in the coprime case, completing the proof of Theorem 3. Section B.8 then gives the corresponding K-class cohort reduction and survival-polynomial substitutions, while Section B.9 explains the heterogeneous-input weighted-polynomial substitution. These extension sections show how the same mechanism carries over, rather than introducing additional formal theorem statements. The later subsections collect finite-input threshold refinements and pulse-cycle results used to interpret the non-coprime case. B.1 System Dynamics and Characteristic Polynomial Consider two request classes with common input length l0l_0 but different decoding lengths l1,1<l1,2l_1,1<l_1,2. Let p=λ1/(λ1+λ2)p= _1/( _1+ _2) and q=1−pq=1-p. The token balance at time n yields the recurrence: (l0+1)x0n+1= (l_0+1)x^n+1_0=\; (l0+l1,2)q⋅x0n−l1,2+1+[(l0+l1,1)p−q]x0n−l1,1+1 (l_0+l_1,2)q· x^n-l_1,2+1_0+[(l_0+l_1,1)p-q]x^n-l_1,1+1_0 −∑i=n−l1,1+2nx0i−q∑i=n−l1,2+2n−l1,1x0i. - _i=n-l_1,1+2^nx^i_0-q _i=n-l_1,2+2^n-l_1,1x^i_0. Subtracting consecutive equations and defining Dn=x0n+1−x0nD^n=x^n+1_0-x^n_0: (l0+1)Dn+∑m=1l1,1−1(l0+m+1)Dn−m+q∑m=l1,1l1,2−1(l0+m+1)Dn−m=0.(l_0+1)D^n+ _m=1^l_1,1-1(l_0+m+1)D^n-m+q _m=l_1,1^l_1,2-1(l_0+m+1)D^n-m=0. The characteristic polynomial is: F(z)=(l0+1)zl1,2−1+∑m=1l1,1−1(l0+m+1)zl1,2−1−m+q∑m=l1,1l1,2−1(l0+m+1)zl1,2−1−m.F(z)=(l_0+1)z^l_1,2-1+ _m=1^l_1,1-1(l_0+m+1)z^l_1,2-1-m+q _m=l_1,1^l_1,2-1(l_0+m+1)z^l_1,2-1-m. (28) B.2 Limiting Polynomial and Key Decomposition As l0→∞l_0→∞, define the limiting polynomial: A(z)=liml0→∞F(z)l0+1=zl1,2−1+∑m=1l1,1−1zl1,2−1−m+q∑m=l1,1l1,2−1zl1,2−1−m.A(z)= _l_0→∞ F(z)l_0+1=z^l_1,2-1+ _m=1^l_1,1-1z^l_1,2-1-m+q _m=l_1,1^l_1,2-1z^l_1,2-1-m. Summing geometric series yields the closed form: (1−z)A(z)=−zl1,2+pzl1,2−l1,1+q.(1-z)A(z)=-z^l_1,2+pz^l_1,2-l_1,1+q. (29) The characteristic polynomial admits a decomposition that separates leading-order root structure from the O(1/l0)O(1/l_0) correction. Define B(z)=F(z)−(l0+1)A(z)=∑m=1l1,1−1mzl1,2−1−m+q∑m=l1,1l1,2−1mzl1,2−1−m.B(z)=F(z)-(l_0+1)A(z)= _m=1^l_1,1-1mz^l_1,2-1-m+q _m=l_1,1^l_1,2-1mz^l_1,2-1-m. We claim that B(z)=(l1,2−1)A(z)−zA′(z)B(z)=(l_1,2-1)A(z)-zA (z). To verify, compute: zA′(z) zA (z) =(l1,2−1)zl1,2−1+∑m=1l1,1−1(l1,2−1−m)zl1,2−1−m+q∑m=l1,1l1,2−1(l1,2−1−m)zl1,2−1−m =(l_1,2-1)z^l_1,2-1+ _m=1^l_1,1-1(l_1,2-1-m)z^l_1,2-1-m+q _m=l_1,1^l_1,2-1(l_1,2-1-m)z^l_1,2-1-m =(l1,2−1)A(z)−B(z). =(l_1,2-1)A(z)-B(z). Therefore: F(z)=(l0+1)A(z)+B(z)=(l0+l1,2)A(z)−zA′(z).F(z)=(l_0+1)A(z)+B(z)=(l_0+l_1,2)A(z)-zA (z). (30) This decomposition reduces the stability problem to analyzing the roots of A(z)A(z) and their perturbation under the O(1/l0)O(1/l_0) correction zA′(z)zA (z). B.3 Root Structure of the Limiting Polynomial We establish four lemmas characterizing the roots of A(z)A(z). Lemma 10 (Boundedness). All roots of (1−z)A(z)=0(1-z)A(z)=0 satisfy |z|≤1|z|≤ 1. The proof is deferred to Appendix C. Lemma 11 (Unit Circle Structure). If |z|=1|z|=1 and (1−z)A(z)=0(1-z)A(z)=0, then zg=1z^g=1 where g=gcd(l1,1,l1,2)g= (l_1,1,l_1,2). The proof is deferred to Appendix C. Lemma 12 (Exclusion of Unity). z=1z=1 is not a root of A(z)A(z). The proof is deferred to Appendix C. Lemma 13 (Non-Trivial g-th Roots). If g=gcd(l1,1,l1,2)>1g= (l_1,1,l_1,2)>1, every non-trivial g-th root of unity ω=e2πik/gω=e^2π ik/g for k=1,…,g−1k=1,…,g-1 is a root of A(z)A(z). The proof is deferred to Appendix C. Combining these lemmas: when g=1g=1, Lemmas 11 and 12 imply that all roots of A(z)A(z) lie strictly inside the unit circle; when g>1g>1, Lemma 13 shows there are exactly g−1g-1 roots on the unit circle, located at the non-trivial g-th roots of unity. Figure 10 in Section 4 visualizes this structure: panel (a) shows the coprime case with all roots inside the unit circle, while panel (b) shows the non-coprime case with a root at z=−1z=-1 drifting outside. Example 8 (Root structure verification). For the coprime case (l1,1=2l_1,1=2, l1,2=3l_1,2=3, p=q=1/2p=q=1/2), the limiting polynomial is A(z)=z2+z+12,roots z=−1±i2,|z|=12≃0.707.A(z)=z^2+z+ 12, z= -1 2, |z|= 1 2 0.707. All roots lie strictly inside the unit circle (Lemma 10), A(1)=5/2>0A(1)=5/2>0 (Lemma 12), and since gcd(2,3)=1 (2,3)=1 no root reaches the boundary (Lemma 11). For the non-coprime case (l1,1=2l_1,1=2, l1,2=4l_1,2=4, gcd=2 =2): A(z)=z3+z2+12z+12=(z+1)(z2+12).A(z)=z^3+z^2+ 12z+ 12=(z+1)\! (z^2+ 12 ). The root z=−1z=-1 sits on the unit circle, as Lemma 13 predicts: ω=eiπ=−1ω=e^iπ=-1 is the unique non-trivial g-th root of unity for g=2g=2. The remaining roots z=±i/2z= / 2 satisfy |z|=1/2<1|z|=1/ 2<1. Thus only the GCD-predicted root reaches the boundary, and it is exactly the root that the IFT will push outside the unit circle for finite l0l_0 (Theorem 14). Figure 10: Root structure of the limiting polynomial A(z)A(z) for the two-class examples (p=q=1/2p=q=1/2). (a) Coprime decode lengths (l1(1)=2l_1^(1)=2, l1(2)=3l_1^(2)=3): the polynomial A(z)=z2+z+12A(z)=z^2+z+ 12 has roots at (−1±i)/2(-1± i)/2 with |z|=1/2≈0.71|z|=1/ 2≈ 0.71, strictly inside the unit circle (dashed blue). The eviction-free equilibrium is asymptotically stable. (b) Non-coprime decode lengths (l1(1)=2l_1^(1)=2, l1(2)=4l_1^(2)=4, g=2g=2): the polynomial factors as A(z)=(z+1)(z2+12)A(z)=(z+1)(z^2+ 12), placing a root at z=−1z=-1 on the unit circle (red dot). For finite l0=10l_0=10, the Implicit Function Theorem shows this root drifts to |z|≈1.087|z|≈ 1.087 (arrow), establishing instability. The two interior roots (blue dots) at ±i/2± i/ 2 remain harmless. The root z=1z=1 is never a root of A(z)A(z) (Lemma i). B.4 Instability for Non-Coprime Case (g>1g>1) Theorem 14 (Instability). Let gcd(l1,1,l1,2)=g>1 (l_1,1,l_1,2)=g>1. For sufficiently large l0l_0, the characteristic equation F(z)=0F(z)=0 has g−1g-1 roots with |z|>1|z|>1. Proof. Using decomposition (30), define: G(z,ϵ)=A(z)−ϵzA′(z),ϵ=1l0+l1,2.G(z,ε)=A(z)-ε zA (z), ε= 1l_0+l_1,2. For ϵ>0ε>0: G(z,ϵ)=0⇔F(z)=0G(z,ε)=0 F(z)=0 (after dividing (30) by l0+l1,2l_0+l_1,2). At each non-trivial g-th root ω, the Implicit Function Theorem applies: G(ω,0)=A(ω)=0G(ω,0)=A(ω)=0 by Lemma 13, and ∂G∂z(ω,0)=A′(ω)≠0 ∂ G∂ z(ω,0)=A (ω)≠ 0, as we now verify. To compute A′(ω)A (ω), differentiate (29) with respect to z: −A(z)+(1−z)A′(z)=−l1,2zl1,2−1+p(l1,2−l1,1)zl1,2−l1,1−1.-A(z)+(1-z)A (z)=-l_1,2z^l_1,2-1+p(l_1,2-l_1,1)z^l_1,2-l_1,1-1. At a non-trivial g-th root ω where A(ω)=0A(ω)=0 and ωl1,2=ωl1,2−l1,1=1ω^l_1,2=ω^l_1,2-l_1,1=1 (by Lemma 13): (1−ω)A′(ω) (1-ω)A (ω) =−l1,2ωl1,2−1+p(l1,2−l1,1)ωl1,2−l1,1−1 =-l_1,2ω^l_1,2-1+p(l_1,2-l_1,1)ω^l_1,2-l_1,1-1 =−l1,2ω−1+p(l1,2−l1,1)ω−1(since ωl1,2=ωl1,2−l1,1=1) =-l_1,2ω^-1+p(l_1,2-l_1,1)ω^-1 (since $ω^l_1,2=ω^l_1,2-l_1,1=1$) =ω−1[−l1,2+p(l1,2−l1,1)] =ω^-1[-l_1,2+p(l_1,2-l_1,1)] =ω−1[−l1,2+pl1,2−pl1,1] =ω^-1[-l_1,2+pl_1,2-pl_1,1] =−ω−1[(1−p)l1,2+pl1,1] =-ω^-1[(1-p)l_1,2+pl_1,1] =−ω−1[ql1,2+pl1,1]. =-ω^-1[ql_1,2+pl_1,1]. Since p,q>0p,q>0 and l1,1,l1,2≥1l_1,1,l_1,2≥ 1, we have ql1,2+pl1,1>0ql_1,2+pl_1,1>0. Also ω≠1ω≠ 1 (non-trivial root), so 1−ω≠01-ω≠ 0. Therefore: A′(ω)=−ω−1(pl1,1+ql1,2)1−ω≠0.A (ω)= -ω^-1(pl_1,1+ql_1,2)1-ω≠ 0. By IFT, there exists a smooth function z(ϵ)z(ε) with z(0)=ωz(0)=ω and G(z(ϵ),ϵ)=0G(z(ε),ε)=0. Differentiating G(z(ϵ),ϵ)=0G(z(ε),ε)=0 with respect to ϵε at ϵ=0ε=0: z′(0)=−∂G/∂ϵ∂G/∂z|(ω,0)=−ωA′(ω)A′(ω)=ω.z (0)=- ∂ G/∂ε∂ G/∂ z |_(ω,0)=- -ω A (ω)A (ω)=ω. Taylor expansion gives z(ϵ)=ω(1+ϵ)+r(ϵ)z(ε)=ω(1+ε)+r(ε) where r(ϵ)=O(ϵ2)r(ε)=O(ε^2). Let ζ(ϵ)=ω−1r(ϵ)ζ(ε)=ω^-1r(ε); then ζ(ϵ)=O(ϵ2)ζ(ε)=O(ε^2) and: |z(ϵ)|=|1+ϵ+ζ(ϵ)|.|z(ε)|=|1+ε+ζ(ε)|. For sufficiently small ϵ>0ε>0, there exists a constant C>0C>0 such that |ζ(ϵ)|≤Cϵ2|ζ(ε)|≤ Cε^2. Therefore: |z(ϵ)|≥1+ϵ−Cϵ2>1.|z(ε)|≥ 1+ε-Cε^2>1. Applying this argument to each of the g−1g-1 distinct non-trivial g-th roots of unity yields g−1g-1 distinct roots of F(z)=0F(z)=0 with |z|>1|z|>1 for all sufficiently large l0l_0. □ Lemma 15 (Complementary Root Count in the Non-Coprime Case). Let gcd(l1,1,l1,2)=g>1 (l_1,1,l_1,2)=g>1. For sufficiently large l0l_0, the characteristic equation F(z)=0F(z)=0 has exactly g−1g-1 roots outside the unit disk, all satisfying |z|−1=Θ(1/l0)|z|-1= (1/l_0), and the remaining l1,2−gl_1,2-g roots satisfy |z|<1|z|<1. Roots are counted with algebraic multiplicity. The proof is deferred to Appendix C. Lemma 16 (Generic finite exit from a local no-eviction neighborhood). Assume gcd(l1,1,l1,2)=g>1 (l_1,1,l_1,2)=g>1 and l0l_0 is sufficiently large. There exists a neighborhood N of the eviction-free equilibrium, within the proportional-cohort manifold, such that LPF eviction is inactive throughout N. While the trajectory remains in N, the exact saturated-input dynamics coincide with the no-eviction affine stage-state map. For every initial perturbation in N with nonzero projection onto the unstable eigenspace, the trajectory exits N in finite time. The exceptional perturbations are contained in a proper linear subspace and therefore have Lebesgue measure zero in the local state coordinates. The proof is deferred to Appendix C. Lemma 15 gives the exact unstable/stable root count used in Theorem 3. Lemma 16 then connects this spectral instability to the local dynamical implication: outside the measure-zero set of perturbations with zero unstable projection, a non-coprime system cannot remain forever in the neighborhood where eviction is inactive and the no-eviction recurrence is exact. The later pulse-cycle instance in Section B.10 then makes this non-coprime recurrent-eviction behavior explicit through a period-g pulse cycle and its local return map. B.5 Local Stability for Coprime Case (g=1g=1) The local stability proof does not require a generic simplicity assumption on the roots of A. We use Rouché’s theorem to count roots with multiplicity inside a contour strictly contained in the unit disk. Theorem 17 (Local Stability). Let gcd(l1,1,l1,2)=1 (l_1,1,l_1,2)=1. For every p∈(0,1)p∈(0,1) and for sufficiently large l0l_0, all roots of F(z)=0F(z)=0 satisfy |z|<1|z|<1. Proof. When g=1g=1, Lemmas 11 and 12 imply all roots of A(z)A(z) satisfy |αj|<1| _j|<1. Let r=maxj|αj|<1r= _j| _j|<1, and choose ρ with r<ρ<1r<ρ<1. On the circle |z|=ρ|z|=ρ, the polynomial A has no zeros, so mρ:=min|z|=ρ|A(z)|>0,Mρ:=max|z|=ρ|zA′(z)|<∞.m_ρ:= _|z|=ρ|A(z)|>0, M_ρ:= _|z|=ρ|zA (z)|<∞. Using decomposition (30) with ϵ=1/(l0+l1,2)ε=1/(l_0+l_1,2), the finite equation is A(z)−ϵzA′(z)=0.A(z)-ε zA (z)=0. For all sufficiently large l0l_0, ϵMρ<mρε M_ρ<m_ρ on |z|=ρ|z|=ρ. Rouché’s theorem then implies that A−ϵzA′A-ε zA and A have the same number of roots in |z|<ρ|z|<ρ. Since A has degree l1,2−1l_1,2-1, this accounts for all roots of F(z)=0F(z)=0, and they all satisfy |z|<ρ<1|z|<ρ<1. □ Example 9 (IFT Root Drift). For the two-class examples (l1,1=2l_1,1=2, l1,2=3l_1,2=3 or 44, p=q=1/2p=q=1/2), Figure 11 plots the spectral radius |zmax||z_ | of F(z)F(z) as l0l_0 increases. In the non-coprime case (l1,1=2l_1,1=2, l1,2=4l_1,2=4, gcd=2 =2), the root at ω=−1ω=-1 drifts to |z|≃1+1/(l0+4)|z| 1+1/(l_0+4), remaining above 11 for all finite l0l_0. In the coprime case (l1,1=2l_1,1=2, l1,2=3l_1,2=3), |zmax|→1/2≃0.707|z_ |→ 1/ 2 0.707 as l0→∞l_0→∞, with a safety margin that persists at every finite l0l_0. Figure 11: Spectral radius of F(z)F(z) versus input length l0l_0 (p=q=1/2p=q=1/2). Non-coprime case (l1(1)=2l_1^(1)=2, l1(2)=4l_1^(2)=4, red): the root at z=−1z=-1 of A(z)A(z) drifts to |z|>1|z|>1 for every finite l0l_0 (Theorem 14). Coprime case (l1(1)=2l_1^(1)=2, l1(2)=3l_1^(2)=3, blue): all roots remain strictly inside the unit circle (Theorem 17), with a safety margin that persists as l0→∞l_0→∞. Both curves approach their limiting values (11 and 1/21/ 2) as l0→∞l_0→∞, confirming the IFT first-order approximation |z|≈|α|(1+1/(l0+l1(2)))|z|≈|α|(1+1/(l_0+l_1^(2))). B.6 Global Convergence for Coprime Case Local stability (Theorem 17) shows the equilibrium is stable to small perturbations. We now prove global convergence: the system reaches equilibrium from any feasible initial active state in the saturated-input model, even when eviction occurs during transients. Figure 2(a) in Section 4 illustrates this convergence for the coprime case gcd(2,3)=1 (2,3)=1. Throughout this section, we work in the asymptotic regime l0→∞l_0→∞: memory scales as M=βl0M=β l_0 for fixed β>0β>0; decoding lengths l1,1,l1,2l_1,1,l_1,2 are constants; and gcd(l1,1,l1,2)=1 (l_1,1,l_1,2)=1. All asymptotic notation is with respect to l0→∞l_0→∞. As l0l_0 grows, eviction perturbations become O(1/l0)O(1/l_0) while state variables remain O(1)O(1), so the contractive linear dynamics dominate. B.6.1 Normalized System We write XsnX^n_s for the number of requests at stage s at time n (equivalently xsnx^n_s in the earlier notation). The original state Xn∈ℝl1,2X^n ^l_1,2 has non-uniform equilibrium: Xs∗=x∗X_s^*=x^* for s<l1,1s<l_1,1 and Xs∗=qx∗X_s^*=qx^* for s≥l1,1s≥ l_1,1, where x∗x^* denotes the equilibrium admission rate. (At equilibrium, a fraction p of admissions are class 1 and q are class 2. For s<l1,1s<l_1,1, both classes contribute, giving px∗+qx∗=x∗px^*+qx^*=x^* requests at stage s. For s≥l1,1s≥ l_1,1, only class 2 requests remain, giving qx∗qx^*.) Define the normalized system: Ysn=Xsns<l1,1Xsn/qs≥l1,1Y^n_s= casesX^n_s&s<l_1,1\\ X^n_s/q&s≥ l_1,1 cases with weights Vs=l0+s+1V_s=l_0+s+1 for s<l1,1s<l_1,1 and Vs=q(l0+s+1)V_s=q(l_0+s+1) for s≥l1,1s≥ l_1,1. The equilibrium becomes uniform: Y∗=[x∗,…,x∗]⊤Y^*=[x^*,…,x^*] . The equilibrium admission rate x∗x^* satisfies: x∗=M∑sVs=βl0∑s=0l1,1−1(l0+s+1)+q∑s=l1,1l1,2−1(l0+s+1).x^*= M _sV_s= β l_0 _s=0^l_1,1-1(l_0+s+1)+q _s=l_1,1^l_1,2-1(l_0+s+1). The denominator expands to (l1,1+q(l1,2−l1,1))l0+Θ(1)=(pl1,1+ql1,2)l0+Θ(1)(l_1,1+q(l_1,2-l_1,1))l_0+ (1)=(pl_1,1+ql_1,2)l_0+ (1). Letting κ=pl1,1+ql1,2κ=pl_1,1+ql_1,2, we have: x∗=βl0κl0+Θ(1)=βκ+O(1/l0)=Θ(1).x^*= β l_0κ l_0+ (1)= βκ+O(1/l_0)= (1). B.6.2 Linear Dynamics and Lyapunov Function The deviation yn=Yn−Y∗y^n=Y^n-Y^* evolves under the transition matrix Φ∈ℝl1,2×l1,2 ^l_1,2× l_1,2: Φ=(−V1/V0−V2/V0⋯−Vl1,2−1/V0010⋯00⋮⋱⋮00⋯10). = pmatrix-V_1/V_0&-V_2/V_0&·s&-V_l_1,2-1/V_0&0\\ 1&0&·s&0&0\\ && && \\ 0&0&·s&1&0 pmatrix. Since the last column of Φ is zero, z=0z=0 is an eigenvalue. The remaining eigenvalues are determined by the (l1,2−1)×(l1,2−1)(l_1,2-1)×(l_1,2-1) leading principal submatrix, which is a companion matrix whose characteristic polynomial is F(z)/(l0+1)F(z)/(l_0+1). Hence the nonzero eigenvalues of Φ are exactly the l1,2−1l_1,2-1 roots of F(z)=0F(z)=0. Lemma 18 (Spectral Bound). When gcd(l1,1,l1,2)=1 (l_1,1,l_1,2)=1, there exists l0,⋆l_0, such that for l0≥l0,⋆l_0≥ l_0, , all eigenvalues of Φ satisfy |zj|≤ρ<1|z_j|≤ρ<1 for some fixed ρ independent of l0l_0. The proof is deferred to Appendix C. Lemma 19 (Lyapunov Matrix Bounds). For l0≥l0,⋆l_0≥ l_0, (Lemma 18), let Φ=Φ(l0) = (l_0) and let P=P(l0)P=P(l_0) be the unique positive definite solution to the discrete Lyapunov equation Φ⊤PΦ−P=−I P -P=-I. There exists CP>0C_P>0, independent of l0l_0, such that I⪯P⪯CPI P C_PI. The proof is deferred to Appendix C. The Lyapunov function L(y)=y⊤PyL(y)=y Py satisfies ‖y‖22≤L(y)≤CP‖y‖22\|y\|_2^2≤ L(y)≤ C_P\|y\|_2^2 and L(Φy)−L(y)=−‖y‖22L( y)-L(y)=-\|y\|_2^2. Example 10 (Transition matrix and Lyapunov bounds). Continuing the coprime example (l1,1=2l_1,1=2, l1,2=3l_1,2=3, l0=10l_0=10, p=q=1/2p=q=1/2, M=118M=118), the normalized weights are V0=11V_0=11, V1=12V_1=12, V2=13/2V_2=13/2, giving ∑Vs=59/2Σ V_s=59/2 and equilibrium x∗=2⋅118/59=4x^*=2· 118/59=4. The transition matrix is Φ=(−12/11−13/220100010), = pmatrix-12/11&-13/22&0\\ 1&0&0\\ 0&1&0 pmatrix, a companion matrix whose nonzero eigenvalues satisfy z2+1211z+1322=0z^2+ 1211z+ 1322=0, equivalently F(z)/(l0+1)=0F(z)/(l_0+1)=0. The roots are z=(−12±i142)/22z=(-12 142)/22 with modulus |z|=13/22≃0.769|z|= 13/22 0.769, confirming ρ<1ρ<1 (Lemma 18). Solving the Lyapunov equation Φ⊤PΦ−P=−I P -P=-I yields CP=‖P‖2≃10.8C_P=\|P\|_2 10.8. The lower bound P⪰IP I is tight: λmin(P)=1 _ (P)=1 (the k=0k=0 term in the series P=∑k(Φk)⊤ΦkP= _k( ^k) ^k already contributes I). The resulting convergence rate 1−1/CP≃0.9071-1/C_P 0.907 per step is conservative compared to the observed spectral rate ρ2≃0.59ρ^2 0.59 (see Example 11). B.6.3 Eviction Bounds Lemma 20 (Physical Bounds). The total number of in-flight requests is O(1)O(1), and the number of evicted requests per step is O(1/l0)O(1/l_0). The proof is deferred to Appendix C. The actual evolution is yn=Φyn−1+eny^n= y^n-1+e^n, where en∈ℝl1,2e^n ^l_1,2 captures the deviation caused by eviction. Lemma 21 (Perturbation Bound). There exists a constant Ce>0C_e>0, independent of l0l_0, such that ‖en‖2≤Ce/l0\|e^n\|_2≤ C_e/l_0 for all n. The proof is deferred to Appendix C. Figure 12 illustrates the mechanism behind Lemmas 20–21. Panel (a) contrasts token growth per step (O(1)O(1)) with the memory freed by a single eviction (≥l0+1≥ l_0+1): at l0=100l_0=100, one eviction clears roughly 99 times the overflow. Panel (b) plots the resulting upper bound on evicted requests per step as a function of l0l_0. This bound is uniform over all time steps n and ensures ‖en‖2≤Ce/l0\|e^n\|_2≤ C_e/l_0, which is small enough for the Lyapunov contraction to dominate the perturbation when l0l_0 is large. Figure 12: Eviction perturbation bound (Lemmas 20–21). (a) Token growth per step (Θ(1) (1)) versus memory freed by one eviction (≥l0+1≥ l_0+1). At l0=100l_0=100, one eviction clears ≈9≈\!9 times the overflow, so each step triggers at most a fraction of an eviction. (b) Upper bound on evicted requests per step as a function of l0l_0 (β=11.8β=11.8). The bound βl0/(l0+1)2=O(1/l0)β l_0/(l_0+1)^2=O(1/l_0) is uniform over all time steps n; it guarantees ‖en‖2≤Ce/l0\|e_n\|_2≤ C_e/l_0 for a constant CeC_e independent of n. B.6.4 Convergence Proof Theorem 22 (Global Convergence). Let gcd(l1,1,l1,2)=1 (l_1,1,l_1,2)=1 and M=βl0M=β l_0. For every p∈(0,1)p∈(0,1) and sufficiently large l0l_0, the system converges exponentially to equilibrium from any feasible initial active state in the saturated-input model. Proof. We construct the neighborhood explicitly. Define: δ=β4C2κ>0,where C2=l1,2⋅maxsVs/l0.δ= β4C_2κ>0, C_2= l_1,2· _sV_s/l_0. Since maxsVs≤l0+l1,2 _sV_s≤ l_0+l_1,2, we have C2≤l1,2(1+l1,2/l0)C_2≤ l_1,2(1+l_1,2/l_0) and in particular C2≤2l1,2C_2≤ 2 l_1,2 for large l0l_0. Thus δ=Θ(1)δ= (1) and is effectively independent of l0l_0. Define the Lyapunov sublevel set =y:L(y)<δ2N=\y:L(y)<δ^2\. Since L(y)≥‖y‖22L(y)≥\|y\|_2^2 (Lemma 19), every y∈y satisfies ‖y‖2<δ\|y\|_2<δ. We first show that no eviction occurs inside N. The post-shift memory ESE^S (before admission) is: ES=∑s=0l1,2−2Vs+1Ysn=∑s=0l1,2−2Vs+1(x∗+yn,s).E^S= _s=0^l_1,2-2V_s+1Y^n_s= _s=0^l_1,2-2V_s+1(x^*+y_n,s). At equilibrium, ES,∗=∑s=0l1,2−2Vs+1x∗=M−V0x∗E^S,*= _s=0^l_1,2-2V_s+1x^*=M-V_0x^*. The deviation satisfies: |ES−ES,∗|=|∑s=0l1,2−2Vs+1yn,s|≤maxsVs⋅l1,2‖yn‖2≤C2l0‖yn‖2.|E^S-E^S,*|= | _s=0^l_1,2-2V_s+1y_n,s |≤ _sV_s· l_1,2\|y^n\|_2≤ C_2l_0\|y^n\|_2. When ‖yn‖2≤δ\|y^n\|_2≤δ: ES−M E^S-M ≤−V0x∗+C2l0δ ≤-V_0x^*+C_2l_0δ =−(l0+1)βκ+O(1/l0)+C2l0⋅β4C2κ =- (l_0+1)βκ+O(1/l_0)+C_2l_0· β4C_2κ ≤−βl02κ+βl04κ=−βl04κ<0. ≤- β l_02κ+ β l_04κ=- β l_04κ<0. Hence, no eviction occurs inside N for sufficiently large l0l_0. Outside N, the Lyapunov energy strictly decreases. The one-step change is: ΔLn L_n =L(yn)−L(yn−1)=(Φyn−1+en)⊤P(Φyn−1+en)−(yn−1)⊤Pyn−1 =L(y^n)-L(y^n-1)=( y^n-1+e^n) P( y^n-1+e^n)-(y^n-1) Py^n-1 =(yn−1)⊤(Φ⊤PΦ−P)yn−1+2(en)⊤PΦyn−1+(en)⊤Pen =(y^n-1) ( P -P)y^n-1+2(e^n) P y^n-1+(e^n) Pe^n =−‖yn−1‖22+Rn, =-\|y^n-1\|_2^2+R_n, where the residual term is Rn=2(en)⊤PΦyn−1+(en)⊤PenR_n=2(e^n) P y^n-1+(e^n) Pe^n. By Lemmas 19 and 21: |Rn|≤2‖en‖2⋅‖P‖2⋅‖Φ‖2⋅‖yn−1‖2+‖P‖2‖en‖22≤C3l0‖yn−1‖2+C4l02,|R_n|≤ 2\|e^n\|_2·\|P\|_2·\| \|_2·\|y^n-1\|_2+\|P\|_2\|e^n\|_2^2≤ C_3l_0\|y^n-1\|_2+ C_4l_0^2, where we used ‖P‖2≤CP\|P\|_2≤ C_P (Lemma 19) and ‖en‖2≤Ce/l0\|e^n\|_2≤ C_e/l_0 (Lemma 21). Moreover, for all sufficiently large l0l_0, the coefficients satisfy |Vs/V0|≤2|V_s/V_0|≤ 2, so ∥Φ∥2≤∥Φ∥F≤5(l1,2−1)=:CΦ\| \|_2≤\| \|_F≤ 5(l_1,2-1)=:C_ . Thus C3=2CPCΦCeC_3=2C_PC_ C_e and C4=CPCe2C_4=C_PC_e^2. Outside N, L(yn−1)≥δ2L(y^n-1)≥δ^2, so ‖yn−1‖22≥L(yn−1)/CP≥δ2/CP\|y^n-1\|_2^2≥ L(y^n-1)/C_P≥δ^2/C_P. Hence: ΔLn≤−δ2CP+C3Myl0+C4l02, L_n≤- δ^2C_P+ C_3M_yl_0+ C_4l_0^2, where My=supn‖yn‖2=O(1)M_y= _n\|y^n\|_2=O(1). Indeed, ∑sXsn≤M/(l0+1)=O(1) _sX^n_s≤ M/(l_0+1)=O(1) implies ‖Yn‖2≤‖Yn‖1≤1min(1,q)∑sXsn=O(1)\|Y^n\|_2≤\|Y^n\|_1≤ 1 (1,q) _sX^n_s=O(1), while ‖Y∗‖2=l1,2x∗=Θ(1)\|Y^*\|_2= l_1,2\,x^*= (1), so ‖yn‖2≤‖Yn‖2+‖Y∗‖2=O(1)\|y^n\|_2≤\|Y^n\|_2+\|Y^*\|_2=O(1) uniformly in n. Choose l0,3l_0,3 such that (C3My+C4)/l0≤δ2/(2CP)(C_3M_y+C_4)/l_0≤δ^2/(2C_P) for l0≥l0,3l_0≥ l_0,3. Then ΔLn≤−δ2/(2CP)<0 L_n≤-δ^2/(2C_P)<0. The system enters N in finite time: the initial Lyapunov value satisfies L(y0)≤CPMy2L(y_0)≤ C_PM_y^2, and the guaranteed decrease of δ2/(2CP)δ^2/(2C_P) per step gives entry within T∗=⌈2CP2My2/δ2⌉T^*= 2C_P^2M_y^2/δ^2 steps. Once inside, the system remains in N: since en=0e^n=0 inside N (no eviction occurs there), L(yn)=L(yn−1)−‖yn−1‖22<L(yn−1)L(y^n)=L(y^n-1)-\|y^n-1\|_2^2<L(y^n-1), so the sublevel set is invariant. Finally, the convergence inside N is exponential. With en=0e^n=0, the dynamics reduce to yn=Φyn−1y^n= y^n-1. Using L(Φy)−L(y)=−‖y‖22L( y)-L(y)=-\|y\|_2^2 and L(y)≤CP‖y‖22L(y)≤ C_P\|y\|_2^2: L(yn)=L(yn−1)−‖yn−1‖22≤(1−1CP)L(yn−1).L(y^n)=L(y^n-1)-\|y^n-1\|_2^2≤ (1- 1C_P )L(y^n-1). Iterating gives L(yn)≤(1−1/CP)n−n0L(yn0)L(y^n)≤(1-1/C_P)^n-n_0L(y^n_0), hence ‖yn‖2→0\|y^n\|_2→ 0 geometrically and the convergence is exponential. □ The following example traces each phase of the convergence mechanism on a concrete instance. Example 11 (Lyapunov convergence illustration). Using the coprime parameters of Example 4 (l1,1=2l_1,1=2, l1,2=3l_1,2=3, l0=10l_0=10, p=q=1/2p=q=1/2, M=118M=118), the transition matrix Φ∈ℝ3×3 ^3× 3 has spectral radius ρ≃0.769ρ 0.769, the discrete Lyapunov equation Φ⊤PΦ−P=−I P -P=-I gives CP≃10.8C_P 10.8, and the eviction-free threshold is δ≃0.57δ 0.57 (so δ2≃0.32δ^2 0.32). Near equilibrium, the post-shift memory ES,∗=V1x∗+V2x∗=74E^S,*=V_1x^*+V_2x^*=74 consumes 63%63\% of M=118M=118, leaving V0x∗=44V_0x^*=44 units for new admissions. Under the worst perturbation ‖y‖=δ\|y\|=δ, the memory deviation is at most C2l0δ≃12C_2l_0δ 12 units, so the admission margin remains 3232 units above zero (Figure 13). Starting from y0=(1,0,0)⊤y_0=(1,0,0) , the energy L(y0)=8.70L(y_0)=8.70 decreases by ‖yn−1‖2\|y^n-1\|^2 at each step. The guaranteed decrease outside N exceeds δ2/(2CP)≃0.015δ^2/(2C_P) 0.015 per step, but the actual decreases range from 0.190.19 to 2.552.55. The energy crosses δ2δ^2 at T∗=8T^*=8 (Figure 14). Inside N, no eviction occurs, so the pure linear dynamics yn=Φyn−1y^n= y^n-1 take over. The trajectory remains in N and converges geometrically: L(yn)≤(1−1/CP)n−n0L(yn0).L(y^n)≤(1-1/C_P)^n-n_0L(y^n_0). This gives a theoretical rate of 1−1/CP≃0.9071-1/C_P 0.907 per step, while the observed decay is closer to ρ2≃0.59ρ^2 0.59. The state spirals to the origin in the (y0,y1)(y_0,y_1)-plane (Figure 15). Figure 13: Step 1 illustration (Example 11): post-shift memory budget. At equilibrium, admitting x∗=4x^*=4 requests fills memory to exactly M. Under worst-case perturbation ‖y‖≤δ\|y\|≤δ, the deviation C2l0δ≈12C_2l_0δ≈ 12 leaves a margin of 3232 units, so no eviction is triggered inside N. Figure 14: Steps 2–3 illustration (Example 11): energy descent on log scale. Outside N (red background), the Lyapunov energy L(yn)L(y_n) decreases at each step (Step 2): the actual decreases (0.190.19–2.552.55) far exceed the guaranteed minimum δ2/(2CP)≈0.015δ^2/(2C_P)≈ 0.015. The energy crosses δ2δ^2 at T∗=8T^*=8 (Step 3, orange dot). Figure 15: Steps 4–5 illustration (Example 11). (a) State-space trajectory in the (y0,y1)(y_0,y_1) plane. The system enters =L<δ2N=\L<δ^2\ (green dashed ellipse) at T∗=8T^*=8 (orange) and remains inside (Step 4, invariance). Blue segments show the trajectory spiraling to the origin under pure linear dynamics (Step 5). (b) Energy L(yn)L(y_n) on log scale near T∗T^*. Inside N, the decay tracks the geometric rate ρ2≈0.59ρ^2≈ 0.59 (gray dashed). The mechanism behind this convergence is the scaling of eviction perturbations. When M=βl0M=β l_0, the number of in-flight requests is O(1)O(1), so each perturbation is O(1/l0)O(1/l_0). As l0→∞l_0→∞, these perturbations vanish relative to the O(1)O(1) state variables, and the contractive linear dynamics dominate. B.7 Finite-Input Spectral Drift and Stability Threshold This subsection proves the finite-input statements used in Section 4.3. Throughout this subsection, set a:=l1,1a:=l_1,1, n:=l1,2n:=l_1,2, q:=1−pq:=1-p, and θn:=a/n _n:=a/n. The proof has three parts. First, we quantify how each limiting root moves when ε=(l0+n)−1 =(l_0+n)^-1 is positive. Second, we identify the limiting root closest to the unit circle. Third, we balance these two effects to obtain the finite-l0l_0 stability threshold. We write the corresponding finite-l0l_0 characteristic equation as Fε(z)F_ (z), where Fε(z)=1εA(z)−zA′(z).F_ (z)= 1 A(z)-zA (z). Lemma 23 (Multiple roots are away from the threshold shell). Fix p∈(0,1)p∈(0,1). There are constants cp>0c_p>0 and NpN_p such that, for every coprime pair 1≤a<n1≤ a<n, n≥Npn≥ N_p, any non-unit multiple root ζ of Pn(z):=zn−pzn−a−qP_n(z):=z^n-pz^n-a-q satisfies |ζ|≤1−cpn.|ζ|≤ 1- c_pn. Hence possible multiple roots of A are separated from the O(n−3)O(n^-3) threshold shell in which the two dominant roots cross the unit circle. The proof is deferred to Appendix C. Theorem 24 (Spectral drift under finite input length). Assume gcd(l1,1,l1,2)=1 (l_1,1,l_1,2)=1. Let α be a simple root of the limiting polynomial A, i.e., A(α)=0A(α)=0 and A′(α)≠0A (α)≠ 0. Then there exists a unique root branch zα(ε)z_α( ) of FεF_ with zα(0)=αz_α(0)=α, and constants εα>0 _α>0 and Kα>0K_α>0, such that for all 0≤ε≤εα0≤ ≤ _α, |zα(ε)−α(1+ε)−c2(α)ε2|≤Kαε3,c2(α)=α2(αA′(α)A′(α)+2). |z_α( )-α(1+ )-c_2(α) ^2 |≤ K_α ^3, c_2(α)= α2 ( α A (α)A (α)+2 ). (31) Along coprime families with l1,2→∞l_1,2→∞, the two dominant limiting branches are simple. Let ρ(ε)ρ( ) denote the spectral radius of the corresponding finite-l0l_0 linearization. On each dominant branch, the second-order modulus correction is positive. Moreover, for every fixed threshold-scale constant E>0E>0, there exist constants Kρ>0K_ρ>0 and Nρ≥1N_ρ≥ 1 such that, for all l1,2≥Nρl_1,2≥ N_ρ and all 0≤ε≤E(l1,2)−30≤ ≤ E(l_1,2)^-3, |ρ(ε)−ρ∞(1+ε)|≤Kρl1,2ε2. |ρ( )- _∞(1+ ) |≤ K_ρ\,l_1,2 ^2. (32) Proposition 25 (Spectral gap scaling). Along any coprime family with l1,2→∞l_1,2→∞, with θn:=l1,1/l1,2 _n:=l_1,1/l_1,2, there exist constants Kgap>0K_gap>0 and Ngap≥1N_gap≥ 1 such that, for all l1,2≥Ngapl_1,2≥ N_gap, |1−ρ∞−c(θn,p)(l1,2)−3|≤Kgap(l1,2)−4,c(θn,p)=2π2p(1−p)((1−p)+pθn)3. |1- _∞-c( _n,p)(l_1,2)^-3 |≤ K_gap(l_1,2)^-4, c( _n,p)= 2π^2p(1-p)((1-p)+p _n)^3. (33) Corollary 26 (Stability threshold). Along any coprime family with l1,2→∞l_1,2→∞, there exist constants KS>0K_S>0 and N0≥1N_0≥ 1 such that, for all l1,2≥N0l_1,2≥ N_0, the minimum stable input length l0,min:=minl0∈ℤ≥0:ρ((l0+l1,2)−1)<1l_0, := \l_0 _≥ 0:ρ ((l_0+l_1,2)^-1 )<1 \ satisfies |(l0,min+l1,2)(1−ρ∞)−1|≤KS(l1,2)−2. |(l_0, +l_1,2)(1- _∞)-1 |≤ K_S(l_1,2)^-2. Pn(z):=zn−pzn−a−q.P_n(z):=z^n-pz^n-a-q. Since A(1)=pa+qn>0A(1)=pa+qn>0, the unit root of PnP_n is removed by the (1−z)(1-z) factor in (29). Thus the roots of A are exactly the non-unit roots of PnP_n. Lemma 27 (Near-unit logarithmic chart). Fix p∈(0,1)p∈(0,1). There exist constants δ,η,c>0δ,η,c>0, independent of the coprime pair 1≤a<n1≤ a<n, such that every root z≠1z≠ 1 of PnP_n with |z|≥e−η/n|z|≥ e^-η/n can be represented as z=ωe−μ/n,ωn=1,ℑμ∈[−π,π],z=ω e^-μ/n, ω^n=1, μ∈[-π,π], after choosing an n-th root ω nearest to the argument of z. If x∈(−π,π]x∈(-π,π] is defined by ω−a=eixω^-a=e^ix, then H(μ,x,θn)=0,θn=a/n,H(μ,x, _n)=0, _n=a/n, where H(μ,x,θ):=e−μ−peixe−(1−θ)μ−q.H(μ,x,θ):=e^-μ-pe^ixe^-(1-θ)μ-q. For |x|≤δ|x|≤δ and ℜμ≤η μ≤η, this equation has the unique solution μ=μ(x,θ)μ=μ(x,θ) near zero. For |x|≥δ|x|≥δ, every such near-unit solution satisfies ℜμ≥c μ≥ c. The proof is deferred to Appendix C. B.7.1 Proof of Proposition 25 We next evaluate the limiting spectral gap. The limiting roots of A are most transparent in logarithmic coordinates around the n-th roots of unity. For each m∈0,…,n−1m∈\0,…,n-1\, let xm:=the principal representative of 2πmn(mod2π),xm∈(−π,π].x_m:=the principal representative of 2π mn 2π, x_m∈(-π,π]. Because gcd(a,n)=1 (a,n)=1, multiplication by a is invertible modulo n. Hence there is a unique um(modn)u_m n such that aum≡−m(modn).au_m≡-m n. Define ωm,n:=e2πium/n. _m,n:=e^2 _m/n. Then ωm,n=1 _m,n^n=1 and ωm,n−a=eixm _m,n^-a=e^ix_m. For m≠0m≠ 0, the near-unit root chart in Lemma 27 parameterizes the root branch associated with this phase as z=ωm,nexp(−μ/n).z= _m,n (-μ/n). Substituting this expression into Pn(z)=0P_n(z)=0 gives H(μ,xm,θn)=0,θn:=a/n,H(μ,x_m, _n)=0, _n:=a/n, where H(μ,x,θ):=e−μ−peixe−(1−θ)μ−q.H(μ,x,θ):=e^-μ-pe^ixe^-(1-θ)μ-q. At phase x=0x=0, the solution is μ=0μ=0 for every θ∈[0,1]θ∈[0,1]. Moreover, Hμ(0,0,θ)=−(q+pθ)≠0.H_μ(0,0,θ)=-(q+pθ)≠ 0. Thus the implicit-function theorem gives a smooth local branch μ(x,θ)μ(x,θ), uniformly for θ∈[0,1]θ∈[0,1], such that H(μ(x,θ),x,θ)=0,μ(0,θ)=0.H(μ(x,θ),x,θ)=0, μ(0,θ)=0. Let D(θ):=q+pθD(θ):=q+pθ. Differentiating implicitly at x=0x=0 gives μx(0,θ)=−ipD(θ) _x(0,θ)=-i pD(θ) and μxx(0,θ)=pqD(θ)3. _x(0,θ)= pqD(θ)^3. Consequently, near the boundary phase x=0x=0, ℜμ(x,θ)=pq2D(θ)3x2+O(|x|3), μ(x,θ)= pq2D(θ)^3x^2+O(|x|^3), uniformly in θ. Branches bounded away from x=0x=0 are separated from the unit circle by Lemma 27: for |x|≥δ|x|≥δ, near-unit roots satisfy ℜμ≥cδ>0 μ≥ c_δ>0, and therefore |z|≤e−cδ/n=1−Θ(n−1)|z|≤ e^-c_δ/n=1- (n^-1). Roots outside the near-unit chart have an even larger radial gap. Because a and n are coprime, the nonzero phase set is ±2π/n,±4π/n,….\± 2π/n,± 4π/n,…\. After shrinking δ, the Taylor remainder is at most one half of the quadratic term for |x|≤δ|x|≤δ, uniformly in θ∈[0,1]θ∈[0,1]. Hence among phases with |x|≤δ|x|≤δ, the roots closest to the unit circle are exactly those with |x|=2π/n|x|=2π/n. For these branches, ℜμ(2π/n,θn)=2π2pqD(θn)3n−2+O(n−3). μ(2π/n, _n)= 2π^2pqD( _n)^3n^-2+O(n^-3). Therefore ρ∞=exp(−1nℜμ(2π/n,θn))=1−2π2pq(q+pθn)3n−3+O(n−4). _∞= \! (- 1n μ(2π/n, _n) )=1- 2π^2pq(q+p _n)^3n^-3+O(n^-4). Returning to the original notation θn=l1,1/l1,2 _n=l_1,1/l_1,2 and n=l1,2n=l_1,2 gives 1−ρ∞=2π2p(1−p)((1−p)+pθn)3(l1,2)−3+O((l1,2)−4),1- _∞= 2π^2p(1-p)((1-p)+p _n)^3\,(l_1,2)^-3+O((l_1,2)^-4), which is (33). The same estimates also give the separation needed later. If xk=2πk/nx_k=2π k/n and 2≤k≤δn/(2π)2≤ k≤δ n/(2π), then ℜμ(xk,θn)−ℜμ(x1,θn)≥c(k2−1)n−2, μ(x_k, _n)- μ(x_1, _n)≥ c(k^2-1)n^-2, so the corresponding moduli are below the dominant modulus by at least cn−3cn^-3. If |xk|≥δ|x_k|≥δ, Lemma 27 gives 1−|αk|≥cδn−11-| _k|≥ c_δn^-1. Thus every non-dominant limiting branch is separated from the dominant modulus by at least cn−3cn^-3. B.7.2 Proof of Theorem 24 Let α be a simple root of A. The key point is that the finite-input correction enters the characteristic equation as a small radial perturbation of the limiting polynomial. Dividing (30) by l0+nl_0+n, the finite-l0l_0 characteristic equation is G(z,ε):=A(z)−εzA′(z)=0,ε=1l0+n.G(z, ):=A(z)- zA (z)=0, = 1l_0+n. At (z,ε)=(α,0)(z, )=(α,0), we have G(α,0)=0G(α,0)=0 and Gz(α,0)=A′(α)≠0G_z(α,0)=A (α)≠ 0. The analytic implicit-function theorem therefore identifies a unique root branch zα(ε)z_α( ), analytic in ε , with zα(0)=αz_α(0)=α. Differentiating G(zα(ε),ε)=0G(z_α( ), )=0 at ε=0 =0 gives zα′(0)=α.z_α (0)=α. Thus the first-order finite-l0l_0 effect pushes the root radially outward: the direction of motion is the root itself. To obtain the stated remainder, expand one order further. Write zα(ε)=α+αε+c2(α)ε2+O(ε3).z_α( )=α+α +c_2(α) ^2+O( ^3). Substituting this expansion into A(z)−εzA′(z)=0A(z)- zA (z)=0 and matching the ε2 ^2 terms gives c2(α)=α2(αA′(α)A′(α)+2).c_2(α)= α2 ( α A (α)A (α)+2 ). Analyticity of the branch gives the stated O(ε3)O( ^3) remainder on a sufficiently small branch neighborhood. To use this expansion at the threshold scale, we need a uniform bound on the second-order coefficient along the dominant roots. For such a root, write α=ωm,nexp(−μ(xm,θn)/n),|xm|=2π/n.α= _m,n (-μ(x_m, _n)/n), |x_m|=2π/n. Since μ(xm,θn)=O(n−1)μ(x_m, _n)=O(n^-1), we have αa=e−ixme−θnμ(xm,θn)=1+O(n−1).α^a=e^-ix_me^- _nμ(x_m, _n)=1+O(n^-1). Moreover, Pn′(α)=αn−a−1nαa−p(n−a),P_n (α)=α^n-a-1\nα^a-p(n-a)\, and therefore nαa−p(n−a)=nq+pθn+O(n−1).nα^a-p(n-a)=n\q+p _n+O(n^-1)\. Since q+pθn≥q>0q+p _n≥ q>0, |Pn′(α)|≥cn|P_n (α)|≥ cn for large n. Since α≠1α≠ 1, Pn(α)=0P_n(α)=0, and A=−Pn/(1−z)A=-P_n/(1-z) by (29), we have A′(α)=−Pn′(α)1−α.A (α)=- P_n (α)1-α. Moreover, |1−α|=O(n−1)|1-α|=O(n^-1) on the dominant branches, so |A′(α)|≥c′n2|A (α)|≥ c n^2. In particular, the dominant roots are simple uniformly along the coprime family. The same calculation gives Pn′(α)=αn−a−2n(n−1)αa−p(n−a)(n−a−1)=O(n2),P_n (α)=α^n-a-2\n(n-1)α^a-p(n-a)(n-a-1)\=O(n^2), so |Pn′(α)Pn′(α)|=O(n) | P_n (α)P_n (α) |=O(n) uniformly on the dominant branches. Also |1−α|−1=O(n).|1-α|^-1=O(n). Indeed, ωm,n≠1 _m,n≠ 1, the nearest nontrivial n-th root of unity is at distance 2sin(π/n)2 (π/n) from 11, and α−ωm,n=O(n−2)α- _m,n=O(n^-2) on the dominant branches. Since the constant sign in A=−Pn/(1−z)A=-P_n/(1-z) cancels in logarithmic derivatives, A′(α)A′(α)=Pn′(α)Pn′(α)+21−α=O(n). A (α)A (α)= P_n (α)P_n (α)+ 21-α=O(n). Consequently, along each dominant branch, |zα(ε)|=|α|(1+ε+O(nε2)).|z_α( )|=|α| (1+ +O(n ^2) ). The same expansion also identifies the sign of the second-order modulus correction. Write zα(ε)=α(1+ε+dαε2+O(ε3)),dα:=c2(α)α=1+αA′(α)2A′(α).z_α( )=α (1+ +d_α ^2+O( ^3) ), d_α:= c_2(α)α=1+ α A (α)2A (α). Then |zα(ε)|=|α|(1+ε+ℜ(dα)ε2+O(ε3)).|z_α( )|=|α| (1+ + (d_α) ^2+O( ^3) ). We check ℜ(dα)>0 (d_α)>0 on the dominant branches directly. Using A=−Pn/(1−z)A=-P_n/(1-z) at a non-unit root, dα=11−α+αPn′(α)2Pn′(α).d_α= 11-α+ α P_n (α)2P_n (α). Let rα:=αa.r_α:=α^a. The derivative formulas above give the exact identity αPn′(α)Pn′(α)=nrα−p(1−θn)2rα−p(1−θn)−1. α P_n (α)P_n (α)=n\, r_α-p(1- _n)^2r_α-p(1- _n)-1. For dominant roots, rα=e−ixme−θnμ(xm,θn)r_α=e^-ix_me^- _nμ(x_m, _n) with |xm|=2π/n|x_m|=2π/n, so rα=1+O(n−1)r_α=1+O(n^-1). Hence rα−p(1−θn)2rα−p(1−θn)=q+2pθn−pθn2q+pθn+O(n−1). r_α-p(1- _n)^2r_α-p(1- _n)= q+2p _n-p _n^2q+p _n+O(n^-1). The real part of the leading ratio is bounded below by a positive constant uniformly over θn∈[0,1] _n∈[0,1], because q>0q>0 and q+2pθn−pθn2≥q.q+2p _n-p _n^2≥ q. The remaining term has nonnegative real part. Indeed, if α=reiφα=re^i with r<1r<1, then ℜ11−α=1−rcosφ|1−α|2>0. 11-α= 1-r |1-α|^2>0. Consequently the n-order positive term above cannot be offset by (1−α)−1(1-α)^-1. There is a constant c∗>0c_*>0 such that ℜ(dα)≥c∗n (d_α)≥ c_*n on the dominant branches for all sufficiently large n. This proves that the second-order modulus correction is positive. We now pass from the branch expansion to the spectral radius. No genericity assumption on p is needed. The threshold-scale argument only uses the two dominant phases |xm|=2π/n|x_m|=2π/n, whose roots are simple uniformly by the calculation above. Possible multiple roots are non-dominant by Lemma 23; they are already Ω(n−1) (n^-1) inside the unit disk and therefore cannot affect an O(n−3)O(n^-3) crossing. For 0<|xm|≤δ0<|x_m|≤δ, the same logarithmic-coordinate calculation, formalized in Lemma 28 below, gives νm(η)=μ(xm,θn)−η+O(η2),η=nε, _m(η)=μ(x_m, _n)-η+O(η^2), η=n , uniformly in m,a,nm,a,n. Hence |zm(ε)|=|αm|1+ε+O(nε2)|z_m( )|=| _m|\1+ +O(n ^2)\ for all small-phase branches. Among these branches, Proposition 25 shows that the two dominant phases are separated from all other small phases by at least cn−3cn^-3 in limiting modulus. At the threshold scale ε≤En−3 ≤ En^-3, the perturbation error O(nε2)O(n ^2) is only O(n−5)O(n^-5), so the dominant branches remain the only candidates for the spectral radius near the crossing. For |xm|≥δ|x_m|≥δ, Lemma 27 gives ℜμ≥cδ μ≥ c_δ, so the limiting roots are at radial distance Ω(n−1) (n^-1) from the unit circle. By Rouché’s theorem on contours enclosing the corresponding root clusters A−εzA′A- zA has the same multiplicities as A there, and those finite-ε clusters remain at distance Ω(n−1) (n^-1) from the unit circle for ε≤En−3 ≤ En^-3, after reducing E if needed. Combining these estimates yields |ρ(ε)−ρ∞(1+ε)|≤Kρnε2 |ρ( )- _∞(1+ ) |≤ K_ρn ^2 for 0≤ε≤En−30≤ ≤ En^-3, which is (32). Lemma 28 (Uniform finite-input perturbation in logarithmic coordinates). Fix p∈(0,1)p∈(0,1). There are constants δ,η0,C,N>0δ, _0,C,N>0, depending only on p, such that the following holds for all coprime 1≤a<n1≤ a<n, n≥Nn≥ N. For every nonzero phase 0<|xm|≤δ0<|x_m|≤δ, the finite-input equation has a unique logarithmic branch zm,n(η)=ωm,nexp(−νm,n(η)/n),η:=nε,z_m,n(η)= _m,n (- _m,n(η)/n), η:=n , with νm,n(0)=μ(xm,θn) _m,n(0)=μ(x_m, _n), for 0≤η≤η00≤η≤ _0, and νm,n(η)=μ(xm,θn)−η+Rm,n(η),|Rm,n(η)|≤Cη2. _m,n(η)=μ(x_m, _n)-η+R_m,n(η), |R_m,n(η)|≤ Cη^2. The proof is deferred to Appendix C. Lemma 29 (No stable islands before the asymptotic threshold). Let Δn:=1−ρ∞ _n:=1- _∞. There are constants C,N>0C,N>0, depending only on p, such that for all coprime 1≤a<n1≤ a<n, n≥Nn≥ N, the finite-input polynomial is unstable for every physical input value satisfying Δn+CnΔn2≤ε≤1n. _n+Cn _n^2≤ ≤ 1n. Consequently, the first stable integer input length has the same asymptotic location as the local crossing of the two dominant branches. The proof is deferred to Appendix C. B.7.3 Proof of Corollary 26 Let Δn:=1−ρ∞ _n:=1- _∞. Proposition 25 gives Δn=Θ(n−3) _n= (n^-3). By Theorem 24, ρ(ε)=ρ∞(1+ε)+O(nε2).ρ( )= _∞(1+ )+O(n ^2). The proof of Proposition 25 shows that every non-dominant limiting branch is below the dominant modulus by at least cn−3cn^-3. At the threshold scale ε=O(Δn)=O(n−3) =O( _n)=O(n^-3), the finite-l0l_0 perturbation error is O(nε2)=O(nΔn2)=O(n−5),O(n ^2)=O(n _n^2)=O(n^-5), which is smaller than this separation. Thus the dominant branches alone determine the first crossing of the unit circle near the stability threshold: for a sufficiently large constant C, a dominant branch has modulus larger than one whenever ε≥Δn+CnΔn2 ≥ _n+Cn _n^2 within the threshold-scale neighborhood. Lemma 29 extends this instability to the whole physical range above the crossing window, up to ε≤1/n ≤ 1/n. Conversely, all roots lie strictly inside the unit disk whenever ε≤Δn−CnΔn2. ≤ _n-Cn _n^2. The stability boundary is therefore determined up to an O(nΔn2)O(n _n^2) error by 1=ρ∞(1+ε)+O(nε2).1= _∞(1+ )+O(n ^2). Since the boundary has ε=Θ(Δn) = ( _n), this gives ε=Δn+O(n−5),Δnε=1+O(n−2). = _n+O(n^-5), _n =1+O(n^-2). Because ε=(l0+n)−1 =(l_0+n)^-1 is strictly decreasing in l0l_0, the instability interval in Lemma 29 covers every physical integer input length below the local crossing window. Integer rounding in l0l_0 does not affect this order. If the real threshold is s=l0+ns=l_0+n, replacing s by a neighboring integer changes sΔns _n by at most Δn=O(n−3) _n=O(n^-3), which is absorbed by the claimed O(n−2)O(n^-2) tolerance. Using ε=(l0,min+n)−1 =(l_0, +n)^-1, with Lemma 29 ruling out earlier stable islands, yields (l0,min+n)(1−ρ∞)=1+O(n−2),(l_0, +n)(1- _∞)=1+O(n^-2), which is the claimed bound after enlarging the constant. This corollary implies Proposition 4. Indeed, Proposition 25 gives 1−ρ∞=2π2p(1−p)((1−p)+pθn)3n−3+O(n−4),θn=a/n.1- _∞= 2π^2p(1-p)((1-p)+p _n)^3\,n^-3+O(n^-4), _n=a/n. Here and above, for each fixed p∈(0,1)p∈(0,1), the constants in the O(⋅)O(·) terms are uniform in n and in the coprime sequence. The corollary gives l0,min+n=1+O(n−2)1−ρ∞.l_0, +n= 1+O(n^-2)1- _∞. Substituting the spectral-gap expansion and using θn→θ∈[0,1) _n→θ∈[0,1) yields l0,min=((1−p)+pθ)32π2p(1−p)n3+o(n3).l_0, = ((1-p)+pθ)^32π^2p(1-p)\,n^3+o(n^3). Since n=l1,2n=l_1,2, this is exactly the asymptotic threshold stated in Proposition 4. B.8 Extension to Multiple Request Types We first explain the K≥3K≥ 3 extension for request classes with decoding lengths l1,1<⋯<l1,Kl_1,1<·s<l_1,K, proportions p1,…,pKp_1,…,p_K, and a common input length l0l_0. Heterogeneous input lengths are handled separately in Section B.9. Write d:=l1,Kd:=l_1,K. The argument uses the same embedded linearization as in the two-class case; the new object is the survival weight αs _s, which replaces the two-class piecewise normalization. The main substitutions are the following: the class composition at a stage is summarized by αs _s, the memory weight becomes Vs=αs(l0+s+1)V_s= _s(l_0+s+1), and the two-class polynomial is replaced by the survival polynomial in (34). The following paragraphs give the corresponding root-location, finite-input perturbation, and global-convergence checks under these substitutions. B.8.1 Cohort reduction Under per-iteration proportional admission akn=pkana^n_k=p_ka^n and proportional within-stage eviction, the full class-stage occupancy process collapses to a d-dimensional cohort manifold: xk,sn=pkYsn(s<l1,k),xk,sn=0(s≥l1,k),x^n_k,s=p_kY^n_s\;\;(s<l_1,k), x^n_k,s=0\;\;(s≥ l_1,k), for a single vector Yn∈ℝ+dY^n _+^d. Shift preserves within-stage proportions, proportional eviction scales all classes in a mixed stage by the same factor, and proportional admission injects a new mixed cohort. From any feasible initial active state, after at most d iterations all pre-existing requests have completed or been evicted; thereafter every surviving cohort was admitted under the proportional rule, so the process lies on this manifold. Define the survival weight and effective stage weight: αs:=∑k:l1,k>spk,Vs:=αs(l0+s+1),s=0,…,d−1. _s:= _k:l_1,k>sp_k, V_s:= _s(l_0+s+1), s=0,…,d-1. The survival weight αs _s is nonincreasing, with α0=1 _0=1 and αd−1=pK>0 _d-1=p_K>0; it drops exactly at the decoding lengths. Total memory is ∑s=0d−1VsYsn _s=0^d-1V_sY^n_s, and the eviction-free equilibrium is Y∗=x∗Y^*=x^*1, where x∗=M/∑sVsx^*=M/ _sV_s. B.8.2 Characteristic polynomial On the cohort manifold, the linearized no-eviction dynamics have the same companion form as in the two-class case: yn=Φyn−1y^n= y^n-1, with first-row entries −Vj+1/V0-V_j+1/V_0. The nonzero eigenvalues are the roots of Fl0(z)=∑s=0d−1Vszd−1−s=(l0+d)A(z)−zA′(z),F_l_0(z)= _s=0^d-1V_sz^d-1-s=(l_0+d)A(z)-zA (z), where the limiting polynomial is (1−z)A(z)=−zd+∑k=1Kpkzd−l1,k.(1-z)A(z)=-z^d+ _k=1^Kp_kz^d-l_1,k. (34) B.8.3 Root structure of A(z)A(z) All roots of A lie in the closed unit disk. Indeed, if |z|>1|z|>1, then |z|d≤∑kpk|z|d−l1,k<|z|d,|z|^d≤ _kp_k|z|^d-l_1,k<|z|^d, a contradiction. To locate the unit-circle roots, note that gcd(d−l1,1,…,d−l1,K−1,d)=g (d-l_1,1,…,d-l_1,K-1,d)=g: any divisor of d and d−l1,id-l_1,i also divides l1,il_1,i. If |z|=1|z|=1 and A(z)=0A(z)=0, equality in the triangle inequality forces zd−l1,k=1z^d-l_1,k=1 for every k, and Bézout’s identity gives zg=1z^g=1. Since A(1)=∑kpkl1,k>0A(1)= _kp_kl_1,k>0, only non-trivial g-th roots can be roots of A. At each such root ω, differentiating (34) gives (1−ω)A′(ω)=−ω−1∑kpkl1,k,(1-ω)A (ω)=-ω^-1 _kp_kl_1,k, so A′(ω)≠0A (ω)≠ 0. B.8.4 Instability when g>1g>1 Each non-trivial g-th root ω satisfies A(ω)=0A(ω)=0 and A′(ω)≠0A (ω)≠ 0. Applying the implicit-function theorem to G(z,ε)=A(z)−εzA′(z),ε=1l0+d,G(z, )=A(z)- zA (z), = 1l_0+d, gives z′(0)=ωz (0)=ω, and hence z(ε)=ω(1+ε)+O(ε2).z( )=ω(1+ )+O( ^2). Thus the finite-input correction induces the same outward radial drift as in the two-class system. Each unit-circle root moves outside the unit disk for sufficiently small positive ε , producing g−1g-1 unstable eigenvalues. B.8.5 Local stability when g=1g=1 When g=1g=1, all roots of A lie strictly inside the unit circle. Let r∗:=maxj|αj|<1r_*:= _j| _j|<1, and choose ρ∈(r∗,1)ρ∈(r_*,1). On |z|=ρ|z|=ρ, |A(z)|≥mρ>0|A(z)|≥ m_ρ>0, while |εzA′(z)|≤εMρ| zA (z)|≤ M_ρ. For l0l_0 large enough that εMρ<mρ M_ρ<m_ρ, Rouché’s theorem implies that Fl0/(l0+d)F_l_0/(l_0+d) and A have the same number of roots in |z|<ρ|z|<ρ, namely all d−1d-1. Therefore ρ(Φ)≤ρ<1ρ( )≤ρ<1. B.8.6 Global convergence when g=1g=1 The global-convergence check follows the structure of Section B.6 after replacing the two-class normalization weights by αs _s. The only points that require checking are the population bound, the size of the eviction perturbation, and the no-eviction neighborhood. All three checks use the same estimates as in the two-class proof. Since αs≥pK>0 _s≥ p_K>0, the in-service population Nn=∑sαsYsn≤Ml0+1N^n= _s _sY^n_s≤ Ml_0+1 is O(1)O(1), uniformly in K. Each shift increases memory by at most NnN^n tokens. Restoring feasibility therefore requires evicting only O(1/l0)O(1/l_0) requests per step, so the perturbation from the no-eviction linearized dynamics satisfies ‖en‖2=O(1/l0)\|e^n\|_2=O(1/l_0) in the Y-coordinates. The Schur bound for Φ gives the Lyapunov function ℒ(y)=y⊤PyL(y)=y Py with I⪯P⪯CPI P C_PI; here CPC_P may depend on the fixed K-class instance but not on l0l_0. Therefore ℒ(yn)−ℒ(yn−1)≤−‖yn−1‖22+O(1/l0).L(y^n)-L(y^n-1)≤-\|y^n-1\|_2^2+O(1/l_0). For ‖yn−1‖2≥δ\|y^n-1\|_2≥δ, this drift is strictly negative when l0l_0 is large enough. The no-eviction neighborhood is obtained exactly as in the two-class proof: the equilibrium leaves a stage-0 admission margin of order l0l_0, while the memory deviation is at most O(l0‖y‖2)O(l_0\|y\|_2). Choosing δ>0δ>0 small enough therefore rules out eviction whenever ‖y‖2<δ\|y\|_2<δ. Since ℒ≥0L≥ 0, the embedded trajectory reaches this neighborhood in finite time. Thereafter en=0e^n=0, and the Schur-stable linear dynamics imply exponential convergence. B.8.7 Spectral gap scaling for K≥3K≥ 3 The log-coordinate parameterization of Section B.7.1 extends to K classes. For the polynomial (34), write n:=l1,Kn:=l_1,K and parameterize the u-th branch as z=ωuexp(−μ/n)z= _u (-μ/n), where ωu _u is an n-th root of unity. The branch equation becomes ∑k=1Kpkeixk(u)eβk,nμ=1,xk(u):=−2πul1,kn(mod2π), _k=1^Kp_ke^ix_k(u)e _k,nμ=1, x_k(u):=- 2π ul_1,kn\!\! 2π, with βk,n:=l1,k/n _k,n:=l_1,k/n and xK(u)=0x_K(u)=0. The implicit-function theorem gives a local branch μ(x)μ(x) with ℜμ(x)=12D∑k=1Kpk(xk−βkx¯)2+O(‖x‖3),D:=∑kpkβk,x¯:=∑kpkxkD. μ(x)= 12D _k=1^Kp_k (x_k- _k x )^2+O(\|x\|^3), D:= _kp_k _k, x:= _kp_kx_kD. The quadratic term is positive definite; in particular, the k=Kk=K term contributes pKx¯2p_K x^2. Thus the spectral gap is governed by the smallest nonzero value of ℜμ μ over the discrete phases x(u)x(u), u=1,…,n−1u=1,…,n-1. Fixed shorter lengths. If l1,1,…,l1,K−1l_1,1,…,l_1,K-1 are fixed and n→∞n→∞, the branch u∗u^* satisfying gcd(l1,1,…,l1,K−1)u∗≡1(modn) (l_1,1,…,l_1,K-1)\,u^*≡ 1 n yields phases xk=O(1/n)x_k=O(1/n). The resulting gap has the cubic scaling 1−ρ∞=cfixn−3+O(n−4),cfix=2π2pK∑k=1K−1pk(ak#)2+2π2pK2(∑k=1K−1pkak#)2,1- _∞=c_fix\,n^-3+O(n^-4), c_fix= 2π^2p_K _k=1^K-1p_k(a_k^\#)^2+ 2π^2p_K^2 ( _k=1^K-1p_ka_k^\# )^2, where ak#:=l1,k/gcd(l1,1,…,l1,K−1)a_k^\#:=l_1,k/ (l_1,1,…,l_1,K-1). For K=2K=2, this reduces to 2π2p/q22π^2p/q^2. Bounded resonance. More generally, suppose there exist a fixed integer u¯ u and bounded integers c1,…,cK−1c_1,…,c_K-1 such that u¯l1,k≡ck(modn) ul_1,k≡ c_k n for all k. Then 1−ρ∞=cresn−3+O(n−4),cres=2π2D∑k=1Kpk(ck−βk∑jpjcjD)2,1- _∞=c_res\,n^-3+O(n^-4), c_res= 2π^2D _k=1^Kp_k (c_k- _k _jp_jc_jD )^2, with cK:=0c_K:=0. This includes near-consecutive families such as (n,n+1,…,n+K−1)(n,n+1,…,n+K-1). Generic ratios. When no bounded resonance exists, the minimizing branch index grows with n. The gap exponent then depends on the simultaneous Diophantine approximation properties of (β1,…,βK−1)( _1,…, _K-1). The numerical evidence is consistent with the generic exponent 1+2/(K−1)1+2/(K-1), giving α=2α=2 for K=3K=3 and α=5/3α=5/3 for K=4K=4. A proof of this generic exponent remains open. B.9 Heterogeneous Input Lengths We now justify Remark 2. The common-input proof above sets l0,1=l0,2l_0,1=l_0,2 only to keep the recurrence and polynomial notation light. The heterogeneous-input case differs only in the memory weights carried by surviving cohorts, not in the completion phases. If heterogeneous inputs scale as l0,k=rkL+O(1),rk>0,l_0,k=r_kL+O(1), r_k>0, then the same cohort-balance derivation replaces the common-input limiting polynomial by a weighted survival polynomial. For K classes, let R=∑k=1KpkrkR= _k=1^Kp_kr_k and l1,K=maxkl1,kl_1,K= _kl_1,k. The limiting polynomial can be written as Ar(z)=∑m=0l1,K−1(∑k:l1,k>mpkrk)zl1,K−1−m,A_r(z)= _m=0^l_1,K-1 ( _k:\,l_1,k>mp_kr_k )z^l_1,K-1-m, or equivalently, (1−z)Ar(z)=−Rzl1,K+∑k=1Kpkrkzl1,K−l1,k.(1-z)A_r(z)=-Rz^l_1,K+ _k=1^Kp_kr_k\,z^l_1,K-l_1,k. Thus heterogeneous inputs do not change the timing exponents l1,K−l1,kl_1,K-l_1,k; they only replace the class probabilities pkp_k by positive weights pkrkp_kr_k in the survival coefficients. The triangle inequality argument used in Lemmas 10–13 therefore carries over after normalizing by R: equality on the unit circle still forces all active phases zl1,kz^l_1,k to agree, which is exactly the same root-of-unity condition governed by gcd(l1,1,…,l1,K) (l_1,1,…,l_1,K). The remaining steps follow the same outline as in the common-input proof, with constants changed by the weights pkrkp_kr_k. For g>1g>1, the non-trivial g-th roots still satisfy Ar(ω)=0A_r(ω)=0, and differentiating the weighted closed form gives (1−ω)Ar′(ω)=−ω−1∑k=1Kpkrkl1,k≠0.(1-ω)A_r (ω)=-ω^-1 _k=1^Kp_kr_kl_1,k≠ 0. The corresponding finite-L perturbation has a positive radial first-order coefficient, whose value depends on pkp_k and rkr_k, so the same root-of-unity mechanism produces outward drift. For g=1g=1, all non-equilibrium limiting roots are strictly inside the unit disk, so Rouché’s theorem keeps the finite-L roots inside for sufficiently large L. The global Lyapunov step is checked by the same estimates: because each rk>0r_k>0 is fixed, all effective stage weights are Θ(L) (L), the active population remains O(1)O(1), and each eviction perturbation is O(1/L)O(1/L). Thus heterogeneous inputs change constants through the positive ratios rkr_k, while preserving the spectral and Lyapunov mechanisms used in the two-class common-input case. Remark 3 (Stable initial conditions in non-coprime systems). When g>1g>1, some initial conditions remain stable because the instability is spectral rather than global across all directions. The general solution admits a Vandermonde decomposition into the equilibrium mode z0=1z_0=1, unstable modes z1,…,zg−1z_1,…,z_g-1 with |zj|>1|z_j|>1, and stable modes zg,…,zl1,2−1z_g,…,z_l_1,2-1 with |zj|<1|z_j|<1. Stability holds exactly when the initial perturbation has no projection onto the unstable subspace. The equilibrium X∗=x∗(1,…,1)⊤X^*=x^*(1,…,1) itself lies outside that unstable subspace. B.10 Pulse Cycle This subsection gives a complementary finite-l0l_0 calculation for the non-coprime case g>1g>1. The finite-exit result above shows that synchronized GCD modes push generic local perturbations out of the no-eviction neighborhood; the instance below makes the resulting recurrent-eviction behavior explicit by exhibiting a two-class common-input pulse cycle and computing its local return map. Recall that we require a1n=pan,a2n=qana^n_1=pa^n, a^n_2=qa^n at every iteration. If LPF partially evicts a mixed stage, it removes classes 1 and 2 in proportion to their occupancies in that stage. Lemma 30 (Cohort reduction for the strict mixing rule). Consider the two-class common-input system with decoding lengths l1,1<l1,2l_1,1<l_1,2, and write a:=l1,1a:=l_1,1 and b:=l1,2b:=l_1,2. Under strict per-iteration proportional admission and proportional within-stage eviction, the class-stage process admits a scalar cohort representation yjny^n_j such that x1,jn=pyjn,j<a,0,j≥a,x2,jn=qyjn,0≤j≤b−1.x^n_1,j= casesp\,y^n_j,&j<a,\\ 0,&j≥ a, cases x^n_2,j=q\,y^n_j, 0≤ j≤ b-1. Moreover, the normalized variables of the coprime proof satisfy Yjn=yjn,0≤j≤b−1,Y^n_j=y^n_j, 0≤ j≤ b-1, and the resulting cohort dynamics have effective weights Vj=l0+1+j,0≤j≤a−1,q(l0+1+j),a≤j≤b−1.V_j= casesl_0+1+j,&0≤ j≤ a-1,\\ q(l_0+1+j),&a≤ j≤ b-1. cases The proof is deferred to Appendix C. Proposition 31 (Two-class common-input exact pulse cycle). Assume g=gcd(a,b)>1g= (a,b)>1, and write h:=b/gh:=b/g. For r=0,…,g−1r=0,…,g-1, define Jr=r,r+g,…,r+(h−1)g,β=M∑m=0h−1Vg−1+mg,J_r=\r,r+g,…,r+(h-1)g\, β= M _m=0^h-1V_g-1+mg, and αr=M−β∑m=1h−1Vr+mgVr. _r= M-β _m=1^h-1V_r+mgV_r. Let Z(r)∈ℝbZ^(r) ^b be the state whose only nonzero coordinates are Zr(r)=αr,Zr+mg(r)=β,m=1,…,h−1.Z^(r)_r= _r, Z^(r)_r+mg=β, m=1,…,h-1. Then Z(0)→Z(1)→⋯→Z(g−1)→Z(0)Z^(0)→ Z^(1)→·s→ Z^(g-1)→ Z^(0) is an exact period-g orbit. Its average throughput is T¯pulse=2Ma(2l0+a+g)+q(b−a)(2l0+a+b+g). T_pulse= 2Ma(2l_0+a+g)+q(b-a)(2l_0+a+b+g). Proof. Write u=l0+1u=l_0+1. For r=0,…,g−1r=0,…,g-1, let Sr:=∑m=1h−1Vr+mg.S_r:= _m=1^h-1V_r+mg. Then αr=(M−βSr)/(u+r) _r=(M-β S_r)/(u+r). Within each branch of the weight profile, Vj+g−VjV_j+g-V_j is constant, so Sr=S0+cr,c=ag−1+q(bg−ag)≥0.S_r=S_0+cr, c= ag-1+q\! ( bg- ag )≥ 0. Hence αr−αr+1=M−βS0+βcu(u+r)(u+r+1)>0for r=0,…,g−2, _r- _r+1= M-β S_0+β cu(u+r)(u+r+1)>0 r=0,…,g-2, because M−βS0=V0α0>0M-β S_0=V_0 _0>0. Also, αg−1=M−β∑m=1h−1Vg−1+mgVg−1=β. _g-1= M-β _m=1^h-1V_g-1+mgV_g-1=β. Fix r≤g−2r≤ g-2. Starting from Z(r)Z^(r), the execute step shifts the support from JrJ_r to Jr+1J_r+1. The youngest occupied age r+1r+1 carries mass αr _r, and all older occupied ages in Jr+1J_r+1 carry mass β. The post-execute memory exceeds M by exactly Vr+1(αr−αr+1)>0.V_r+1( _r- _r+1)>0. This overflow is smaller than the full youngest-stage load Vr+1αrV_r+1 _r. Hence LPF trims only the youngest occupied age, reducing its mass from αr _r to αr+1 _r+1. No new admission occurs, so the next state is Z(r+1)Z^(r+1). At phase r=g−1r=g-1, every occupied age already carries mass β. Execute removes the age-(b−1)(b-1) cohort, shifts the remaining h−1h-1 cohorts to ages g,2g,…,(h−1)g,2g,…,(h-1)g, and creates slack M−∑m=1h−1Vmgβ=V0α0.M- _m=1^h-1V_mgβ=V_0 _0. No eviction is needed. Admission therefore inserts a new age-0 cohort of mass α0 _0, reconstructing Z(0)Z^(0). Finally, ∑m=0h−1Vg−1+mg=a(2l0+a+g)+q(b−a)(2l0+a+b+g)2g. _m=0^h-1V_g-1+mg= a(2l_0+a+g)+q(b-a)(2l_0+a+b+g)2g. Since one cohort of mass β completes every g iterations, T¯pulse=βg=2Ma(2l0+a+g)+q(b−a)(2l0+a+b+g). T_pulse= βg= 2Ma(2l_0+a+g)+q(b-a)(2l_0+a+b+g). □ Proposition 32 (Local return map for the two-class pulse cycle). In a neighborhood of the pulse cycle from Proposition 31, the phase maps are affine. For r=0,…,g−2r=0,…,g-2, if z=(z0,…,zh−1)z=(z_0,…,z_h-1) denotes the masses on the support JrJ_r, then Φr(z0,…,zh−1)=(M−∑m=1h−1Vr+1+mgzmVr+1,z1,…,zh−1). _r(z_0,…,z_h-1)= ( M- _m=1^h-1V_r+1+mgz_mV_r+1,z_1,…,z_h-1 ). At the wrap phase, Φg−1(z0,…,zh−1)=(M−∑m=1h−1Vmgzm−1V0,z0,…,zh−2). _g-1(z_0,…,z_h-1)= ( M- _m=1^h-1V_mgz_m-1V_0,z_0,…,z_h-2 ). Let ℛ=Φg−1∘⋯∘Φ0R= _g-1 ·s _0 be the g-step return map at phase 0. Then DℛDR has one exact zero eigenvalue, and its remaining eigenvalues are the roots of the compressed two-class polynomial F^(z)=∑m=0a/g−1(l0g+1+m)zh−1−m+q∑m=a/gh−1(l0g+1+m)zh−1−m. F(z)= _m=0^a/g-1 ( l_0g+1+m )z^h-1-m+q _m=a/g^h-1 ( l_0g+1+m )z^h-1-m. (35) Proof. The first point is local branch consistency. The strict inequalities that define the pulse cycle also define an open neighborhood on which the LPF branch does not change. The strict inequalities αr>αr+1 _r> _r+1 for r≤g−2r≤ g-2, together with α0>0 _0>0, persist in a small neighborhood of each phase state. On that neighborhood, the LPF trim pattern is fixed: for r≤g−2r≤ g-2, only the youngest occupied age is partially trimmed; for r=g−1r=g-1, no eviction occurs and admission fills the slack at age 0. The displayed affine maps follow directly from execute, LPF trim, and admission. We next reduce the g-phase return map to the nontrivial coordinates. Now write x=(x0,…,xh−2):=(z1,…,zh−1),Wm:=Vg−1+mg,m=0,…,h−1.x=(x_0,…,x_h-2):=(z_1,…,z_h-1), W_m:=V_g-1+mg, m=0,…,h-1. Every non-wrap phase deletes the current youngest coordinate and leaves the older coordinates unchanged. Therefore the g-step return map is determined by x alone: ℛred(x0,…,xh−2)=(M−∑m=1h−1Wmxm−1W0,x0,…,xh−3).R_red(x_0,…,x_h-2)= ( M- _m=1^h-1W_mx_m-1W_0,x_0,…,x_h-3 ). Its Jacobian is the companion matrix K=(−W1/W0−W2/W0⋯−Wh−1/W010⋯001⋱0⋮⋱⋮00⋯10),K= pmatrix-W_1/W_0&-W_2/W_0&·s&-W_h-1/W_0\\ 1&0&·s&0\\ 0&1& &0\\ && & \\ 0&0&·s&1&0 pmatrix, so the full Jacobian has block form Dℛ=(0∗0K),DR= pmatrix0&*\\ 0&K pmatrix, This block-triangular form gives one exact zero eigenvalue. The remaining h−1h-1 eigenvalues are the roots of the characteristic polynomial of K. It remains only to identify this companion polynomial. The dictionary is the compressed coprime two-class dictionary a¯:=a/g,b¯:=b/g=h,ℓ0:=l0/g, a:=a/g, b:=b/g=h, _0:=l_0/g, with effective weights sampled along the g-spaced pulse support, Wm:=Vg−1+mgW_m:=V_g-1+mg. In these variables, Wmg=Vg−1+mg=ℓ0+1+m,0≤m≤a¯−1,q(ℓ0+1+m),a¯≤m≤b¯−1, W_mg= V_g-1+mgg= cases _0+1+m,&0≤ m≤ a-1,\\ q( _0+1+m),& a≤ m≤ b-1, cases so the companion polynomial of K is exactly F^(z)=∑m=0a¯−1(ℓ0+1+m)zb¯−1−m+q∑m=a¯b¯−1(ℓ0+1+m)zb¯−1−m, F(z)= _m=0 a-1( _0+1+m)z b-1-m+q _m= a b-1( _0+1+m)z b-1-m, which is (35). □ Corollary 33 (Local pulse stability). The pulse cycle from Proposition 31 is locally asymptotically stable if and only if the polynomial F F in (35) is Schur stable. In particular, for generic q∈(0,1)q∈(0,1) and sufficiently large l0l_0, the pulse cycle is locally asymptotically stable. Proof. The local return map is affine in a neighborhood of the pulse cycle, so local asymptotic stability is equivalent to ρ(Dℛ)<1ρ(DR)<1. Proposition 32 reduces this condition to ρ(K)<1ρ(K)<1, equivalently Schur stability of F F. Thus the compressed polynomial gives the local stability criterion for this recurrent- eviction pulse cycle. The final claim follows because the compressed pair (a¯,b¯)=(a/g,b/g)( a, b)=(a/g,b/g) is coprime, and the proof of Theorem 17 depends only on the coefficient profile of the polynomial. Applying that argument to F F gives Schur stability for generic q and sufficiently large ℓ0=l0/g _0=l_0/g, hence for sufficiently large l0l_0. □ Example 12 (Pulse return map for (2,4)(2,4)). Let a=2a=2, b=4b=4, and g=2g=2. At phase 0, the state is z=(x,y)z=(x,y) on ages 0 and 22, and Φ0(x,y)=(M−V3yV1,y)=(M−q(l0+4)yl0+2,y). _0(x,y)= ( M-V_3yV_1,y )= ( M-q(l_0+4)yl_0+2,y ). At phase 11, the state is (u,v)(u,v) on ages 11 and 33, and Φ1(u,v)=(M−V2uV0,u)=(M−q(l0+3)ul0+1,u). _1(u,v)= ( M-V_2uV_0,u )= ( M-q(l_0+3)ul_0+1,u ). Therefore D(Φ1∘Φ0)=(0V2V3V0V10−V3V1),D( _1 _0)= pmatrix0& V_2V_3V_0V_1\\[8.0pt] 0&- V_3V_1 pmatrix, so the eigenvalues are z1=0,z2=−V3V1=−q(l0+4)l0+2.z_1=0, z_2=- V_3V_1=- q(l_0+4)l_0+2. Hence the exact local stability condition is q<l0+2l0+4.q< l_0+2l_0+4. For the symmetric case p=q=1/2p=q=1/2, this inequality holds for every l0≥1l_0≥ 1. B.11 Summary This appendix proves Theorem 3 in the two-class common-input normalization and explains the corresponding extension arguments: 1. The characteristic polynomial decomposes as F(z)=(l0+l1,2)A(z)−zA′(z)F(z)=(l_0+l_1,2)A(z)-zA (z). 2. Roots of A(z)A(z) on the unit circle are exactly the non-trivial g-th roots of unity (Lemmas 10–13). 3. For g>1g>1: IFT shows these roots drift outside the unit circle, causing instability (Theorem 14). 4. For g=1g=1: All roots remain inside the unit circle; Lyapunov analysis proves global convergence from any feasible initial active state in the saturated-input model (Theorems 17 and 22). 5. The non-coprime two-class system also admits an exact period-g pulse cycle whose local return-map eigenvalues are given by a compressed coprime polynomial (Section B.10). 6. The K≥3K≥ 3 and heterogeneous-input discussions use the same survival-polynomial argument with positive class weights (Sections B.8–B.9). Appendix C Proofs of Auxiliary Lemmas This appendix collects the proofs of the auxiliary lemmas used in Appendices A and B. The lemma statements are kept in the main proof flow, while the technical details are gathered here. C.1 Proof of Lemma A.1 Proof of Lemma A.1. Under eviction-free operation, the memory boundary is preserved and the stage-0 admission satisfies (l0+1)x0n+1=(l0+l1)xl1−1n−∑j=0l1−2xjn.(l_0+1)x^n+1_0=(l_0+l_1)x^n_l_1-1- _j=0^l_1-2x^n_j. (36) Rewriting gives x0n+1=xl1−1n+l1xl1−1n−∑j=0l1−1xjnl0+1.x^n+1_0=x^n_l_1-1+ l_1x^n_l_1-1- _j=0^l_1-1x^n_jl_0+1. (37) For j≥1j≥ 1, the shift relation xjn+1=xj−1nx^n+1_j=x^n_j-1 preserves all non-final stage values. Therefore the only new coordinate is x0n+1x^n+1_0. If the maximum is attained at some stage j≤l1−2j≤ l_1-2, then the same value reappears at stage j+1j+1, so x¯n+1≥x¯n x^n+1≥ x^n. If the maximum is attained at the final stage, then xl1−1n≥∑jxjn/l1x^n_l_1-1≥ _jx^n_j/l_1, and (37) gives x0n+1≥xl1−1n=x¯n.x^n+1_0≥ x^n_l_1-1= x^n. Hence x¯n+1≥x¯n x^n+1≥ x^n. The minimum is similar. If it is attained at some stage j≤l1−2j≤ l_1-2, it shifts unchanged to stage j+1j+1, so x¯n+1≤x¯n x^n+1≤ x^n. If it is attained at the final stage, then xl1−1n≤∑jxjn/l1x^n_l_1-1≤ _jx^n_j/l_1, and (37) gives x0n+1≤xl1−1n=x¯n.x^n+1_0≤ x^n_l_1-1= x^n. Hence x¯n+1≤x¯n x^n+1≤ x^n, and so Gn+1≥GnG^n+1≥ G^n. □ C.2 Proof of Lemma A.2 Proof of Lemma A.2. Suppose the system stays eviction-free. The argument has three parts. First, the running maximum must converge if no eviction ever occurs. Second, whenever a near-maximum cohort reaches the final stage, the balance equation creates a new admission that jumps a fixed positive amount above the current maximum. Third, convergence forces such near-maximum final-stage events to occur along late renewals, which contradicts the fixed jump. By Lemma A.1, the running maximum x¯n x^n is non-decreasing. The memory constraint implies x¯n(l0+1)≤∑j=0l1−1(l0+1+j)xjn=M. x^n(l_0+1)≤ _j=0^l_1-1(l_0+1+j)x^n_j=M. Thus x¯n x^n is bounded and converges; in particular x¯n+1−x¯n→0 x^n+1- x^n→ 0. We next quantify the jump that occurs when the final stage is close to the running maximum. Fix a time n, write an:=x¯n−xl1−1n≥0a_n:= x^n-x^n_l_1-1≥ 0, and set Sn:=∑j=0l1−1(x¯n−xjn).S_n:= _j=0^l_1-1( x^n-x^n_j). Since Gn≥G0G^n≥ G^0, we have Sn≥G0S_n≥ G^0. Rewriting (37) relative to x¯n x^n gives x0n+1−x¯n=Sn−(l0+l1+1)anl0+1.x^n+1_0- x^n= S_n-(l_0+l_1+1)a_nl_0+1. (38) Consequently, whenever the final-stage coordinate is within G0/[2(l0+l1+1)]G^0/[2(l_0+l_1+1)] of the running maximum, the next admission exceeds the current maximum by at least G0/[2(l0+1)]G^0/[2(l_0+1)]. It remains to connect this local jump estimate to the long-run trajectory. A cohort that attains the running maximum has two possibilities before it reaches the final stage. If no larger admission appears first, then the cohort reaches stage l1−1l_1-1 still attaining the running maximum, and the preceding paragraph gives the fixed positive jump. If a larger admission appears first, then the running maximum has already increased, and we restart the same argument from this newer maximizing cohort. Thus the only way to avoid the fixed jump would be to keep renewing the running maximum before the tracked cohort reaches the final stage. That last possibility is also incompatible with convergence. Since x¯n x^n is monotone and convergent, for every fixed window length q, x¯n+q−x¯n→0. x^n+q- x^n→ 0. Apply this with q=l1−1q=l_1-1 along sufficiently late renewal times. During the next l1−1l_1-1 iterations, the tracked cohort advances from its admission stage to the final stage, while the running maximum can increase only by o(1)o(1). Therefore, for all sufficiently late renewals, that cohort reaches the final stage within G0/[2(l0+l1+1)]G^0/[2(l_0+l_1+1)] of the then-current running maximum. The jump estimate (38) then forces a new increase of at least G0/[2(l0+1)]G^0/[2(l_0+1)], contradicting x¯n+1−x¯n→0 x^n+1- x^n→ 0. Hence the eviction-free regime must break down in finite time. The resulting LPF eviction creates the first eviction-induced support loss in the relative-position representation, moving the trajectory from full support to the next lower live-support level. Since the fixed point is the unique eviction-free boundary state with G0=0G^0=0, it is unstable. □ C.3 Proof of Lemma A.3 Proof of Lemma A.3. Zero mass shifts as zero, so PrP_r remains empty until it next reaches the final stage. Starting from the boundary M, every other live position increases its footprint by one token during execute, while PrP_r’s completion releases zero memory. The post-execution memory is therefore M~n=M+∑q≠rzqn>M. M^n=M+ _q≠ rz^n_q>M. In the continuous formulation of Section 2, LPF eviction may trim a fractional amount and restores the total to exactly M, leaving no slack for admission: the new stage-0 batch is zero. That batch is exactly the mass that would have been assigned to PrP_r after wrap-around, so zrn+1=0z^n+1_r=0. Repeating the argument each time PrP_r returns to stage 0 shows that PrP_r never revives. □ C.4 Proof of Lemma A.6 Proof of Lemma A.6. Let u¯:=minhuh,u¯:=maxhuh. u:= _hu_h, u:= _hu_h. The shifted coordinates u0,…,um−2u_0,…,u_m-2 reappear unchanged in Y′Y , so only the loss of the oldest value um−1u_m-1 can reduce the spread. If um−1u_m-1 is neither the unique maximum nor the unique minimum, then both u¯ u and u¯ u remain among the shifted coordinates, so the spread cannot decrease. If um−1=u¯u_m-1= u, then every term um−1−uhu_m-1-u_h in (18) is nonnegative, hence u0′≥u¯u _0≥ u. The old minimum remains among the shifted coordinates, so Gsc(Y′)≥u¯−u¯=Gsc(Y).G^sc(Y )≥ u- u=G^sc(Y). If Gsc(Y)>0G^sc(Y)>0, then some uh<u¯u_h< u, so the numerator in (18) is strictly positive and u0′>u¯u _0> u; thus the spread strictly grows. The case um−1=u¯u_m-1= u is symmetric: every term in the numerator of (18) is nonpositive, so u0′≤u¯u _0≤ u, while the old maximum remains among the shifted coordinates. Therefore the spread again cannot decrease, and it is strict when Gsc(Y)>0G^sc(Y)>0. □ C.5 Proof of Lemma A.8 Proof of Lemma A.8. Suppose, toward contradiction, that the support pattern remains fixed forever. The proof mirrors Lemma A.2, but now on the block-end chain and in the normalized coordinates uh=yh/ghu_h=y_h/g_h. We first obtain a convergent running maximum, then show that an oldest coordinate close to that maximum creates a uniform positive jump, and finally use convergence to force such close-oldest events along late renewals. Index the sampled states by r, and write Ur:=maxhuhr,Gr:=Gsc(Yr).U^r:= _hu^r_h, G^r:=G^sc(Y_r). The proof of Lemma A.6 shows that UrU^r is non-decreasing. Since uhr∈[0,M/(l0+1)]u^r_h∈[0,M/(l_0+1)], UrU^r is bounded and therefore converges; hence Ur+1−Ur→0U^r+1-U^r→ 0. Also Gr≥G0>0G^r≥ G^0>0 by Lemma A.6. We now isolate the one-step estimate that drives the contradiction. At a sampled step r, let the oldest normalized coordinate be um−1ru^r_m-1, and set ar:=Ur−um−1ra_r:=U^r-u^r_m-1. Define Sr:=∑h=0m−2gh(Ur−uhr).S_r:= _h=0^m-2g_h\,(U^r-u^r_h). If ar≤G0/[2(l0+l1)]a_r≤ G^0/[2(l_0+l_1)], then the oldest coordinate is not the minimum, so a minimum-attaining coordinate survives among h=0,…,m−2h=0,…,m-2, and Sr≥Gr≥G0S_r≥ G^r≥ G^0. Rewriting (18) relative to UrU^r gives u0r+1−Ur=Sr−(l0+l1)arl0+gm−1.u^r+1_0-U^r= S_r-(l_0+l_1)a_rl_0+g_m-1. (39) Thus, whenever the oldest coordinate is within G0/[2(l0+l1)]G^0/[2(l_0+l_1)] of the running maximum, the new coordinate exceeds the current maximum by at least G0/[2(l0+l1)]G^0/[2(l_0+l_1)]. It remains to show that the hypothesis of this estimate must hold arbitrarily late. Follow any coordinate that attains the running maximum. If it reaches the oldest slot before a larger newly created coordinate appears, then the estimate above gives the fixed positive jump. If a larger coordinate appears first, then UrU^r has already increased and we restart the tracking argument from this new coordinate. Hence avoiding the fixed jump would require infinitely many such renewals. But infinite late renewals are also impossible under convergence. Since UrU^r is monotone and convergent, for the fixed window length m−1m-1, Ur+m−1−Ur→0.U^r+m-1-U^r→ 0. After a renewal at sampled time r, the renewing coordinate reaches the oldest slot within at most m−1m-1 sampled steps unless an even larger renewal occurs first, in which case we restart from that later and larger coordinate. Along sufficiently late renewals, the total increase of UrU^r during this window is less than G0/[2(l0+l1)]G^0/[2(l_0+l_1)]. Therefore the tracked coordinate reaches the oldest slot within G0/[2(l0+l1)]G^0/[2(l_0+l_1)] of the then-current running maximum, and (39) again forces a fixed positive jump. This contradicts Ur+1−Ur→0U^r+1-U^r→ 0. Therefore the fixed-support affine continuation cannot remain in the positive orthant forever. The final step is to translate this affine contradiction back to the physical LPF dynamics. On a fixed support pattern, Proposition A.4 gives the affine block-end update only on the branch where every live coordinate stays positive and LPF trims only the prescribed least-progressed mass during the intervening eviction block. Leaving the positive orthant is therefore exactly reaching a branch boundary: some live mass is exhausted by LPF. At that boundary yh=ghuh=0y_h=g_hu_h=0 for at least one live position, and by Lemma A.3 the emptied relative position cannot revive. Thus the next sampled state lies on a strictly smaller support pattern after finitely many sampled steps. □ C.6 Proof of Lemma A.9 Proof of Lemma A.9. If |I|=1|I|=1, the trajectory is already on the single-live-position stratum and cannot be captured by a nonmaximal orbit, so the claim is empty. Assume |I|≥2|I|≥ 2. We prove first that, for each fixed finite horizon, the set of initial states captured by a nonmaximal balanced orbit by that horizon has relative Lebesgue measure zero in ℬIB_I. The desired claim then follows by taking the countable union over horizons. The finite-horizon proof has four steps. First, finite-time capture can be checked at a block-end representative of the eventual balanced orbit. Second, the LPF dynamics on a fixed finite horizon split the initial face into finitely many affine branch cells, after discarding lower-dimensional branch boundaries. Third, on each nondegenerate branch cell, the corresponding branch map is built from affine isomorphisms and affine submersions, so preimages of relative-measure-zero target sets remain relative-measure-zero. Fourth, the nonmaximal balanced targets form only finitely many points in each positive-dimensional target face. Step 1: finite-time capture and boundary faces. Here “captured” means that the trajectory equals a state on the balanced orbit from some finite time onward. For finite-time capture at an arbitrary physical phase, passing to the next block-end gives the corresponding balanced sampled representative. By Lemma A.3 the live-position set can only shrink, and on any eventual live set of size m≥2m≥ 2, the block-end chain is governed by Proposition A.4: either Gsc=0G^sc=0, in which case the sampled state is the balanced representative and determines the full periodic orbit, or Gsc>0G^sc>0, in which case Lemma A.8 forces another support loss in finite time. In the rest of the proof, “measure zero” always means zero relative Lebesgue measure on the affine hull of the current memory-boundary face. Step 2: finite-horizon branch cells. Fix a finite horizon T. Up to time T, only finitely many LPF branches are possible: at each step, a branch records the current support pattern and, whenever LPF evicts, the ordered set of stages exhausted by eviction together with the unique stage that is partially trimmed. On any fixed branch, all LPF ordering inequalities and positivity inequalities are fixed, so the execute–evict–admit update is affine on the relative interior of that branch cell. We first remove the branch boundaries. These are the states where one of the strict branch inequalities becomes an equality: an eviction depth exactly exhausts a stage, the eviction stops with no positive partially trimmed survivor, or the partial trim has zero size. For a fixed step and a fixed branch history, each such equality is affine in the current branch coordinates, so it defines a proper affine face unless it is empty. There are only finitely many such faces up to horizon T. Their preimages in the initial face also have measure zero by the pullback argument of Step 3 below. Thus, after discarding a finite union of relative-measure-zero sets, it suffices to work on the relative interiors of nondegenerate branch cells. On such a cell, we group fixed-support physical steps into the exact block-end map from Proposition A.4 and treat support-loss steps separately; equivalently, the finite-horizon map is a finite composition of elementary execute–evict–admit affine pieces on the same LPF branch. The only maps that can appear in this composition are the following two types: affine isomorphisms on a fixed boundary stratum, and affine submersions onto a lower-dimensional boundary stratum. Step 3: pullback of measure-zero sets through branch maps. We now verify these two map types and their null-set pullback property. • In the eviction-free regime, the boundary map is affine and invertible. It shifts xjx_j to xj+1x_j+1 for j<l1−1j<l_1-1, and the new admission is x0′=(l0+l1)xl1−1−∑j=0l1−2xjl0+1.x _0= (l_0+l_1)x_l_1-1- _j=0^l_1-2x_jl_0+1. The associated linear map has determinant ±(l0+l1)/(l0+1)≠0±(l_0+l_1)/(l_0+1)≠ 0. It preserves the weighted memory hyperplane ∑jwjxj=M _jw_jx_j=M, so its restriction to the boundary affine hull is an affine isomorphism. • On a fixed support pattern, the block-end map in normalized coordinates uh=yh/ghu_h=y_h/g_h is affine and invertible. It shifts old normalized masses and has ∂u0′∂um−1=l0+l1l0+gm−1≠0, ∂ u _0∂ u_m-1= l_0+l_1l_0+g_m-1≠ 0, so its full Jacobian is nonsingular. This map sends the old boundary hyperplane to the rotated new boundary hyperplane, hence restricts to an affine isomorphism between the corresponding block-end strata. • At a support-loss branch, the map to the lower-dimensional stratum is an affine submersion. Let x~ x be the post-execute, pre-eviction vector on a fixed nondegenerate LPF branch. Let E be the live positions fully exhausted by LPF, let q be the unique position partially trimmed with trim amount 0<τ<x~q0<τ< x_q, and let J be the surviving live positions after the step. For a genuine support-loss branch E≠∅E≠ ; if E=∅E= , the branch remains on the same support pattern. Thus q∈Jq∈ J. Set H:=J∖qH:=J \q\. Branches with no positive partially trimmed survivor, with zero trim, or with τ=x~qτ= x_q, are exactly the measure-zero branch-boundary cases already discarded. On the target boundary face, use z=(xh′)h∈Hz=(x _h)_h∈ H as local affine coordinates; the remaining target coordinate is determined by xq′=M−∑h∈Hwhzhwq.x _q= M- _h∈ Hw_hz_hw_q. On the relative interior of the source branch, the pre-eviction masses (x~h)h∈H( x_h)_h∈ H are distinct affine functions of the source state. By the LPF order, the trim does not reach any position in H before it stops partway through position q, so the positions in H are not trimmed during this eviction step. Complete them to a source affine chart (z,η)(z,η) as follows. Use the affine image of the source memory-boundary equation to solve for the non-target coordinate x~q x_q, and let η collect the remaining non-target source coordinates, including fully exhausted masses and, if present, the mass that completes during the execute step. This chart is valid on a sufficiently small relative neighborhood inside the branch cell because all LPF ordering and positivity inequalities are strict there. The partial-trim amount follows affinely from the prescribed overflow, the completed mass, and the exhausted masses. In these coordinates, the target free coordinates are exactly the surviving copied-or-shifted masses xh′=x~h=zhx _h= x_h=z_h, h∈Hh∈ H. Hence, after affine changes of coordinates, the branch has the normal form (z,η)⟼z,(z,η) z, where z∈ℝ|H|=ℝ|J|−1z ^|H|=R^|J|-1 are target coordinates and η collects the discarded fiber coordinates. Its Jacobian contains an identity block of size |J|−1|J|-1, so it has full row rank and the branch is a submersion. It remains to justify why these maps preserve relative nullity under preimage. Affine isomorphisms are bi-Lipschitz on the affine hulls of the relevant strata, so they preserve and reflect measure-zero sets. For an affine submersion, affine changes of source and target coordinates put the map in the normal form (z,η)↦z(z,η) z on each bounded polyhedral branch cell. Hence for a relative-measure-zero target set N, its preimage has measure λ(z,η):z∈N=∫Nλ(fiber over z)z=0λ\(z,η):z∈ N\= _Nλ(fiber over z)\,dz=0 by Fubini, because the memory boundary makes the branch cell bounded and each fiber has finite measure. Therefore the preimage of a relative-measure-zero set under any finite composition of these branch maps also has relative measure zero. Step 4: finite balanced targets and countable union over horizons. For any fixed relative support pattern and physical phase with m≥2m≥ 2 live positions, the balanced orbit contributes a single point of the corresponding stratum. Indeed, if the live masses are y0,…,ym−1y_0,…,y_m-1 with predecessor gaps g0,…,gm−1g_0,…,g_m-1, balance requires y0g0=y1g1=⋯=ym−1gm−1, y_0g_0= y_1g_1=·s= y_m-1g_m-1, so yh=cghy_h=cg_h, and the memory boundary fixes c. There are finitely many relative support patterns and at most l1l_1 physical phases. Therefore the target nonmaximal balanced states form a finite set in each stratum, hence a measure-zero set because the target stratum has dimension m−1≥1m-1≥ 1. Fix the horizon T. By Steps 2 and 3, on every nondegenerate branch cell, the preimage of this finite balanced target set has relative measure zero in the initial face. The discarded branch boundaries also have relative measure zero, and there are only finitely many branch sequences up to T. Hence the set captured by a nonmaximal balanced orbit by time T has relative measure zero in ℬIB_I. Finally, finite-time capture means capture by some finite horizon, so the full exact-capture set is the countable union over T=0,1,2,…T=0,1,2,… of these finite-horizon null sets. Countable subadditivity preserves measure zero and proves the claim. □ C.7 Proof of Lemma A.10 Proof of Lemma A.10. Choose ϵ0<12minr≠s‖Cr−Cs‖ _0< 12 _r≠ s\|C_r-C_s\| and replace the given ϵε by minϵ,ϵ0 \ε, _0\. Then a state within this distance of maxC_ has a unique closest phase. Fix such a phase r. Write the coordinate at stage r as the principal coordinate and all other coordinates as residual coordinates. By the memory-boundary equation, the principal coordinate differs from M/wrM/w_r by a linear combination of the residual coordinates. Thus, by taking δ small enough, the total residual memory can be made arbitrarily small and the principal mass remains bounded away from zero, uniformly over the finitely many phases. More concretely, choose this total residual memory smaller than a fixed fraction of minrM/wr _rM/w_r; then, even if all higher-stage residual cohorts complete during an execute step, the nonfinal phase still has strictly positive overflow and therefore no new admission can occur before LPF eviction restores the boundary. We claim that for sufficiently small phase neighborhoods the trajectory cannot leave the prescribed ϵε-tube before it reaches the single-live-position stratum. If r<l1−1r<l_1-1, the principal cohort advances to stage r+1r+1. At the cycle point CrC_r, this advancement creates overflow (wr+1−wr)Mwr=Mwr>0.(w_r+1-w_r) Mw_r= Mw_r>0. For sufficiently small residual mass, the same strict overflow persists after accounting for any residual cohorts that complete during the execute step. Continuous LPF then restores the memory boundary exactly. It removes any lower-progress residual cohorts before it can trim the advanced principal cohort, and if residual cohorts at higher stages remain, their total memory is still of the same small order as the initial residual memory. The advanced principal coordinate is then determined by the boundary equation and therefore differs from M/wr+1M/w_r+1 by only the memory contribution of those higher-stage residuals. If r=l1−1r=l_1-1, the principal cohort completes and the admission step creates the next principal cohort at stage 0; any residual cohorts again have only the small memory inherited from the initial residuals, and the stage-0 principal mass is fixed by the boundary equation up to that same small residual memory. No new residual cohort is created in this local tube: at nonfinal phases the strict overflow makes the continuous LPF step fill the boundary by eviction, so there is no additional admission, while at the final phase the new admitted cohort is precisely the next principal cohort. Existing residual cohorts either are evicted by LPF when they lag behind the principal cohort or complete after at most l1l_1 physical iterations when they lie ahead. Hence, for small enough δ, all iterates before absorption remain within the prescribed ϵε-tube around the corresponding cycle phase. Now take X0∉ℰX^0 in this δ-tube. If the trajectory is not already on the single-live-position stratum, then it has at least two live positions and cannot stay on, or be captured by, any nonmaximal balanced orbit: the eviction-free fixed point and all intermediate balanced limit cycles are included in ℰE. Theorem A.1 therefore forces support losses until only one live position remains. Once a single live position remains, the memory-boundary equation fixes its mass uniquely at the current phase, namely M/wrM/w_r, so the state is exactly CrC_r. From then on the trajectory follows maxC_ . Thus the trajectory reaches maxC_ in finite time, remains within ϵε of the cycle at all times, and then has distance zero from the cycle. □ C.8 Proof of Lemma 9 Proof of Lemma 9. Each cohort present at time zero has age at least zero and therefore either completes or is evicted within at most d iterations. Hence, after d iterations, every live cohort was admitted after time zero. Such a newly admitted cohort enters with class masses pkanp_ka^n, so it has the proportional composition stated above at age zero. One execution step only advances the cohort age and removes classes whose decoding length has ended. If LPF evicts part of a mixed stage, the proportional within-stage rule multiplies every live class mass in that stage by the same factor, so the ratios pkp_k among the surviving classes are preserved. Therefore all live cohorts after time d have the displayed form, and the same argument shows that the set of such states is forward invariant. □ C.9 Proof of Lemma 10 Proof of Lemma 10. From (29), any root z≠1z≠ 1 satisfies zl1,2=pzl1,2−l1,1+qz^l_1,2=pz^l_1,2-l_1,1+q. Taking absolute values and applying the triangle inequality: |z|l1,2=|pzl1,2−l1,1+q|≤p|z|l1,2−l1,1+q.|z|^l_1,2=|pz^l_1,2-l_1,1+q|≤ p|z|^l_1,2-l_1,1+q. Define g(x)=xl1,2−pxl1,2−l1,1−qg(x)=x^l_1,2-px^l_1,2-l_1,1-q for x≥0x≥ 0. First, g(1)=1−p−q=0g(1)=1-p-q=0. Second, for x>1x>1: g′(x)=l1,2xl1,2−1−p(l1,2−l1,1)xl1,2−l1,1−1=xl1,2−l1,1−1[l1,2xl1,1−p(l1,2−l1,1)].g (x)=l_1,2x^l_1,2-1-p(l_1,2-l_1,1)x^l_1,2-l_1,1-1=x^l_1,2-l_1,1-1[l_1,2x^l_1,1-p(l_1,2-l_1,1)]. Since x>1x>1 implies xl1,1>1x^l_1,1>1, the bracket exceeds l1,2−p(l1,2−l1,1)=ql1,2+pl1,1>0l_1,2-p(l_1,2-l_1,1)=ql_1,2+pl_1,1>0, so g′(x)>0g (x)>0 for x>1x>1. By the mean value theorem, g(x)>g(1)=0g(x)>g(1)=0 for all x>1x>1. Now suppose |z|>1|z|>1. Then g(|z|)>0g(|z|)>0, i.e., |z|l1,2>p|z|l1,2−l1,1+q|z|^l_1,2>p|z|^l_1,2-l_1,1+q. This contradicts the bound |z|l1,2≤p|z|l1,2−l1,1+q|z|^l_1,2≤ p|z|^l_1,2-l_1,1+q. Hence |z|≤1|z|≤ 1. □ C.10 Proof of Lemma 11 Proof of Lemma 11. For |z|=1|z|=1, we have |z|l1,2=1|z|^l_1,2=1 and |pzl1,2−l1,1+q|≤p+q=1|pz^l_1,2-l_1,1+q|≤ p+q=1 (by triangle inequality). Since (1−z)A(z)=0(1-z)A(z)=0 requires equality in (29), we need |zl1,2|=|pzl1,2−l1,1+q||z^l_1,2|=|pz^l_1,2-l_1,1+q|, i.e., 1=|pzl1,2−l1,1+q|1=|pz^l_1,2-l_1,1+q|. Since |pzl1,2−l1,1|=p>0|pz^l_1,2-l_1,1|=p>0 and |q|=q>0|q|=q>0, triangle-inequality equality requires zl1,2−l1,1z^l_1,2-l_1,1 to be a positive real of modulus one, hence zl1,2−l1,1=1z^l_1,2-l_1,1=1. Then zl1,2=p+q=1z^l_1,2=p+q=1, so zl1,2 z^l_1,2 =1, =1, zl1,2−l1,1 z^l_1,2-l_1,1 =1. =1. By the definition of GCD, g=gcd(l1,1,l1,2)=gcd(l1,2,l1,2−l1,1)g= (l_1,1,l_1,2)= (l_1,2,l_1,2-l_1,1). Since zl1,2=1z^l_1,2=1 and zl1,2−l1,1=1z^l_1,2-l_1,1=1, we have zgcd(l1,2,l1,2−l1,1)=1z (l_1,2,l_1,2-l_1,1)=1, i.e., zg=1z^g=1 (by Bézout’s identity: there exist integers a,ba,b such that g=a⋅l1,2+b⋅(l1,2−l1,1)g=a· l_1,2+b·(l_1,2-l_1,1)). □ C.11 Proof of Lemma 12 Proof of Lemma 12. Direct substitution into the definition of A(z)A(z): A(1) A(1) =1l1,2−1+∑m=1l1,1−11l1,2−1−m+q∑m=l1,1l1,2−11l1,2−1−m =1^l_1,2-1+ _m=1^l_1,1-11^l_1,2-1-m+q _m=l_1,1^l_1,2-11^l_1,2-1-m =1+(l1,1−1)⋅1+q⋅(l1,2−l1,1)⋅1 =1+(l_1,1-1)· 1+q·(l_1,2-l_1,1)· 1 =l1,1+q(l1,2−l1,1) =l_1,1+q(l_1,2-l_1,1) =l1,1+(1−p)(l1,2−l1,1)(since q=1−p) =l_1,1+(1-p)(l_1,2-l_1,1) (since $q=1-p$) =l1,1+l1,2−l1,1−p(l1,2−l1,1) =l_1,1+l_1,2-l_1,1-p(l_1,2-l_1,1) =l1,2−pl1,2+pl1,1 =l_1,2-pl_1,2+pl_1,1 =(1−p)l1,2+pl1,1 =(1-p)l_1,2+pl_1,1 =ql1,2+pl1,1>0. =ql_1,2+pl_1,1>0. Since p,q>0p,q>0 and l1,1,l1,2≥1l_1,1,l_1,2≥ 1, we have A(1)>0A(1)>0, so z=1z=1 is not a root of A(z)A(z). □ C.12 Proof of Lemma 13 Proof of Lemma 13. Write l1,1=agl_1,1=ag and l1,2=bgl_1,2=bg with gcd(a,b)=1 (a,b)=1. For any ω with ωg=1ω^g=1 and ω≠1ω≠ 1: ωl1,1=(ωg)a=1ω^l_1,1=(ω^g)^a=1, ωl1,2=(ωg)b=1ω^l_1,2=(ω^g)^b=1, and ωl1,2−l1,1=(ωg)b−a=1ω^l_1,2-l_1,1=(ω^g)^b-a=1. Substituting into (29): (1−ω)A(ω)=−1+p+q=0(1-ω)A(ω)=-1+p+q=0. Since ω≠1ω≠ 1, we have 1−ω≠01-ω≠ 0, and therefore A(ω)=0A(ω)=0. □ C.13 Proof of Lemma 15 Proof of Lemma 15. Write Gϵ(z):=A(z)−ϵzA′(z),ϵ:=1l0+l1,2.G_ε(z):=A(z)-ε zA (z), ε:= 1l_0+l_1,2. By the decomposition (30), the roots of F are exactly the roots of GϵG_ε. The degree of GϵG_ε is l1,2−1l_1,2-1 for all sufficiently small ϵε, since the leading coefficient is 1−ϵ(l1,2−1)1-ε(l_1,2-1). First consider the roots of the limiting polynomial A. By Lemmas 10–13, every root of A lies in the closed unit disk, the only roots on the unit circle are the non-trivial g-th roots of unity, and z=1z=1 is not a root. Moreover, the computation in the proof of Theorem 14 gives A′(ω)≠0A (ω)≠ 0 at each non-trivial g-th root ω. Hence these g−1g-1 unit-circle roots are simple, and the remaining l1,2−gl_1,2-g roots of A, counted with algebraic multiplicity, lie strictly inside the unit disk. Let r<1r<1 be the largest modulus of these remaining roots, and choose ρ with r<ρ<1r<ρ<1. Then A has no zeros on |z|=ρ|z|=ρ, so mρ:=min|z|=ρ|A(z)|>0,Mρ:=max|z|=ρ|zA′(z)|<∞.m_ρ:= _|z|=ρ|A(z)|>0, M_ρ:= _|z|=ρ|zA (z)|<∞. For sufficiently small ϵε, ϵMρ<mρε M_ρ<m_ρ. Rouché’s theorem on |z|=ρ|z|=ρ implies that GϵG_ε and A have the same number of roots in |z|<ρ|z|<ρ, namely l1,2−gl_1,2-g. These roots are stable because ρ<1ρ<1. It remains to locate the roots associated with the unit-circle roots. Because there are finitely many non-trivial g-th roots, choose pairwise disjoint neighborhoods UωU_ω around them. Shrinking a common ϵ0>0 _0>0 if necessary, the implicit-function argument in Theorem 14 gives, for every 0<ϵ<ϵ00<ε< _0 and each non-trivial g-th root ω, a unique zero zω(ϵ)∈Uωz_ω(ε)∈ U_ω of GϵG_ε. Moreover ∂zGϵ(zω(ϵ))≠0 _zG_ε(z_ω(ε))≠ 0, so this zero is simple. The neighborhoods are disjoint, hence these roots are distinct. They satisfy zω(ϵ)=ω(1+ϵ)+O(ϵ2),|zω(ϵ)|−1=Θ(ϵ)=Θ(1/l0)>0.z_ω(ε)=ω(1+ε)+O(ε^2), |z_ω(ε)|-1= (ε)= (1/l_0)>0. Thus GϵG_ε has g−1g-1 unstable roots. Together with the l1,2−gl_1,2-g roots inside |z|<ρ|z|<ρ, this accounts for all l1,2−1l_1,2-1 roots of GϵG_ε. Therefore no other finite-l0l_0 roots exist, and the asserted root count follows. □ C.14 Proof of Lemma 16 Proof of Lemma 16. Use the normalized two-class cohort coordinates Ys=Xs,s<l1,1,Xs/q,s≥l1,1,Vs=l0+s+1,s<l1,1,q(l0+s+1),s≥l1,1.Y_s= casesX_s,&s<l_1,1,\\ X_s/q,&s≥ l_1,1, cases V_s= casesl_0+s+1,&s<l_1,1,\\ q(l_0+s+1),&s≥ l_1,1. cases The eviction-free equilibrium is Y∗=x∗Y^*=x^*1. Let ES(Y)E^S(Y) denote the memory immediately after the execution/completion step and before admission. At equilibrium, the next admission has mass x∗>0x^*>0, so M−ES(Y∗)=V0x∗>0.M-E^S(Y^*)=V_0x^*>0. By continuity, after shrinking a neighborhood of Y∗Y^* if needed, every Y∈Y satisfies Ys≥0Y_s≥ 0 and |ES(Y)−ES(Y∗)|<12V0x∗.|E^S(Y)-E^S(Y^*)|< 12V_0x^*. Therefore M−ES(Y)>12V0x∗>0M-E^S(Y)> 12V_0x^*>0, the next admission amount (M−ES(Y))/V0(M-E^S(Y))/V_0 is positive, and feasibility is restored by admission alone. No LPF eviction is triggered anywhere in N. On this local no-eviction region, subtracting the equilibrium gives the exact linear stage-state dynamics yn+1=Φyn,yn:=Yn−Y∗.y^n+1= y^n, y^n:=Y^n-Y^*. The matrix Φ is the companion/shift matrix for the no-eviction dynamics: it has one zero eigenvalue, and its nonzero eigenvalues are exactly the roots of F(z)=0F(z)=0. Lemma 15 shows that these nonzero eigenvalues consist of g−1g-1 unstable roots and l1,2−gl_1,2-g stable roots. Thus Φ has a spectral splitting Eu⊕EsE^u E^s, with dimEu=g−1 E^u=g-1, and the zero eigenvalue is included in EsE^s. Let PuP_u be the spectral projection onto EuE^u. If Puy0≠0P_uy^0≠ 0, then along the no-eviction dynamics Puyn=ΦunPuy0,P_uy^n= _u^nP_uy^0, where Φu=Φ|Eu _u= |_E^u has all eigenvalues outside the unit circle. Hence Φu−n→0 _u^-n→ 0. If ΦunPuy0n≥0\ _u^nP_uy^0\_n≥ 0 were bounded, then Puy0=Φu−nΦunPuy0→0,P_uy^0= _u^-n _u^nP_uy^0→ 0, a contradiction. Therefore the unstable component is unbounded as long as the linear no-eviction dynamics continue. Since N is bounded after shrinking it if necessary, the trajectory must leave N in finite time. The exceptional initial perturbations in N are contained in kerPu P_u, a proper linear subspace of the local state space. They therefore have Lebesgue measure zero in local coordinates. □ C.15 Proof of Lemma 18 Proof of Lemma 18. The proof of Theorem 17 gives a radius ρ<1ρ<1 and an l0,⋆l_0, such that every root of F(z)=0F(z)=0 lies in |z|<ρ|z|<ρ for l0≥l0,⋆l_0≥ l_0, . These roots are exactly the nonzero eigenvalues of Φ , and the remaining eigenvalue is 0. □ C.16 Proof of Lemma 19 Proof of Lemma 19. Since all eigenvalues of Φ satisfy |zj|<1|z_j|<1, the series P=∑k=0∞(Φk)⊤ΦkP= _k=0^∞( ^k) ^k converges to the unique solution of Φ⊤PΦ−P=−I P -P=-I. The identity P−Φ⊤PΦ=IP- P =I gives P⪰IP I. For the upper bound, note that the entries of Φ(l0) (l_0) are ratios Vs/V0V_s/V_0, so Φ(l0) (l_0) depends continuously on 1/(l0+1)1/(l_0+1) and the family Φ(l0):l0≥l0,⋆\ (l_0):l_0≥ l_0, \ has compact closure. Vectorizing the Lyapunov equation gives: (I−Φ⊤⊗Φ⊤)vec(P)=vec(I). (I- )\,vec(P)=vec(I). Since ρ(Φ)≤ρ<1ρ( )≤ρ<1 (Lemma 18), we have ρ(Φ⊤⊗Φ⊤)=ρ(Φ)2≤ρ2<1ρ( )=ρ( )^2≤ρ^2<1, so I−Φ⊤⊗Φ⊤I- is invertible for all l0≥l0,⋆l_0≥ l_0, . The inverse depends continuously on Φ , hence ‖(I−Φ⊤⊗Φ⊤)−1‖2\|(I- )^-1\|_2 is bounded on the compact closure. Consequently ‖P‖2\|P\|_2 is uniformly bounded for l0≥l0,⋆l_0≥ l_0, , implying P⪯CPIP C_PI for some constant CPC_P independent of l0l_0. □ C.17 Proof of Lemma 20 Proof of Lemma 20. Let Nn=∑s=0l1,2−1XsnN^n= _s=0^l_1,2-1X^n_s be the total number of (actual) requests in the system at time n. Each request occupies at least l0+1l_0+1 tokens, so: Nn≤Ml0+1=βl0l0+1=O(1).N^n≤ Ml_0+1= β l_0l_0+1=O(1). In one iteration, each in-flight request generates one new token during decoding, so the post-shift token increase is at most Nn=O(1)N^n=O(1). Completions can only reduce memory, and the admission controller never increases memory beyond M (it admits at most the available slack). Therefore, the number of tokens that must be removed by eviction in any step is at most the O(1)O(1) overflow created by the shift. Since evicting one request frees at least l0+1l_0+1 tokens, the number of evicted requests per step is at most O(1)/(l0+1)=O(1/l0)O(1)/(l_0+1)=O(1/l_0). □ C.18 Proof of Lemma 21 Proof of Lemma 21. The perturbation en=yn−Φyn−1e^n=y^n- y^n-1 arises when eviction truncates the linear update. At stage 0, eviction replaces the ideal admission a~n<0 a_n<0 with zero, so |e0n|=|a~n|=(ES−M)/V0=O(1)/(l0+1)=O(1/l0)|e^n_0|=| a_n|=(E^S-M)/V_0=O(1)/(l_0+1)=O(1/l_0) by Lemma 20. At stages s≥1s≥ 1, the eviction removes O(1/l0)O(1/l_0) requests in total (Lemma 20), giving ∑s≥1|(en)s|≤O(1/l0)/min(1,q)=O(1/l0) _s≥ 1|(e^n)_s|≤ O(1/l_0)/ (1,q)=O(1/l_0). Hence ‖en‖2≤‖en‖1=O(1/l0)\|e^n\|_2≤\|e^n\|_1=O(1/l_0). □ C.19 Proof of Lemma 23 Proof of Lemma 23. If Pn(ζ)=Pn′(ζ)=0P_n(ζ)=P_n (ζ)=0 and ζ≠1ζ≠ 1, then ζ≠0ζ≠ 0 and nζn−1=p(n−a)ζn−a−1,soζa=p(1−an).nζ^n-1=p(n-a)ζ^n-a-1, ζ^a=p (1- an ). Therefore |ζ|≤p1/a≤p1/n=exp(logpn)≤1−logp2n|ζ|≤ p^1/a≤ p^1/n= \! ( pn )≤ 1- - p2n for all sufficiently large n. This proves the claim with cp=−log(p)/2>0c_p=- (p)/2>0. Since the dominant threshold shell has radial width O(n−3)O(n^-3) around the unit circle, these multiple roots cannot determine the first crossing. □ C.20 Proof of Lemma 27 Proof of Lemma 27. First note that all roots of PnP_n lie in the closed unit disk. Indeed, if R:=|z|>1R:=|z|>1, then Rn=|pzn−a+q|≤pRn−a+q<pRn+q,R^n=|pz^n-a+q|≤ pR^n-a+q<pR^n+q, which implies Rn<1R^n<1, a contradiction. Hence the logarithmic coordinates used below always satisfy ℜμ≥0 μ≥ 0. The representation is just the principal logarithm in the sector around a nearest n-th root of unity: once ω is chosen, set μ=−nLog(z/ω)μ=-nLog(z/ω), with ℑμ∈[−π,π] μ∈[-π,π]. Since ωn=1ω^n=1 and ω−a=eixω^-a=e^ix, substituting z=ωe−μ/nz=ω e^-μ/n into Pn(z)=0P_n(z)=0 gives the displayed equation for H. If a root lies on a sector boundary and has two nearest n-th roots of unity, fix either one by an arbitrary deterministic tie-breaking rule. The estimates below are invariant under this choice. We use the chart only for coverage and uniform bounds; a boundary root that admits two labels is counted once as a root of PnP_n. The only point that needs care is uniformity. At (μ,x)=(0,0)(μ,x)=(0,0), Hμ(0,0,θ)=−(q+pθ),H_μ(0,0,θ)=-(q+pθ), which is bounded away from zero uniformly over θ∈[0,1]θ∈[0,1], since q>0q>0. The implicit-function theorem therefore gives a unique branch μ(x,θ)μ(x,θ) for |x|≤δ|x|≤δ, with δ chosen uniformly in θ. We also need that this local branch accounts for all solutions in the near-unit strip when |x|≤δ|x|≤δ. This follows by compactness. At x=0x=0 and ℜμ=0 μ=0, writing u=e−μ,v=e−(1−θ)μ,u=e^-μ, v=e^-(1-θ)μ, the equation H(μ,0,θ)=0H(μ,0,θ)=0 gives u=pv+qu=pv+q with |u|=|v|=1|u|=|v|=1. Equality in the triangle inequality forces u=v=1u=v=1, and therefore μ=0μ=0 in the strip ℑμ∈[−π,π] μ∈[-π,π]. Consequently, after choosing η and δ small enough, there are no solutions of H(μ,x,θ)=0H(μ,x,θ)=0 with 0≤ℜμ≤η,|x|≤δ,ℑμ∈[−π,π],0≤ μ≤η, |x|≤δ, μ∈[-π,π], outside the fixed IFT neighborhood of μ=0μ=0. Thus the displayed branch is the unique near-unit solution for small phases. If the last assertion failed, compactness would give a limit (μ∗,x∗,θ∗)( _*,x_*, _*) with ℜμ∗=0 _*=0, |x∗|≥δ|x_*|≥δ, and e−μ∗−peix∗e−(1−θ∗)μ∗−q=0.e^- _*-pe^ix_*e^-(1- _*) _*-q=0. Writing u=e−μ∗u=e^- _* and v=eix∗e−(1−θ∗)μ∗v=e^ix_*e^-(1- _*) _*, we have |u|=|v|=1|u|=|v|=1. The equation u=pv+qu=pv+q can hold with p,q>0p,q>0 and |u|=|v|=1|u|=|v|=1 only when u=v=1u=v=1, by equality in the triangle inequality. Hence x∗=0(mod2π)x_*=0 2π, contradicting |x∗|≥δ|x_*|≥δ with x∗∈(−π,π]x_*∈(-π,π]. Therefore phases bounded away from zero have ℜμ≥c μ≥ c uniformly. □ C.21 Proof of Lemma 28 Proof of Lemma 28. We keep the removable denominator in A=−Pn/(1−z)A=-P_n/(1-z), because this is the term that must be controlled uniformly. In the chart z=ωm,ne−ν/nz= _m,ne^-ν/n, set t:=1/nt:=1/n and H(ν,x,θ)=e−ν−peixe−(1−θ)ν−q.H(ν,x,θ)=e^-ν-pe^ixe^-(1-θ)ν-q. Since A=−H/(1−z)A=-H/(1-z) and zA′(z)=−n∂νA(z)zA (z)=-n _νA(z), the equation A(z)−εzA′(z)=0A(z)- zA (z)=0 is equivalent, after multiplying by the nonzero factor −(1−z)-(1-z), to (ν,η,x,θ,t):=H+ηHν−tηz1−zH=0,η=nε.J(ν,η,x,θ,t):=H+η H_ν-tη z1-zH=0, η=n . At η=0η=0, this reduces to H(ν,x,θ)=0H(ν,x,θ)=0, whose solution is ν=μ(x,θ)ν=μ(x,θ). Moreover, ν(μ(x,θ),0,x,θ,t)=Hν(μ(x,θ),x,θ),J_ν(μ(x,θ),0,x,θ,t)=H_ν(μ(x,θ),x,θ), and this derivative is bounded away from zero uniformly for |x|≤δ|x|≤δ and θ∈[0,1]θ∈[0,1], after shrinking δ, because Hν(0,0,θ)=−(q+pθ)≤−q<0H_ν(0,0,θ)=-(q+pθ)≤-q<0. The only uniformity issue is the last term in J. On the branches under consideration m≠0m≠ 0, and the principal logarithm has |ℑν|≤π| ν|≤π. Thus, on the unit-scale neighborhood used by the implicit-function theorem, |1−z|≥c/n,|tz1−z|≤C.|1-z|≥ c/n, |t z1-z |≤ C. All derivatives of H are uniformly bounded on this neighborhood. The analytic implicit-function theorem therefore applies with constants independent of m,a,nm,a,n. Differentiating (νm,n(η),η,xm,θn,1/n)=0J( _m,n(η),η,x_m, _n,1/n)=0 at η=0η=0 gives νm,n′(0)=−ην=−HνHν=−1, _m,n (0)=- J_ηJ_ν=- H_νH_ν=-1, where the term containing H vanishes because H(μ(xm,θn),xm,θn)=0H(μ(x_m, _n),x_m, _n)=0. The same uniform bounds control the second η-derivative of νm,n _m,n, so Taylor’s theorem gives the stated O(η2)O(η^2) remainder. □ C.22 Proof of Lemma 29 Proof of Lemma 29. The lemma rules out the only global pathology not excluded by the local expansion alone: stability could, in principle, reappear at a smaller input length after the dominant local crossing. We prove a stronger root-existence statement: throughout the physical range above, at least one root lies outside the unit disk. Let η=nεη=n . We split the interval [nΔn+Cn2Δn2,1][n _n+Cn^2 _n^2,1] into three ranges. On the small-η range, the dominant branch itself is outside. On an intermediate range, we construct an outside root in a fixed small phase window. On the large-η range, the product of the root moduli already exceeds one. First consider η≤η0η≤ _0, where η0 _0 is the constant from Lemma 28. Write the remainder in that lemma as |R(η)|≤CRη2|R(η)|≤ C_Rη^2, and reduce η0 _0, if necessary, so that CRη2≤η/4C_Rη^2≤η/4 on 0≤η≤η00≤η≤ _0. On the dominant phase x1=2π/nx_1=2π/n, Lemma 28 gives the continuation z∗(η) z_*(η) =ω1,nexp(−ν∗(η)/n), = _1,n (- _*(η)/n), ν∗(η) _*(η) =μ(2π/n,θn)−η+O(η2) =μ(2π/n, _n)-η+O(η^2) for 0≤η≤η00≤η≤ _0. Since ρ∞=exp−ℜμ(2π/n,θn)/n, _∞= \- μ(2π/n, _n)/n\, we have ℜμ(2π/n,θn)=nΔn+O(nΔn2). μ(2π/n, _n)=n _n+O(n _n^2). Thus, after enlarging C, the excess η−ℜμ(2π/n,θn)η- μ(2π/n, _n) dominates both error terms. More explicitly, if η is comparable to nΔn _n, then |R(η)|≤CRη2=O(n2Δn2),|R(η)|≤ C_Rη^2=O(n^2 _n^2), so choosing C larger than the conversion and remainder constants gives η−ℜμ(2π/n,θn)>|R(η)|η- μ(2π/n, _n)>|R(η)|. If η is larger, the reduced bound CRη2≤η/4C_Rη^2≤η/4 gives the same conclusion. Therefore ℜν∗(η)<0wheneverε≥Δn+CnΔn2andη≤η0. _*(η)<0 ≥ _n+Cn _n^2 η≤ _0. The corresponding root satisfies |z∗(η)|=exp(−ℜν∗(η)/n)>1|z_*(η)|= (- _*(η)/n)>1, so the system is unstable throughout this part of the range. We next cover an intermediate range that is bounded away from both endpoints. Set η1:=1+p2<1, _1:= 1+p2<1, and reduce η0 _0, if necessary, so that 0<η0<η10< _0< _1. For η∈[η0,η1]η∈[ _0, _1], consider the reduced logarithmic equation at phase x=0x=0, H(ν,0,θ)+ηHν(ν,0,θ)=0.H(ν,0,θ)+η H_ν(ν,0,θ)=0. Writing z=e−νz=e^-ν and γ:=1−θγ:=1-θ, and using the positive real branch of z1−θz^1-θ for z≥1z≥ 1, this equation becomes fη,θ(z):=(1−η)z−p1−η(1−θ)z1−θ−q=0.f_η,θ(z):=(1-η)z-p\1-η(1-θ)\z^1-θ-q=0. For z≥1z≥ 1, the function fη,θf_η,θ is convex, because fη,θ′(z)=p1−η(1−θ)θ(1−θ)z−θ−1≥0.f_η,θ (z)=p\1-η(1-θ)\θ(1-θ)z^-θ-1≥ 0. Moreover, fη,θ(1)=−η(q+pθ)≤−η0q<0,fη,θ(z)→∞as z→∞,f_η,θ(1)=-η(q+pθ)≤- _0q<0, f_η,θ(z)→∞ z→∞, uniformly over (η,θ)∈[η0,η1]×[0,1](η,θ)∈[ _0, _1]×[0,1]. To see the uniformity, use z1−θ≤z^1-θ≤ z for z≥1z≥ 1 to get fη,θ(z)≥q(1−η)+pηθz−q≥q(1−η1)z−q.f_η,θ(z)≥\q(1-η)+pηθ\z-q≥ q(1- _1)z-q. Hence there is a largest root z∗(η,θ)>1z_*(η,θ)>1. At this root, fη,θ′(z∗)=(1−η)θ+(1−θ)qz∗>0,f_η,θ (z_*)=(1-η)θ+ (1-θ)qz_*>0, where we used p1−η(1−θ)z∗1−θ=(1−η)z∗−q.p\1-η(1-θ)\z_*^1-θ=(1-η)z_*-q. At the endpoint cases θ=0θ=0 and θ=1θ=1, the equation reduces to the same explicit root z∗=(1−η)−1z_*=(1-η)^-1, and the derivative remains positive. The positive derivative makes this root locally continuous in (η,θ)(η,θ) by the implicit-function theorem, and the preceding uniform growth bound keeps it in a compact z-interval. Therefore compactness over (η,θ)∈[η0,η1]×[0,1](η,θ)∈[ _0, _1]×[0,1] gives constants r0,m0>0r_0,m_0>0 such that z∗(η,θ) z_*(η,θ) ≥er0>1, ≥ e^r_0>1, fη,θ′(z∗(η,θ)) f_η,θ (z_*(η,θ)) ≥m0. ≥ m_0. Equivalently, the reduced equation has a simple solution ν0(η,θ):=−logz∗(η,θ) _0(η,θ):=- z_*(η,θ) with ℜν0≤−r0 _0≤-r_0, uniformly over this compact parameter set. We then realize this reduced outside root as an actual finite-n root. The derivative lower bound above lets us apply the implicit-function theorem uniformly once more, now with the phase x also allowed to vary; the fractional power is taken using the local analytic branch around the positive real root z∗(η,θ)z_*(η,θ). Thus, after choosing x0>0x_0>0 sufficiently small, the reduced equation H(ν,x,θ)+ηHν(ν,x,θ)=0H(ν,x,θ)+η H_ν(ν,x,θ)=0 has a solution ν0(η,θ,x) _0(η,θ,x) for every η∈[η0,η1]η∈[ _0, _1], θ∈[0,1]θ∈[0,1], and x∈[0,2x0]x∈[0,2x_0], with ℜν0(η,θ,x)≤−3r04. _0(η,θ,x)≤- 3r_04. Choose I=[x0,2x0]⊂(0,δ)I=[x_0,2x_0]⊂(0,δ), where δ is from Lemma 27. We use the following elementary counting fact: for all large n, the lattice 2πm/n\2π m/n\ has at least cInc_In points in I, while the set of nnth roots satisfying |ω−1|≤s|ω-1|≤ s has at most CssnC_ssn points. Because m↦umm u_m is a permutation modulo n, choosing s>0s>0 small enough leaves at least one phase xm∈Ix_m∈ I with |ωm,n−1|≥s| _m,n-1|≥ s. For this phase and for ν in a fixed neighborhood of ν0(η,θn,xm) _0(η, _n,x_m), |1nz1−z|=O(n−1),z=ωm,ne−ν/n. | 1n z1-z |=O(n^-1), z= _m,ne^-ν/n. Thus the full finite-n logarithmic equation H+ηHν−ηnz1−zH=0H+η H_ν- ηn z1-zH=0 is an O(n−1)O(n^-1) perturbation of the reduced equation, uniformly over η∈[η0,η1]η∈[ _0, _1]. The implicit-function theorem gives a nearby solution νm,n(η) _m,n(η) satisfying ℜνm,n(η)≤−r02. _m,n(η)≤- r_02. The associated root has |zm,n(η)|=exp−ℜνm,n(η)/n>1.|z_m,n(η)|= \- _m,n(η)/n\>1. Therefore the finite-input polynomial is unstable throughout η∈[η0,η1]η∈[ _0, _1]. For the large-η range, consider η∈[η1,1]η∈[ _1,1]. The finite-input polynomial has degree n−1n-1, constant coefficient q, and leading coefficient 1−ε(n−1)=1−η+ηn.1- (n-1)=1-η+ ηn. The product of the moduli of all n−1n-1 roots is therefore q1−η+η/n. q1-η+η/n. For η≥η1=(1+p)/2=1−q/2η≥ _1=(1+p)/2=1-q/2, the denominator is at most q/2+1/nq/2+1/n, which is strictly smaller than q for all sufficiently large n. Hence the product of the root moduli is larger than one, and at least one root must lie outside the unit disk. Combining the three ranges proves instability for every ε∈[Δn+CnΔn2,1/n] ∈[ _n+Cn _n^2,1/n]. Stable islands before the asymptotic threshold are therefore impossible. □ C.23 Proof of Lemma 30 Proof of Lemma 30. Admission creates a fresh mixed cohort in the exact proportions p:qp:q. The execute step advances each surviving cohort by one age; class 1 leaves after age a−1a-1, while class 2 leaves after age b−1b-1. Proportional within-stage eviction rescales all classes in a mixed stage by the same factor and therefore preserves the within-stage composition. Induction over n gives the displayed cohort representation. For j<aj<a, the total occupancy is x1,jn+x2,jn=yjnx^n_1,j+x^n_2,j=y^n_j; for j≥aj≥ a, only class 2 remains, so the total occupancy is qyjnqy^n_j. Hence the normalized variables used above satisfy Yjn=yjnY^n_j=y^n_j, with the effective stage weights stated in the lemma. □ C.24 Proof of Lemma 1 Proof of Lemma 1. Let =X1,…,XpC=\X_1,…,X_p\ be a limit cycle of period p on the memory boundary (Mn=M^n=M at every iteration). Write Xn=(x0n,…,xl1−1n)X^n=(x^n_0,…,x^n_l_1-1) and let yn:=xl1−1ny_n:=x^n_l_1-1 denote the number of completions at iteration n, so that T¯()=1p∑n=1pyn T(C)= 1p _n=1^py_n. By the waste decomposition (27), T¯()=x∗−E()/(pW)≤x∗ T(C)=x^*-E(C)/(pW)≤ x^*, with equality only when no eviction occurs (E=0E=0). All subpopulations below are submasses of this continuous state. When a subpopulation cuts through a stage, the within-stage tie-breaking is fixed so that the non-protected submass is trimmed before the protected submass; this is an admissible representative of the continuous LPF convention in Section 2. We now lower bound T¯() T(C) by a direct counting argument. Define m:=Mwl1−1=Ml0+l1.m:= Mw_l_1-1= Ml_0+l_1. Fix any starting index t∈1,…,pt∈\1,…,p\ and consider the l1l_1 consecutive iterations t,t+1,…,t+l1−1t,t+1,…,t+l_1-1 (with indices taken modulo p). We claim that at least m requests complete over this block: ∑r=0l1−1yt+r≥m. _r=0^l_1-1y_t+r\;≥\;m. (40) To see this, observe that at time t the total number of active requests is at least m because M=∑j=0l1−1wjxjt≤wl1−1∑j=0l1−1xjt.M= _j=0^l_1-1w_jx^t_j≤ w_l_1-1 _j=0^l_1-1x^t_j. Consider any subpopulation of exactly m active request mass at time t with the largest stage indices.111If the cutoff falls within a stage, take an arbitrary m-mass subpopulation from that stage; requests within a stage are indistinguishable in the continuous model. Call this the protected mass. At any future iteration before it completes, each protected unit occupies at most wl1−1w_l_1-1 tokens, so the protected subpopulation uses at most mwl1−1=Mm\,w_l_1-1=M tokens at all times (including immediately after Execute). Evicting only non-protected mass therefore suffices to restore feasibility after any Execute step: if we hypothetically removed every non-protected unit, the remaining protected mass would still fit in memory. Under LPF, evictions occur in increasing order of stage index, so protected mass can only be evicted after all less-progressed non-protected mass has been removed. At the cutoff stage that may contain both protected and non-protected mass, the amount to remove never exceeds the non-protected mass, because the protected mass alone is feasible; by the continuous within-stage convention fixed above, the non-protected mass is evicted first. Consequently, the protected subpopulation is never evicted and advances one stage per iteration until completion. Because each unit traverses l1l_1 stages, all protected mass completes within the next l1l_1 iterations, proving (40). Summing (40) over t=1,…,pt=1,…,p and noting that each completion yny_n appears in exactly l1l_1 of the resulting window sums gives l1∑n=1pyn≥pm.l_1 _n=1^py_n\;≥\;pm. Dividing by pl1pl_1 yields T¯()=1p∑n=1pyn≥ml1=Ml1(l0+l1)=T¯l1−1. T(C)= 1p _n=1^py_n\;≥\; ml_1= Ml_1(l_0+l_1)= T_l_1-1. We next characterize when equality holds. Define the total number of active requests at time n by Nn:=∑j=0l1−1xjn.N_n:= _j=0^l_1-1x^n_j. Since wj≤wl1−1w_j≤ w_l_1-1 for all j, the memory constraint implies Nn≥Mwl1−1=m,N_n≥ Mw_l_1-1=m, (41) with equality if and only if x0n=⋯=xl1−2n=0x^n_0=·s=x^n_l_1-2=0 (i.e., all active requests are at stage l1−1l_1-1). We claim that if there exists some index t with yt>0y_t>0 and Nt>mN_t>m, the corresponding length-l1l_1 completion window is strictly larger than m: ∑r=0l1−1yt+r>m. _r=0^l_1-1y_t+r\;>\;m. (42) Indeed, set δ:=minyt,Nt−m,δ:= \y_t,\;N_t-m\, which is strictly positive under yt>0y_t>0 and Nt>mN_t>m. Consider the subpopulation of size m+δm+δ consisting of the active request mass at time t with the largest stage indices, using the same within-stage convention as above. This enlarged protected subpopulation includes all stage-(l1−1)(l_1-1) mass, so exactly yty_t of it completes at iteration t. Immediately after the Execute step at iteration t, the remaining enlarged protected mass equals (m+δ)−yt≤m,(m+δ)-y_t≤ m, where we used δ≤ytδ≤ y_t. Since every unit occupies at most wl1−1w_l_1-1 tokens, the remaining protected mass fits in memory: its total footprint is at most mwl1−1=Mm\,w_l_1-1=M (and thereafter it only decreases as further completions occur). Consequently, evicting only non-protected mass suffices to restore feasibility after any subsequent Execute step. Under LPF, non-protected mass (which is weakly less progressed at time t and remains so under stage advancement) is evicted before protected mass, and the continuous within-stage convention removes non-protected mass first whenever the eviction front reaches the cutoff stage. Hence none of the m+δm+δ enlarged protected mass is ever evicted, and all of it completes within the next l1l_1 iterations. This proves (42). If C is not the maximal-eviction cycle, it never visits a state with Nt=mN_t=m. Indeed, if Nt=mN_t=m for some t, then by the equality case of (41) we must have Xt=(0,…,0,m)X_t=(0,…,0,m). Starting from this state, the execute-evict-admit map deterministically generates the maximal-eviction cycle, so C itself would be maximal, a contradiction. Hence Nt>mN_t>m for all t on any non-maximal limit cycle. By (40), there exists t with yt>0y_t>0; applying (42) at such t gives one strict window sum. Summing window sums over t=1,…,pt=1,…,p then yields l1∑n=1pyn>pml_1 _n=1^py_n>pm, i.e., T¯()>m/l1 T(C)>m/l_1. Finally, the maximal-eviction cycle achieves T¯=m/l1 T=m/l_1, so equality holds if and only if C is the maximal-eviction cycle. □ Appendix D Numerical Supplement This appendix contains the numerical experiments behind Section 6. The main text keeps one representative figure per mechanism. The supplementary figures give the supporting model-based simulations, Vidur simulations, real-GPU experiments, and parameter sweeps. Throughout this appendix, “model-based simulator” denotes a direct implementation of the discrete-time memory and admission recursions in Section 2. It keeps the model’s state variables, capacity constraint, greedy admission rule, and LPF eviction rule, and adds stochastic arrivals only in experiments that explicitly study open-system behavior. These runs use the paper’s state equations as the simulator and isolate the mathematical mechanism. “Vidur” denotes the large-scale LLM-serving simulator of Agrawal et al. (2024), which reports simulation errors below 5% for latency and throughput. Unless otherwise stated, our Vidur experiments use the Sarathi scheduler (Agrawal et al., 2023), Meta-Llama-3-8B, and a single NVIDIA A100 GPU. Vidur simulates serving iterations and tracks request-level KV cache memory, so it serves as an intermediate simulation environment between the model-based simulator and physical GPU experiments. In the Vidur simulations, pending requests are considered in arrival order and admitted when memory is available; the per-iteration admission cap based on the eviction-free admission rate is added only in the rate-limited variant. When resident KV cache later exceeds capacity, Vidur records an eviction event and returns the affected request to the waiting queue. We report these events as the system-level counterparts of model evictions. The eviction priority follows the LPF abstraction used in the model, removing least-progressed active requests first. D.1 Model-based GCD simulations The model-based simulator implements the discrete-time memory and admission dynamics of Section 2. Time is measured in scheduling iterations, memory is measured in the same normalized KV cache units as the model, and a newly admitted request contributes its input length KV cache before growing by one unit per decoding step. The first two figures isolate the deterministic GCD mechanism under saturated input: coprime decoding lengths desynchronize completions and converge to the eviction-free equilibrium, whereas non-coprime decoding lengths align completions and generate eviction cycles. Figure 16: Two-class model-based GCD comparison under greedy admission with common input length l0=40l_0=40 and p=1/2p=1/2. The coprime decoding-length pair (l1,1,l1,2)=(4,7)(l_1,1,l_1,2)=(4,7) converges to an eviction-free equilibrium, while the non-coprime pair (4,8)(4,8) exhibits persistent oscillations and eviction. Figure 17: Three-class model-based GCD comparison under greedy admission with common input length l0=30l_0=30 and equal class proportions. The coprime decoding-length sets l1∈2,7,12l_1∈\2,7,12\ and l1∈2,9,12l_1∈\2,9,12\ converge to eviction-free equilibria; the non-coprime set l1∈2,8,12l_1∈\2,8,12\ exhibits persistent oscillations. D.2 Mixing mechanisms and additional metrics Section 6.2 gives the representative serving-system mixing result. The supplementary figures and tables separate the model-based mechanism from the metric changes induced by coprime mixing and partial-GCD reduction. In the model-based runs, routing changes only the set of decoding lengths pooled on a node; in the Vidur runs, the same routing change is tested under Sarathi’s serving simulation, which tracks request-level KV cache memory. Figure 18: Request mixing dynamics in the model-based simulator with M=600M=600 and common input length l0=30l_0=30. Segregated routing assigns decoding lengths 6,10\6,10\ to one node and 9,15\9,15\ to another, producing periodic eviction because the two nodes have non-coprime GCDs. Uniformly mixing all four decoding lengths l1∈6,9,10,15l_1∈\6,9,10,15\ gives effective GCD =1=1, desynchronizes completions, and converges to an eviction-free equilibrium. Table 4: Request mixing effect (model-based simulator with M=600M=600 and common input length l0=30l_0=30). Segregating classes on separate nodes causes periodic eviction due to non-coprime GCDs (2 and 3). Uniformly mixing classes creates effective GCD=1=1 and is consistent with near-zero eviction through desynchronization in this setup. Mixing cuts evictions by 100% (88→ 0), improves latency by 4.0%, and increases throughput by 5.3% versus the segregated average. Routing Strategy Evictions Latency (s) Throughput (req/s) Configuration Segregated 6,10\6,10\ 63 42.50 48.2 l1∈6,10l_1∈\6,10\ Segregated 9,15\9,15\ 112 45.30 46.8 l1∈9,15l_1∈\9,15\ Segregated (average) 88 43.90 47.5 — Mixed (all classes) 0 42.10 50.0 l1∈6,9,10,15l_1∈\6,9,10,15\ Note. Segregated average is the average of the two segregated nodes. Mixed uses the same two-node budget with all request classes pooled. Throughput is completed requests per second. Figure 19: Model-based simulator summary under Poisson arrivals: mixed routing versus the segregated average. Coprime mixing eliminates evictions over this simulated horizon, while partial-GCD reduction still lowers eviction pressure, latency, and throughput loss. Figure 20: Throughput mechanism for request mixing. Mixing removes the gap between the segregated optimal throughput and the synchronized worst-cycle throughput. The gain comes from preventing synchronization from driving the system into a lower-throughput cycle. Figure 21: Partial GCD reduction in the model-based simulator with M=1000M=1000 and common input length l0=30l_0=30. Segregated nodes with decoding lengths 20,40\20,40\ and 25,50\25,50\ have high GCDs and severe periodic eviction; mixing all four classes reduces the effective GCD to 5 and cuts eviction pressure. Table 5: Partial GCD reduction effect (model-based simulator with M=1000M=1000 and common input length l0=30l_0=30). Segregating classes on separate nodes with high GCDs (20 and 25) causes severe periodic eviction. Uniformly mixing classes reduces effective GCD to 5, achieving 52% fewer evictions through partial desynchronization. This demonstrates that mixing benefits extend beyond coprime configurations. Routing Strategy Evictions Latency (s) Throughput (req/s) Configuration Segregated 20,40\20,40\ 248 68.20 38.5 l1∈20,40l_1∈\20,40\, GCD=20 Segregated 25,50\25,50\ 190 71.40 37.2 l1∈25,50l_1∈\25,50\, GCD=25 Segregated (average) 219 69.80 37.9 — Mixed (all classes) 105 65.30 42.8 l1∈20,25,40,50l_1∈\20,25,40,50\, GCD=5 Note. Segregated average is the average of the two segregated nodes. Mixed uses the same two-node budget with all request classes pooled. Throughput is completed requests per second. Figure 22: Coprime mixing memory dynamics with common input length l0=512l_0=512. Mixing decoding-length sets 50,75\50,75\ and 77,84\77,84\ produces combined GCD =1=1 and removes the periodic overflow observed under segregated routing. Figure 23: Partial-GCD mixing memory dynamics with common input length l0=512l_0=512. Mixing decoding-length sets 100,200\100,200\ and 125,250\125,250\ reduces the effective GCD from 100/125 to 25 and weakens synchronization. Table 6: Request mixing effect with 20k requests, common input length l0=512l_0=512, and overloaded arrivals. Segregating classes on separate nodes causes periodic eviction due to non-coprime GCDs (25 and 7). Uniformly mixing classes creates effective GCD=1=1 and has 98.7% fewer evictions. Holding the workload, scheduler, and two-device budget fixed, mixing cuts evictions by 1,338 (1,356→ 18), improves latency by 17.4%, and increases throughput by 19.0% versus the segregated average. Routing Strategy Evictions Latency (s) Throughput (req/s) Configuration Segregated 50,75\50,75\ 1,059 136.3 73.4 l1∈50,75l_1∈\50,75\, GCD=25 Segregated 77,84\77,84\ 1,640 183.2 54.8 l1∈77,84l_1∈\77,84\, GCD=7 Segregated (average) 1,349 159.8 64.1 — Mixed (all classes) 18 131.9 76.2 l1∈50,75,77,84l_1∈\50,75,77,84\, GCD=1 Note. Segregated average is the average of the two segregated devices. Mixed uses the same two-device budget with all request classes pooled. Throughput is completed requests per second. Table 7: Partial GCD reduction effect with 20k requests and common input length l0=512l_0=512. Segregating classes on separate nodes with high GCDs (100 and 125) causes severe periodic eviction. Uniformly mixing classes reduces effective GCD to 25 and has 34.0% fewer evictions. Holding the workload, scheduler, and two-device budget fixed, mixing cuts evictions by 1,259 (3,708→ 2,449), improves latency by 7.2%, and increases throughput by 5.8% versus the segregated average. This demonstrates that mixing benefits extend beyond coprime configurations. Routing Strategy Evictions Latency (s) Throughput (req/s) Configuration Segregated 100,200\100,200\ 3296 367.9 27.3 l1∈100,200l_1∈\100,200\, GCD=100 Segregated 125,250\125,250\ 4121 473.4 21.2 l1∈125,250l_1∈\125,250\, GCD=125 Segregated (average) 3708 420.6 24.2 — Mixed (all classes) 2449 390.4 25.6 l1∈100,125,200,250l_1∈\100,125,200,250\, GCD=25 Note. Segregated average is the average of the two segregated devices. Mixed uses the same two-device budget with all request classes pooled. Throughput is completed requests per second. D.3 Vidur and real-GPU experiments The following experiments ask whether the observed dynamics are consistent with the synchronization mechanism after reintroducing serving-system details. The real-GPU experiments use an implemented serving stack. These experiments test whether similar completion synchronization, memory growth, and eviction patterns appear beyond the stylized simulator. In the fixed-workload Vidur and real-GPU experiments, requests are generated according to the stated class proportions and submitted at a sufficiently high rate at the beginning of the run. They therefore form a persistent waiting queue QnQ^n, and the scheduler admits from this queue whenever memory is available. This construction approximates the saturated-input regime analyzed in the model, while the open-system experiments in Section˜6.1 separately study Poisson arrivals. Figure 24: GCD effect on memory dynamics with common input length l0=512l_0=512, rate =7000=7000, and 20k requests. Coprime decoding lengths 4,7\4,7\ converge to a stable memory equilibrium with zero eviction; non-coprime decoding lengths 4,8\4,8\ exhibit periodic overflow and eviction. Figure 25: Homogeneous real-GPU experiment (l0=5000l_0=5000, l1=1000l_1=1000). The figure records physical memory usage and admitted requests over time. Memory repeatedly saturates capacity, triggers eviction, and drops; admissions mirror the same cycle. Figure 26: Two-class real-GPU experiments with common input length l0=5000l_0=5000. Columns compare the coprime decoding-length pair (1000,1211)(1000,1211) with the non-coprime pair (1000,1200)(1000,1200); rows show physical memory usage and admitted requests. The non-coprime case exhibits stronger synchronized memory pressure. Figure 27: Real admission (top) and real eviction (bottom) over wall-clock time for three decoding-length configurations. Segregated routing (l1∈5,10l_1∈\5,10\ and l1∈6,12l_1∈\6,12\) produces recurring eviction bursts at fixed intervals; mixed routing (l1∈5,6,10,12l_1∈\5,6,10,12\, GCD=1=1) eliminates the periodic pattern. x-axis: timestamp in seconds. D.4 Rate-limit mechanism and sensitivity Section 6.3 gives the Vidur rate-limited admission result. The supplementary figures illustrate the corresponding mechanism in the model-based simulator and show the throughput-eviction tradeoff across admission limits. Figure 28: Rate-limited admission dynamics in the model-based simulator with M=1000M=1000, l0=20l_0=20, and l1=20l_1=20. Greedy admission produces periodic memory overflow and eviction spikes; rate-limited admission keeps memory below capacity and eliminates eviction over the simulated horizon. Figure 29: Throughput-eviction tradeoff in the model-based simulator. Throughput peaks near the eviction-free equilibrium x∗x^* and declines beyond it as eviction overhead grows. Table 8: Rate-limited admission eliminates eviction while improving throughput (model-based simulator with M=1000,l0=20,l1=20M=1000,l_0=20,l_1=20). Metric Baseline (Greedy) Rate-Limited (x∗x^*) Improvement Total Evictions (4000 steps) 2662 0 100% Effective Throughput (req/step) 1.33 1.61 20.7% Mean Eviction Rate 0.666 0.000 — Stability Unstable (periodic eviction) Stable (zero eviction) — D.5 Burst-window and burst-factor robustness This section combines the finite-window ablation with the burst-factor robustness sweeps. Mixing requires overlap among distinct request classes. Under bursty arrivals, a short high-rate window may end before the scheduler sees enough heterogeneous requests to form the intended mixed pool. Longer burst windows move the realized class mix closer to the target proportions, increase the probability of effective coprime mixing, and improve the performance of mixed routing. The burst-factor results are consistent with the same mechanism: mixing helps when the burst contains enough heterogeneity, while rate-limited admission remains the direct hard cap against temporary overshoot. Figure 30: Window-length ablation for finite burst mixing in the model-based simulator. Short bursts may not contain enough active classes to realize the intended coprime pool; longer bursts do. Figure 31: Robustness to periodic burst arrivals: coprime mixing in Vidur. The sweep compares baseline segregated routing, baseline mixed routing, rate-limited segregated routing, and rate-limited mixed routing. Figure 32: Robustness to periodic burst arrivals: partial-GCD reduction in Vidur. Mixed routing reduces the effective GCD to a value above one; rate limiting remains the policy that eliminates evictions over this horizon. Figure 33: Model-based robustness under periodic burst arrivals: coprime mixing. Mixing reduces eviction pressure under greedy admission, while rate-limited policies remain at zero eviction. Figure 34: Model-based robustness under periodic burst arrivals: partial-GCD reduction. Partial mixing improves the greedy baseline, while rate limiting remains the hard stability mechanism.