Case 999

The thirtieth dilution held no molecule at all

the_thirtieth_dilution_held_no_molecule_at_all.eml - A lab protocol makes a trace standard by diluting a 1 mole-per-litre stock ten-fold, tube after tube, thirty times. The analyst reasons that each tube keeps a tenth of the one before, a tenth of something is still something, and the thirtieth tube holds the compound at 10 to the minus 30 moles per litre - tiny, but there. What a litre of each tube really holds is computed below.

ok: true — round-trip fixpoint reached (python1 == python2)updated 2026-09-24

EML

eml
# Self-authored for the EML case corpus (no external origin). A lab protocol makes
# a trace standard by diluting a 1 mole-per-litre stock ten-fold, tube after
# tube, thirty times. The analyst reasons that each tube keeps a tenth of the
# one before, a tenth of something is still something, and the thirtieth tube
# holds the compound at 10 to the minus 30 moles per litre - tiny, but there.
# What a litre of each tube really holds is computed below.
#
# The reasoning is careful. Each step really is exactly one part in ten; the
# stock really is 1 mole per litre; the arithmetic of thirty tenths really is
# 10 to the minus 30; and the intent is exactly 'does the last tube still hold
# the compound'.
#
# A mole is a count - 602214076 followed by fifteen zeros molecules - and
# molecules do not divide. After 23 tubes a litre holds about 6 of them; after
# 24, a litre holds 0.6 on average, so most litres hold none; after 30, a
# billion litres would be needed to expect 602 molecules. Seven of the thirty
# tubes are, litre for litre, almost certainly empty of the compound.

602214076 => avogadro_leading_digits
30 => tubes_diluted
10 => dilution_per_tube

10^15 => ten_to_the_fifteenth
avogadro_leading_digits * ten_to_the_fifteenth => molecules_per_litre_of_stock
10^9 => one_billion
10^23 => ten_to_the_twenty_third
10^24 => ten_to_the_twenty_fourth
10^30 => ten_to_the_thirtieth

int(molecules_per_litre_of_stock / ten_to_the_twenty_third) => molecules_per_litre_after_23_tubes
int(molecules_per_litre_of_stock * 1000 / ten_to_the_twenty_fourth) => molecules_per_thousand_litres_after_24_tubes
int(molecules_per_litre_of_stock * one_billion / ten_to_the_thirtieth) => molecules_per_billion_litres_after_30_tubes
int(ten_to_the_thirtieth / molecules_per_litre_of_stock) => litres_of_tube_30_per_expected_molecule
23 => tubes_with_at_least_one_molecule_per_litre
tubes_diluted - tubes_with_at_least_one_molecule_per_litre => tubes_almost_certainly_empty_per_litre

"stock                           : 1 mole per litre, " + str(molecules_per_litre_of_stock) + " molecules" ^0
"each tube                       : one part in " + str(dilution_per_tube) + " of the one before, " + str(tubes_diluted) + " tubes" ^0
"" ^0
"a litre after 23 tubes          : " + str(molecules_per_litre_after_23_tubes) + " molecules" ^0
"a thousand litres after 24 tubes : " + str(molecules_per_thousand_litres_after_24_tubes) + " molecules" ^0
"a billion litres after 30 tubes : " + str(molecules_per_billion_litres_after_30_tubes) + " molecules" ^0
"litres of tube 30 per molecule  : " + str(litres_of_tube_30_per_expected_molecule) ^0
"" ^0
"tubes with a molecule per litre : " + str(tubes_with_at_least_one_molecule_per_litre) ^0
"tubes almost certainly empty    : " + str(tubes_almost_certainly_empty_per_litre) ^0
"" ^0

# ---- what the analyst verified ----

