⚛️ quantum physics

New Quantum Internet Applications via Verifiable One-Time Programs

This paper introduces Verifiable One-Time Programs constructed from single-qubit states and classical cryptography to enable single-round Open Secure Computation, thereby facilitating near-term quantum applications such as sealed-bid auctions, consensus protocols, and differentially private aggregation.

Original authors: Lev Stambler

Published 2026-03-16

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Lev Stambler

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to send a secret recipe to a friend, but you want to make sure they can only cook the dish once, and you want to be absolutely sure they didn't cheat by looking at the ingredients before they started.

In the world of cryptography, this is called a One-Time Program (OTP). It's like a digital "burn-after-reading" envelope. However, building these in the real world is usually incredibly hard because it requires complex, expensive quantum computers that don't exist yet.

This paper introduces a new, simpler way to do this using single-qubit states (the simplest building blocks of quantum information, like a single coin flip) combined with some clever classical math tricks. The author, Lev Stambler, calls this new system Verifiable One-Time Programs (Ver-OTPs) and uses it to build something even bigger called Open Secure Computation (OSC).

Here is a breakdown of the paper's ideas using everyday analogies.

1. The Problem: The "Ephemeral" Envelope

Usually, quantum "one-time programs" are like ice cubes. They are great, but they melt (lose their quantum state) very quickly. If you send an ice cube to a friend, they have to catch it and use it immediately, or it's gone. This makes them useless for many real-world tasks where you might need to send a program and have the user run it later.

The Author's Insight:
Instead of trying to keep the ice cube frozen forever, what if we accept that it melts quickly, but we build a verification system around it? We can check if the ice cube was real before it melts, and if it was, we trust the result.

2. The Solution: The "Magic Box" (Verifiable OTPs)

The author creates a Verifiable One-Time Program. Think of this as a Magic Box sent to a user.

How it works: The sender puts a secret program inside the box. The box is made of many tiny, fragile "shards" (quantum states).
The Catch-and-Choose Game: Before the user opens the box to run the program, the sender asks the user to randomly break a few shards to check if they are real.
- If the shards look fake, the user knows the box is a scam and stops.
- If the shards look real, the user is statistically guaranteed that the rest of the box is also real.
The Result: The user can now safely run the program once. Because the shards are fragile, they can't run it twice.

Why is this special?
It uses very simple quantum technology (single-qubit states) that we can actually build with today's technology, rather than waiting for futuristic quantum supercomputers.

3. The Big Leap: "Open Secure Computation" (OSC)

Once we have these Magic Boxes, the author builds a new system called Open Secure Computation (OSC).

Imagine a Town Hall Meeting where anyone can walk up and drop a sealed envelope into a box.

No Registration: You don't need to sign up or show ID beforehand. Anyone can participate.
The Mayor (Receiver): There is a "Mayor" (the receiver) who collects all the envelopes.
The Twist: The Mayor can group the envelopes however they want. They can take Envelopes A, B, and C and ask, "What is the average of these?" Then, they can take Envelopes D and E and ask, "What is the sum of these?"
The Security: Even though the Mayor is in charge, they cannot see what is inside the envelopes until they do the math. And because of the Magic Boxes, the Mayor can't cheat by opening the envelopes early or running the math twice.

4. Real-World Applications (The "What can we do with this?" section)

The paper shows how this "Town Hall" system can solve three major problems:

A. The Sealed-Bid Auction (The "Blind Bidding" Game)

Scenario: You want to sell a rare painting. Bidders want to bid without seeing each other's offers.
The Problem: Usually, the auctioneer might peek at the bids or rig the game.
The OSC Solution: Bidders drop their sealed bids into the system. The system (the Mayor) calculates the winner and the price without the auctioneer ever seeing the individual bids.
The Benefit: The auctioneer can't cheat, and the bidders know their secrets are safe. It happens in one single round—no back-and-forth emails.

