No single change improved it and two together doubled it

# Self-authored for the EML case corpus (no external origin). A tuner adjusts a
# system one parameter at a time, keeps a change only if the score improves,
# and stops when no single change helps. Every score it measures is real. What
# it stops at, against what the system can reach, is computed below.
#
# The tuning is careful. It measures the real score after every change; it keeps
# only genuine improvements; it tries every parameter before stopping; and the
# intent is exactly 'find the best setting'.
#
# Changing either parameter alone makes the score worse and changing both
# together nearly doubles it, so a tuner that moves one at a time stops at 50
# with 90 one double-step away.

50 => score_at_the_stop
45 => score_changing_only_a
45 => score_changing_only_b
90 => score_changing_both

score_changing_only_a - score_at_the_stop => gain_from_a_alone
score_changing_only_b - score_at_the_stop => gain_from_b_alone
score_changing_both - score_at_the_stop => gain_from_both_together
int(score_at_the_stop * 10000 / score_changing_both) => share_of_the_optimum_reached_per_myriad

"score at the tuner's stop       : " + str(score_at_the_stop) ^0
"change only A                   : " + str(score_changing_only_a) + ", gain " + str(gain_from_a_alone) ^0
"change only B                   : " + str(score_changing_only_b) + ", gain " + str(gain_from_b_alone) ^0
"change A and B together         : " + str(score_changing_both) + ", gain " + str(gain_from_both_together) ^0
"" ^0
"the tuner stops at              : " + str(score_at_the_stop) + ", every single step is downhill" ^0
"the best setting                : " + str(score_changing_both) ^0
"share of the optimum reached    : " + str(share_of_the_optimum_reached_per_myriad) + " per ten thousand" ^0
"" ^0

# ---- what the tuning verified ----

"the one-at-a-time tuner" ^0
"  measures : the real score after every change" ^0
"  keeps : only genuine improvements" ^0
"  stops : after trying every parameter with no gain" ^0
"  intent : find the best setting" ^0
"  false improvements kept : 0" ^0
"  verdict : NO SINGLE CHANGE IMPROVES THE SCORE" ^0
"" ^0
"  measuring the real score and keeping only real gains is" ^0
"  the part done right here, and it is why the stop is a" ^0
"  true statement about every neighbouring setting" ^0
"" ^0

# ---- what one-at-a-time cannot see ----

"the landscape" ^0
"  from the stop, one step in A : down " + str(gain_from_a_alone) ^0
"  from the stop, one step in B : down " + str(gain_from_b_alone) ^0
"  from the stop, one step in both : up " + str(gain_from_both_together) ^0
"  what the tuner can take : one step in one parameter" ^0
"  so the only move that helps : is the one the tuner cannot" ^0
"    make" ^0
"  the stop : is a local best, ringed by worse, with the" ^0
"    global best diagonally across the ring" ^0
"" ^0

# ---- what the operator got ----

"the setting" ^0
"  delivered : " + str(score_at_the_stop) + ", certified as a stop" ^0
"  available : " + str(score_changing_both) ^0
"  is any measurement wrong : no" ^0
"  is 'no single change helps' the same as 'nothing helps' :" ^0
"    no; it is a fact about steps of size one in one" ^0
"    direction" ^0
"" ^0

# ---- null control ----

# The same tuner also trying pairs of changes (or random restarts from other
# starting points), so a ridge crossed diagonally is reachable.
50 => nc_score_reached_one_at_a_time
90 => nc_score_reached_trying_pairs
40 => nc_score_the_pair_move_recovers

"null control - also try changing two parameters at once" ^0
"  score reached, one at a time : " + str(nc_score_reached_one_at_a_time) ^0
"  score reached, trying pairs : " + str(nc_score_reached_trying_pairs) ^0
"  score the pair move recovers : " + str(nc_score_the_pair_move_recovers) ^0
"  no score and no parameter changed; the tuner stopped" ^0
"  mistaking its own step size for the shape of the ground" ^0
"" ^0

# ---- the rule ----

"what a stop-when-no-single-change-helps rule guarantees" ^0
"  every setting one step away scores lower : exactly, real" ^0
"    scores, every parameter tried" ^0
"  the setting is the best : not addressed; both parameters" ^0
"    moved together score " + str(score_changing_both) + " against " + str(score_at_the_stop) + " at the stop, and" ^0
"    that move is two steps the tuner never takes as one" ^0
"" ^0

"a search that moves one way at a time can only certify the ground it can" ^0
"step onto; a peak with a better peak across a dip is a stop by that rule and" ^0
"not by any other, and the certificate describes the rule's legs, not the hill" ^0
"" ^0

"It measures real scores and stops only when no single change helps - the stop" ^0
"is true of every neighbour. But changing A and B together scores " + str(score_changing_both) + " against" ^0
"" + str(score_at_the_stop) + ", a move of two steps the tuner never takes as one; it delivers " + str(share_of_the_optimum_reached_per_myriad) + " per ten" ^0
"thousand of the optimum, until it also tries pairs." ^0

