The reviewer got stricter and the author leaned on it

# Self-authored for the EML case corpus (no external origin). Review got
# stricter because defects were escaping, and self-checking got lighter because
# review was catching things. Where the pair settles is simulated.
#
# Both adjustments are correct responses to correct evidence. The reviewer saw
# defects reach production and looked harder, which found more. The author saw
# review catching things reliably and spent the pre-submit hour on the next
# change instead, which is what a working review process is for.
#
# Effort spent by one party is evidence for the other party about how much to
# spend. Neither is optimising the pair, and neither can see the other's
# number, so the total lands wherever the two adjustments meet.
#
# Ten rounds are run and every quantity is computed from the pair.

20 => base_defects
12 => rounds
2 => escape_tolerance
5 => reliance_threshold

"a change carries " + str(base_defects) + " latent defects before any effort" ^0
"author effort removes 1 each; review effort catches 2 each" ^0
"" ^0

6 => author
2 => reviewer
0 => total_author
0 => total_reviewer
0 => total_escaped
0 => t
"round   author   reviewer   caught   escaped   review days" ^0
while t < rounds:
    base_defects - author => written
    if written < 0:
        0 => written
    reviewer * 2 => caught
    if written < caught:
        written => caught
    written - caught => escaped
    total_author + author => total_author
    total_reviewer + reviewer => total_reviewer
    total_escaped + escaped => total_escaped
    t + 1 => t
    if t <= 6:
        "  " + str(t) + "       " + str(author) + "        " + str(reviewer) + "          " + str(caught) + "        " + str(escaped) + "         " + str(reviewer) ^0
    author => next_author
    reviewer => next_reviewer
    if escaped > escape_tolerance:
        reviewer + 1 => next_reviewer
    if caught >= reliance_threshold:
        author - 1 => next_author
    if next_author < 0:
        0 => next_author
    if next_reviewer > 10:
        10 => next_reviewer
    next_author => author
    next_reviewer => reviewer
"" ^0

"where it settles" ^0
"  author effort   : 6 at the start, " + str(author) + " at the end" ^0
"  reviewer effort : 2 at the start, " + str(reviewer) + " at the end" ^0
"  effort per change, start : " + str(6 + 2) ^0
"  effort per change, end   : " + str(author + reviewer) ^0
if author + reviewer > 8:
    "  the pair spends " + str(author + reviewer - 8) + " more than it started with" ^0
elif author + reviewer == 8:
    "  the pair spends exactly what it started with, in a different place" ^0
else:
    "  the pair spends " + str(8 - author - reviewer) + " less than it started with" ^0
"" ^0

"escaped defects, over " + str(rounds) + " rounds : " + str(total_escaped) ^0
"  author effort spent   : " + str(total_author) ^0
"  reviewer effort spent : " + str(total_reviewer) ^0
"" ^0

# ---- what the same total effort buys if it is placed rather than negotiated ----
#
# The two efforts are not interchangeable: one removes a defect, the other
# catches two. A pair that could see both numbers would not split it this way.

author + reviewer => budget
0 => best_escaped
0 => best_a
0 => first
for a in [0:budget]:
    budget - a => r
    base_defects - a => w
    if w < 0:
        0 => w
    r * 2 => c
    if w < c:
        w => c
    w - c => e
    if first == 0:
        e => best_escaped
        a => best_a
        1 => first
    if e < best_escaped:
        e => best_escaped
        a => best_a
"the same budget of " + str(budget) + ", split every possible way" ^0
"  best split : author " + str(best_a) + ", reviewer " + str(budget - best_a) + ", escaping " + str(best_escaped) ^0
base_defects - author => w_now
if w_now < 0:
    0 => w_now
reviewer * 2 => c_now
if w_now < c_now:
    w_now => c_now
w_now - c_now => e_now
"  where it settled : author " + str(author) + ", reviewer " + str(reviewer) + ", escaping " + str(e_now) ^0
if e_now > best_escaped:
    "  the negotiated split lets " + str(e_now - best_escaped) + " more through for the same effort" ^0
elif e_now == best_escaped:
    "  the two coincide: mutual adjustment landed on the efficient split," ^0
    "  which it should, because review effort here is twice as productive" ^0
    "  as author effort and the pair kept moving until that showed" ^0
"" ^0

# ---- what the journey cost ----
#
# The destination is right. It was reached one increment per round, and every
# round before it ran at the split it had reached so far.

