Edge Resource Competition Game

• Edge Resource Competition (ERC) Game is a unifying abstraction of game-theoretic models where strategic agents compete for scarce edge resources like computing, storage, and bandwidth.
• The models employ hierarchical dynamics with user demand and provider supply, integrating replicator dynamics and Stackelberg leadership to analyze equilibria.
• ERC formulations leverage state variables such as congestion, pricing, and resource allocation to explore user offloading, provider cooperation, and adversarial competition.

Searching arXiv for the papers on arXiv and closely related ERC formulations. Edge Resource Competition (ERC) Game denotes a family of game-theoretic models in which strategic agents compete over scarce edge-side resources such as computing capacity, storage, bandwidth, servers, edge locations, or purchasable network resources, with payoffs shaped by congestion, service quality, prices, coalition structure, and information asymmetry. In the current literature, ERC is best understood as a unifying abstraction rather than a single canonical model: it appears in hierarchical edge–cloud service selection and cloud-resource trading, user-side task-offloading games, cooperative provider-level sharing, decentralized edge caching, bargaining-and-matching in vehicular edge computing, topological hub–periphery competition, and abstract resource-allocation templates such as resource buying and neighbourhood balancing (Du et al., 2021, Cao et al., 2017, Yang et al., 2018, Sun et al., 2022, Sedghani et al., 5 May 2026, Harks et al., 2012, Auger et al., 2023).

1. Conceptual scope and constituent elements

An ERC game is defined by three ingredients: a scarce edge resource, strategic agents whose decisions are mutually coupled through that resource, and an equilibrium concept that stabilizes the resulting competition. Across the literature, the agents can be user populations, mobile devices, edge computing service providers, cloud providers, content providers, edge devices, vehicles, vehicular edge servers, or adversarial teams on a network. The resources under contention include CPU cycles, cloud capacity sold upstream to edge providers, server counts, storage slots, edge nodes or regions, and even subsets of graph edges or battlefields in abstract allocation models (Du et al., 2021, Yang et al., 2018, Sedghani et al., 5 May 2026, Ferdowsi et al., 2017, Harks et al., 2012).

The recurring architectural pattern is hierarchical. One layer captures demand-side competition—users choosing where to offload, subscribe, cache, or route—while another captures supply-side competition—providers setting prices, requesting upstream resources, allocating capacity, or forming coalitions. In the SDN-managed hybrid edge–cloud model, for example, users evolve by replicator dynamics while a cloud computing provider acts as Stackelberg leader over multiple edge providers (Du et al., 2021). In vehicular edge computing, task requesters and servers bargain over price and compute allocation, and then compete through a many-to-one matching process (Sun et al., 2022). In cooperative resource sharing, service providers first satisfy native applications and then share the remaining resources with others, so competition is transformed into coalition formation over surplus capacity (Zafari et al., 2020, Zafari et al., 2018).

A common misconception is to identify ERC only with user offloading. The literature shows a wider scope. ERC can be user-vs-user competition for queueing service, provider-vs-provider competition for users, provider-vs-provider competition for upstream cloud or storage, or even adversarial competition over network position and reserve placement (Yang et al., 2018, Du et al., 2021, Sedghani et al., 5 May 2026, Cullen et al., 2023).

2. Strategic variables, constraints, and payoff structures

Despite their heterogeneity, ERC models use a small set of reusable state and control variables. User-population models employ population shares such as

$$\mathbf{x}(t) = [x_1(t),\dots,x_N(t),x_c(t)]^T,\qquad \sum_i x_i(t)=1,$$

with provider-side controls such as cloud price $p(t)$ and purchased cloud shares $r_n(t)$ satisfying

$\sum_{n=1}^N r_n(t) + r_c(t) = 1.$

In that setting, the per-user computing rates are

$$\omega_n(\mathbf x,\mathbf r)=\frac{R_n+R_c r_n(t)}{Kx_n(t)},\qquad \omega_c(\mathbf x,\mathbf r)=\frac{R_c\left(1-\sum_{n=1}^N r_n(t)\right)}{Kx_c(t)},$$

and user payoff is explicitly of the form “computing power divided by price,” namely

$$\pi_n(n,\mathbf x,\mathbf r)=\frac{\beta\,\omega_n(\mathbf x,\mathbf r)}{p_n},\qquad \pi_c(c,\mathbf x,\mathbf r)=\frac{\beta\,\omega_c(\mathbf x,\mathbf r)}{p_c}.$$

This makes the competitive mechanism transparent: more capacity or lower fee attracts demand; more congestion repels