# Example 971 — The water boiled at ninety `the_water_boiled_at_ninety.eml` - A recipe says 'boil for ten minutes', a cook at three thousand metres brings the pot to a rolling boil and times ten minutes to the second, and the food comes out underdone. What 'boiling' means at altitude, and what it means in a pressure cooker, is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). A recipe says # 'boil for ten minutes', a cook at three thousand metres brings the pot to a # rolling boil and times ten minutes to the second, and the food comes out # underdone. What 'boiling' means at altitude, and what it means in a pressure # cooker, is computed below. # # The reasoning is careful. The water was genuinely boiling; ten minutes were # genuinely timed; the recipe was followed to the letter; and the intent was # exactly 'cook it as long as the recipe says'. # # Boiling is the point where water's vapour pressure meets the air pressure, # and thinner air lowers it - at three thousand metres water boils at about # ninety degrees, not a hundred - and since cooking roughly halves in speed for # every ten degrees lost, the recipe's ten minutes at a hundred is twenty at # ninety, while a pressure cooker at a hundred and twenty does it in two and a # half. The recipe wrote a temperature and spelled it 'boil'. 100 => boiling_point_at_sea_level_c 90 => boiling_point_at_three_thousand_metres_c 120 => boiling_point_in_a_pressure_cooker_c 10 => recipe_minutes_at_a_boil 10 => degrees_per_halving_of_cooking_speed boiling_point_at_sea_level_c - boiling_point_at_three_thousand_metres_c => degrees_lost_at_altitude int(degrees_lost_at_altitude / degrees_per_halving_of_cooking_speed) => halvings_of_speed_at_altitude 2^1 => slowdown_factor_at_altitude recipe_minutes_at_a_boil * slowdown_factor_at_altitude => minutes_needed_at_altitude minutes_needed_at_altitude - recipe_minutes_at_a_boil => minutes_the_recipe_fell_short int(recipe_minutes_at_a_boil * 10000 / minutes_needed_at_altitude) => share_of_the_cooking_the_recipe_delivered_per_myriad boiling_point_in_a_pressure_cooker_c - boiling_point_at_sea_level_c => degrees_gained_in_the_pressure_cooker int(degrees_gained_in_the_pressure_cooker / degrees_per_halving_of_cooking_speed) => doublings_of_speed_in_the_pressure_cooker 2^2 => speedup_factor_in_the_pressure_cooker int(recipe_minutes_at_a_boil * 10 / speedup_factor_in_the_pressure_cooker) => minutes_needed_in_the_pressure_cooker_tenths "recipe : boil for " + str(recipe_minutes_at_a_boil) + " minutes, written where water boils at " + str(boiling_point_at_sea_level_c) + " C" ^0 "at three thousand metres : water boils at " + str(boiling_point_at_three_thousand_metres_c) + " C, " + str(degrees_lost_at_altitude) + " degrees cooler" ^0 "cooking speed : halves per " + str(degrees_per_halving_of_cooking_speed) + " degrees lost; " + str(halvings_of_speed_at_altitude) + " halving here, " + str(slowdown_factor_at_altitude) + " times slower" ^0 "minutes needed at altitude : " + str(minutes_needed_at_altitude) + ", the recipe fell " + str(minutes_the_recipe_fell_short) + " short" ^0 "cooking the recipe delivered : " + str(share_of_the_cooking_the_recipe_delivered_per_myriad) + " per ten thousand of what it names" ^0 "" ^0 "pressure cooker : boils at " + str(boiling_point_in_a_pressure_cooker_c) + " C, " + str(degrees_gained_in_the_pressure_cooker) + " degrees hotter, " + str(doublings_of_speed_in_the_pressure_cooker) + " doublings, " + str(speedup_factor_in_the_pressure_cooker) + " times faster" ^0 "minutes needed under pressure : " + str(minutes_needed_in_the_pressure_cooker_tenths) + " tenths of a minute" ^0 "" ^0 # ---- what the cook verified ---- "the to-the-letter reasoning" ^0 " boiling : a rolling boil, genuinely" ^0 " time : " + str(recipe_minutes_at_a_boil) + " minutes, to the second" ^0 " recipe : followed exactly" ^0 " intent : cook it as long as the recipe says" ^0 " facts wrong : 0" ^0 " verdict : BOILED TEN MINUTES, AS WRITTEN" ^0 "" ^0 " bringing the water to a true boil and timing it exactly is" ^0 " the part done right here, and it is why every one of the" ^0 " recipe's words was obeyed" ^0 "" ^0 # ---- what boiling means at altitude ---- "a word standing in for a temperature" ^0 " what the recipe wanted : " + str(recipe_minutes_at_a_boil) + " minutes at " + str(boiling_point_at_sea_level_c) + " C" ^0 " what it wrote : 'boil', which at sea level is the same thing" ^0 " what boiling is : the temperature where water's vapour" ^0 " pressure meets the air's, and thinner air meets it sooner" ^0 " at altitude : a true boil at " + str(boiling_point_at_three_thousand_metres_c) + " C, " + str(degrees_lost_at_altitude) + " degrees short of" ^0 " what the word carried at sea level" ^0 " what " + str(degrees_lost_at_altitude) + " degrees do to cooking : roughly halve its speed, so" ^0 " the same food wants " + str(minutes_needed_at_altitude) + " minutes" ^0 " the same word the other way : a pressure cooker's boil is" ^0 " " + str(boiling_point_in_a_pressure_cooker_c) + " C, and " + str(recipe_minutes_at_a_boil) + " minutes there is " + str(speedup_factor_in_the_pressure_cooker) + " times too long" ^0 "" ^0 # ---- what the cook got ---- "the pot" ^0 " believed : cooked as the recipe intended" ^0 " actual : " + str(share_of_the_cooking_the_recipe_delivered_per_myriad) + " per ten thousand of the cooking, underdone" ^0 " was the water boiling : yes, at " + str(boiling_point_at_three_thousand_metres_c) + " C" ^0 " did 'boil' mean what the recipe meant : no; the recipe" ^0 " meant a temperature and wrote the name of an event that" ^0 " happens at that temperature only at sea level" ^0 "" ^0 # ---- null control ---- # The same recipe followed by temperature and time instead of by the word # 'boil' and time. 10 => nc_minutes_following_the_word 20 => nc_minutes_following_the_temperature 10 => nc_minutes_the_temperature_adds_back "null control - follow the temperature the word stood for" ^0 " minutes, following the word : " + str(nc_minutes_following_the_word) ^0 " minutes, following the temperature : " + str(nc_minutes_following_the_temperature) ^0 " minutes the temperature adds back : " + str(nc_minutes_the_temperature_adds_back) ^0 " no recipe and no pot changed; the instruction was read as" ^0 " the temperature it encoded" ^0 "" ^0 # ---- the rule ---- "what boiling for the written time guarantees" ^0 " the water was at its boiling point for " + str(recipe_minutes_at_a_boil) + " minutes : exactly" ^0 " the food received the recipe's cooking : not addressed; the" ^0 " boiling point here is " + str(boiling_point_at_three_thousand_metres_c) + " C, cooking halves per " + str(degrees_per_halving_of_cooking_speed) + " degrees, and" ^0 " " + str(recipe_minutes_at_a_boil) + " minutes at " + str(boiling_point_at_three_thousand_metres_c) + " is " + str(share_of_the_cooking_the_recipe_delivered_per_myriad) + " per ten thousand of " + str(recipe_minutes_at_a_boil) + " minutes at " + str(boiling_point_at_sea_level_c) ^0 "" ^0 "'boil' is a temperature wearing the name of an event, and the event moves" ^0 "with the air above the pot; follow the word and you follow the weather," ^0 "follow the temperature and you follow the cook who wrote it" ^0 "" ^0 "The water boiled and " + str(recipe_minutes_at_a_boil) + " minutes were timed - the recipe was obeyed. But 'boil'" ^0 "stands for " + str(boiling_point_at_sea_level_c) + " C, and at three thousand metres a true boil is " + str(boiling_point_at_three_thousand_metres_c) + ", so the food got" ^0 "" + str(share_of_the_cooking_the_recipe_delivered_per_myriad) + " per ten thousand of its cooking and needed " + str(minutes_needed_at_altitude) + " minutes, while a pressure cooker at" ^0 "" + str(boiling_point_in_a_pressure_cooker_c) + " needs " + str(minutes_needed_in_the_pressure_cooker_tenths) + " tenths of a minute, until the word is read as the temperature it encodes." ^0 ``` ## Python (deterministic transpilation) ```python boiling_point_at_sea_level_c = 100 boiling_point_at_three_thousand_metres_c = 90 boiling_point_in_a_pressure_cooker_c = 120 recipe_minutes_at_a_boil = 10 degrees_per_halving_of_cooking_speed = 10 degrees_lost_at_altitude = boiling_point_at_sea_level_c - boiling_point_at_three_thousand_metres_c halvings_of_speed_at_altitude = int(degrees_lost_at_altitude / degrees_per_halving_of_cooking_speed) slowdown_factor_at_altitude = 2**1 minutes_needed_at_altitude = recipe_minutes_at_a_boil * slowdown_factor_at_altitude minutes_the_recipe_fell_short = minutes_needed_at_altitude - recipe_minutes_at_a_boil share_of_the_cooking_the_recipe_delivered_per_myriad = int(recipe_minutes_at_a_boil * 10000 / minutes_needed_at_altitude) degrees_gained_in_the_pressure_cooker = boiling_point_in_a_pressure_cooker_c - boiling_point_at_sea_level_c doublings_of_speed_in_the_pressure_cooker = int(degrees_gained_in_the_pressure_cooker / degrees_per_halving_of_cooking_speed) speedup_factor_in_the_pressure_cooker = 2**2 minutes_needed_in_the_pressure_cooker_tenths = int(recipe_minutes_at_a_boil * 10 / speedup_factor_in_the_pressure_cooker) print("recipe : boil for " + str(recipe_minutes_at_a_boil) + " minutes, written where water boils at " + str(boiling_point_at_sea_level_c) + " C") print("at three thousand metres : water boils at " + str(boiling_point_at_three_thousand_metres_c) + " C, " + str(degrees_lost_at_altitude) + " degrees cooler") print("cooking speed : halves per " + str(degrees_per_halving_of_cooking_speed) + " degrees lost; " + str(halvings_of_speed_at_altitude) + " halving here, " + str(slowdown_factor_at_altitude) + " times slower") print("minutes needed at altitude : " + str(minutes_needed_at_altitude) + ", the recipe fell " + str(minutes_the_recipe_fell_short) + " short") print("cooking the recipe delivered : " + str(share_of_the_cooking_the_recipe_delivered_per_myriad) + " per ten thousand of what it names") print("") print("pressure cooker : boils at " + str(boiling_point_in_a_pressure_cooker_c) + " C, " + str(degrees_gained_in_the_pressure_cooker) + " degrees hotter, " + str(doublings_of_speed_in_the_pressure_cooker) + " doublings, " + str(speedup_factor_in_the_pressure_cooker) + " times faster") print("minutes needed under pressure : " + str(minutes_needed_in_the_pressure_cooker_tenths) + " tenths of a minute") print("") print("the to-the-letter reasoning") print(" boiling : a rolling boil, genuinely") print(" time : " + str(recipe_minutes_at_a_boil) + " minutes, to the second") print(" recipe : followed exactly") print(" intent : cook it as long as the recipe says") print(" facts wrong : 0") print(" verdict : BOILED TEN MINUTES, AS WRITTEN") print("") print(" bringing the water to a true boil and timing it exactly is") print(" the part done right here, and it is why every one of the") print(" recipe's words was obeyed") print("") print("a word standing in for a temperature") print(" what the recipe wanted : " + str(recipe_minutes_at_a_boil) + " minutes at " + str(boiling_point_at_sea_level_c) + " C") print(" what it wrote : 'boil', which at sea level is the same thing") print(" what boiling is : the temperature where water's vapour") print(" pressure meets the air's, and thinner air meets it sooner") print(" at altitude : a true boil at " + str(boiling_point_at_three_thousand_metres_c) + " C, " + str(degrees_lost_at_altitude) + " degrees short of") print(" what the word carried at sea level") print(" what " + str(degrees_lost_at_altitude) + " degrees do to cooking : roughly halve its speed, so") print(" the same food wants " + str(minutes_needed_at_altitude) + " minutes") print(" the same word the other way : a pressure cooker's boil is") print(" " + str(boiling_point_in_a_pressure_cooker_c) + " C, and " + str(recipe_minutes_at_a_boil) + " minutes there is " + str(speedup_factor_in_the_pressure_cooker) + " times too long") print("") print("the pot") print(" believed : cooked as the recipe intended") print(" actual : " + str(share_of_the_cooking_the_recipe_delivered_per_myriad) + " per ten thousand of the cooking, underdone") print(" was the water boiling : yes, at " + str(boiling_point_at_three_thousand_metres_c) + " C") print(" did 'boil' mean what the recipe meant : no; the recipe") print(" meant a temperature and wrote the name of an event that") print(" happens at that temperature only at sea level") print("") nc_minutes_following_the_word = 10 nc_minutes_following_the_temperature = 20 nc_minutes_the_temperature_adds_back = 10 print("null control - follow the temperature the word stood for") print(" minutes, following the word : " + str(nc_minutes_following_the_word)) print(" minutes, following the temperature : " + str(nc_minutes_following_the_temperature)) print(" minutes the temperature adds back : " + str(nc_minutes_the_temperature_adds_back)) print(" no recipe and no pot changed; the instruction was read as") print(" the temperature it encoded") print("") print("what boiling for the written time guarantees") print(" the water was at its boiling point for " + str(recipe_minutes_at_a_boil) + " minutes : exactly") print(" the food received the recipe's cooking : not addressed; the") print(" boiling point here is " + str(boiling_point_at_three_thousand_metres_c) + " C, cooking halves per " + str(degrees_per_halving_of_cooking_speed) + " degrees, and") print(" " + str(recipe_minutes_at_a_boil) + " minutes at " + str(boiling_point_at_three_thousand_metres_c) + " is " + str(share_of_the_cooking_the_recipe_delivered_per_myriad) + " per ten thousand of " + str(recipe_minutes_at_a_boil) + " minutes at " + str(boiling_point_at_sea_level_c)) print("") print("'boil' is a temperature wearing the name of an event, and the event moves") print("with the air above the pot; follow the word and you follow the weather,") print("follow the temperature and you follow the cook who wrote it") print("") print("The water boiled and " + str(recipe_minutes_at_a_boil) + " minutes were timed - the recipe was obeyed. But 'boil'") print("stands for " + str(boiling_point_at_sea_level_c) + " C, and at three thousand metres a true boil is " + str(boiling_point_at_three_thousand_metres_c) + ", so the food got") print("" + str(share_of_the_cooking_the_recipe_delivered_per_myriad) + " per ten thousand of its cooking and needed " + str(minutes_needed_at_altitude) + " minutes, while a pressure cooker at") print("" + str(boiling_point_in_a_pressure_cooker_c) + " needs " + str(minutes_needed_in_the_pressure_cooker_tenths) + " tenths of a minute, until the word is read as the temperature it encodes.") ``` ## stdout (executed) ```text recipe : boil for 10 minutes, written where water boils at 100 C at three thousand metres : water boils at 90 C, 10 degrees cooler cooking speed : halves per 10 degrees lost; 1 halving here, 2 times slower minutes needed at altitude : 20, the recipe fell 10 short cooking the recipe delivered : 5000 per ten thousand of what it names pressure cooker : boils at 120 C, 20 degrees hotter, 2 doublings, 4 times faster minutes needed under pressure : 25 tenths of a minute the to-the-letter reasoning boiling : a rolling boil, genuinely time : 10 minutes, to the second recipe : followed exactly intent : cook it as long as the recipe says facts wrong : 0 verdict : BOILED TEN MINUTES, AS WRITTEN bringing the water to a true boil and timing it exactly is the part done right here, and it is why every one of the recipe's words was obeyed a word standing in for a temperature what the recipe wanted : 10 minutes at 100 C what it wrote : 'boil', which at sea level is the same thing what boiling is : the temperature where water's vapour pressure meets the air's, and thinner air meets it sooner at altitude : a true boil at 90 C, 10 degrees short of what the word carried at sea level what 10 degrees do to cooking : roughly halve its speed, so the same food wants 20 minutes the same word the other way : a pressure cooker's boil is 120 C, and 10 minutes there is 4 times too long the pot believed : cooked as the recipe intended actual : 5000 per ten thousand of the cooking, underdone was the water boiling : yes, at 90 C did 'boil' mean what the recipe meant : no; the recipe meant a temperature and wrote the name of an event that happens at that temperature only at sea level null control - follow the temperature the word stood for minutes, following the word : 10 minutes, following the temperature : 20 minutes the temperature adds back : 10 no recipe and no pot changed; the instruction was read as the temperature it encoded what boiling for the written time guarantees the water was at its boiling point for 10 minutes : exactly the food received the recipe's cooking : not addressed; the boiling point here is 90 C, cooking halves per 10 degrees, and 10 minutes at 90 is 5000 per ten thousand of 10 minutes at 100 'boil' is a temperature wearing the name of an event, and the event moves with the air above the pot; follow the word and you follow the weather, follow the temperature and you follow the cook who wrote it The water boiled and 10 minutes were timed - the recipe was obeyed. But 'boil' stands for 100 C, and at three thousand metres a true boil is 90, so the food got 5000 per ten thousand of its cooking and needed 20 minutes, while a pressure cooker at 120 needs 25 tenths of a minute, until the word is read as the temperature it encodes. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done