Half the users was a quarter of the value

# Self-authored for the EML case corpus (no external origin). A messaging
# network is valued by its user count, a rival has exactly half as many users,
# and the rival is priced at half. What the users of a network are actually
# connected by is computed below.
#
# The valuation is careful. Both user counts are real and audited; half is
# exactly half; the price is scaled in proportion to the count; and the intent
# is exactly 'price the rival relative to the leader'.
#
# What a user of a network gets is the other users they can reach, and the
# number of connections grows with the square of the users, so half the users
# is a quarter of the connections - and a quarter, not a half, of what the
# network is for.

1000 => users_leader
500 => users_rival

users_leader - 1 => users_leader_minus_one
int(users_leader * users_leader_minus_one / 2) => connections_leader
users_rival - 1 => users_rival_minus_one
int(users_rival * users_rival_minus_one / 2) => connections_rival
int(users_rival * 10000 / users_leader) => rival_share_of_users_per_myriad
int(connections_rival * 10000 / connections_leader) => rival_share_of_connections_per_myriad
rival_share_of_users_per_myriad - rival_share_of_connections_per_myriad => share_the_head_count_overstates_per_myriad

"users, leader                   : " + str(users_leader) ^0
"users, rival                    : " + str(users_rival) + ", " + str(rival_share_of_users_per_myriad) + " per ten thousand of the leader" ^0
"rival priced at                 : " + str(rival_share_of_users_per_myriad) + " per ten thousand of the leader" ^0
"" ^0
"connections, leader             : " + str(connections_leader) ^0
"connections, rival              : " + str(connections_rival) + ", " + str(rival_share_of_connections_per_myriad) + " per ten thousand of the leader" ^0
"head count overstates by        : " + str(share_the_head_count_overstates_per_myriad) + " per ten thousand" ^0
"" ^0

# ---- what the valuation verified ----

"the per-user valuation" ^0
"  counts : real and audited, both" ^0
"  ratio : exactly half" ^0
"  price : scaled in proportion to the count" ^0
"  intent : price the rival relative to the leader" ^0
"  users double-counted : 0" ^0
"  verdict : HALF THE USERS, HALF THE PRICE" ^0
"" ^0
"  auditing the real counts and scaling exactly is the part" ^0
"  done right here, and it is why half is precisely the" ^0
"  rival's share of the people" ^0
"" ^0

# ---- what users are connected by ----

"the network" ^0
"  what a user joins for : the others they can reach" ^0
"  what a user can reach : every other user, a pair each" ^0
"  pairs among " + str(users_leader) + " : " + str(connections_leader) ^0
"  pairs among " + str(users_rival) + " : " + str(connections_rival) ^0
"  so the rival offers each user : half as many people to" ^0
"    reach, and has half as many users to offer it to" ^0
"  half of a half : a quarter" ^0
"" ^0

# ---- what the buyer got ----

"the price" ^0
"  paid : half the leader" ^0
"  connections bought : a quarter of the leader's" ^0
"  is either count wrong : no" ^0
"  is a user the unit of a network's worth : no; a" ^0
"    connection is, and connections go as the square" ^0
"" ^0

# ---- null control ----

# The same two networks priced on connections (or on activity between users)
# rather than on head count.
5000 => nc_rival_share_priced_on_users_per_myriad
2495 => nc_rival_share_priced_on_connections_per_myriad
2505 => nc_overpayment_the_connection_basis_removes_per_myriad

"null control - price on connections, not on users" ^0
"  rival share, priced on users : " + str(nc_rival_share_priced_on_users_per_myriad) + " per ten thousand" ^0
"  rival share, priced on connections : " + str(nc_rival_share_priced_on_connections_per_myriad) + " per ten thousand" ^0
"  overpayment the connection basis removes : " + str(nc_overpayment_the_connection_basis_removes_per_myriad) + " per ten thousand" ^0
"  no user and no count changed; the unit of value stopped" ^0
"  being a head" ^0
"" ^0

# ---- the rule ----

"what a head-count valuation guarantees" ^0
"  the rival has half the people : exactly, audited counts," ^0
"    exact ratio" ^0
"  the rival is worth half : not addressed; a network's worth" ^0
"    is in its connections, which grow as the square, so half" ^0
"    the users is " + str(rival_share_of_connections_per_myriad) + " per ten thousand of the connections, not " + str(rival_share_of_users_per_myriad) ^0
"" ^0

"a network is not its members but the lines between them, and lines grow as" ^0
"the square of members; a price set on heads is set on the root of the thing" ^0
"being bought, and every halving of heads is a quartering of what they join" ^0
"" ^0

"Both counts are audited and half is exactly half - the rival really has " + str(users_rival) ^0
"users to the leader's " + str(users_leader) + ". But users are connected pairwise, and " + str(connections_rival) ^0
"connections is " + str(rival_share_of_connections_per_myriad) + " per ten thousand of " + str(connections_leader) + ", so half the users is a quarter of" ^0
"the network, " + str(share_the_head_count_overstates_per_myriad) + " per ten thousand overpaid on head count, until the price follows the connections." ^0

