# Example 914 — Half the users was a quarter of the value `half_the_users_was_a_quarter_of_the_value.eml` - 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. ## EML ```eml # 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 ``` ## Python (deterministic transpilation) ```python 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.") ``` ## stdout (executed) ```text 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. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done