# Example 1002 — The crate on its small end slid no easier `the_crate_on_its_small_end_slid_no_easier.eml` - Two movers must slide a 60 kg crate across a warehouse floor. Lying flat it touches the floor with 5000 square centimetres; one mover stands it on its small end, 1000 square centimetres, and reasons that with a fifth of the surface rubbing, it will slide with a fifth of the push. What the push really is is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). Two movers must # slide a 60 kg crate across a warehouse floor. Lying flat it touches the floor # with 5000 square centimetres; one mover stands it on its small end, 1000 # square centimetres, and reasons that with a fifth of the surface rubbing, it # will slide with a fifth of the push. What the push really is is computed # below. # # The reasoning is careful. The small end really is a fifth of the flat face; # the floor and the crate really are the same; rubbing really does happen # where the surfaces touch; and the intent is exactly 'make the crate easier to # slide'. # # Sliding friction is set by how hard the surfaces are pressed together - the # crate's weight - times a factor for the two materials, and not by the area. # On the small end the same weight presses on a fifth of the area, five times as # hard on every square centimetre, and the two changes cancel: the push is 30 kg # either way, not 6. 60 => crate_kg 50 => friction_factor_percent 5000 => flat_face_cm2 1000 => small_end_cm2 int(friction_factor_percent * crate_kg / 100) => push_needed_kg int(push_needed_kg * small_end_cm2 / flat_face_cm2) => push_expected_on_the_small_end_kg push_needed_kg - push_expected_on_the_small_end_kg => push_the_area_rule_misses_kg int(crate_kg * 1000 / flat_face_cm2) => pressure_flat_grams_per_cm2 int(crate_kg * 1000 / small_end_cm2) => pressure_on_end_grams_per_cm2 int(flat_face_cm2 / small_end_cm2) => area_ratio "crate : " + str(crate_kg) + " kg, friction factor " + str(friction_factor_percent) + " percent" ^0 "flat face : " + str(flat_face_cm2) + " cm2, pressing " + str(pressure_flat_grams_per_cm2) + " g on each cm2" ^0 "small end : " + str(small_end_cm2) + " cm2, a " + str(area_ratio) + "th of it, pressing " + str(pressure_on_end_grams_per_cm2) + " g on each cm2" ^0 "" ^0 "push needed, lying flat : " + str(push_needed_kg) + " kg" ^0 "push needed, on its end : " + str(push_needed_kg) + " kg" ^0 "push expected on its end : " + str(push_expected_on_the_small_end_kg) + " kg" ^0 "push the area rule misses : " + str(push_the_area_rule_misses_kg) + " kg" ^0 "" ^0 # ---- what the movers verified ---- "the less-surface reasoning" ^0 " small end : a " + str(area_ratio) + "th of the flat face" ^0 " floor and crate : the same" ^0 " where rubbing happens : where the surfaces touch" ^0 " intent : make the crate easier to slide" ^0 " facts wrong : 0" ^0 " verdict : ON ITS END IT SLIDES WITH A FIFTH OF THE PUSH" ^0 "" ^0 " measuring both faces is the part done right here, and it is" ^0 " why " + str(small_end_cm2) + " cm2 is exactly the area on the floor when it stands" ^0 "" ^0 # ---- what friction depends on ---- "pressed together, not spread out" ^0 " what sets sliding friction : how hard the surfaces are pressed" ^0 " together, times a factor for the two materials" ^0 " how hard they are pressed : the crate's weight, " + str(crate_kg) + " kg, on any face" ^0 " what the smaller face changes : the same weight on less area," ^0 " " + str(pressure_on_end_grams_per_cm2) + " g on each cm2 instead of " + str(pressure_flat_grams_per_cm2) ^0 " why it cancels : a fifth of the contact, each part pressed five" ^0 " times as hard" ^0 " the push : " + str(push_needed_kg) + " kg, flat or on end" ^0 "" ^0 # ---- what the movers got ---- "the push" ^0 " believed : " + str(push_expected_on_the_small_end_kg) + " kg on its end" ^0 " actual : " + str(push_needed_kg) + " kg, the same as flat, and a crate now tall enough" ^0 " to tip" ^0 " is the area wrong : no; the end is a " + str(area_ratio) + "th of the face" ^0 " does friction follow the area : no; it follows the weight" ^0 "" ^0 # ---- null control ---- # The same crate pushed with friction worked out from its weight instead of from # the area in contact. 6 => nc_push_read_from_the_area_kg 30 => nc_push_read_from_the_weight_kg 24 => nc_kg_the_weight_rule_restores "null control - work friction out from the weight" ^0 " push, read from the area : " + str(nc_push_read_from_the_area_kg) + " kg" ^0 " push, read from the weight : " + str(nc_push_read_from_the_weight_kg) + " kg" ^0 " kg the weight rule restores : " + str(nc_kg_the_weight_rule_restores) ^0 " no crate and no floor changed; the friction was computed from" ^0 " what presses the surfaces together" ^0 "" ^0 # ---- the rule ---- "what standing the crate on a smaller face guarantees" ^0 " less of it touches the floor : exactly, a " + str(area_ratio) + "th" ^0 " it slides with less push : not addressed; friction follows the" ^0 " weight pressing the surfaces together, " + str(crate_kg) + " kg on any face, and" ^0 " the push stays " + str(push_needed_kg) + " kg" ^0 "" ^0 "friction is a bargain between weight and contact, and the weight always wins" ^0 "it back; shrink the contact and every part of it bears down harder" ^0 "" ^0 "The small end is a " + str(area_ratio) + "th of the flat face - measured. But sliding friction follows" ^0 "the weight pressing the surfaces together, not the area, so on its end the" ^0 "crate still needs " + str(push_needed_kg) + " kg of push, not " + str(push_expected_on_the_small_end_kg) + ", until friction is worked out from the" ^0 "weight rather than from the surface in contact." ^0 ``` ## Python (deterministic transpilation) ```python crate_kg = 60 friction_factor_percent = 50 flat_face_cm2 = 5000 small_end_cm2 = 1000 push_needed_kg = int(friction_factor_percent * crate_kg / 100) push_expected_on_the_small_end_kg = int(push_needed_kg * small_end_cm2 / flat_face_cm2) push_the_area_rule_misses_kg = push_needed_kg - push_expected_on_the_small_end_kg pressure_flat_grams_per_cm2 = int(crate_kg * 1000 / flat_face_cm2) pressure_on_end_grams_per_cm2 = int(crate_kg * 1000 / small_end_cm2) area_ratio = int(flat_face_cm2 / small_end_cm2) print("crate : " + str(crate_kg) + " kg, friction factor " + str(friction_factor_percent) + " percent") print("flat face : " + str(flat_face_cm2) + " cm2, pressing " + str(pressure_flat_grams_per_cm2) + " g on each cm2") print("small end : " + str(small_end_cm2) + " cm2, a " + str(area_ratio) + "th of it, pressing " + str(pressure_on_end_grams_per_cm2) + " g on each cm2") print("") print("push needed, lying flat : " + str(push_needed_kg) + " kg") print("push needed, on its end : " + str(push_needed_kg) + " kg") print("push expected on its end : " + str(push_expected_on_the_small_end_kg) + " kg") print("push the area rule misses : " + str(push_the_area_rule_misses_kg) + " kg") print("") print("the less-surface reasoning") print(" small end : a " + str(area_ratio) + "th of the flat face") print(" floor and crate : the same") print(" where rubbing happens : where the surfaces touch") print(" intent : make the crate easier to slide") print(" facts wrong : 0") print(" verdict : ON ITS END IT SLIDES WITH A FIFTH OF THE PUSH") print("") print(" measuring both faces is the part done right here, and it is") print(" why " + str(small_end_cm2) + " cm2 is exactly the area on the floor when it stands") print("") print("pressed together, not spread out") print(" what sets sliding friction : how hard the surfaces are pressed") print(" together, times a factor for the two materials") print(" how hard they are pressed : the crate's weight, " + str(crate_kg) + " kg, on any face") print(" what the smaller face changes : the same weight on less area,") print(" " + str(pressure_on_end_grams_per_cm2) + " g on each cm2 instead of " + str(pressure_flat_grams_per_cm2)) print(" why it cancels : a fifth of the contact, each part pressed five") print(" times as hard") print(" the push : " + str(push_needed_kg) + " kg, flat or on end") print("") print("the push") print(" believed : " + str(push_expected_on_the_small_end_kg) + " kg on its end") print(" actual : " + str(push_needed_kg) + " kg, the same as flat, and a crate now tall enough") print(" to tip") print(" is the area wrong : no; the end is a " + str(area_ratio) + "th of the face") print(" does friction follow the area : no; it follows the weight") print("") nc_push_read_from_the_area_kg = 6 nc_push_read_from_the_weight_kg = 30 nc_kg_the_weight_rule_restores = 24 print("null control - work friction out from the weight") print(" push, read from the area : " + str(nc_push_read_from_the_area_kg) + " kg") print(" push, read from the weight : " + str(nc_push_read_from_the_weight_kg) + " kg") print(" kg the weight rule restores : " + str(nc_kg_the_weight_rule_restores)) print(" no crate and no floor changed; the friction was computed from") print(" what presses the surfaces together") print("") print("what standing the crate on a smaller face guarantees") print(" less of it touches the floor : exactly, a " + str(area_ratio) + "th") print(" it slides with less push : not addressed; friction follows the") print(" weight pressing the surfaces together, " + str(crate_kg) + " kg on any face, and") print(" the push stays " + str(push_needed_kg) + " kg") print("") print("friction is a bargain between weight and contact, and the weight always wins") print("it back; shrink the contact and every part of it bears down harder") print("") print("The small end is a " + str(area_ratio) + "th of the flat face - measured. But sliding friction follows") print("the weight pressing the surfaces together, not the area, so on its end the") print("crate still needs " + str(push_needed_kg) + " kg of push, not " + str(push_expected_on_the_small_end_kg) + ", until friction is worked out from the") print("weight rather than from the surface in contact.") ``` ## stdout (executed) ```text crate : 60 kg, friction factor 50 percent flat face : 5000 cm2, pressing 12 g on each cm2 small end : 1000 cm2, a 5th of it, pressing 60 g on each cm2 push needed, lying flat : 30 kg push needed, on its end : 30 kg push expected on its end : 6 kg push the area rule misses : 24 kg the less-surface reasoning small end : a 5th of the flat face floor and crate : the same where rubbing happens : where the surfaces touch intent : make the crate easier to slide facts wrong : 0 verdict : ON ITS END IT SLIDES WITH A FIFTH OF THE PUSH measuring both faces is the part done right here, and it is why 1000 cm2 is exactly the area on the floor when it stands pressed together, not spread out what sets sliding friction : how hard the surfaces are pressed together, times a factor for the two materials how hard they are pressed : the crate's weight, 60 kg, on any face what the smaller face changes : the same weight on less area, 60 g on each cm2 instead of 12 why it cancels : a fifth of the contact, each part pressed five times as hard the push : 30 kg, flat or on end the push believed : 6 kg on its end actual : 30 kg, the same as flat, and a crate now tall enough to tip is the area wrong : no; the end is a 5th of the face does friction follow the area : no; it follows the weight null control - work friction out from the weight push, read from the area : 6 kg push, read from the weight : 30 kg kg the weight rule restores : 24 no crate and no floor changed; the friction was computed from what presses the surfaces together what standing the crate on a smaller face guarantees less of it touches the floor : exactly, a 5th it slides with less push : not addressed; friction follows the weight pressing the surfaces together, 60 kg on any face, and the push stays 30 kg friction is a bargain between weight and contact, and the weight always wins it back; shrink the contact and every part of it bears down harder The small end is a 5th of the flat face - measured. But sliding friction follows the weight pressing the surfaces together, not the area, so on its end the crate still needs 30 kg of push, not 6, until friction is worked out from the weight rather than from the surface in contact. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done