Quantum Online Memory Checking

The problem of memory checking considers storing files on an unreliable public server whose memory can be modified by a malicious party. The main task is to design an online memory checker with the capability to verify that the information on the server has not been corrupted. To store n bits of public information, the memory checker has s private reliable bits for verification purpose; while to retrieve each bit of public information the checker communicates t bits with the public memory. Earlier work showed that, for classical memory checkers, the lower bound s*t \in Omega(n) holds. In this article we study quantum memory checkers that have s private qubits and that are allowed to quantum query the public memory using t qubits. We prove an exponential improvement over the classical setting by showing the existence of a quantum checker that, using quantum fingerprints, requires only s \in O(log n) qubits of local memory and t \in O(polylog n) qubits of communication with the public memory.

💡 Research Summary

The paper revisits the classic problem of memory checking—verifying that data stored on an untrusted public server has not been altered—through the lens of quantum information processing. In the traditional (classical) model a verifier keeps s private bits and, for each query, exchanges t bits with the server. A well‑known lower bound shows that the product s·t must grow linearly with the size n of the stored file (s·t = Ω(n)), meaning that one cannot simultaneously shrink both local storage and communication overhead.

The authors break this barrier by allowing the verifier to use quantum resources: s private qubits and t quantum queries to the public memory. The central technical tool is the quantum fingerprint, a compact O(log n)‑qubit quantum state that encodes an n‑bit string. Two distinct strings produce nearly orthogonal fingerprints, while identical strings yield fingerprints with inner product close to one. This property can be tested efficiently with a SWAP test, which estimates the squared inner product of two quantum states using only a few elementary quantum gates and a single measurement.

The proposed protocol works as follows. The n‑bit file is partitioned into blocks of size B (e.g., √n). For each block the verifier computes a quantum fingerprint and stores it locally; the total private memory therefore requires only O(log n) qubits regardless of the number of blocks. When a client wishes to read a particular bit, the verifier sends the block index to the server. The server recomputes the fingerprint of the current block contents and returns it. The verifier then runs a SWAP test between the received fingerprint and the stored correct fingerprint. If the server has not tampered with the block, the test outputs “equal’’ with probability 1 − ε; if the block has been altered, the probability drops to at most ε, where ε can be made arbitrarily small by repeating the test a polylogarithmic number of times.

Complexity analysis shows that the verifier’s private storage s = Θ(log n) qubits and the communication per query t = Θ(polylog n) qubits, achieving an exponential improvement over the classical bound. The authors also discuss fault‑tolerance: each fingerprint can be encoded with a small quantum error‑correcting code (e.g., a