best_escaped * rounds => ideal_total
"escapes if the efficient split had been chosen on the first day" ^0
"  " + str(best_escaped) + " per round over " + str(rounds) + " rounds : " + str(ideal_total) ^0
"escapes actually incurred : " + str(total_escaped) ^0
if total_escaped > ideal_total:
    "  the difference is " + str(total_escaped - ideal_total) + ", which is what discovering the split by" ^0
    "  mutual adjustment cost, at " + str(int((total_escaped - ideal_total) * 100 / ideal_total)) + "% on top" ^0
"  neither party could have named the split earlier: it depends on both" ^0
"  productivities, and each of them knows only its own" ^0
"" ^0

# ---- what each party sees ----

"each party reading only its own instrument" ^0
"  the reviewer sees : defects it catches, which rose" ^0
"  the author sees   : defects it is told about, which rose" ^0
"  both read a rising number as evidence their own adjustment was right" ^0
"  neither reads " + str(total_escaped) + ", the count that reached production" ^0
"" ^0

# ---- the control: a party that cannot observe the other ----
#
# Where the author never learns what review caught, there is no signal to lean
# on, and the effort stays where it was put.

6 => c_author
2 => c_reviewer
0 => ct
while ct < rounds:
    base_defects - c_author => w
    c_reviewer * 2 => c
    if w < c:
        w => c
    w - c => e
    if e > escape_tolerance:
        c_reviewer + 1 => c_reviewer
    if c_reviewer > 10:
        10 => c_reviewer
    ct + 1 => ct
"control - the author is never told what review caught" ^0
"  author effort at the end   : " + str(c_author) ^0
"  reviewer effort at the end : " + str(c_reviewer) ^0
if c_author == 6:
    "  unchanged, because the signal it was responding to was the other party" ^0
"" ^0

"Two parties each adjusting on their own signal reached the split neither" ^0
"could compute, one increment at a time. What the search cost is the defects" ^0
"that escaped while it was still searching." ^0

base_defects = 20
rounds = 12
escape_tolerance = 2
reliance_threshold = 5
print("a change carries " + str(base_defects) + " latent defects before any effort")
print("author effort removes 1 each; review effort catches 2 each")
print("")
author = 6
reviewer = 2
total_author = 0
total_reviewer = 0
total_escaped = 0
t = 0
print("round   author   reviewer   caught   escaped   review days")
while t < rounds:
    written = base_defects - author
    if written < 0:
        written = 0
    caught = reviewer * 2
    if written < caught:
        caught = written
    escaped = written - caught
    total_author = total_author + author
    total_reviewer = total_reviewer + reviewer
    total_escaped = total_escaped + escaped
    t = t + 1
    if t <= 6:
        print("  " + str(t) + "       " + str(author) + "        " + str(reviewer) + "          " + str(caught) + "        " + str(escaped) + "         " + str(reviewer))
    next_author = author
    next_reviewer = reviewer
    if escaped > escape_tolerance:
        next_reviewer = reviewer + 1
    if caught >= reliance_threshold:
        next_author = author - 1
    if next_author < 0:
        next_author = 0
    if next_reviewer > 10:
        next_reviewer = 10
    author = next_author
    reviewer = next_reviewer
print("")
print("where it settles")
print("  author effort   : 6 at the start, " + str(author) + " at the end")
print("  reviewer effort : 2 at the start, " + str(reviewer) + " at the end")
print("  effort per change, start : " + str(6 + 2))
print("  effort per change, end   : " + str(author + reviewer))
if author + reviewer > 8:
    print("  the pair spends " + str(author + reviewer - 8) + " more than it started with")
elif author + reviewer == 8:
    print("  the pair spends exactly what it started with, in a different place")
else:
    print("  the pair spends " + str(8 - author - reviewer) + " less than it started with")
print("")
print("escaped defects, over " + str(rounds) + " rounds : " + str(total_escaped))
print("  author effort spent   : " + str(total_author))
print("  reviewer effort spent : " + str(total_reviewer))
print("")
budget = author + reviewer
best_escaped = 0
best_a = 0
first = 0
for a in range(0, budget+1):
    r = budget - a
    w = base_defects - a
    if w < 0:
        w = 0
    c = r * 2
    if w < c:
        c = w
    e = w - c
    if first == 0:
        best_escaped = e
        best_a = a
        first = 1
    if e < best_escaped:
        best_escaped = e
        best_a = a
