# Example 1003 — The four rope block let one hauler do four mens lifting in four times the time `the_four_rope_block_let_one_hauler_do_four_mens_lifting_in_four_times_the_time.eml` - A crew must raise 20 loads of 200 kg each 3 metres onto a platform. Four haulers lifting on one rope can do it; the foreman fits a four-rope pulley block instead and reasons that since the block quarters the pull, one hauler now does the work of four, and the job will take the same time with one person. How long it really takes is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). A crew must raise # 20 loads of 200 kg each 3 metres onto a platform. Four haulers lifting on one # rope can do it; the foreman fits a four-rope pulley block instead and reasons # that since the block quarters the pull, one hauler now does the work of four, # and the job will take the same time with one person. How long it really takes # is computed below. # # The reasoning is careful. The block really does have four supporting ropes; # the pull really is a quarter of the load, 50 kg; one hauler really can hold # 50 kg; and the intent is exactly 'finish the lift with one person'. # # A block trades force for distance: to raise the load 3 metres, four ropes must # each shorten by 3 metres, so 12 metres of rope pass through the hauler's # hands. The work - load times height - does not change. At the same hand speed, # each load takes 24 seconds instead of 6, and the job takes 480 seconds where # the four haulers took 120. 200 => load_kg 3 => lift_height_m 20 => loads 4 => ropes_supporting_the_block 5 => hand_speed_tenths_of_a_m_per_s int(load_kg / ropes_supporting_the_block) => pull_with_the_block_kg lift_height_m * ropes_supporting_the_block => rope_pulled_per_load_m load_kg * lift_height_m => work_per_load_kg_m pull_with_the_block_kg * rope_pulled_per_load_m => work_through_the_block_per_load_kg_m int(lift_height_m * 10 / hand_speed_tenths_of_a_m_per_s) => seconds_per_load_four_haulers int(rope_pulled_per_load_m * 10 / hand_speed_tenths_of_a_m_per_s) => seconds_per_load_one_hauler seconds_per_load_four_haulers * loads => job_seconds_four_haulers seconds_per_load_one_hauler * loads => job_seconds_one_hauler int(job_seconds_one_hauler / job_seconds_four_haulers) => times_as_long "load : " + str(load_kg) + " kg, raised " + str(lift_height_m) + " m, " + str(loads) + " times" ^0 "block : " + str(ropes_supporting_the_block) + " supporting ropes, pull " + str(pull_with_the_block_kg) + " kg" ^0 "rope pulled per load : " + str(rope_pulled_per_load_m) + " m, where a direct lift pulls " + str(lift_height_m) ^0 "work per load : " + str(work_per_load_kg_m) + " kg-m direct, " + str(work_through_the_block_per_load_kg_m) + " kg-m through the block" ^0 "hand speed : " + str(hand_speed_tenths_of_a_m_per_s) + " tenths of a m/s" ^0 "" ^0 "four haulers, direct : " + str(seconds_per_load_four_haulers) + " s a load, " + str(job_seconds_four_haulers) + " s for the job" ^0 "one hauler, with the block : " + str(seconds_per_load_one_hauler) + " s a load, " + str(job_seconds_one_hauler) + " s for the job, " + str(times_as_long) + " times as long" ^0 "" ^0 # ---- what the foreman verified ---- "the quarter-the-pull reasoning" ^0 " block : " + str(ropes_supporting_the_block) + " supporting ropes" ^0 " pull : " + str(pull_with_the_block_kg) + " kg, a quarter of the load" ^0 " hauler : can hold " + str(pull_with_the_block_kg) + " kg" ^0 " intent : finish the lift with one person" ^0 " facts wrong : 0" ^0 " verdict : ONE HAULER DOES FOUR HAULERS' JOB IN THE SAME TIME" ^0 "" ^0 " counting the supporting ropes is the part done right here, and" ^0 " it is why " + str(pull_with_the_block_kg) + " kg is exactly the pull one hauler must hold" ^0 "" ^0 # ---- what the block trades ---- "force for distance" ^0 " what the block divides : the pull, by " + str(ropes_supporting_the_block) ^0 " what it multiplies : the rope that must pass through the hands," ^0 " " + str(rope_pulled_per_load_m) + " m for every " + str(lift_height_m) + " m the load rises" ^0 " what it leaves alone : the work, " + str(work_per_load_kg_m) + " kg-m a load either way" ^0 " what one pair of hands does : the same rope speed as before," ^0 " so four times the rope takes four times as long" ^0 "" ^0 # ---- what the foreman got ---- "the job" ^0 " believed : " + str(job_seconds_four_haulers) + " s with one hauler" ^0 " actual : " + str(job_seconds_one_hauler) + " s" ^0 " is the block wrong : no; it quarters the pull exactly" ^0 " does a smaller pull mean less work : no; the work is the" ^0 " load times the height, and the block only spreads it out" ^0 "" ^0 # ---- null control ---- # The same job timed by the rope that must be pulled instead of by the force # that must be held. 120 => nc_job_seconds_read_from_the_pull 480 => nc_job_seconds_read_from_the_rope 360 => nc_seconds_the_rope_adds "null control - time the job by the rope" ^0 " job, read from the pull : " + str(nc_job_seconds_read_from_the_pull) + " s" ^0 " job, read from the rope pulled : " + str(nc_job_seconds_read_from_the_rope) + " s" ^0 " seconds the rope adds : " + str(nc_seconds_the_rope_adds) ^0 " no load and no block changed; the job was measured by the work" ^0 " the hands must do, not the force they must hold" ^0 "" ^0 # ---- the rule ---- "what a four-rope block guarantees" ^0 " the pull is a quarter of the load : exactly, " + str(pull_with_the_block_kg) + " kg" ^0 " one hauler finishes in the same time : not addressed; the" ^0 " block multiplies the rope by " + str(ropes_supporting_the_block) + ", the work is unchanged, and" ^0 " the job takes " + str(job_seconds_one_hauler) + " s instead of " + str(job_seconds_four_haulers) ^0 "" ^0 "a machine can change the size of an effort but not its amount; what it takes" ^0 "off the arms it puts back on the rope" ^0 "" ^0 "The block quarters the pull to " + str(pull_with_the_block_kg) + " kg - exactly. But the work is the load times" ^0 "the height, so " + str(rope_pulled_per_load_m) + " m of rope must pass for every " + str(lift_height_m) + " m of lift, and one hauler" ^0 "takes " + str(job_seconds_one_hauler) + " s where four took " + str(job_seconds_four_haulers) + ", until the job is timed by the work and not the" ^0 "pull." ^0 ``` ## Python (deterministic transpilation) ```python load_kg = 200 lift_height_m = 3 loads = 20 ropes_supporting_the_block = 4 hand_speed_tenths_of_a_m_per_s = 5 pull_with_the_block_kg = int(load_kg / ropes_supporting_the_block) rope_pulled_per_load_m = lift_height_m * ropes_supporting_the_block work_per_load_kg_m = load_kg * lift_height_m work_through_the_block_per_load_kg_m = pull_with_the_block_kg * rope_pulled_per_load_m seconds_per_load_four_haulers = int(lift_height_m * 10 / hand_speed_tenths_of_a_m_per_s) seconds_per_load_one_hauler = int(rope_pulled_per_load_m * 10 / hand_speed_tenths_of_a_m_per_s) job_seconds_four_haulers = seconds_per_load_four_haulers * loads job_seconds_one_hauler = seconds_per_load_one_hauler * loads times_as_long = int(job_seconds_one_hauler / job_seconds_four_haulers) print("load : " + str(load_kg) + " kg, raised " + str(lift_height_m) + " m, " + str(loads) + " times") print("block : " + str(ropes_supporting_the_block) + " supporting ropes, pull " + str(pull_with_the_block_kg) + " kg") print("rope pulled per load : " + str(rope_pulled_per_load_m) + " m, where a direct lift pulls " + str(lift_height_m)) print("work per load : " + str(work_per_load_kg_m) + " kg-m direct, " + str(work_through_the_block_per_load_kg_m) + " kg-m through the block") print("hand speed : " + str(hand_speed_tenths_of_a_m_per_s) + " tenths of a m/s") print("") print("four haulers, direct : " + str(seconds_per_load_four_haulers) + " s a load, " + str(job_seconds_four_haulers) + " s for the job") print("one hauler, with the block : " + str(seconds_per_load_one_hauler) + " s a load, " + str(job_seconds_one_hauler) + " s for the job, " + str(times_as_long) + " times as long") print("") print("the quarter-the-pull reasoning") print(" block : " + str(ropes_supporting_the_block) + " supporting ropes") print(" pull : " + str(pull_with_the_block_kg) + " kg, a quarter of the load") print(" hauler : can hold " + str(pull_with_the_block_kg) + " kg") print(" intent : finish the lift with one person") print(" facts wrong : 0") print(" verdict : ONE HAULER DOES FOUR HAULERS' JOB IN THE SAME TIME") print("") print(" counting the supporting ropes is the part done right here, and") print(" it is why " + str(pull_with_the_block_kg) + " kg is exactly the pull one hauler must hold") print("") print("force for distance") print(" what the block divides : the pull, by " + str(ropes_supporting_the_block)) print(" what it multiplies : the rope that must pass through the hands,") print(" " + str(rope_pulled_per_load_m) + " m for every " + str(lift_height_m) + " m the load rises") print(" what it leaves alone : the work, " + str(work_per_load_kg_m) + " kg-m a load either way") print(" what one pair of hands does : the same rope speed as before,") print(" so four times the rope takes four times as long") print("") print("the job") print(" believed : " + str(job_seconds_four_haulers) + " s with one hauler") print(" actual : " + str(job_seconds_one_hauler) + " s") print(" is the block wrong : no; it quarters the pull exactly") print(" does a smaller pull mean less work : no; the work is the") print(" load times the height, and the block only spreads it out") print("") nc_job_seconds_read_from_the_pull = 120 nc_job_seconds_read_from_the_rope = 480 nc_seconds_the_rope_adds = 360 print("null control - time the job by the rope") print(" job, read from the pull : " + str(nc_job_seconds_read_from_the_pull) + " s") print(" job, read from the rope pulled : " + str(nc_job_seconds_read_from_the_rope) + " s") print(" seconds the rope adds : " + str(nc_seconds_the_rope_adds)) print(" no load and no block changed; the job was measured by the work") print(" the hands must do, not the force they must hold") print("") print("what a four-rope block guarantees") print(" the pull is a quarter of the load : exactly, " + str(pull_with_the_block_kg) + " kg") print(" one hauler finishes in the same time : not addressed; the") print(" block multiplies the rope by " + str(ropes_supporting_the_block) + ", the work is unchanged, and") print(" the job takes " + str(job_seconds_one_hauler) + " s instead of " + str(job_seconds_four_haulers)) print("") print("a machine can change the size of an effort but not its amount; what it takes") print("off the arms it puts back on the rope") print("") print("The block quarters the pull to " + str(pull_with_the_block_kg) + " kg - exactly. But the work is the load times") print("the height, so " + str(rope_pulled_per_load_m) + " m of rope must pass for every " + str(lift_height_m) + " m of lift, and one hauler") print("takes " + str(job_seconds_one_hauler) + " s where four took " + str(job_seconds_four_haulers) + ", until the job is timed by the work and not the") print("pull.") ``` ## stdout (executed) ```text load : 200 kg, raised 3 m, 20 times block : 4 supporting ropes, pull 50 kg rope pulled per load : 12 m, where a direct lift pulls 3 work per load : 600 kg-m direct, 600 kg-m through the block hand speed : 5 tenths of a m/s four haulers, direct : 6 s a load, 120 s for the job one hauler, with the block : 24 s a load, 480 s for the job, 4 times as long the quarter-the-pull reasoning block : 4 supporting ropes pull : 50 kg, a quarter of the load hauler : can hold 50 kg intent : finish the lift with one person facts wrong : 0 verdict : ONE HAULER DOES FOUR HAULERS' JOB IN THE SAME TIME counting the supporting ropes is the part done right here, and it is why 50 kg is exactly the pull one hauler must hold force for distance what the block divides : the pull, by 4 what it multiplies : the rope that must pass through the hands, 12 m for every 3 m the load rises what it leaves alone : the work, 600 kg-m a load either way what one pair of hands does : the same rope speed as before, so four times the rope takes four times as long the job believed : 120 s with one hauler actual : 480 s is the block wrong : no; it quarters the pull exactly does a smaller pull mean less work : no; the work is the load times the height, and the block only spreads it out null control - time the job by the rope job, read from the pull : 120 s job, read from the rope pulled : 480 s seconds the rope adds : 360 no load and no block changed; the job was measured by the work the hands must do, not the force they must hold what a four-rope block guarantees the pull is a quarter of the load : exactly, 50 kg one hauler finishes in the same time : not addressed; the block multiplies the rope by 4, the work is unchanged, and the job takes 480 s instead of 120 a machine can change the size of an effort but not its amount; what it takes off the arms it puts back on the rope The block quarters the pull to 50 kg - exactly. But the work is the load times the height, so 12 m of rope must pass for every 3 m of lift, and one hauler takes 480 s where four took 120, until the job is timed by the work and not the pull. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done