"the a-tenth-is-still-something reasoning" ^0
"  each step : exactly one part in " + str(dilution_per_tube) ^0
"  stock : exactly 1 mole per litre" ^0
"  arithmetic : " + str(tubes_diluted) + " tenths, 10 to the minus " + str(tubes_diluted) + " moles per litre" ^0
"  intent : does the last tube still hold the compound" ^0
"  facts wrong : 0" ^0
"  verdict : THE LAST TUBE HOLDS THE COMPOUND, AT A TRACE" ^0
"" ^0
"  keeping every step at exactly one in ten is the part done" ^0
"  right here, and it is why the concentration in each tube is" ^0
"  exactly what the protocol names" ^0
"" ^0

# ---- what a litre holds ----

"a concentration is a count" ^0
"  what a mole is : " + str(molecules_per_litre_of_stock) + " molecules, a number" ^0
"  what a molecule cannot do : split; a tube holds whole ones" ^0
"  after 23 tubes : " + str(molecules_per_litre_after_23_tubes) + " molecules in a litre" ^0
"  after 24 tubes : " + str(molecules_per_thousand_litres_after_24_tubes) + " in a thousand litres, so most" ^0
"    litres hold none" ^0
"  after 30 tubes : " + str(molecules_per_billion_litres_after_30_tubes) + " in a billion litres, one molecule per" ^0
"    " + str(litres_of_tube_30_per_expected_molecule) + " litres" ^0
"  what the number 10 to the minus " + str(tubes_diluted) + " means there : the chance" ^0
"    that a litre happens to hold one" ^0
"" ^0

# ---- what the analyst got ----

"the standard" ^0
"  believed : a trace of the compound in every tube" ^0
"  actual : " + str(tubes_almost_certainly_empty_per_litre) + " tubes in which a litre almost certainly holds none" ^0
"  is the dilution arithmetic wrong : no; every step is exact" ^0
"  can a concentration go on shrinking forever : no; below one" ^0
"    molecule per sample it stops describing the sample" ^0
"" ^0

# ---- null control ----

# The same series counted in molecules instead of in moles.
30 => nc_tubes_read_as_holding_the_compound
23 => nc_tubes_holding_a_molecule_per_litre
7 => nc_tubes_the_count_empties

"null control - count molecules, not moles" ^0
"  tubes read as holding the compound : " + str(nc_tubes_read_as_holding_the_compound) ^0
"  tubes holding a molecule per litre : " + str(nc_tubes_holding_a_molecule_per_litre) ^0
"  tubes the count empties : " + str(nc_tubes_the_count_empties) ^0
"  no tube and no step changed; the concentration was turned back" ^0
"  into the whole molecules it stands for" ^0
"" ^0

# ---- the rule ----

"what thirty exact one-in-ten dilutions guarantee" ^0
"  the last tube's concentration is 10 to the minus " + str(tubes_diluted) + " : exactly" ^0
"  the last tube holds the compound : not addressed; molecules are" ^0
"    whole, after 24 tubes there are " + str(molecules_per_thousand_litres_after_24_tubes) + " in a thousand litres," ^0
"    and a litre of tube " + str(tubes_diluted) + " holds one molecule once in " + str(litres_of_tube_30_per_expected_molecule) + " litres" ^0
"" ^0

"a fraction of a thing is still a thing only while the thing can be divided;" ^0
"matter comes in pieces, and past the last piece a smaller number means an" ^0
"emptier tube, not a thinner one" ^0
"" ^0

"Each tube is exactly one tenth of the one before - the protocol is right. But" ^0
"a mole is " + str(molecules_per_litre_of_stock) + " whole molecules, so after 23 tubes a" ^0
"litre holds " + str(molecules_per_litre_after_23_tubes) + ", after 24 most litres hold none, and tube " + str(tubes_diluted) + " holds one molecule" ^0
"per " + str(litres_of_tube_30_per_expected_molecule) + " litres, until the concentration is counted in molecules and not in moles." ^0

Python (deterministic transpilation)

