The Condition Is the Claim

A one-time pad is unbreakable, provided it is true.

That second half looks harmless. It is not. It carries the claim.

A true one-time pad is not a grand name for strong encryption. It is a very specific object with very specific conditions attached: the pad is genuinely random; it is at least as long as the message; it is used once; it stays secret; it is not copied, logged, inferred, generated from a seed, reused by accident, or betrayed by the machine or person handling it. The word true is doing work here. It is not decoration.

Miss any of that and the proof has not been weakened. It has gone.

That is why the one-time pad is such a useful starting point. The ideal claim is clean. Properly made, the ciphertext does not contain enough information to recover the plaintext. It is not merely hard to break. It is not waiting for more compute, better algebra, or a quantum computer with sharper teeth. Every possible message of the same length remains possible. There is no hidden pattern for the attacker to uncover, because the pad has removed the relationship the attacker would need.

But that belongs to the true object.

It does not automatically belong to a file called pad.txt. It does not belong to a pseudo-random stream because somebody liked the length of it. It does not belong to a hardware generator because the box had a serious-looking data sheet. It does not belong to a process diagram in which all the arrows were tidy and all the difficult human behaviour was quietly abstracted away. It does not belong to a ceremony unless the ceremony protects the actual conditions.

The word does not do the work. The conditions do.

This is not pedantry. Pedantry is arguing about labels when nothing depends on them. Here, everything depends on the label being earned. If the pad is true, the claim is absolute. If the pad is not true, we have changed subject. We may still have a useful system. We may have something defensible, practical, even very strong. But we do not get to borrow the proof from the thing we failed to instantiate.

That is the hinge of the whole essay.

A claim can be perfectly valid inside its assumptions and still be abused in the real world. The abuse begins when the clean word is carried across from the model to the implementation as if the proof travelled with it for free.

It does not.

Provided it is true is not a caveat. It is the whole load-bearing structure. It is where the clean world of definitions meets the grubby world of machines, people, incentives and mistakes. It is also where a useful technical conversation either stays honest or turns into a costume party for impressive nouns.

The Ideal Claims Are Not Bullshit

The ideal claims themselves are not the enemy.

A true one-time pad really is unbreakable in the sense that matters. That is not marketing drivel and it is not hand-waving (to quote a robot friend of mine). It is one of the cleanest claims in cryptography, because the object has been defined cleanly: random, secret, single-use, as long as the message, independent of the plaintext. Inside those assumptions, the proof stands. The right response to that is not cynicism. The right response is to know exactly where the proof begins and where it stops.

Quantum computing also has real claims behind it. The word quantum is not magic, but neither is it empty. A properly specified quantum algorithm, running on an ideal or sufficiently fault-tolerant machine, can exploit structure that a classical approach may struggle with. The machine can prepare a state whose measurement statistics favour certain outcomes. That is a careful statement. It is not influencing the future. It is not magic. It is arranging the present system so that measurement samples from a useful probability distribution. When the algorithm and the problem fit, that is genuinely powerful. The point is not to diminish the claim. The point is to stop it being inflated beyond the conditions that make it true.

The same generosity should be given to models. A sufficiently defined perfect model could weight its outputs correctly, if we define perfection strongly enough. It could rank the right answer above the wrong one. It could, in principle, produce an answer distribution that tracks reality rather than merely sounding plausible. That is a legitimate abstraction. So is an ideal quantum computer. So is a true one-time pad. The problem is not the existence of ideal objects. The problem is the lazy habit of letting the shine from the ideal fall onto an implementation that has not earned it.

Good abstractions matter, because they let us reason. Nobody can think clearly if every sentence has to drag every assumption, edge case and implementation detail behind it. A noun is a handle. It lets us pick up a complicated object without spelling out the whole machine every time.

The ideal is not bullshit. The model is not bullshit. The proof is not bullshit.

The bullshit starts when the ideal is smuggled into the real world and treated as if the proof, the machinery, the evidence and the operating conditions came free with the noun.

The Ideal Dies in Transit

The proof does not travel automatically into implementation. That is the central mistake.

We use a noun that belongs to an ideal object, then attach it to something in the world. The noun arrives polished. The thing it is attached to may be much less polished. Sometimes the fit is close enough. Sometimes it is laughable. Either way, the word itself does not settle the matter.

Quantum computer. AI model. Security control. Mandate. Assurance. Ownership.

Each of these can point to something real. None of them proves that the real thing exists. The noun compresses the conditions. It does not satisfy them. It is a label, not a miracle.

A claimed one-time pad may fail through bad entropy, weak generation, reuse, custody failure, copying, logging, leakage, endpoint compromise, or a procedural shortcut invented because the real process was inconvenient. The mathematics has not failed when that happens. The implementation never reached the mathematics. A deterministic stream with a long output is not a true one-time pad. A pad used twice is not a one-time pad any more. A pad that leaks through its handling is not protected by the clean proof. The failure is not subtle. The thing has changed category.