print("the same budget of " + str(budget) + ", split every possible way")
print("  best split : author " + str(best_a) + ", reviewer " + str(budget - best_a) + ", escaping " + str(best_escaped))
w_now = base_defects - author
if w_now < 0:
    w_now = 0
c_now = reviewer * 2
if w_now < c_now:
    c_now = w_now
e_now = w_now - c_now
print("  where it settled : author " + str(author) + ", reviewer " + str(reviewer) + ", escaping " + str(e_now))
if e_now > best_escaped:
    print("  the negotiated split lets " + str(e_now - best_escaped) + " more through for the same effort")
elif e_now == best_escaped:
    print("  the two coincide: mutual adjustment landed on the efficient split,")
    print("  which it should, because review effort here is twice as productive")
    print("  as author effort and the pair kept moving until that showed")
print("")
ideal_total = best_escaped * rounds
print("escapes if the efficient split had been chosen on the first day")
print("  " + str(best_escaped) + " per round over " + str(rounds) + " rounds : " + str(ideal_total))
print("escapes actually incurred : " + str(total_escaped))
if total_escaped > ideal_total:
    print("  the difference is " + str(total_escaped - ideal_total) + ", which is what discovering the split by")
    print("  mutual adjustment cost, at " + str(int((total_escaped - ideal_total) * 100 / ideal_total)) + "% on top")
print("  neither party could have named the split earlier: it depends on both")
print("  productivities, and each of them knows only its own")
print("")
print("each party reading only its own instrument")
print("  the reviewer sees : defects it catches, which rose")
print("  the author sees   : defects it is told about, which rose")
print("  both read a rising number as evidence their own adjustment was right")
print("  neither reads " + str(total_escaped) + ", the count that reached production")
print("")
c_author = 6
c_reviewer = 2
ct = 0
while ct < rounds:
    w = base_defects - c_author
    c = c_reviewer * 2
    if w < c:
        c = w
    e = w - c
    if e > escape_tolerance:
        c_reviewer = c_reviewer + 1
    if c_reviewer > 10:
        c_reviewer = 10
    ct = ct + 1
print("control - the author is never told what review caught")
print("  author effort at the end   : " + str(c_author))
print("  reviewer effort at the end : " + str(c_reviewer))
if c_author == 6:
    print("  unchanged, because the signal it was responding to was the other party")
print("")
print("Two parties each adjusting on their own signal reached the split neither")
print("could compute, one increment at a time. What the search cost is the defects")
print("that escaped while it was still searching.")

a change carries 20 latent defects before any effort
author effort removes 1 each; review effort catches 2 each

round   author   reviewer   caught   escaped   review days
  1       6        2          4        10         2
  2       6        3          6        8         3
  3       5        4          8        7         4
  4       4        5          10        6         5
  5       3        6          12        5         6
  6       2        7          14        4         7

where it settles
  author effort   : 6 at the start, 0 at the end
  reviewer effort : 2 at the start, 9 at the end
  effort per change, start : 8
  effort per change, end   : 9
  the pair spends 1 more than it started with

escaped defects, over 12 rounds : 53
  author effort spent   : 27
  reviewer effort spent : 80

the same budget of 9, split every possible way
  best split : author 0, reviewer 9, escaping 2
  where it settled : author 0, reviewer 9, escaping 2
  the two coincide: mutual adjustment landed on the efficient split,
  which it should, because review effort here is twice as productive
  as author effort and the pair kept moving until that showed

escapes if the efficient split had been chosen on the first day
  2 per round over 12 rounds : 24
escapes actually incurred : 53
  the difference is 29, which is what discovering the split by
  mutual adjustment cost, at 120% on top
  neither party could have named the split earlier: it depends on both
  productivities, and each of them knows only its own

each party reading only its own instrument
  the reviewer sees : defects it catches, which rose
  the author sees   : defects it is told about, which rose
  both read a rising number as evidence their own adjustment was right
  neither reads 53, the count that reached production

control - the author is never told what review caught
  author effort at the end   : 6
  reviewer effort at the end : 6
  unchanged, because the signal it was responding to was the other party

Two parties each adjusting on their own signal reached the split neither
could compute, one increment at a time. What the search cost is the defects
that escaped while it was still searching.

Trace event types