The shortcut made every commute longer

# Self-authored for the EML case corpus (no external origin). A city adds a
# free, instant shortcut between the two halves of its road network, every
# driver picks the fastest route given everyone else's choice, and the travel
# times are measured exactly. What the network settles to with the shortcut is
# computed below.
#
# The change is careful. The shortcut is genuinely free and instant; each driver
# chooses the fastest route given the others, and none can do better by
# switching alone; every driver is counted; and the intent is exactly 'faster
# commutes'.
#
# Selfish routing settles at an equilibrium, not an optimum, and the shortcut
# moves the equilibrium: with it, every driver takes both congested links, and
# every commute goes from 65 minutes to 80.

4000 => drivers
100 => drivers_per_minute_on_a_congested_link
45 => fixed_link_minutes

int(drivers / 2) => drivers_per_route_before
int(drivers_per_route_before / drivers_per_minute_on_a_congested_link) => congested_link_minutes_before
congested_link_minutes_before + fixed_link_minutes => commute_minutes_before
int(drivers / drivers_per_minute_on_a_congested_link) => congested_link_minutes_after
congested_link_minutes_after + congested_link_minutes_after => commute_minutes_after_via_shortcut
congested_link_minutes_after + fixed_link_minutes => commute_minutes_after_avoiding_shortcut
commute_minutes_after_via_shortcut - commute_minutes_before => minutes_added_per_driver
int(minutes_added_per_driver * 10000 / commute_minutes_before) => commute_slower_per_myriad

"drivers                         : " + str(drivers) ^0
"congested link                  : 1 minute per " + str(drivers_per_minute_on_a_congested_link) + " drivers on it" ^0
"fixed link                      : " + str(fixed_link_minutes) + " minutes regardless" ^0
"" ^0
"before the shortcut, per route  : " + str(drivers_per_route_before) + " drivers" ^0
"  congested link                : " + str(congested_link_minutes_before) + " min, plus fixed " + str(fixed_link_minutes) ^0
"  commute                       : " + str(commute_minutes_before) + " minutes, both routes" ^0
"" ^0
"after the shortcut, all drivers on both congested links" ^0
"  each congested link           : " + str(congested_link_minutes_after) + " min" ^0
"  commute via shortcut          : " + str(commute_minutes_after_via_shortcut) + " minutes" ^0
"  commute avoiding it           : " + str(commute_minutes_after_avoiding_shortcut) + " minutes, so nobody does" ^0
"minutes added per driver        : " + str(minutes_added_per_driver) ^0
"commute slower                  : " + str(commute_slower_per_myriad) + " per ten thousand" ^0
"" ^0

# ---- what the change verified ----

"the new shortcut" ^0
"  the link : genuinely free and instant" ^0
"  each driver : the fastest route given the others" ^0
"  stability : no driver can do better by switching alone" ^0
"  intent : faster commutes" ^0
"  drivers uncounted : 0" ^0
"  verdict : EVERY DRIVER IS ON THEIR BEST ROUTE" ^0
"" ^0
"  every driver being on a best response is the part done" ^0
"  right here, and it is why the 80-minute outcome is stable" ^0
"  rather than an accident" ^0
"" ^0

# ---- what the shortcut does to the equilibrium ----

"the two networks" ^0
"  without the shortcut : drivers split, each route one" ^0
"    congested link and one fixed, " + str(commute_minutes_before) + " minutes" ^0
"  with the shortcut : congested-then-shortcut-then-congested" ^0
"    beats either old route for any single driver" ^0
"  so all " + str(drivers) + " take it : both congested links carry everyone," ^0
"    " + str(congested_link_minutes_after) + " minutes each" ^0
"  can one driver improve by leaving : no; the old routes" ^0
"    now cost " + str(commute_minutes_after_avoiding_shortcut) ^0
"  so the network settles at : " + str(commute_minutes_after_via_shortcut) + ", worse for all" ^0
"" ^0

# ---- what the drivers got ----

"the commute" ^0
"  before : " + str(commute_minutes_before) + " minutes" ^0
"  after a free, instant link was added : " + str(commute_minutes_after_via_shortcut) + " minutes" ^0
"  is any travel time mismeasured : no" ^0
"  is any driver on a wrong route : no; each is on their" ^0
"    best" ^0
"  did adding capacity help : no; it moved where everyone" ^0
"    ends up" ^0
"" ^0

# ---- null control ----

# The same network with the shortcut closed (or tolled by its true congestion
# cost), returning the equilibrium to the split.
80 => nc_commute_with_the_free_shortcut
65 => nc_commute_with_the_shortcut_closed
15 => nc_minutes_per_driver_closing_it_saves

