# Example 992 — The fine sand drew the water higher than the gravel `the_fine_sand_drew_the_water_higher_than_the_gravel.eml` - A builder laying a floor slab over damp ground must choose the layer beneath it, and chooses fine sand over coarse gravel, reasoning that sand packs tight with tiny gaps while gravel is full of big holes, so sand will let less water up to the slab. How high water climbs in each is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). A builder laying a # floor slab over damp ground must choose the layer beneath it, and chooses fine # sand over coarse gravel, reasoning that sand packs tight with tiny gaps while # gravel is full of big holes, so sand will let less water up to the slab. How # high water climbs in each is computed below. # # The reasoning is careful. Sand really does pack with far smaller gaps; water # really does pass through sand more slowly when pushed; the damp ground really # is 20 cm below the slab; and the intent is exactly 'keep the slab dry'. # # In a narrow gap water climbs by itself, pulled up by its surface tension, and # the narrower the gap the higher it climbs - the height goes as one over the # gap's radius. Gaps of 5 hundredths of a millimetre lift water 296 mm, well past # the slab; gaps of 2 mm lift it only 7. The tight sand is a wick; the gravel is # a break. 728 => surface_tension_tenths_of_mn_per_m 981 => gravity_cm_per_s2 5 => sand_gap_radius_hundredths_of_a_mm 200 => gravel_gap_radius_hundredths_of_a_mm 200 => damp_ground_below_the_slab_mm int(2 * surface_tension_tenths_of_mn_per_m * 1000 / gravity_cm_per_s2) => rise_times_radius_hundredths_of_a_mm2 int(rise_times_radius_hundredths_of_a_mm2 / sand_gap_radius_hundredths_of_a_mm) => water_climbs_in_the_sand_mm int(rise_times_radius_hundredths_of_a_mm2 / gravel_gap_radius_hundredths_of_a_mm) => water_climbs_in_the_gravel_mm water_climbs_in_the_sand_mm - damp_ground_below_the_slab_mm => sand_climb_to_spare_above_the_slab_mm damp_ground_below_the_slab_mm - water_climbs_in_the_gravel_mm => gravel_stops_short_of_the_slab_by_mm int(gravel_gap_radius_hundredths_of_a_mm / sand_gap_radius_hundredths_of_a_mm) => gravel_gaps_times_wider "surface tension of water : " + str(surface_tension_tenths_of_mn_per_m) + " tenths of a mN/m" ^0 "climb times gap radius : " + str(rise_times_radius_hundredths_of_a_mm2) + " hundredths of a mm2" ^0 "" ^0 "fine sand, gap radius : " + str(sand_gap_radius_hundredths_of_a_mm) + " hundredths of a mm; water climbs " + str(water_climbs_in_the_sand_mm) + " mm" ^0 "coarse gravel, gap radius : " + str(gravel_gap_radius_hundredths_of_a_mm) + " hundredths of a mm, " + str(gravel_gaps_times_wider) + " times wider; water climbs " + str(water_climbs_in_the_gravel_mm) + " mm" ^0 "damp ground below the slab : " + str(damp_ground_below_the_slab_mm) + " mm" ^0 "" ^0 "sand reaches the slab with : " + str(sand_climb_to_spare_above_the_slab_mm) + " mm of climb to spare" ^0 "gravel stops short of it by : " + str(gravel_stops_short_of_the_slab_by_mm) + " mm" ^0 "" ^0 # ---- what the builder verified ---- "the tight-packing reasoning" ^0 " sand : tiny gaps, packed tight" ^0 " gravel : big holes between the stones" ^0 " pushed water : passes through sand far more slowly" ^0 " intent : keep the slab dry" ^0 " facts wrong : 0" ^0 " verdict : FINE SAND KEEPS THE WATER DOWN BETTER THAN GRAVEL" ^0 "" ^0 " knowing that sand resists water pushed through it is the part" ^0 " done right here, and it is why a flood from above would soak" ^0 " through the gravel first" ^0 "" ^0 # ---- how high water climbs by itself ---- "narrow gaps pull" ^0 " what lifts the water : its surface tension, clinging to the" ^0 " grains and pulling the surface up the gap" ^0 " what holds it down : the weight of the column it has lifted" ^0 " where they balance : at a height that goes as one over the" ^0 " gap's radius, " + str(rise_times_radius_hundredths_of_a_mm2) + " hundredths of a mm2 divided by it" ^0 " in the sand : " + str(water_climbs_in_the_sand_mm) + " mm, past a slab " + str(damp_ground_below_the_slab_mm) + " mm above the damp" ^0 " in the gravel : " + str(water_climbs_in_the_gravel_mm) + " mm, nowhere near it" ^0 " what the tight packing did : made every gap a wick" ^0 "" ^0 # ---- what the builder got ---- "the slab" ^0 " believed : dry above a tight layer of sand" ^0 " actual : damp from below; the sand lifts water to the slab" ^0 " with " + str(sand_climb_to_spare_above_the_slab_mm) + " mm of climb to spare" ^0 " is sand slower to let pushed water through : yes; that part" ^0 " is true" ^0 " does tightness keep rising damp out : no; it is what draws it up" ^0 "" ^0 # ---- null control ---- # The same two layers judged by how high water climbs in them by itself instead # of by how tightly they pack. 0 => nc_climb_read_from_the_tightness_of_the_sand_mm 296 => nc_climb_from_the_width_of_the_gaps_mm 296 => nc_mm_the_gap_width_reveals "null control - judge the layer by its gaps" ^0 " climb in the sand, read from its tightness : " + str(nc_climb_read_from_the_tightness_of_the_sand_mm) + " mm" ^0 " climb in the sand, from the width of its gaps : " + str(nc_climb_from_the_width_of_the_gaps_mm) + " mm" ^0 " mm the gap width reveals : " + str(nc_mm_the_gap_width_reveals) ^0 " no ground and no slab changed; the layer was judged by the" ^0 " force that lifts water, not the one that pushes it" ^0 "" ^0 # ---- the rule ---- "what a tight, fine layer guarantees" ^0 " water pushed through it moves slowly : exactly" ^0 " it keeps rising damp from the slab : not addressed; water climbs" ^0 " a gap by itself to a height of one over its radius, " + str(water_climbs_in_the_sand_mm) + " mm" ^0 " in the sand against " + str(water_climbs_in_the_gravel_mm) + " mm in the gravel, and the slab sits " + str(damp_ground_below_the_slab_mm) ^0 " mm up" ^0 "" ^0 "a barrier against pushing is not a barrier against pulling; the finer the" ^0 "gap, the harder water is to force through it and the higher it climbs on its" ^0 "own" ^0 "" ^0 "Sand does resist water pushed through it - that part is right. But water" ^0 "climbs a gap by itself to a height of one over its radius: " + str(water_climbs_in_the_sand_mm) + " mm in the sand," ^0 "past a slab " + str(damp_ground_below_the_slab_mm) + " mm above the damp, and " + str(water_climbs_in_the_gravel_mm) + " mm in the gravel, until the layer is" ^0 "chosen by the width of its gaps rather than the tightness of its packing." ^0 ``` ## Python (deterministic transpilation) ```python surface_tension_tenths_of_mn_per_m = 728 gravity_cm_per_s2 = 981 sand_gap_radius_hundredths_of_a_mm = 5 gravel_gap_radius_hundredths_of_a_mm = 200 damp_ground_below_the_slab_mm = 200 rise_times_radius_hundredths_of_a_mm2 = int(2 * surface_tension_tenths_of_mn_per_m * 1000 / gravity_cm_per_s2) water_climbs_in_the_sand_mm = int(rise_times_radius_hundredths_of_a_mm2 / sand_gap_radius_hundredths_of_a_mm) water_climbs_in_the_gravel_mm = int(rise_times_radius_hundredths_of_a_mm2 / gravel_gap_radius_hundredths_of_a_mm) sand_climb_to_spare_above_the_slab_mm = water_climbs_in_the_sand_mm - damp_ground_below_the_slab_mm gravel_stops_short_of_the_slab_by_mm = damp_ground_below_the_slab_mm - water_climbs_in_the_gravel_mm gravel_gaps_times_wider = int(gravel_gap_radius_hundredths_of_a_mm / sand_gap_radius_hundredths_of_a_mm) print("surface tension of water : " + str(surface_tension_tenths_of_mn_per_m) + " tenths of a mN/m") print("climb times gap radius : " + str(rise_times_radius_hundredths_of_a_mm2) + " hundredths of a mm2") print("") print("fine sand, gap radius : " + str(sand_gap_radius_hundredths_of_a_mm) + " hundredths of a mm; water climbs " + str(water_climbs_in_the_sand_mm) + " mm") print("coarse gravel, gap radius : " + str(gravel_gap_radius_hundredths_of_a_mm) + " hundredths of a mm, " + str(gravel_gaps_times_wider) + " times wider; water climbs " + str(water_climbs_in_the_gravel_mm) + " mm") print("damp ground below the slab : " + str(damp_ground_below_the_slab_mm) + " mm") print("") print("sand reaches the slab with : " + str(sand_climb_to_spare_above_the_slab_mm) + " mm of climb to spare") print("gravel stops short of it by : " + str(gravel_stops_short_of_the_slab_by_mm) + " mm") print("") print("the tight-packing reasoning") print(" sand : tiny gaps, packed tight") print(" gravel : big holes between the stones") print(" pushed water : passes through sand far more slowly") print(" intent : keep the slab dry") print(" facts wrong : 0") print(" verdict : FINE SAND KEEPS THE WATER DOWN BETTER THAN GRAVEL") print("") print(" knowing that sand resists water pushed through it is the part") print(" done right here, and it is why a flood from above would soak") print(" through the gravel first") print("") print("narrow gaps pull") print(" what lifts the water : its surface tension, clinging to the") print(" grains and pulling the surface up the gap") print(" what holds it down : the weight of the column it has lifted") print(" where they balance : at a height that goes as one over the") print(" gap's radius, " + str(rise_times_radius_hundredths_of_a_mm2) + " hundredths of a mm2 divided by it") print(" in the sand : " + str(water_climbs_in_the_sand_mm) + " mm, past a slab " + str(damp_ground_below_the_slab_mm) + " mm above the damp") print(" in the gravel : " + str(water_climbs_in_the_gravel_mm) + " mm, nowhere near it") print(" what the tight packing did : made every gap a wick") print("") print("the slab") print(" believed : dry above a tight layer of sand") print(" actual : damp from below; the sand lifts water to the slab") print(" with " + str(sand_climb_to_spare_above_the_slab_mm) + " mm of climb to spare") print(" is sand slower to let pushed water through : yes; that part") print(" is true") print(" does tightness keep rising damp out : no; it is what draws it up") print("") nc_climb_read_from_the_tightness_of_the_sand_mm = 0 nc_climb_from_the_width_of_the_gaps_mm = 296 nc_mm_the_gap_width_reveals = 296 print("null control - judge the layer by its gaps") print(" climb in the sand, read from its tightness : " + str(nc_climb_read_from_the_tightness_of_the_sand_mm) + " mm") print(" climb in the sand, from the width of its gaps : " + str(nc_climb_from_the_width_of_the_gaps_mm) + " mm") print(" mm the gap width reveals : " + str(nc_mm_the_gap_width_reveals)) print(" no ground and no slab changed; the layer was judged by the") print(" force that lifts water, not the one that pushes it") print("") print("what a tight, fine layer guarantees") print(" water pushed through it moves slowly : exactly") print(" it keeps rising damp from the slab : not addressed; water climbs") print(" a gap by itself to a height of one over its radius, " + str(water_climbs_in_the_sand_mm) + " mm") print(" in the sand against " + str(water_climbs_in_the_gravel_mm) + " mm in the gravel, and the slab sits " + str(damp_ground_below_the_slab_mm)) print(" mm up") print("") print("a barrier against pushing is not a barrier against pulling; the finer the") print("gap, the harder water is to force through it and the higher it climbs on its") print("own") print("") print("Sand does resist water pushed through it - that part is right. But water") print("climbs a gap by itself to a height of one over its radius: " + str(water_climbs_in_the_sand_mm) + " mm in the sand,") print("past a slab " + str(damp_ground_below_the_slab_mm) + " mm above the damp, and " + str(water_climbs_in_the_gravel_mm) + " mm in the gravel, until the layer is") print("chosen by the width of its gaps rather than the tightness of its packing.") ``` ## stdout (executed) ```text surface tension of water : 728 tenths of a mN/m climb times gap radius : 1484 hundredths of a mm2 fine sand, gap radius : 5 hundredths of a mm; water climbs 296 mm coarse gravel, gap radius : 200 hundredths of a mm, 40 times wider; water climbs 7 mm damp ground below the slab : 200 mm sand reaches the slab with : 96 mm of climb to spare gravel stops short of it by : 193 mm the tight-packing reasoning sand : tiny gaps, packed tight gravel : big holes between the stones pushed water : passes through sand far more slowly intent : keep the slab dry facts wrong : 0 verdict : FINE SAND KEEPS THE WATER DOWN BETTER THAN GRAVEL knowing that sand resists water pushed through it is the part done right here, and it is why a flood from above would soak through the gravel first narrow gaps pull what lifts the water : its surface tension, clinging to the grains and pulling the surface up the gap what holds it down : the weight of the column it has lifted where they balance : at a height that goes as one over the gap's radius, 1484 hundredths of a mm2 divided by it in the sand : 296 mm, past a slab 200 mm above the damp in the gravel : 7 mm, nowhere near it what the tight packing did : made every gap a wick the slab believed : dry above a tight layer of sand actual : damp from below; the sand lifts water to the slab with 96 mm of climb to spare is sand slower to let pushed water through : yes; that part is true does tightness keep rising damp out : no; it is what draws it up null control - judge the layer by its gaps climb in the sand, read from its tightness : 0 mm climb in the sand, from the width of its gaps : 296 mm mm the gap width reveals : 296 no ground and no slab changed; the layer was judged by the force that lifts water, not the one that pushes it what a tight, fine layer guarantees water pushed through it moves slowly : exactly it keeps rising damp from the slab : not addressed; water climbs a gap by itself to a height of one over its radius, 296 mm in the sand against 7 mm in the gravel, and the slab sits 200 mm up a barrier against pushing is not a barrier against pulling; the finer the gap, the harder water is to force through it and the higher it climbs on its own Sand does resist water pushed through it - that part is right. But water climbs a gap by itself to a height of one over its radius: 296 mm in the sand, past a slab 200 mm above the damp, and 7 mm in the gravel, until the layer is chosen by the width of its gaps rather than the tightness of its packing. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done