# Example 927 — Adjusting after every miss doubled the scatter `adjusting_after_every_miss_doubled_the_scatter.eml` - A filling machine misses its target by a little every time, and after every fill the operator nudges the setting by exactly the amount of the last miss, in the opposite direction. Every measurement is real and every adjustment is arithmetically exact. What such diligence does to the scatter is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). A filling # machine misses its target by a little every time, and after every fill the # operator nudges the setting by exactly the amount of the last miss, in the # opposite direction. Every measurement is real and every adjustment is # arithmetically exact. What such diligence does to the scatter is computed # below. # # The practice is careful. Every fill is measured exactly; the adjustment is # precisely the last error, reversed; nothing is left uncorrected; and the # intent is exactly 'keep the fills on target'. # # The misses are random noise around a target the machine already holds, so # each adjustment moves the setting by one draw of noise and the next fill adds # another - two draws of noise per fill instead of one, and the variance # doubles. 100 => variance_of_the_machine_alone 10 => standard_deviation_of_the_machine_alone 2 => draws_of_noise_in_each_fill_when_adjusted variance_of_the_machine_alone * draws_of_noise_in_each_fill_when_adjusted => variance_when_adjusted_after_every_miss variance_when_adjusted_after_every_miss - variance_of_the_machine_alone => variance_added_by_adjusting int(variance_added_by_adjusting * 10000 / variance_of_the_machine_alone) => scatter_increase_per_myriad 141 => standard_deviation_when_adjusted_tenths standard_deviation_when_adjusted_tenths - standard_deviation_of_the_machine_alone * 10 => tenths_of_sd_added "machine alone, variance : " + str(variance_of_the_machine_alone) + " (standard deviation " + str(standard_deviation_of_the_machine_alone) + ")" ^0 "rule : after each fill, move the setting by minus the last miss" ^0 "" ^0 "draws of noise per fill, adjusted : " + str(draws_of_noise_in_each_fill_when_adjusted) ^0 "variance when adjusted : " + str(variance_when_adjusted_after_every_miss) ^0 "variance added by adjusting : " + str(variance_added_by_adjusting) + ", " + str(scatter_increase_per_myriad) + " per ten thousand more scatter" ^0 "standard deviation when adjusted : " + str(standard_deviation_when_adjusted_tenths) + " tenths, up " + str(tenths_of_sd_added) + " tenths" ^0 "" ^0 # ---- what the practice verified ---- "the adjust-every-time practice" ^0 " measurement : every fill, exactly" ^0 " adjustment : precisely the last error, reversed" ^0 " coverage : nothing left uncorrected" ^0 " intent : keep the fills on target" ^0 " misses ignored : 0" ^0 " verdict : EVERY MISS WAS CORRECTED" ^0 "" ^0 " measuring every fill exactly and correcting every miss is" ^0 " the part done right here, and it is why no error was" ^0 " ever left standing" ^0 "" ^0 # ---- what correcting noise does ---- "chasing the funnel" ^0 " what a miss is : one random draw around a target the" ^0 " machine already holds" ^0 " what the adjustment does : moves the setting by that draw" ^0 " what the next fill does : adds a fresh draw to the moved" ^0 " setting" ^0 " so each fill carries : two draws of noise, not one" ^0 " the variance : " + str(variance_of_the_machine_alone) + " becomes " + str(variance_when_adjusted_after_every_miss) ^0 " the diligence : is the entire extra scatter" ^0 "" ^0 # ---- what the line got ---- "the fills" ^0 " scatter with no adjustment : standard deviation " + str(standard_deviation_of_the_machine_alone) ^0 " scatter with adjustment after every miss : " + str(standard_deviation_when_adjusted_tenths) + " tenths" ^0 " is any measurement or adjustment wrong : no; each is exact" ^0 " is a miss a signal to adjust : not when it is noise, and" ^0 " around a machine already on target it is noise" ^0 "" ^0 # ---- null control ---- # The same machine left alone unless a control chart signals a real shift # (a point beyond the limits or a run), so noise is not chased. 200 => nc_variance_adjusting_after_every_miss 100 => nc_variance_adjusting_only_on_a_signal 100 => nc_variance_the_restraint_removes "null control - adjust only on a control-chart signal" ^0 " variance, adjusting after every miss : " + str(nc_variance_adjusting_after_every_miss) ^0 " variance, adjusting only on a signal : " + str(nc_variance_adjusting_only_on_a_signal) ^0 " variance the restraint removes : " + str(nc_variance_the_restraint_removes) ^0 " no machine and no measurement changed; the operator" ^0 " stopped treating each draw of noise as a message" ^0 "" ^0 # ---- the rule ---- "what correcting every miss exactly guarantees" ^0 " no error is ever left standing : exactly, every fill" ^0 " measured, every miss reversed" ^0 " the fills stay closer to target : not addressed; the" ^0 " misses are noise, each correction injects one more draw" ^0 " of it, and the variance goes from " + str(variance_of_the_machine_alone) + " to " + str(variance_when_adjusted_after_every_miss) ^0 "" ^0 "a system already on target that is corrected for each random miss is being" ^0 "steered by its own noise; every correction is a fresh error added to the" ^0 "next result, and the hand that never lets a miss stand is the hand that" ^0 "doubles them" ^0 "" ^0 "Every fill is measured exactly and every miss is reversed exactly - nothing is" ^0 "left uncorrected. But the misses are random draws around a target the machine" ^0 "already holds, so each correction adds a draw to the next fill: variance " + str(variance_of_the_machine_alone) ^0 "becomes " + str(variance_when_adjusted_after_every_miss) + ", " + str(scatter_increase_per_myriad) + " per ten thousand more scatter, until the operator waits for a signal." ^0 ``` ## Python (deterministic transpilation) ```python variance_of_the_machine_alone = 100 standard_deviation_of_the_machine_alone = 10 draws_of_noise_in_each_fill_when_adjusted = 2 variance_when_adjusted_after_every_miss = variance_of_the_machine_alone * draws_of_noise_in_each_fill_when_adjusted variance_added_by_adjusting = variance_when_adjusted_after_every_miss - variance_of_the_machine_alone scatter_increase_per_myriad = int(variance_added_by_adjusting * 10000 / variance_of_the_machine_alone) standard_deviation_when_adjusted_tenths = 141 tenths_of_sd_added = standard_deviation_when_adjusted_tenths - standard_deviation_of_the_machine_alone * 10 print("machine alone, variance : " + str(variance_of_the_machine_alone) + " (standard deviation " + str(standard_deviation_of_the_machine_alone) + ")") print("rule : after each fill, move the setting by minus the last miss") print("") print("draws of noise per fill, adjusted : " + str(draws_of_noise_in_each_fill_when_adjusted)) print("variance when adjusted : " + str(variance_when_adjusted_after_every_miss)) print("variance added by adjusting : " + str(variance_added_by_adjusting) + ", " + str(scatter_increase_per_myriad) + " per ten thousand more scatter") print("standard deviation when adjusted : " + str(standard_deviation_when_adjusted_tenths) + " tenths, up " + str(tenths_of_sd_added) + " tenths") print("") print("the adjust-every-time practice") print(" measurement : every fill, exactly") print(" adjustment : precisely the last error, reversed") print(" coverage : nothing left uncorrected") print(" intent : keep the fills on target") print(" misses ignored : 0") print(" verdict : EVERY MISS WAS CORRECTED") print("") print(" measuring every fill exactly and correcting every miss is") print(" the part done right here, and it is why no error was") print(" ever left standing") print("") print("chasing the funnel") print(" what a miss is : one random draw around a target the") print(" machine already holds") print(" what the adjustment does : moves the setting by that draw") print(" what the next fill does : adds a fresh draw to the moved") print(" setting") print(" so each fill carries : two draws of noise, not one") print(" the variance : " + str(variance_of_the_machine_alone) + " becomes " + str(variance_when_adjusted_after_every_miss)) print(" the diligence : is the entire extra scatter") print("") print("the fills") print(" scatter with no adjustment : standard deviation " + str(standard_deviation_of_the_machine_alone)) print(" scatter with adjustment after every miss : " + str(standard_deviation_when_adjusted_tenths) + " tenths") print(" is any measurement or adjustment wrong : no; each is exact") print(" is a miss a signal to adjust : not when it is noise, and") print(" around a machine already on target it is noise") print("") nc_variance_adjusting_after_every_miss = 200 nc_variance_adjusting_only_on_a_signal = 100 nc_variance_the_restraint_removes = 100 print("null control - adjust only on a control-chart signal") print(" variance, adjusting after every miss : " + str(nc_variance_adjusting_after_every_miss)) print(" variance, adjusting only on a signal : " + str(nc_variance_adjusting_only_on_a_signal)) print(" variance the restraint removes : " + str(nc_variance_the_restraint_removes)) print(" no machine and no measurement changed; the operator") print(" stopped treating each draw of noise as a message") print("") print("what correcting every miss exactly guarantees") print(" no error is ever left standing : exactly, every fill") print(" measured, every miss reversed") print(" the fills stay closer to target : not addressed; the") print(" misses are noise, each correction injects one more draw") print(" of it, and the variance goes from " + str(variance_of_the_machine_alone) + " to " + str(variance_when_adjusted_after_every_miss)) print("") print("a system already on target that is corrected for each random miss is being") print("steered by its own noise; every correction is a fresh error added to the") print("next result, and the hand that never lets a miss stand is the hand that") print("doubles them") print("") print("Every fill is measured exactly and every miss is reversed exactly - nothing is") print("left uncorrected. But the misses are random draws around a target the machine") print("already holds, so each correction adds a draw to the next fill: variance " + str(variance_of_the_machine_alone)) print("becomes " + str(variance_when_adjusted_after_every_miss) + ", " + str(scatter_increase_per_myriad) + " per ten thousand more scatter, until the operator waits for a signal.") ``` ## stdout (executed) ```text machine alone, variance : 100 (standard deviation 10) rule : after each fill, move the setting by minus the last miss draws of noise per fill, adjusted : 2 variance when adjusted : 200 variance added by adjusting : 100, 10000 per ten thousand more scatter standard deviation when adjusted : 141 tenths, up 41 tenths the adjust-every-time practice measurement : every fill, exactly adjustment : precisely the last error, reversed coverage : nothing left uncorrected intent : keep the fills on target misses ignored : 0 verdict : EVERY MISS WAS CORRECTED measuring every fill exactly and correcting every miss is the part done right here, and it is why no error was ever left standing chasing the funnel what a miss is : one random draw around a target the machine already holds what the adjustment does : moves the setting by that draw what the next fill does : adds a fresh draw to the moved setting so each fill carries : two draws of noise, not one the variance : 100 becomes 200 the diligence : is the entire extra scatter the fills scatter with no adjustment : standard deviation 10 scatter with adjustment after every miss : 141 tenths is any measurement or adjustment wrong : no; each is exact is a miss a signal to adjust : not when it is noise, and around a machine already on target it is noise null control - adjust only on a control-chart signal variance, adjusting after every miss : 200 variance, adjusting only on a signal : 100 variance the restraint removes : 100 no machine and no measurement changed; the operator stopped treating each draw of noise as a message what correcting every miss exactly guarantees no error is ever left standing : exactly, every fill measured, every miss reversed the fills stay closer to target : not addressed; the misses are noise, each correction injects one more draw of it, and the variance goes from 100 to 200 a system already on target that is corrected for each random miss is being steered by its own noise; every correction is a fresh error added to the next result, and the hand that never lets a miss stand is the hand that doubles them Every fill is measured exactly and every miss is reversed exactly - nothing is left uncorrected. But the misses are random draws around a target the machine already holds, so each correction adds a draw to the next fill: variance 100 becomes 200, 10000 per ten thousand more scatter, until the operator waits for a signal. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done