A claimed quantum computer may fail through noise, scale, decoherence, gate error, measurement error, poor error correction, or a simple mismatch between the machine and the problem being claimed. The useful quantum claims usually mean a particular algorithm, a particular problem structure, and a machine that can preserve the relevant states long enough for the calculation to matter. I do not need a doctorate in the underlying physics to recognise the shape of the claim. The model comes first. The physical machine has to earn it. The adjective quantum is not a permission slip to stop asking engineering questions. If anything, it should make the questions sharper, because the useful claim rests on conditions that are fragile and expensive to maintain.

Models and controls fail in the same general way, when the label outruns the reality. A language model can sound calm, fluent and finished while being wrong. It can learn what answers tend to look like without fully learning what makes them true. Those overlap in many domains, which is why models are useful. They do not overlap perfectly, which is why they are dangerous when treated as if they know rather than generate.

A control can appear in a catalogue, a policy, a dashboard or a risk pack while controlling very little.

Plausibility is not truth. Confidence is not proof.

A beautifully weighted wrong answer is still wrong. A noisy machine with a glamorous noun is still noisy. A control that does not operate is not made real by typography. The label may make the failure easier to discuss. It does not make the failure disappear.

Calculate the Gap

The useful question is not whether the ideal statement is true. Often it is. The useful question is whether the object in front of us satisfies the conditions that make the statement true.

What would have to be true for this sentence to be true?

That question cuts through a lot. It does not sneer at the ideal. It does not attack mathematics, physics, models, controls or policies. It grants the clean claim its clean territory, and then asks whether the thing in front of us actually lives there. It asks the claim to unpack itself. It turns a confident noun back into a set of conditions that can be inspected.

And the gap is inspectable. If the claim depends on randomness, inspect the randomness. If it depends on secrecy, inspect the custody. If it depends on a machine, inspect the machine. If it depends on a model, inspect the grounding, the training objective, the domain limits, the verification and the failure modes. If it depends on a control, inspect whether anything is actually being controlled. This is calculable in the useful sense: list the conditions, test them, challenge them, evidence them, or find them missing. Not fake precision. Not spreadsheet mysticism. Just disciplined inspection. The aim is not to produce a decorative number. The aim is to expose the exact place where the claim stops matching the object.

That habit of mind works across cryptography, quantum computing, AI, engineering and security work alike. It stops the room relaxing just because the right label has appeared. The risk has been logged. The control has been mapped. The owner field has been populated. The dashboard has a colour. The initiative has a title.

Something has happened, certainly.

Often what has happened is language.

The adult question is colder: what changed in the system, the estate, the behaviour, the risk?

The dull corporate version is almost too miserable to mention, but it belongs here, because it is the same failure in cheaper clothes. A mandate is not an action. A policy is not a control. A dashboard is not evidence. A risk entry is not mitigation. An owner field is not ownership. A steering group is not progress.

These things can be useful. They can be necessary. They can be part of the machinery that turns intent into change. But they are not the change itself. They are not useless by default, but they are not magic by appointment.

The Word Does Not Bring the World With It

Naming is not instantiation.

Calling something a one-time pad does not make it true. Calling something a quantum computer does not make it useful. Calling something an AI model does not make it intelligent. Calling something a control does not make it operate.

This is why the corporate version matters, however reluctantly. If a mandate is real, where is the mechanism? Who turns the instruction into performed work? Who has authority? Who has capacity? Who loses the argument when delivery becomes inconvenient? If a control is real, where does it operate? What system does it affect? Who maintains it? What evidence shows it is working? What would we see if it failed?

Without those answers, the organisation has not created control. It has created intent with stationery. It may be well-formatted intent. It may have a distribution list, a sponsor, a monthly review slot and a row in a tracker. It is still intent.

The right question is always the same: what would have to be true?

For a one-time pad, the answer is true randomness, secrecy, single use, sufficient length and no leakage. For a useful quantum computer, it is coherence, scale, error correction, algorithmic fit and reliable measurement. For a model, it is grounding, verification, domain limits, and truth-tracking rather than mere fluency. For a control, it is operation, ownership, evidence, consequence and effect.

Provided. Provided. Provided.

That is not hedging. That is the difference between a claim and a costume.

The world does not honour our labels. Reality has no interest in the slide, the diagram, the confidence, the acronym, the policy verb, the dashboard colour or the fact that everyone in the room nodded at the right time.

The word can point. It cannot instantiate.

The word can describe. It cannot operate.

The word can promise. It cannot deliver.

A word carries a proof only when the thing satisfies the conditions that make the proof apply. Until then, it is only language with ambitions.

The thing must earn the name.

Provided it is true.