Cryptographic Proof in Plain English

The phrase 'cryptographic proof' makes most people's eyes glaze over, which is unfortunate, because the underlying idea is one of the most useful concepts of the past fifty years. So let me strip it down. A cryptographic proof — the kind we put on every artifact that matters in the GI Engine — is a small bundle of bytes that does exactly three things. It says who. It says what. And it says when. Anyone with the right software can check those three things in milliseconds, anywhere, with no need to talk to whoever made the proof. That's the whole magic trick.

The 'who' part comes from a thing called a key pair. Think of a key pair as a matched lock and key, except backward. The lock is public — anyone can have it, anyone can use it to check things. The key is private — only the owner has it. When the owner wants to sign something, they use their private key. When anyone else wants to check the signature, they use the matching public lock. The math is set up so that only the real key can produce a signature that the real lock will accept. If someone forges a signature, the lock will refuse it, every time, with no judgment call.

The 'what' part comes from a thing called a hash. A hash is a fingerprint — a short string of bytes that uniquely identifies a longer document. Change one comma in the document and the hash changes completely. Change nothing and the hash stays identical. The function that computes the hash is publicly known, so anyone can compute the hash of any document themselves and compare it to the hash someone else claims. If the hashes match, the documents are byte-identical. If they don't match, the documents differ — even if you can't see the difference. The fingerprint is more discerning than your eyes.

Combine the two and you get the basic building block. The signer takes the document, computes its hash, and signs the hash with their private key. They publish the document, the hash, and the signature. Anyone receiving the package can recompute the hash from the document (proving the 'what'), check the signature against the hash using the signer's public lock (proving the 'who'), and read the timestamp the signer included in the signed payload (proving the 'when'). Three checks, all of which are arithmetic, none of which requires anyone's word for anything. The mathematics is the witness.

What this gives you that nothing else gives you is offline verification. The signer can be unreachable, asleep, retired, or out of business. The platform that produced the document can be down. The country the signer lives in can have lost internet access. The verification still works, because all you need is the document, the signature, and the public lock — and the lock is published once, can be cached forever, and never has to change for the proof to keep verifying. Twenty years from now, with the signer long gone, the proof will still verify. That property is rare in software. It is what makes cryptographic proof suitable for things that have to outlive the people who made them.

There are some properties that fall out for free once you have signing. You can chain signatures — sign A, then sign 'A's hash plus my new content B,' and the chain becomes a tamper-evident sequence where any edit to any link in the chain breaks every later link. You can sign across organizations — the hospital's key signs the patient record, the lab's key signs the result, the doctor's key signs the prescription, and the pharmacy can verify all three signatures without trusting any single one. You can sign at scale — modern hardware can produce and verify hundreds of thousands of signatures per second per device. The cost of signing every artifact in a complex workflow is, in practice, indistinguishable from zero.

What you do not get from cryptographic proof — and this is important — is a guarantee that the signer was telling the truth about the underlying facts. A doctor can sign a wrong diagnosis. A lab can sign a contaminated result. A truck driver can sign a manifest that does not match the actual cargo. Cryptographic proof says 'this person committed to this content at this time.' It does not say 'this content is correct.' Correctness is a different problem, with a different layer of safeguards. What proof gives you is the ability to hold someone to what they actually said, not to a different thing they later claim they said. That alone changes most disputes.

Strip away the jargon and you have a tool that says who, what, and when, with arithmetic precision, verifiable by anyone, anywhere, forever. The mathematics is sixty years old. The hardware to run it on a phone is fifteen years old. The legal frameworks that recognize it are five to twenty years old. The thing that has been new is the workflow that bakes signing in at the moment of action — not as an afterthought, not as a special procedure, just as the default for every artifact that matters. That is the layer the GI Engine builds. The math underneath it is plain English once you stop apologizing for it.