# Example 925 — The tank was twice as big and the legs were not `the_tank_was_twice_as_big_and_the_legs_were_not.eml` - A water tank that works is rebuilt at twice the size - every dimension doubled, the same design, the same materials, the same four legs scaled with it - and the legs buckle. How the weight and the legs scale with the size is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). A water tank that # works is rebuilt at twice the size - every dimension doubled, the same # design, the same materials, the same four legs scaled with it - and the legs # buckle. How the weight and the legs scale with the size is computed below. # # The scale-up is careful. Every dimension is exactly doubled; the design is # the proven one; the materials are the same grade; the legs are doubled in # every dimension like everything else; and the intent is exactly 'the same # tank, bigger'. # # Doubling every dimension multiplies the water by eight and the cross-section # of a leg by four, so each leg carries twice the stress it was proven at - the # shape is the same and the loads are not. 2 => scale_factor 1000 => water_weight_at_scale_one 100 => leg_cross_section_at_scale_one 4 => legs scale_factor * scale_factor * scale_factor => volume_multiplier scale_factor * scale_factor => area_multiplier water_weight_at_scale_one * volume_multiplier => water_weight_at_scale_two leg_cross_section_at_scale_one * area_multiplier => leg_cross_section_at_scale_two int(water_weight_at_scale_one * 10 / (legs * leg_cross_section_at_scale_one)) => stress_per_unit_area_at_scale_one_tenths int(water_weight_at_scale_two * 10 / (legs * leg_cross_section_at_scale_two)) => stress_per_unit_area_at_scale_two_tenths int(stress_per_unit_area_at_scale_two_tenths * 10000 / stress_per_unit_area_at_scale_one_tenths) => stress_relative_to_proven_per_myriad "scale factor : " + str(scale_factor) + " in every dimension" ^0 "water weight, original : " + str(water_weight_at_scale_one) ^0 "leg cross-section, original : " + str(leg_cross_section_at_scale_one) + " each, " + str(legs) + " legs" ^0 "" ^0 "volume multiplies by : " + str(volume_multiplier) ^0 "area multiplies by : " + str(area_multiplier) ^0 "water weight, doubled tank : " + str(water_weight_at_scale_two) ^0 "leg cross-section, doubled tank : " + str(leg_cross_section_at_scale_two) + " each" ^0 "stress on a leg, original : " + str(stress_per_unit_area_at_scale_one_tenths) + " tenths per unit area" ^0 "stress on a leg, doubled : " + str(stress_per_unit_area_at_scale_two_tenths) + " tenths per unit area" ^0 "stress relative to the proven : " + str(stress_relative_to_proven_per_myriad) + " per ten thousand" ^0 "" ^0 # ---- what the scale-up verified ---- "the doubled tank" ^0 " dimensions : every one exactly doubled" ^0 " design : the proven one" ^0 " materials : the same grade" ^0 " legs : doubled in every dimension too" ^0 " intent : the same tank, bigger" ^0 " dimensions left unscaled : 0" ^0 " verdict : GEOMETRICALLY IDENTICAL AT TWICE THE SIZE" ^0 "" ^0 " scaling every dimension exactly is the part done right" ^0 " here, and it is why the doubled tank is the same shape" ^0 " to the last proportion" ^0 "" ^0 # ---- how weight and legs scale ---- "the square and the cube" ^0 " what the water fills : a volume, which goes as the cube" ^0 " what a leg resists with : a cross-section, which goes as" ^0 " the square" ^0 " doubled : " + str(volume_multiplier) + " times the water on " + str(area_multiplier) + " times the leg" ^0 " so each unit of leg : carries " + str(scale_factor) + " times what it was proven at" ^0 " the shape is the same : the ratio of load to strength is" ^0 " not, and cannot be, under uniform scaling" ^0 "" ^0 # ---- what the builders got ---- "the doubled tank, filled" ^0 " stress on the legs : " + str(stress_relative_to_proven_per_myriad) + " per ten thousand of the proven" ^0 " is any dimension wrong : no" ^0 " is the same shape the same safety : no; safety is a" ^0 " ratio of a cube to a square, and doubling moves it" ^0 "" ^0 # ---- null control ---- # The same scale-up with the legs sized to the load rather than to the shape: # cross-section scaled with the cube, not the square. 20000 => nc_stress_per_myriad_legs_scaled_with_shape 10000 => nc_stress_per_myriad_legs_scaled_with_load 1 => nc_legs_hold_when_sized_to_the_load "null control - size the legs to the load, not the shape" ^0 " stress, legs scaled with the shape : " + str(nc_stress_per_myriad_legs_scaled_with_shape) + " per ten thousand" ^0 " stress, legs scaled with the load : " + str(nc_stress_per_myriad_legs_scaled_with_load) + " per ten thousand" ^0 " legs hold when sized to the load : " + str(nc_legs_hold_when_sized_to_the_load) ^0 " no material and no design changed; the legs stopped being" ^0 " scaled by the rule that scales the water" ^0 "" ^0 # ---- the rule ---- "what an exact uniform scale-up guarantees" ^0 " the bigger tank is the same shape in every proportion :" ^0 " exactly, every dimension doubled" ^0 " the bigger tank is as safe : not addressed; the water" ^0 " grows as the cube and a leg's strength as the square, so" ^0 " each leg carries " + str(stress_relative_to_proven_per_myriad) + " per ten thousand of the proven stress" ^0 "" ^0 "a shape can be kept and a ratio cannot when the ratio is between two powers" ^0 "of the size; what fills goes as the cube and what holds goes as the square," ^0 "and every doubling asks the legs for twice what the proof gave them" ^0 "" ^0 "Every dimension is exactly doubled - the tank is the proven shape to the last" ^0 "proportion. But the water grows " + str(volume_multiplier) + "-fold and each leg's cross-section " + str(area_multiplier) + "-fold, so" ^0 "a leg carries " + str(stress_relative_to_proven_per_myriad) + " per ten thousand of the stress it was proven at, until the" ^0 "legs are sized to the load and not to the shape." ^0 ``` ## Python (deterministic transpilation) ```python scale_factor = 2 water_weight_at_scale_one = 1000 leg_cross_section_at_scale_one = 100 legs = 4 volume_multiplier = scale_factor * scale_factor * scale_factor area_multiplier = scale_factor * scale_factor water_weight_at_scale_two = water_weight_at_scale_one * volume_multiplier leg_cross_section_at_scale_two = leg_cross_section_at_scale_one * area_multiplier stress_per_unit_area_at_scale_one_tenths = int(water_weight_at_scale_one * 10 / (legs * leg_cross_section_at_scale_one)) stress_per_unit_area_at_scale_two_tenths = int(water_weight_at_scale_two * 10 / (legs * leg_cross_section_at_scale_two)) stress_relative_to_proven_per_myriad = int(stress_per_unit_area_at_scale_two_tenths * 10000 / stress_per_unit_area_at_scale_one_tenths) print("scale factor : " + str(scale_factor) + " in every dimension") print("water weight, original : " + str(water_weight_at_scale_one)) print("leg cross-section, original : " + str(leg_cross_section_at_scale_one) + " each, " + str(legs) + " legs") print("") print("volume multiplies by : " + str(volume_multiplier)) print("area multiplies by : " + str(area_multiplier)) print("water weight, doubled tank : " + str(water_weight_at_scale_two)) print("leg cross-section, doubled tank : " + str(leg_cross_section_at_scale_two) + " each") print("stress on a leg, original : " + str(stress_per_unit_area_at_scale_one_tenths) + " tenths per unit area") print("stress on a leg, doubled : " + str(stress_per_unit_area_at_scale_two_tenths) + " tenths per unit area") print("stress relative to the proven : " + str(stress_relative_to_proven_per_myriad) + " per ten thousand") print("") print("the doubled tank") print(" dimensions : every one exactly doubled") print(" design : the proven one") print(" materials : the same grade") print(" legs : doubled in every dimension too") print(" intent : the same tank, bigger") print(" dimensions left unscaled : 0") print(" verdict : GEOMETRICALLY IDENTICAL AT TWICE THE SIZE") print("") print(" scaling every dimension exactly is the part done right") print(" here, and it is why the doubled tank is the same shape") print(" to the last proportion") print("") print("the square and the cube") print(" what the water fills : a volume, which goes as the cube") print(" what a leg resists with : a cross-section, which goes as") print(" the square") print(" doubled : " + str(volume_multiplier) + " times the water on " + str(area_multiplier) + " times the leg") print(" so each unit of leg : carries " + str(scale_factor) + " times what it was proven at") print(" the shape is the same : the ratio of load to strength is") print(" not, and cannot be, under uniform scaling") print("") print("the doubled tank, filled") print(" stress on the legs : " + str(stress_relative_to_proven_per_myriad) + " per ten thousand of the proven") print(" is any dimension wrong : no") print(" is the same shape the same safety : no; safety is a") print(" ratio of a cube to a square, and doubling moves it") print("") nc_stress_per_myriad_legs_scaled_with_shape = 20000 nc_stress_per_myriad_legs_scaled_with_load = 10000 nc_legs_hold_when_sized_to_the_load = 1 print("null control - size the legs to the load, not the shape") print(" stress, legs scaled with the shape : " + str(nc_stress_per_myriad_legs_scaled_with_shape) + " per ten thousand") print(" stress, legs scaled with the load : " + str(nc_stress_per_myriad_legs_scaled_with_load) + " per ten thousand") print(" legs hold when sized to the load : " + str(nc_legs_hold_when_sized_to_the_load)) print(" no material and no design changed; the legs stopped being") print(" scaled by the rule that scales the water") print("") print("what an exact uniform scale-up guarantees") print(" the bigger tank is the same shape in every proportion :") print(" exactly, every dimension doubled") print(" the bigger tank is as safe : not addressed; the water") print(" grows as the cube and a leg's strength as the square, so") print(" each leg carries " + str(stress_relative_to_proven_per_myriad) + " per ten thousand of the proven stress") print("") print("a shape can be kept and a ratio cannot when the ratio is between two powers") print("of the size; what fills goes as the cube and what holds goes as the square,") print("and every doubling asks the legs for twice what the proof gave them") print("") print("Every dimension is exactly doubled - the tank is the proven shape to the last") print("proportion. But the water grows " + str(volume_multiplier) + "-fold and each leg's cross-section " + str(area_multiplier) + "-fold, so") print("a leg carries " + str(stress_relative_to_proven_per_myriad) + " per ten thousand of the stress it was proven at, until the") print("legs are sized to the load and not to the shape.") ``` ## stdout (executed) ```text scale factor : 2 in every dimension water weight, original : 1000 leg cross-section, original : 100 each, 4 legs volume multiplies by : 8 area multiplies by : 4 water weight, doubled tank : 8000 leg cross-section, doubled tank : 400 each stress on a leg, original : 25 tenths per unit area stress on a leg, doubled : 50 tenths per unit area stress relative to the proven : 20000 per ten thousand the doubled tank dimensions : every one exactly doubled design : the proven one materials : the same grade legs : doubled in every dimension too intent : the same tank, bigger dimensions left unscaled : 0 verdict : GEOMETRICALLY IDENTICAL AT TWICE THE SIZE scaling every dimension exactly is the part done right here, and it is why the doubled tank is the same shape to the last proportion the square and the cube what the water fills : a volume, which goes as the cube what a leg resists with : a cross-section, which goes as the square doubled : 8 times the water on 4 times the leg so each unit of leg : carries 2 times what it was proven at the shape is the same : the ratio of load to strength is not, and cannot be, under uniform scaling the doubled tank, filled stress on the legs : 20000 per ten thousand of the proven is any dimension wrong : no is the same shape the same safety : no; safety is a ratio of a cube to a square, and doubling moves it null control - size the legs to the load, not the shape stress, legs scaled with the shape : 20000 per ten thousand stress, legs scaled with the load : 10000 per ten thousand legs hold when sized to the load : 1 no material and no design changed; the legs stopped being scaled by the rule that scales the water what an exact uniform scale-up guarantees the bigger tank is the same shape in every proportion : exactly, every dimension doubled the bigger tank is as safe : not addressed; the water grows as the cube and a leg's strength as the square, so each leg carries 20000 per ten thousand of the proven stress a shape can be kept and a ratio cannot when the ratio is between two powers of the size; what fills goes as the cube and what holds goes as the square, and every doubling asks the legs for twice what the proof gave them Every dimension is exactly doubled - the tank is the proven shape to the last proportion. But the water grows 8-fold and each leg's cross-section 4-fold, so a leg carries 20000 per ten thousand of the stress it was proven at, until the legs are sized to the load and not to the shape. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done