The values were equal as floats

# Self-authored for the EML case corpus (no external origin). The reconciliation
# passed on every pair it compared, and each comparison ran without error. What
# the comparison treats as equal is computed below.
#
# The reconciliation is careful. It compares the two sides pair by pair, not in
# aggregate; it runs on every pair, no sampling; a difference is meant to fail
# the pair and halt; and the pairs it passed it really did evaluate as equal.
#
# The comparison is == on floating-point dollars, and cents below the float's
# precision at that magnitude round away before the compare.

90000 => pairs_compared
37 => pairs_that_differ_by_a_cent
37 => pairs_equal_as_floats
0 => pairs_the_reconciliation_failed

pairs_equal_as_floats => hidden_discrepancies
hidden_discrepancies => discrepancy_cents_total
int(pairs_that_differ_by_a_cent * 10000 / pairs_compared) => hidden_share_per_myriad

"pairs compared                  : " + str(pairs_compared) ^0
"  that truly differ by a cent   : " + str(pairs_that_differ_by_a_cent) ^0
"  equal as floats               : " + str(pairs_equal_as_floats) ^0
"  the reconciliation failed     : " + str(pairs_the_reconciliation_failed) ^0
"hidden discrepancies            : " + str(hidden_discrepancies) ^0
"discrepancy total               : " + str(discrepancy_cents_total) + " cents" ^0
"hidden share                    : " + str(hidden_share_per_myriad) + " per ten thousand" ^0
"" ^0
"one pair, in cents and as floats" ^0
"  side A : 100000000001 cents" ^0
"  side B : 100000000000 cents" ^0
"  differ by : 1 cent" ^0
"  as float dollars : both nearest the same value, so ==" ^0
"" ^0

# ---- what the reconciliation verified ----

"the reconciliation" ^0
"  compares : pair by pair, not in aggregate" ^0
"  coverage : every pair, no sampling" ^0
"  on a difference : fails the pair and halts" ^0
"  pairs it passed : evaluated equal, genuinely" ^0
"  pairs it failed : " + str(pairs_the_reconciliation_failed) ^0
"  verdict : RECONCILED" ^0
"" ^0
"  comparing pair by pair rather than netting the totals is" ^0
"  the part done right here, and it is why offsetting errors" ^0
"  cannot hide" ^0
"" ^0

# ---- what equal means here ----

"the comparison itself" ^0
"  operator : == on floating-point dollars" ^0
"  what a float holds at ten-figure magnitudes : not every" ^0
"    cent" ^0
"  a one-cent difference there : rounds to the same" ^0
"    representable value" ^0
"  so the two sides : are equal as floats, unequal as cents" ^0
"  pairs this hid : " + str(pairs_equal_as_floats) ^0
"" ^0

# ---- what the cent-level truth is ----

"the same pairs, in integer cents" ^0
"  pairs that differ by a cent : " + str(pairs_that_differ_by_a_cent) ^0
"  what the reconciliation said about them : equal" ^0
"  cents unaccounted for : " + str(discrepancy_cents_total) ^0
"  is the comparison wrong : no; as floats they are equal" ^0
"  are they equal : no; as cents they differ" ^0
"" ^0

# ---- null control ----

# The same pairs, compared as integer cents rather than as floating-point
# dollars.
0 => nc_hidden_when_compared_as_cents
37 => nc_pairs_the_cent_compare_fails
37 => nc_cents_it_would_surface

"null control - compare integer cents" ^0
"  hidden discrepancies, cent compare : " ^0
"    " + str(nc_hidden_when_compared_as_cents) ^0
"  pairs the cent compare fails : " + str(nc_pairs_the_cent_compare_fails) ^0
"  cents it would surface : " + str(nc_cents_it_would_surface) ^0
"  no amount changed; the comparison stopped rounding the" ^0
"  cents away before it looked" ^0
"" ^0

# ---- the rule ----

"what a passed reconciliation guarantees" ^0
"  every compared pair evaluated equal : exactly, pair by" ^0
"    pair, no sampling, halt on a difference" ^0
"  equal amounts reconcile : not addressed; the comparison" ^0
"    is == on floats and cents beyond the float's precision" ^0
"    vanish - " + str(pairs_equal_as_floats) + " pairs compared equal while differing by a" ^0
"    cent, hiding " + str(discrepancy_cents_total) + " cents" ^0
"" ^0

"equality is only as fine as the type it is tested in, and a float at a large" ^0
"magnitude cannot hold a cent; two amounts a cent apart are the same number to" ^0
"it, and the reconciliation asks it, not the ledger" ^0
"" ^0

"It compares pair by pair with no sampling and halts on a difference - every" ^0
"pair equal. The compare is == on float dollars, which cannot hold a cent at ten" ^0
"figures, so " + str(pairs_equal_as_floats) + " pairs a cent apart read as equal, " + str(discrepancy_cents_total) + " cents hidden, " ^0
"" + str(hidden_share_per_myriad) + " per ten thousand of the pairs, under " + str(pairs_the_reconciliation_failed) + " failures." ^0