B. The "Atomic Proposal" (The "Group Hug" for Consensus)

Scenario: In computer networks (like Bitcoin or Ethereum), computers need to agree on a rule. Usually, a leader says, "Let's do X," and everyone has to say "Yes."
The Problem: If the leader is slow or malicious, the whole network stalls.
The OSC Solution: The leader proposes a value. Everyone drops their "Yes/No" into the system. The system instantly checks if a majority agreed. If they did, it generates a "Group Signature" proving everyone agreed.
The Benefit: It speeds up how networks reach agreement, making them faster and more secure.

C. Private Statistics (The "Anonymous Survey")

Scenario: A company wants to know the average salary of its employees without asking anyone to reveal their specific salary.
The OSC Solution: Employees send their salary data (encrypted) and a secret "noise" number. The system adds them all up and adds a little bit of random "static" (noise) to the final result.
The Benefit: The company gets a useful average number, but no one can figure out who earned what. Crucially, employees don't need to register beforehand; they can just send their data anonymously.

5. The "Hardware" Requirement

The most exciting part for engineers is that this doesn't require a sci-fi quantum computer.

The Quantum Part: It only needs single-qubit states (like a single photon of light). These are already being sent over fiber optic cables today.
The Classical Part: The heavy lifting is done by standard computers using advanced math (encryption and zero-knowledge proofs).

Summary

The paper is like inventing a new type of safe deposit box that is so simple to build (using basic quantum parts) that we can use it now.

Verifiable OTPs: A box you can check before you open, ensuring it's real and can only be opened once.
OSC: A system where strangers can send secret data to a central server, and the server can compute results on that data without ever seeing the raw data or needing to know who sent it.

This opens the door to fairer auctions, faster internet consensus, and private data analysis using technology that is just around the corner, rather than decades away.

1. Problem Statement

The quantum internet promises revolutionary applications beyond Quantum Key Distribution (QKD), but most proposed protocols require sophisticated quantum resources (e.g., long-lived quantum memories, complex entanglement) that are currently beyond the reach of near-term technology.

Existing constructions of One-Time Programs (OTPs)—programs that can be evaluated exactly once—often rely on single-qubit states (like BB84 states). While these are experimentally feasible over long distances, they suffer from short coherence times, making them ephemeral (e𝖮𝖳𝖯s). This ephemerality limits their utility because the receiver must be online and ready immediately, defeating the purpose of a "program" that can be evaluated later. Furthermore, without verification, a receiver cannot trust that the e𝖮𝖳𝖯 is well-formed or that the sender hasn't tampered with the logic.

The paper addresses the challenge of constructing verifiable, single-round secure computation protocols using only minimal quantum resources (single-qubit states) and standard hardware assumptions, enabling applications like sealed-bid auctions and consensus primitives without pre-registration.

2. Methodology

The authors propose a two-layered framework combining quantum primitives with advanced classical cryptography:

A. Verifiable One-Time Programs (Ver-OTPs)

The core innovation is transforming ephemeral OTPs into Verifiable OTPs (Ver-OTPs).

Construction: A Ver-OTP consists of a Garbled Circuit (representing the function) and Verifiable One-Time Memories (OTMs).
Verification Mechanism:
- The sender generates secret shares of the wire labels for the garbled circuit.
- These shares are distributed across multiple single-bit input OTPs.
- The receiver performs a Cut-and-Choose verification: they randomly select a fraction of the OTPs to "open" and verify the validity of the shares and the garbled circuit using Non-Interactive Zero-Knowledge Proofs (NIZKs).
- If the check passes, the receiver is assured that the remaining unopened OTPs contain valid shares to reconstruct the correct wire labels for their chosen input.
Security: The scheme uses a Secret Sharing threshold ( $\zeta/2 + 1$ ) to ensure the receiver cannot reconstruct both wire labels (0 and 1) for any input bit, preserving the one-time property.

B. Open Secure Computation (OSC)