score_at_the_stop = 50
score_changing_only_a = 45
score_changing_only_b = 45
score_changing_both = 90
gain_from_a_alone = score_changing_only_a - score_at_the_stop
gain_from_b_alone = score_changing_only_b - score_at_the_stop
gain_from_both_together = score_changing_both - score_at_the_stop
share_of_the_optimum_reached_per_myriad = int(score_at_the_stop * 10000 / score_changing_both)
print("score at the tuner's stop       : " + str(score_at_the_stop))
print("change only A                   : " + str(score_changing_only_a) + ", gain " + str(gain_from_a_alone))
print("change only B                   : " + str(score_changing_only_b) + ", gain " + str(gain_from_b_alone))
print("change A and B together         : " + str(score_changing_both) + ", gain " + str(gain_from_both_together))
print("")
print("the tuner stops at              : " + str(score_at_the_stop) + ", every single step is downhill")
print("the best setting                : " + str(score_changing_both))
print("share of the optimum reached    : " + str(share_of_the_optimum_reached_per_myriad) + " per ten thousand")
print("")
print("the one-at-a-time tuner")
print("  measures : the real score after every change")
print("  keeps : only genuine improvements")
print("  stops : after trying every parameter with no gain")
print("  intent : find the best setting")
print("  false improvements kept : 0")
print("  verdict : NO SINGLE CHANGE IMPROVES THE SCORE")
print("")
print("  measuring the real score and keeping only real gains is")
print("  the part done right here, and it is why the stop is a")
print("  true statement about every neighbouring setting")
print("")
print("the landscape")
print("  from the stop, one step in A : down " + str(gain_from_a_alone))
print("  from the stop, one step in B : down " + str(gain_from_b_alone))
print("  from the stop, one step in both : up " + str(gain_from_both_together))
print("  what the tuner can take : one step in one parameter")
print("  so the only move that helps : is the one the tuner cannot")
print("    make")
print("  the stop : is a local best, ringed by worse, with the")
print("    global best diagonally across the ring")
print("")
print("the setting")
print("  delivered : " + str(score_at_the_stop) + ", certified as a stop")
print("  available : " + str(score_changing_both))
print("  is any measurement wrong : no")
print("  is 'no single change helps' the same as 'nothing helps' :")
print("    no; it is a fact about steps of size one in one")
print("    direction")
print("")
nc_score_reached_one_at_a_time = 50
nc_score_reached_trying_pairs = 90
nc_score_the_pair_move_recovers = 40
print("null control - also try changing two parameters at once")
print("  score reached, one at a time : " + str(nc_score_reached_one_at_a_time))
print("  score reached, trying pairs : " + str(nc_score_reached_trying_pairs))
print("  score the pair move recovers : " + str(nc_score_the_pair_move_recovers))
print("  no score and no parameter changed; the tuner stopped")
print("  mistaking its own step size for the shape of the ground")
print("")
print("what a stop-when-no-single-change-helps rule guarantees")
print("  every setting one step away scores lower : exactly, real")
print("    scores, every parameter tried")
print("  the setting is the best : not addressed; both parameters")
print("    moved together score " + str(score_changing_both) + " against " + str(score_at_the_stop) + " at the stop, and")
print("    that move is two steps the tuner never takes as one")
print("")
print("a search that moves one way at a time can only certify the ground it can")
print("step onto; a peak with a better peak across a dip is a stop by that rule and")
print("not by any other, and the certificate describes the rule's legs, not the hill")
print("")
print("It measures real scores and stops only when no single change helps - the stop")
print("is true of every neighbour. But changing A and B together scores " + str(score_changing_both) + " against")
print("" + str(score_at_the_stop) + ", a move of two steps the tuner never takes as one; it delivers " + str(share_of_the_optimum_reached_per_myriad) + " per ten")
print("thousand of the optimum, until it also tries pairs.")

score at the tuner's stop       : 50
change only A                   : 45, gain -5
change only B                   : 45, gain -5
change A and B together         : 90, gain 40

the tuner stops at              : 50, every single step is downhill
the best setting                : 90
share of the optimum reached    : 5555 per ten thousand

the one-at-a-time tuner
  measures : the real score after every change
  keeps : only genuine improvements
  stops : after trying every parameter with no gain
  intent : find the best setting
  false improvements kept : 0
  verdict : NO SINGLE CHANGE IMPROVES THE SCORE

  measuring the real score and keeping only real gains is
  the part done right here, and it is why the stop is a
  true statement about every neighbouring setting

the landscape
  from the stop, one step in A : down -5
  from the stop, one step in B : down -5
  from the stop, one step in both : up 40
  what the tuner can take : one step in one parameter
  so the only move that helps : is the one the tuner cannot
    make
  the stop : is a local best, ringed by worse, with the
    global best diagonally across the ring

the setting
  delivered : 50, certified as a stop
  available : 90
  is any measurement wrong : no
  is 'no single change helps' the same as 'nothing helps' :
    no; it is a fact about steps of size one in one
    direction

null control - also try changing two parameters at once
  score reached, one at a time : 50
  score reached, trying pairs : 90
  score the pair move recovers : 40
  no score and no parameter changed; the tuner stopped
  mistaking its own step size for the shape of the ground

what a stop-when-no-single-change-helps rule guarantees
  every setting one step away scores lower : exactly, real
    scores, every parameter tried
  the setting is the best : not addressed; both parameters
    moved together score 90 against 50 at the stop, and
    that move is two steps the tuner never takes as one

a search that moves one way at a time can only certify the ground it can
step onto; a peak with a better peak across a dip is a stop by that rule and
not by any other, and the certificate describes the rule's legs, not the hill

It measures real scores and stops only when no single change helps - the stop
is true of every neighbour. But changing A and B together scores 90 against
50, a move of two steps the tuner never takes as one; it delivers 5555 per ten
thousand of the optimum, until it also tries pairs.

Trace event types