pairs_compared = 90000
pairs_that_differ_by_a_cent = 37
pairs_equal_as_floats = 37
pairs_the_reconciliation_failed = 0
hidden_discrepancies = pairs_equal_as_floats
discrepancy_cents_total = hidden_discrepancies
hidden_share_per_myriad = int(pairs_that_differ_by_a_cent * 10000 / pairs_compared)
print("pairs compared                  : " + str(pairs_compared))
print("  that truly differ by a cent   : " + str(pairs_that_differ_by_a_cent))
print("  equal as floats               : " + str(pairs_equal_as_floats))
print("  the reconciliation failed     : " + str(pairs_the_reconciliation_failed))
print("hidden discrepancies            : " + str(hidden_discrepancies))
print("discrepancy total               : " + str(discrepancy_cents_total) + " cents")
print("hidden share                    : " + str(hidden_share_per_myriad) + " per ten thousand")
print("")
print("one pair, in cents and as floats")
print("  side A : 100000000001 cents")
print("  side B : 100000000000 cents")
print("  differ by : 1 cent")
print("  as float dollars : both nearest the same value, so ==")
print("")
print("the reconciliation")
print("  compares : pair by pair, not in aggregate")
print("  coverage : every pair, no sampling")
print("  on a difference : fails the pair and halts")
print("  pairs it passed : evaluated equal, genuinely")
print("  pairs it failed : " + str(pairs_the_reconciliation_failed))
print("  verdict : RECONCILED")
print("")
print("  comparing pair by pair rather than netting the totals is")
print("  the part done right here, and it is why offsetting errors")
print("  cannot hide")
print("")
print("the comparison itself")
print("  operator : == on floating-point dollars")
print("  what a float holds at ten-figure magnitudes : not every")
print("    cent")
print("  a one-cent difference there : rounds to the same")
print("    representable value")
print("  so the two sides : are equal as floats, unequal as cents")
print("  pairs this hid : " + str(pairs_equal_as_floats))
print("")
print("the same pairs, in integer cents")
print("  pairs that differ by a cent : " + str(pairs_that_differ_by_a_cent))
print("  what the reconciliation said about them : equal")
print("  cents unaccounted for : " + str(discrepancy_cents_total))
print("  is the comparison wrong : no; as floats they are equal")
print("  are they equal : no; as cents they differ")
print("")
nc_hidden_when_compared_as_cents = 0
nc_pairs_the_cent_compare_fails = 37
nc_cents_it_would_surface = 37
print("null control - compare integer cents")
print("  hidden discrepancies, cent compare : ")
print("    " + str(nc_hidden_when_compared_as_cents))
print("  pairs the cent compare fails : " + str(nc_pairs_the_cent_compare_fails))
print("  cents it would surface : " + str(nc_cents_it_would_surface))
print("  no amount changed; the comparison stopped rounding the")
print("  cents away before it looked")
print("")
print("what a passed reconciliation guarantees")
print("  every compared pair evaluated equal : exactly, pair by")
print("    pair, no sampling, halt on a difference")
print("  equal amounts reconcile : not addressed; the comparison")
print("    is == on floats and cents beyond the float's precision")
print("    vanish - " + str(pairs_equal_as_floats) + " pairs compared equal while differing by a")
print("    cent, hiding " + str(discrepancy_cents_total) + " cents")
print("")
print("equality is only as fine as the type it is tested in, and a float at a large")
print("magnitude cannot hold a cent; two amounts a cent apart are the same number to")
print("it, and the reconciliation asks it, not the ledger")
print("")
print("It compares pair by pair with no sampling and halts on a difference - every")
print("pair equal. The compare is == on float dollars, which cannot hold a cent at ten")
print("figures, so " + str(pairs_equal_as_floats) + " pairs a cent apart read as equal, " + str(discrepancy_cents_total) + " cents hidden, ")
print("" + str(hidden_share_per_myriad) + " per ten thousand of the pairs, under " + str(pairs_the_reconciliation_failed) + " failures.")

pairs compared                  : 90000
  that truly differ by a cent   : 37
  equal as floats               : 37
  the reconciliation failed     : 0
hidden discrepancies            : 37
discrepancy total               : 37 cents
hidden share                    : 4 per ten thousand

one pair, in cents and as floats
  side A : 100000000001 cents
  side B : 100000000000 cents
  differ by : 1 cent
  as float dollars : both nearest the same value, so ==

the reconciliation
  compares : pair by pair, not in aggregate
  coverage : every pair, no sampling
  on a difference : fails the pair and halts
  pairs it passed : evaluated equal, genuinely
  pairs it failed : 0
  verdict : RECONCILED

  comparing pair by pair rather than netting the totals is
  the part done right here, and it is why offsetting errors
  cannot hide

the comparison itself
  operator : == on floating-point dollars
  what a float holds at ten-figure magnitudes : not every
    cent
  a one-cent difference there : rounds to the same
    representable value
  so the two sides : are equal as floats, unequal as cents
  pairs this hid : 37

the same pairs, in integer cents
  pairs that differ by a cent : 37
  what the reconciliation said about them : equal
  cents unaccounted for : 37
  is the comparison wrong : no; as floats they are equal
  are they equal : no; as cents they differ

null control - compare integer cents
  hidden discrepancies, cent compare : 
    0
  pairs the cent compare fails : 37
  cents it would surface : 37
  no amount changed; the comparison stopped rounding the
  cents away before it looked

what a passed reconciliation guarantees
  every compared pair evaluated equal : exactly, pair by
    pair, no sampling, halt on a difference
  equal amounts reconcile : not addressed; the comparison
    is == on floats and cents beyond the float's precision
    vanish - 37 pairs compared equal while differing by a
    cent, hiding 37 cents

equality is only as fine as the type it is tested in, and a float at a large
magnitude cannot hold a cent; two amounts a cent apart are the same number to
it, and the reconciliation asks it, not the ledger

It compares pair by pair with no sampling and halts on a difference - every
pair equal. The compare is == on float dollars, which cannot hold a cent at ten
figures, so 37 pairs a cent apart read as equal, 37 cents hidden, 
4 per ten thousand of the pairs, under 0 failures.

Trace event types