Publicly Verifiable Quantum Money

13 concepts6 papers2 proposals

In a classical digital world, preventing fraud requires a ledger. Because classical data can be copied perfectly with a simple copy-and-paste operation, a central authority or a distributed consensus mechanism must track every transaction to prevent "double-spending."

Quantum mechanics offers a radical alternative through the no-cloning theorem, which states that it is physically impossible to create an identical copy of an arbitrary, unknown quantum state. This principle opens the door to quantum money: physical tokens of value encoded in quantum states that are fundamentally impossible to counterfeit.

However, moving from the physics of no-cloning to a functional cryptographic currency introduces a profound paradox: How do you allow the public to verify that a quantum banknote is authentic without giving them enough information to clone it?

The Verification Dilemma: Private vs. Public

The earliest designs for quantum money relied on private verification. In a private-key scheme, a central bank issues a quantum state and keeps a secret classical record of its exact configuration. When a user wants to spend the money, they must send it back to the bank. The bank checks the state against its secret key and validates the transaction.

In Pseudorandom Quantum States, Fang Song et al. demonstrated that secure private-key quantum money can be built efficiently using states that are computationally indistinguishable from completely random states. Because an adversary cannot distinguish these pseudorandom states from truly random ones, they cannot extract enough information to clone them, ensuring robust security against computationally bounded counterfeiters.

The drawback of private verification is practical: the bank must be involved in every single transaction. For a quantum currency to function like physical cash, it needs public verification, allowing anyone to validate a banknote using a public algorithm without contacting the mint.

The Private-to-Public Verification Gap

Introducing public verification creates a dangerous vulnerability. If the verification algorithm is public, an adversary can run it as many times as they want on their own quantum computer.

The core tension is that any mechanism capable of verifying a quantum state must interact with it. If an adversary possesses a machine that can verify whether a state is a valid banknote, they can use that machine as a guide. By repeatedly feeding altered quantum states into the public verification circuit and observing the outcomes, the adversary can iteratively sculpt a generic state into a valid counterfeit banknote.

The authors of On the (Im)plausibility of Public-Key Quantum Money from Collision-Resistant Hash Functions, Prabhanjan Vijendra Ananth et al., formalized this barrier. They showed that the very information exposed to enable public verification can often be exploited to clone the state, demonstrating that it is highly implausible to construct public-key quantum money using standard classical building blocks like collision-resistant hash functions.

This "private-to-public verification gap" is a recurring challenge across quantum cryptography. For example, in Classical Commitments to Quantum States, Sam Gunn et al. developed a protocol allowing a classical verifier to securely "lock" a quantum state using the Learning With Errors (LWE) assumption. However, their scheme still requires the verifier to hold a secret key to validate the state's opening, leaving a completely public, third-party auditable verification scheme as an elusive goal.

Escaping the Trap with Mathematical Hardness

To bypass this verification gap, researchers must find mathematical structures where verifying a state's validity does not reveal how to construct or duplicate it.

One theoretical solution is to assume the existence of a "black box." In Quantum Copy-Protection and Quantum Money, Scott Aaronson proved that publicly verifiable quantum money is possible relative to a quantum oracle. This oracle acts as an impenetrable black-box unitary transformation that handles verification without exposing its internal complexity to the user.

To realize public verification in the real world without relying on idealized oracles, protocols must leverage problems that are computationally intractable even for quantum computers. In Quantum money from knots, Edward Farhi et al. proposed a scheme based on knot theory.

[Bank Generates Token] ---> Superposition of Equivalent Knot Diagrams
                                       |
                                       v
[Public Verification]  ---> Computes Knot Invariants (e.g., Alexander Polynomial)
                                       |
                                       v
                       Validates state without revealing how to construct 
                       a new, independent superposition of the same knot.

In this knot-based scheme, a banknote is a quantum superposition of equivalent knot diagrams. Anyone can publicly verify the banknote by computing a knot invariant (like the Alexander polynomial) which remains identical for all diagrams of the same knot. Crucially, knowing the invariant allows you to verify the state, but it does not give you an efficient way to generate a new, independent quantum superposition of equivalent diagrams. While the authors noted that a definitive security proof remains open, it illustrates how topological complexity can protect a state from being cloned via its verification circuit.

Protecting Against the Mint: Collision-Free Money

Even if a protocol achieves secure public verification, a final security loophole remains: What if the bank itself is untrusted or compromised?

In standard public-key cryptography, anyone with the master generation key can print infinite copies of valid tokens. If a malicious actor gains access to the mint, they could cause uncontrolled currency inflation.

To eliminate this threat, Andrew Lutomirski et al. introduced a stricter security paradigm known as collision-free quantum money in Breaking and Making Quantum Money: Toward a New Quantum Cryptographic Protocol.

In a collision-free scheme, the mathematical formulation ensures that not even the issuing authority can efficiently generate two identical, valid copies of the same quantum banknote. The generation algorithm is inherently probabilistic and one-way; it outputs a unique serial number and a matching quantum state, but prevents the creator from targeting a specific serial number twice. This ensures that every piece of quantum currency is globally unique from the moment of its measurement, protecting the economy from both external counterfeiters and corrupt insiders.

Key Foundational Work

Breaking and Making Quantum Money: Toward a New Quantum Cryptographic Protocol (2010) — contributed 4 concept elements to this direction.
Quantum Copy-Protection and Quantum Money (2009) — contributed 3 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_collision_free_quantum_money_c1c099a5,
  title = {collision-free quantum money},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/collision-free-quantum-money/rdr_c1c099a545ea4012afa18f7d4632edac},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_collision_free_quantum_money_c1c099a5_v1,
  title = {collision-free quantum money},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/collision-free-quantum-money/rdr_c1c099a545ea4012afa18f7d4632edac/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake