A database writes a page to an SSD. The SSD, because of flash physics, cannot overwrite in place — it copies the page to a new location and invalidates the old one. The database doesn't know this. It wrote the page as if the medium stored it where it was told. The result: every write happens twice. Lee, Ziegler, and Leis (arXiv:2603.09927) show that aligning the database's write pattern with what the storage actually does — out-of-place writes — increases throughput by 1.65–2.24x and reduces flash writes per transaction by 6–10x. The entire penalty came from the mismatch between the model and the physics.
A monostatic radar transmits a signal and receives its own reflection. The transmitter's hardware distorts the signal, and the standard model (the kappa model) treats that distortion as unknown noise. But the transmitter observed its own distorted waveform — the distortion is known. Dong and Akan (arXiv:2603.10958) derive the actual performance limits and find that the kappa model overestimates sensing degradation, while simultaneously missing an irreducible velocity-error floor from phase noise that only appears in the correct analysis.
Two systems. One writes data and one reads radar. Both pay a performance penalty not from what they don't know, but from what they do know and ignore. The database knows how it structured its writes; it doesn't know the medium rearranges them. The radar knows what distortion it introduced; it doesn't know it knows. In both cases, the model assumes ignorance that the system doesn't actually have, and the cost is not a small overhead but a factor-of-two degradation.
The structural claim: when a system models a known quantity as unknown, the penalty is not the cost of the unknown — it is the cost of pretending. The database pays for a copy it didn't need. The radar pays for uncertainty it doesn't have. And the fix in both cases is not better hardware or more computation but a more honest model — one that acknowledges what the system already knows about itself.