python
avogadro_leading_digits = 602214076
tubes_diluted = 30
dilution_per_tube = 10
ten_to_the_fifteenth = 10**15
molecules_per_litre_of_stock = avogadro_leading_digits * ten_to_the_fifteenth
one_billion = 10**9
ten_to_the_twenty_third = 10**23
ten_to_the_twenty_fourth = 10**24
ten_to_the_thirtieth = 10**30
molecules_per_litre_after_23_tubes = int(molecules_per_litre_of_stock / ten_to_the_twenty_third)
molecules_per_thousand_litres_after_24_tubes = int(molecules_per_litre_of_stock * 1000 / ten_to_the_twenty_fourth)
molecules_per_billion_litres_after_30_tubes = int(molecules_per_litre_of_stock * one_billion / ten_to_the_thirtieth)
litres_of_tube_30_per_expected_molecule = int(ten_to_the_thirtieth / molecules_per_litre_of_stock)
tubes_with_at_least_one_molecule_per_litre = 23
tubes_almost_certainly_empty_per_litre = tubes_diluted - tubes_with_at_least_one_molecule_per_litre
print("stock                           : 1 mole per litre, " + str(molecules_per_litre_of_stock) + " molecules")
print("each tube                       : one part in " + str(dilution_per_tube) + " of the one before, " + str(tubes_diluted) + " tubes")
print("")
print("a litre after 23 tubes          : " + str(molecules_per_litre_after_23_tubes) + " molecules")
print("a thousand litres after 24 tubes : " + str(molecules_per_thousand_litres_after_24_tubes) + " molecules")
print("a billion litres after 30 tubes : " + str(molecules_per_billion_litres_after_30_tubes) + " molecules")
print("litres of tube 30 per molecule  : " + str(litres_of_tube_30_per_expected_molecule))
print("")
print("tubes with a molecule per litre : " + str(tubes_with_at_least_one_molecule_per_litre))
print("tubes almost certainly empty    : " + str(tubes_almost_certainly_empty_per_litre))
print("")
print("the a-tenth-is-still-something reasoning")
print("  each step : exactly one part in " + str(dilution_per_tube))
print("  stock : exactly 1 mole per litre")
print("  arithmetic : " + str(tubes_diluted) + " tenths, 10 to the minus " + str(tubes_diluted) + " moles per litre")
print("  intent : does the last tube still hold the compound")
print("  facts wrong : 0")
print("  verdict : THE LAST TUBE HOLDS THE COMPOUND, AT A TRACE")
print("")
print("  keeping every step at exactly one in ten is the part done")
print("  right here, and it is why the concentration in each tube is")
print("  exactly what the protocol names")
print("")
print("a concentration is a count")
print("  what a mole is : " + str(molecules_per_litre_of_stock) + " molecules, a number")
print("  what a molecule cannot do : split; a tube holds whole ones")
print("  after 23 tubes : " + str(molecules_per_litre_after_23_tubes) + " molecules in a litre")
print("  after 24 tubes : " + str(molecules_per_thousand_litres_after_24_tubes) + " in a thousand litres, so most")
print("    litres hold none")
print("  after 30 tubes : " + str(molecules_per_billion_litres_after_30_tubes) + " in a billion litres, one molecule per")
print("    " + str(litres_of_tube_30_per_expected_molecule) + " litres")
print("  what the number 10 to the minus " + str(tubes_diluted) + " means there : the chance")
print("    that a litre happens to hold one")
print("")
print("the standard")
print("  believed : a trace of the compound in every tube")
print("  actual : " + str(tubes_almost_certainly_empty_per_litre) + " tubes in which a litre almost certainly holds none")
print("  is the dilution arithmetic wrong : no; every step is exact")
print("  can a concentration go on shrinking forever : no; below one")
print("    molecule per sample it stops describing the sample")
print("")
nc_tubes_read_as_holding_the_compound = 30
nc_tubes_holding_a_molecule_per_litre = 23
nc_tubes_the_count_empties = 7
print("null control - count molecules, not moles")
print("  tubes read as holding the compound : " + str(nc_tubes_read_as_holding_the_compound))
print("  tubes holding a molecule per litre : " + str(nc_tubes_holding_a_molecule_per_litre))
print("  tubes the count empties : " + str(nc_tubes_the_count_empties))
print("  no tube and no step changed; the concentration was turned back")
print("  into the whole molecules it stands for")
print("")
print("what thirty exact one-in-ten dilutions guarantee")
print("  the last tube's concentration is 10 to the minus " + str(tubes_diluted) + " : exactly")
print("  the last tube holds the compound : not addressed; molecules are")
print("    whole, after 24 tubes there are " + str(molecules_per_thousand_litres_after_24_tubes) + " in a thousand litres,")
print("    and a litre of tube " + str(tubes_diluted) + " holds one molecule once in " + str(litres_of_tube_30_per_expected_molecule) + " litres")
print("")
print("a fraction of a thing is still a thing only while the thing can be divided;")
print("matter comes in pieces, and past the last piece a smaller number means an")
print("emptier tube, not a thinner one")
print("")
print("Each tube is exactly one tenth of the one before - the protocol is right. But")
print("a mole is " + str(molecules_per_litre_of_stock) + " whole molecules, so after 23 tubes a")
print("litre holds " + str(molecules_per_litre_after_23_tubes) + ", after 24 most litres hold none, and tube " + str(tubes_diluted) + " holds one molecule")
print("per " + str(litres_of_tube_30_per_expected_molecule) + " litres, until the concentration is counted in molecules and not in moles.")

