# Example 1004 — The same push on the longer bar snapped the bolt `the_same_push_on_the_longer_bar_snapped_the_bolt.eml` - A mechanic frees a seized nut with a 75 cm bar, then tightens the new bolt with the same bar and the same firm push used every day on a 25 cm wrench - a push that always gives the specified 100 newton-metres. How tight the bolt really goes is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). A mechanic frees a # seized nut with a 75 cm bar, then tightens the new bolt with the same bar and # the same firm push used every day on a 25 cm wrench - a push that always gives # the specified 100 newton-metres. How tight the bolt really goes is computed # below. # # The reasoning is careful. The push really is the same 400 newtons, a trained # feel; on the usual wrench it really does give the specified tightness; the # bolt really is the right bolt; and the intent is exactly 'tighten to spec'. # # Tightness is torque, the push times the distance from the bolt to where it is # applied. Three times the lever with the same push is three times the torque: # 300 newton-metres on a bolt that yields at 120. The push that would have given # the specified 100 on the long bar is a third of the usual one, 133 newtons. 400 => push_newtons 25 => usual_wrench_cm 75 => long_bar_cm 100 => specified_torque_nm 120 => bolt_yields_at_nm int(push_newtons * usual_wrench_cm / 100) => torque_on_the_usual_wrench_nm int(push_newtons * long_bar_cm / 100) => torque_on_the_long_bar_nm int(long_bar_cm / usual_wrench_cm) => lever_times_longer torque_on_the_long_bar_nm - bolt_yields_at_nm => over_the_yield_nm int(torque_on_the_long_bar_nm * 100 / bolt_yields_at_nm) => torque_vs_yield_percent int(specified_torque_nm * 100 / long_bar_cm) => push_for_spec_on_the_long_bar_newtons "push : " + str(push_newtons) + " N" ^0 "usual wrench : " + str(usual_wrench_cm) + " cm, torque " + str(torque_on_the_usual_wrench_nm) + " N-m, the specified " + str(specified_torque_nm) ^0 "long bar : " + str(long_bar_cm) + " cm, " + str(lever_times_longer) + " times the lever, torque " + str(torque_on_the_long_bar_nm) + " N-m" ^0 "bolt yields at : " + str(bolt_yields_at_nm) + " N-m; long bar is " + str(over_the_yield_nm) + " over, " + str(torque_vs_yield_percent) + " percent of it" ^0 "push for spec on the long bar : " + str(push_for_spec_on_the_long_bar_newtons) + " N" ^0 "" ^0 # ---- what the mechanic verified ---- "the same-push reasoning" ^0 " push : " + str(push_newtons) + " N, a trained, repeatable feel" ^0 " on the usual wrench : exactly the specified " + str(specified_torque_nm) + " N-m" ^0 " bolt : the right one" ^0 " intent : tighten to spec" ^0 " facts wrong : 0" ^0 " verdict : THE USUAL PUSH GIVES THE USUAL TIGHTNESS" ^0 "" ^0 " keeping the push the same is the part done right here, and it" ^0 " is why " + str(push_newtons) + " N is exactly what reached the handle" ^0 "" ^0 # ---- what the lever does ---- "torque is push times lever" ^0 " what tightens a bolt : the turning effect, push times the" ^0 " distance from the bolt" ^0 " usual wrench : " + str(push_newtons) + " N at " + str(usual_wrench_cm) + " cm, " + str(torque_on_the_usual_wrench_nm) + " N-m" ^0 " long bar : the same " + str(push_newtons) + " N at " + str(long_bar_cm) + " cm, " + str(torque_on_the_long_bar_nm) + " N-m" ^0 " what the trained feel measured : the push, which the hand can" ^0 " feel; not the lever, which it cannot" ^0 "" ^0 # ---- what the mechanic got ---- "the bolt" ^0 " believed : " + str(specified_torque_nm) + " N-m, to spec" ^0 " actual : " + str(torque_on_the_long_bar_nm) + " N-m, past its yield of " + str(bolt_yields_at_nm) + ", stretched and snapped" ^0 " was the push different : no; " + str(push_newtons) + " N both times" ^0 " is the push the tightness : only on the lever it was learned on" ^0 "" ^0 # ---- null control ---- # The same bolt tightened by torque instead of by the feel of the push. 100 => nc_torque_read_from_the_push_nm 300 => nc_torque_read_from_push_times_lever_nm 200 => nc_nm_the_long_lever_adds "null control - count the lever" ^0 " torque, read from the push : " + str(nc_torque_read_from_the_push_nm) + " N-m" ^0 " torque, read from push times lever : " + str(nc_torque_read_from_push_times_lever_nm) + " N-m" ^0 " N-m the long lever adds : " + str(nc_nm_the_long_lever_adds) ^0 " no bolt and no push changed; the turning effect was computed" ^0 " from both of its factors" ^0 "" ^0 # ---- the rule ---- "what the same trained push guarantees" ^0 " the same force reaches the handle : exactly, " + str(push_newtons) + " N" ^0 " the bolt reaches the same tightness : not addressed; torque is" ^0 " push times lever, the bar is " + str(lever_times_longer) + " times the wrench, and the bolt" ^0 " gets " + str(torque_on_the_long_bar_nm) + " N-m against a yield of " + str(bolt_yields_at_nm) ^0 "" ^0 "a feel for force is a feel for one lever; change the lever and the same" ^0 "hand is a different tool" ^0 "" ^0 "The push was the usual " + str(push_newtons) + " N - exactly. But torque is push times lever, and the" ^0 "bar is " + str(lever_times_longer) + " times the wrench, so the bolt got " + str(torque_on_the_long_bar_nm) + " N-m against a yield of " + str(bolt_yields_at_nm) + ", where" ^0 "" + str(push_for_spec_on_the_long_bar_newtons) + " N would have given the specified " + str(specified_torque_nm) + ", until the tightness is set by torque and" ^0 "not by the feel of the push." ^0 ``` ## Python (deterministic transpilation) ```python push_newtons = 400 usual_wrench_cm = 25 long_bar_cm = 75 specified_torque_nm = 100 bolt_yields_at_nm = 120 torque_on_the_usual_wrench_nm = int(push_newtons * usual_wrench_cm / 100) torque_on_the_long_bar_nm = int(push_newtons * long_bar_cm / 100) lever_times_longer = int(long_bar_cm / usual_wrench_cm) over_the_yield_nm = torque_on_the_long_bar_nm - bolt_yields_at_nm torque_vs_yield_percent = int(torque_on_the_long_bar_nm * 100 / bolt_yields_at_nm) push_for_spec_on_the_long_bar_newtons = int(specified_torque_nm * 100 / long_bar_cm) print("push : " + str(push_newtons) + " N") print("usual wrench : " + str(usual_wrench_cm) + " cm, torque " + str(torque_on_the_usual_wrench_nm) + " N-m, the specified " + str(specified_torque_nm)) print("long bar : " + str(long_bar_cm) + " cm, " + str(lever_times_longer) + " times the lever, torque " + str(torque_on_the_long_bar_nm) + " N-m") print("bolt yields at : " + str(bolt_yields_at_nm) + " N-m; long bar is " + str(over_the_yield_nm) + " over, " + str(torque_vs_yield_percent) + " percent of it") print("push for spec on the long bar : " + str(push_for_spec_on_the_long_bar_newtons) + " N") print("") print("the same-push reasoning") print(" push : " + str(push_newtons) + " N, a trained, repeatable feel") print(" on the usual wrench : exactly the specified " + str(specified_torque_nm) + " N-m") print(" bolt : the right one") print(" intent : tighten to spec") print(" facts wrong : 0") print(" verdict : THE USUAL PUSH GIVES THE USUAL TIGHTNESS") print("") print(" keeping the push the same is the part done right here, and it") print(" is why " + str(push_newtons) + " N is exactly what reached the handle") print("") print("torque is push times lever") print(" what tightens a bolt : the turning effect, push times the") print(" distance from the bolt") print(" usual wrench : " + str(push_newtons) + " N at " + str(usual_wrench_cm) + " cm, " + str(torque_on_the_usual_wrench_nm) + " N-m") print(" long bar : the same " + str(push_newtons) + " N at " + str(long_bar_cm) + " cm, " + str(torque_on_the_long_bar_nm) + " N-m") print(" what the trained feel measured : the push, which the hand can") print(" feel; not the lever, which it cannot") print("") print("the bolt") print(" believed : " + str(specified_torque_nm) + " N-m, to spec") print(" actual : " + str(torque_on_the_long_bar_nm) + " N-m, past its yield of " + str(bolt_yields_at_nm) + ", stretched and snapped") print(" was the push different : no; " + str(push_newtons) + " N both times") print(" is the push the tightness : only on the lever it was learned on") print("") nc_torque_read_from_the_push_nm = 100 nc_torque_read_from_push_times_lever_nm = 300 nc_nm_the_long_lever_adds = 200 print("null control - count the lever") print(" torque, read from the push : " + str(nc_torque_read_from_the_push_nm) + " N-m") print(" torque, read from push times lever : " + str(nc_torque_read_from_push_times_lever_nm) + " N-m") print(" N-m the long lever adds : " + str(nc_nm_the_long_lever_adds)) print(" no bolt and no push changed; the turning effect was computed") print(" from both of its factors") print("") print("what the same trained push guarantees") print(" the same force reaches the handle : exactly, " + str(push_newtons) + " N") print(" the bolt reaches the same tightness : not addressed; torque is") print(" push times lever, the bar is " + str(lever_times_longer) + " times the wrench, and the bolt") print(" gets " + str(torque_on_the_long_bar_nm) + " N-m against a yield of " + str(bolt_yields_at_nm)) print("") print("a feel for force is a feel for one lever; change the lever and the same") print("hand is a different tool") print("") print("The push was the usual " + str(push_newtons) + " N - exactly. But torque is push times lever, and the") print("bar is " + str(lever_times_longer) + " times the wrench, so the bolt got " + str(torque_on_the_long_bar_nm) + " N-m against a yield of " + str(bolt_yields_at_nm) + ", where") print("" + str(push_for_spec_on_the_long_bar_newtons) + " N would have given the specified " + str(specified_torque_nm) + ", until the tightness is set by torque and") print("not by the feel of the push.") ``` ## stdout (executed) ```text push : 400 N usual wrench : 25 cm, torque 100 N-m, the specified 100 long bar : 75 cm, 3 times the lever, torque 300 N-m bolt yields at : 120 N-m; long bar is 180 over, 250 percent of it push for spec on the long bar : 133 N the same-push reasoning push : 400 N, a trained, repeatable feel on the usual wrench : exactly the specified 100 N-m bolt : the right one intent : tighten to spec facts wrong : 0 verdict : THE USUAL PUSH GIVES THE USUAL TIGHTNESS keeping the push the same is the part done right here, and it is why 400 N is exactly what reached the handle torque is push times lever what tightens a bolt : the turning effect, push times the distance from the bolt usual wrench : 400 N at 25 cm, 100 N-m long bar : the same 400 N at 75 cm, 300 N-m what the trained feel measured : the push, which the hand can feel; not the lever, which it cannot the bolt believed : 100 N-m, to spec actual : 300 N-m, past its yield of 120, stretched and snapped was the push different : no; 400 N both times is the push the tightness : only on the lever it was learned on null control - count the lever torque, read from the push : 100 N-m torque, read from push times lever : 300 N-m N-m the long lever adds : 200 no bolt and no push changed; the turning effect was computed from both of its factors what the same trained push guarantees the same force reaches the handle : exactly, 400 N the bolt reaches the same tightness : not addressed; torque is push times lever, the bar is 3 times the wrench, and the bolt gets 300 N-m against a yield of 120 a feel for force is a feel for one lever; change the lever and the same hand is a different tool The push was the usual 400 N - exactly. But torque is push times lever, and the bar is 3 times the wrench, so the bolt got 300 N-m against a yield of 120, where 133 N would have given the specified 100, until the tightness is set by torque and not by the feel of the push. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done