## Why do agents always employ the same algorithm when playing a congestion game?

I’ve been conducting research into congestion games and have come across many papers that study the effects on the outcome of a game played by agents employing a particular algorithm e.g. seeing how quickly Nash equilibrium is approached when using a modified version of fictitious play.

Is there any particular reason as to why there hasn’t been any research conducted that looks into agents using different algorithms playing a single congestion game? For example, agents who uses fictitious play playing alongside agents who use a q-learning algorithm.

## london – How do I know if I have got a congestion charge?

The congestion charge applies between 7am – 6pm Monday to Friday except bank holidays. The fee is £11.50 per vehicle per day if you pay in advance or before midnight on the day you enter the zone, but if you forget, you can still pay the fee up to midnight the following day but the price increases to £14. After that you incur a penalty.

Westminster Bridge is in the congestion zone.

## How is the London congestion charge administered?

I have a rental car and I’m not sure whether I drove through the zone over the last few days. How can I know whether I’m obligated to pay the charge, and if I am but have not done so, then what will happen?

## computer networks – tcp to avoid congestion

I came across this question:

``````At the beginning of transmission t, a TCP connection in congestion avoidance mode
has a congestion window w = 60 segments.Packet loss is observed during transmission
rounds t, t+10, and t+20 by getting multiple ACKs. What is the congestion window
at the end of round t, t + 10, and t + 20?

If there's no further packet loss, when will the window of w = 60 segments be reached again?
``````

``````Congestion window is halved during transmission round t, leading to w = 30. At the
beginning of transmission round t + 10, the window has increased to w = 40 but it will be
halved again during transmission round t + 10 to w = 20. Similarly, after transmission round
t + 20, the window will be w = 15. With no further packet loss, 45 transmission rounds later
at t + 65, the window will reach again the original size of w = 60.
``````

I know that due to multiple ACKs, packet loss cuts the window size in half. So at t + 10, w = 30 makes sense. However, I don't really get the rest. Why does the window size increase by 10? And at t + 20, why isn't it reduced to 10 instead of 15? If someone could explain the steps it would be great.

## computer networks – TCP congestion control problem

Assume that the maximum transmission window size for a TCP connection is 12000 bytes. Each packet consists of 2000 bytes. At some point, the connection is in a slow start phase with a current 4000 byte transmission window. Subsequently, the transmitter receives two acknowledgments. Assume no packets are lost and there are no waiting times. What is the maximum possible value of the current transmission window?

A) 4000 bytes

B) 8000 bytes

C) 10,000 bytes

D) 12000 bytes

In the congestion control algorithm, when we are in the slow start phase, after 1RTT (round trip time) if the window size exceeds the threshold when doubling, we set cwnd (current window size) = threshold or cwnd = 2 * cwnd?

How to solve this problem?

## Do multiple SSIDs affect congestion on Wi-Fi 6 networks?

Wi-Fi 6 has anti-congestion features, does this allow one to use an unlimited number * of SSID without causing interference?

* * A large number

## Optimization – Linear mathematical formulation of a congestion game.

I need to implement the following congestion game in AMPL:

Leave $$J = {1,2,3,4 }$$ be a set of jobs and leave $$M = {1,2,3 }$$ Be a set of machines.

• Work 1 can be solved by machines 1 and 2.
• Work 2 can be solved by machines 1 and 3.
• Work 3 can be solved by machines 2 and 3.
• Work 4 can be solved by machines 2 and 3.

Each job uses a single machine.

The time required by each machine to solve a job depends on its congestion (namely, the amount of different jobs assigned to the machine) as follows:

• Machine 1: $$time_1 =[1,3,5,7]$$
• Machine 2: $$time_2 =[2,4,6,8]$$
• Machine 3: $$time_3 =[3,4,5,6]$$

The element $$i$$ vector $$time_m$$ is equal to the time required by the machine $$m$$ given a congestion equal to $$i$$.

[e.g.] If machine 1 solves jobs 1 and 2, the congestion of the machine
1 is equal to 2, so the resolution of these works (1 and 2) requires
equal time to $$time_1 (2) = 3$$. (indexing starts from 1)

The objective is to solve all the works in such a way that the maximum time between the machines is minimal.

The problem with the implementation is that I need to use the variable "congestion" as an index and that is not allowed in AMPL.

Is there any way to implement this game as a linear problem in AMPL? What is the formulation of linear mathematical programming without using variables as indexes of the "time matrix" (the matrix has as rows) $$time_i$$)?