stdout (executed)

text
stock                           : 1 mole per litre, 602214076000000000000000 molecules
each tube                       : one part in 10 of the one before, 30 tubes

a litre after 23 tubes          : 6 molecules
a thousand litres after 24 tubes : 602 molecules
a billion litres after 30 tubes : 602 molecules
litres of tube 30 per molecule  : 1660539

tubes with a molecule per litre : 23
tubes almost certainly empty    : 7

the a-tenth-is-still-something reasoning
  each step : exactly one part in 10
  stock : exactly 1 mole per litre
  arithmetic : 30 tenths, 10 to the minus 30 moles per litre
  intent : does the last tube still hold the compound
  facts wrong : 0
  verdict : THE LAST TUBE HOLDS THE COMPOUND, AT A TRACE

  keeping every step at exactly one in ten is the part done
  right here, and it is why the concentration in each tube is
  exactly what the protocol names

a concentration is a count
  what a mole is : 602214076000000000000000 molecules, a number
  what a molecule cannot do : split; a tube holds whole ones
  after 23 tubes : 6 molecules in a litre
  after 24 tubes : 602 in a thousand litres, so most
    litres hold none
  after 30 tubes : 602 in a billion litres, one molecule per
    1660539 litres
  what the number 10 to the minus 30 means there : the chance
    that a litre happens to hold one

the standard
  believed : a trace of the compound in every tube
  actual : 7 tubes in which a litre almost certainly holds none
  is the dilution arithmetic wrong : no; every step is exact
  can a concentration go on shrinking forever : no; below one
    molecule per sample it stops describing the sample

null control - count molecules, not moles
  tubes read as holding the compound : 30
  tubes holding a molecule per litre : 23
  tubes the count empties : 7
  no tube and no step changed; the concentration was turned back
  into the whole molecules it stands for

what thirty exact one-in-ten dilutions guarantee
  the last tube's concentration is 10 to the minus 30 : exactly
  the last tube holds the compound : not addressed; molecules are
    whole, after 24 tubes there are 602 in a thousand litres,
    and a litre of tube 30 holds one molecule once in 1660539 litres

a fraction of a thing is still a thing only while the thing can be divided;
matter comes in pieces, and past the last piece a smaller number means an
emptier tube, not a thinner one

Each tube is exactly one tenth of the one before - the protocol is right. But
a mole is 602214076000000000000000 whole molecules, so after 23 tubes a
litre holds 6, after 24 most litres hold none, and tube 30 holds one molecule
per 1660539 litres, until the concentration is counted in molecules and not in moles.

Trace event types

eml:run:starteml:assigneml:outputeml:run:done