users_leader = 1000
users_rival = 500
users_leader_minus_one = users_leader - 1
connections_leader = int(users_leader * users_leader_minus_one / 2)
users_rival_minus_one = users_rival - 1
connections_rival = int(users_rival * users_rival_minus_one / 2)
rival_share_of_users_per_myriad = int(users_rival * 10000 / users_leader)
rival_share_of_connections_per_myriad = int(connections_rival * 10000 / connections_leader)
share_the_head_count_overstates_per_myriad = rival_share_of_users_per_myriad - rival_share_of_connections_per_myriad
print("users, leader                   : " + str(users_leader))
print("users, rival                    : " + str(users_rival) + ", " + str(rival_share_of_users_per_myriad) + " per ten thousand of the leader")
print("rival priced at                 : " + str(rival_share_of_users_per_myriad) + " per ten thousand of the leader")
print("")
print("connections, leader             : " + str(connections_leader))
print("connections, rival              : " + str(connections_rival) + ", " + str(rival_share_of_connections_per_myriad) + " per ten thousand of the leader")
print("head count overstates by        : " + str(share_the_head_count_overstates_per_myriad) + " per ten thousand")
print("")
print("the per-user valuation")
print("  counts : real and audited, both")
print("  ratio : exactly half")
print("  price : scaled in proportion to the count")
print("  intent : price the rival relative to the leader")
print("  users double-counted : 0")
print("  verdict : HALF THE USERS, HALF THE PRICE")
print("")
print("  auditing the real counts and scaling exactly is the part")
print("  done right here, and it is why half is precisely the")
print("  rival's share of the people")
print("")
print("the network")
print("  what a user joins for : the others they can reach")
print("  what a user can reach : every other user, a pair each")
print("  pairs among " + str(users_leader) + " : " + str(connections_leader))
print("  pairs among " + str(users_rival) + " : " + str(connections_rival))
print("  so the rival offers each user : half as many people to")
print("    reach, and has half as many users to offer it to")
print("  half of a half : a quarter")
print("")
print("the price")
print("  paid : half the leader")
print("  connections bought : a quarter of the leader's")
print("  is either count wrong : no")
print("  is a user the unit of a network's worth : no; a")
print("    connection is, and connections go as the square")
print("")
nc_rival_share_priced_on_users_per_myriad = 5000
nc_rival_share_priced_on_connections_per_myriad = 2495
nc_overpayment_the_connection_basis_removes_per_myriad = 2505
print("null control - price on connections, not on users")
print("  rival share, priced on users : " + str(nc_rival_share_priced_on_users_per_myriad) + " per ten thousand")
print("  rival share, priced on connections : " + str(nc_rival_share_priced_on_connections_per_myriad) + " per ten thousand")
print("  overpayment the connection basis removes : " + str(nc_overpayment_the_connection_basis_removes_per_myriad) + " per ten thousand")
print("  no user and no count changed; the unit of value stopped")
print("  being a head")
print("")
print("what a head-count valuation guarantees")
print("  the rival has half the people : exactly, audited counts,")
print("    exact ratio")
print("  the rival is worth half : not addressed; a network's worth")
print("    is in its connections, which grow as the square, so half")
print("    the users is " + str(rival_share_of_connections_per_myriad) + " per ten thousand of the connections, not " + str(rival_share_of_users_per_myriad))
print("")
print("a network is not its members but the lines between them, and lines grow as")
print("the square of members; a price set on heads is set on the root of the thing")
print("being bought, and every halving of heads is a quartering of what they join")
print("")
print("Both counts are audited and half is exactly half - the rival really has " + str(users_rival))
print("users to the leader's " + str(users_leader) + ". But users are connected pairwise, and " + str(connections_rival))
print("connections is " + str(rival_share_of_connections_per_myriad) + " per ten thousand of " + str(connections_leader) + ", so half the users is a quarter of")
print("the network, " + str(share_the_head_count_overstates_per_myriad) + " per ten thousand overpaid on head count, until the price follows the connections.")

users, leader                   : 1000
users, rival                    : 500, 5000 per ten thousand of the leader
rival priced at                 : 5000 per ten thousand of the leader

connections, leader             : 499500
connections, rival              : 124750, 2497 per ten thousand of the leader
head count overstates by        : 2503 per ten thousand

the per-user valuation
  counts : real and audited, both
  ratio : exactly half
  price : scaled in proportion to the count
  intent : price the rival relative to the leader
  users double-counted : 0
  verdict : HALF THE USERS, HALF THE PRICE

  auditing the real counts and scaling exactly is the part
  done right here, and it is why half is precisely the
  rival's share of the people

the network
  what a user joins for : the others they can reach
  what a user can reach : every other user, a pair each
  pairs among 1000 : 499500
  pairs among 500 : 124750
  so the rival offers each user : half as many people to
    reach, and has half as many users to offer it to
  half of a half : a quarter

the price
  paid : half the leader
  connections bought : a quarter of the leader's
  is either count wrong : no
  is a user the unit of a network's worth : no; a
    connection is, and connections go as the square

null control - price on connections, not on users
  rival share, priced on users : 5000 per ten thousand
  rival share, priced on connections : 2495 per ten thousand
  overpayment the connection basis removes : 2505 per ten thousand
  no user and no count changed; the unit of value stopped
  being a head

what a head-count valuation guarantees
  the rival has half the people : exactly, audited counts,
    exact ratio
  the rival is worth half : not addressed; a network's worth
    is in its connections, which grow as the square, so half
    the users is 2497 per ten thousand of the connections, not 5000

a network is not its members but the lines between them, and lines grow as
the square of members; a price set on heads is set on the root of the thing
being bought, and every halving of heads is a quartering of what they join

Both counts are audited and half is exactly half - the rival really has 500
users to the leader's 1000. But users are connected pairwise, and 124750
connections is 2497 per ten thousand of 499500, so half the users is a quarter of
the network, 2503 per ten thousand overpaid on head count, until the price follows the connections.

Trace event types