"null control - close the shortcut" ^0
"  commute with the free shortcut : " + str(nc_commute_with_the_free_shortcut) + " minutes" ^0
"  commute with it closed : " + str(nc_commute_with_the_shortcut_closed) + " minutes" ^0
"  minutes per driver closing it saves : " + str(nc_minutes_per_driver_closing_it_saves) ^0
"  no road and no driver changed; the network stopped" ^0
"  offering a move that is better alone and worse together" ^0
"" ^0

# ---- the rule ----

"what an equilibrium of best routes guarantees" ^0
"  no driver can shorten their own commute alone : exactly," ^0
"    every driver on a best response" ^0
"  commutes are as short as the network allows : not" ^0
"    addressed; the free shortcut moves the equilibrium from" ^0
"    " + str(commute_minutes_before) + " to " + str(commute_minutes_after_via_shortcut) + " minutes for every driver, and closing it" ^0
"    would give all of them back " + str(nc_minutes_per_driver_closing_it_saves) ^0
"" ^0

"more road is more choice, and a choice each driver takes because it is better" ^0
"for them can be worse for everyone once all of them take it; the network" ^0
"settles where no one can move, not where no one would want to be" ^0
"" ^0

"Every driver is on the fastest route given the others - the outcome is a true" ^0
"equilibrium. But the free, instant shortcut makes everyone take both congested" ^0
"links, and the commute goes from " + str(commute_minutes_before) + " to " + str(commute_minutes_after_via_shortcut) + " minutes for all " + str(drivers) + "," ^0
"" + str(commute_slower_per_myriad) + " per ten thousand slower, until the shortcut is closed." ^0

drivers = 4000
drivers_per_minute_on_a_congested_link = 100
fixed_link_minutes = 45
drivers_per_route_before = int(drivers / 2)
congested_link_minutes_before = int(drivers_per_route_before / drivers_per_minute_on_a_congested_link)
commute_minutes_before = congested_link_minutes_before + fixed_link_minutes
congested_link_minutes_after = int(drivers / drivers_per_minute_on_a_congested_link)
commute_minutes_after_via_shortcut = congested_link_minutes_after + congested_link_minutes_after
commute_minutes_after_avoiding_shortcut = congested_link_minutes_after + fixed_link_minutes
minutes_added_per_driver = commute_minutes_after_via_shortcut - commute_minutes_before
commute_slower_per_myriad = int(minutes_added_per_driver * 10000 / commute_minutes_before)
print("drivers                         : " + str(drivers))
print("congested link                  : 1 minute per " + str(drivers_per_minute_on_a_congested_link) + " drivers on it")
print("fixed link                      : " + str(fixed_link_minutes) + " minutes regardless")
print("")
print("before the shortcut, per route  : " + str(drivers_per_route_before) + " drivers")
print("  congested link                : " + str(congested_link_minutes_before) + " min, plus fixed " + str(fixed_link_minutes))
print("  commute                       : " + str(commute_minutes_before) + " minutes, both routes")
print("")
print("after the shortcut, all drivers on both congested links")
print("  each congested link           : " + str(congested_link_minutes_after) + " min")
print("  commute via shortcut          : " + str(commute_minutes_after_via_shortcut) + " minutes")
print("  commute avoiding it           : " + str(commute_minutes_after_avoiding_shortcut) + " minutes, so nobody does")
print("minutes added per driver        : " + str(minutes_added_per_driver))
print("commute slower                  : " + str(commute_slower_per_myriad) + " per ten thousand")
print("")
print("the new shortcut")
print("  the link : genuinely free and instant")
print("  each driver : the fastest route given the others")
print("  stability : no driver can do better by switching alone")
print("  intent : faster commutes")
print("  drivers uncounted : 0")
print("  verdict : EVERY DRIVER IS ON THEIR BEST ROUTE")
print("")
print("  every driver being on a best response is the part done")
print("  right here, and it is why the 80-minute outcome is stable")
print("  rather than an accident")
print("")
print("the two networks")
print("  without the shortcut : drivers split, each route one")
print("    congested link and one fixed, " + str(commute_minutes_before) + " minutes")
print("  with the shortcut : congested-then-shortcut-then-congested")
print("    beats either old route for any single driver")
print("  so all " + str(drivers) + " take it : both congested links carry everyone,")
print("    " + str(congested_link_minutes_after) + " minutes each")
print("  can one driver improve by leaving : no; the old routes")
print("    now cost " + str(commute_minutes_after_avoiding_shortcut))
print("  so the network settles at : " + str(commute_minutes_after_via_shortcut) + ", worse for all")
print("")
print("the commute")
print("  before : " + str(commute_minutes_before) + " minutes")
print("  after a free, instant link was added : " + str(commute_minutes_after_via_shortcut) + " minutes")
print("  is any travel time mismeasured : no")
print("  is any driver on a wrong route : no; each is on their")
print("    best")
print("  did adding capacity help : no; it moved where everyone")
print("    ends up")
print("")
nc_commute_with_the_free_shortcut = 80
nc_commute_with_the_shortcut_closed = 65
nc_minutes_per_driver_closing_it_saves = 15
print("null control - close the shortcut")
print("  commute with the free shortcut : " + str(nc_commute_with_the_free_shortcut) + " minutes")
print("  commute with it closed : " + str(nc_commute_with_the_shortcut_closed) + " minutes")
print("  minutes per driver closing it saves : " + str(nc_minutes_per_driver_closing_it_saves))
print("  no road and no driver changed; the network stopped")
print("  offering a move that is better alone and worse together")
print("")
print("what an equilibrium of best routes guarantees")
print("  no driver can shorten their own commute alone : exactly,")
print("    every driver on a best response")
print("  commutes are as short as the network allows : not")
print("    addressed; the free shortcut moves the equilibrium from")
print("    " + str(commute_minutes_before) + " to " + str(commute_minutes_after_via_shortcut) + " minutes for every driver, and closing it")
print("    would give all of them back " + str(nc_minutes_per_driver_closing_it_saves))
print("")
print("more road is more choice, and a choice each driver takes because it is better")
print("for them can be worse for everyone once all of them take it; the network")
print("settles where no one can move, not where no one would want to be")
print("")
print("Every driver is on the fastest route given the others - the outcome is a true")
print("equilibrium. But the free, instant shortcut makes everyone take both congested")
print("links, and the commute goes from " + str(commute_minutes_before) + " to " + str(commute_minutes_after_via_shortcut) + " minutes for all " + str(drivers) + ",")
print("" + str(commute_slower_per_myriad) + " per ten thousand slower, until the shortcut is closed.")

