The game consists of information providers trying to deliver new information daily to a large random population spread out on a fixed number of backbone networks.  The providers want to reach as many users as possible, using any combination of direct delivery through the backbone and local caching. The game is a competition between providers to maximize profit, which is the value of users reached minus the cost to reach them.

• There are N information providers competing.
  
• Each day, each provider gets X bytes of new information (e.g. web pages, videos, data files, etc.). The  amount X is the same for all providers and is known at the beginning of the day. X changes every day following a known probability distribution F. F is a power law distribution with alpha = 3, i.e. F(x) = 1 - P (X >x) = 1- (x_min/x)^2, for x >= xmin, and 0 otherwise. Let x_min = 0.5 Gbytes.
  
• Each user will "consume" the day's information once and only once, within the same day. When a user consumes the information, the provider who delivered it gets a reward of V dollars.

• The users are on K different networks. Each user is on only one network. For each network, k = 1, ..., K, the demand D_k is the number of users on that network, which changes every day following a known probability distribution G. G is an exponential distribution, G(d) = 1- exp(-lambda d), for d >= 0 and 0 otherwise. Let lambda = 1/10,000.
• The networks have known fixed bandwidth capacity C_k, k= 1, ..., K.
  
• The  providers have different ways to deliver the information to the users.
1. A user can "download" it from the provider directly across the network that user is on. The network bandwidth costs the information provider P_b $/byte.
   
2. The provider can "cache" at most one local copy of the information in each network, so that users on that network download the local copy in the network they are on. Caching costs the provider a setup fee of S_c = $10,000 each time (independently of size in bytes), plus P_c $/byte in storage and zero in bandwidth.
   
• Most users prefer a locally cached copy if one is available because it's faster for them, i.e. if there is at least one cached copy in network k, then q D_k users will get the local copy in network k, and (1-q) D_k will download for some q > 0.5. Otherwirse, all D_k users will download.
  
• All the locally cached copies are equal to the users. So if, as a result of the providers there are m cached copies in network k, each copy will be accessed by q D_k /m users
• The providers have equal access to the networks, so each of the providers will get (1-q)D_k/N  downloads
• If the network bandwidth gets congested, i.e. (1-q)D_k > C_k, then all the transmissions across  that network fail i.e the users don't consume the information and none of the providers get the reward. However they still pay the cost of the bandwidth. The cached copies are not affected by congestion.
  

1. At the beginning of each day, the system generates  today's value of X and gives it to each of the players. 
   
2. Each player replies with a boolean action vector a_i = [a_i1 , ...., a_iK] representing his decisions to cache. Thus a_ik = TRUE means that provider i decided to cache in network k, and a_ik = FALSE means the opposite. 
3. The system then generates demand D_k for all k, divides it among the N players following the above rules to get b_ik, the number of users who download directly from provider i, and c_ik the number of users who get it from i's cached copy.
   
4. For each player i, the system increments the score by U_i = R_i - B_i - L_i, where
• total reward R_i = sum_k [(1((1-q)D_k < C_k)b_ik + c_ik)V],  where m_k = sum_{k, a_ik > 0} 1 = # of k such that a_ik > 0;
  
• bandwidth cost B_i =  sum_k [- X P_b b_ik] and
  
• total caching cost L_i  = sum_k [ (P_c X + S_c) a_ik]
5. The sytem sends each player i the 2K values: b_ik and c_ik