# Example 961 — The ice at zero did four times the work of water at zero `the_ice_at_zero_did_four_times_the_work_of_water_at_zero.eml` - A host chilling drinks has ice at zero degrees and iced water at zero degrees, reasons that two things at the same temperature cool the same, pours the water in to avoid dilution, and the drinks stay warm. What a hundred grams at zero can absorb, as ice and as water, is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). A host chilling # drinks has ice at zero degrees and iced water at zero degrees, reasons that # two things at the same temperature cool the same, pours the water in to # avoid dilution, and the drinks stay warm. What a hundred grams at zero can # absorb, as ice and as water, is computed below. # # The reasoning is careful. Both are at exactly zero; a thermometer cannot tell # them apart; cooling flows from cold to warm; and the intent was exactly 'cool # the drink as much as the cold thing can'. # # Melting absorbs heat without any change of temperature, 334 joules per gram, # while warming water absorbs 4.2 joules per gram per degree - so a hundred # grams of ice takes 33400 joules just to become water at zero and then warms # like water, five times what the same hundred grams of zero-degree water can # take on its way to twenty. 100 => cooler_mass_g 334 => latent_heat_of_melting_j_per_g 42 => specific_heat_of_water_tenths_of_a_j_per_g_k 20 => drink_start_c 500 => drink_mass_g int(cooler_mass_g * specific_heat_of_water_tenths_of_a_j_per_g_k * drink_start_c / 10) => water_at_zero_can_absorb_warming_to_twenty_j cooler_mass_g * latent_heat_of_melting_j_per_g => ice_absorbs_while_melting_j ice_absorbs_while_melting_j + water_at_zero_can_absorb_warming_to_twenty_j => ice_can_absorb_in_all_to_twenty_j int(ice_can_absorb_in_all_to_twenty_j * 100 / water_at_zero_can_absorb_warming_to_twenty_j) => ice_over_water_per_hundred int(ice_absorbs_while_melting_j * 100 / water_at_zero_can_absorb_warming_to_twenty_j) => melting_alone_over_water_per_hundred int(drink_mass_g * specific_heat_of_water_tenths_of_a_j_per_g_k / 10) => drink_heat_capacity_j_per_k int(cooler_mass_g * specific_heat_of_water_tenths_of_a_j_per_g_k / 10) => cooler_heat_capacity_j_per_k int(drink_heat_capacity_j_per_k * drink_start_c * 10 / (drink_heat_capacity_j_per_k + cooler_heat_capacity_j_per_k)) => final_temperature_with_water_tenths_c int((drink_heat_capacity_j_per_k * drink_start_c - ice_absorbs_while_melting_j) * 10 / (drink_heat_capacity_j_per_k + cooler_heat_capacity_j_per_k)) => final_temperature_with_ice_tenths_c final_temperature_with_water_tenths_c - final_temperature_with_ice_tenths_c => extra_cooling_from_the_ice_tenths_c drink_start_c * 10 - final_temperature_with_water_tenths_c => cooling_from_the_water_tenths_c drink_start_c * 10 - final_temperature_with_ice_tenths_c => cooling_from_the_ice_tenths_c "cooler : " + str(cooler_mass_g) + " g at 0 C, as water or as ice" ^0 "drink : " + str(drink_mass_g) + " g at " + str(drink_start_c) + " C" ^0 "" ^0 "water at zero can absorb : " + str(water_at_zero_can_absorb_warming_to_twenty_j) + " J warming to " + str(drink_start_c) + " C" ^0 "ice absorbs while melting : " + str(ice_absorbs_while_melting_j) + " J, at zero the whole time" ^0 "ice can absorb in all : " + str(ice_can_absorb_in_all_to_twenty_j) + " J to " + str(drink_start_c) + " C" ^0 "ice over water : " + str(ice_over_water_per_hundred) + " per hundred; the melting alone is " + str(melting_alone_over_water_per_hundred) ^0 "" ^0 "drink with the water : ends at " + str(final_temperature_with_water_tenths_c) + " tenths of a degree, cooled " + str(cooling_from_the_water_tenths_c) + " tenths" ^0 "drink with the ice : ends at " + str(final_temperature_with_ice_tenths_c) + " tenths of a degree, cooled " + str(cooling_from_the_ice_tenths_c) + " tenths" ^0 "extra cooling from the ice : " + str(extra_cooling_from_the_ice_tenths_c) + " tenths of a degree" ^0 "" ^0 # ---- what the host verified ---- "the same-temperature reasoning" ^0 " ice : 0 C" ^0 " water : 0 C" ^0 " thermometer : cannot tell them apart" ^0 " intent : cool the drink as much as the cold thing can" ^0 " facts wrong : 0" ^0 " verdict : SAME TEMPERATURE, SAME COOLING" ^0 "" ^0 " checking both at exactly zero is the part done right here," ^0 " and it is why the first joule of heat flows into each of" ^0 " them at exactly the same rate" ^0 "" ^0 # ---- what a hundred grams at zero can absorb ---- "temperature is not capacity" ^0 " what temperature says : which way heat flows, and how fast" ^0 " what it does not say : how much heat a thing can take" ^0 " water at zero : takes " + str(specific_heat_of_water_tenths_of_a_j_per_g_k) + " tenths of a joule per gram per degree, and" ^0 " is at the drink's temperature after " + str(water_at_zero_can_absorb_warming_to_twenty_j) + " J" ^0 " ice at zero : takes " + str(latent_heat_of_melting_j_per_g) + " J per gram to melt, staying at zero," ^0 " " + str(ice_absorbs_while_melting_j) + " J before it even starts to warm" ^0 " the same reading, " + str(ice_over_water_per_hundred) + " per hundred of the work : because a change" ^0 " of state absorbs heat that a thermometer never sees" ^0 "" ^0 # ---- what the host got ---- "the drinks" ^0 " believed : cooled as much as ice would, with no dilution" ^0 " actual : " + str(cooling_from_the_water_tenths_c) + " tenths of a degree cooler, where ice gives " + str(cooling_from_the_ice_tenths_c) ^0 " is the thermometer wrong : no; both really are at zero" ^0 " is temperature the measure of cooling power : no; the" ^0 " melting is where the ice does its work, at zero, unseen" ^0 "" ^0 # ---- null control ---- # The same choice made on heat absorbed instead of on temperature read. 8400 => nc_cooling_power_read_from_temperature_j 41800 => nc_cooling_power_read_from_heat_absorbed_j 33400 => nc_joules_the_change_of_state_hides "null control - measure what each can absorb" ^0 " cooling power, read from temperature : " + str(nc_cooling_power_read_from_temperature_j) + " J, the same for both" ^0 " cooling power, read from heat absorbed : " + str(nc_cooling_power_read_from_heat_absorbed_j) + " J for the ice" ^0 " joules the change of state hides : " + str(nc_joules_the_change_of_state_hides) ^0 " no ice and no drink changed; the capacity was measured" ^0 " instead of the temperature" ^0 "" ^0 # ---- the rule ---- "what two things at the same temperature guarantee" ^0 " heat flows into each at the same rate at first : exactly" ^0 " each can absorb the same amount : not addressed; ice absorbs" ^0 " " + str(ice_absorbs_while_melting_j) + " J in melting with no change of temperature, so " + str(cooler_mass_g) + " g of" ^0 " ice at zero takes " + str(ice_over_water_per_hundred) + " per hundred of what " + str(cooler_mass_g) + " g of water at zero can" ^0 "" ^0 "a thermometer reads the doorway and not the room; ice and water at zero" ^0 "stand at the same door, and one of them has a hall behind it that swallows" ^0 "heat without moving the needle" ^0 "" ^0 "Both are at zero - the thermometer is right. But temperature is direction," ^0 "not capacity: melting takes " + str(ice_absorbs_while_melting_j) + " J with no change of reading, so the ice can" ^0 "absorb " + str(ice_can_absorb_in_all_to_twenty_j) + " J against the water's " + str(water_at_zero_can_absorb_warming_to_twenty_j) + ", cooling the drink " + str(cooling_from_the_ice_tenths_c) + " tenths of a degree" ^0 "where the water manages " + str(cooling_from_the_water_tenths_c) + ", until the cold thing is measured by what it can absorb." ^0 ``` ## Python (deterministic transpilation) ```python cooler_mass_g = 100 latent_heat_of_melting_j_per_g = 334 specific_heat_of_water_tenths_of_a_j_per_g_k = 42 drink_start_c = 20 drink_mass_g = 500 water_at_zero_can_absorb_warming_to_twenty_j = int(cooler_mass_g * specific_heat_of_water_tenths_of_a_j_per_g_k * drink_start_c / 10) ice_absorbs_while_melting_j = cooler_mass_g * latent_heat_of_melting_j_per_g ice_can_absorb_in_all_to_twenty_j = ice_absorbs_while_melting_j + water_at_zero_can_absorb_warming_to_twenty_j ice_over_water_per_hundred = int(ice_can_absorb_in_all_to_twenty_j * 100 / water_at_zero_can_absorb_warming_to_twenty_j) melting_alone_over_water_per_hundred = int(ice_absorbs_while_melting_j * 100 / water_at_zero_can_absorb_warming_to_twenty_j) drink_heat_capacity_j_per_k = int(drink_mass_g * specific_heat_of_water_tenths_of_a_j_per_g_k / 10) cooler_heat_capacity_j_per_k = int(cooler_mass_g * specific_heat_of_water_tenths_of_a_j_per_g_k / 10) final_temperature_with_water_tenths_c = int(drink_heat_capacity_j_per_k * drink_start_c * 10 / (drink_heat_capacity_j_per_k + cooler_heat_capacity_j_per_k)) final_temperature_with_ice_tenths_c = int((drink_heat_capacity_j_per_k * drink_start_c - ice_absorbs_while_melting_j) * 10 / (drink_heat_capacity_j_per_k + cooler_heat_capacity_j_per_k)) extra_cooling_from_the_ice_tenths_c = final_temperature_with_water_tenths_c - final_temperature_with_ice_tenths_c cooling_from_the_water_tenths_c = drink_start_c * 10 - final_temperature_with_water_tenths_c cooling_from_the_ice_tenths_c = drink_start_c * 10 - final_temperature_with_ice_tenths_c print("cooler : " + str(cooler_mass_g) + " g at 0 C, as water or as ice") print("drink : " + str(drink_mass_g) + " g at " + str(drink_start_c) + " C") print("") print("water at zero can absorb : " + str(water_at_zero_can_absorb_warming_to_twenty_j) + " J warming to " + str(drink_start_c) + " C") print("ice absorbs while melting : " + str(ice_absorbs_while_melting_j) + " J, at zero the whole time") print("ice can absorb in all : " + str(ice_can_absorb_in_all_to_twenty_j) + " J to " + str(drink_start_c) + " C") print("ice over water : " + str(ice_over_water_per_hundred) + " per hundred; the melting alone is " + str(melting_alone_over_water_per_hundred)) print("") print("drink with the water : ends at " + str(final_temperature_with_water_tenths_c) + " tenths of a degree, cooled " + str(cooling_from_the_water_tenths_c) + " tenths") print("drink with the ice : ends at " + str(final_temperature_with_ice_tenths_c) + " tenths of a degree, cooled " + str(cooling_from_the_ice_tenths_c) + " tenths") print("extra cooling from the ice : " + str(extra_cooling_from_the_ice_tenths_c) + " tenths of a degree") print("") print("the same-temperature reasoning") print(" ice : 0 C") print(" water : 0 C") print(" thermometer : cannot tell them apart") print(" intent : cool the drink as much as the cold thing can") print(" facts wrong : 0") print(" verdict : SAME TEMPERATURE, SAME COOLING") print("") print(" checking both at exactly zero is the part done right here,") print(" and it is why the first joule of heat flows into each of") print(" them at exactly the same rate") print("") print("temperature is not capacity") print(" what temperature says : which way heat flows, and how fast") print(" what it does not say : how much heat a thing can take") print(" water at zero : takes " + str(specific_heat_of_water_tenths_of_a_j_per_g_k) + " tenths of a joule per gram per degree, and") print(" is at the drink's temperature after " + str(water_at_zero_can_absorb_warming_to_twenty_j) + " J") print(" ice at zero : takes " + str(latent_heat_of_melting_j_per_g) + " J per gram to melt, staying at zero,") print(" " + str(ice_absorbs_while_melting_j) + " J before it even starts to warm") print(" the same reading, " + str(ice_over_water_per_hundred) + " per hundred of the work : because a change") print(" of state absorbs heat that a thermometer never sees") print("") print("the drinks") print(" believed : cooled as much as ice would, with no dilution") print(" actual : " + str(cooling_from_the_water_tenths_c) + " tenths of a degree cooler, where ice gives " + str(cooling_from_the_ice_tenths_c)) print(" is the thermometer wrong : no; both really are at zero") print(" is temperature the measure of cooling power : no; the") print(" melting is where the ice does its work, at zero, unseen") print("") nc_cooling_power_read_from_temperature_j = 8400 nc_cooling_power_read_from_heat_absorbed_j = 41800 nc_joules_the_change_of_state_hides = 33400 print("null control - measure what each can absorb") print(" cooling power, read from temperature : " + str(nc_cooling_power_read_from_temperature_j) + " J, the same for both") print(" cooling power, read from heat absorbed : " + str(nc_cooling_power_read_from_heat_absorbed_j) + " J for the ice") print(" joules the change of state hides : " + str(nc_joules_the_change_of_state_hides)) print(" no ice and no drink changed; the capacity was measured") print(" instead of the temperature") print("") print("what two things at the same temperature guarantee") print(" heat flows into each at the same rate at first : exactly") print(" each can absorb the same amount : not addressed; ice absorbs") print(" " + str(ice_absorbs_while_melting_j) + " J in melting with no change of temperature, so " + str(cooler_mass_g) + " g of") print(" ice at zero takes " + str(ice_over_water_per_hundred) + " per hundred of what " + str(cooler_mass_g) + " g of water at zero can") print("") print("a thermometer reads the doorway and not the room; ice and water at zero") print("stand at the same door, and one of them has a hall behind it that swallows") print("heat without moving the needle") print("") print("Both are at zero - the thermometer is right. But temperature is direction,") print("not capacity: melting takes " + str(ice_absorbs_while_melting_j) + " J with no change of reading, so the ice can") print("absorb " + str(ice_can_absorb_in_all_to_twenty_j) + " J against the water's " + str(water_at_zero_can_absorb_warming_to_twenty_j) + ", cooling the drink " + str(cooling_from_the_ice_tenths_c) + " tenths of a degree") print("where the water manages " + str(cooling_from_the_water_tenths_c) + ", until the cold thing is measured by what it can absorb.") ``` ## stdout (executed) ```text cooler : 100 g at 0 C, as water or as ice drink : 500 g at 20 C water at zero can absorb : 8400 J warming to 20 C ice absorbs while melting : 33400 J, at zero the whole time ice can absorb in all : 41800 J to 20 C ice over water : 497 per hundred; the melting alone is 397 drink with the water : ends at 166 tenths of a degree, cooled 34 tenths drink with the ice : ends at 34 tenths of a degree, cooled 166 tenths extra cooling from the ice : 132 tenths of a degree the same-temperature reasoning ice : 0 C water : 0 C thermometer : cannot tell them apart intent : cool the drink as much as the cold thing can facts wrong : 0 verdict : SAME TEMPERATURE, SAME COOLING checking both at exactly zero is the part done right here, and it is why the first joule of heat flows into each of them at exactly the same rate temperature is not capacity what temperature says : which way heat flows, and how fast what it does not say : how much heat a thing can take water at zero : takes 42 tenths of a joule per gram per degree, and is at the drink's temperature after 8400 J ice at zero : takes 334 J per gram to melt, staying at zero, 33400 J before it even starts to warm the same reading, 497 per hundred of the work : because a change of state absorbs heat that a thermometer never sees the drinks believed : cooled as much as ice would, with no dilution actual : 34 tenths of a degree cooler, where ice gives 166 is the thermometer wrong : no; both really are at zero is temperature the measure of cooling power : no; the melting is where the ice does its work, at zero, unseen null control - measure what each can absorb cooling power, read from temperature : 8400 J, the same for both cooling power, read from heat absorbed : 41800 J for the ice joules the change of state hides : 33400 no ice and no drink changed; the capacity was measured instead of the temperature what two things at the same temperature guarantee heat flows into each at the same rate at first : exactly each can absorb the same amount : not addressed; ice absorbs 33400 J in melting with no change of temperature, so 100 g of ice at zero takes 497 per hundred of what 100 g of water at zero can a thermometer reads the doorway and not the room; ice and water at zero stand at the same door, and one of them has a hall behind it that swallows heat without moving the needle Both are at zero - the thermometer is right. But temperature is direction, not capacity: melting takes 33400 J with no change of reading, so the ice can absorb 41800 J against the water's 8400, cooling the drink 166 tenths of a degree where the water manages 34, until the cold thing is measured by what it can absorb. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done