Building on Ver-OTPs, the authors define Open Secure Computation (OSC), a novel primitive where:

No Pre-registration: A set of unknown sending parties can submit inputs to a known (but untrusted) receiving party.
Single-Round: The protocol completes in a single round of communication.
Adaptive Partitioning: The receiver can adaptively partition the set of inputs into disjoint groups to compute the function multiple times (subject to security constraints).

OSC Construction:

Multi-Key Homomorphic Encryption (MHE): Senders encrypt their inputs under their own public keys.
Verification: Each sender creates a Ver-OTP that hardcodes their secret key. This Ver-OTP is designed to output a partial decryption of the MHE ciphertext only if the ciphertext corresponds to the sender's public key.
Execution: The receiver verifies all Ver-OTPs. If valid, the receiver homomorphically evaluates the function $f$ on a subset of ciphertexts. The receiver then executes the Ver-OTPs to obtain partial decryptions, which are combined to reveal the final output.
Security Modifications: The authors propose modifications to standard MHE schemes to support auxiliary inputs, index independence, and partial decryption simulation when not all keys are known.

3. Key Contributions

Verifiable One-Time Programs (Ver-OTPs): A new primitive allowing a receiver to verify the correctness of an OTP relative to public data before execution, using only single-qubit states and classical NIZKs.
Open Secure Computation (OSC): A single-round secure computation model that requires no pre-registration of parties, enabling "open" participation.
Novel Applications: The construction of several practical protocols using OSC:
- Single-Round Sealed-Bid Auctions: With honest-majority guarantees.
- Honest-Majority Atomic Proposals: A building block for consensus protocols (e.g., PBFT, HotStuff).
- Differentially Private Statistical Aggregation: Allowing unknown parties to contribute data without pre-registration while ensuring privacy.
- Fair Exchange: A blockchain-assisted protocol for fair digital goods exchange.
Near-Term Feasibility: The quantum requirement is minimal (single-qubit BB84-like states), making the framework potentially implementable with current or near-term quantum technology.

4. Results

Theoretical Security: The paper provides simulation-based security proofs for Ver-OTPs and OSC. The security relies on the hardness of the underlying cryptographic assumptions (NIZK, Commitments, MHE) and the cut-and-choose soundness of the OTP verification.
Functionality: The authors demonstrate that OSC can successfully handle adaptive partitioning attacks by enforcing an "honest majority" check within the function logic (e.g., if a partition lacks a majority of registered parties, the output is $\perp$ ).
Efficiency Trade-off: The approach trades heavy quantum resources for classical complexity (using MHE, NIZKs, and Garbled Circuits), which is considered practical given the rapid optimization of classical cryptography.

5. Significance

Bridging the Quantum-Classical Gap: This work demonstrates that sophisticated cryptographic tasks (like secure multi-party computation) can be achieved with minimal quantum hardware (single qubits), bypassing the need for long-lived quantum memories or complex entanglement.
New Paradigm for Quantum Internet: It moves beyond QKD and position verification, proposing a framework for quantum-assisted cryptography where quantum states act as a "trusted setup" or verification mechanism for classical cryptographic protocols.
Practical Applications: The ability to run sealed-bid auctions and consensus primitives in a single round without pre-registration opens new possibilities for decentralized systems, blockchain coordination, and privacy-preserving data aggregation in dynamic, open networks.
Foundational Primitive: Ver-OTPs are identified as a primitive of independent interest, potentially useful for software licensing, pay-to-run models, and fair exchange, independent of the OSC framework.

Open Questions & Future Work

The authors identify several directions for future research:

Removing the Common Reference String (CRS) assumption.
Improving the efficiency of Ver-OTPs.
Adding fault tolerance for noisy quantum environments.
Achieving Universal Composability (UC) security.
Extending the framework to handle quantum inputs/outputs.
Constructing MHE schemes that satisfy the specific security definitions required without modification.