drivers                         : 4000
congested link                  : 1 minute per 100 drivers on it
fixed link                      : 45 minutes regardless

before the shortcut, per route  : 2000 drivers
  congested link                : 20 min, plus fixed 45
  commute                       : 65 minutes, both routes

after the shortcut, all drivers on both congested links
  each congested link           : 40 min
  commute via shortcut          : 80 minutes
  commute avoiding it           : 85 minutes, so nobody does
minutes added per driver        : 15
commute slower                  : 2307 per ten thousand

the new shortcut
  the link : genuinely free and instant
  each driver : the fastest route given the others
  stability : no driver can do better by switching alone
  intent : faster commutes
  drivers uncounted : 0
  verdict : EVERY DRIVER IS ON THEIR BEST ROUTE

  every driver being on a best response is the part done
  right here, and it is why the 80-minute outcome is stable
  rather than an accident

the two networks
  without the shortcut : drivers split, each route one
    congested link and one fixed, 65 minutes
  with the shortcut : congested-then-shortcut-then-congested
    beats either old route for any single driver
  so all 4000 take it : both congested links carry everyone,
    40 minutes each
  can one driver improve by leaving : no; the old routes
    now cost 85
  so the network settles at : 80, worse for all

the commute
  before : 65 minutes
  after a free, instant link was added : 80 minutes
  is any travel time mismeasured : no
  is any driver on a wrong route : no; each is on their
    best
  did adding capacity help : no; it moved where everyone
    ends up

null control - close the shortcut
  commute with the free shortcut : 80 minutes
  commute with it closed : 65 minutes
  minutes per driver closing it saves : 15
  no road and no driver changed; the network stopped
  offering a move that is better alone and worse together

what an equilibrium of best routes guarantees
  no driver can shorten their own commute alone : exactly,
    every driver on a best response
  commutes are as short as the network allows : not
    addressed; the free shortcut moves the equilibrium from
    65 to 80 minutes for every driver, and closing it
    would give all of them back 15

more road is more choice, and a choice each driver takes because it is better
for them can be worse for everyone once all of them take it; the network
settles where no one can move, not where no one would want to be

Every driver is on the fastest route given the others - the outcome is a true
equilibrium. But the free, instant shortcut makes everyone take both congested
links, and the commute goes from 65 to 80 minutes for all 4000,
2307 per ten thousand slower, until the shortcut is closed.

Trace event types