Introduction
Can a classical party use an adversary’s quantum computer as its own trusted quantum device?
Mahadev’s breakthrough [33 ] demonstrated that a classical party can verify quantum decision problems, even when the quantum computation is performed by an untrusted prover. A quantum computer, however, provides much more than answers to decision problems. It can sample from distributions, prepare quantum states for other parties, process quantum states received from them, and retain quantum information across successive computations. These capabilities are central to quantum cryptography, where security can depend on information being encoded in a quantum state rather than revealed through a classical description. Participating in such a protocol may require a party to keep private quantum memory, manipulate it in response to incoming messages, and release only selected outputs. This raises a broader question:
Can a classical client obtain the capabilities of a trusted quantum computer through classical interaction with a single untrusted quantum server?
Even restricted versions of this goal remain unresolved as we discuss below.
SampBQP Verification. A natural first step beyond decision problems is to ask a quantum server to sample the classical output of a prescribed quantum circuit. This task, known as classical verification of SampBQP, requires the client to verify the distribution of the output, rather than a single decision bit. Prior work [CLLW22] makes progress on this question, but is limited to soundness error that is inversely proportional to the number of repetitions, leaving the following question open.
Can classical verification of SampBQP be achieved with negligible error?
Remote State Preparation. Quantum outputs introduce a further challenge: correctness alone may not capture the desired cryptographic guarantee. Consider, for example, a classical party that wishes to give a quantum adversary an unclonable quantum ciphertext. The classical party may know how to prepare the ciphertext, but sending these instructions to the quantum device would defeat the purpose: the adversary could generate as many ciphertexts as it likes. Asking the adversary to prove that it prepared the correct state does not resolve this problem either, since correctness alone says nothing about the additional copies or information it may have retained. We would like the adversary to learn only what it could have learned from receiving a single quantum ciphertext, even though it performs every quantum operation involved in preparing that ciphertext!
The example above is a special case of what is known as (verifiable) remote state preparation (RSP) in the literature [24 ] . RSP allows a classical party to “send” a quantum state ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ to a quantum party, as long as it knows a classical description of a quantum circuit that efficiently prepares the state. The goal is for the quantum party to receive no more information than if it had directly received ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ .
There has been meaningful progress on building RSP for restricted state families with inverse-polynomial error [24 , 20 ] . For cryptography, such a loss can overwhelm the security guarantee altogether: in the case of the unclonable encryption example discussed earlier, this leaves room for an adversary to succeed with inverse-polynomial probability where the ideal quantum protocol permits only negligible success. Thus, seven years after its introduction, the main question about RSP has remained open:
Can remote state preparation be obtained for arbitrary efficiently computable states with negligible error?
Stateful Multi-Round Protocols, Beyond RSP. A key motivation for the introduction of RSP was to allow a classical client to effectively assume the role of a quantum party in an interactive protocol. But enabling this requires an even stronger form of classical control: we want the classical device to be able to direct the quantum device through multiple rounds of interaction, with assured privacy and a guarantee that any deviations will be detected.
Let us explain what we are looking for in more detail. Imagine a classical client with a trusted quantum computer of its own. The client could privately choose a computation, apply it to a quantum state received from another party, and return a quantum output. It could then keep part of the state as private memory, and use it in a later computation to return another output, and so on. We would like to faithfully reproduce this entire interaction when all of the quantum hardware is instead controlled by another party, who may be malicious. The client should communicate only classically, yet retain the privacy and control that its own quantum computer would have provided.
The Obstacle: Testing Destroys the Output. A central obstacle is that checking a quantum computation can destroy the very state we wanted to use. This is relatively harmless when the goal is to learn a decision: after obtaining enough evidence for the answer, we can discard the computation. It becomes a serious problem when the goal is to obtain a sample or continue computing on a quantum output. Evidence that a state was correct is of little use if producing that evidence consumes the state.
One natural approach is to ask the server for many candidate states, test most of them, and retain an untested state for use. This approach underlies the classical verification of SampBQP [CLLW22]. However, testing polynomially many candidates leaves an inverse-polynomial opportunity for an incorrect state to escape inspection. For decision computations, independent repetition and majority can reduce a bounded error to negligible. For general sampling tasks and quantum outputs, there is no analogous generic operation that combines several moderately reliable outputs into one negligibly erroneous output.
There is a further difficulty. Even if a test preserves an honest server’s state, what prevents a malicious server from replacing its state after passing the test? To support a sequence of computations, the client needs a guarantee about the same evolving quantum state throughout the interaction. It must be possible to test that state without destroying it , continue using the state, and keep the server bound to the result of each operation.
Obtaining this guarantee through classical communication is the central technical challenge addressed by our work.
Main Result
Our main construction is a two-party computation protocol between a classical client and a quantum server for general real quantum circuits.
The client supplies a private classical input which may specify a classical description of (1) the desired quantum circuit C C C and (2) an efficient preparation procedure for an initial state ∣ ψ C ⟩ \lvert\psi_C \rangle ∣ ψ C ⟩ .
The server supplies an arbitrary quantum input, possibly entangled with an external reference.
The computation returns designated classical outputs to the client and prescribed quantum outputs to the server. The parties may choose to discard some output wires so their state/value is returned to neither party.
Figure 1 illustrates the ideal functionality.
Figure 1. The ideal quantum two-party functionality (abort omitted). The client’s private input w w w specifies U w U_w U w , which acts on the server’s input register S S S and zero-initialized ancillas A A A . It returns B B B to the server, measures C C C in the computational basis to produce the client’s output y y y , and discards D D D . The possibly entangled external reference E E E is untouched. Our protocol realizes this functionality using only classical communication.
Theorem 1 (Informal). Assuming the post-quantum hardness of LWE , there exists an interactive protocol for secure quantum computation of real quantum circuits between a classical client and a quantum server which achieves simulation-based security with abort with an ϵ \epsilon ϵ -simulator.
Here, ε \varepsilon ε -simulation means that, for every inverse-polynomial ε > 0 \varepsilon> 0 ε > 0 , there is a simulator running in time polynomial in the security parameter, the computation size, and 1 / ε 1/\varepsilon 1/ ε , whose ideal execution is indistinguishable from the real execution up to computational advantage ε \varepsilon ε . Crucially, the protocol itself and the honest parties’ running times are independent of ε \varepsilon ε . This guarantee suffices to preserve negligible security loss in any efficiently testable cryptographic game: any inverse-polynomial violation would yield an attack on the ideal functionality by choosing ε \varepsilon ε sufficiently smaller than the violating advantage. We highlight some example applications below where we get the standard (negligible-error) indistinguishability-based security.
Remark 1. At the end of § 2.1 , we isolate a particular primitive whose construction with negligible security would generically lift our results to negligible-loss simulation. 1
The restriction to real gates is inherent to any classical-communication protocol and is not overly restrictive. It is well-established that any quantum circuit with complex gates can be generically converted into one with real gates, with a specific input-encoding [BV93]. Moreover, many of the example applications we mention below natively use real quantum circuits.
Private Quantum Memory Across Computations. The sequential composition of our protocol also allows the classical client to maintain private quantum memory on the server across a polynomial number of sequential computations. At each stage, the client can privately choose the next computation, process the stored memory together with newly supplied quantum inputs, and obtain designated outputs while retaining the remaining state for future use. The quantum server is prevented from tampering with the persistent memory by authenticating it between each computation. The resulting interaction admits ε \varepsilon ε -simulation with abort, including when the memory is entangled with an external system. This gives the client the capabilities of a trusted quantum computer whose state persists across interactions. We describe this extension in § 7 .
Applications.
We highlight a few consequences and applications of our main result below.
Verification of quantum sampling. Chung, Lee, Lin, and Wu [CLLW22] gave classical verification of SampBQP with inverse-polynomial computational soundness error and explicitly asked whether negligible soundness error is possible. We resolve this question for verification of the output distribution of a prescribed quantum circuit.
Corollary 1 (Verification of Quantum Sampling, Informal). Let C C C be an efficient quantum circuit with classical output distribution D D D .
Assuming the post-quantum hardness of LWE, there exists a classical verification of quantum sampling protocol where the classical client’s output distribution is computationally indistinguishable from D D D (conditioned on the quantum server not causing an abort).
The negligible error here is the additional error introduced by verification. It is separate from the statistical approximation allowed in the definition of SampBQP: if C C C samples from D D D with ∥ D − D ∗ ∥ T V ≤ δ \lVert D-D^*\rVert_{\mathrm{TV}}\le\delta ∥ D − D ∗ ∥ TV ≤ δ for a target distribution D ∗ D^* D ∗ , then the corresponding joint decision-and-output distribution has computational distinguishing error at most δ + negl ( λ ) \delta+\operatorname{negl}(\lambda) δ + negl ( λ ) relative to ideal sampling from D ∗ D^* D ∗ . Our result does not require the quantum sampler’s approximation error δ \delta δ itself to be negligible. See § 8.1.1 .
Remote state preparation. Prior RSP protocols prepare states from restricted families with security error scaling inversely with the protocol length T T T [24 , 20 ] . When the time T T T protocol is used to replace a round of quantum communication in a falsifiable game G Q G_Q G Q to obtain G C G_C G C , the error permits an inverse polynomial increase in the maximum winning probability of any QPT adversary a d v \mathit{adv} adv :
max Q P T a d v Pr [ win G C ] ≤ max Q P T a d v Pr [ win G Q ] + 1 poly ( T ) \max_{\mathrm{QPT}\ \mathit{adv}}\Pr[\operatorname{win}G_C]\le\max_{\mathrm{QPT}\ \mathit{adv}}\Pr[\operatorname{win}G_Q]+\frac{1}{\operatorname{poly}(T)} QPT adv max Pr [ win G C ] ≤ QPT adv max Pr [ win G Q ] + poly ( T ) 1
Gheorghiu, Metger, and Poremba explicitly ask how to obtain negligible security error in the cryptographic applications of RSP. Our construction addresses this question through ϵ \epsilon ϵ -simulation and also supports arbitrary (real) efficiently preparable states chosen by the sender.
Corollary 2 (Remote State Preparation, Informal). Let ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ be any state which can be efficiently prepared by a real circuit.
Assuming the post-quantum hardness of LWE, there exists a remote state preparation protocol with ϵ \epsilon ϵ -simulation for ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ . As a result, it has standard (negligible error) falsifiable security:
max Q P T a d v Pr [ win G C ] ≤ max Q P T a d v Pr [ win G Q ] + negl ( λ ) \max_{\mathrm{QPT}\ \mathit{adv}}\Pr[\operatorname{win}G_C]\le\max_{\mathrm{QPT}\ \mathit{adv}}\Pr[\operatorname{win}G_Q]+\operatorname{negl}(\lambda) QPT adv max Pr [ win G C ] ≤ QPT adv max Pr [ win G Q ] + negl ( λ )
Here, arbitrary means any efficiently preparable state chosen through the sender’s private classical description—not an unknown state supplied to the classical sender.
This is an ϵ \epsilon ϵ -simulation guarantee but its cryptographic applications can nevertheless have negligible security loss. For example, the client can remotely prepare an unclonable quantum ciphertext without revealing its preparation procedure. Replacing quantum transmission by this protocol preserves the original unclonability game’s security bound up to a negligible additive term: any inverse-polynomial excess winning probability would contradict the original scheme’s security by choosing ϵ \epsilon ϵ sufficiently smaller than that excess. Thus the receiver’s participation in preparing the ciphertext does not give it a non-negligible advantage in producing two usable ciphertexts. See § 8.1.2 and § 9 .
Classical revocation of leased quantum keys. Secure key leasing allows a user to borrow a quantum decryption key, with the guarantee that returning a key that passes verification removes the user’s ability to decrypt, as formalized by the scheme’s security game [3 ] . In the quantum-return formulation, revocation requires the lessor to receive and verify a quantum key. A classical revocation protocol removes that requirement, allowing the lessor to verify surrender of the decryption capability through classical interaction alone.
Corollary 3 (Classical Revocation of Quantum States, Informal). Assuming the post-quantum hardness of LWE, every secure key leasing scheme with efficient quantum verification admits an interactive revocation protocol using only classical communication. The compiled scheme preserves security after revocation up to negligible loss.
The parties securely evaluate the scheme’s verification procedure on the lessee’s quantum input and the lessor’s private verification key, return the verification decision to the lessor, and discard the submitted key registers. This application illustrates the ability to process and consume a quantum input already held by an adversary.
Other Applications. § 9 develops the following additional applications:
Unclonable encryption over a classical channel (§ 9.1 ).
Public-key quantum money with a classical bank from polynomial hardness (§ 9.1.1 ).
Improved extraction for classical-verifier arguments of quantum knowledge (§ 9.1.2 ).
Secure key leasing with proofs of no-intrusion (§ 9.1.3 ).
Quantum obfuscation with interactive classical communication (§ 9.1.4 ).
We provide more details about these applications in § 2.3 .
Technical Overview
We begin with an overview of our approach for a slightly less ambitious task: verifying a single general quantum computation where the circuit U = U T ∘ ⋯ ∘ U 1 U = U_T \circ\cdots\circ U_1 U = U T ∘ ⋯ ∘ U 1 is public. After computing U U U , the classical party’s output register C C C is measured in the computational basis and the discarded register D D D is traced out.
History State Verification. Feynman’s famed clock construction succinctly encodes the entirety of any quantum computation as a single quantum state: the “history” state. As computation progresses, the initial input and ancillas ∣ ψ 0 ⟩ = ∣ i n ⟩ ⊗ ∣ 0 ⟩ |\psi_0\rangle= |{\rm in}\rangle\otimes|0\rangle ∣ ψ 0 ⟩ = ∣ in ⟩ ⊗ ∣0 ⟩ evolves into ∣ ψ 1 ⟩ = U 1 ∣ ψ 0 ⟩ |\psi_1\rangle= U_1|\psi_0\rangle ∣ ψ 1 ⟩ = U 1 ∣ ψ 0 ⟩ , then into ∣ ψ 2 ⟩ = U 2 ∣ ψ 1 ⟩ |\psi_2\rangle= U_2|\psi_1\rangle ∣ ψ 2 ⟩ = U 2 ∣ ψ 1 ⟩ , and so on. The history state encodes all steps of the evolution in superposition over the timestep t t t :
∑ t = 1 T ∣ t ⟩ ⊗ ∣ ψ t ⟩ \sum_{t=1}^{T} |t\rangle\otimes|\psi_t\rangle t = 1 ∑ T ∣ t ⟩ ⊗ ∣ ψ t ⟩
Now measure the clock register, and get a time t t t . If t t t is maximal at t = T t = T t = T , then the residual state is the output of the computation: ∣ ψ T ⟩ \lvert\psi_T\rangle ∣ ψ T ⟩ . Moreover, a history state can be tested via a series of projective measurements [29 ] .
This suggests a general template for enforcing delegated computation for any publicly known circuit. Suppose the client had a trusted measurement device which could hold a state and perform simple measurements on it. Then:
The server sends a history state of the computation to the trusted measurement device.
The measurement device tests the received state by measuring whether it violates any history state invariants.
The measurement device measures the clock to get a time t t t .
If t < T t < T t < T : send ∣ ψ t ⟩ \lvert\psi_t\rangle ∣ ψ t ⟩ back to the server for another try.
If t = T t = T t = T , measure register C \mathcal{C} C and discard register D \mathcal{D} D .
Implementing the Trusted Measurement Device. Mahadev [33 ] took the first step towards implementing this template for a classical client. Following her approach, we will replace the trusted measurement device with a commitment which can be opened to measurement results of the committed state:
The server commits to a history state.
The client picks a measurement test and asks the server to give an opening for that measurement. It repeats this multiple times to amplify soundness.
The client asks the server to open the clock register in the computational basis to get the time t t t . If t = T t = T t = T , the server is committed to ∣ ψ T ⟩ \lvert\psi_T\rangle ∣ ψ T ⟩ and can open to a measurement of it.
The limitation of Mahadev’s commitment is that it only supports a complete measurement of the committed state (in either the computational or Hadamard basis). This destroys the state completely, preventing amplification and ruining the output step. Still, the collected statistics from one test are sufficient for deciding decision problems like BQP or QMA.
[CLLW22] opened the approach to verifying quantum sampling tasks (SampBQP) by committing to many states, then testing all-but-one of them. The remaining untested state is likely to be a history state, except with ≈ 1 / N \approx1/N ≈ 1/ N probability where N N N is the number of states committed to. So, it can be measured to get the output sample in step 3.
Non-Destructive Testing. To transcend the 1 / N 1/N 1/ N limit, the client must test a state, then use the same tested state for output . This requires, at a minimum, that the test not destroy the committed history state.
[27 ] gave a general approach to making classical verification of QMA non-destructive. In the context of Mahadev’s protocol, an important part of their approach is to avoid directly measuring the commitment openings. Instead, the prover proves the existence of openings which the verifier would accept in a special NP argument which avoids collapsing superpositions over NP witnesses. When paired with a high-completeness ZX Hamiltonian [34 ] , the prover’s opening register is entirely supported on openings which the verifier would accept, and so is not disturbed by the witness-preserving argument.
We adopt a similar approach, but with a few important modifications. [27 ] ’s NP argument requires that the prover knows the statement it is proving – which requires revealing the decoding key for the commitment. Once the key is revealed, the tested state is no longer bound by the original commitment.2 A malicious server can swap it out before the next test or output step.
Safely Verifying Openings. We insulate the client’s decoding key by designing a witness-preserving argument for NP where the precise statement being proven is hidden from the prover. In other words: a secure two-party computation (2PC) for classical functionalities which preserves the quantum party’s input . In its most general form, the goal is to measure some secret classical function f f f on the quantum party’s input, then return the residual state:
Input: The classical client inputs a classical function f f f . The quantum server inputs a superposition ∣ ψ ⟩ = ∑ v α v ∣ v ⟩ |\psi\rangle= \sum_v \alpha_v |v\rangle ∣ ψ ⟩ = ∑ v α v ∣ v ⟩ .
Output: Measure y = f ( v ) y = f(v) y = f ( v ) on the quantum party’s input. Send y y y to the classical party and return the residual quantum state ∣ ψ y ⟩ ∝ ∑ v : f ( v ) = y α v ∣ v ⟩ |\psi_y\rangle\propto\sum_{v:f(v)=y} \alpha_v |v\rangle ∣ ψ y ⟩ ∝ ∑ v : f ( v ) = y α v ∣ v ⟩ to the quantum party.
Importantly, the 2PC hides f f f , up to whatever is necessarily revealed by the residual state ∣ ψ y ⟩ |\psi_y\rangle ∣ ψ y ⟩ . Now the client can input its decoding key as part of a function f f f which checks for accepting openings, and be assured that the decoding key is hidden.
Constructing such a 2PC for general f f f is difficult. Instead, we construct a 2PC for constant-degree multilinear polynomials. This suffices for testing committed history states because we use a commitment with linear decoding and the history state Hamiltonian has constant locality, so their composition is a constant degree multilinear polynomial. See § 2.1 for more details.
Ensuring Commitment Continuity. Simply hiding the decoding key does not ensure binding after a decoding query, though. The adversary can potentially learn enough to break binding through its residual state ∣ ψ y ⟩ |\psi_y\rangle ∣ ψ y ⟩ , or even through the client’s decision of whether to continue or abort.
We define and construct a new classical commitment to quantum states with continual ideal binding .
committed state is defined with overwhelming probability whenever the commitment phase passes; prior works allow an adversary to cause a δ \sqrt{\delta} δ extraction error by giving invalid openings with probability δ \delta δ [19 ] .
Together, these two properties allow us to reason about the residual committed state after doing multiple measurement tests. If the adversary passes all of the tests, the residual committed state must be negligibly far from a history state. We also show how the client can help the server to recover the committed state after testing it, which allows a coherent output in the overall protocol.
Our construction leverages a close connection between authentication and commitments. Essentially, we build a remote state preparation protocol for [4 ] ’s coset-state authentication code. The client can help the server to remotely authenticate any state of the server’s choice, under the client’s key. Moreover, [4 ] ’s authentication code has linear decoding, so it is compatible with our linear input-preserving 2PC. See § 2.2 for more details.
Summary of the Approach for Public Computations. Putting everything together, our approach for verifying public computations is as follows.
The server commits to a history state.
The client repeatedly runs gentle tests on the committed state by using the state-preserving 2PC for classical (linear) functions. The server inputs an opening, and the state-preserving 2PC measures only whether the opening corresponds to a valid history state.
The client asks the server to open the clock register to a time t t t .
If t < T t < T t < T , the client helps the server recover the whole ∣ ψ t ⟩ \lvert\psi_t\rangle ∣ ψ t ⟩ . Then, the server uncomputes U t ∘ ⋯ ∘ U 1 U_t \circ\cdots\circ U_1 U t ∘ ⋯ ∘ U 1 and they restart the protocol.
If t = T t = T t = T , the server sends the client’s output by opening the classical register C C C in the computational basis. Then, the client helps the server recover its output register B B B from the commitment. Register D D D is not recovered.
Wrapping Up: Privacy and Persistent Memory. So far, we have only addressed computations where the server knows the description U = ( U 1 , … , U T ) U = (U_1,\ldots,U_T) U = ( U 1 , … , U T ) and can choose the input. How can the client hide U U U from the server? And if it wants to do a follow-up computation V = ( V 1 , … , V T ′ ) V = (V_1,\ldots,V_{T'}) V = ( V 1 , … , V T ′ ) , how can it ensure that U U U ’s output ∣ ψ T ⟩ \lvert\psi_T\rangle ∣ ψ T ⟩ is used as the input to V V V ?
The first question can be addressed using quantum fully-homomorphic encryption (QFHE). Instead of directly telling the server the classical description of U U U , the client encrypts it under a QFHE as U ~ \widetilde{U} U and asks the server to homomorphically evaluate the universal circuit on U ~ \widetilde{U} U and the input. If the QFHE is circuit-private, the (honestly) evaluated output ∣ ψ T ~ ⟩ \lvert\widetilde{\psi_T}\rangle ∣ ψ T ⟩ is statistically independent of U ~ \widetilde{U} U and can be safely decrypted. There is a crucial technical subtlety for circuit privacy: the public computation needs to hide the ancillas used for QFHE evaluation. This is implemented in the 2PC by discarding register D \mathcal{D} D .
Next, we use private computation to implement persistent memory. Suppose that the client wants to perform a computation U U U , save some memory, and later use that memory for another computation V V V . Since U U U is hidden, the client may safely embed an authentication key k k k into it. The modified U ′ U' U ′ performs the original U U U , then authenticates the output ∣ ψ T ⟩ \lvert\psi_T\rangle ∣ ψ T ⟩ under k k k . This also ensures hiding of ∣ ψ T ⟩ \lvert\psi_T\rangle ∣ ψ T ⟩ between computations since quantum authentication is necessarily hiding [5 ] . Then, the client embeds k k k into V V V so that V ′ V' V ′ first verifies and decodes the authenticated ∣ ψ T ⟩ \lvert\psi_T\rangle ∣ ψ T ⟩ before using it.
Simulation Error. Our construction ultimately achieves ϵ \epsilon ϵ -simulation, meaning that for every ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) , there is 1 / ϵ 1/\epsilon 1/ ϵ -time simulator that is indistinguishable from the real execution except with probability ϵ \epsilon ϵ . This arises from the input-preserving linear 2PC and propagates through the rest of the primitives we construct. If one could achieve negligible simulation error input-preserving 2PC, then it would immediately improve the main result to also have negligible simulation error. We discuss this point further at the end of § 2.1 .
Input-Preserving 2PC for Classical Constant-Degree Polynomials
The first step to our solution is a input-preserving 2PC for classical functions f f f which are constant degree multilinear polynomials over F 2 \mathbb{F}_2 F 2 . We also extend the behavior slightly to allow the classical party to abort if f ( v ) f(\mathbf{v}) f ( v ) is not an allowed output. This addition is useful for checking the openings of our commitments: decoding applies a linear function, then checks whether a post-fix of the output is 0 \mathbf{0} 0 . In case it is not, the 2PC has measured more than is strictly necessary for decoding and so it might not be safe to return the post-measurement state. Output-checking can be easily added to our construction since the classical party gets its output before the recovery process begins for the quantum party’s output.
Simplifications. We make two simplifications for this task. First, it suffices to construct an input-preserving 2PC only for linear f f f . To upgrade to a polynomial with maximum degree c c c , the quantum party may reversibly extend its input to include all degree-c c c monomials. If c c c is constant, this is a polynomial blow-up. Then, the classical party uses the linearized version of f f f whose coefficients are all the monomials of f f f . The goal is thus to realize the following functionality:
Input: The classical client inputs a classical linear function L ∈ F 2 ℓ × m L \in\mathbb{F}_2^{\ell\times m} L ∈ F 2 ℓ × m . The quantum server inputs a superposition ∣ ψ ⟩ = ∑ v α v ∣ v ⟩ \lvert\psi\rangle= \sum_{\mathbf{v}} \alpha_{\mathbf{v}}\lvert\mathbf{v}\rangle ∣ ψ ⟩ = ∑ v α v ∣ v ⟩ .
Output: Measure u = L v \mathbf{u}=L\mathbf{v} u = L v on the quantum party’s input. Send u \mathbf{u} u to the classical party. Then, if u \mathbf{u} u is an allowed output, return the residual quantum state ∣ ψ u ⟩ ∝ ∑ v : L v = u α v ∣ v ⟩ |\psi_{\mathbf{u}}\rangle\propto\sum_{\mathbf{v}:L\mathbf{v}=\mathbf{u}}\alpha_{\mathbf{v}}|\mathbf{v}\rangle ∣ ψ u ⟩ ∝ ∑ v : L v = u α v ∣ v ⟩ to the quantum party.
Second, we show security against arbitrary malicious quantum parties, but only against honest-but-curious classical parties. An honest-but-curious party follows the protocol exactly, but may nevertheless be a QPT algorithm. Upgrading security for the classical party can be done generically [22 , 25 ] : the classical party proves in zero-knowledge for NP that each message is correctly computed. The same transformation does not work against the quantum party because the correctness of its messages are not necessarily even QMA statements. Security against a semi-honest classical party is more straightforward, so for the purposes of this overview we just describe security against a malicious quantum party.
Protocol. For the purposes of the overview, we focus on L ∈ F 2 1 × m L\in\mathbb{F}_2^{1\times m} L ∈ F 2 1 × m which only contain 1 row. The main tool we use is a noisy trapdoor claw-free function (NTCF) with the adaptive hardcore bit property [BCM+18]. Roughly, this is a 2 → 1 2\to1 2 → 1 function which can be inverted using a secret trapdoor. Moreover, the adaptive hardcore bit property guarantees that it is hard to find inner products with the difference between collisions ( x 0 ⊕ x 1 ) ⋅ d (x_0\oplus x_1)\cdot\mathbf{d} ( x 0 ⊕ x 1 ) ⋅ d , even if d \mathbf{d} d is chosen by the adversary. The protocol can be broadly separated into 4 phases.
Input Commitment. The classical party samples m m m NTCF public parameters and trapdoors ( p p i , t d i ) (\mathsf{pp}_i,\mathsf{td}_i) ( pp i , td i ) . The quantum party now commits to each bit v i v_i v i of their input v \mathbf{v} v by coherently evaluating the NTCF p p i \mathsf{pp}_i pp i on v i v_i v i and measuring the output y i y_i y i . This leaves them with the state
∑ v α v ∣ v ⟩ ⨂ i = 1 m ∣ x i , v i ⟩ \sum_{\mathbf{v}}\alpha_{\mathbf{v}}|\mathbf{v}\rangle\bigotimes_{i=1}^{m}|x_{i,v_i}\rangle v ∑ α v ∣ v ⟩ i = 1 ⨂ m ∣ x i , v i ⟩
Crucially, v \mathbf{v} v is not collapsed because the NTCF has two preimages x i , 0 x_{i,0} x i , 0 and x i , 1 x_{i,1} x i , 1 for every y i y_i y i . The quantum party sends the measured images ( y i ) i ∈ [ m ] (y_i)_{i\in[m]} ( y i ) i ∈ [ m ] to the classical party. Then, they perform a witness-preserving argument of knowledge for NP [27 ] to show knowledge of preimages ( v i , x i , v i ) (v_i,x_{i,v_i}) ( v i , x i , v i ) for each y i y_i y i , without collapsing their witness superposition .
Function Masking. The classical party uses t d i \mathsf{td}_i td i to invert each y i y_i y i into its preimages x i , 0 x_{i,0} x i , 0 and x i , 1 x_{i,1} x i , 1 , which it uses to compute Δ i = ( 0 , x i , 0 ) ⊕ ( 1 , x i , 1 ) \Delta_i=(0,x_{i,0})\oplus(1,x_{i,1}) Δ i = ( 0 , x i , 0 ) ⊕ ( 1 , x i , 1 ) . Then, it samples random d i \mathbf{d}_i d i and masks each bit of L L L as
p i = ( d i ⋅ Δ i ) ⊕ L i p_i=(\mathbf{d}_i\cdot\Delta_i)\oplus L_i p i = ( d i ⋅ Δ i ) ⊕ L i
Finally, it sends each masked bit to the classical party:
( d i , p i ) i ∈ [ m ] (\mathbf{d}_i,p_i)_{i\in[m]} ( d i , p i ) i ∈ [ m ]
Evaluation. The quantum party coherently computes the following into a fresh register, using its superposition over ∣ v i , x i , v i ⟩ \lvert v_i,\mathbf{x}_{i,v_i}\rangle ∣ v i , x i , v i ⟩ :
t = ⨁ i ( d i ⋅ ( v i , x i , v i ) ⊕ v i p i ) t = \bigoplus_i \left(\mathbf{d}_i \cdot(v_i,\mathbf{x}_{i,v_i}) \oplus v_i p_i\right) t = i ⨁ ( d i ⋅ ( v i , x i , v i ) ⊕ v i p i )
Then, it measures the result and sends t t t to the classical party.
The quantum party proves that t t t is correctly computed using a witness-preserving argument of knowledge for NP, which negligibly disturbs the superposition over ∣ v i , x i , v i ⟩ \lvert v_i,\mathbf{x}_{i,v_i}\rangle ∣ v i , x i , v i ⟩ .
Finally, the classical party computes its output u u u as
u = ( ⨁ i = 1 m d i ⋅ ( 0 , x i , 0 ) ) ⊕ t u = \left(\bigoplus_{i=1}^{m} \mathbf{d}_i \cdot(0,\mathbf{x}_{i,0})\right) \oplus t u = ( i = 1 ⨁ m d i ⋅ ( 0 , x i , 0 ) ) ⊕ t
Recovery. The quantum party measures each of its x i \mathbf{x}_i x i registers in the Hadamard basis to obtain vectors e i \mathbf{e}_i e i . It then sends these to the classical party.
The classical party sends back the following for each i i i :3
β i = e i ⋅ ( x i , 0 ⊕ x i , 1 ) \beta_i = \mathbf{e}_i \cdot(\mathbf{x}_{i,0} \oplus\mathbf{x}_{i,1}) β i = e i ⋅ ( x i , 0 ⊕ x i , 1 )
Finally, the quantum party applies Z β i Z^{\beta_i} Z β i to the i i i ’th index of its input register, for every i i i .
To generalize this to more rows, the classical party samples fresh NTCF instances for each row and the quantum party commits to v \mathbf{v} v repeatedly under each of the NTCF rows. Thus, v i v_i v i is committed to a total of ℓ \ell ℓ times. Additionally, only one recovery phase is reported for each v i v_i v i , which is the sum of the phases it incurs across the ℓ \ell ℓ rows of L L L .
Correctness and Input Preservation. At the end of the input commitment step, the quantum party holds
∑ v α v ∣ v ⟩ ⨂ i = 1 m ∣ x i , v i ⟩ \sum_{\mathbf{v}} \alpha_{\mathbf{v}} \lvert\mathbf{v}\rangle\bigotimes_{i=1}^{m} \lvert\mathbf{x}_{i,v_i}\rangle v ∑ α v ∣ v ⟩ i = 1 ⨂ m ∣ x i , v i ⟩
The next time it is modified is in the evaluation step, where
t = ⨁ i ( d i ⋅ ( v i , x i , v i ) ⊕ v i p i ) t = \bigoplus_i \left(\mathbf{d}_i \cdot(v_i,\mathbf{x}_{i,v_i}) \oplus v_i p_i\right) t = i ⨁ ( d i ⋅ ( v i , x i , v i ) ⊕ v i p i )
is measured. The trick is to show that t t t depends only on ( 0 , x i , 0 ) (0,x_{i,0}) ( 0 , x i , 0 ) and L v Lv Lv . Expanding p i = ( d i ⋅ Δ i ) ⊕ L i p_i=(d_i\cdot\Delta_i)\oplus L_i p i = ( d i ⋅ Δ i ) ⊕ L i , we find that
t = ⨁ i ( ( d i ⋅ ( v i , x i , v i ) ) ⊕ v i ( d i ⋅ Δ ) ) ⊕ ⨁ i L i v i = ⨁ i ( d i ⋅ ( ( v i , x i , v i ) ⊕ v i Δ ) ) ⊕ L v = ⨁ i ( d i ⋅ ( 0 , x i , 0 ) ) ⊕ L v \begin{aligned}
t&=\bigoplus_i\left((d_i\cdot(v_i,x_{i,v_i}))\oplus v_i(d_i\cdot\Delta)\right)\oplus\bigoplus_i L_iv_i\\
&=\bigoplus_i\left(d_i\cdot\left((v_i,x_{i,v_i})\oplus v_i\Delta\right)\right)\oplus Lv\\
&=\bigoplus_i\left(d_i\cdot(0,x_{i,0})\right)\oplus Lv
\end{aligned} t = i ⨁ ( ( d i ⋅ ( v i , x i , v i )) ⊕ v i ( d i ⋅ Δ ) ) ⊕ i ⨁ L i v i = i ⨁ ( d i ⋅ ( ( v i , x i , v i ) ⊕ v i Δ ) ) ⊕ Lv = i ⨁ ( d i ⋅ ( 0 , x i , 0 ) ) ⊕ Lv
The last simplification holds because when v i = 0 v_i=0 v i = 0 , Δ i \Delta_i Δ i is not added, and when v i = 1 v_i=1 v i = 1 , Δ i \Delta_i Δ i switches ( 1 , x i , 1 ) (1,x_{i,1}) ( 1 , x i , 1 ) to ( 0 , x i , 0 ) (0,x_{i,0}) ( 0 , x i , 0 ) . Thus, measuring t t t only disturbs the quantum party’s state by measuring L v Lv Lv , and the classical party correctly unmasks its output.
The final step to analyze is recovery . When the quantum party measures its x i x_i x i register in the Hadamard basis, it adds a phase ( − 1 ) e ⋅ x i , v i (-1)^{e\cdot x_{i,v_i}} ( − 1 ) e ⋅ x i , v i to the corresponding v i v_i v i register. If there were only one i i i , then the residual state would be
∑ v i α i , v i ( − 1 ) e ⋅ x i , v i ∣ v i ⟩ . \sum_{v_i}\alpha_{i,v_i}(-1)^{e\cdot x_{i,v_i}}\lvert v_i\rangle. v i ∑ α i , v i ( − 1 ) e ⋅ x i , v i ∣ v i ⟩ .
Factoring out a global phase ( − 1 ) e ⋅ x i , 0 (-1)^{e\cdot x_{i,0}} ( − 1 ) e ⋅ x i , 0 removes the phase when v i = 0 v_i=0 v i = 0 and changes it to a relative phase ( − 1 ) e i ⋅ ( x i , 0 ⊕ x i , 1 ) (-1)^{e_i\cdot(x_{i,0}\oplus x_{i,1})} ( − 1 ) e i ⋅ ( x i , 0 ⊕ x i , 1 ) when v i = 1 v_i=1 v i = 1 . Therefore, up to global phase the remaining state is
∑ v i α i , v i ( ( − 1 ) v i ) e i ⋅ ( x i , 0 ⊕ x i , 1 ) ∣ v i ⟩ . \sum_{v_i}\alpha_{i,v_i}((-1)^{v_i})^{e_i\cdot(x_{i,0}\oplus x_{i,1})}\lvert v_i\rangle. v i ∑ α i , v i (( − 1 ) v i ) e i ⋅ ( x i , 0 ⊕ x i , 1 ) ∣ v i ⟩ .
Therefore applying Z e i ⋅ ( x i , 0 ⊕ x i , 1 ) Z^{e_i\cdot(x_{i,0}\oplus x_{i,1})} Z e i ⋅ ( x i , 0 ⊕ x i , 1 ) removes the relative phase.
Security for 1 Column L L L . The protocol above is secure when L L L only has one column, but has a concrete attack when L L L has more. We first describe the security for one column and why it breaks down for multiple columns. then describe how to fix the attack by encoding the inputs L L L and v v v in a particular way before using them in the above protocol.
Intuitively, security relies on two parts: the extraction of the input via the argument of knowledge and the masking of L i L_i L i by a random inner product d i ⋅ Δ i d_i\cdot\Delta_i d i ⋅ Δ i . For now we assume that the quantum party’s input is temporarily exposed during the argument of knowledge and we will revisit extraction at the end of this section.
If the recovery step were skipped, then the quantum party’s input looks collapsed at the end of the protocol. In other words, it is indistinguishable whether ( v i , x i , v i ) (v_i,x_{i,v_i}) ( v i , x i , v i ) was measured during the argument of knowledge. In this case, d i ⋅ Δ i d_i\cdot\Delta_i d i ⋅ Δ i is indistinguishable from a uniformly random bit; otherwise quantum Goldreich-Levin [2 ] can be used to recover Δ \Delta Δ , which can then be combined with the measured ( v i , x i , v i ) (v_i,x_{i,v_i}) ( v i , x i , v i ) to find the other preimage of y i y_i y i .
The recovery step complicates the situation by providing an additional bit of leakage about Δ \Delta Δ . Security comes from the fact that L v Lv Lv is always measured. If L = 1 L=1 L = 1 , then v v v itself is measured. In this case, we can show using the adaptive hardcore bit property that the random inner product d ⋅ Δ \mathbf{d} \cdot\Delta d ⋅ Δ is indistinguishable from a uniform bit, even given the additional recovery leakage. Thus, we may change p p p to be an encoding of 0 0 0 instead of an encoding of L = 1 L = 1 L = 1 . Now p p p is always an encoding of 0 0 0 , regardless of L L L .
An Attack on Multiple Columns. The issue with the more general multi-column case is that the adversary can isolate individual columns using a slight variation on the honest computation of t t t .4 Suppose that the adversary chose a column i i i and added the phase
s i = ( d i ⋅ ( v i , x i , v i ) ⊕ v i p i ) s_i = \left(\mathbf{d}_i \cdot(\mathbf{v}_i,\mathbf{x}_{i,v_i}) \oplus v_i p_i\right) s i = ( d i ⋅ ( v i , x i , v i ) ⊕ v i p i )
to v i v_i v i . As we computed before, this becomes a global phase ( 0 , x i , 0 ) (0,\mathbf{x}_{i,0}) ( 0 , x i , 0 ) together with a local phase L i v i L_i v_i L i v i :
s i = ( 0 , x i , 0 ) + L i v i s_i = (0,\mathbf{x}_{i,0}) + L_i v_i s i = ( 0 , x i , 0 ) + L i v i
This allows the adversary to distinguish between two possible choices of L ( 0 ) L^{(0)} L ( 0 ) or L ( 1 ) L^{(1)} L ( 1 ) which have the same row space. Since they have the same row space, measuring L ( b ) L^{(b)} L ( b ) separates the same vectors, and so should not be distinguishable using the post-measurement state. However, the adversary can input a superposition over v \mathbf{v} v and w \mathbf{w} w such that L ( 0 ) v = L ( 0 ) w L^{(0)}\mathbf{v} = L^{(0)}\mathbf{w} L ( 0 ) v = L ( 0 ) w and L ( 1 ) v = L ( 1 ) w L^{(1)}\mathbf{v} = L^{(1)}\mathbf{w} L ( 1 ) v = L ( 1 ) w , but which differ at an index i i i where L i ( 0 ) ≠ L i ( 1 ) L_i^{(0)} \ne L_i^{(1)} L i ( 0 ) = L i ( 1 ) . In this case, applying the isolated phase at index i i i flips ∣ v ⟩ + ∣ w ⟩ |\mathbf{v}\rangle+ |\mathbf{w}\rangle ∣ v ⟩ + ∣ w ⟩ to ∣ v ⟩ − ∣ w ⟩ |\mathbf{v}\rangle- |\mathbf{w}\rangle ∣ v ⟩ − ∣ w ⟩ if and only if L ( 1 ) L^{(1)} L ( 1 ) is being computed.
Extension to Multi-Column L L L : Input Encoding. The solution is to use a redundant randomized encoding of L L L as in the input. Suppose that we encoded L L L as
L ′ = L D + R P L' = LD + RP L ′ = L D + R P
where R R R is a random matrix and there is some generator matrix G G G satisfying D G = I DG = I D G = I (D D D is a “decoding” matrix) and P G = 0 PG = 0 P G = 0 (P P P is a “parity-check” matrix). Then if we encode the quantum input as
and compute the protocol using inputs L ′ L' L ′ and v ′ v' v ′ , the output is correct:
L ′ v ′ = L ( D G ) v + R ( P G ) = L v . L'v' = L(DG)v + R(PG) = Lv. L ′ v ′ = L ( D G ) v + R ( P G ) = Lv .
The randomization term R P RP R P buys us the ability to randomize individual indices of L ′ L' L ′ . Thus, if the adversary attempts to isolate a specific column j j j of L ′ L' L ′ , the value L ∗ j L_{*j} L ∗ j will be masked by a random bit. By choosing an appropriate G G G , we can ensure that every combination of columns from L ′ L' L ′ will always be masked by a random bit, unless the adversary adds a whole row L i ∗ L_{i*} L i ∗ . However, adding a phase from an entire row L i ∗ L_{i*} L i ∗ is safe. The ideal functionality has already measured L i ∗ v L_{i*}\mathbf{v} L i ∗ v , which ensures such an attack only introduces a global phase. See the technical sections for more details on the choice of the encoding matrices.
Indistinguishable Temporary Extraction and ϵ \epsilon ϵ -Simulation. The ϵ \epsilon ϵ -error in simulation comes from the extraction of the input in the witness-preserving argument of knowledge. Intuitively, we need an extraction guarantee similar to [30 ] ’s “state-preserving extraction”, which allows extracting an NP witness while simultaneously simulating the prover’s post-argument state. Using [30 ] ’s extractor (with slight modifications described below) limits us to ϵ \epsilon ϵ -simulation5 until a construction with a better extractor is found. The new construction would necessarily need to be a super-constant round protocol to avoid the impossibility results of [14 ] .
Witness -preservation complicates matters further. Since the witness superposition must remain uncollapsed, the extractor cannot simply measure the witness during the extraction process or it has no hope of simulating the post-argument state. Instead, the best it can do is to temporarily expose the witness, then “replace” the witness after the simulator is finished. We call this indistinguishable extraction . [28 ] observes that ϵ \epsilon ϵ -indistinguishable extraction can be accomplished by applying the unitary truncation U ϵ 2 U_{\epsilon^2} U ϵ 2 of [30 ] ’s variable-runtime guaranteed extractor to [27 ] ’s argument to expose the witness, then inverting U ϵ 2 U_{\epsilon^2} U ϵ 2 to return the witness. Since there is an ϵ 2 \epsilon^2 ϵ 2 error in extraction, temporary extraction in this way causes an O ( ϵ ) O(\epsilon) O ( ϵ ) statistical disturbance of the state.
Thus, obtaining negligible simulation boils down to the following task: construct a witness-preserving argument of knowledge with strict polynomial-time guaranteed extraction.
Classical Commitments to Quantum States with Continual Binding
Next, we describe our new commitment scheme. To commit to a quantum state, the quantum sender interacts with a classical receiver. At the end of the commitment protocol, the receiver holds a commitment key c o m \mathsf{com} com and the sender holds an opening register R o p \mathcal{R}_{\mathrm{op}} R op . The sender can then measure their opening register to obtain openings to a measurement of their committed state in either the Hadamard or computational basis. Moreover, after giving (partial) openings via the input-preserving 2PC from the previous section, the receiver can help the sender to recover what remains of the committed state after these measurements.
Defining Binding. Intuitively, a commitment is binding to a quantum state if there exists a well-defined state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ whose measurement statistics match the adversary’s opening distribution. We formalize this through the real/ideal paradigm. In the ideal world, the adversary must explicitly declare the state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ which they are committing to. Then, they lose access to ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ except through a measurement oracle which represents “opening” the commitment. Ideal binding requires that some QPT simulator forces the adversary to adhere to the ideal behavior: It must extract ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ explicitly and generate an indistinguishable view for the adversary, given only access to the measurement oracle.
Continual binding extends the ideal world to permit multiple “opening”/measurement queries. This naturally tracks how the committed state ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ evolves as the simulated adversary measures it. After each measurement partially collapses the committed state, the simulator only has access to measurements on the residual state.
Authentication and Commitment. Our construction makes use of a close connection between commitments and authentication. Both protect a quantum state against undetected modification, but they differ at the encoding step. In an authentication scheme, the encoder is trusted. In a commitment scheme, the encoder is adversarial . Their goal is to change the message after committing to it and they might cheat during the encoding process to do so. Our construction bridges the adversarial encoding gap by remotely preparing authenticated states underneath a key held by the classical receiver. We use the authentication scheme of [4 ] , whose continual security was established in [26 ] . To inherit continual binding, we show that a malicious committer’s view can be simulated using only an honestly authenticated state and the oracle access permitted by the authentication guarantee. Such a simulation allows us to transform any attack on the commitment into an attack on the underlying authentication scheme.
Only a fixed resource needs to be prepared: an authenticated ∣ + ⟩ |+\rangle ∣ + ⟩ state. We first explain how the scheme’s linear decoding and homomorphic CNOT operations let us use this resource both to authenticate the committer’s chosen input and to recover the state afterward. We then address the main new challenge: preparing Auth ( ∣ + ⟩ ) \operatorname{Auth}(|+\rangle) Auth ( ∣ + ⟩) through classical interaction with the simulation guarantee needed by this reduction.
Committer’s Input Choice. Suppose for now that the classical receiver can securely prepare an authenticated ∣ + ⟩ |+\rangle ∣ + ⟩ state on the committer’s hardware. This fixed resource suffices to authenticate an arbitrary input. We first transform it into a half-authenticated EPR pair, then let the committer teleport its chosen input into the authenticated half. The receiver accounts for the teleportation corrections by updating the authentication key. Concretely:
The classical receiver helps the quantum committer to prepare an authenticated ∣ + ⟩ |+\rangle ∣ + ⟩ state.
The receiver and committer transform Auth k ( ∣ + ⟩ ) \operatorname{Auth}_k(|+\rangle) Auth k ( ∣ + ⟩) into a half-authenticated EPR pair ∑ b ∣ b ⟩ ⊗ Auth k ( ∣ b ⟩ ) \sum_b |b\rangle\otimes\operatorname{Auth}_k(|b\rangle) ∑ b ∣ b ⟩ ⊗ Auth k ( ∣ b ⟩) using a state-preserving classical 2PC with the following linear functionality: On input ( b 1 , Auth k ( b 2 ) ) (b_1,\operatorname{Auth}_k(b_2)) ( b 1 , Auth k ( b 2 )) from the quantum party and a key k k k from the classical party, the 2PC outputs c = b 1 ⊕ b 2 c=b_1\oplus b_2 c = b 1 ⊕ b 2 .
If the committer inputs ∣ + ⟩ ⊗ Auth k ( ∣ + ⟩ ) |+\rangle\otimes\operatorname{Auth}_k(|+\rangle) ∣ + ⟩ ⊗ Auth k ( ∣ + ⟩) , they will hold ∑ b ∣ b ⊕ c ⟩ ⊗ Auth k ( ∣ b ⟩ ) \sum_b |b\oplus c\rangle\otimes\operatorname{Auth}_k(|b\rangle) ∑ b ∣ b ⊕ c ⟩ ⊗ Auth k ( ∣ b ⟩) at the end of the 2PC. They can then correct the half-authenticated EPR pair by applying X c X^c X c to the plain half.
The committer teleports their chosen input ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ through the clear half into the authenticated half. They report the teleportation Pauli corrections to the receiver, who updates the authentication key k k k accordingly.
The second step uses the continual security of the underlying authentication scheme. The 2PC functionality decodes the authenticated b 2 b_2 b 2 before measuring its parity with b 1 b_1 b 1 . Continual security ensures that the authenticated register remains bound to the resulting logical state, including its entanglement with the unencoded register. Thus, the decoding query used to create the EPR pair does not invalidate the security needed for subsequent operations.
Recovery. Recovery uses the same teleportation idea in the opposite direction, but must preserve the security of the preceding interaction. Simply revealing the authentication key could expose information that distinguishes a simulated commitment from a real one. We instead release the state while keeping the key secret.
As [26 ] observe, the scheme’s homomorphic CNOT operations allow the authenticated state to be teleported through a second half-authenticated EPR pair, this time into the unencoded half. The committer sends openings to the authenticated teleportation outcomes, which the receiver decodes to determine the corrections. The receiver then communicates these corrections so that the committer can recover the state. This procedure uses only operations and decoding queries covered by the authentication scheme’s continual-security guarantee, allowing recovery to extend the preceding simulation safely.
Reducing Authentication to Coset-State Preparation. The remaining step is how to securely prepare Auth ( ∣ + ⟩ ) \operatorname{Auth}(\lvert+\rangle) Auth (∣ + ⟩) . In [4 ] ’s scheme, a computational basis state ∣ b ⟩ \lvert b\rangle ∣ b ⟩ is encoded as a random coset state
Auth k ( ∣ b ⟩ ) : = X x Z z ∣ S + b Δ ⟩ \operatorname{Auth}_k(\lvert b\rangle) := X^x Z^z \lvert S + b\Delta\rangle Auth k (∣ b ⟩) := X x Z z ∣ S + b Δ ⟩
The key k = ( x , z , S , Δ ) k = (x,z,S,\Delta) k = ( x , z , S , Δ ) specifies the subspace S S S , masking offsets ( x , z ) (x,z) ( x , z ) , and logical offset Δ \Delta Δ . Multiple qubits are encoded using the same S S S and Δ \Delta Δ , but independent masks ( x , z ) (x,z) ( x , z ) . Thus, the authenticated ∣ + ⟩ \lvert+\rangle ∣ + ⟩ state that we need to prepare is simply a random coset state
Auth k ( ∣ + ⟩ ) = X x Z z ∣ S Δ ⟩ \operatorname{Auth}_k(\lvert+\rangle) = X^x Z^z \lvert S_\Delta\rangle Auth k (∣ + ⟩) = X x Z z ∣ S Δ ⟩
of the subspace S Δ = S + Span ( Δ ) S_\Delta= S + \operatorname{Span}(\Delta) S Δ = S + Span ( Δ ) .
Remote State Preparation of Coset States
The main technical contribution of our commitment construction is a way to securely and remotely prepare such coset states. The classical sender chooses any subspace S ⊂ F 4 λ S \subset\mathbb{F}^{4\lambda} S ⊂ F 4 λ of dimension ≈ 2 λ \approx2\lambda ≈ 2 λ and helps the quantum receiver prepare a random coset state X x Z z ∣ S ⟩ X^x Z^z \lvert S\rangle X x Z z ∣ S ⟩ .6 The classical sender also learns the random masks ( x , z ) (x,z) ( x , z ) . In the commitment application, the classical sender is the commitment receiver, and the quantum receiver is the committer.
The goal of this section is to develop an RSP protocol which preserves all of the (falsifiable) security properties of coset states up to a negligible security loss. In particular, we need the binding property from [4 ] ’s authentication code to hold. A few prior works have constructed protocols for remotely preparing coset states which preserve specific security properties up to negligible loss [35 CHV23, 36 , 8 ] . However, these protocols do not preserve all security properties; indeed, the core technical contributions of [CHV23] and [8 ] are to modify [35 ] ’s and [36 ] ’s protocols to preserve additional specific properties. We obtain a wholistic solution using a simulation-based notion of security, which we describe below.
Security with Membership Oracles. The goal is for the quantum receiver R Q ∗ R_Q^* R Q ∗ to receive no more information than if it had directly received the intended state, along with some limited leakage oracles. Thus, any adversary breaking some property of coset states prepared remotely could be transformed into an adversary which breaks the same property when the coset states are received directly.
We formalize this notion via simulation. A QPT algorithm Sim receives X x Z z ∣ S ⟩ X^xZ^z|S\rangle X x Z z ∣ S ⟩ and access to membership oracles for S + x S+x S + x and S ⊥ + z S^\perp+z S ⊥ + z . Using these, it must generate a view indistinguishable from the receiver’s view in a real execution, if the distinguisher were given the final masks ( x , z ) (x,z) ( x , z ) .
Both the membership oracles and indistinguishability given ( x , z ) (x,z) ( x , z ) are chosen for compatibility with continual binding. Recall that continual binding permits decoding oracle access and binds to the residual state after each decoding query. Membership queries for S + x S+x S + x and S ⊥ + z S^\perp+z S ⊥ + z can be implemented through the computational-basis decoding and Hadamard-basis verification interfaces already covered by that guarantee. Furthermore, indistinguishability when also given ( x , z ) (x,z) ( x , z ) ensures that simulation of the preparation remains indistinguishable even when continual binding exposes additional decoding oracles dependent on the key k = ( S , Δ , x , z ) k=(S,\Delta,x,z) k = ( S , Δ , x , z ) . Consequently, the preparation simulator can be smoothly incorporated into the continual binding reduction.
A Starting Point. We first give some intuition for the construction. Suppose we instead wanted to construct states of a simpler form
This is a uniform superposition over all elements of the coset S + x S+x S + x . F 2 4 λ \mathbb{F}_2^{4\lambda} F 2 4 λ can be linearly partitioned into such cosets by multiplying with any generator matrix M S ⊥ M_{S^\perp} M S ⊥ of S ⊥ S^\perp S ⊥ . Thus, preparing a uniform superposition ∑ v ∣ v ⟩ \sum_v |v\rangle ∑ v ∣ v ⟩ and measuring M S ⊥ v M_{S^\perp}v M S ⊥ v produces a random X x ∣ S ⟩ X^x|S\rangle X x ∣ S ⟩ . Such linear measurements can be carried out underneath our state-preserving linear 2PC. The classical sender can use M S ⊥ v M_{S^\perp}v M S ⊥ v to identify a canonical element Can S ( v ) \operatorname{Can}_S(v) Can S ( v ) of S + v S+v S + v to describe the prepared state, so we refer to this measurement as measuring Can S ( v ) \operatorname{Can}_S(v) Can S ( v ) .
Unfortunately, this basic approach is not simulateable given a pre-determined X x ∣ S ⟩ X^x|S\rangle X x ∣ S ⟩ . There is no way to force the correct x x x — the adversary could even force its own x ′ x' x ′ by just inputting ∣ x ′ ⟩ |x'\rangle ∣ x ′ ⟩ into the 2PC!
Hiding x x x Through z z z . The key to removing adversarial control of x x x lies in the missing z z z . We can do the following two-step approach to (still insecurely) prepare X x Z z ∣ S ⟩ X^xZ^z|S\rangle X x Z z ∣ S ⟩ :
Sample a random 3 λ 3\lambda 3 λ -dimensional superspace T ⊃ S T \supset S T ⊃ S and prepare X z ∣ T ⊥ ⟩ X^{z}|T^{\perp}\rangle X z ∣ T ⊥ ⟩ using the starting approach. Then, apply a Hadamard to produce
Use the state-preserving linear 2PC to measure Can S ( ∙ ) \operatorname{Can}_{S}(\bullet) Can S ( ∙ ) on Z z ∣ T ⟩ Z^{z}|T\rangle Z z ∣ T ⟩ and obtain x x x .
Now x x x is drawn randomly from T T T and its marginal distribution is close to uniform since T T T is much larger than S S S . If we had set T = S T=S T = S , then we would have been stuck with just Z z ∣ S ⟩ Z^{z}|S\rangle Z z ∣ S ⟩ !
Setting T T T to be much larger than S S S not only enables x x x to coexist with z z z , it also gives a way to remove the adversary’s control of x x x . The trick is to view X z ∣ T ⊥ ⟩ X^{z}|T^{\perp}\rangle X z ∣ T ⊥ ⟩ as authenticated in the Hadamard basis . Intuitively, for a fixed S S S , the only way to find a vector in T T T (other than v ∈ S v \in S v ∈ S ) is to have actually prepared the state X z ∣ T ⊥ ⟩ X^{z}|T^{\perp}\rangle X z ∣ T ⊥ ⟩ and applied a Hadamard. This gives a method to catch cheating provers who attempt to input something other than Z z ∣ T ⟩ Z^{z}|T\rangle Z z ∣ T ⟩ in the second step: check that their input is supported on T \ S T\backslash S T \ S in the computational basis.
Construction. We also need to remove adversarial control of z z z , which can be dealt with in a similar manner using a random R ⊥ ⊃ S ⊥ R^{\perp} \supset S^{\perp} R ⊥ ⊃ S ⊥ . This gives the following three-step approach for securely preparing X x Z z ∣ S ⟩ X^{x}Z^{z}|S\rangle X x Z z ∣ S ⟩ :
The sender chooses S S S and samples R ⊂ S ⊂ T R \subset S \subset T R ⊂ S ⊂ T where dim ( R ) = λ \dim(R)=\lambda dim ( R ) = λ and dim ( T ) = 3 λ \dim(T)=3\lambda dim ( T ) = 3 λ .
The receiver prepares and inputs ∣ + 4 λ ⟩ |+^{4\lambda}\rangle ∣ + 4 λ ⟩ to a state-preserving 2PC which, on computational basis input ∣ v ⟩ |v\rangle ∣ v ⟩ , measures
x R ← Can R ( v ) x_{R} \leftarrow\operatorname{Can}_{R}(v) x R ← Can R ( v )
This results in the state X x R ∣ R ⟩ X^{x_{R}}|R\rangle X x R ∣ R ⟩ .
The receiver applies H H H to their state to get Z x R ∣ R ⊥ ⟩ Z^{x_{R}}|R^{\perp}\rangle Z x R ∣ R ⊥ ⟩ and inputs it to a state-preserving 2PC which measures
z ← { Can T ⊥ ( v ) if v ∈ R ⊥ \ S ⊥ , ⊥ else . z \leftarrow
\begin{cases}
\operatorname{Can}_{T^{\perp}}(v) & \text{if } v \in R^{\perp}\backslash S^{\perp},\\
\perp& \text{else}.
\end{cases} z ← { Can T ⊥ ( v ) ⊥ if v ∈ R ⊥ \ S ⊥ , else .
This aborts with negligible probability since S ⊥ S^{\perp} S ⊥ is much smaller than R ⊥ R^{\perp} R ⊥ . If it does not, then the receiver obtains the state Z x R X z ∣ T ⊥ ⟩ Z^{x_{R}}X^{z}|T^{\perp}\rangle Z x R X z ∣ T ⊥ ⟩ since T ⊥ ⊂ R ⊥ T^{\perp} \subset R^{\perp} T ⊥ ⊂ R ⊥ .
The receiver applies H H H to their state to get X x T Z z ∣ T ⟩ X^{x_{T}}Z^{z}|T\rangle X x T Z z ∣ T ⟩ and inputs it to a state-preserving 2PC which measures
x ← { Can S ( v ) if v ∈ ( T + x R ) \ ( S + x R ) , ⊥ else . x \leftarrow
\begin{cases}
\operatorname{Can}_{S}(v) & \text{if } v \in(T+x_{R})\backslash(S+x_{R}),\\
\perp& \text{else}.
\end{cases} x ← { Can S ( v ) ⊥ if v ∈ ( T + x R ) \ ( S + x R ) , else .
This aborts with negligible probability since S S S is much smaller than T T T . If it does not, then the receiver obtains the state X x Z z ∣ S ⟩ X^{x}Z^{z}|S\rangle X x Z z ∣ S ⟩ since S ⊂ T S \subset T S ⊂ T .
Finally, the sender outputs the ( x , z ) (x,z) ( x , z ) pair output by the second two 2PCs.
Simulation Using X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}\lvert S\rangle X x ′ Z z ′ ∣ S ⟩ . To show security, Sim must generate the receiver’s view from a prescribed X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}\lvert S\rangle X x ′ Z z ′ ∣ S ⟩ . The main challenge in doing so is that the protocol is classical:
How can Sim introduce X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}\lvert S\rangle X x ′ Z z ′ ∣ S ⟩ into the receiver’s view when the receiver expects only classical messages?
Prior works justify the insertion by observable testing and a rigidity argument that isolates a particular state on the adversary’s registers, then directly swapping that state. However, the observable tests are destructive, which introduces a poly ( 1 / N ) \operatorname{poly}(1/N) poly ( 1/ N ) distinguishing vulnerability scaling with the number of tests N N N . We design a new method which smoothly inserts X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}\lvert S\rangle X x ′ Z z ′ ∣ S ⟩ into the receiver’s view, without the protocol-dependent error.
Sim makes two general kinds of modifications to the protocol. First, it replaces each of the 2PCs with a simulated 2PC. This exposes and requires Sim to internally run the ideal functionalities for each of the 2PCs. Second, it changes those ideal functionalities fundamentally. In the first 2PC, it replaces the Can R ( ∙ ) \operatorname{Can}_{R}(\bullet) Can R ( ∙ ) measurement by a CX onto the prescribed coset state. Then, in the second 2PC, it replaces Can T ⊥ ( ∙ ) \operatorname{Can}_{T^\perp}(\bullet) Can T ⊥ ( ∙ ) measurement by a CZ onto the prescribed state, and in the third, it replaces Can S ( ∙ ) \operatorname{Can}_{S}(\bullet) Can S ( ∙ ) by another CX similarly to the first. The checks v ∈ R ⊥ ∖ S ⊥ v \in R^\perp\setminus S^\perp v ∈ R ⊥ ∖ S ⊥ and v ∈ ( T + x R ) ∖ ( S + x R ) v \in(T+xR)\setminus(S+xR) v ∈ ( T + x R ) ∖ ( S + x R ) are replaced by queries to the S ⊥ + z ′ S^\perp+z' S ⊥ + z ′ and S + x ′ S+x' S + x ′ oracles, respectively.
To see how Sim injects X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}\lvert S\rangle X x ′ Z z ′ ∣ S ⟩ into the receiver’s view, consider a receiver which behaves honestly. Figure 2 makes the intuition clear: in this case, Sim is just a SWAP gate!
Figure 2. Coset RSP Simulator , when the adversary is honest.
Indistinguishability of Sim. Of course, Sim must be indistinguishable even against a dishonest receiver. The modified checks guarantee that the sender’s output is ( x ′ , z ′ ) (x',z') ( x ′ , z ′ ) , so the state itself matches, but what about the replaced measurements and checks?
As hinted at by our technique used to hide x x x through z z z , each check goes hand-in-hand with the prior measurement. We focus just on how to replace the first 2PC’s Can R ( ∙ ) \operatorname{Can}_{R}(\bullet) Can R ( ∙ ) measurement and the second 2PC’s R ⊥ ∖ S R^\perp\setminus S R ⊥ ∖ S check; the later replacements can be done similarly.
The key to the replacement is a variant of the well-known measurement-phase equivalence: measuring Can R ( ∙ ) \operatorname{Can}_{R}(\bullet) Can R ( ∙ ) and discarding the result is equivalent to applying Z z Z^{z} Z z for a random z ← R ⊥ z \leftarrow R^\perp z ← R ⊥ . As an intuitive interpretation, measuring Can R ( ∙ ) \operatorname{Can}_{R}(\bullet) Can R ( ∙ ) only reveals a single random vector from R R R . Since R R R is a uniform superspace of S S S much smaller than the overall space F 2 n \mathbb{F}_{2}^{n} F 2 n , it is now hard for the adversary to find any element of R ⊥ R^\perp R ⊥ aside from S ⊥ + z S^\perp+z S ⊥ + z , even given S S S . Thus, we may indistinguishably shrink the R ⊥ ∖ S ⊥ R^\perp\setminus S^\perp R ⊥ ∖ S ⊥ check to just S ⊥ + z S^\perp+z S ⊥ + z .
The phase interpretation also helps with replacing the Can R ( ∙ ) \operatorname{Can}_{R}(\bullet) Can R ( ∙ ) measurement by a CX onto X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}|S\rangle X x ′ Z z ′ ∣ S ⟩ . Since X s ∣ S ⟩ = ∣ S ⟩ X^{s}|S\rangle=|S\rangle X s ∣ S ⟩ = ∣ S ⟩ for every s ∈ S s\in S s ∈ S , the next effect of the CX on any computational basis input ∣ v ⟩ |v\rangle ∣ v ⟩ is to apply X Can S ( v ) X^{\operatorname{Can}_{S}(v)} X Can S ( v ) to the prescribed state and phase-kickback z ′ z' z ′ to the input state. The marginal distribution of a random vector from R R R is statistically close to the uniform distribution of z ′ z' z ′ , so the phase behavior matches. Moreover, Sim needs to (temporarily) record x S = Can S ( v ) x_{S}=\operatorname{Can}_{S}(v) x S = Can S ( v ) anyway for the later ( T + x S ) \ ( S + x S ) (T+x_{S})\backslash(S+x_{S}) ( T + x S ) \ ( S + x S ) check.7 Therefore the classical-copying of x S x_{S} x S also matches the CX replacement.
Applications
We highlight three applications which demonstrate different aspects of our main result. Two of the three highlighted applications are well-known open problems: negligible security loss in both (1) classical verification of quantum sampling and (2) remote state preparation of arbitrary efficiently preparable states. The third is a novel application: (3) classical revocation of quantum certificates. At the end of this section, we also list a number of simpler applications implied by our main results.
Randomized Outputs: Quantum Sampling Verification. A natural first step beyond decision problems is to ask for samples from some distribution. More concretely, let D D D be the output distribution for a given a quantum circuit C C C . The task is then to verifiably produce samples from D D D .
Previously, [CLLW22] showed a classical-interaction protocol parameterized by ϵ = 1 / poly ( λ ) \epsilon=1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) which verifiably samples from a distribution D ′ D' D ′ that is ϵ \epsilon ϵ -close to D D D . This is not a big sacrifice for SampBQP, which already allows C C C 's distribution D D D to differ from the target distribution D ∗ D^{*} D ∗ by a 1 / poly ( λ ) 1/\operatorname{poly}(\lambda) 1/ poly ( λ ) amount. However, for cases where C C C can sample exactly from the target distribution D ∗ D^{*} D ∗ , any non-negligible loss is undesirable.
Our 2PC allows directly implementing the circuit C C C without dependence on any ϵ \epsilon ϵ , yet with the guarantee that the classical party's output is ϵ \epsilon ϵ -computationally indistinguishable from a true execution of C C C for every ϵ = 1 / poly ( λ ) \epsilon=1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . Therefore the classical party obtains samples from a distribution D ′ D' D ′ whose computational distance from D D D is smaller than every 1 / poly ( λ ) 1/\operatorname{poly}(\lambda) 1/ poly ( λ ) – in other words, negligible.
Sending States: Remote State Preparation. Remote state preparation (RSP) allows a classical client to send a quantum message, thereby replacing a quantum party in a non-interactive quantum protocol. For example, [24 ] allow a classical verifier to participate in a quantum blind delegation protocol, while [20 ] allow a classical verifier to send an unclonable quantum ciphertext.
So far, existing constructions have had two limitations. First, they are limited to preparing specific families of states and the sender cannot the exact state to prepare, e.g. it can decide the basis X X X or Z Z Z , but cannot pick between ∣ + ⟩ |+\rangle ∣ + ⟩ and ∣ − ⟩ |-\rangle ∣ − ⟩ . Restrictions on preparable states limit the protocols for which RSP can replace a quantum party. Second, their protocols take 1 / ϵ 1/\epsilon 1/ ϵ time to reduce the soundness error to ϵ \epsilon ϵ . Many cryptographic protocols require negligible security loss, which a ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) error can overwhelm entirely.
Our 2PC allows directly implementing any efficient preparation procedure, resolving both limitations. Concretely, given any quantum game G Q G_Q G Q where one of the parties sends one quantum message then becomes classical, our 2PC can replace that party with a classical party to produce a new game G C G_C G C . It then guarantees than any QPT adversary that wins G C G_C G C with probability δ \delta δ can be turned into an adversary for G Q G_Q G Q with time blow-up 1 / ϵ 1/\epsilon 1/ ϵ which also wins G Q G_Q G Q with probability ≥ δ + ϵ \ge\delta+ \epsilon ≥ δ + ϵ . Crucially, ϵ \epsilon ϵ can be tuned independently of G C G_C G C itself. Since every ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) still results in a QPT adversary, the increase in winning probability between G C G_C G C and G Q G_Q G Q must be negligible:
max Q P T A Pr [ win G C ( A ) ] ≤ max Q P T A Pr [ win G Q ( A ) ] + negl ( λ ) \max_{\mathrm{QPT}\ A} \Pr[\operatorname{win}\ G_C(A)] \le\max_{\mathrm{QPT}\ A} \Pr[\operatorname{win}\ G_Q(A)] + \operatorname{negl}(\lambda) QPT A max Pr [ win G C ( A )] ≤ QPT A max Pr [ win G Q ( A )] + negl ( λ )
The replacement can occur regardless of the precise states to be sent. Indeed, we later give several explicit applications where more complicated states must be sent.
Quantum Storage: Classical Revocation of Quantum Certificates. Our final highlighted application allows receiving, checking, and confiscating quantum states. For example, consider securely leasing a PKE decryption key as a quantum state [3 ] . The party borrowing the quantum key can return a certificate (which may be the quantum key itself), and, if the certificate is valid, then the party who borrowed the key becomes unable to decrypt any future ciphertexts. Although there do exist ways to generate a classical certificate of revocation, in many cases it is easier in constructions to directly return the key itself.
Our result gives a way for a classical party to generically revoke keys even when the certificate is a quantum state. They can run our 2PC to receive and check the certificate, then discard the remaining state. Our 2PC security guarantees that the discarded state computationally disappears from the server’s view, allowing the original secure key leasing security to kick in. Since the secure key leasing decryption security game can be ϵ \epsilon ϵ -approximated by the simulator for every ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) , any adversarial lessor’s advantage in decrypting ciphertexts after revocation must be less than ϵ \epsilon ϵ – in other words, negligible.
Other Applications. We provide details here about the other previously mentioned example applications.
Semi-Quantum Unclonable Encryption. Unclonable encryption ensures that a ciphertext cannot be split into two parts, each of which can simultaneously be decrypted using the decryption key. Our remote state preparation application allows a classical client to send the quantum ciphertext while incurring only a negligible loss in the cloning security game. This answers an open problem by [20 ] .
states using only classical interaction with the quantum recipient, assuming iO and subexponentially hard LWE. By using our protocol to send banknotes for Zhandry’s PKQM scheme [39 ] , we obtain the same primitive from weaker assumptions: iO and the polynomial hardness of LWE.
Proofs of No-Intrusion for Decryption Keys. [23 ] gave a classical-communication protocol for non-destructively testing whether a quantum ciphertext has been stolen from an external server. Beyond ciphertexts, one can also check decryption keys. Our result allows generically compiling any secure key leasing scheme with publicly verifiable revocation in an oracle model to achieve this. Notably, SKL with public verifiability in an oracle model does not imply public-key quantum money in the plain model, so we can hope to achieve this from weaker assumptions. The outline is similar to classical revocation of quantum certificates, except that the certificate is coherently returned to the prover after the 2PC, instead of being confiscated.
Improved Extraction in CVQC for QMA. The quality of an extractor can be measured by the difference between the probability that the prover passes the CVQC and the extracted state passes QMA verification (extraction error), the minimum probability with which the prover must pass for this guarantee to hold (knowledge error), and the difference between the number of witness copies required for an honest prover and the number extracted (copy error). Prior works incurred either 1 / poly ( T ) 1/\operatorname{poly}(T) 1/ poly ( T ) extraction error in a protocol with T T T rounds and 0 copy error, or negligible extraction error and O ( λ ) O(\lambda) O ( λ ) copy error [37 , 27 ] .
By directly implementing a QMA verifier using our 2PC, we obtain a classical argument of knowledge for QMA with 0 copy error and whose extraction error depends on the amount of time one is willing to run the extractor for, not on the original protocol. In particular, any ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) extraction error can be achieved by running the extractor for 1 / poly ( ϵ ) 1/\operatorname{poly}(\epsilon) 1/ poly ( ϵ ) time. Moreover, given a single copy of any witness which would pass QMA verification with probability α \alpha α , the prover passes CVQC verification with probability α − negl ( λ ) \alpha- \operatorname{negl}(\lambda) α − negl ( λ ) . [27 ] left this as an open problem for α \alpha α bounded away from 1.
Quantum Obfuscation with Interactive Classical Communication. A series of works have constructed obfuscation for various types of quantum circuits. For any of these schemes where the circuit C C C to be obfuscated has a classical description, a classical computer may obfuscate and send C C C by interacting classically with the quantum recipient using our 2PC. In particular, the obfuscation retains any falsifiable guarantees when compiled in this manner. For example, an indistinguishability obfuscator still satisfies the full notion of indistinguishability obfuscation – that is, iO ( C 1 ) \operatorname{iO}(C_1) iO ( C 1 ) is negligibly distinguishable from iO ( C 2 ) \operatorname{iO}(C_2) iO ( C 2 ) so long as C 1 C_1 C 1 and C 2 C_2 C 2 are functionally equivalent.
We leave open the question of obtaining a non-interactive classical obfuscation procedure.
AI Disclosure.
ChatGPT 6.0 was used to proofread and make edits to this paper during writing. It was also used to generate starting text for the applications section, which was subsequently edited by the authors. It found a bug in the original input-preserving 2PC for linear classical functions (see § 2.1 ) and suggested a fix for it, together with a revised proof. The authors have checked the proof carefully before incorporating it, and take responsibility for all technical content presented in this paper.
Preliminaries
Notation and Conventions
λ \lambda λ is the security parameter.
Quantum Circuits. A unitary circuit U = U T ∘ ⋯ U 1 U = U_T \circ\cdots U_1 U = U T ∘ ⋯ U 1 is composed of unitary gates ( U 1 , … , U T ) (U_1, \ldots, U_T) ( U 1 , … , U T ) applied in sequence to an input register S \mathcal{S} S and an ancilla register A \mathcal{A} A , initialized to ∣ 0 a ⟩ \lvert0^{a} \rangle ∣ 0 a ⟩ . A general quantum circuit additionally specifies the following output registers: a coherent output register B \mathcal{B} B , a measured output register C \mathcal{C} C , and a discarded register D \mathcal{D} D . U U U is applied to S \mathcal{S} S and A \mathcal{A} A to produce ( B , C , D ) (\mathcal{B}, \mathcal{C}, \mathcal{D}) ( B , C , D ) , then C \mathcal{C} C is measured in the computational basis and D \mathcal{D} D is discarded. Any advice is incorporated into the input. See Figure 3 .
Figure 3. A General Quantum Circuit
Throughout this work, we will by default consider real unitary gates. Any quantum circuit may be generically converted into a real version, with some additional encoding of the input [BV93].
Quantum Turing Machines. A quantum Turing machine M = ( U , Π E n d ) M = (U, \Pi_{\mathrm{End}}) M = ( U , Π End ) consists of a transition unitary U U U and an end-state projector Π E n d \Pi_{\mathrm{End}} Π End . It is evaluated on a state ρ \rho ρ in register I \mathcal{I} I by initializing a work register W \mathcal{W} W to ∣ 0 ⟩ \lvert0 \rangle ∣ 0 ⟩ , then alternating U U U and the termination measurement { Π E n d , I − Π E n d } \{\Pi_{\mathrm{End}}, I - \Pi_{\mathrm{End}}\} { Π End , I − Π End } on ( I , W ) (\mathcal{I}, \mathcal{W}) ( I , W ) until the termination measurement returns Π E n d \Pi_{\mathrm{End}} Π End . The runtime of M ( ρ ) M(\rho) M ( ρ ) is the number of applications of U U U before termination.
Quantum Algorithms. A QPT algorithm is a family of poly ( n ) \operatorname{poly}(n) poly ( n ) -sized unitary circuits { U n } n ∈ N \{U_n\}_{n\in\mathbb{N}} { U n } n ∈ N .8 It is uniform if the family is generated via a deterministic polynomial-time (classical) Turing machine. An expected QPT algorithm is a quantum Turing machine such that for all n n n -qubit inputs ρ \rho ρ , the expected runtime of M ( ρ ) M(\rho) M ( ρ ) is poly ( n ) \operatorname{poly}(n) poly ( n ) .
Adversarial Model. We consider QPT adversaries which are non-uniform QPT algorithms with non-uniform quantum advice (auxiliary input) { ρ λ } λ ∈ N \{\rho_\lambda\}_{\lambda\in\mathbb{N}} { ρ λ } λ ∈ N . We often omit explicitly mentioning the advice.
For any two distribution ensembles D = { D λ } λ ∈ N \mathcal{D}=\{\mathcal{D}_\lambda\}_{\lambda\in\mathbb{N}} D = { D λ } λ ∈ N and D ′ = { D λ ′ } λ ∈ N \mathcal{D}'=\{\mathcal{D}'_\lambda\}_{\lambda\in\mathbb{N}} D ′ = { D λ ′ } λ ∈ N , we use D ≡ D ′ \mathcal{D}\equiv\mathcal{D}' D ≡ D ′ to denote that these distribution ensembles are statistically close, and use D ≈ D ′ \mathcal{D}\approx\mathcal{D}' D ≈ D ′ to denote that they are computationally indistinguishable by any QPT distinguisher with auxiliary input. When an adversary A λ A_\lambda A λ is used to define the distributions, their auxiliary input may be entangled with the distinguisher’s. We use D ≈ ε D ′ \mathcal{D}\overset{\varepsilon}{\approx}\mathcal{D}' D ≈ ε D ′ to denote that the distributions may be computationally distinguished with at most probability ε + negl ( λ ) \varepsilon+\operatorname{negl}(\lambda) ε + negl ( λ ) .
When comparing real numbers, a ≈ b a\approx b a ≈ b denotes that ∣ a − b ∣ = negl ( λ ) |a-b|=\operatorname{negl}(\lambda) ∣ a − b ∣ = negl ( λ ) , i.e. it drops negligible differences. We frequently use a ≈ negl ( λ ) b a\approx_{\operatorname{negl}(\lambda)}b a ≈ negl ( λ ) b to be explicit about the dropped difference.
Other Notation. We also define some quantum-specific notation.
For any q q q -qubit quantum state ρ \rho ρ and string b ∈ { 0 , 1 } q \mathbf{b}\in\{0,1\}^{q} b ∈ { 0 , 1 } q , we denote by m ← Measure ( b , ρ ) \mathbf{m}\leftarrow\operatorname{Measure}(\mathbf{b},\rho) m ← Measure ( b , ρ ) the result of measuring ρ \rho ρ according to the basis b \mathbf{b} b , where b i = 0 b_i=0 b i = 0 corresponds to the Z Z Z basis, b i = 1 b_i=1 b i = 1 corresponds to the X X X basis.
For more general measurements, we use the following notation. Let U U U be a quantum unitary on n n n qubits and let f : { 0 , 1 } n → { 0 , 1 } m f:\{0,1\}^{n}\to\{0,1\}^{m} f : { 0 , 1 } n → { 0 , 1 } m be a classical function. We denote the projective measurement
M [ f , U ] = { U † ( ∑ x : f ( x ) = y ∣ x ⟩ ⟨ x ∣ ) U } y ∈ { 0 , 1 } m M[f,U]=\left\{U^\dagger\left(\sum_{x:f(x)=y}|x\rangle\langle x|\right)U\right\}_{y\in\{0,1\}^{m}} M [ f , U ] = ⎩ ⎨ ⎧ U † x : f ( x ) = y ∑ ∣ x ⟩ ⟨ x ∣ U ⎭ ⎬ ⎫ y ∈ { 0 , 1 } m
When f f f is the identity, we write M [ U ] = M [ I , U ] M[U]=M[I,U] M [ U ] = M [ I , U ] to denote measuring all of the qubits in the basis defined by U U U .
History States
History States. Kitaev’s proof that the local Hamiltonian problem is QMA-complete makes use of history states . Intuitively, a history state tracks how a quantum computation U = U t ⋯ U 1 U = U_t \cdots U_1 U = U t ⋯ U 1 evolves over time by being in superposition over the states of the system ∣ t ⟩ ⊗ U ≤ t ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) |t\rangle\otimes U_{\leq t}(|\psi\rangle\otimes|0^a\rangle) ∣ t ⟩ ⊗ U ≤ t ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩) at time t t t , where ∣ 0 a ⟩ |0^a\rangle ∣ 0 a ⟩ are the ancilla registers used in the computation. The time t t t is encoded in unary: for T ≥ 1 T \geq1 T ≥ 1 and t ∈ { 0 , … , T } t \in\{0,\ldots,T\} t ∈ { 0 , … , T } , define t 1 , T ∈ { 0 , 1 } T t_{1,T} \in\{0,1\}^T t 1 , T ∈ { 0 , 1 } T to be the unary encoding
t 1 , T = 1 t 0 T − t . t_{1,T}=1^t0^{T-t}. t 1 , T = 1 t 0 T − t .
Definition 1 ([29 ] ). Fix any quantum circuit C C C that takes as input a state of the form ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ |\psi\rangle\otimes|0^a\rangle ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ , where the last a a a qubits are ancillas that are initialized to 0 0 0 , and consists of T T T gates U 1 , … , U T U_1,\ldots,U_T U 1 , … , U T . Then for any input state ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ |\psi\rangle\otimes|0^a\rangle ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ , we define the history state of C C C on ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ |\psi\rangle\otimes|0^a\rangle ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ to be
Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) = 1 T + 1 ∑ t = 0 T U ≤ t ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) ⊗ ∣ t 1 , T ⟩ . \operatorname{Hist}_{C}(|\psi\rangle\otimes|0^a\rangle)=\frac{1}{\sqrt{T+1}}\sum_{t=0}^{T}U_{\leq t}(|\psi\rangle\otimes|0^a\rangle)\otimes|t_{1,T}\rangle. Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩) = T + 1 1 t = 0 ∑ T U ≤ t ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩) ⊗ ∣ t 1 , T ⟩ . where U ≤ 0 = I U_{\leq0}=I U ≤ 0 = I and U ≤ t = U t U t − 1 ⋯ U 1 U_{\leq t}=U_tU_{t-1}\cdots U_1 U ≤ t = U t U t − 1 ⋯ U 1 for 1 ≤ t ≤ T 1 \leq t \leq T 1 ≤ t ≤ T . Define the unitary U H i s t C U_{\mathrm{Hist}_C} U Hist C (defined on the legal-clock subspace) to be
U H i s t C = ∑ t = 0 T U ≤ t ⊗ ∣ t 1 , T ⟩ ⟨ t 1 , T ∣ . U_{\mathrm{Hist}_C}=\sum_{t=0}^{T}U_{\leq t}\otimes|t_{1,T}\rangle\langle t_{1,T}|. U Hist C = t = 0 ∑ T U ≤ t ⊗ ∣ t 1 , T ⟩ ⟨ t 1 , T ∣. Note that
U H i s t C ( ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) ⊗ 1 T + 1 ∑ t = 0 T ∣ t 1 , T ⟩ ) = Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) . U_{\mathrm{Hist}_C}\left((|\psi\rangle\otimes|0^a\rangle)\otimes\frac{1}{\sqrt{T+1}}\sum_{t=0}^{T}|t_{1,T}\rangle\right)=\operatorname{Hist}_{C}(|\psi\rangle\otimes|0^a\rangle). U Hist C ( ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩) ⊗ T + 1 1 t = 0 ∑ T ∣ t 1 , T ⟩ ) = Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩) .
Kitaev showed a local Hamiltonian where history state of a computation C C C is a low-energy state. The Hamiltonian H H i s t H_{\mathrm{Hist}} H Hist is comprised of several parts. H i n H_{\mathrm{in}} H in checks that the input ancillas are correctly initialized to ∣ 0 a ⟩ |0^a\rangle ∣ 0 a ⟩ , H f o r m a t H_{\mathrm{format}} H format checks that the clock is correctly formatted, and H p r o p H_{\mathrm{prop}} H prop checks that each step of the computation is done correctly. In the context of QMA, there is also a term H o u t H_{\mathrm{out}} H out which checks that the output is accepting. We explicitly omit H o u t H_{\mathrm{out}} H out from the Hamiltonian H H H for this work. As a result, H H i s t H_{\mathrm{Hist}} H Hist always has a non-empty kernel.
Theorem 2 (Feynman-Kitaev history Hamiltonian and X/Z test). [29 , 16 ] Let C = ( U 1 , … , U T ) C=(U_1,\ldots,U_T) C = ( U 1 , … , U T ) be a quantum circuit of constant-local gates that uses a a a ancilla qubits that are initialized to 0 0 0 .9 There is a constant-local Hamiltonian
H H i s t ( C ) = H f o r m a t + H p r o p + H i n = ∑ j = 1 M Π C , j , M = O ( T ) , H_{\mathrm{Hist}}(C)=H_{\mathrm{format}}+H_{\mathrm{prop}}+H_{\mathrm{in}}=\sum_{j=1}^{M}\Pi_{C,j},\qquad M=O(T), H Hist ( C ) = H format + H prop + H in = j = 1 ∑ M Π C , j , M = O ( T ) , with H o u t H_{\mathrm{out}} H out omitted, where every Π C , j \Pi_{C,j} Π C , j is a projector,
ker H H i s t ( C ) = span { Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) : ∣ ψ ⟩ } , \operatorname{ker}H_{\mathrm{Hist}}(C)=\operatorname{span}\{\operatorname{Hist}_{C}(|\psi\rangle\otimes|0^a\rangle):|\psi\rangle\}, ker H Hist ( C ) = span { Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩) : ∣ ψ ⟩} ,
and there exists a universal constant c > 0 c > 0 c > 0 such that for G : = ∏ ker H H i s t ( C ) G := \prod_{\ker} H_{\mathrm{Hist}}(C) G := ∏ k e r H Hist ( C ) ,
H H i s t ( C ) ⪰ c ( T + 1 ) 2 ( I − G ) , H_{\mathrm{Hist}}(C) \succeq\frac{c}{(T+1)^2}(I-G), H Hist ( C ) ⪰ ( T + 1 ) 2 c ( I − G ) ,
If, in addition, every U t U_t U t is Hermitian and diagonal in either the X X X or the Z Z Z basis, then for every j j j there are a product X / Z X/Z X / Z basis θ j \theta_j θ j and a constant-size predicate g j g_j g j such that
Π C , j = H θ j ( ∑ z : g j ( z ) = 1 ∣ z ⟩ ⟨ z ∣ ) H θ j . (1) \Pi_{C,j}=H^{\theta_j}\left(\sum_{z:g_j(z)=1}|z\rangle\langle z|\right)H^{\theta_j}. \tag*{(1)} Π C , j = H θ j z : g j ( z ) = 1 ∑ ∣ z ⟩ ⟨ z ∣ H θ j . (1)
Remark 2. An immediate consequence of Theorem 2 is the following: Consider the test that samples j ← [ M ] j \leftarrow[M] j ← [ M ] , performs the projective measurement { Π C , j , I − Π C , j } \{\Pi_{C,j},I-\Pi_{C,j}\} { Π C , j , I − Π C , j } , and rejects on outcome 1. Then for every state ρ \rho ρ ,
Pr j ← [ M ] [ r e j e c t ] = 1 M Tr ( H H i s t ( C ) ρ ) ≥ c M ( T + 1 ) 2 Tr ( ( I − G ) ρ ) . \Pr_{j\leftarrow[M]}[\mathrm{reject}]=\frac{1}{M}\operatorname{Tr}(H_{\mathrm{Hist}}(C)\rho)\ge\frac{c}{M(T+1)^2}\operatorname{Tr}((I-G)\rho). j ← [ M ] Pr [ reject ] = M 1 Tr ( H Hist ( C ) ρ ) ≥ M ( T + 1 ) 2 c Tr (( I − G ) ρ ) . Namely, the probability of rejection is at least an inverse-polynomial multiple of the weight of ρ \rho ρ outside the history-state subspace. In addition, every valid history state is accepted with probability 1.
For our work we need each local Hamiltonian term Π C , j \Pi_{C,j} Π C , j to be diagonal in a product X / Z X/Z X / Z basis. Fitzsimons, Hajdušek, and Morimae [18 ] gave a test for measuring the energy of X Z XZ X Z Hamiltonians using only single-qubit X / Z X/Z X / Z measurements whose acceptance probability is determined by the energy of an X Z XZ X Z Hamiltonian: the verifier samples a Pauli term from the Hamiltonian and measures that term. This does not directly implement the individual Feynman–Kitaev projectors and does not have perfect completeness. We instead restrict to circuits over the gate set G X Z \mathcal{G}_{XZ} G X Z , defined by
G X Z = { X , C Z , C C Z , G ^ } where G ^ = ( H ⊗ H ) C Z ( H ⊗ H ) . \mathcal{G}_{XZ}=\{X,CZ,CCZ,\widehat{G}\}\quad\text{where}\quad\widehat{G}=(H\otimes H)CZ(H\otimes H). G X Z = { X , C Z , C C Z , G } where G = ( H ⊗ H ) C Z ( H ⊗ H ) .
Building on an observation of Ma and Natarajan [34 ] , the Feynman–Kitaev projectors for such circuits are diagonal in product X / Z X/Z X / Z bases, yielding the perfect-completeness test below.10
Corollary 4 (Perfect-completeness X / Z X/Z X / Z test for history states). Let C = ( U 1 , … , U T ) C=(U_1,\ldots,U_T) C = ( U 1 , … , U T ) be a quantum circuit, where each U j ∈ G X Z U_j\in\mathcal{G}_{XZ} U j ∈ G X Z , and let H H i s t ( C ) = ∑ j = 1 M Π C , j H_{\mathrm{Hist}}(C)=\sum_{j=1}^{M}\Pi_{C,j} H Hist ( C ) = ∑ j = 1 M Π C , j . Then the following holds:
Pr j ← [ M ] [ Π C , j ( Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) ) = 0 ] = 1. \Pr_{j \leftarrow[M]}\left[\Pi_{C,j}\left(\operatorname{Hist}_{C}\left(|\psi\rangle\otimes|0^{a}\rangle\right)\right)=0\right]=1. j ← [ M ] Pr [ Π C , j ( Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) ) = 0 ] = 1.
Pr j ← [ M ] [ Π C , j ( ρ ) = 1 ] = 1 M Tr ( H H i s t ( C ) ρ ) ≥ c M ( T + 1 ) 2 Tr ( ( I − G ) ρ ) . \Pr_{j \leftarrow[M]}[\Pi_{C,j}(\rho)=1]=\frac{1}{M}\operatorname{Tr}(H_{\mathrm{Hist}}(C)\rho)\geq\frac{c}{M(T+1)^2}\operatorname{Tr}((I-G)\rho). j ← [ M ] Pr [ Π C , j ( ρ ) = 1 ] = M 1 Tr ( H Hist ( C ) ρ ) ≥ M ( T + 1 ) 2 c Tr (( I − G ) ρ ) .
where G G G is the projector onto the kernel of H H i s t ( C ) H_{\mathrm{Hist}}(C) H Hist ( C ) .
Corollary 4 implies the following theorem.
Theorem 3 (Repeated history-state test). Let C = ( U 1 , … , U T ) C=(U_1,\ldots,U_T) C = ( U 1 , … , U T ) be a quantum circuit, where each U j ∈ G X Z U_j\in\mathcal{G}_{XZ} U j ∈ G X Z , and let
H H i s t ( C ) = ∑ j = 1 M Π C , j ; G : = Π ker H H i s t ( C ) . H_{\mathrm{Hist}}(C)=\sum_{j=1}^{M}\Pi_{C,j};\qquad G:=\Pi_{\ker H_{\mathrm{Hist}}(C)}. H Hist ( C ) = j = 1 ∑ M Π C , j ; G := Π k e r H Hist ( C ) . Consider the test that given a state ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ , independently repeats the following r = M ⋅ ( T + 1 ) 2 ⋅ λ r=M\cdot(T+1)^2\cdot\lambda r = M ⋅ ( T + 1 ) 2 ⋅ λ times: sample j ← [ M ] j\leftarrow[M] j ← [ M ] , apply the X/Z projection { I − Π C , j , Π C , j } \{I-\Pi_{C,j},\Pi_{C,j}\} { I − Π C , j , Π C , j } , and abort on the second outcome. Let p a c c p_{\mathrm{acc}} p acc be the probability that all tests accept and let ρ a c c \rho_{\mathrm{acc}} ρ acc be the residual state conditioned on acceptance, averaged over the sampled indices. Then for γ = c ( T + 1 ) 2 \gamma=\frac{c}{(T+1)^2} γ = ( T + 1 ) 2 c where c ∈ N c\in\mathbb{N} c ∈ N is the constant from Theorem 2,
p a c c − ∥ G ∣ ψ ⟩ ∥ 2 ≤ ( 1 − γ M ) r ≤ e − γ r / M . p_{\mathrm{acc}}-\|G|\psi\rangle\|^2\leq\left(1-\frac{\gamma}{M}\right)^r\leq e^{-\gamma r/M}. p acc − ∥ G ∣ ψ ⟩ ∥ 2 ≤ ( 1 − M γ ) r ≤ e − γ r / M . Moreover, if G ∣ ψ ⟩ ≠ 0 G|\psi\rangle\ne0 G ∣ ψ ⟩ = 0 , then, for ∣ h ⟩ : = G ∣ ψ ⟩ / ∥ G ∣ ψ ⟩ ∥ |h\rangle:=G|\psi\rangle/\|G|\psi\rangle\| ∣ h ⟩ := G ∣ ψ ⟩ /∥ G ∣ ψ ⟩ ∥ ,
1 2 ∥ ρ a c c − ∣ h ⟩ ⟨ h ∣ ∥ 1 ≤ e − γ r / M p a c c . \frac{1}{2}\|\rho_{\mathrm{acc}}-|h\rangle\langle h|\|_1\leq\sqrt{\frac{e^{-\gamma r/M}}{p_{\mathrm{acc}}}}. 2 1 ∥ ρ acc − ∣ h ⟩ ⟨ h ∣ ∥ 1 ≤ p acc e − γ r / M . Consequently, if p a c c ≥ 1 / poly ( λ ) p_{\mathrm{acc}}\geq1/\operatorname{poly}(\lambda) p acc ≥ 1/ poly ( λ ) , then ρ a c c \rho_{\mathrm{acc}} ρ acc is negligibly close to a valid history state.
Proof. Note that
image ( G ) = ⋂ j = 1 M ker ( Π C , j ) , \operatorname{image}(G)=\bigcap_{j=1}^{M}\ker(\Pi_{C,j}), image ( G ) = j = 1 ⋂ M ker ( Π C , j ) ,
Let P j = I − Π C , j P_j=I-\Pi_{C,j} P j = I − Π C , j and Q : = I − G Q:=I-G Q := I − G . By Corollary 1, for every ∣ ϕ ⟩ ∈ image ( Q ) |\phi\rangle\in\operatorname{image}(Q) ∣ ϕ ⟩ ∈ image ( Q ) ,
E j ← [ M ] ∥ P j ∣ ϕ ⟩ ∥ 2 = E j ← [ M ] ∥ ( I − Π C , j ) ∣ ϕ ⟩ ∥ 2 = ∥ ϕ ∥ 2 − 1 M ⟨ ϕ ∣ H H i s t ( C ) ∣ ϕ ⟩ ≤ ( 1 − γ M ) ∥ ϕ ∥ 2 . \mathbb{E}_{j\leftarrow[M]}\|P_j|\phi\rangle\|^2=\mathbb{E}_{j\leftarrow[M]}\|(I-\Pi_{C,j})|\phi\rangle\|^2=\|\phi\|^2-\frac{1}{M}\langle\phi|H_{\mathrm{Hist}}(C)|\phi\rangle\leq\left(1-\frac{\gamma}{M}\right)\|\phi\|^2. E j ← [ M ] ∥ P j ∣ ϕ ⟩ ∥ 2 = E j ← [ M ] ∥ ( I − Π C , j ) ∣ ϕ ⟩ ∥ 2 = ∥ ϕ ∥ 2 − M 1 ⟨ ϕ ∣ H Hist ( C ) ∣ ϕ ⟩ ≤ ( 1 − M γ ) ∥ ϕ ∥ 2 .
For for any j = ( j 1 , … , j r ) ∈ [ M ] r \mathbf{j}=(j_1,\ldots,j_r)\in[M]^r j = ( j 1 , … , j r ) ∈ [ M ] r , denote by K j : = P j r ⋯ P j 1 K_{\mathbf{j}}:=P_{j_r}\cdots P_{j_1} K j := P j r ⋯ P j 1 . Using this notation, the equation above implies that
E j ∥ K j Q ∣ ψ ⟩ ∥ 2 ≤ ( 1 − γ M ) r ∥ Q ∣ ψ ⟩ ∥ 2 . \mathbb{E}_{\mathbf{j}}\left\|K_{\mathbf{j}}Q|\psi\rangle\right\|^2\leq\left(1-\frac{\gamma}{M}\right)^r\left\|Q|\psi\rangle\right\|^2. E j ∥ K j Q ∣ ψ ⟩ ∥ 2 ≤ ( 1 − M γ ) r ∥ Q ∣ ψ ⟩ ∥ 2 .
Moreover,
K j ∣ ψ ⟩ = G ∣ ψ ⟩ + K j Q ∣ ψ ⟩ , K_{\mathbf{j}}|\psi\rangle=G|\psi\rangle+K_{\mathbf{j}}Q|\psi\rangle, K j ∣ ψ ⟩ = G ∣ ψ ⟩ + K j Q ∣ ψ ⟩ ,
and the two summands are orthogonal. Hence
p a c c = ∥ G ∣ ψ ⟩ ∥ 2 + E j ∥ K j Q ∣ ψ ⟩ ∥ 2 , p_{\mathrm{acc}}=\left\|G|\psi\rangle\right\|^2+\mathbb{E}_{\mathbf{j}}\left\|K_{\mathbf{j}}Q|\psi\rangle\right\|^2, p acc = ∥ G ∣ ψ ⟩ ∥ 2 + E j ∥ K j Q ∣ ψ ⟩ ∥ 2 ,
and therefore
p a c c − ∥ G ∣ ψ ⟩ ∥ 2 ≤ ( 1 − γ M ) r ≤ e − γ r / M . p_{\mathrm{acc}}-\left\|G|\psi\rangle\right\|^2\leq\left(1-\frac{\gamma}{M}\right)^r\leq e^{-\gamma r/M}. p acc − ∥ G ∣ ψ ⟩ ∥ 2 ≤ ( 1 − M γ ) r ≤ e − γ r / M .
Suppose that G ∣ ψ ⟩ ≠ 0 G|\psi\rangle\ne0 G ∣ ψ ⟩ = 0 , and let
∣ h ⟩ : = G ∣ ψ ⟩ ∥ G ∣ ψ ⟩ ∥ . |h\rangle:=\frac{G|\psi\rangle}{\left\|G|\psi\rangle\right\|}. ∣ h ⟩ := ∥ G ∣ ψ ⟩ ∥ G ∣ ψ ⟩ .
The conditioned residual state is
ρ a c c = 1 p a c c E j [ K j ∣ ψ ⟩ ⟨ ψ ∣ K j † ] . \rho_{\mathrm{acc}}=\frac{1}{p_{\mathrm{acc}}}\mathbb{E}_{\mathbf{j}}\left[K_{\mathbf{j}}|\psi\rangle\langle\psi|K_{\mathbf{j}}^\dagger\right]. ρ acc = p acc 1 E j [ K j ∣ ψ ⟩ ⟨ ψ ∣ K j † ] .
The fact that K j † ∣ h ⟩ = ∣ h ⟩ K_{\mathbf{j}}^\dagger|h\rangle=|h\rangle K j † ∣ h ⟩ = ∣ h ⟩ implies that
⟨ h ∣ ρ a c c ∣ h ⟩ = ∥ G ∣ ψ ⟩ ∥ 2 p a c c . \langle h|\rho_{\mathrm{acc}}|h\rangle=\frac{\left\|G|\psi\rangle\right\|^2}{p_{\mathrm{acc}}}. ⟨ h ∣ ρ acc ∣ h ⟩ = p acc ∥ G ∣ ψ ⟩ ∥ 2 .
Thus, by the Fuchs–van de Graaf inequality,
1 2 ∥ ρ a c c − ∣ h ⟩ ⟨ h ∣ ∥ 1 ≤ 1 − ∥ G ∣ ψ ⟩ ∥ 2 p a c c ≤ e − γ r / M p a c c . \frac{1}{2}\left\|\rho_{\mathrm{acc}}-|h\rangle\langle h|\right\|_1\leq\sqrt{1-\frac{\left\|G|\psi\rangle\right\|^2}{p_{\mathrm{acc}}}}\leq\sqrt{\frac{e^{-\gamma r/M}}{p_{\mathrm{acc}}}}. 2 1 ∥ ρ acc − ∣ h ⟩ ⟨ h ∣ ∥ 1 ≤ 1 − p acc ∥ G ∣ ψ ⟩ ∥ 2 ≤ p acc e − γ r / M .
Finally, since γ = Ω ( T − 2 ) \gamma=\Omega(T^{-2}) γ = Ω ( T − 2 ) and r = Ω ( M T 2 λ ) r=\Omega(MT^2\lambda) r = Ω ( M T 2 λ ) ,
e − γ r / M = e − Ω ( λ ) . e^{-\gamma r/M}=e^{-\Omega(\lambda)}. e − γ r / M = e − Ω ( λ ) .
Therefore, if p a c c ≥ 1 / poly ( λ ) p_{\mathrm{acc}}\geq1/\operatorname{poly}(\lambda) p acc ≥ 1/ poly ( λ ) , then ρ a c c \rho_{\mathrm{acc}} ρ acc is negligibly close to the valid history state ∣ h ⟩ |h\rangle ∣ h ⟩ . □ \square □
Quantum Fully Homomorphic Encryption
Definition 2 (Quantum Fully-Homomorphic Encryption (QFHE), [9 , 32 , 12 ] ). A quantum homomorphic encryption scheme with respect to a message space M \mathcal{M} M consists of four QPT quantum algorithms
( Gen , Enc , Eval , Dec ) (\operatorname{Gen},\operatorname{Enc},\operatorname{Eval},\operatorname{Dec}) ( Gen , Enc , Eval , Dec ) with the following syntax:
Key Generation. Gen is a classical PPT algorithm that takes as input the security parameter in unary 1 λ 1^{\lambda} 1 λ and outputs a public and secret key pair ( p k , s k ) (\mathrm{pk},\mathrm{sk}) ( pk , sk ) .12
Encryption. E n c : M → C \mathrm{Enc}:\mathcal{M}\to\mathcal{C} Enc : M → C takes as input a public key p k \mathrm{pk} pk and a classical or quantum state ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ in the message space M \mathcal{M} M , and outputs a classical or quantum state ciphertext ∣ ψ ^ ⟩ |\hat{\psi}\rangle ∣ ψ ^ ⟩ in the ciphertext space C \mathcal{C} C . If ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ is entirely classical, then so is ∣ ψ ^ ⟩ |\hat{\psi}\rangle ∣ ψ ^ ⟩ .
Homomorphic Evaluation. Eval takes as input a public key p k \mathrm{pk} pk , a unitary circuit C C C , a ciphertext ∣ ψ ^ ⟩ |\hat{\psi}\rangle ∣ ψ ^ ⟩ , and ancilla registers ∣ 0 a ⟩ |0^{a}\rangle ∣ 0 a ⟩ (which we often omit from the notation), and outputs an evaluated quantum ciphertext ∣ ϕ ^ ⟩ |\hat{\phi}\rangle ∣ ϕ ^ ⟩ . The garbage ancillas are discarded.
The algorithms have the following properties:
Correctness. For every polynomials ℓ \ell ℓ and p p p , it holds that for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N , every quantum state ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ consisting of ℓ ( λ ) \ell(\lambda) ℓ ( λ ) qubits, and every quantum circuits C C C of size p ( λ ) p(\lambda) p ( λ ) , it holds that
Dec ( s k , Eval ( p k , C , Enc ( p k , ∣ ψ ⟩ ) ) ) and C ( ∣ ψ ⟩ ) \operatorname{Dec}(\mathrm{sk},\operatorname{Eval}(\mathrm{pk},C,\operatorname{Enc}(\mathrm{pk},|\psi\rangle)))\quad\text{and}\quad C(|\psi\rangle) Dec ( sk , Eval ( pk , C , Enc ( pk , ∣ ψ ⟩))) and C ( ∣ ψ ⟩)
have negligible trace distance, where ( p k , s k ) ← Gen ( 1 λ ) (\mathrm{pk},\mathrm{sk})\leftarrow\operatorname{Gen}(1^{\lambda}) ( pk , sk ) ← Gen ( 1 λ ) .
Semantic Security. For every polynomial ℓ \ell ℓ , every λ ∈ N \lambda\in\mathbb{N} λ ∈ N and every pair of quantum (or classical) ℓ ( λ ) \ell(\lambda) ℓ ( λ ) -qubit states ( ∣ ψ 0 ⟩ , ∣ ψ 1 ⟩ ) (|\psi_0\rangle,|\psi_1\rangle) ( ∣ ψ 0 ⟩ , ∣ ψ 1 ⟩) , it holds that
Enc ( p k , ∣ ψ 0 ⟩ ) ≈ Enc ( p k , ∣ ψ 1 ⟩ ) , \operatorname{Enc}(\mathrm{pk},|\psi_0\rangle)\approx\operatorname{Enc}(\mathrm{pk},|\psi_1\rangle), Enc ( pk , ∣ ψ 0 ⟩) ≈ Enc ( pk , ∣ ψ 1 ⟩) ,
where ( p k , s k ) ← Gen ( 1 λ ) (\mathrm{pk},\mathrm{sk})\leftarrow\operatorname{Gen}(1^{\lambda}) ( pk , sk ) ← Gen ( 1 λ ) .
Compactness. There exists a polynomial p p p such that for any family { C λ } λ ∈ N \{C_{\lambda}\}_{\lambda\in\mathbb{N}} { C λ } λ ∈ N of polynomial size circuits, where C λ C_{\lambda} C λ takes as input an n ( λ ) n(\lambda) n ( λ ) -qubit quantum state, and for every n ( λ ) n(\lambda) n ( λ ) -qubit state ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ , the runtime of Dec on input ( s k , Eval ( p k , C , ∣ ψ ⟩ ) ) (\mathrm{sk},\operatorname{Eval}(\mathrm{pk},C,|\psi\rangle)) ( sk , Eval ( pk , C , ∣ ψ ⟩)) is at most p ( λ ) p(\lambda) p ( λ ) , where ( p k , s k ) ← Gen ( 1 λ ) (\mathrm{pk},\mathrm{sk})\leftarrow\operatorname{Gen}(1^{\lambda}) ( pk , sk ) ← Gen ( 1 λ ) . Namely, the decryption runtime is independent of the size of the evaluated circuit C C C .
For the ciphertext rerandomization approach to circuit privacy, see [6 Section 3.7 of the full version] .
Definition 3. A QFHE scheme is said to be circuit private if there exists a QPT simulator Sim such that for every polynomial-size quantum circuit C C C , that takes as input a quantum register A \mathcal{A} A , and for every QPT adversary that given pk outputs a state ρ A E \rho_{\mathcal{A}\mathcal{E}} ρ A E , where E \mathcal{E} E is an arbitrary auxiliary register,13
( p k , s k , Eval ( p k , C ⊗ I E , ρ ^ A E ) ) ≈ c ( p k , s k , w ^ , ( Sim ⊗ I E ) p k , ( C ⊗ I E ) ρ A E ) . (\mathrm{pk},\mathrm{sk},\operatorname{Eval}(\mathrm{pk},C\otimes I_{\mathcal{E}},\hat{\rho}_{\mathcal{A}\mathcal{E}}))\approx_{\mathrm{c}}(\mathrm{pk},\mathrm{sk},\hat{w},(\operatorname{Sim}\otimes I_{\mathcal{E}})_{\mathrm{pk},(C\otimes I_{\mathcal{E}})\rho_{\mathcal{A}\mathcal{E}}}). ( pk , sk , Eval ( pk , C ⊗ I E , ρ ^ A E )) ≈ c ( pk , sk , w ^ , ( Sim ⊗ I E ) pk , ( C ⊗ I E ) ρ A E ) .
where ( p k , s k ) ← G e n ( 1 λ ) (\mathrm{pk},\mathrm{sk}) \leftarrow\mathrm{Gen}(1^{\lambda}) ( pk , sk ) ← Gen ( 1 λ ) , and ρ A E \rho_{\mathcal{A E}} ρ A E is the state that the adversary outputs upon receiving p k \mathrm{pk} pk .14 Thus, an evaluated ciphertext reveals no information about C C C beyond its output, even to a party holding s k \mathrm{sk} sk .
Theorem 4 ([32 , 12 ] ). There exists a circuit private QFHE scheme that satisfies the property in Remark 3, assuming the post-quantum hardness of LWE.
Functional Authentication via Coset States
We recall the notion and construction of functional authentication from [4 ] , with the strengthened security shown by [26 ] . Although their construction only supports homomorphic evaluations from a limited class of circuits, we state the definition with respect to arbitrary classes of circuits.
Definition
Definition 4 (Functional Authentication). A functional authentication scheme for a family of unitaries U = { U n } n ∈ N \mathcal{U}=\{\mathcal{U}_{n}\}_{n\in\mathbb{N}} U = { U n } n ∈ N consists of the following algorithms.
K e y G e n ( 1 λ , 1 n ) → k \mathrm{KeyGen}(1^{\lambda},1^{n})\to k KeyGen ( 1 λ , 1 n ) → k takes the security parameter and an n n n -qubit message length n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) , and outputs a classical authentication key k k k .
E n c k ( ρ ) → σ \mathrm{Enc}_{k}(\rho)\to\sigma Enc k ( ρ ) → σ is an isometry, parameterized by k k k , that maps an n n n -qubit state ρ \rho ρ to an authenticated state σ = ( σ 1 , … , σ n ) \sigma=(\sigma_{1},\ldots,\sigma_{n}) σ = ( σ 1 , … , σ n ) , where each σ i \sigma_{i} σ i consists of p ( λ ) p(\lambda) p ( λ ) qubits, where p p p is a polynomial.
E v a l ( U ) → U ~ \mathrm{Eval}(U)\to\widetilde{U} Eval ( U ) → U is a classical algorithm that takes as input a description of a unitary U ∈ U n U\in\mathcal{U}_{n} U ∈ U n on n n n qubits, then outputs a description of another unitary U ~ \widetilde{U} U on n p ( λ ) np(\lambda) n p ( λ ) qubits. U ~ \widetilde{U} U acts as the homomorphic implementation of U U U on authenticated states.
KeyEval ( k , U ) → k U \operatorname{KeyEval}(k,U) \to k_U KeyEval ( k , U ) → k U is a classical algorithm that maps a key k k k and a unitary U ∈ U n U \in\mathcal{U}_n U ∈ U n to an evaluation key k U k_U k U .
We emphasize that k U k_U k U does not necessarily belong to the same keyspace as k k k .
Dec k U ( c ) → m / ⊥ \operatorname{Dec}_{k_U}(c) \to m/\perp Dec k U ( c ) → m / ⊥ is a classical decoding algorithm that, given a candidate physical measurement outcome c c c , returns either its decoded logical outcome m m m or ⊥ \perp ⊥ . It is parameterized by an evaluation key k U k_U k U .
We overload Dec k U ( c , f ) \operatorname{Dec}_{k_U}(c,f) Dec k U ( c , f ) to compute v = Dec k ( c ) v=\operatorname{Dec}_k(c) v = Dec k ( c ) , then output f ( v ) f(v) f ( v ) for some classical function f f f .
Functional authentication must satisfy correctness and functional security.
Correctness requires that authenticating a state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ , then homomorphically measuring the authenticated state is equivalent to directly measuring ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ , then authenticating the residual state.
Definition 5 (Functional Authentication Correctness). A functional authentication scheme for U U U is correct if For every function f : { 0 , 1 } n → { 0 , 1 } ∗ f:\{0,1\}^n \to\{0,1\}^* f : { 0 , 1 } n → { 0 , 1 } ∗ , unitary U ∈ U U \in\mathcal{U} U ∈ U , and key k ∈ Supp ( KeyGen ( 1 λ , 1 n ) ) k \in\operatorname{Supp}(\operatorname{KeyGen}(1^\lambda,1^n)) k ∈ Supp ( KeyGen ( 1 λ , 1 n )) ,
M [ f ∘ Dec k U , U ~ ] ∘ Enc k = Enc k ∘ M [ f , U ] , (2) M\left[f \circ\operatorname{Dec}_{k_U},\widetilde{U}\right]\circ\operatorname{Enc}_k=\operatorname{Enc}_k\circ M[f,U], \tag*{(2)} M [ f ∘ Dec k U , U ] ∘ Enc k = Enc k ∘ M [ f , U ] , (2) where f ( ⊥ ) : = ⊥ f(\perp):=\perp f ( ⊥ ) :=⊥ , and the definition of M [ f , U ] M[f,U] M [ f , U ] can be found in § 3.1 . Moreover, for every n n n -qubit state ρ \rho ρ and every unitary U ∈ U n U \in\mathcal{U}_n U ∈ U n ,
Pr [ ⊤ ← M [ Ver k U , U ~ ] ( Enc k ( ρ ) ) ] = 1. \Pr\left[\top\gets M\left[\operatorname{Ver}_{k_U},\widetilde{U}\right]\left(\operatorname{Enc}_k(\rho)\right)\right]=1. Pr [ ⊤ ← M [ Ver k U , U ] ( Enc k ( ρ ) ) ] = 1. where the probability is over the measurement outcome.
Functional authentication security considers a bounded-query algorithm A \mathcal{A} A which receives an authenticated state ∣ ψ ~ ⟩ \lvert\widetilde{\psi}\rangle ∣ ψ ⟩ of its choice along with quantum oracle access to a pre-defined set of decoding functions. Ideally, we want that A \mathcal{A} A should behave as if it never received ∣ ψ ~ ⟩ \lvert\widetilde{\psi}\rangle ∣ ψ ⟩ , and the oracles were replaced by direct measurements on ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ . The following definition from [26 ] formalizes this intuition.
Definition 6 (Functional Authentication Security [26 ] ). Fix t t t , n ′ = poly ( λ ) n'=\operatorname{poly}(\lambda) n ′ = poly ( λ ) , functions f 1 , … , f t : { 0 , 1 } n → { 0 , 1 } n ′ f_1,\ldots,f_t:\{0,1\}^n \to\{0,1\}^{n'} f 1 , … , f t : { 0 , 1 } n → { 0 , 1 } n ′ , and unitaries U 1 , … , U t ∈ U U_1,\ldots,U_t \in\mathcal{U} U 1 , … , U t ∈ U . Let k j = KeyEval ( k , U j ) k_j=\operatorname{KeyEval}(k,U_j) k j = KeyEval ( k , U j ) . Define the following coherent oracles f D e c k \mathsf{fDec}_k fDec k and f V e r k \mathsf{fVer}_k fVer k . A query contains an index j ∈ [ t ] j \in[t] j ∈ [ t ] , a candidate physical outcome v ~ \widetilde{v} v , and an answer register Y Y Y . f V e r \mathsf{fVer} fVer additionally takes as input a register V V V .
fDeck ( j , v ~ , Y ) (j,\widetilde{v},\mathcal{Y}) ( j , v , Y ) :
Compute v ← Dec k j ( v ~ ) v \leftarrow\operatorname{Dec}_{k_j}(\widetilde{v}) v ← Dec k j ( v ) .
If v = ⊥ v=\perp v =⊥ , apply Write( ⊥ ) (\perp) ( ⊥ ) to Y \mathcal{Y} Y .
Otherwise, apply Write( f j ( v ) ) (f_j(v)) ( f j ( v )) to Y \mathcal{Y} Y .
fVer k ( j , v ~ , Y , V ) _k(j,\widetilde{v},\mathcal{Y},\mathcal{V}) k ( j , v , Y , V ) :
Compute b ← Ver k j ( v ~ ) b \leftarrow\operatorname{Ver}_{k_j}(\widetilde{v}) b ← Ver k j ( v ) .
If b = ⊥ b=\perp b =⊥ , apply Write( ⊥ ) (\perp) ( ⊥ ) to Y \mathcal{Y} Y .
Otherwise, apply Write( M [ f , U j ] V ) (M[f,U_j]\mathcal{V}) ( M [ f , U j ] V ) to Y \mathcal{Y} Y .
The definitions of M [ f , U ] M[f,U] M [ f , U ] and Write can be found in the notation subsection 3.1. The tests and writes above are interpreted as controlled operations, and the measurements are implemented coherently. Then, for every polynomial-query quantum adversary A \mathcal{A} A and every state ∣ ψ ⟩ V W \lvert\psi\rangle_{\mathcal{V}\mathcal{W}} ∣ ψ ⟩ V W ,
{ ( V , W ) ← ∣ ψ ⟩ V W , k ← KeyGen ( 1 λ , 1 n ) , V ~ ← Enc k ( V ) , ( V ~ , W ) ← A f D e c k ( V ~ , W ) (3) \left\{
\begin{aligned}
(\mathcal{V},\mathcal{W}) &\leftarrow\lvert\psi\rangle_{\mathcal{V}\mathcal{W}},\\
k &\leftarrow\operatorname{KeyGen}(1^\lambda,1^n),\\
\widetilde{\mathcal{V}} &\leftarrow\operatorname{Enc}_k(\mathcal{V}),\\
(\widetilde{\mathcal{V}},\mathcal{W}) &\leftarrow\mathcal{A}^{\mathsf{fDeck}}(\widetilde{\mathcal{V}},\mathcal{W})
\end{aligned}
\right. \tag*{(3)} ⎩ ⎨ ⎧ ( V , W ) k V ( V , W ) ← ∣ ψ ⟩ V W , ← KeyGen ( 1 λ , 1 n ) , ← Enc k ( V ) , ← A fDeck ( V , W ) (3)
2 − Ω ( λ ) ≡ { ( V , W ) ← ∣ ψ ⟩ V W , k ← KeyGen ( 1 λ , 1 n ) , V ~ ← Enc k ( ∣ 0 n ⟩ ) , ( V ~ , W ) ← A f V e r k ( ⋅ , ⋅ , ⋅ , V ) ( V ~ , W ) 2^{-\Omega(\lambda)}
\equiv
\left\{
\begin{aligned}
(\mathcal{V},\mathcal{W}) &\leftarrow\lvert\psi\rangle_{\mathcal{V}\mathcal{W}},\\
k &\leftarrow\operatorname{KeyGen}(1^\lambda,1^n),\\
\widetilde{\mathcal{V}} &\leftarrow\operatorname{Enc}_k(\lvert0^n\rangle),\\
(\widetilde{\mathcal{V}},\mathcal{W}) &\leftarrow\mathcal{A}^{\mathsf{fVer}_k(\cdot,\cdot,\cdot,\mathcal{V})}(\widetilde{\mathcal{V}},\mathcal{W})
\end{aligned}
\right. 2 − Ω ( λ ) ≡ ⎩ ⎨ ⎧ ( V , W ) k V ( V , W ) ← ∣ ψ ⟩ V W , ← KeyGen ( 1 λ , 1 n ) , ← Enc k (∣ 0 n ⟩) , ← A fVer k ( ⋅ , ⋅ , ⋅ , V ) ( V , W )
Coset-state construction
In this section we present the construction due to Bartusek, Brakerski, and Vaikuntanathan [4 ] . The construction supports the family
U n Z X - L i n : = { H θ L : θ ∈ { 0 , 1 } n and L is a sequence of CNOT gates on n qubits } . \mathcal{U}^{\mathrm{ZX\text{-}Lin}}_n := \left\{H^\theta L:\theta\in\{0,1\}^n\text{ and }L\text{ is a sequence of CNOT gates on }n\text{ qubits}\right\}. U n ZX - Lin := { H θ L : θ ∈ { 0 , 1 } n and L is a sequence of CNOT gates on n qubits } .
Let U Z X - L i n : = { U n Z X - L i n } n ∈ N \mathcal{U}^{\mathrm{ZX\text{-}Lin}}:=\{\mathcal{U}^{\mathrm{ZX\text{-}Lin}}_n\}_{n\in\mathbb{N}} U ZX - Lin := { U n ZX - Lin } n ∈ N . A description of U ∈ U n Z X - L i n U\in\mathcal{U}^{\mathrm{ZX\text{-}Lin}}_n U ∈ U n ZX - Lin includes a factorization U = H θ L U=H^\theta L U = H θ L .
Notation. A subspace state
∣ S ⟩ = 1 ∣ S ∣ ∑ s ∈ S ∣ s ⟩ \lvert S\rangle=\frac{1}{\sqrt{\lvert S\rvert}}\sum_{s\in S}\lvert s\rangle ∣ S ⟩ = ∣ S ∣ 1 s ∈ S ∑ ∣ s ⟩
is a uniform superposition over a subspace S ⊆ F d S\subseteq\mathbb{F}^d S ⊆ F d of some ambient vector space F d \mathbb{F}^d F d which has dimension d d d . Most commonly, we consider binary vector spaces F 2 d \mathbb{F}_2^d F 2 d . A coset state is a subspace state with x x x and z z z offsets: X x Z z ∣ S ⟩ X^xZ^z\lvert S\rangle X x Z z ∣ S ⟩ .
Can ( S ) ⊂ F d \operatorname{Can}(S)\subset\mathbb{F}^d Can ( S ) ⊂ F d is set of canonical elements of each S + x S+x S + x , which is isomorphic to the quotient group F d / S = { S + x : x ∈ F d } \mathbb{F}^d/S=\{S+x:x\in\mathbb{F}^d\} F d / S = { S + x : x ∈ F d } . The isomorphism is given by Can S : F d → F d \operatorname{Can}_S:\mathbb{F}^d\to\mathbb{F}^d Can S : F d → F d . Note that Can S ( x ) = Can S ( x ′ ) \operatorname{Can}_S(x)=\operatorname{Can}_S(x') Can S ( x ) = Can S ( x ′ ) if and only if S + x = S + x ′ S+x=S+x' S + x = S + x ′ . We additionally require that Can S ( x ) ∈ S + x \operatorname{Can}_S(x)\in S+x Can S ( x ) ∈ S + x . Thus, we refer to Can S ( x ) \operatorname{Can}_S(x) Can S ( x ) as the “canonical element” of S + x S+x S + x .
Given a λ \lambda λ -dimensional subspace S ⊆ F 2 2 λ + 1 S\subseteq\mathbb{F}_2^{2\lambda+1} S ⊆ F 2 2 λ + 1 and Δ ∉ S \Delta\notin S Δ ∈ / S , define
S Δ : = S + Span { Δ } = S ∪ ( S + Δ ) . S_\Delta:=S+\operatorname{Span}\{\Delta\}=S\cup(S+\Delta). S Δ := S + Span { Δ } = S ∪ ( S + Δ ) .
Fix a canonical Δ H ∈ S ⊥ ∖ S Δ ⊥ \Delta_H \in S^\perp\setminus S^\perp_\Delta Δ H ∈ S ⊥ ∖ S Δ ⊥ . Then
S ⊥ = S Δ ⊥ + Span { Δ H } = S Δ ⊥ ∪ ( S Δ ⊥ + Δ H ) . S^\perp= S^\perp_\Delta+ \operatorname{Span}\{\Delta_H\} = S^\perp_\Delta\cup(S^\perp_\Delta+ \Delta_H). S ⊥ = S Δ ⊥ + Span { Δ H } = S Δ ⊥ ∪ ( S Δ ⊥ + Δ H ) .
Construction 1 (Coset functional authentication). The coset authentication scheme of Bartusek, Brakerski, and Vaikuntanathan [4 ] is defined as follows.
KeyGen ( 1 λ , 1 n ) (1^\lambda,1^n) ( 1 λ , 1 n ) : Sample a uniformly random λ \lambda λ -dimensional subspace S ⊆ F 2 2 λ + 1 S \subseteq\mathbb{F}_2^{2\lambda+1} S ⊆ F 2 2 λ + 1 , a uniformly random Δ ← F 2 2 λ + 1 ∖ S \Delta\leftarrow\mathbb{F}_2^{2\lambda+1} \setminus S Δ ← F 2 2 λ + 1 ∖ S , and uniformly random x i , z i ← F 2 2 λ + 1 x_i,z_i \leftarrow\mathbb{F}_2^{2\lambda+1} x i , z i ← F 2 2 λ + 1 for every i ∈ [ n ] i \in[n] i ∈ [ n ] .15 Output
k : = ( S , Δ , x , z ) , x = ( x i ) i ∈ [ n ] , z = ( z i ) i ∈ [ n ] . k := (S,\Delta,\mathbf{x},\mathbf{z}), \qquad\mathbf{x}=(x_i)_{i\in[n]}, \qquad\mathbf{z}=(z_i)_{i\in[n]}. k := ( S , Δ , x , z ) , x = ( x i ) i ∈ [ n ] , z = ( z i ) i ∈ [ n ] . E S , Δ ∣ b ⟩ = ∣ S + b Δ ∣ for b ∈ { 0 , 1 } . E_{S,\Delta}|b\rangle= |S+b\Delta| \qquad\text{for } b\in\{0,1\}. E S , Δ ∣ b ⟩ = ∣ S + b Δ∣ for b ∈ { 0 , 1 } . Apply E S , Δ ⊗ n E_{S,\Delta}^{\otimes n} E S , Δ ⊗ n to ρ \rho ρ , followed by the quantum one-time pad
X x Z z : = ⨂ i ∈ [ n ] X x i Z z i . X^{\mathbf{x}}Z^{\mathbf{z}} := \bigotimes_{i\in[n]} X^{x_i}Z^{z_i}. X x Z z := i ∈ [ n ] ⨂ X x i Z z i . θ ~ : = ( θ 1 2 λ + 1 ∥ ⋯ ∥ θ n 2 λ + 1 ) , \widetilde{\theta}:=(\theta_1^{2\lambda+1}\parallel\cdots\parallel\theta_n^{2\lambda+1}), θ := ( θ 1 2 λ + 1 ∥ ⋯ ∥ θ n 2 λ + 1 ) , where θ i 2 λ + 1 \theta_i^{2\lambda+1} θ i 2 λ + 1 denotes 2 λ + 1 2\lambda+1 2 λ + 1 repetitions of θ i \theta_i θ i . Define L ~ \widetilde{L} L by replacing every logical CNOT in L L L with the transversal operation CNOT ⊗ ( 2 λ + 1 ) \operatorname{CNOT}^{\otimes(2\lambda+1)} CNOT ⊗ ( 2 λ + 1 ) on the corresponding authenticated blocks. Output
U ~ : = H θ ~ L ~ . \widetilde{U}:=H^{\widetilde{\theta}}\widetilde{L}. U := H θ L . KeyEval ( k , U ) (k,U) ( k , U ) : Parse k = ( S , Δ , x , z ) k=(S,\Delta,\mathbf{x},\mathbf{z}) k = ( S , Δ , x , z ) and the description U = H θ L U=H^\theta L U = H θ L . Process the CNOT gates of L L L in order to update the one-time-pad keys. For a CNOT with control i i i and target j j j , apply the update
( ( x i , z i ) , ( x j , z j ) ) ⟼ ( ( x i , z i + z j ) , ( x i + x j , z j ) ) . ((x_i,z_i),(x_j,z_j)) \longmapsto((x_i,z_i+z_j),(x_i+x_j,z_j)). (( x i , z i ) , ( x j , z j )) ⟼ (( x i , z i + z j ) , ( x i + x j , z j )) . Denote the resulting offsets by ( x L , z L ) (\mathbf{x}_L,\mathbf{z}_L) ( x L , z L ) . For every i ∈ [ n ] i\in[n] i ∈ [ n ] , define
( T i , Γ i , r i ) : = { ( S , Δ , x L , i ) if θ i = 0 , ( S Δ ⊥ , Δ H , z L , i ) if θ i = 1. (T_i,\Gamma_i,r_i):=
\begin{cases}
(S,\Delta,x_{L,i}) & \text{if }\theta_i=0,\\
(S^\perp_\Delta,\Delta_H,z_{L,i}) & \text{if }\theta_i=1.
\end{cases} ( T i , Γ i , r i ) := { ( S , Δ , x L , i ) ( S Δ ⊥ , Δ H , z L , i ) if θ i = 0 , if θ i = 1. Output the evaluation key
k U : = ( ( T i , Γ i , r i ) ) i ∈ [ n ] . k_U:=((T_i,\Gamma_i,r_i))_{i\in[n]}. k U := (( T i , Γ i , r i ) ) i ∈ [ n ] .
Dec k U ( c ) \operatorname{Dec}_{k_U}(c) Dec k U ( c ) : Parse k U = ( ( T i , Γ i , r i ) ) i ∈ [ n ] k_U = ((T_i,\Gamma_i,r_i))_{i\in[n]} k U = (( T i , Γ i , r i ) ) i ∈ [ n ] and c = ( c 1 , … , c n ) c = (c_1,\ldots,c_n) c = ( c 1 , … , c n ) with c i ∈ F 2 2 λ + 1 c_i \in\mathbb{F}_2^{2\lambda+1} c i ∈ F 2 2 λ + 1 . For every i ∈ [ n ] i \in[n] i ∈ [ n ] , compute
m i : = { 0 c i ∈ T i + r i , 1 c i ∈ T i + Γ i + r i , ⊥ otherwise . m_i := \begin{cases} 0 & c_i \in T_i+r_i, \\ 1 & c_i \in T_i+\Gamma_i+r_i, \\ \perp& \text{otherwise}. \end{cases} m i := ⎩ ⎨ ⎧ 0 1 ⊥ c i ∈ T i + r i , c i ∈ T i + Γ i + r i , otherwise .
If some m i = ⊥ m_i=\perp m i =⊥ , output ⊥ \perp ⊥ ; otherwise output m = ( m 1 , … , m n ) m=(m_1,\ldots,m_n) m = ( m 1 , … , m n ) .
Ver ‾ k U ( c ) \overline{\operatorname{Ver}}_{k_U}(c) Ver k U ( c ) : Using the same parsing, check whether c i ∈ T i + Span { Γ i } + r i c_i \in T_i+\operatorname{Span}\{\Gamma_i\}+r_i c i ∈ T i + Span { Γ i } + r i for every i ∈ [ n ] i\in[n] i ∈ [ n ] . Output ⊤ \top ⊤ if every check passes, and output ⊥ \perp ⊥ otherwise.
As a special case, we also define Eval \operatorname{Eval} Eval and KeyEval \operatorname{KeyEval} KeyEval on Pauli operators X x ′ Z z ′ X^{x'}Z^{z'} X x ′ Z z ′ where x ′ , z ′ ∈ F 2 n x',z'\in\mathbb{F}_2^n x ′ , z ′ ∈ F 2 n by
and KeyEval ( k , X x ′ Z z ′ ) = ( S , Δ , x − x ′ ⊗ Δ , z − z ′ ⊗ Δ H ) \operatorname{KeyEval}(k,X^{x'}Z^{z'})=(S,\Delta,x-x'\otimes\Delta,z-z'\otimes\Delta_H) KeyEval ( k , X x ′ Z z ′ ) = ( S , Δ , x − x ′ ⊗ Δ , z − z ′ ⊗ Δ H ) .
In particular, Pauli operators can be applied solely with a key update, and the updated key remains in the original KeyGen keyspace. Therefore if we let k ′ = KeyEval ( k , X x ′ Z z ′ ) k'=\operatorname{KeyEval}(k,X^{x'}Z^{z'}) k ′ = KeyEval ( k , X x ′ Z z ′ ) , then
Auth k ′ ( ∣ ψ ⟩ ) = Auth k ( X x ′ Z z ′ ∣ ψ ⟩ ) (4) \operatorname{Auth}_{k'}(|\psi\rangle)=\operatorname{Auth}_k(X^{x'}Z^{z'}|\psi\rangle) \tag*{(4)} Auth k ′ ( ∣ ψ ⟩) = Auth k ( X x ′ Z z ′ ∣ ψ ⟩) (4)
Huang and Tang give a stronger, simulation-based definition than Bartusek, Brakerski, and Vaikuntanathan’s original definition and show that the same construction satisfies the stronger definition.
Theorem 5 ([26 ] ). For λ ≥ Ω ( n ) \lambda\ge\Omega(n) λ ≥ Ω ( n ) , Construction 1 is a functional authentication scheme for U Z X - L i n \mathcal{U}^{\mathrm{ZX\text{-}Lin}} U ZX - Lin in the sense of Definition 4.
We mention an additional useful property of BBV’s construction: decoding is (almost) linear.
Lemma 1 (Affine decoding). Let Chk S Δ \operatorname{Chk}_{S_\Delta} Chk S Δ and Chk S ⊥ \operatorname{Chk}_{S^\perp} Chk S ⊥ be parity-check matrices for S Δ S_\Delta S Δ and S ⊥ S^\perp S ⊥ , respectively, and define
L C : = ( Δ H T Chk S Δ ) , L H : = ( Δ T Chk S ⊥ ) . L_C := \begin{pmatrix} \Delta_H^{\mathsf T} \\ \operatorname{Chk}_{S_\Delta} \end{pmatrix}, \qquad L_H := \begin{pmatrix} \Delta^{\mathsf T} \\ \operatorname{Chk}_{S^\perp} \end{pmatrix}. L C := ( Δ H T Chk S Δ ) , L H := ( Δ T Chk S ⊥ ) . For each i ∈ [ n ] i\in[n] i ∈ [ n ] , let y i = L C x L , i y_i=L_Cx_{L,i} y i = L C x L , i if θ i = 0 \theta_i=0 θ i = 0 , and let y i = L H z L , i y_i=L_Hz_{L,i} y i = L H z L , i if θ i = 1 \theta_i=1 θ i = 1 . Define
w i : = { L C c i − y i if θ i = 0 , L H c i − y i if θ i = 1 , m i : = { b if w i = b ∥ 0 2 λ for some b ∈ { 0 , 1 } , ⊥ otherwise . w_i := \begin{cases} L_Cc_i-y_i & \text{if }\theta_i=0, \\ L_Hc_i-y_i & \text{if }\theta_i=1, \end{cases}
\qquad
m_i := \begin{cases} b & \text{if }w_i=b\mathbin\Vert0^{2\lambda}\text{ for some }b\in\{0,1\}, \\ \perp& \text{otherwise}. \end{cases} w i := { L C c i − y i L H c i − y i if θ i = 0 , if θ i = 1 , m i := { b ⊥ if w i = b ∥ 0 2 λ for some b ∈ { 0 , 1 } , otherwise . Then Dec k U ( c ) \operatorname{Dec}_{k_U}(c) Dec k U ( c ) outputs ⊥ \perp ⊥ if some m i = ⊥ m_i=\perp m i =⊥ , and otherwise outputs ( m 1 , … , m n ) (m_1,\ldots,m_n) ( m 1 , … , m n ) .
Proof. The kernel of Chk S Δ \operatorname{Chk}_{S_\Delta} Chk S Δ and Chk S ⊥ \operatorname{Chk}_{S^\perp} Chk S ⊥ are S S S and S ⊥ S^\perp S ⊥ , respectively, so w i w_i w i ends in 0 2 λ 0^{2\lambda} 0 2 λ if and only if c i − x L , i ∈ S Δ c_i-x_{L,i}\in S_\Delta c i − x L , i ∈ S Δ or c i − z L , i ∈ S ⊥ c_i-z_{L,i}\in S^\perp c i − z L , i ∈ S ⊥ , respectively. Furthermore, the first bit of w i w_i w i is 1 1 1 if and only if c i − x L , i ∈ S + Δ c_i-x_{L,i}\in S+\Delta c i − x L , i ∈ S + Δ or c i − z L , i ∈ S ⊥ + Δ H c_i-z_{L,i}\in S^\perp+\Delta_H c i − z L , i ∈ S ⊥ + Δ H , respectively.
Noisy Trapdoor Claw-Free Functions
In what follows we define the notion of a noisy trapdoor claw-free function family . This notion is simpler than the notion of a dual-mode noisy trapdoor claw-free function family .16
Definition 7. A noisy trapdoor claw-free function (NTCF) family is described by PPT algorithms: ( S e t u p , E v a l , I n v e r t , C h e c k , S y n d ) (\mathsf{Setup},\mathsf{Eval},\mathsf{Invert},\mathsf{Check},\mathsf{Synd}) ( Setup , Eval , Invert , Check , Synd )
with the following syntax:
S e t u p ( 1 λ ) → ( p p , t d ) \mathsf{Setup}(1^\lambda) \to(\mathsf{pp},\mathsf{td}) Setup ( 1 λ ) → ( pp , td ) . This PPT key generation algorithm takes as input a security parameter λ \lambda λ (in unary) and outputs public parameters p p \mathsf{pp} pp and a secret trapdoor t d \mathsf{td} td .
We denote by D p p \mathsf{D}_{\mathsf{pp}} D pp the domain of the (randomized) function defined by p p \mathsf{pp} pp , and assume for simplicity that D p p \mathsf{D}_{\mathsf{pp}} D pp is an efficiently verifiable and samplable subset of { 0 , 1 } n ( λ ) \{0,1\}^{n(\lambda)} { 0 , 1 } n ( λ ) , where n ( λ ) = poly ( λ ) n(\lambda)=\operatorname{poly}(\lambda) n ( λ ) = poly ( λ ) . We denote by R p p \mathsf{R}_{\mathsf{pp}} R pp the range of this (randomized) function.
E v a l ( p p , b , x ) → y \mathsf{Eval}(\mathsf{pp},b,x) \to y Eval ( pp , b , x ) → y . This PPT algorithm takes as input a public key p p \mathsf{pp} pp , a bit b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } and an element x ∈ D p p x \in\mathsf{D}_{\mathsf{pp}} x ∈ D pp , and outputs a string y y y distributed according to some distribution χ = χ p p , b , x \chi=\chi_{\mathsf{pp},b,x} χ = χ pp , b , x .
I n v e r t ( t d , y ) → ( ( 0 , x 0 ) , ( 1 , x 1 ) ) \mathsf{Invert}(\mathsf{td},y) \to((0,x_0),(1,x_1)) Invert ( td , y ) → (( 0 , x 0 ) , ( 1 , x 1 )) . This deterministic polynomial time algorithm takes as input a trapdoor t d \mathsf{td} td , and an element y y y in the range R p p \mathsf{R}_{\mathsf{pp}} R pp and outputs two pairs ( 0 , x 0 ) (0,x_0) ( 0 , x 0 ) and ( 1 , x 1 ) (1,x_1) ( 1 , x 1 ) with x 0 , x 1 ∈ D p p x_0,x_1 \in\mathsf{D}_{\mathsf{pp}} x 0 , x 1 ∈ D pp , or ⊥ \perp ⊥ .
C h e c k ( p p , b , x , y ) → 0 / 1 \mathsf{Check}(\mathsf{pp},b,x,y) \to0/1 Check ( pp , b , x , y ) → 0/1 . This deterministic poly-time algorithm takes as input a public key p p \mathsf{pp} pp , a bit b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } , an element x ∈ D p p x \in\mathsf{D}_{\mathsf{pp}} x ∈ D pp and an element y ∈ R p p y \in\mathsf{R}_{\mathsf{pp}} y ∈ R pp and outputs a bit.
S y n d ( b , x , d ) → d ′ \mathsf{Synd}(b,x,d) \to d' Synd ( b , x , d ) → d ′ . This deterministic poly-time algorithm takes as input a bit b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } , a domain element x ∈ D p p x \in\mathsf{D}_{\mathsf{pp}} x ∈ D pp , and a string d ∈ { 0 , 1 } n + 1 d \in\{0,1\}^{n+1} d ∈ { 0 , 1 } n + 1 , and outputs a syndrome d ′ ∈ { 0 , 1 } k d' \in\{0,1\}^k d ′ ∈ { 0 , 1 } k .
We define the set G o o d b , x = { d : S y n d ( b , x , d ) ≠ 0 k } \mathsf{Good}_{b,x}=\{d:\mathsf{Synd}(b,x,d)\ne0^k\} Good b , x = { d : Synd ( b , x , d ) = 0 k } . The predicate G o o d ( x 0 , x 1 , d ) = 1 \mathsf{Good}(x_0,x_1,d)=1 Good ( x 0 , x 1 , d ) = 1 means that d ∈ G o o d 0 , x 0 ∩ G o o d 1 , x 1 d \in\mathsf{Good}_{0,x_0}\cap\mathsf{Good}_{1,x_1} d ∈ Good 0 , x 0 ∩ Good 1 , x 1 .
We require that the following properties are satisfied.
Completeness:
(a) For every ( p p , t d ) ∈ Supp ( S e t u p ( 1 λ ) ) (\mathsf{pp},\mathsf{td}) \in\operatorname{Supp}(\mathsf{Setup}(1^\lambda)) ( pp , td ) ∈ Supp ( Setup ( 1 λ )) , b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } , x ∈ D p p x \in\mathsf{D}_{\mathsf{pp}} x ∈ D pp , and y ∈ Supp ( E v a l ( p p , b , x ) ) y \in\operatorname{Supp}(\mathsf{Eval}(\mathsf{pp},b,x)) y ∈ Supp ( Eval ( pp , b , x )) ,
I n v e r t ( t d , y ) = ( ( 0 , x 0 ) , ( 1 , x 1 ) ) \mathsf{Invert}(\mathsf{td},y)=((0,x_0),(1,x_1)) Invert ( td , y ) = (( 0 , x 0 ) , ( 1 , x 1 )) such that x b = x x_b=x x b = x and y ∈ Supp ( E v a l ( p p , β , x β ) ) y \in\operatorname{Supp}(\mathsf{Eval}(\mathsf{pp},\beta,x_\beta)) y ∈ Supp ( Eval ( pp , β , x β )) for every β ∈ { 0 , 1 } \beta\in\{0,1\} β ∈ { 0 , 1 } .
(b) For all ( p p , t d ) ∈ Supp ( Setup ( 1 λ ) ) (\mathrm{pp},\mathrm{td}) \in\operatorname{Supp}(\operatorname{Setup}(1^\lambda)) ( pp , td ) ∈ Supp ( Setup ( 1 λ )) , there exists a perfect matching M p p ⊆ D p p × D p p M_{\mathrm{pp}} \subseteq D_{\mathrm{pp}} \times D_{\mathrm{pp}} M pp ⊆ D pp × D pp such that for all ( x 0 , x 1 ) (x_0,x_1) ( x 0 , x 1 ) , it holds that Eval ( p p , 0 , x 0 ) ≡ Eval ( p p , 1 , x 1 ) \operatorname{Eval}(\mathrm{pp},0,x_0) \equiv\operatorname{Eval}(\mathrm{pp},1,x_1) Eval ( pp , 0 , x 0 ) ≡ Eval ( pp , 1 , x 1 ) if and only if ( x 0 , x 1 ) ∈ M p p (x_0,x_1) \in M_{\mathrm{pp}} ( x 0 , x 1 ) ∈ M pp .
(c) For every ( p p , t d ) ∈ Supp ( Setup ( 1 λ ) ) (\mathrm{pp},\mathrm{td}) \in\operatorname{Supp}(\operatorname{Setup}(1^\lambda)) ( pp , td ) ∈ Supp ( Setup ( 1 λ )) , b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } and x ∈ D p p \mathbf{x} \in D_{\mathrm{pp}} x ∈ D pp ,
Pr [ Check ( p p , b , x , y ) = 1 ] = 1 (5) \Pr[\operatorname{Check}(\mathrm{pp},b,\mathbf{x},\mathbf{y})=1]=1 \tag*{(5)} Pr [ Check ( pp , b , x , y ) = 1 ] = 1 (5)
if and only if y ∈ Supp ( Eval ( p p , b , x ) ) \mathbf{y} \in\operatorname{Supp}(\operatorname{Eval}(\mathrm{pp},b,\mathbf{x})) y ∈ Supp ( Eval ( pp , b , x )) .
(d) For every ( p p , t d ) ∈ Supp ( Setup ( 1 λ ) ) (\mathrm{pp},\mathrm{td}) \in\operatorname{Supp}(\operatorname{Setup}(1^\lambda)) ( pp , td ) ∈ Supp ( Setup ( 1 λ )) and every b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } and x ∈ D p p \mathbf{x} \in D_{\mathrm{pp}} x ∈ D pp ,
Pr d ← { 0 , 1 } n + 1 [ d ∈ Good b , x ] = 1 − negl ( λ ) . \Pr_{d \gets\{0,1\}^{n+1}}[d \in\operatorname{Good}_{b,\mathbf{x}}]=1-\operatorname{negl}(\lambda). d ← { 0 , 1 } n + 1 Pr [ d ∈ Good b , x ] = 1 − negl ( λ ) .
Efficient Range Superposition: There is an quantum polynomial-time procedure which samples a state with negligible trace distance from
∑ x ∈ D p p y ∈ R p p p p p ( b , x , y ) ∣ x ⟩ ∣ y ⟩ \sum_{\substack{\mathbf{x} \in D_{\mathrm{pp}}\\ \mathbf{y} \in R_{\mathrm{pp}}}} \sqrt{p_{\mathrm{pp}}(b,\mathbf{x},\mathbf{y})}\lvert\mathbf{x}\rangle\lvert\mathbf{y}\rangle x ∈ D pp y ∈ R pp ∑ p pp ( b , x , y ) ∣ x ⟩ ∣ y ⟩
where p p p ( b , x , y ) p_{\mathrm{pp}}(b,\mathbf{x},\mathbf{y}) p pp ( b , x , y ) is the probability density of y \mathbf{y} y in the distribution Eval ( p p , b , x ) \operatorname{Eval}(\mathrm{pp},b,\mathbf{x}) Eval ( pp , b , x ) .
Adaptive Hardcore Bit: For every QPT adversary A \mathcal{A} A there exists a negligible function μ \mu μ such that for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N ,
Pr [ A ( p p ) = ( y , b , x , d , v ) : Check ( p p , b , x , y ) = 1 ∧ Good ( x 0 , x 1 , d ) = 1 ∧ d ⋅ ( 1 , x 0 ⊕ x 1 ) = v ] ≤ 1 2 + μ ( λ ) , \Pr[\mathcal{A}(\mathrm{pp})=(\mathbf{y},b,\mathbf{x},d,v):\operatorname{Check}(\mathrm{pp},b,\mathbf{x},\mathbf{y})=1 \land\operatorname{Good}(\mathbf{x}_0,\mathbf{x}_1,d)=1 \land d\cdot(1,\mathbf{x}_0\oplus\mathbf{x}_1)=v] \le\frac{1}{2}+\mu(\lambda), Pr [ A ( pp ) = ( y , b , x , d , v ) : Check ( pp , b , x , y ) = 1 ∧ Good ( x 0 , x 1 , d ) = 1 ∧ d ⋅ ( 1 , x 0 ⊕ x 1 ) = v ] ≤ 2 1 + μ ( λ ) ,
where the probability is over ( p p , t d ) ← Setup ( 1 λ ) (\mathrm{pp},\mathrm{td}) \gets\operatorname{Setup}(1^\lambda) ( pp , td ) ← Setup ( 1 λ ) , and where ( ( 0 , x 0 ) , ( 1 , x 1 ) ) = Invert ( t d , y ) ((0,\mathbf{x}_0),(1,\mathbf{x}_1))=\operatorname{Invert}(\mathrm{td},\mathbf{y}) (( 0 , x 0 ) , ( 1 , x 1 )) = Invert ( td , y ) .
Lemma 2. [BCM+18] There exists an NTCF family assuming the post-quantum hardness of LWE.
In addition, we will need three non-standard properties of the NTCF. The first is a modified collapsing property in the presence of one bit of leakage. It holds generically for any NTCF. The second is the hiding of a random inner product predicate when an adaptive hardcore bit is also leaked. This holds generically for NTCFs where Synd is linear in d d d . The third is a variation of [28 ] ’s phase injection lemma which holds in the presence of one bit of random inner product leakage. This holds generically for any NTCF satisfying the second property. See Section A for the complete proofs.
Lemma 3 (Collapsing with a leaked inner product). Let (Setup, Eval, Invert, Check, Synd) be a NTCF family. For a QPT adversary A \mathcal{A} A and c ∈ { 0 , 1 } c \in\{0,1\} c ∈ { 0 , 1 } , define the experiment Coll-IP c A ( 1 λ ) \operatorname{Coll\text{-}IP}_{c}^{\mathcal{A}}(1^\lambda) Coll - IP c A ( 1 λ ) as follows:
The challenger samples ( p p , t d ) ← Setup ( 1 λ ) (\mathrm{pp},\mathrm{td}) \leftarrow\operatorname{Setup}(1^\lambda) ( pp , td ) ← Setup ( 1 λ ) and sends p p \mathrm{pp} pp to A A A .
A A A sends a classical image y y y to the challenger. The challenger computes ( ( 0 , x 0 ) , ( 1 , x 1 ) ) ← Invert ( t d , y ) ((0,x_0),(1,x_1)) \leftarrow\operatorname{Invert}(\mathrm{td},y) (( 0 , x 0 ) , ( 1 , x 1 )) ← Invert ( td , y ) . If inversion fails, the experiment outputs 0 and terminates.
The challenger samples d ← { 0 , 1 } n + 1 \mathbf{d} \leftarrow\{0,1\}^{n+1} d ← { 0 , 1 } n + 1 and defines Δ = ( 0 , x 0 ) ⊕ ( 1 , x 1 ) \Delta=(0,x_0)\oplus(1,x_1) Δ = ( 0 , x 0 ) ⊕ ( 1 , x 1 ) . Then, it sends ( d , d ⋅ Δ ) (\mathbf{d},\mathbf{d}\cdot\Delta) ( d , d ⋅ Δ ) to A A A .
A A A sends a ( n + 1 ) (n+1) ( n + 1 ) -qubit register X \mathcal{X} X to the challenger, retaining its private registers. The challenger performs the two-outcome projective measurement { Π y , I − Π y } \{\Pi_y,I-\Pi_y\} { Π y , I − Π y } on X \mathcal{X} X , where
Π y = ∑ b ∈ { 0 , 1 } , x Check ( p p , b , x , y ) = 1 ∣ b , x ⟩ ⟨ b , x ∣ . \Pi_y=\sum_{\substack{b\in\{0,1\},x\\ \operatorname{Check}(\mathrm{pp},b,x,y)=1}} |b,x\rangle\langle b,x|. Π y = b ∈ { 0 , 1 } , x Check ( pp , b , x , y ) = 1 ∑ ∣ b , x ⟩ ⟨ b , x ∣.
If the outcome is I − Π y I-\Pi_y I − Π y , the experiment outputs 0 and terminates.
If c = 1 c=1 c = 1 , the challenger measures X \mathcal{X} X in the computational basis and discards the outcome. If c = 0 c=0 c = 0 , it leaves X \mathcal{X} X unchanged. It then returns X \mathcal{X} X to A A A .
A A A outputs a bit, which is the output of the experiment.
Then, for every QPT adversary A A A ,
∣ Pr [ Coll-IPA 0 A ( 1 λ ) = 1 ] − Pr [ Coll-IPA 1 A ( 1 λ ) = 1 ] ∣ ≤ negl ( λ ) . \left|\Pr[\operatorname{Coll\text{-}IPA}^{A}_{0}(1^\lambda)=1]-\Pr[\operatorname{Coll\text{-}IPA}^{A}_{1}(1^\lambda)=1]\right|\leq\operatorname{negl}(\lambda). Pr [ Coll - IPA 0 A ( 1 λ ) = 1 ] − Pr [ Coll - IPA 1 A ( 1 λ ) = 1 ] ≤ negl ( λ ) .
Definition 8 (2-query adaptive hardcore bit). A NTCF family is said to satisfy the 2-query adaptive hardcore bit property if every QPT adversary A A A wins in the following game with probability 1 2 + negl ( λ ) \frac{1}{2}+\operatorname{negl}(\lambda) 2 1 + negl ( λ ) .
The challenger samples ( p p , t d ) ← Setup ( 1 λ ) (\mathrm{pp},\mathrm{td}) \leftarrow\operatorname{Setup}(1^\lambda) ( pp , td ) ← Setup ( 1 λ ) and sends p p \mathrm{pp} pp to A A A .
A A A sends a classical tuple ( b , x , y ) (b,x,y) ( b , x , y ) to the challenger. It may retain arbitrary quantum side information.
The challenger checks that Check ( p p , b , x , y ) = 1 \operatorname{Check}(\mathrm{pp},b,x,y)=1 Check ( pp , b , x , y ) = 1 . If this is not the case then the game is terminated with the default guess c ′ = 0 c'=0 c ′ = 0 . Otherwise, the challenger does the following:
(a) Compute ( ( 0 , x 0 ) , ( 1 , x 1 ) ) = Invert ( t d , y ) ((0,x_0),(1,x_1))=\operatorname{Invert}(\mathrm{td},y) (( 0 , x 0 ) , ( 1 , x 1 )) = Invert ( td , y ) .
(b) Sample uniformly at random c ← { 0 , 1 } c\leftarrow\{0,1\} c ← { 0 , 1 } and d ← { 0 , 1 } n + 1 \mathbf{d}\leftarrow\{0,1\}^{n+1} d ← { 0 , 1 } n + 1 .
(c) Compute p = d ⋅ ( 1 , x 0 ⊕ x 1 ) ⊕ c p=\mathbf{d}\cdot(1,x_0\oplus x_1)\oplus c p = d ⋅ ( 1 , x 0 ⊕ x 1 ) ⊕ c .
(d) Send ( d , p ) (\mathbf{d},p) ( d , p ) .
A A A sends a classical vector e ∈ { 0 , 1 } n \mathbf{e}\in\{0,1\}^{n} e ∈ { 0 , 1 } n .
The challenger checks that Synd ( b , x b , e ) ∉ { 0 k , Synd ( b , x b , d ) } \operatorname{Synd}(b,x_b,\mathbf{e})\notin\{0^k,\operatorname{Synd}(b,x_b,\mathbf{d})\} Synd ( b , x b , e ) ∈ / { 0 k , Synd ( b , x b , d )} for both b ∈ { 0 , 1 } b\in\{0,1\} b ∈ { 0 , 1 } . If either check fails then the game is terminated with a default guess c ′ = 0 c'=0 c ′ = 0 . Otherwise, the challenger sends β = e ⋅ ( x 0 ⊕ x 1 ) \beta=\mathbf{e}\cdot(x_0\oplus x_1) β = e ⋅ ( x 0 ⊕ x 1 ) to A A A .
A \mathcal{A} A outputs a bit c ′ ∈ { 0 , 1 } c' \in\{0,1\} c ′ ∈ { 0 , 1 } .
A \mathcal{A} A wins if c ′ = c c' = c c ′ = c .
Lemma 4. Fix any NTCF family (satisfying the adaptive hardcore-bit property) for which Synd is linear in d \mathbf{d} d ; i.e, the map
d ↦ Synd ( b , x , d ) \mathbf{d} \mapsto\operatorname{Synd}(b,\mathbf{x},\mathbf{d}) d ↦ Synd ( b , x , d ) is linear over F 2 \mathbb{F}_2 F 2 . Then this NTCF family satisfies the two-query adaptive hardcore-bit property Definition 8.
We note in the NTCF construction from [BCM+18], the function Synd is indeed linear in d \mathbf{d} d . Thus, by Lemma 4 this construction also satisfies the 2-query adaptive hardcore bit property, assuming the post-quantum hardness of LWE.
Lemma 5 (Phase Injection with 1 Bit Leakage). Let F \mathcal{F} F be an NTCF with adaptive hardcore bits and linear Synd. Then every QPT adversary A \mathcal{A} A wins in the following game with probability at most 1 / 2 + negl ( λ ) 1/2 + \operatorname{negl}(\lambda) 1/2 + negl ( λ ) .
Challenger: Sample ( p p , t d ) ← Setup ( 1 λ ) (\mathsf{pp},\mathsf{td}) \leftarrow\operatorname{Setup}(1^\lambda) ( pp , td ) ← Setup ( 1 λ ) and sample a random bit p ← { 0 , 1 } p \leftarrow\{0,1\} p ← { 0 , 1 } . Send p p \mathsf{pp} pp to A \mathcal{A} A .
A \mathcal{A} A sends back a classical value y y y and a register R \mathcal{R} R (which should store a preimage of y y y ).
Challenger: Perform the projective measurement { Π y , I − Π y } \{\Pi_y,I-\Pi_y\} { Π y , I − Π y } on R \mathcal{R} R where Π y \Pi_y Π y projects onto ( b , r b ) (b,r_b) ( b , r b ) such that Check ( p p , b , r b , y ) = 1 \operatorname{Check}(\mathsf{pp},b,r_b,y)=1 Check ( pp , b , r b , y ) = 1 . If the result is I − Π y I-\Pi_y I − Π y , then A \mathcal{A} A needs to guess p p p (without being given any information about p p p ), and the game is over.
Challenger: Otherwise, if p = 1 p=1 p = 1 then apply a Z Z Z gate to the first qubit of R \mathcal{R} R . Send R \mathcal{R} R back to A \mathcal{A} A .
Challenger (Leakage): Compute ( ( 0 , r 0 ) , ( 1 , r 1 ) ) ← Invert ( t d , y ) ((0,r_0),(1,r_1)) \leftarrow\operatorname{Invert}(\mathsf{td},y) (( 0 , r 0 ) , ( 1 , r 1 )) ← Invert ( td , y ) . Set Δ = ( 0 , r 0 ) ⊕ ( 1 , r 1 ) \Delta=(0,r_0)\oplus(1,r_1) Δ = ( 0 , r 0 ) ⊕ ( 1 , r 1 ) . Then sample d ← { 0 , 1 } n + 1 \mathbf{d} \leftarrow\{0,1\}^{n+1} d ← { 0 , 1 } n + 1 and send ( d , d ⋅ Δ ) (\mathbf{d},\mathbf{d}\cdot\Delta) ( d , d ⋅ Δ ) to the adversary.
A \mathcal{A} A sends a string e e e to the challenger.
Challenger: If Synd ( b , r b , e ) ∉ { 0 k , Synd ( b , r b , d ) } \operatorname{Synd}(b,r_b,e)\notin\{0^k,\operatorname{Synd}(b,r_b,\mathbf{d})\} Synd ( b , r b , e ) ∈ / { 0 k , Synd ( b , r b , d )} for both b ∈ { 0 , 1 } b\in\{0,1\} b ∈ { 0 , 1 } , send ( e ⋅ Δ ) ⊕ p (e\cdot\Delta)\oplus p ( e ⋅ Δ ) ⊕ p to A \mathcal{A} A . Otherwise send a random bit b ′ b' b ′ .
A \mathcal{A} A outputs a bit p ′ p' p ′ . They win if and only if p ′ = p p'=p p ′ = p .
Witness-Preserving Arguments for NP
[27 ] showed how a quantum prover holding a superposition ∑ w α w ∣ w ⟩ \sum_w \alpha_w\lvert w\rangle ∑ w α w ∣ w ⟩ of NP witnesses for x ∈ L x\in\mathcal{L} x ∈ L can convince a classical verifier that x ∈ L x\in\mathcal{L} x ∈ L without disturbing their witness superposition. We recall the notion and their result in this section. Then, in the next section we observe that techniques from [30 ] can make the protocol “indistinguishably-extractable”; that is, the prover’s view can be indistinguishably simulated in such a way that the witness is temporarily extracted, then returned to the prover to obtain the final view.
Definition 9. [27 ] A witness-preserving argument for an NP language L \mathcal{L} L is an interactive protocol between a QPT prover P P P and a PPT verifier V V V that satisfies the following guarantees.
Completeness and Witness Preservation. For every x ∈ L x \in\mathcal{L} x ∈ L and every superposition ∣ ψ ⟩ = ∑ w α w ∣ w ⟩ W ⊗ ∣ ϕ w ⟩ B |\psi\rangle= \sum_w \alpha_w |w\rangle_{\mathcal{W}} \otimes|\phi_w\rangle_B ∣ ψ ⟩ = ∑ w α w ∣ w ⟩ W ⊗ ∣ ϕ w ⟩ B over witnesses for x x x (encoded in the computational basis and potentially entangled with an external state ∣ ϕ w ⟩ |\phi_w\rangle ∣ ϕ w ⟩ ), there exist negligible functions μ 1 \mu_1 μ 1 and μ 2 \mu_2 μ 2 such that for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N ,
Pr [ ( 1 2 ∥ ∣ ψ ⟩ ⟨ ψ ∣ − ρ ∥ 1 ≤ μ 1 ( λ ) ) ∧ ( b = ⊤ ) : ( ρ , b ) ← ⟨ P ( ∣ ψ ⟩ ) , V ⟩ ( 1 λ , x ) ] ≥ 1 − μ 2 ( λ ) , \Pr\left[\left(\frac{1}{2}\left\| |\psi\rangle\langle\psi|-\rho\right\|_1 \leq\mu_1(\lambda)\right) \wedge(b=\top) : (\rho,b) \leftarrow\langle P(|\psi\rangle),V\rangle(1^\lambda,x)\right] \geq1-\mu_2(\lambda), Pr [ ( 2 1 ∥ ∣ ψ ⟩ ⟨ ψ ∣ − ρ ∥ 1 ≤ μ 1 ( λ ) ) ∧ ( b = ⊤ ) : ( ρ , b ) ← ⟨ P ( ∣ ψ ⟩) , V ⟩ ( 1 λ , x ) ] ≥ 1 − μ 2 ( λ ) , where P P P acts only on register W \mathcal{W} W and where the notation ( ρ , b ) ← ⟨ P ( ∣ ψ ⟩ ) , V ⟩ ( 1 λ , x ) (\rho,b) \leftarrow\langle P(|\psi\rangle),V\rangle(1^\lambda,x) ( ρ , b ) ← ⟨ P ( ∣ ψ ⟩) , V ⟩ ( 1 λ , x ) means that V V V outputs b ∈ { ⊤ , ⊥ } b \in\{\top,\bot\} b ∈ { ⊤ , ⊥ } and P P P ’s residual state is ρ \rho ρ .
When we wish to be more precise about the repair guarantees, we say that the argument is ( 1 − μ 1 ) (1-\mu_1) ( 1 − μ 1 ) -witness-preserving.
Computational Soundness. For every polynomial ℓ = ℓ ( λ ) \ell=\ell(\lambda) ℓ = ℓ ( λ ) , there exists a negligible function μ \mu μ such that for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N , every x ∉ L x \notin\mathcal{L} x ∈ / L of size ≤ ℓ ( λ ) \leq\ell(\lambda) ≤ ℓ ( λ ) and every QPT cheating prover P ∗ P^* P ∗ with auxiliary input ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ consisting of at most poly ( ℓ ( λ ) ) \operatorname{poly}(\ell(\lambda)) poly ( ℓ ( λ )) qubits
Pr [ ⟨ P ∗ ( ∣ ψ ⟩ ) , V ⟩ ( 1 λ , x ) = ⊤ ] ≤ μ ( λ ) \Pr[\langle P^*(|\psi\rangle),V\rangle(1^\lambda,x)=\top] \leq\mu(\lambda) Pr [⟨ P ∗ ( ∣ ψ ⟩) , V ⟩ ( 1 λ , x ) = ⊤ ] ≤ μ ( λ )
Theorem 6. [27 ] There exists a witness-preserving argument for NP, assuming the existence of dual-mode claw-free trapdoor function family with state recovery (which in turn can be constructed from the post-quantum hardness of LWE [BCM+18]).
Quantum Extraction for Arguments of Classical Knowledge
We next define the notion of indistinguishable-extraction, which is a variation on [30 ] ’s “state-preserving extraction”.17 State-preserving extraction allows generating an indistinguishable transcript and adversarial state while simultaneously extracting a witness. However, obtaining the extracted witness and transcript simultaneously necessarily means collapsing the prover’s witness, which is immediately distinguishable in a witness-preserving argument.
In indistinguishable-extraction, we deliberately avoid collapsing the witness in this way. Instead, we build an interface which temporarily exposes a coherent witness, then “returns” the witness to the adversary without collapsing it. The resulting interface is quite similar to [30 ] ’s guaranteed extraction: there is a unitary extractor Ext which uses a superposition over accepting transcripts to extract a valid witness with overwhelming probability. The difference from guaranteed extraction is that we require Ext \operatorname{Ext} Ext to be unitary . Thus, it may be inverted afterwards, returning the witness.
In what follows, we denote by
View P ∗ ⟨ P ∗ ( ∣ ψ ⟩ ) , V ⟩ ( 1 λ , x ) \operatorname{View}_{P^*}\langle P^*(|\psi\rangle),V\rangle(1^\lambda,x) View P ∗ ⟨ P ∗ ( ∣ ψ ⟩) , V ⟩ ( 1 λ , x )
the view of an adversarial prover P ∗ P^* P ∗ after interacting in the protocol ⟨ P ∗ ( ∣ ψ ⟩ ) , V ⟩ ( 1 λ , x ) \langle P^*(|\psi\rangle),V\rangle(1^\lambda,x) ⟨ P ∗ ( ∣ ψ ⟩) , V ⟩ ( 1 λ , x ) , which includes the transcript in register T \mathcal{T} T as well as the residual state of P ∗ P^* P ∗ in register A \mathcal{A} A .
Definition 10 (Indistinguishably-Extractable Arguments). An NP argument is said to be indistinguishably-extractable if there exist an expected QPT algorithm Sim \operatorname{Sim} Sim and uniform family of poly ( λ ) \operatorname{poly}(\lambda) poly ( λ ) -sized unitaries { Ext λ } λ ∈ N \{\operatorname{Ext}_\lambda\}_{\lambda\in\mathbb{N}} { Ext λ } λ ∈ N satisfying the following for every sufficiently large security parameter λ ∈ N \lambda\in\mathbb{N} λ ∈ N , every adversarial QPT prover P ∗ P^* P ∗ and every NP statement x x x :
Syntax. Sim ( P ∗ ) \operatorname{Sim}(P^*) Sim ( P ∗ ) outputs three registers ( T , A , S ) (\mathcal{T},\mathcal{A},\mathcal{S}) ( T , A , S ) and a decision bit b b b denoting whether T \mathcal{T} T contains an accepting transcript. T \mathcal{T} T contains a superposition over classical transcripts T T T , A \mathcal{A} A contains the adversary’s state, and S \mathcal{S} S is a work register for the simulator.18
Ext \operatorname{Ext} Ext operates on registers ( T , A , S ) (\mathcal{T},\mathcal{A},\mathcal{S}) ( T , A , S ) and reorganizes them into registers ( W , E ) (\mathcal{W},\mathcal{E}) ( W , E ) . W \mathcal{W} W contains the extracted witness and E \mathcal{E} E is a work register.
Tr S [ ∣ ϕ ⟩ T , A , S ] ≈ View P ∗ ⟨ P ∗ , V ⟩ ( 1 λ , x ) \operatorname{Tr}_{\mathcal{S}}\left[|\phi\rangle_{\mathcal{T},\mathcal{A},\mathcal{S}}\right]\approx\operatorname{View}_{P^*}\langle P^*,V\rangle(1^\lambda,x) Tr S [ ∣ ϕ ⟩ T , A , S ] ≈ View P ∗ ⟨ P ∗ , V ⟩ ( 1 λ , x ) where ( ∣ ϕ ⟩ T , A , S , b ) ← Sim P ∗ ( 1 λ , x , ∣ ψ ⟩ ) (|\phi\rangle_{\mathcal{T},\mathcal{A},\mathcal{S}},b)\leftarrow\operatorname{Sim}^{P^*}(1^\lambda,x,|\psi\rangle) ( ∣ ϕ ⟩ T , A , S , b ) ← Sim P ∗ ( 1 λ , x , ∣ ψ ⟩) . If the indistinguishability is computational (resp. statistical), we say the argument is computationally (resp. statistically) indistinguishably-extractable.
Extraction. Let Π Ext , λ = Ext λ † Π Ver Ext λ \Pi_{\operatorname{Ext},\lambda}=\operatorname{Ext}_{\lambda}^{\dagger}\Pi_{\operatorname{Ver}}\operatorname{Ext}_{\lambda} Π Ext , λ = Ext λ † Π Ver Ext λ be the projector onto Ext λ \operatorname{Ext}_{\lambda} Ext λ successfully extracting an accepting witness for x x x to register W \mathcal{W} W . Consider the following experiment Ind \operatorname{Ind} Ind -Ext λ \operatorname{Ext}_{\lambda} Ext λ :
Run ( ∣ ϕ ⟩ T , A , S , b S i m ) ← Sim P ∗ ( 1 λ , x ) (|\phi\rangle_{\mathcal{T},\mathcal{A},\mathcal{S}},b_{\mathrm{Sim}})\leftarrow\operatorname{Sim}^{P^*}(1^\lambda,x) ( ∣ ϕ ⟩ T , A , S , b Sim ) ← Sim P ∗ ( 1 λ , x ) .
If b S i m = ⊤ b_{\mathrm{Sim}}=\top b Sim = ⊤ : measure ∣ ϕ ⟩ T , A , S |\phi\rangle_{\mathcal{T},\mathcal{A},\mathcal{S}} ∣ ϕ ⟩ T , A , S according to { Π Ext , λ , I − Π Ext , λ } \{\Pi_{\operatorname{Ext},\lambda},I-\Pi_{\operatorname{Ext},\lambda}\} { Π Ext , λ , I − Π Ext , λ } . Call the measurement result (representing successful extraction) b E x t b_{\mathrm{Ext}} b Ext .
Then the probability of generating an accepting transcript but failing to extract a valid witness is negligible:
Pr Ind - Ext λ [ b S i m = ⊤ ∧ b E x t = ⊥ ] = negl ( λ ) \Pr_{\operatorname{Ind}\text{-}\operatorname{Ext}_{\lambda}}\left[b_{\mathrm{Sim}}=\top\land b_{\mathrm{Ext}}=\bot\right]=\operatorname{negl}(\lambda) Ind - Ext λ Pr [ b Sim = ⊤ ∧ b Ext = ⊥ ] = negl ( λ )
It will also be useful to define an approximate version, where the extractor is allowed to take poly ( 1 / ϵ ) \operatorname{poly}(1/\epsilon) poly ( 1/ ϵ ) time to extract a witness with probability 1 − ϵ 1-\epsilon 1 − ϵ , for every ϵ \epsilon ϵ .
Definition 11 (ϵ \epsilon ϵ -Indistinguishable-Extractability). We say an argument is ϵ \epsilon ϵ -Indistinguishably-Extractable if there exists an expected QPT Sim and uniform family of poly ( λ , n ) \operatorname{poly}(\lambda,n) poly ( λ , n ) -sized unitaries { { Ext λ , n } n ∈ N } λ ∈ N \{\{\operatorname{Ext}_{\lambda,n}\}_{n\in\mathbb{N}}\}_{\lambda\in\mathbb{N}} {{ Ext λ , n } n ∈ N } λ ∈ N such that
Simulation. Sim P ∗ \operatorname{Sim}^{P^*} Sim P ∗ produces indistinguishable adversarial views.
ϵ \epsilon ϵ -Extraction. Let Ind-Ext λ , n \operatorname{Ind\text{-}Ext}_{\lambda,n} Ind - Ext λ , n be the experiment from Definition 10 using Ext λ , n \operatorname{Ext}_{\lambda,n} Ext λ , n . For all sufficiently large λ ∈ N \lambda\in\mathbb{N} λ ∈ N and all n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) , the probability of a successful transcript but unsuccessful extraction is at most 1 / n 1/n 1/ n :
Pr Ind-Ext λ , ϵ ( n ) [ b S i m = ⊤ ∧ b E x t = ⊥ ] ≤ 1 / n \Pr_{\operatorname{Ind\text{-}Ext}_{\lambda,\epsilon}(n)}[b_{\mathrm{Sim}}=\top\land b_{\mathrm{Ext}}=\bot]\le1/n Ind - Ext λ , ϵ ( n ) Pr [ b Sim = ⊤ ∧ b Ext = ⊥ ] ≤ 1/ n
The almost-as-good-as-new lemma [1 ] (closely related to the gentle measurement lemma [38 ] ) limits the damage that indistinguishable extraction can do to a simulated transcript.
Lemma 6. For all adversarial provers P ∗ P^* P ∗ ,
1 2 ∥ Sim ( P ∗ ) − Ind-Ext λ , n ∥ 1 ≤ 1 / n \frac{1}{2}\left\lVert\operatorname{Sim}(P^*)-\operatorname{Ind\text{-}Ext}_{\lambda,n}\right\rVert_1\le\sqrt{1/n} 2 1 ∥ Sim ( P ∗ ) − Ind - Ext λ , n ∥ 1 ≤ 1/ n
Combining this with the indistinguishability of simulation,
Tr S [ Ind-Ext λ , n 2 ] ≈ 1 / n c View P ∗ ⟨ P ∗ ( ∣ ψ ⟩ ) , V ⟩ ( 1 λ , x ) \operatorname{Tr}_{S}[\operatorname{Ind\text{-}Ext}_{\lambda,n^2}]\mathrel{\overset{1/n}{\approx}_{c}}\operatorname{View}_{P^*}\langle P^*(|\psi\rangle),V\rangle(1^\lambda,x) Tr S [ Ind - Ext λ , n 2 ] ≈ 1/ n c View P ∗ ⟨ P ∗ ( ∣ ψ ⟩) , V ⟩ ( 1 λ , x )
Moreover, if Ind-Ext λ , n 2 \operatorname{Ind\text{-}Ext}_{\lambda,n^2} Ind - Ext λ , n 2 behaves arbitrarily in the case of b S i m = ⊤ ∧ b E x t = ⊥ b_{\mathrm{Sim}}=\top\land b_{\mathrm{Ext}}=\bot b Sim = ⊤ ∧ b Ext = ⊥ , the distance is at most 1 / n + 1 / n 2 1/n+1/n^2 1/ n + 1/ n 2 .
Lombardi, Ma, and Spooner show a general class of protocols which have guaranteed extraction (i.e. Ext \operatorname{Ext} Ext is allowed to be an expected QPT algorithm instead of a unitary). Although the exact conditions are somewhat complex, they specifically list [21 ] 's 3-coloring protocol as satisfying these properties, with a small tweak: commit to the witness first, then run a GMW argument which is amplified in parallel [30 Section 5.3 and Corollary 8.1] . Moreover, Lombardi, Ma, and Spooner show that there exists series of unitary dilations { U ϵ ( n ) } n ∈ N \{U_{\epsilon(n)}\}_{n\in\mathbb{N}} { U ϵ ( n ) } n ∈ N which ϵ \epsilon ϵ -approximate the guaranteed extractor [30 Claim 9.4] .19
Theorem 7. For every (computationally or statistically) collapsing commitment Com \operatorname{Com} Com , the following protocol is statistically ϵ \epsilon ϵ -indistinguishably-extractable.
Commit to the witness w w w using Com \operatorname{Com} Com .
Prove knowledge of an opening to a witness w w w using [21 ] ’s 3-coloring protocol, instantiated with Com.
Finally, we observe that this theorem can be combined with [27 ] ’s construction of witness-preserving arguments. Their construction is a parallel repetition of [21 ] ’s 3-coloring protocol using a specially chosen commitment which admits future recovery of the committed superposition, followed by a recovery procedure after the verifier makes its decision. An additional commitment and recovery step can be added at the start and end of their protocol. The following corollary is obtained by applying the above theorem to the portion of the protocol before recovery and observing that the recovery step afterwards cannot increase the statistical distance.20
Corollary 5. There exists a − - − witness-preserving argument for N P \mathrm{NP} NP with approximate indistinguishable-extraction, assuming the existence of dual-mode claw-free trapdoor function family with state recovery (which in turn can be constructed from the post-quantum hardness of LWE [BCM^{+}18]).
Semi-Quantum Secure 2-Party Computation
In this section, we define 2PC for general quantum circuits G ( ∣ ψ ⟩ , w ) G(\lvert\psi\rangle,w) G (∣ ψ ⟩ , w ) between a classical party P C P_C P C and a quantum party P Q P_Q P Q . P Q P_Q P Q provides the quantum input ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ and P C P_C P C provides the classical input w w w . Without loss of generality, P Q P_Q P Q outputs the coherent output register B \mathcal{B} B and P C P_C P C outputs the measurement result of C \mathcal{C} C . Recall that G G G also discards the subregister D \mathcal{D} D resulting from its evaluation.
Definition 12. Let G G G be a general quantum circuit. We say that a 2-party protocol ( P Q , P C ) (P_Q,P_C) ( P Q , P C ) , where P Q P_Q P Q is a QPT party and P C P_C P C is a PPT (classical) party, securely computes G G G if the following two conditions hold:
Correctness: For every quantum state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ and every classical string w w w , the output distribution of ( P Q ( ∣ ψ ⟩ ) , P C ( w ) ) (P_Q(\lvert\psi\rangle),P_C(w)) ( P Q (∣ ψ ⟩) , P C ( w )) has negligible trace distance to G ( ∣ ψ ⟩ , w ) G(\lvert\psi\rangle,w) G (∣ ψ ⟩ , w ) .
Security against P Q P_Q P Q : For every (possibly malicious) QPT party P Q ∗ P_Q^* P Q ∗ there exists a QPT simulator S Q S_Q S Q such that for every ( ∣ ψ ⟩ , w ) (\lvert\psi\rangle,w) (∣ ψ ⟩ , w ) ,
Ideal S Q ( g , ∣ ψ ⟩ , w ) ≈ Real P Q ∗ ( g , ∣ ψ ⟩ , w ) \operatorname{Ideal}_{S_Q}(g,\lvert\psi\rangle,w) \approx\operatorname{Real}_{P_Q^*}(g,\lvert\psi\rangle,w) Ideal S Q ( g , ∣ ψ ⟩ , w ) ≈ Real P Q ∗ ( g , ∣ ψ ⟩ , w )
Here, Real P Q ∗ ( g , ∣ ψ ⟩ , w ) \operatorname{Real}_{P_Q^*}(g,\lvert\psi\rangle,w) Real P Q ∗ ( g , ∣ ψ ⟩ , w ) is the following distribution:
The outputs of P Q ∗ P_Q^* P Q ∗ and P C P_C P C after interacting in the 2PC protocol, where P C P_C P C simply outputs its output string y y y , or ⊥ \perp ⊥ if the protocol was prematurely terminated, and P Q ∗ P_Q^* P Q ∗ outputs its entire view.
::: Ideal S Q ( g , ∣ ψ ⟩ , w ) \operatorname{Ideal}_{S_Q}(g, |\psi\rangle, w) Ideal S Q ( g , ∣ ψ ⟩ , w ) is the following distribution:
The classical party P C P_C P C sends its input w w w to the ideal functionality, and S Q ( ∣ ψ ⟩ ) S_Q(|\psi\rangle) S Q ( ∣ ψ ⟩) sends an arbitrary register S S S .
The ideal functionality applies the isometry G w = G ( ⋅ , w ) G_w = G(\cdot,w) G w = G ( ⋅ , w ) , obtaining a coherent output register B B B and measurement result y y y . Then, it sends B B B to the simulator.
The simulator decides whether to abort the functionality or not.
If not, the ideal functionality sends y y y to P C P_C P C .
Security Against P C P_C P C : For every (possibly malicious) QPT party P C ∗ P_C^* P C ∗ there exists a QPT simulator S C S_C S C such that for every input pair ( ∣ ψ ⟩ , w ) (|\psi\rangle,w) ( ∣ ψ ⟩ , w ) ,
Ideal S C ( g , ∣ ψ ⟩ , w ) ≈ Real P C ∗ ( g , ∣ ψ ⟩ , w ) . \operatorname{Ideal}_{S_C}(g,|\psi\rangle,w) \approx\operatorname{Real}_{P_C^*}(g,|\psi\rangle,w). Ideal S C ( g , ∣ ψ ⟩ , w ) ≈ Real P C ∗ ( g , ∣ ψ ⟩ , w ) .
Here Real P C ∗ ( g , ∣ ψ ⟩ , w ) \operatorname{Real}_{P_C^*}(g,|\psi\rangle,w) Real P C ∗ ( g , ∣ ψ ⟩ , w ) is the following distribution:
The outputs of P C ∗ P_C^* P C ∗ and P Q P_Q P Q after interacting in the 2PC protocol, where P Q P_Q P Q simply outputs its residual state ∣ ψ y ⟩ |\psi_y\rangle ∣ ψ y ⟩ , or ⊥ \bot ⊥ if the protocol was prematurely terminated, and P C ∗ P_C^* P C ∗ outputs its entire view.
Ideal S C ( g , ∣ ψ ⟩ , w ) \operatorname{Ideal}_{S_C}(g,|\psi\rangle,w) Ideal S C ( g , ∣ ψ ⟩ , w ) is the following distribution:
P Q P_Q P Q sends its input state ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ to the ideal functionality, and S C ( w ) S_C(w) S C ( w ) sends an arbitrary input w ′ w' w ′ .
The ideal functionality computes G ( ∣ ψ ⟩ , w ) G(|\psi\rangle,w) G ( ∣ ψ ⟩ , w ) , obtaining a coherent output register B B B and measurement result y y y . Then, it sends y y y to the simulator.
The simulator decides whether to abort the functionality or not.
If not, the ideal functionality sends register B B B to P Q P_Q P Q .
Definition 13. We say a 2-party protocol ϵ \epsilon ϵ -securely computes g g g if correctness holds and if there exist uniform QPT oracle circuits { S Q , λ , n } λ , n ∈ N \{S_{Q,\lambda,n}\}_{\lambda,n\in\mathbb{N}} { S Q , λ , n } λ , n ∈ N and { S C , λ , n } λ , n ∈ N \{S_{C,\lambda,n}\}_{\lambda,n\in\mathbb{N}} { S C , λ , n } λ , n ∈ N such that for all QPT adversaries P C ∗ P_C^* P C ∗ or P Q ∗ P_Q^* P Q ∗ , all sufficiently large λ \lambda λ and all n = poly ( λ ) n = \operatorname{poly}(\lambda) n = poly ( λ ) ,
Ideal S C ( g , ∣ ψ ⟩ , w , n ) ≈ 1 / n Real P C ∗ ( g , ∣ ψ ⟩ , w ) \operatorname{Ideal}_{S_C}(g,|\psi\rangle,w,n) \mathrel{\approx^{1/n}} \operatorname{Real}_{P_C^*}(g,|\psi\rangle,w) Ideal S C ( g , ∣ ψ ⟩ , w , n ) ≈ 1/ n Real P C ∗ ( g , ∣ ψ ⟩ , w ) Ideal S Q ( g , ∣ ψ ⟩ , w , n ) ≈ 1 / n Real P Q ∗ ( g , ∣ ψ ⟩ , w ) \operatorname{Ideal}_{S_Q}(g,|\psi\rangle,w,n) \mathrel{\approx^{1/n}} \operatorname{Real}_{P_Q^*}(g,|\psi\rangle,w) Ideal S Q ( g , ∣ ψ ⟩ , w , n ) ≈ 1/ n Real P Q ∗ ( g , ∣ ψ ⟩ , w ) where the ideal experiments are defined as above using S Q , λ , n P Q ∗ S_{Q,\lambda,n}^{P_Q^*} S Q , λ , n P Q ∗ or S C , λ , n P C ∗ S_{C,\lambda,n}^{P_C^*} S C , λ , n P C ∗ instead of S Q S_Q S Q or S C S_C S C , respectively.
Honest-But-Curious P C P_C P C Adversaries. By default, we consider any adversary who controls the quantum party P Q P_Q P Q to be “malicious”, meaning it may deviate from the protocol arbitrarily. For the classical party P C P_C P C , however, we consider adversaries controlling them to be “honest-but-curious”. These adversaries behave honestly during the protocol, but attempt to learn additional information from the transcript. They output their entire view at the end of the protocol instead of just the prescribed output.
It is well-known that honest-but-curious security can be generically upgraded to malicious security for parties whose role during the protocol consists only of classical computation . In particular, this consists of applying the GMW compilation to the classical party, using quantum-secure classical subprotocols. [22 , 25 ] . This is done by committing to P C P_C P C ’s input at the start of the protocol, and generating committed randomness for the rest of the protocol by coin-tossing-in-the-well. Then the party proves honest computation of each message with respect to the committed input and randomness, in zero-knowledge. Since P C P_C P C only does honest computation during the protocol, the statements to be proved are in NP, so standard zero-knowledge for NP suffices.
Input-Preserving 2-PC for Classical Constant-Degree Functions with Post-Processed Abort
In this section we construct our input-preserving 2-PC for classical constant-degree functions, where the classical party can decide if the output is delivered adaptively, based on the function output. We start by focusing on linear functionalities. The extension to constant-degree functionalities is pretty straightforward, and is described in § 4.1.8 .
Throughout this section all vector spaces, inner products, and sums are over F 2 \mathbb{F}_2 F 2 . We consider the functionality where the quantum party P Q P_Q P Q takes as input an arbitrary quantum state ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ \sum_{v\in\{0,1\}^{m}} \alpha_v \lvert v\rangle ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ and the classical party P C P_C P C takes as input a linear function L ∈ { 0 , 1 } ℓ × m L \in\{0,1\}^{\ell\times m} L ∈ { 0 , 1 } ℓ × m and a poly-size circuit C : { 0 , 1 } ℓ → { 0 , 1 } C : \{0,1\}^{\ell} \to\{0,1\} C : { 0 , 1 } ℓ → { 0 , 1 } which determines if the output should be delivered or not. Their goal is to securely implement the following quantum circuit G G G :
Ideal Linear Function with Post-Processed Abort. G ( ∣ ψ ⟩ , ( L , C ) ) G(\lvert\psi\rangle,(L,C)) G (∣ ψ ⟩ , ( L , C )) uses the following inputs. P Q P_Q P Q provides a quantum state ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ \sum_{v\in\{0,1\}^{m}} \alpha_v \lvert v\rangle ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ . P C P_C P C provides a linear function L ∈ { 0 , 1 } ℓ × m L \in\{0,1\}^{\ell\times m} L ∈ { 0 , 1 } ℓ × m and a poly-size classical circuit C : { 0 , 1 } ℓ → { 0 , 1 } C : \{0,1\}^{\ell} \to\{0,1\} C : { 0 , 1 } ℓ → { 0 , 1 } . Then, G G G works as follows:
Compute
∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ ∣ L v ⟩ \sum_{v\in\{0,1\}^{m}} \alpha_v |v\rangle|L_v\rangle v ∈ { 0 , 1 } m ∑ α v ∣ v ⟩ ∣ L v ⟩
Measure the last register to obtain u ∈ { 0 , 1 } ℓ \mathbf{u} \in\{0,1\}^{\ell} u ∈ { 0 , 1 } ℓ . Keep the residual state ∣ φ ⟩ |\varphi\rangle ∣ φ ⟩ , where
∣ φ ⟩ ∝ ∑ v ∈ { 0 , 1 } m : L v = u α v ∣ v ⟩ |\varphi\rangle\propto\sum_{v\in\{0,1\}^{m}:L_v=\mathbf{u}} \alpha_v |v\rangle ∣ φ ⟩ ∝ v ∈ { 0 , 1 } m : L v = u ∑ α v ∣ v ⟩
If C ( u ) = 0 C(\mathbf{u})=0 C ( u ) = 0 then place ∣ φ ⟩ |\varphi\rangle ∣ φ ⟩ in register B \mathcal{B} B . Otherwise discard ∣ φ ⟩ |\varphi\rangle ∣ φ ⟩ .
Output register B \mathcal{B} B (which is sent to P Q P_Q P Q ) and u \mathbf{u} u (which is sent to P C P_C P C ).
Recall that the ideal functionality for G G G also permits the adversary to abort the computation after seeing its output. We slightly modify the ideal functionality so that P C P_C P C always gets its input before P Q P_Q P Q does. In particular, an adversarial P Q P_Q P Q does not get to see its own output before deciding whether to abort.
Theorem 8. There exist a ϵ \epsilon ϵ -simulateable input-preserving 2PC for classical linear functions with post-processed abort under the post-quantum hardness of LWE.
If there additionally exists an indistinguishable extractable witness-preserving argument for NP, then the 2PC has negligible-loss security instead.
Construction
Setup
Cryptographic primitives Our protocol makes use of the following primitives:
Noisy trapdoor claw-free function family with the adaptive 2-query hardcore bit property, as defined in § 3.6 . We denote this family by
( S e t u p , E v a l , I n v e r t , C h e c k , S y n d ) (\mathsf{Setup},\mathsf{Eval},\mathsf{Invert},\mathsf{Check},\mathsf{Synd}) ( Setup , Eval , Invert , Check , Synd )
Witness-preserving indistinguishably-extractable argument for NP, as defined in § 3.7 .
We note that both these primitives can be instantiated from the LWE assumption.
Encoding Matrices. We will use the following matrices to encode the inputs of each party. Fix a logical input length m ≥ 1 m \ge1 m ≥ 1 and let N : = m + ( m 2 ) N := m + \binom{m}{2} N := m + ( 2 m ) be the encoded input length. Let K m K_m K m be the ( m 2 ) × m \binom{m}{2} \times m ( 2 m ) × m edge–vertex incidence matrix of the complete graph on m m m vertices. Its rows are all possible combinations of 2 standard basis vectors e j + e k e_j+e_k e j + e k .
Define the generator matrix G G G , decoder matrix D D D , and parity-check matrix P P P by
G : = ( I m K m ) ∈ F 2 N × m , D : = ( I m 0 m × ( N − m ) ) ∈ F 2 m × N , P : = ( K m I N − m ) ∈ F 2 ( N − m ) × N . (6) \begin{aligned}
G &:= \begin{pmatrix} I_m \\ K_m \end{pmatrix} \in\mathbb{F}_2^{N \times m},\\
D &:= \left(I_m\ \ 0_{m \times(N-m)}\right) \in\mathbb{F}_2^{m \times N},\\
P &:= \left(K_m\ \ I_{N-m}\right) \in\mathbb{F}_2^{(N-m) \times N}. \tag*{(6)}
\end{aligned} G D P := ( I m K m ) ∈ F 2 N × m , := ( I m 0 m × ( N − m ) ) ∈ F 2 m × N , := ( K m I N − m ) ∈ F 2 ( N − m ) × N . (6)
These matrices satisfy
D G = I m , P G = 0 , rank ( P ) = N − m . DG = I_m,\qquad PG = 0,\qquad\operatorname{rank}(P) = N-m. D G = I m , P G = 0 , rank ( P ) = N − m .
We will encode the inputs of each party as
L ′ = L D + R P v ′ = G v (7) \begin{aligned}
L' &= LD + RP\\
\mathbf{v}' &= Gv \tag*{(7)}
\end{aligned} L ′ v ′ = L D + R P = G v (7)
where R R R is a random ℓ × ( N − m ) \ell\times(N-m) ℓ × ( N − m ) matrix. For a column vector v ∈ F 2 m \mathbf{v} \in\mathbb{F}_2^m v ∈ F 2 m , the encoding v ′ = G v \mathbf{v}' = G\mathbf{v} v ′ = G v consists of the m m m original coordinates followed by all ( m 2 ) \binom{m}{2} ( 2 m ) pairwise parities v j + v k v_j+v_k v j + v k . Therefore
L ′ v ′ = L ( D G ) v + R ( P G ) = L v L'\mathbf{v}' = L(DG)\mathbf{v} + R(PG) = L\mathbf{v} L ′ v ′ = L ( D G ) v + R ( P G ) = L v
Protocol
Protocol 1 (Input-Preserving 2-PC for the linear functionality). The quantum party P Q P_Q P Q takes as input a register V V V containing an arbitrary state
∣ ψ ⟩ = ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ V |\psi\rangle= \sum_{\mathbf{v}\in\{0,1\}^m} \alpha_{\mathbf{v}} |\mathbf{v}\rangle_V ∣ ψ ⟩ = v ∈ { 0 , 1 } m ∑ α v ∣ v ⟩ V
The classical party P C P_C P C takes as input a linear function L ∈ { 0 , 1 } ℓ × m L \in\{0,1\}^{\ell\times m} L ∈ { 0 , 1 } ℓ × m and a poly-size circuit C : { 0 , 1 } ℓ → { 0 , 1 } C : \{0,1\}^{\ell} \to\{0,1\} C : { 0 , 1 } ℓ → { 0 , 1 } . For every ( i , j ) ∈ [ ℓ ] × [ m ] (i,j) \in[\ell] \times[m] ( i , j ) ∈ [ ℓ ] × [ m ] let L i , j ∈ { 0 , 1 } L_{i,j} \in\{0,1\} L i , j ∈ { 0 , 1 } denote the ( i , j ) (i,j) ( i , j ) entry of L L L and let v j v_j v j denote the j j j th entry of v \mathbf{v} v .
Phase 0: Input Encoding Denote v ′ = G v \mathbf{v}' = G\mathbf{v} v ′ = G v . The quantum party P Q P_Q P Q encodes its state to be the state
∣ ψ ′ ⟩ = ∑ v ∈ { 0 , 1 } m α v ∣ v , G v ⟩ . |\psi'\rangle= \sum_{\mathbf{v}\in\{0,1\}^m} \alpha_{\mathbf{v}} |\mathbf{v},G\mathbf{v}\rangle. ∣ ψ ′ ⟩ = v ∈ { 0 , 1 } m ∑ α v ∣ v , G v ⟩ .
The classical party P C P_C P C samples a random matrix R ← F 2 ℓ × ( N − m ) R \leftarrow\mathbb{F}_2^{\ell\times(N-m)} R ← F 2 ℓ × ( N − m ) and sets
L ′ = L D + R P . L' = LD + RP. L ′ = L D + R P .
Phase 1: entry-wise NTCF commitments.
P C P_{\mathrm{C}} P C samples for every ( i , j ) ∈ [ ℓ ] × [ N ] (i,j) \in[\ell] \times[N] ( i , j ) ∈ [ ℓ ] × [ N ] ,
( p p i , j , t d i , j ) ← NTCF.Setup ( 1 λ ) , (\mathrm{pp}_{i,j},\mathrm{td}_{i,j}) \leftarrow\operatorname{NTCF.Setup}(1^\lambda), ( pp i , j , td i , j ) ← NTCF.Setup ( 1 λ ) ,
and sends to P Q P_{\mathrm{Q}} P Q the public parameters
p p : = { p p i , j } i ∈ [ ℓ ] , j ∈ [ N ] . \mathrm{pp} := \{\mathrm{pp}_{i,j}\}_{i\in[\ell],\,j\in[N]}. pp := { pp i , j } i ∈ [ ℓ ] , j ∈ [ N ] .
P Q P_{\mathrm{Q}} P Q parses v ′ = ( v 1 ′ , … , v N ′ ) ∈ F 2 N \mathbf{v}'=(v'_1,\ldots,v'_N)\in\mathbb{F}_2^N v ′ = ( v 1 ′ , … , v N ′ ) ∈ F 2 N and does the following:
(a) Using the efficient range superposition preparation property of the NTCF, add randomness registers for every ( i , j ) (i,j) ( i , j ) and coherently evaluate Eval ( p p i , j , v j ′ , x i , j ) \operatorname{Eval}(\mathrm{pp}_{i,j},v'_j,x_{i,j}) Eval ( pp i , j , v j ′ , x i , j ) using the same input bit v j ′ v'_j v j ′ for every i ∈ [ ℓ ] i\in[\ell] i ∈ [ ℓ ] , to obtain the state
∑ v ∈ { 0 , 1 } m α v ∣ v , v ′ ⟩ V V ⨂ i = 1 ℓ ⨂ j = 1 N ∑ x i , j ∈ F 2 n p p p ( v j ′ , x i , j , y i , j ) ∣ x i , j ⟩ R i , j ∣ y i , j ⟩ . \sum_{\mathbf{v}\in\{0,1\}^m}\alpha_{\mathbf{v}}|\mathbf{v},\mathbf{v}'\rangle_{\mathsf{VV}}\bigotimes_{i=1}^{\ell}\bigotimes_{j=1}^{N}\sum_{x_{i,j}\in\mathbb{F}_2^n}\sqrt{p_{\mathrm{pp}}(v'_j,x_{i,j},y_{i,j})}|x_{i,j}\rangle_{\mathcal{R}_{i,j}}|y_{i,j}\rangle. v ∈ { 0 , 1 } m ∑ α v ∣ v , v ′ ⟩ VV i = 1 ⨂ ℓ j = 1 ⨂ N x i , j ∈ F 2 n ∑ p pp ( v j ′ , x i , j , y i , j ) ∣ x i , j ⟩ R i , j ∣ y i , j ⟩ .
where p p p ( v j ′ , x i , j , y i , j ) p_{\mathrm{pp}}(v'_j,x_{i,j},y_{i,j}) p pp ( v j ′ , x i , j , y i , j ) is the probability density of y y y in the distribution Eval ( p p i , j , v j ′ , x i , j ) \operatorname{Eval}(\mathrm{pp}_{i,j},v'_j,x_{i,j}) Eval ( pp i , j , v j ′ , x i , j ) .
(b) Measure the image registers to obtain y = ( y i , j ) ( i , j ) ∈ [ ℓ ] × [ N ] \mathbf{y}=(y_{i,j})_{(i,j)\in[\ell]\times[N]} y = ( y i , j ) ( i , j ) ∈ [ ℓ ] × [ N ] , and send y \mathbf{y} y to P C P_{\mathrm{C}} P C .
The honest residual state is of the form
∑ v ∈ { 0 , 1 } m α v ∣ v , v ′ ⟩ V V ⨂ i = 1 ℓ ⨂ j = 1 N ∣ x i , j , v j ′ ⟩ R i , j , \sum_{\mathbf{v}\in\{0,1\}^m}\alpha_{\mathbf{v}}|\mathbf{v},\mathbf{v}'\rangle_{\mathsf{VV}}\bigotimes_{i=1}^{\ell}\bigotimes_{j=1}^{N}|x_{i,j,v'_j}\rangle_{\mathcal{R}_{i,j}}, v ∈ { 0 , 1 } m ∑ α v ∣ v , v ′ ⟩ VV i = 1 ⨂ ℓ j = 1 ⨂ N ∣ x i , j , v j ′ ⟩ R i , j ,
where
Check ( p p i , j , v j ′ , x i , j , v j ′ , y i , j ) = 1. \operatorname{Check}(\mathrm{pp}_{i,j},v'_j,x_{i,j,v'_j},y_{i,j})=1. Check ( pp i , j , v j ′ , x i , j , v j ′ , y i , j ) = 1.
The parties then run a witness-preserving indistinguishably-extractable argument for the relation
R c o m = { ( ( p p , y ) , ( v , v ′ , { x i , j } ( i , j ) ∈ [ ℓ ] × [ N ] ) ) : v ′ = G v ∧ ∀ i , j , Check ( p p i , j , v j ′ , x i , j , y i , j ) = 1 } . \mathcal{R}_{\mathrm{com}}=\left\{\left((\mathrm{pp},\mathbf{y}),(\mathbf{v},\mathbf{v}',\{x_{i,j}\}_{(i,j)\in[\ell]\times[N]})\right):
\mathbf{v}'=G\mathbf{v}\ \land\ \forall i,j,\ \operatorname{Check}(\mathrm{pp}_{i,j},v'_j,x_{i,j},y_{i,j})=1\right\}. R com = { ( ( pp , y ) , ( v , v ′ , { x i , j } ( i , j ) ∈ [ ℓ ] × [ N ] ) ) : v ′ = G v ∧ ∀ i , j , Check ( pp i , j , v j ′ , x i , j , y i , j ) = 1 } .
If the verifier rejects, P C P_{\mathrm{C}} P C aborts.
Phase 2: Masking L ′ L' L ′ . P C P_{\mathrm{C}} P C does the following for every ( i , j ) ∈ [ ℓ ] × [ N ] (i,j)\in[\ell]\times[N] ( i , j ) ∈ [ ℓ ] × [ N ] :
Compute Invert ( t d i , j , y i , j ) \operatorname{Invert}(\mathrm{td}_{i,j},y_{i,j}) Invert ( td i , j , y i , j ) , if the output is ⊥ \perp ⊥ then abort. Otherwise the output is of the form ( ( 0 , x i , j , 0 ) , ( 1 , x i , j , 1 ) ) ((0,x_{i,j,0}),(1,x_{i,j,1})) (( 0 , x i , j , 0 ) , ( 1 , x i , j , 1 )) , in which case define
Δ i , j : = ( 1 , x i , j , 0 ⊕ x i , j , 1 ) . \Delta_{i,j}:=(1,x_{i,j,0}\oplus x_{i,j,1}). Δ i , j := ( 1 , x i , j , 0 ⊕ x i , j , 1 ) .
Sample d i , j ← { 0 , 1 } n + 1 d_{i,j}\leftarrow\{0,1\}^{n+1} d i , j ← { 0 , 1 } n + 1 and compute
p i , j : = ( d i , j ⋅ Δ i , j ) ⊕ L i , j ′ . p_{i,j}:=(d_{i,j}\cdot\Delta_{i,j})\oplus L'_{i,j}. p i , j := ( d i , j ⋅ Δ i , j ) ⊕ L i , j ′ .
P C P_{\mathrm{C}} P C sends ( d , p ) (\mathbf{d},\mathbf{p}) ( d , p ) to P Q P_{\mathrm{Q}} P Q where
d = ( d i , j ) ( i , j ) ∈ [ ℓ ] × [ N ] and p = ( p i , j ) ( i , j ) ∈ [ ℓ ] × [ N ] . \mathbf{d}=(d_{i,j})_{(i,j)\in[\ell]\times[N]}\quad\text{and}\quad\mathbf{p}=(p_{i,j})_{(i,j)\in[\ell]\times[N]}. d = ( d i , j ) ( i , j ) ∈ [ ℓ ] × [ N ] and p = ( p i , j ) ( i , j ) ∈ [ ℓ ] × [ N ] .
Phase 3: measuring the hidden linear function.
P Q P_{\mathrm{Q}} P Q coherently computes into a fresh register for every i ∈ [ ℓ ] i \in[\ell] i ∈ [ ℓ ]
t i = ⨁ j = 1 N ( ( d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ⊕ p i , j v j ′ ) t_i = \bigoplus_{j=1}^{N} \left((d_{i,j} \cdot(v'_j,x_{i,j,v'_j}) \oplus p_{i,j}v'_j\right) t i = j = 1 ⨁ N ( ( d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ⊕ p i , j v j ′ )
It measures the resulting register t = ( t 1 , … , t ℓ ) ∈ { 0 , 1 } ℓ \mathbf{t} = (t_1,\ldots,t_\ell) \in\{0,1\}^{\ell} t = ( t 1 , … , t ℓ ) ∈ { 0 , 1 } ℓ , and sends t \mathbf{t} t to P C P_{\mathrm{C}} P C .
Note that
t = ( ⨁ j = 1 N ( d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ⊕ p i , j v j ′ ) ) i ∈ [ ℓ ] = ( ⨁ j = 1 N d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ) i ∈ [ ℓ ] ⊕ ( ⨁ j = 1 N v j ′ ⋅ ( ( d i , j ⋅ Δ i , j ) ⊕ L i , j ′ ) ) i ∈ [ ℓ ] = ( ⨁ j = 1 N d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ) i ∈ [ ℓ ] ⊕ ( ⨁ j = 1 N v j ′ ( d i , j ⋅ Δ i , j ) ) i ∈ [ ℓ ] ⊕ ( ⨁ j = 1 N v j ′ ⋅ L i , j ′ ) i ∈ [ ℓ ] = ( ⨁ j = 1 N d i , j ⋅ ( ( v j ′ , x i , j , v j ′ ) ⊕ v j ′ Δ i , j ) ) i ∈ [ ℓ ] ⊕ L ′ v ′ = ( ⨁ j = 1 N d i , j ⋅ ( 0 , x i , j , 0 ) ) i ∈ [ ℓ ] ⊕ L v . \begin{aligned}
\mathbf{t} =
\left(
\bigoplus_{j=1}^{N}
\left(d_{i,j} \cdot(v'_j,x_{i,j,v'_j}) \oplus p_{i,j}v'_j\right)
\right)_{i \in[\ell]} \\
&=
\left(
\bigoplus_{j=1}^{N} d_{i,j} \cdot(v'_j,x_{i,j,v'_j})
\right)_{i \in[\ell]}
\oplus
\left(
\bigoplus_{j=1}^{N} v'_j \cdot((d_{i,j} \cdot\Delta_{i,j}) \oplus L'_{i,j})
\right)_{i \in[\ell]} \\
&=
\left(
\bigoplus_{j=1}^{N} d_{i,j} \cdot(v'_j,x_{i,j,v'_j})
\right)_{i \in[\ell]}
\oplus
\left(
\bigoplus_{j=1}^{N} v'_j(d_{i,j} \cdot\Delta_{i,j})
\right)_{i \in[\ell]}
\oplus
\left(
\bigoplus_{j=1}^{N} v'_j \cdot L'_{i,j}
\right)_{i \in[\ell]} \\
&=
\left(
\bigoplus_{j=1}^{N} d_{i,j} \cdot((v'_j,x_{i,j,v'_j}) \oplus v'_j\Delta_{i,j})
\right)_{i \in[\ell]}
\oplus L'v' \\
&=
\left(
\bigoplus_{j=1}^{N} d_{i,j} \cdot(0,x_{i,j,0})
\right)_{i \in[\ell]}
\oplus L\mathbf{v}.
\end{aligned} t = ( j = 1 ⨁ N ( d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ⊕ p i , j v j ′ ) ) i ∈ [ ℓ ] = ( j = 1 ⨁ N d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ) i ∈ [ ℓ ] ⊕ ( j = 1 ⨁ N v j ′ ⋅ (( d i , j ⋅ Δ i , j ) ⊕ L i , j ′ ) ) i ∈ [ ℓ ] = ( j = 1 ⨁ N d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ) i ∈ [ ℓ ] ⊕ ( j = 1 ⨁ N v j ′ ( d i , j ⋅ Δ i , j ) ) i ∈ [ ℓ ] ⊕ ( j = 1 ⨁ N v j ′ ⋅ L i , j ′ ) i ∈ [ ℓ ] = ( j = 1 ⨁ N d i , j ⋅ (( v j ′ , x i , j , v j ′ ) ⊕ v j ′ Δ i , j ) ) i ∈ [ ℓ ] ⊕ L ′ v ′ = ( j = 1 ⨁ N d i , j ⋅ ( 0 , x i , j , 0 ) ) i ∈ [ ℓ ] ⊕ L v .
Note that the first summation, denoted by
a : = ( ⨁ j = 1 N d i , j ⋅ ( 0 , x i , j , 0 ) ) i ∈ [ ℓ ] (8) \mathbf{a} := \left(
\bigoplus_{j=1}^{N} d_{i,j} \cdot(0,x_{i,j,0})
\right)_{i \in[\ell]} \tag*{(8)} a := ( j = 1 ⨁ N d i , j ⋅ ( 0 , x i , j , 0 ) ) i ∈ [ ℓ ] (8)
is fixed. This implies that this measurement collapses the state to v \mathbf{v} v such that L v = t ⊕ a L\mathbf{v} = \mathbf{t} \oplus\mathbf{a} L v = t ⊕ a .
The parties run a second witness-preserving indistinguishably-extractable argument for the relation
R e v a l = { ( ( p p , y , d , p , t ) , ( v , v ′ , { x i , j } i , j ) ) : v ′ = G v ∧ ∀ i , j , Check ( p p i , j , v j ′ , x i , j , y i , j ) = 1 ∧ ∀ i , t i = ⨁ j = 1 N ( d i , j ⋅ ( v j ′ , x i , j ) ⊕ p i , j v j ′ ) } . \mathcal{R}_{\mathrm{eval}} =
\left\{
\begin{array}{l}
((\mathsf{pp},\mathbf{y},\mathbf{d},\mathbf{p},\mathbf{t}),(\mathbf{v},\mathbf{v}',\{x_{i,j}\}_{i,j})) :
\\
\mathbf{v}' = G\mathbf{v}
\\
\land\ \forall i,j,\ \operatorname{Check}(\mathsf{pp}_{i,j},v'_j,x_{i,j},y_{i,j}) = 1
\\
\land\ \forall i,\ t_i = \bigoplus_{j=1}^{N}(d_{i,j} \cdot(v'_j,x_{i,j}) \oplus p_{i,j}v'_j)
\end{array}
\right\}. R eval = ⎩ ⎨ ⎧ (( pp , y , d , p , t ) , ( v , v ′ , { x i , j } i , j )) : v ′ = G v ∧ ∀ i , j , Check ( pp i , j , v j ′ , x i , j , y i , j ) = 1 ∧ ∀ i , t i = ⨁ j = 1 N ( d i , j ⋅ ( v j ′ , x i , j ) ⊕ p i , j v j ′ ) ⎭ ⎬ ⎫ .
If the verifier rejects, P C P_{\mathrm{C}} P C aborts.
P C P_C P C computes a = ( a 1 , … , a ℓ ) ∈ { 0 , 1 } ℓ \mathbf{a}=(a_1,\ldots,a_\ell)\in\{0,1\}^\ell a = ( a 1 , … , a ℓ ) ∈ { 0 , 1 } ℓ as in Equation (8) , and stores the output
u = t ⊕ a . \mathbf{u}=\mathbf{t}\oplus\mathbf{a}. u = t ⊕ a .
If C ( u ) = 1 C(\mathbf{u})=1 C ( u ) = 1 then send ⊥ \perp ⊥ to P Q P_Q P Q , abort the protocol, and output u \mathbf{u} u .
Otherwise, continue to the recovery phase.
Phase 4: recovery. This phase is executed only if C ( u ) = 0 C(\mathbf{u})=0 C ( u ) = 0 . Party P C P_C P C has already stored u \mathbf{u} u as its output.
P Q P_Q P Q applies H ⊗ n H^{\otimes n} H ⊗ n to every preimage register R i , j R_{i,j} R i , j , for ( i , j ) ∈ [ ℓ ] × [ N ] (i,j)\in[\ell]\times[N] ( i , j ) ∈ [ ℓ ] × [ N ] , and measures these registers in the computational basis. Denote the outcomes by
e i , j ∈ { 0 , 1 } n . \mathbf{e}_{i,j}\in\{0,1\}^{n}. e i , j ∈ { 0 , 1 } n .
It sends ( e i , j ) i ∈ [ ℓ ] , j ∈ [ N ] (\mathbf{e}_{i,j})_{i\in[\ell],\,j\in[N]} ( e i , j ) i ∈ [ ℓ ] , j ∈ [ N ] to P C P_C P C .
P C P_C P C checks that the message has the prescribed format and that, for every ( i , j ) ∈ [ ℓ ] × [ N ] (i,j)\in[\ell]\times[N] ( i , j ) ∈ [ ℓ ] × [ N ] and every b ∈ { 0 , 1 } b\in\{0,1\} b ∈ { 0 , 1 } ,
Synd ( b , x i , j , b , e i , j ) ∉ { 0 , Synd ( b , x i , j , b , d i , j ) } . \operatorname{Synd}(b,x_{i,j,b},\mathbf{e}_{i,j})\notin\{0,\operatorname{Synd}(b,x_{i,j,b},\mathbf{d}_{i,j})\}. Synd ( b , x i , j , b , e i , j ) ∈ / { 0 , Synd ( b , x i , j , b , d i , j )} .
If any check fails, P C P_C P C sends ⊥ \perp ⊥ and terminates, retaining its stored output u \mathbf{u} u . No recovery bits are released in this case, and no further recovery query is answered. Otherwise, P C P_C P C computes
β i , j : = e i , j ⋅ ( x i , j , 0 ⊕ x i , j , 1 ) , ζ j : = ⨁ i = 1 ℓ β i , j , j ∈ [ N ] . \beta_{i,j}:=\mathbf{e}_{i,j}\cdot(x_{i,j,0}\oplus x_{i,j,1}),\qquad
\zeta_j:=\bigoplus_{i=1}^{\ell}\beta_{i,j},\quad j\in[N]. β i , j := e i , j ⋅ ( x i , j , 0 ⊕ x i , j , 1 ) , ζ j := i = 1 ⨁ ℓ β i , j , j ∈ [ N ] .
It sends
ζ : = ( ζ 1 , … , ζ N ) ∈ { 0 , 1 } N \boldsymbol{\zeta}:=(\zeta_1,\ldots,\zeta_N)\in\{0,1\}^{N} ζ := ( ζ 1 , … , ζ N ) ∈ { 0 , 1 } N
to P Q P_Q P Q , and outputs the stored value u \mathbf{u} u .
If P Q P_Q P Q receives ⊥ \perp ⊥ , it discards its quantum registers and outputs ⊥ \perp ⊥ . Otherwise, P Q P_Q P Q applies Z ζ Z^{\boldsymbol{\zeta}} Z ζ to the encoded register W W W . It then applies the inverse of the encoding circuit from Phase 0, retains the original m m m input qubits, discards the resulting zero ancillas, and outputs the retained register.
We next prove Theorem 8 by arguing that the protocol above satisfies the required correctness and security guarantees.
Correctness of Protocol 1
Lemma 7 (Correctness). Assume P C ( L , C ) P_C(L,C) P C ( L , C ) and P Q ( ρ A , B ) P_Q(\rho_{A,B}) P Q ( ρ A , B ) honestly execute Protocol 1 using inputs ( L , C ) (L,C) ( L , C ) and register A A A , respectively. Then for all ( L , C ) (L,C) ( L , C ) and ρ A , B \rho_{A,B} ρ A , B , the joint output distribution of P C P_C P C and P Q P_Q P Q together with register B B B has negl ( λ ) \operatorname{negl}(\lambda) negl ( λ ) trace distance to
∑ u ∣ u ⟩ ⟨ u ∣ ⊗ ( ( Π L , u ⊗ I B ) ρ A , B ( Π L , u ⊗ I B ) ) \sum_{\mathbf{u}} |\mathbf{u}\rangle\langle\mathbf{u}| \otimes\left((\Pi_{L,\mathbf{u}} \otimes I_B)\rho_{A,B}(\Pi_{L,\mathbf{u}} \otimes I_B)\right) u ∑ ∣ u ⟩ ⟨ u ∣ ⊗ ( ( Π L , u ⊗ I B ) ρ A , B ( Π L , u ⊗ I B ) ) where Π L , u = ∑ v : L v = u ∣ v ⟩ ⟨ v ∣ \Pi_{L,\mathbf{u}}=\sum_{\mathbf{v}:L\mathbf{v}=\mathbf{u}}|\mathbf{v}\rangle\langle\mathbf{v}| Π L , u = ∑ v : L v = u ∣ v ⟩ ⟨ v ∣ projects onto ∣ v ⟩ |\mathbf{v}\rangle ∣ v ⟩ such that L v = u L\mathbf{v}=\mathbf{u} L v = u and where the first register is P C P_C P C ’s output and the second is P Q P_Q P Q ’s output together with register B B B . The only exception occurs when C ( u ) = 1 C(\mathbf{u})=1 C ( u ) = 1 , in which case the relation holds when register A A A is traced out.
Proof. The witness-preserving property of the two NP arguments ensures that the quantum party’s witness register is negligibly disturbed by the arguments. Thus, we omit them in the following analysis at the cost of a negligible error.
After Phase 1, the perfect matching and efficient range superposition properties of the NTCF imply that the honest residual state is statistically close to
∣ Φ ⟩ = ∑ v ∈ { 0 , 1 } m α v ∣ v , G v ⟩ V ⨂ i = 1 ℓ ⨂ j = 1 N ∣ x i , j , v j ′ ⟩ R i , j , |\Phi\rangle=\sum_{\mathbf{v}\in\{0,1\}^{m}}\alpha_{\mathbf{v}}|\mathbf{v},G\mathbf{v}\rangle_V\bigotimes_{i=1}^{\ell}\bigotimes_{j=1}^{N}|x_{i,j,v'_j}\rangle_{R_{i,j}}, ∣Φ ⟩ = v ∈ { 0 , 1 } m ∑ α v ∣ v , G v ⟩ V i = 1 ⨂ ℓ j = 1 ⨂ N ∣ x i , j , v j ′ ⟩ R i , j ,
where
Check ( p p i , j , v j ′ , x i , j , v j ′ , y i , j ) = 1. \operatorname{Check}(\mathrm{pp}_{i,j},v'_j,x_{i,j,v'_j},y_{i,j})=1. Check ( pp i , j , v j ′ , x i , j , v j ′ , y i , j ) = 1.
For every ( i , j ) (i,j) ( i , j ) the two valid preimages satisfy
( v j ′ , x i , j , v j ′ ) = ( 0 , x i , j , 0 ) ⊕ v j ′ Δ i , j , (v'_j,x_{i,j,v'_j})=(0,x_{i,j,0})\oplus v'_j\Delta_{i,j}, ( v j ′ , x i , j , v j ′ ) = ( 0 , x i , j , 0 ) ⊕ v j ′ Δ i , j ,
where
Δ i , j : = ( 0 , x i , j , 0 ) ⊕ ( 1 , x i , j , 1 ) . \Delta_{i,j}:=(0,x_{i,j,0})\oplus(1,x_{i,j,1}). Δ i , j := ( 0 , x i , j , 0 ) ⊕ ( 1 , x i , j , 1 ) .
We first analyze the measurement in Phase 3. For each row i ∈ [ ℓ ] i\in[\ell] i ∈ [ ℓ ] , the honest quantum party computes
t i = ⨁ j = 1 N ( d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ⊕ p i , j v j ′ ) . t_i=\bigoplus_{j=1}^{N}\left(d_{i,j}\cdot(v'_j,x_{i,j,v'_j})\oplus p_{i,j}v'_j\right). t i = j = 1 ⨁ N ( d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ⊕ p i , j v j ′ ) .
Using the fact that
( v j ′ , x i , j , v j ′ ) = ( 0 , x i , j , 0 ) ⊕ v j ′ Δ i , j , (v'_j,x_{i,j,v'_j})=(0,x_{i,j,0})\oplus v'_j\Delta_{i,j}, ( v j ′ , x i , j , v j ′ ) = ( 0 , x i , j , 0 ) ⊕ v j ′ Δ i , j ,
we have
d i , j ⋅ ( v j ′ , x i , j , v j ′ ) = d i , j ⋅ ( 0 , x i , j , 0 ) ⊕ v j ′ ( d i , j ⋅ Δ i , j ) . d_{i,j}\cdot(v'_j,x_{i,j,v'_j})=d_{i,j}\cdot(0,x_{i,j,0})\oplus v'_j(d_{i,j}\cdot\Delta_{i,j}). d i , j ⋅ ( v j ′ , x i , j , v j ′ ) = d i , j ⋅ ( 0 , x i , j , 0 ) ⊕ v j ′ ( d i , j ⋅ Δ i , j ) .
Therefore
d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ⊕ p i , j v j ′ = d i , j ⋅ ( 0 , x i , j , 0 ) ⊕ v j ′ ( d i , j ⋅ Δ i , j ⊕ p i , j ) = d i , j ⋅ ( 0 , x i , j , 0 ) ⊕ L i , j ′ v j ′ . \begin{aligned}
d_{i,j}\cdot(v'_j,x_{i,j,v'_j})\oplus p_{i,j}v'_j
&=d_{i,j}\cdot(0,x_{i,j,0})\oplus v'_j(d_{i,j}\cdot\Delta_{i,j}\oplus p_{i,j})\\
&=d_{i,j}\cdot(0,x_{i,j,0})\oplus L'_{i,j}v'_j.
\end{aligned} d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ⊕ p i , j v j ′ = d i , j ⋅ ( 0 , x i , j , 0 ) ⊕ v j ′ ( d i , j ⋅ Δ i , j ⊕ p i , j ) = d i , j ⋅ ( 0 , x i , j , 0 ) ⊕ L i , j ′ v j ′ .
where the last equality follows from the fact that
p i , j = d i , j ⋅ Δ i , j ⊕ L i , j ′ . p_{i,j}=d_{i,j}\cdot\Delta_{i,j}\oplus L'_{i,j}. p i , j = d i , j ⋅ Δ i , j ⊕ L i , j ′ .
Hence
t i = ( ⨁ j = 1 N d i , j ⋅ ( 0 , x i , j , 0 ) ) ⊕ ( ⨁ j = 1 N L i , j ′ v j ′ ) = a i ⊕ ( L ′ v ′ ) i . t_i=\left(\bigoplus_{j=1}^{N}\mathbf{d}_{i,j}\cdot(0,\mathbf{x}_{i,j,0})\right)\oplus\left(\bigoplus_{j=1}^{N}L'_{i,j}\mathbf{v}'_j\right)=a_i\oplus(L'\mathbf{v}')_i. t i = ( j = 1 ⨁ N d i , j ⋅ ( 0 , x i , j , 0 ) ) ⊕ ( j = 1 ⨁ N L i , j ′ v j ′ ) = a i ⊕ ( L ′ v ′ ) i .
where
a i : = ⨁ j = 1 N d i , j ⋅ ( 0 , x i , j , 0 ) . a_i:=\bigoplus_{j=1}^{N}\mathbf{d}_{i,j}\cdot(0,\mathbf{x}_{i,j,0}). a i := j = 1 ⨁ N d i , j ⋅ ( 0 , x i , j , 0 ) .
Denoting by a = ( a 1 , … , a ℓ ) \mathbf{a}=(a_1,\ldots,a_\ell) a = ( a 1 , … , a ℓ ) , we conclude that
t = a ⊕ L ′ v ′ = a ⊕ L v . \mathbf{t}=\mathbf{a}\oplus L'\mathbf{v}'=\mathbf{a}\oplus L\mathbf{v}. t = a ⊕ L ′ v ′ = a ⊕ L v .
Thus measuring t \mathbf{t} t is exactly the same projective measurement as measuring L v L\mathbf{v} L v (with the outcome one-time padded by a \mathbf{a} a ), and hence the residual state becomes
∣ Φ u ⟩ = 1 p u ∑ v : L v = u α v ∣ v , G v ⟩ V ⨂ i = 1 ℓ ⨂ j = 1 N ∣ x i , j , v j ′ ⟩ R i , j . |\Phi_{\mathbf{u}}\rangle=\frac{1}{\sqrt{p_{\mathbf{u}}}}\sum_{\mathbf{v}:L\mathbf{v}=\mathbf{u}}\alpha_{\mathbf{v}}|\mathbf{v},G\mathbf{v}\rangle_V\bigotimes_{i=1}^{\ell}\bigotimes_{j=1}^{N}|\mathbf{x}_{i,j,\mathbf{v}'_j}\rangle_{R_{i,j}}. ∣ Φ u ⟩ = p u 1 v : L v = u ∑ α v ∣ v , G v ⟩ V i = 1 ⨂ ℓ j = 1 ⨂ N ∣ x i , j , v j ′ ⟩ R i , j .
If C ( t ⊕ a ) = C ( L v ) = 1 C(\mathbf{t}\oplus\mathbf{a})=C(L\mathbf{v})=1 C ( t ⊕ a ) = C ( L v ) = 1 then P C P_C P C sends ⊥ \perp ⊥ to P Q P_Q P Q , in which case P Q P_Q P Q outputs ⊥ \perp ⊥ and P C P_C P C outputs L v L\mathbf{v} L v , as desired. Otherwise, if C ( L v ) = 0 C(L\mathbf{v})=0 C ( L v ) = 0 , then the parties continue to the state recovery phase.
In the state-recovery phase, P Q P_Q P Q Hadamard-measures every R i , j R_{i,j} R i , j register. Conditioned on the outcomes e i , j ∈ { 0 , 1 } n \mathbf{e}_{i,j}\in\{0,1\}^{n} e i , j ∈ { 0 , 1 } n , the residual state becomes
1 p u ∑ v : L v = u α v ( − 1 ) ∑ i = 1 ℓ ∑ j = 1 N e i , j ⋅ x i , j , v j ′ ∣ v , G v ⟩ V . \frac{1}{\sqrt{p_{\mathbf{u}}}}\sum_{\mathbf{v}:L\mathbf{v}=\mathbf{u}}\alpha_{\mathbf{v}}(-1)^{\sum_{i=1}^{\ell}\sum_{j=1}^{N}\mathbf{e}_{i,j}\cdot\mathbf{x}_{i,j,\mathbf{v}'_j}}|\mathbf{v},G\mathbf{v}\rangle_V. p u 1 v : L v = u ∑ α v ( − 1 ) ∑ i = 1 ℓ ∑ j = 1 N e i , j ⋅ x i , j , v j ′ ∣ v , G v ⟩ V .
Again using the fact that
x i , j , v j ′ = x i , j , 0 ⊕ v j ′ ( x i , j , 0 ⊕ x i , j , 1 ) , \mathbf{x}_{i,j,\mathbf{v}'_j}=\mathbf{x}_{i,j,0}\oplus\mathbf{v}'_j(\mathbf{x}_{i,j,0}\oplus\mathbf{x}_{i,j,1}), x i , j , v j ′ = x i , j , 0 ⊕ v j ′ ( x i , j , 0 ⊕ x i , j , 1 ) ,
we get
∑ i , j e i , j ⋅ x i , j , 0 ⊕ ∑ i , j v j ′ ( e i , j ⋅ ( x i , j , 0 ⊕ x i , j , 1 ) ) = ∑ i , j e i , j ⋅ x i , j , 0 ⊕ ∑ i , j v j ′ β i , j . \begin{aligned}
&\sum_{i,j}\mathbf{e}_{i,j}\cdot\mathbf{x}_{i,j,0}\oplus\sum_{i,j}\mathbf{v}'_j(\mathbf{e}_{i,j}\cdot(\mathbf{x}_{i,j,0}\oplus\mathbf{x}_{i,j,1}))\\
&=\sum_{i,j}\mathbf{e}_{i,j}\cdot\mathbf{x}_{i,j,0}\oplus\sum_{i,j}\mathbf{v}'_j\beta_{i,j}.
\end{aligned} i , j ∑ e i , j ⋅ x i , j , 0 ⊕ i , j ∑ v j ′ ( e i , j ⋅ ( x i , j , 0 ⊕ x i , j , 1 )) = i , j ∑ e i , j ⋅ x i , j , 0 ⊕ i , j ∑ v j ′ β i , j .
where
β i , j : = e i , j ⋅ ( x i , j , 0 ⊕ x i , j , 1 ) . \beta_{i,j}:=\mathbf{e}_{i,j}\cdot(\mathbf{x}_{i,j,0}\oplus\mathbf{x}_{i,j,1}). β i , j := e i , j ⋅ ( x i , j , 0 ⊕ x i , j , 1 ) .
The first term is global. The second term is exactly cancelled by P Q P_Q P Q ’s phase correction
∣ v , G v ⟩ ⟼ ( − 1 ) ∑ j = 1 N v j ′ ζ j ∣ v , G v ⟩ . |\mathbf{v},G\mathbf{v}\rangle\longmapsto(-1)^{\sum_{j=1}^{N}\mathbf{v}'_j\zeta_j}|\mathbf{v},G\mathbf{v}\rangle. ∣ v , G v ⟩ ⟼ ( − 1 ) ∑ j = 1 N v j ′ ζ j ∣ v , G v ⟩ .
Thus the output of P Q P_Q P Q after inverting the encoding ∣ v , 0 ⟩ ↦ ∣ v , G v ⟩ \lvert v,0\rangle\mapsto\lvert v,Gv\rangle ∣ v , 0 ⟩ ↦ ∣ v , G v ⟩ is the residual state
1 μ u ∑ v : L v = u α v ∣ v ⟩ V , \frac{1}{\sqrt{\mu_u}}\sum_{v:Lv=u}\alpha_v\lvert v\rangle_V, μ u 1 v : Lv = u ∑ α v ∣ v ⟩ V ,
and the output of P C P_C P C is L v Lv Lv , unless there exists ( i , j ) ∈ [ ℓ ] × [ N ] (i,j)\in[\ell]\times[N] ( i , j ) ∈ [ ℓ ] × [ N ] and b ∈ { 0 , 1 } b\in\{0,1\} b ∈ { 0 , 1 } such that
Synd ( b , x i , j , b , e i , j ) ∈ { 0 , Synd ( b , x i , j , b , d i , j ) } \operatorname{Synd}(b,x_{i,j,b},e_{i,j})\in\{0,\operatorname{Synd}(b,x_{i,j,b},d_{i,j})\} Synd ( b , x i , j , b , e i , j ) ∈ { 0 , Synd ( b , x i , j , b , d i , j )}
which will trigger an abort. We next argue that this occurs only with negligible probability. To this end, note that for each ( i , j ) (i,j) ( i , j ) , the honest Hadamard outcome e i , j e_{i,j} e i , j is uniform in { 0 , 1 } n \{0,1\}^{n} { 0 , 1 } n . Hence, for each b ∈ { 0 , 1 } b\in\{0,1\} b ∈ { 0 , 1 } , Synd ( b , x i , j , b , e i , j ) \operatorname{Synd}(b,x_{i,j,b},e_{i,j}) Synd ( b , x i , j , b , e i , j ) is uniform in { 0 , 1 } k \{0,1\}^{k} { 0 , 1 } k . Therefore,
Pr [ Synd ( b , x i , j , b , e i , j ) ∈ { 0 , Synd ( b , x i , j , b , d i , j ) } ] ≤ 2 ⋅ 2 − k . \Pr[\operatorname{Synd}(b,x_{i,j,b},e_{i,j})\in\{0,\operatorname{Synd}(b,x_{i,j,b},d_{i,j})\}]\le2\cdot2^{-k}. Pr [ Synd ( b , x i , j , b , e i , j ) ∈ { 0 , Synd ( b , x i , j , b , d i , j )}] ≤ 2 ⋅ 2 − k .
By a union bound over all 2 ℓ N 2\ell N 2 ℓ N choices of ( i , j , b ) (i,j,b) ( i , j , b ) ,
Pr [ honest recovery abort ] ≤ 4 ℓ N ⋅ 2 − k = negl ( λ ) , \Pr[\text{honest recovery abort}]\le4\ell N\cdot2^{-k}=\operatorname{negl}(\lambda), Pr [ honest recovery abort ] ≤ 4 ℓ N ⋅ 2 − k = negl ( λ ) ,
as desired. □
Security Against Malicious P Q P_Q P Q
Theorem 9 (ϵ \epsilon ϵ -Security against malicious P Q P_Q P Q ). Assume that the NTCF family satisfies the two-query adaptive hardcore bit property, and assume witness-preserving indistinguishably-extractable arguments for NP. Then Protocol 1 ϵ \epsilon ϵ -securely realizes the linear functionality with post-processed abort against malicious QPT P Q ∗ P_Q^* P Q ∗ .
Proof. Let P Q ∗ P_Q^* P Q ∗ be an arbitrary malicious QPT quantum party. We construct an ideal-world simulator Sim P Q ∗ \operatorname{Sim}_{P_Q^*} Sim P Q ∗ for the ideal functionality.
Simulator. Let ( S λ , { Ext λ , η } n ∈ N ) (S_\lambda,\{\operatorname{Ext}_{\lambda,\eta}\}_{n\in\mathbb{N}}) ( S λ , { Ext λ , η } n ∈ N ) be the simulator and extractor for indistinguishable-extraction of the NP argument. Set η = ( n / 3 ) 2 \eta=(n/3)^2 η = ( n /3 ) 2 . The simulator Sim λ , n \operatorname{Sim}_{\lambda,n} Sim λ , n is given the state of the adversary P Q ∗ P_Q^* P Q ∗ and does the following:
For every ( i , j ) ∈ [ ℓ ] × [ N ] (i,j)\in[\ell]\times[N] ( i , j ) ∈ [ ℓ ] × [ N ] generate ( p p i , j , t d i , j ) ← Setup ( 1 λ ) (\mathsf{pp}_{i,j},\mathsf{td}_{i,j})\leftarrow\operatorname{Setup}(1^\lambda) ( pp i , j , td i , j ) ← Setup ( 1 λ ) .
Send p p = { p p i , j } i ∈ [ ℓ ] , j ∈ [ N ] \mathsf{pp}=\{\mathsf{pp}_{i,j}\}_{i\in[\ell],j\in[N]} pp = { pp i , j } i ∈ [ ℓ ] , j ∈ [ N ] to P Q ∗ P_Q^* P Q ∗ and receive image values y = { y i , j } i ∈ [ ℓ ] , j ∈ [ N ] \mathbf{y}=\{y_{i,j}\}_{i\in[\ell],j\in[N]} y = { y i , j } i ∈ [ ℓ ] , j ∈ [ N ] .
Run the S λ S_\lambda S λ for the first argument to obtain a state ∣ ϕ ⟩ T , A , S \lvert\phi\rangle_{T,A,S} ∣ ϕ ⟩ T , A , S .
Measure whether T T T contains an accepting transcript. If it is rejecting then set b Q = 0 b_Q=0 b Q = 0 , indicating abort, so P C P_C P C receives ⊥ \perp ⊥ , and output the view of the simulated P Q ∗ P_Q^* P Q ∗ . Otherwise, measure { Π Ext , λ , η , I − Π Ext , λ , η } \{\Pi_{\operatorname{Ext},\lambda,\eta},I-\Pi_{\operatorname{Ext},\lambda,\eta}\} { Π Ext , λ , η , I − Π Ext , λ , η } which determines if the extractor successfully extracts a witness. If not, immediately output ⊥ \perp ⊥ . If extraction succeeds, discard register S S S and continue.
Otherwise, for every ( i , j ) ∈ [ ℓ ] × [ N ] (i,j) \in[\ell] \times[N] ( i , j ) ∈ [ ℓ ] × [ N ] compute Invert ( t d i , j , y i , j ) \operatorname{Invert}(\mathrm{td}_{i,j},y_{i,j}) Invert ( td i , j , y i , j ) . If any of these output ⊥ \perp ⊥ then abort.21 Otherwise, denote the ( i , j ) (i,j) ( i , j ) output by ( ( 0 , x i , j , 0 ) , ( 1 , x i , j , 1 ) ) ((0,x_{i,j,0}),(1,x_{i,j,1})) (( 0 , x i , j , 0 ) , ( 1 , x i , j , 1 )) . and let
Δ i , j : = ( 0 , x i , j , 0 ) ⊕ ( 1 , x i , j , 1 ) . \Delta_{i,j}:=(0,x_{i,j,0})\oplus(1,x_{i,j,1}). Δ i , j := ( 0 , x i , j , 0 ) ⊕ ( 1 , x i , j , 1 ) .
Sample R ← F 2 ℓ × ( N − m ) R \leftarrow\mathbb{F}_{2}^{\ell\times(N-m)} R ← F 2 ℓ × ( N − m ) and set L ′ = R P L'=RP L ′ = R P . For each ( i , j ) (i,j) ( i , j ) :
(a) Sample d i , j ← { 0 , 1 } n + 1 \mathbf{d}_{i,j} \leftarrow\{0,1\}^{n+1} d i , j ← { 0 , 1 } n + 1 .
(b) Compute p i , j 0 : = d i , j ⋅ Δ i , j ⊕ L i , j ′ p_{i,j}^{0}:=\mathbf{d}_{i,j}\cdot\Delta_{i,j}\oplus L'_{i,j} p i , j 0 := d i , j ⋅ Δ i , j ⊕ L i , j ′ .22
Set d = { d i , j } \mathbf{d}=\{\mathbf{d}_{i,j}\} d = { d i , j } and p 0 = { p i , j 0 } \mathbf{p}^{0}=\{p_{i,j}^{0}\} p 0 = { p i , j 0 } and send ( d , p 0 ) (\mathbf{d},\mathbf{p}^{0}) ( d , p 0 ) to P Q ∗ P_{Q}^{*} P Q ∗ .
Upon receiving t ∈ { 0 , 1 } ℓ \mathbf{t}\in\{0,1\}^{\ell} t ∈ { 0 , 1 } ℓ from P Q ∗ P_{Q}^{*} P Q ∗ , run S λ S_{\lambda} S λ for the second argument, to obtain a state ∣ ϕ ⟩ T , A , S |\phi\rangle_{\mathcal{T},\mathcal{A},\mathcal{S}} ∣ ϕ ⟩ T , A , S .
Measure only the bit indicating if the transcript in register T \mathcal{T} T is accepting or not. If it is rejecting, then set b Q = 0 b_{Q}=0 b Q = 0 indicating abort, and output the view of the simulated P Q ∗ P_{Q}^{*} P Q ∗ .
Otherwise, set b Q = 1 b_{Q}=1 b Q = 1 and measure ∣ ϕ ⟩ T , A , S |\phi\rangle_{\mathcal{T},\mathcal{A},\mathcal{S}} ∣ ϕ ⟩ T , A , S using { Π E x t , λ , η , I − Π E x t , λ , η } \{\Pi_{\mathrm{Ext},\lambda,\eta},I-\Pi_{\mathrm{Ext},\lambda,\eta}\} { Π Ext , λ , η , I − Π Ext , λ , η } to see if the second extraction succeeds. If not, immediately output ⊥ \perp ⊥ . Otherwise, continue.
Compute the witness extraction unitary E x t λ , η \mathrm{Ext}_{\lambda,\eta} Ext λ , η on the state ∣ ϕ ⟩ T , A , S |\phi\rangle_{\mathcal{T},\mathcal{A},\mathcal{S}} ∣ ϕ ⟩ T , A , S . Conditioned on not aborting in the prior step, the extracted witness register W \mathcal{W} W contains a state wholly supported on values ( v , v ′ , { x i , j } ( i , j ) ∈ [ ℓ ] × [ N ] ) (\mathbf{v},\mathbf{v}',\{x_{i,j}\}_{(i,j)\in[\ell]\times[N]}) ( v , v ′ , { x i , j } ( i , j ) ∈ [ ℓ ] × [ N ] ) satisfying v ′ = G v \mathbf{v}'=G\mathbf{v} v ′ = G v and
Check ( p p i , j , v j ′ , x i , j , y i , j ) = 1 \operatorname{Check}(\mathrm{pp}_{i,j},\mathbf{v}'_{j},x_{i,j},y_{i,j})=1 Check ( pp i , j , v j ′ , x i , j , y i , j ) = 1
for all ( i , j ) (i,j) ( i , j ) , and
t i = ⨁ j = 1 N ( ( d i , j ⋅ ( v j ′ , x i , j ) ) ⊕ p i , j 0 v j ′ ) t_i=\bigoplus_{j=1}^{N}\left((\mathbf{d}_{i,j}\cdot(\mathbf{v}'_{j},x_{i,j}))\oplus p_{i,j}^{0}\mathbf{v}'_{j}\right) t i = j = 1 ⨁ N ( ( d i , j ⋅ ( v j ′ , x i , j )) ⊕ p i , j 0 v j ′ )
for all i ∈ [ ℓ ] i\in[\ell] i ∈ [ ℓ ] .
Initialize a register V \mathcal{V} V to ∣ 0 ⟩ |0\rangle ∣0 ⟩ and classical-copy v \mathbf{v} v from register W \mathcal{W} W to register V \mathcal{V} V using a CNOT. Send V \mathcal{V} V to the ideal functionality.
Ideal Functionality. The ideal functionality coherently computes and measures u = L v \mathbf{u}=L\mathbf{v} u = L v . If C ( u ) = 1 C(\mathbf{u})=1 C ( u ) = 1 , it returns ⊥ \perp ⊥ to the simulator. Otherwise, it returns the post-measurement state in register V \mathcal{V} V to the simulator.
If the ideal functionality returns register V \mathcal{V} V , erase it by applying a second CNOT from W \mathcal{W} W to V \mathcal{V} V .
Compute Ext λ , η † \operatorname{Ext}^{\dagger}_{\lambda,\eta} Ext λ , η † and trace out register S \mathcal{S} S .
If the ideal functionality sent ⊥ \perp ⊥ , then output the view of the simulated P Q ∗ P_Q^* P Q ∗ so far.
Otherwise, continue the interaction with P Q ∗ P_Q^* P Q ∗ .
When P Q ∗ P_Q^* P Q ∗ sends recovery vectors e i , j ∈ { 0 , 1 } n \mathbf{e}_{i,j} \in\{0,1\}^n e i , j ∈ { 0 , 1 } n , check that the message has the prescribed format and that for every ( i , j ) ∈ [ ℓ ] × [ N ] (i,j) \in[\ell] \times[N] ( i , j ) ∈ [ ℓ ] × [ N ] and every b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } ,
Synd ( b , x i , j , b , e i , j ) ∉ { 0 , Synd ( b , x i , j , b , d i , j ) } . \operatorname{Synd}(b,x_{i,j,b},e_{i,j}) \notin\{0,\operatorname{Synd}(b,x_{i,j,b},d_{i,j})\}. Synd ( b , x i , j , b , e i , j ) ∈ / { 0 , Synd ( b , x i , j , b , d i , j )} .
If any check fails, simulate P C P_C P C sending ⊥ \perp ⊥ and output the view of the simulated P Q ∗ P_Q^* P Q ∗ .
Otherwise, compute
β i , j : = e i , j ⋅ ( x i , j , 0 ⊕ x i , j , 1 ) , ζ j : = ⨁ i = 1 ℓ β i , j , j ∈ [ N ] , \beta_{i,j} := e_{i,j} \cdot(x_{i,j,0} \oplus x_{i,j,1}), \qquad\zeta_j := \bigoplus_{i=1}^{\ell} \beta_{i,j}, \qquad j \in[N], β i , j := e i , j ⋅ ( x i , j , 0 ⊕ x i , j , 1 ) , ζ j := i = 1 ⨁ ℓ β i , j , j ∈ [ N ] ,
and send ζ = ( ζ 1 , … , ζ N ) \zeta= (\zeta_1,\ldots,\zeta_N) ζ = ( ζ 1 , … , ζ N ) to P Q ∗ P_Q^* P Q ∗ .
We prove that the ideal execution with this simulator is computationally indistinguishable from the real execution.
Hybrid H 0 H_0 H 0 : real execution. Hybrid H 0 H_0 H 0 is the real execution of Protocol 1 between malicious P Q ∗ P_Q^* P Q ∗ and honest P C P_C P C . In this hybrid, for every ( i , j ) (i,j) ( i , j ) , P C P_C P C sends
p i , j = L i , j ′ ⊕ ( d i , j ⋅ Δ i , j ) . p_{i,j} = L'_{i,j} \oplus(d_{i,j} \cdot\Delta_{i,j}). p i , j = L i , j ′ ⊕ ( d i , j ⋅ Δ i , j ) .
Hybrid H 1 H_1 H 1 : indistinguishable extraction. Hybrid H 1 H_1 H 1 is the same as H 0 H_0 H 0 , except we replace the two witness-preserving arguments. Instead, run the indistinguishable-extraction simulator S λ \mathcal{S}_{\lambda} S λ and measure if the extractor Ext λ , η \operatorname{Ext}_{\lambda,\eta} Ext λ , η succeeds. If the extractor fails, immediately output ⊥ \perp ⊥ .
By Lemma 6, each replacement changes the trace distance by at most 1 / η + 1 / η \sqrt{1/\eta}+1/\eta 1/ η + 1/ η since the extractor succeeds with probability ≥ 1 / η \ge1/\eta ≥ 1/ η . Since we set η = ( 3 n ) 2 \eta=(3n)^2 η = ( 3 n ) 2 , the total change in trace distance from the two replacements is less than 1 / n 1/n 1/ n for all n ∈ N n \in\mathbb{N} n ∈ N .
Hybrid H 2 H_2 H 2 : explicit ideal measurement. Hybrid H 2 H_2 H 2 is the same as H 1 H_1 H 1 , except for an additional measurement right after measuring whether the extractor for the second argument succeeds:
Proceed as in H 1 H_1 H 1 until the second witness-preserving argument.
Run S λ \mathcal{S}_{\lambda} S λ and measure whether the extractor succeeds, as in H 1 H_1 H 1 .
Run Ext \operatorname{Ext} Ext to extract a valid witness.
Measure the register containing the extracted v \mathbf{v} v using the projective measurement { Π u L = ∑ v : L v = u ∣ v ⟩ ⟨ v ∣ } u \{\Pi^{L}_{\mathbf{u}}=\sum_{\mathbf{v}:L\mathbf{v}=\mathbf{u}}|\mathbf{v}\rangle\langle\mathbf{v}|\}_{\mathbf{u}} { Π u L = ∑ v : L v = u ∣ v ⟩ ⟨ v ∣ } u to obtain a vector u = L v \mathbf{u}=L\mathbf{v} u = L v .
Run Ext † \operatorname{Ext}^{\dagger} Ext † .
Continue as in H 1 H_1 H 1 .
We show that measuring L v L\mathbf{v} L v does not disturb the state, and that the output of P C P_{\mathsf{C}} P C in hybrid H 1 H_1 H 1 (if it doesn’t abort) is distributed identically to the extracted vector u = L v \mathbf{u}=L\mathbf{v} u = L v . In H 1 H_1 H 1 , for a valid extracted witness,
( v j ′ , x i , j , v j ′ ) = ( 0 , x i , j , 0 ) ⊕ v j ′ Δ i , j . (v'_j,\mathbf{x}_{i,j,v'_j})=(0,\mathbf{x}_{i,j,0})\oplus v'_j\Delta_{i,j}. ( v j ′ , x i , j , v j ′ ) = ( 0 , x i , j , 0 ) ⊕ v j ′ Δ i , j .
Using the fact that
p i , j = ( d i , j ⋅ Δ i , j ) ⊕ L i , j ′ , p_{i,j}=(d_{i,j}\cdot\Delta_{i,j})\oplus L'_{i,j}, p i , j = ( d i , j ⋅ Δ i , j ) ⊕ L i , j ′ ,
we observe that
( d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ) ⊕ p i , j v j ′ = ( d i , j ⋅ ( ( 0 , x i , j , 0 ) ⊕ v j ′ Δ i , j ) ) ⊕ v j ′ ( L i , j ′ ⊕ d i , j ⋅ Δ i , j ) = ( d i , j ⋅ ( 0 , x i , j , 0 ) ) ⊕ L i , j ′ v j ′ . \begin{aligned}
(d_{i,j}\cdot(v'_j,\mathbf{x}_{i,j,v'_j}))\oplus p_{i,j}v'_j
&=(d_{i,j}\cdot((0,\mathbf{x}_{i,j,0})\oplus v'_j\Delta_{i,j}))\oplus v'_j(L'_{i,j}\oplus d_{i,j}\cdot\Delta_{i,j})\\
&=(d_{i,j}\cdot(0,\mathbf{x}_{i,j,0}))\oplus L'_{i,j}v'_j.
\end{aligned} ( d i , j ⋅ ( v j ′ , x i , j , v j ′ )) ⊕ p i , j v j ′ = ( d i , j ⋅ (( 0 , x i , j , 0 ) ⊕ v j ′ Δ i , j )) ⊕ v j ′ ( L i , j ′ ⊕ d i , j ⋅ Δ i , j ) = ( d i , j ⋅ ( 0 , x i , j , 0 )) ⊕ L i , j ′ v j ′ .
Therefore
t i = ⨁ j = 1 N ( ( d i , j ⋅ ( v j ′ , x i , j , v j ′ ) ) ⊕ p i , j v j ′ ) = ( ⨁ j = 1 N d i , j ⋅ ( 0 , x i , j , 0 ) ) ⊕ ⨁ j = 1 N L i , j ′ v j ′ = a i ⊕ ( L ′ v ′ ) i . \begin{aligned}
t_i&=\bigoplus_{j=1}^{N}\left((d_{i,j}\cdot(v'_j,\mathbf{x}_{i,j,v'_j}))\oplus p_{i,j}v'_j\right)\\
&=\left(\bigoplus_{j=1}^{N}d_{i,j}\cdot(0,\mathbf{x}_{i,j,0})\right)\oplus\bigoplus_{j=1}^{N}L'_{i,j}v'_j\\
&=a_i\oplus(L'\mathbf{v}')_i.
\end{aligned} t i = j = 1 ⨁ N ( ( d i , j ⋅ ( v j ′ , x i , j , v j ′ )) ⊕ p i , j v j ′ ) = ( j = 1 ⨁ N d i , j ⋅ ( 0 , x i , j , 0 ) ) ⊕ j = 1 ⨁ N L i , j ′ v j ′ = a i ⊕ ( L ′ v ′ ) i .
Thus t = a ⊕ L ′ v ′ = a ⊕ L v \mathbf{t}=\mathbf{a}\oplus L'\mathbf{v}'=\mathbf{a}\oplus L\mathbf{v} t = a ⊕ L ′ v ′ = a ⊕ L v . Hence, conditioned on the observed value t \mathbf{t} t , the extracted V V V register is already supported only on v \mathbf{v} v ’s such that
L v = t ⊕ a . L\mathbf{v}=\mathbf{t}\oplus\mathbf{a}. L v = t ⊕ a .
Therefore, applying the projective measurement { Π u L } u \{\Pi^{L}_{\mathbf{u}}\}_{\mathbf{u}} { Π u L } u does not further disturb the state. Therefore
Hybrid H 3 H_3 H 3 : Moving the Ideal Measurement. H 3 H_3 H 3 adds a measurement of L v L\mathbf{v} L v in between extraction for the first argument. The same measurement is also done in the second argument.
Claim 1. H 2 ≈ c H 3 H_2\approx_{\mathrm{c}}H_3 H 2 ≈ c H 3
Proof. Measuring L v Lv Lv is equivalent to measuring L ′ v ′ L'v' L ′ v ′ . For any row L i ∗ ′ L'_{i^*} L i ∗ ′ of L ′ L' L ′ , the measurement of L i ∗ ′ ⋅ v ′ L'_{i^*}\cdot v' L i ∗ ′ ⋅ v ′ is equivalent to applying Z L i ∗ ′ Z^{L'_{i^*}} Z L i ∗ ′ with probability 1 / 2 1/2 1/2 during the extraction for either measurement. We show that it is indistinguishable to add these operations during the first extraction.
By the phase injection lemma with 1 bit of inner product leakage (Lemma 5), applying Z L i j ′ Z^{L'_{ij}} Z L ij ′ to the extracted v j ′ v'_j v j ′ for any ( i , j ) (i,j) ( i , j ) during the first extraction is indistinguishable so long as the correction ζ j \zeta_j ζ j is reported as ζ j ⊕ L i j ′ \zeta_j\oplus L'_{ij} ζ j ⊕ L ij ′ . Applying the phase injection lemma a second time during the second extraction reverts the correction to ζ j ⊕ L i j ′ ⊕ L i j ′ = ζ j \zeta_j\oplus L'_{ij}\oplus L'_{ij}=\zeta_j ζ j ⊕ L ij ′ ⊕ L ij ′ = ζ j . Moreover, the combined Z L i ∗ ′ Z^{L'_{i^*}} Z L i ∗ ′ operation during the second extraction only induces a global phase because L i ∗ ′ ⋅ v ′ L'_{i^*}\cdot v' L i ∗ ′ ⋅ v ′ is measured anyway during the second extraction. □ \square □
Hybrid H 4 H_4 H 4 : explicit ideal abort. H 4 H_4 H 4 is the same as H 3 H_3 H 3 except that after measuring u = L v u=Lv u = Lv in between E x t \mathsf{Ext} Ext and E x t † \mathsf{Ext}^{\dagger} Ext † for the second argument, if C ( u ) = 1 C(u)=1 C ( u ) = 1 then it also measures the extracted v v v in the computational basis before continuing.
Claim 2. H 3 ≈ c H 4 H_3\approx_c H_4 H 3 ≈ c H 4 .
Proof. Let H 3 , i H_{3,i} H 3 , i be the hybrid experiment where in the case of an abort, every v k v_k v k is measured for k ≤ i k\le i k ≤ i . Then H 3 , 0 = H 3 H_{3,0}=H_3 H 3 , 0 = H 3 and H 3 , m = H 4 H_{3,m}=H_4 H 3 , m = H 4 . We will show that for every i ∈ { 0 , … , m − 1 } i\in\{0,\ldots,m-1\} i ∈ { 0 , … , m − 1 } , H 3 , i ≈ c H 3 , i + 1 H_{3,i}\approx_c H_{3,i+1} H 3 , i ≈ c H 3 , i + 1 by reducing to the collapsing property of the NTCF with 1 bit of inner product leakage (Lemma 3). Repeating the reduction for every i i i shows that H 3 ≈ H 4 H_3\approx H_4 H 3 ≈ H 4 .
Fix any j ∈ [ ℓ ] j\in[\ell] j ∈ [ ℓ ] . Since v i + 1 = v i + 1 ′ v_{i+1}=v'_{i+1} v i + 1 = v i + 1 ′ and x j , i + 1 x_{j,i+1} x j , i + 1 uniquely determine each other given y j , i + 1 y_{j,i+1} y j , i + 1 , it is equivalent to argue collapsing of ( v i + 1 ′ , x j , i + 1 ) (v'_{i+1},x_{j,i+1}) ( v i + 1 ′ , x j , i + 1 ) . Moreover, the adversary has 0 advantage in distinguishing H 3 , i H_{3,i} H 3 , i from H 3 , i + 1 H_{3,i+1} H 3 , i + 1 conditioned on the non-abort case C ( u ) = 0 C(u)=0 C ( u ) = 0 because the two hybrids are identical in this case.
The reduction works as follows. It plays H 3 , i H_{3,i} H 3 , i using the pp chosen by the collapsing challenger for index ( j , i + 1 ) (j,i+1) ( j , i + 1 ) and the others chosen internally. It forwards y j , i + 1 y_{j,i+1} y j , i + 1 to the collapsing challenger, then receives ( d , d ⋅ Δ ) (d,d\cdot\Delta) ( d , d ⋅ Δ ) from the collapsing challenger and uses this to mask L j , i + 1 ′ L'_{j,i+1} L j , i + 1 ′ .
At this point, H 3 , i H_{3,i} H 3 , i runs S i m \mathsf{Sim} Sim and E x t \mathsf{Ext} Ext to extract ∣ v , x ⟩ |v,x\rangle ∣ v , x ⟩ from the second witness-preserving argument of knowledge. If C ( L v ) = 0 C(Lv)=0 C ( Lv ) = 0 , it immediately guesses 0 in the collapsing experiment. Otherwise, it sends the extracted register containing ( v i + 1 ′ , x j , i + 1 ) (v'_{i+1},x_{j,i+1}) ( v i + 1 ′ , x j , i + 1 ) to the collapsing challenger. The challenger either measures this register or does not, at random, before returning it. After the register is returned, the reduction completes H 3 , i H_{3,i} H 3 , i and outputs the distinguisher’s output.
Observe that if the challenger measures, this is distributed as H 3 , i + 1 H_{3,i+1} H 3 , i + 1 and otherwise it is distributed as H 3 , i H_{3,i} H 3 , i . Since the distinguisher’s advantage is entirely concentrated on the abort case, the reduction has the same advantage in the collapsing game with 1 bit of inner product leakage, which must be negligible. □ \square □
Hybrid H 5 H_5 H 5 : Changing L ′ L' L ′ to Encode 0. Hybrid H 5 H_5 H 5 is the same as H 4 H_4 H 4 , except that the simulator computes L ′ L' L ′ as an encoding of 0 instead of L L L :
for random matrix R R R . It still masks L i , j ′ L'_{i,j} L i , j ′ as p i , j = ( d i , j ⋅ Δ i , j ) ⊕ L i , j ′ p_{i,j} = (d_{i,j} \cdot\Delta_{i,j}) \oplus L'_{i,j} p i , j = ( d i , j ⋅ Δ i , j ) ⊕ L i , j ′ like in the previous hybrid H 4 H_4 H 4 .
The following lemma gives a route to replacing each row L i ∗ ′ L'_{i^*} L i ∗ ′ by an encoding of 0 0 0 instead of an encoding of L i ∗ L_{i^*} L i ∗ .
Lemma 8. Let G G G , D D D , and P P P be the encoding matrices defined at the start of this section. For all ℓ ∈ F 2 m \ell\in\mathbb{F}_2^m ℓ ∈ F 2 m and any QPT adversary,
Exp ℓ ( ℓ ) ≈ c Exp ℓ ( 0 ) \operatorname{Exp}_{\ell}(\ell) \approx_c \operatorname{Exp}_{\ell}(0) Exp ℓ ( ℓ ) ≈ c Exp ℓ ( 0 ) where Exp ℓ ( a ) \operatorname{Exp}_{\ell}(a) Exp ℓ ( a ) is the following game.
The challenger samples N N N public parameters ( p p i , t d i ) ← NTCF.Setup ( 1 λ ) (\mathsf{pp}_i,\mathsf{td}_i) \leftarrow\operatorname{NTCF.Setup}(1^\lambda) ( pp i , td i ) ← NTCF.Setup ( 1 λ ) and send ( p p i ) i ∈ [ N ] (\mathsf{pp}_i)_{i \in[N]} ( pp i ) i ∈ [ N ] to the adversary.
The adversary sends images y 1 , … , y N y_1,\ldots,y_N y 1 , … , y N and joint state on registers ( V , V ′ , X ) (\mathcal{V},\mathcal{V}',\mathcal{X}) ( V , V ′ , X ) to the challenger.23
The challenger measures whether ( V , V ′ , X ) (\mathcal{V},\mathcal{V}',\mathcal{X}) ( V , V ′ , X ) contain a state entirely supported on computational basis states ∣ v , v ′ , ( x 1 , … , x N ) ⟩ \lvert\mathbf{v},\mathbf{v}',(x_1,\ldots,x_N)\rangle ∣ v , v ′ , ( x 1 , … , x N )⟩ such that
v ′ = G v and Check ( p p i , v i ′ , x i , y i ) = 1 ∀ i ∈ [ N ] \mathbf{v}' = G\mathbf{v} \quad\text{and}\quad\operatorname{Check}(\mathsf{pp}_i,v'_i,x_i,y_i)=1\ \forall i\in[N] v ′ = G v and Check ( pp i , v i ′ , x i , y i ) = 1 ∀ i ∈ [ N ] If the result rejects, the experiment immediately outputs 0 0 0 . Otherwise, measure ℓ ⋅ v \ell\cdot\mathbf{v} ℓ ⋅ v and return registers ( V , V ′ , X ) (\mathcal{V},\mathcal{V}',\mathcal{X}) ( V , V ′ , X ) to the adversary.
The challenger does the following:
(a) Compute ( ( 0 , x i ( 0 ) ) , ( 1 , x i ( 1 ) ) ) = Invert ( t d i , y i ) ((0,x_i^{(0)}),(1,x_i^{(1)})) = \operatorname{Invert}(\mathsf{td}_i,y_i) (( 0 , x i ( 0 ) ) , ( 1 , x i ( 1 ) )) = Invert ( td i , y i ) for each i ∈ [ N ] i \in[N] i ∈ [ N ] .24 Then, set Δ i : = ( 0 , x i ( 0 ) ) ⊕ ( 1 , x i ( 1 ) ) \Delta_i := (0,x_i^{(0)}) \oplus(1,x_i^{(1)}) Δ i := ( 0 , x i ( 0 ) ) ⊕ ( 1 , x i ( 1 ) ) .
(b) Sample d i ← F 2 n + 1 \mathbf{d}_i \leftarrow\mathbb{F}_2^{n+1} d i ← F 2 n + 1 for each i ∈ [ N ] i \in[N] i ∈ [ N ] .
(c) Sample a uniform vector r ← F 2 1 × ( N − m ) \mathbf{r} \leftarrow\mathbb{F}_2^{1 \times(N-m)} r ← F 2 1 × ( N − m ) and encode a ′ = a D + r P \mathbf{a}' = \mathbf{a}D + \mathbf{r}P a ′ = a D + r P .
(d) Send ( d i , ( d i ⋅ Δ i ) ⊕ a i ′ ) i ∈ [ N ] (\mathbf{d}_i,(\mathbf{d}_i \cdot\Delta_i) \oplus\mathbf{a}'_i)_{i \in[N]} ( d i , ( d i ⋅ Δ i ) ⊕ a i ′ ) i ∈ [ N ] to the adversary.
A \mathcal{A} A sends vectors e i ∈ { 0 , 1 } n \mathbf{e}_i \in\{0,1\}^n e i ∈ { 0 , 1 } n for i ∈ [ N ] i \in[N] i ∈ [ N ] .
If the recovery message is malformed or Synd ( b , x i ( b ) , e i ) ∈ { 0 , Synd ( b , x i ( b ) , d i ) } \operatorname{Synd}(b,x_i^{(b)},\mathbf{e}_i) \in\{0,\operatorname{Synd}(b,x_i^{(b)},\mathbf{d}_i)\} Synd ( b , x i ( b ) , e i ) ∈ { 0 , Synd ( b , x i ( b ) , d i )} for any i ∈ [ N ] i \in[N] i ∈ [ N ] and b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } , then the challenger sends ⊥ \perp ⊥ to A \mathcal{A} A . Otherwise, the challenger sends β i : = e i ⋅ ( x i ( 0 ) ⊕ x i ( 1 ) ) \beta_i := \mathbf{e}_i \cdot(x_i^{(0)} \oplus x_i^{(1)}) β i := e i ⋅ ( x i ( 0 ) ⊕ x i ( 1 ) ) to A \mathcal{A} A for each i ∈ [ N ] i \in[N] i ∈ [ N ] .
A \mathcal{A} A chooses a bit u ′ u' u ′ to the be experiment’s output.
We prove the lemma in § 4.1.5 . For now, we describe how it shows that H 4 ≈ c H 5 H_4 \approx_c H_5 H 4 ≈ c H 5 .
It suffices to show that we can indistinguishably replace any row L i ∗ L_{i_*} L i ∗ by 0 \mathbf{0} 0 in the encoding. Iterating this for each of the ℓ \ell ℓ rows shows that H 4 ≈ c H 5 H_4 \approx_c H_5 H 4 ≈ c H 5 . Let H 4 , i H_{4,i} H 4 , i be the hybrid where all rows before i i i have been replaced, so that H 4 = H 4 , 1 H_4 = H_{4,1} H 4 = H 4 , 1 and H 5 = H 4 , ℓ + 1 H_5 = H_{4,\ell+1} H 5 = H 4 , ℓ + 1 .
Fix any row i i i and consider the experiments Exp L i ∗ ( L i ∗ ) \operatorname{Exp}_{L_{i_*}}(L_{i_*}) Exp L i ∗ ( L i ∗ ) versus Exp L i ∗ ( 0 ) \operatorname{Exp}_{L_{i_*}}(\mathbf{0}) Exp L i ∗ ( 0 ) . The reduction runs H 4 , i H_{4,i} H 4 , i using the ( p j ) j ∈ [ N ] (\mathbf{p}_j)_{j \in[N]} ( p j ) j ∈ [ N ] for that row of the encoded matrix L i ∗ L_{i_*} L i ∗ . It samples the others internally. Upon the first extraction, it sends the registers containing the extracted v \mathbf{v} v , v ′ \mathbf{v}' v ′ , and ( x i , j ) j ∈ [ N ] (x_{i,j})_{j \in[N]} ( x i , j ) j ∈ [ N ] to the challenger, who measures L i ∗ ⋅ v L_{i_*} \cdot\mathbf{v} L i ∗ ⋅ v and returns the register. It then completes H 4 H_4 H 4 by forwarding the masked values (corresponding to d j d_j d j ) for this row and aggregating its corrections (corresponding to e j e_j e j ) with the internally computed corrections for all other rows into ( ζ j ) j ∈ [ N ] (\zeta_j)_{j \in[N]} ( ζ j ) j ∈ [ N ] before sending them to the adversary. The reduction running on Exp L i ∗ ( L i ∗ ) \operatorname{Exp}_{L_{i_*}}(L_{i_*}) Exp L i ∗ ( L i ∗ ) is distributed according to H 4 , i H_{4,i} H 4 , i and it running on Exp L i ∗ ( 0 ) \operatorname{Exp}_{L_{i_*}}(\mathbf{0}) Exp L i ∗ ( 0 ) is distributed according to H 4 , i + 1 H_{4,i+1} H 4 , i + 1 . Therefore any QPT adversary’s advantage in distinguishing the two must be negligible by Lemma 8.
Remark 5. Note that in H 5 H_5 H 5 , t i t_i t i and hence has no dependence on L L L . Thus, the only L L L -dependent operation remaining in H 5 H_5 H 5 is the explicit ideal measurement inserted during the first and second extractions.
Hybrid H 6 H_6 H 6 : Removing the First L v L\mathbf{v} L v Measurement. H 6 H_6 H 6 removes the measurement of L v L\mathbf{v} L v during the first extraction. The same argument as H 3 H_3 H 3 shows that
H 5 ≈ c H 6 H_5 \approx_c H_6 H 5 ≈ c H 6
Hybrid H 7 H_7 H 7 : the ideal simulation. Hybrid H 7 H_7 H 7 is the ideal execution with the simulator Sim Q ∗ P ∗ \operatorname{Sim}_{Q^*}^{P^*} Sim Q ∗ P ∗ described above. It is easy to see that this hybrid is statistically close to H 6 H_6 H 6 .
Combining the hybrids,
H 0 ≈ c H 1 = H 2 ≈ c H 3 ≈ c H 4 ≈ c H 5 ≈ c H 6 ≡ H 7 . H_0 \approx_c H_1 = H_2 \approx_c H_3 \approx_c H_4 \approx_c H_5 \approx_c H_6 \equiv H_7. H 0 ≈ c H 1 = H 2 ≈ c H 3 ≈ c H 4 ≈ c H 5 ≈ c H 6 ≡ H 7 .
Since H 0 H_0 H 0 is the real execution and H 7 H_7 H 7 is the ideal execution with Sim Q ∗ P ∗ \operatorname{Sim}_{Q^*}^{P^*} Sim Q ∗ P ∗ , we conclude that
REAL Q ∗ P ∗ ( ∣ ψ ⟩ , L ) ≈ c IDEAL Sim Q ∗ P ∗ ( ∣ ψ ⟩ , L ) . \operatorname{REAL}_{Q^*}^{P^*}(|\psi\rangle, L) \approx_c \operatorname{IDEAL}_{\operatorname{Sim}_{Q^*}^{P^*}}(|\psi\rangle, L). REAL Q ∗ P ∗ ( ∣ ψ ⟩ , L ) ≈ c IDEAL Sim Q ∗ P ∗ ( ∣ ψ ⟩ , L ) .
This proves security against malicious P Q ∗ P_Q^* P Q ∗ .
Replacement of the Encoded L L L
We recall the statement of Lemma 8 here. Informally, it considers an experiment where an adversary commits to v ′ = G v \mathbf{v}' = G\mathbf{v} v ′ = G v using many NTCF instances, then some a ⋅ v ′ \mathbf{a} \cdot\mathbf{v}' a ⋅ v ′ is measured. Afterwards, the adversary is given an encoding of a \mathbf{a} a which is masked by a random inner product with the difference Δ \Delta Δ between the collisions of the NTCF. Finally, the adversary may query for an adaptive hardcore bit. The lemma states that since a ⋅ v ′ \mathbf{a} \cdot\mathbf{v}' a ⋅ v ′ is measured, we may indistinguishably replace the encoding of a \mathbf{a} a by an encoding of 0 \mathbf{0} 0 .
Lemma 9. Let G G G , P P P , and D D D be the generator, parity-check, and decoding matrix for a minimal binary code. For all ℓ ∈ F 2 m \ell\in\mathbb{F}_2^m ℓ ∈ F 2 m and any QPT adversary,
Exp ℓ ( ℓ ) ≈ c Exp ℓ ( 0 ) \operatorname{Exp}_{\ell}(\ell) \approx_{\mathrm{c}} \operatorname{Exp}_{\ell}(0) Exp ℓ ( ℓ ) ≈ c Exp ℓ ( 0 ) where Exp ℓ ( a ) \operatorname{Exp}_{\ell}(a) Exp ℓ ( a ) is the following game.
The challenger samples N N N public parameters ( p p i , t d i ) ← NTCF.Setup ( 1 λ ) (\mathrm{pp}_i,\mathrm{td}_i) \leftarrow\operatorname{NTCF.Setup}(1^\lambda) ( pp i , td i ) ← NTCF.Setup ( 1 λ ) and send ( p p i ) i ∈ [ N ] (\mathrm{pp}_i)_{i\in[N]} ( pp i ) i ∈ [ N ] to the adversary.
The adversary sends images y 1 , … , y N y_1,\ldots,y_N y 1 , … , y N and joint state on registers ( V , V ′ , X ) (\mathcal{V},\mathcal{V}',\mathcal{X}) ( V , V ′ , X ) to the challenger.25
The challenger measures whether ( V , V ′ , X ) (\mathcal{V},\mathcal{V}',\mathcal{X}) ( V , V ′ , X ) contain a state entirely supported on computational basis states ∣ v , v ′ , ( x 1 , … , x N ) ⟩ \lvert v,v',(x_1,\ldots,x_N)\rangle ∣ v , v ′ , ( x 1 , … , x N )⟩ such that
v ′ = G v and Check ( p p i , v ′ , x i , y i ) = 1 ∀ i ∈ [ N ] v'=Gv \qquad\text{and} \qquad\operatorname{Check}(\mathrm{pp}_i,v',x_i,y_i)=1\ \forall i\in[N] v ′ = G v and Check ( pp i , v ′ , x i , y i ) = 1 ∀ i ∈ [ N ] If the result rejects, the experiment immediately outputs 0 0 0 . Otherwise, measure ℓ ⋅ v \ell\cdot v ℓ ⋅ v and return registers ( V , V ′ , X ) (\mathcal{V},\mathcal{V}',\mathcal{X}) ( V , V ′ , X ) to the adversary.
The challenger does the following:
(a) Compute ( ( 0 , x i ( 0 ) ) , ( 1 , x i ( 1 ) ) ) = Invert ( t d i , y i ) ((0,x_i^{(0)}),(1,x_i^{(1)}))=\operatorname{Invert}(\mathrm{td}_i,y_i) (( 0 , x i ( 0 ) ) , ( 1 , x i ( 1 ) )) = Invert ( td i , y i ) for each i ∈ [ N ] i\in[N] i ∈ [ N ] .26 Then, set Δ i : = ( 0 , x i ( 0 ) ) ⊕ ( 1 , x i ( 1 ) ) \Delta_i := (0,x_i^{(0)})\oplus(1,x_i^{(1)}) Δ i := ( 0 , x i ( 0 ) ) ⊕ ( 1 , x i ( 1 ) ) .
(b) Sample d i ← F 2 n + 1 d_i\leftarrow\mathbb{F}_2^{n+1} d i ← F 2 n + 1 for each i ∈ [ N ] i\in[N] i ∈ [ N ] .
(c) Sample a uniform vector r ← F 2 N − m r\leftarrow\mathbb{F}_2^{N-m} r ← F 2 N − m and encode a ′ = a D + r P a'=aD+rP a ′ = a D + r P .
(d) Send ( d i , ( d i ⋅ Δ i ) ⊕ a ′ ) i ∈ [ N ] (d_i,(d_i\cdot\Delta_i)\oplus a')_{i\in[N]} ( d i , ( d i ⋅ Δ i ) ⊕ a ′ ) i ∈ [ N ] to the adversary.
A A A sends vectors e i ∈ { 0 , 1 } n e_i\in\{0,1\}^n e i ∈ { 0 , 1 } n for i ∈ [ N ] i\in[N] i ∈ [ N ] .
If the recovery message is malformed or Synd ( b , x i ( b ) , e i ) ∈ { 0 , Synd ( b , x i ( b ) , d i ) } \operatorname{Synd}(b,x_i^{(b)},e_i)\in\{0,\operatorname{Synd}(b,x_i^{(b)},d_i)\} Synd ( b , x i ( b ) , e i ) ∈ { 0 , Synd ( b , x i ( b ) , d i )} for any i ∈ [ N ] i\in[N] i ∈ [ N ] and b ∈ { 0 , 1 } b\in\{0,1\} b ∈ { 0 , 1 } , then the challenger sends ⊥ \perp ⊥ to A A A . Otherwise, the challenger sends β i : = e i ⋅ ( x i ( 0 ) ⊕ x i ( 1 ) ) \beta_i:=e_i\cdot(x_i^{(0)}\oplus x_i^{(1)}) β i := e i ⋅ ( x i ( 0 ) ⊕ x i ( 1 ) ) to A A A for each i ∈ [ N ] i\in[N] i ∈ [ N ] .
A A A chooses a bit u ′ u' u ′ to be the experiment's output.
Notation. For the proof of this lemma, it will be useful to define a slightly modified experiment Exp ℓ ( a , z ) \operatorname{Exp}_{\ell}(a,z) Exp ℓ ( a , z ) for a vector z ∈ F 2 m z\in\mathbb{F}_2^m z ∈ F 2 m . This experiment is identical to Exp ℓ ( a ) \operatorname{Exp}_{\ell}(a) Exp ℓ ( a ) , except for a modification in step 3. If the test measurement rejects, apply Z z Z^z Z z to register V \mathcal{V} V in addition to measuring ℓ ⋅ v \ell\cdot v ℓ ⋅ v . As a consequence,
Exp ℓ ( a ) = Exp ℓ ( a , 0 ) \operatorname{Exp}_{\ell}(a)=\operatorname{Exp}_{\ell}(a,0) Exp ℓ ( a ) = Exp ℓ ( a , 0 )
It will be useful to have shorthand for the probability that any experiment outputs 1:
Pr 1 , ℓ ( a , z ) : = Pr [ 1 ← Exp ℓ ( a , z ) ] \Pr_{1,\ell}(\mathbf{a},\mathbf{z}) := \Pr[1 \leftarrow\operatorname{Exp}_{\ell}(\mathbf{a},\mathbf{z})] 1 , ℓ Pr ( a , z ) := Pr [ 1 ← Exp ℓ ( a , z )]
We also consider experiments where the phase being inserted is not fixed. Given a vector z ′ \mathbf{z}' z ′ , define
Exp ℓ ( a , z + ∗ z ′ ) : = 1 2 Exp ℓ ( a , z ) + 1 2 Exp ℓ ( a , z + z ′ ) \operatorname{Exp}_{\ell}(\mathbf{a},\mathbf{z} + *\mathbf{z}') := \frac{1}{2}\operatorname{Exp}_{\ell}(\mathbf{a},\mathbf{z}) + \frac{1}{2}\operatorname{Exp}_{\ell}(\mathbf{a},\mathbf{z} + \mathbf{z}') Exp ℓ ( a , z + ∗ z ′ ) := 2 1 Exp ℓ ( a , z ) + 2 1 Exp ℓ ( a , z + z ′ )
In other words, insert phase z \mathbf{z} z with probability 1 / 2 1/2 1/2 or phase z + z ′ \mathbf{z}+\mathbf{z}' z + z ′ with probability 1 / 2 1/2 1/2 during the check step 3. Using the equivalence of random phases and measuring, Exp ℓ ( a , z + ∗ z ′ ) \operatorname{Exp}_{\ell}(\mathbf{a},\mathbf{z} + *\mathbf{z}') Exp ℓ ( a , z + ∗ z ′ ) corresponds to also measuring v ⋅ z ′ \mathbf{v}\cdot\mathbf{z}' v ⋅ z ′ during this step.
The final piece of notation we will need is to quantify the signed advantage with which an adversary distinguishes adding a vector b \mathbf{b} b to the encoding, conditioned on a variety of baseline scenarios ( a , z ) (\mathbf{a},\mathbf{z}) ( a , z ) . We define the signed distinguishing gap between Exp ℓ ( a , z ) \operatorname{Exp}_{\ell}(\mathbf{a},\mathbf{z}) Exp ℓ ( a , z ) and Exp ℓ ( a + b , z ) \operatorname{Exp}_{\ell}(\mathbf{a}+\mathbf{b},\mathbf{z}) Exp ℓ ( a + b , z ) to be
Δ ℓ ( b ∣ ( a , z ) ) : = Pr 1 , ℓ ( a , z ) − Pr 1 , ℓ ( a + b , z ) \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z})\right) := \Pr_{1,\ell}(\mathbf{a},\mathbf{z})-\Pr_{1,\ell}(\mathbf{a}+\mathbf{b},\mathbf{z}) Δ ℓ ( b ∣ ( a , z ) ) := 1 , ℓ Pr ( a , z ) − 1 , ℓ Pr ( a + b , z )
The ∗ * ∗ notation extends to the output probabilities Pr 1 , ℓ \Pr_{1,\ell} Pr 1 , ℓ and the gaps Δ ℓ \Delta_{\ell} Δ ℓ by using the corresponding experiment, e.g. Exp ℓ ( a , z + ∗ z ′ ) \operatorname{Exp}_{\ell}(\mathbf{a},\mathbf{z} + *\mathbf{z}') Exp ℓ ( a , z + ∗ z ′ ) .
Proof of Lemma 8. We show that
Exp ℓ ( ℓ , 0 ) ≈ c Exp ℓ ( ℓ , ∗ ℓ ) ≈ c Exp ℓ ( 0 , ∗ ℓ ) = Exp ℓ ( 0 , 0 ) \operatorname{Exp}_{\ell}(\ell,0) \approx_{\mathrm{c}} \operatorname{Exp}_{\ell}(\ell,*\ell) \approx_{\mathrm{c}} \operatorname{Exp}_{\ell}(0,*\ell) = \operatorname{Exp}_{\ell}(0,0) Exp ℓ ( ℓ , 0 ) ≈ c Exp ℓ ( ℓ , ∗ ℓ ) ≈ c Exp ℓ ( 0 , ∗ ℓ ) = Exp ℓ ( 0 , 0 )
For the first and last transitions, we claim that Exp ℓ ( a , 0 ) = Exp ℓ ( a , ∗ ℓ ) \operatorname{Exp}_{\ell}(\mathbf{a},0)=\operatorname{Exp}_{\ell}(\mathbf{a},*\ell) Exp ℓ ( a , 0 ) = Exp ℓ ( a , ∗ ℓ ) for all a \mathbf{a} a . This holds because Exp ℓ ( a , ∗ ℓ ) \operatorname{Exp}_{\ell}(\mathbf{a},*\ell) Exp ℓ ( a , ∗ ℓ ) is the experiment which measures ℓ ⋅ v \ell\cdot\mathbf{v} ℓ ⋅ v , which is already done in Exp ℓ ( a ) \operatorname{Exp}_{\ell}(\mathbf{a}) Exp ℓ ( a ) . The middle transition remains to be shown. Consider any QPT adversary’s distinguishing advantage
∣ Pr 1 , ℓ ( ℓ , ∗ ℓ ) − Pr 1 , ℓ ( 0 , ∗ ℓ ) ∣ \left|\Pr_{1,\ell}(\ell,*\ell)-\Pr_{1,\ell}(0,*\ell)\right| 1 , ℓ Pr ( ℓ , ∗ ℓ ) − 1 , ℓ Pr ( 0 , ∗ ℓ )
Expanding the ∗ ℓ *\ell ∗ ℓ notation and grouping the terms with the same inserted phase, their advantage is
1 2 ∣ Δ ℓ ( ℓ ∣ ( 0 , 0 ) ) + Δ ℓ ( ℓ ∣ ( 0 , ℓ ) ) ∣ \frac{1}{2}\left|\Delta_{\ell}\left(\ell\mid(0,0)\right)+\Delta_{\ell}\left(\ell\mid(0,\ell)\right)\right| 2 1 ∣ Δ ℓ ( ℓ ∣ ( 0 , 0 ) ) + Δ ℓ ( ℓ ∣ ( 0 , ℓ ) ) ∣
Lemma 10 shows that
Δ ℓ ( ℓ ∣ ( 0 , ℓ ) ) = Δ ℓ ( ℓ ∣ ( ℓ , 0 ) ) ± negl ( λ ) \Delta_{\ell}\left(\ell\mid(0,\ell)\right)=\Delta_{\ell}\left(\ell\mid(\ell,0)\right)\pm\operatorname{negl}(\lambda) Δ ℓ ( ℓ ∣ ( 0 , ℓ ) ) = Δ ℓ ( ℓ ∣ ( ℓ , 0 ) ) ± negl ( λ )
against any QPT adversary. Expanding the notation, we have
Δ ℓ ( ℓ ∣ ( ℓ , 0 ) ) = Pr 1 , ℓ ( ℓ , 0 ) − Pr 1 , ℓ ( 0 , 0 ) = − Δ ℓ ( ℓ ∣ ( 0 , 0 ) ) \begin{aligned}
\Delta_{\ell}\left(\ell\mid(\ell,0)\right)=\Pr_{1,\ell}(\ell,0)-\Pr_{1,\ell}(0,0) \\
&=-\Delta_{\ell}\left(\ell\mid(0,0)\right)
\end{aligned} Δ ℓ ( ℓ ∣ ( ℓ , 0 ) ) = 1 , ℓ Pr ( ℓ , 0 ) − 1 , ℓ Pr ( 0 , 0 ) = − Δ ℓ ( ℓ ∣ ( 0 , 0 ) )
The Δ ℓ ( ℓ ∣ ( 0 , 0 ) ) \Delta_{\ell}\left(\ell\mid(0,0)\right) Δ ℓ ( ℓ ∣ ( 0 , 0 ) ) gap terms cancel and the adversary’s advantage is negl ( λ ) \operatorname{negl}(\lambda) negl ( λ ) .
Distinguishing Gap Transport Lemma
The following lemma guarantees that the signed distinguishing gap changes negligibly between two baseline scenarios ( a , z ) (\mathbf{a},\mathbf{z}) ( a , z ) and ( a + b , z + b ) (\mathbf{a}+\mathbf{b},\mathbf{z}+\mathbf{b}) ( a + b , z + b ) where both the encoding and phase differ by the same arbitrary vector b \mathbf{b} b . Since b + b = 0 \mathbf{b}+\mathbf{b}=\mathbf{0} b + b = 0 over F 2 \mathbb{F}_2 F 2 , this can be interpreted as “moving” b \mathbf{b} b from the encoding to the phase in the baseline scenario.
Lemma 10 (Distinguishing Gap Transport, General). For all a , b , c , z ∈ F 2 m \mathbf{a},\mathbf{b},\mathbf{c},\mathbf{z}\in\mathbb{F}_2^m a , b , c , z ∈ F 2 m and all QPT adversaries,
Δ ℓ ( b ∣ ( a , z ) ) ≈ n e g l ( λ ) Δ ℓ ( b ∣ ( a + c , z + c ) ) \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z})\right)\mathrel{\approx_{\mathrm{negl}(\lambda)}}\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\mathbf{c},\mathbf{z}+\mathbf{c})\right) Δ ℓ ( b ∣ ( a , z ) ) ≈ negl ( λ ) Δ ℓ ( b ∣ ( a + c , z + c ) )
We start by proving the same relation when b \mathbf{b} b is a row of G G G (Claim 4), then prove the general version at the end of this subsection. In preparation for the limited version, we show that when g ⋅ v \mathbf{g}\cdot\mathbf{v} g ⋅ v is measured and g \mathbf{g} g is a row of G G G , no QPT adversary can distinguish adding g \mathbf{g} g to the value to be encoded.
Claim 3. Let g \mathbf{g} g be the i i i ’th row of G G G for any i i i . Then for all a \mathbf{a} a and z \mathbf{z} z ,
Δ ℓ ( g ∣ ( a , z + ∗ g ) ) = ± n e g l ( λ ) \Delta_{\ell}\left(\mathbf{g}\mid(\mathbf{a},\mathbf{z}+\ast\mathbf{g})\right)=\pm\mathrm{negl}(\lambda) Δ ℓ ( g ∣ ( a , z + ∗ g ) ) = ± negl ( λ )
Proof. If the test passes in the check step 3, then v i ′ = g ⋅ v \mathbf{v}'_i=\mathbf{g}\cdot\mathbf{v} v i ′ = g ⋅ v . Applying Z g Z^{\mathbf{g}} Z g to V \mathcal{V} V with probability 1 / 2 1/2 1/2 is equivalent to measuring v i ′ \mathbf{v}'_i v i ′ in the computational basis. Together with y i \mathbf{y}_i y i , this uniquely determines x i \mathbf{x}_i x i , so x i \mathbf{x}_i x i can also be measured without disturbing the state.
Now that ( v i ′ , x i ) (\mathbf{v}'_i,\mathbf{x}_i) ( v i ′ , x i ) is measured, we can invoke the 2-query adaptive hardcore bit property on index i i i (Definition 8 and lemma 4). This undetectably replaces ( d i , ( d i ⋅ Δ i ) ⊕ a i ′ ) (d_i,(\mathbf{d}_i\cdot\Delta_i)\oplus a'_i) ( d i , ( d i ⋅ Δ i ) ⊕ a i ′ ) by ( d i , ( d i ⋅ Δ i ) ⊕ a i ′ ⊕ 1 ) (d_i,(\mathbf{d}_i\cdot\Delta_i)\oplus a'_i\oplus1) ( d i , ( d i ⋅ Δ i ) ⊕ a i ′ ⊕ 1 ) in Exp ℓ ( a , z + ∗ g ) \operatorname{Exp}_{\ell}(\mathbf{a},\mathbf{z}+\ast\mathbf{g}) Exp ℓ ( a , z + ∗ g ) . Finally, we show that this replacement yields the other experiment Exp ℓ ( a + g , z + ∗ g ) \operatorname{Exp}_{\ell}(\mathbf{a}+\mathbf{g},\mathbf{z}+\ast\mathbf{g}) Exp ℓ ( a + g , z + ∗ g ) . We have replaced the encoded a ′ \mathbf{a}' a ′ by
a ′ + e i = ( a D + r P ) + e i \mathbf{a}'+\mathbf{e}_i=(\mathbf{a}D+\mathbf{r}P)+\mathbf{e}_i a ′ + e i = ( a D + r P ) + e i
where e i \mathbf{e}_i e i is the i i i ’th standard basis vector. Observe that g D G = e i G \mathbf{g}DG=\mathbf{e}_iG g D G = e i G , so ( g D − e i ) = ( g D + e i ) (\mathbf{g}D-\mathbf{e}_i)=(\mathbf{g}D+\mathbf{e}_i) ( g D − e i ) = ( g D + e i ) is in the kernel of G G G . Since the row span of P P P is the kernel of G G G , there exists a vector s \mathbf{s} s such that s P = g D + e i \mathbf{s}P=\mathbf{g}D+\mathbf{e}_i s P = g D + e i . Therefore
a ′ + e i = ( a + g ) D + ( r + s ) P \mathbf{a}'+\mathbf{e}_i=(\mathbf{a}+\mathbf{g})D+(\mathbf{r}+\mathbf{s})P a ′ + e i = ( a + g ) D + ( r + s ) P
Finally, the uniform distribution r \mathbf{r} r is invariant under linear shifts, so this is distributed precisely as ( a + g ) D + r ′ P (\mathbf{a}+\mathbf{g})D+\mathbf{r}'P ( a + g ) D + r ′ P for uniform r ′ \mathbf{r}' r ′ , which yields Exp ℓ ( a + g , z + ∗ g ) \operatorname{Exp}_{\ell}(\mathbf{a}+\mathbf{g},\mathbf{z}+\ast\mathbf{g}) Exp ℓ ( a + g , z + ∗ g ) .
Claim 4 (Distinguishing Gap Transport, Limited). Let b \mathbf{b} b be any standard basis vector. Then for all a , b , c , z ∈ F 2 m \mathbf{a},\mathbf{b},\mathbf{c},\mathbf{z}\in\mathbb{F}_2^m a , b , c , z ∈ F 2 m and all QPT adversaries,
Δ ℓ ( b ∣ ( a , z ) ) ≈ n e g l ( λ ) Δ ℓ ( b ∣ ( a + c , z + c ) ) (9) \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z})\right)\mathrel{\approx_{\mathrm{negl}(\lambda)}}\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\mathbf{c},\mathbf{z}+\mathbf{c})\right) \tag*{(9)} Δ ℓ ( b ∣ ( a , z ) ) ≈ negl ( λ ) Δ ℓ ( b ∣ ( a + c , z + c ) ) (9)
Proof. First, suppose that the claim holds only when c \mathbf{c} c is also a standard basis vector. Any general c \mathbf{c} c can be decomposed into a linear combination of standard basis vectors. Since c \mathbf{c} c has polynomial length, applying the assumed claim one at a time for each row shows the more general result.
We now show that the claim holds when c \mathbf{c} c is a standard basis vector. We show that the following two relations hold for such c \mathbf{c} c :
Δ ℓ ( b ∣ ( a , z + ∗ c ) ) ≈ n e g l ( λ ) Δ ℓ ( b ∣ ( a + c , z + ∗ c ) ) (10) \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z}+\ast\mathbf{c})\right) \approx_{\mathrm{negl}(\lambda)} \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\mathbf{c},\mathbf{z}+\ast\mathbf{c})\right) \tag*{(10)} Δ ℓ ( b ∣ ( a , z + ∗ c ) ) ≈ negl ( λ ) Δ ℓ ( b ∣ ( a + c , z + ∗ c ) ) (10)
Δ ℓ ( b ∣ ( a + ∗ c , z ) ) ≈ n e g l ( λ ) Δ ℓ ( b ∣ ( a + ∗ c , z + c ) ) (11) \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\ast\mathbf{c},\mathbf{z})\right) \approx_{\mathrm{negl}(\lambda)} \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\ast\mathbf{c},\mathbf{z}+\mathbf{c})\right) \tag*{(11)} Δ ℓ ( b ∣ ( a + ∗ c , z ) ) ≈ negl ( λ ) Δ ℓ ( b ∣ ( a + ∗ c , z + c ) ) (11)
The first shows that when the phase is randomized, the baseline encoding can be switched from a \mathbf{a} a to a + c \mathbf{a}+\mathbf{c} a + c without changing the gap noticeably. The second shows that when the baseline encoding is randomized, the phase can be switched from z \mathbf{z} z to z + c \mathbf{z}+\mathbf{c} z + c without changing the gap noticeably.
Combining these two yields the claim for c \mathbf{c} c using the following expansion:
Δ ℓ ( b ∣ ( a , z ) ) − Δ ℓ ( b ∣ ( a + c , z + c ) ) = [ Δ ℓ ( b ∣ ( a , z + ∗ c ) ) − Δ ℓ ( b ∣ ( a + c , z + ∗ c ) ) ] + [ Δ ℓ ( b ∣ ( a + ∗ c , z ) ) − Δ ℓ ( b ∣ ( a + ∗ c , z + c ) ) ] . (12) \begin{aligned}
\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z})\right)-\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\mathbf{c},\mathbf{z}+\mathbf{c})\right)
&=\left[\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z}+\ast\mathbf{c})\right)-\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\mathbf{c},\mathbf{z}+\ast\mathbf{c})\right)\right]\\
&\quad+\left[\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\ast\mathbf{c},\mathbf{z})\right)-\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\ast\mathbf{c},\mathbf{z}+\mathbf{c})\right)\right]. \tag*{(12)}
\end{aligned} Δ ℓ ( b ∣ ( a , z ) ) − Δ ℓ ( b ∣ ( a + c , z + c ) ) = [ Δ ℓ ( b ∣ ( a , z + ∗ c ) ) − Δ ℓ ( b ∣ ( a + c , z + ∗ c ) ) ] + [ Δ ℓ ( b ∣ ( a + ∗ c , z ) ) − Δ ℓ ( b ∣ ( a + ∗ c , z + c ) ) ] . (12)
To verify this identity, expand the two starred shifts. The terms at ( a , z + c ) (\mathbf{a},\mathbf{z}+\mathbf{c}) ( a , z + c ) and ( a + c , z ) (\mathbf{a}+\mathbf{c},\mathbf{z}) ( a + c , z ) cancel, while the terms at ( a , z ) (\mathbf{a},\mathbf{z}) ( a , z ) and ( a + c , z + c ) (\mathbf{a}+\mathbf{c},\mathbf{z}+\mathbf{c}) ( a + c , z + c ) each occur twice with coefficient 1 / 2 1/2 1/2 , with positive and negative signs, respectively. (10) implies the first grouping is negligible and (11) implies the second grouping is negligible.
Changing Encoding with Randomized Phase (10) . Expanding the Δ ℓ \Delta_{\ell} Δ ℓ notation and recombining the first terms of each against the last terms of each yields the identity
Δ ℓ ( b ∣ ( a , z + ∗ c ) ) − Δ ℓ ( b ∣ ( a + c , z + ∗ c ) ) = Δ ℓ ( c ∣ ( a , z + ∗ c ) ) − Δ ℓ ( c ∣ ( a + c , z + ∗ c ) ) . \begin{aligned}
\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z}+\ast\mathbf{c})\right)-\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\mathbf{c},\mathbf{z}+\ast\mathbf{c})\right)
&=\Delta_{\ell}\left(\mathbf{c}\mid(\mathbf{a},\mathbf{z}+\ast\mathbf{c})\right)-\Delta_{\ell}\left(\mathbf{c}\mid(\mathbf{a}+\mathbf{c},\mathbf{z}+\ast\mathbf{c})\right).
\end{aligned} Δ ℓ ( b ∣ ( a , z + ∗ c ) ) − Δ ℓ ( b ∣ ( a + c , z + ∗ c ) ) = Δ ℓ ( c ∣ ( a , z + ∗ c ) ) − Δ ℓ ( c ∣ ( a + c , z + ∗ c ) ) .
Both terms on the lower line are negligible by Claim 3 since c \mathbf{c} c is a standard basis vector. Therefore
∣ Δ ℓ ( b ∣ ( a , z + ∗ c ) ) − Δ ℓ ( b ∣ ( a + c , z + ∗ c ) ) ∣ = n e g l ( λ ) \left|\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z}+\ast\mathbf{c})\right)-\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\mathbf{c},\mathbf{z}+\ast\mathbf{c})\right)\right|=\mathrm{negl}(\lambda) ∣ Δ ℓ ( b ∣ ( a , z + ∗ c ) ) − Δ ℓ ( b ∣ ( a + c , z + ∗ c ) ) ∣ = negl ( λ )
Changing the Phase with a Randomized Baseline Encoding (11) . Since the baseline ( a + ∗ c , z ) (\mathbf{a}+\ast\mathbf{c},\mathbf{z}) ( a + ∗ c , z ) adds c \mathbf{c} c to the encoding with probability 1 / 2 1/2 1/2 , it is invariant under additions of c \mathbf{c} c . Therefore we can shift the distinguishing term by c \mathbf{c} c :
Δ ℓ ( b ∣ ( a + ∗ c , z ) ) = Δ ℓ ( b + c ∣ ( a + ∗ c , z ) ) . \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\ast\mathbf{c},\mathbf{z})\right)=\Delta_{\ell}\left(\mathbf{b}+\mathbf{c}\mid(\mathbf{a}+\ast\mathbf{c},\mathbf{z})\right). Δ ℓ ( b ∣ ( a + ∗ c , z ) ) = Δ ℓ ( b + c ∣ ( a + ∗ c , z ) ) .
Next, expanding the starred notation in Claim 3 gives a method to shift the phase by b \mathbf{b} b which is a row of G G G :
1 2 ( Δ ℓ ( b ∣ ( a , z ) ) + Δ ℓ ( b ∣ ( a , z + ⋆ b ) ) ) = Δ ℓ ( b ∣ ( a , z + ⋆ b ) ) ≈ negl ( λ ) 0 \frac{1}{2}\left(\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z})\right)+\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z}+\star\mathbf{b})\right)\right)=\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z}+\star\mathbf{b})\right)\mathrel{\approx_{\operatorname{negl}(\lambda)}}0 2 1 ( Δ ℓ ( b ∣ ( a , z ) ) + Δ ℓ ( b ∣ ( a , z + ⋆ b ) ) ) = Δ ℓ ( b ∣ ( a , z + ⋆ b ) ) ≈ negl ( λ ) 0
Combining the phase shift with the distinguishing term shift, we can transform
Δ ℓ ( b ∣ ( a + ⋆ c , z ) ) ≈ negl ( λ ) − Δ ℓ ( b ∣ ( a + ⋆ c , z + b ) ) = − Δ ℓ ( b + c ∣ ( a + ⋆ c , z + b ) ) ≈ negl ( λ ) Δ ℓ ( b + c ∣ ( a + ⋆ c , z + c ) ) = Δ ℓ ( b ∣ ( a + ⋆ c , z + c ) ) \begin{aligned}
\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\star\mathbf{c},\mathbf{z})\right)&\mathrel{\approx_{\operatorname{negl}(\lambda)}}-\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\star\mathbf{c},\mathbf{z}+\mathbf{b})\right)\\
&=-\Delta_{\ell}\left(\mathbf{b}+\mathbf{c}\mid(\mathbf{a}+\star\mathbf{c},\mathbf{z}+\mathbf{b})\right)\\
&\mathrel{\approx_{\operatorname{negl}(\lambda)}}\Delta_{\ell}\left(\mathbf{b}+\mathbf{c}\mid(\mathbf{a}+\star\mathbf{c},\mathbf{z}+\mathbf{c})\right)\\
&=\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\star\mathbf{c},\mathbf{z}+\mathbf{c})\right)
\end{aligned} Δ ℓ ( b ∣ ( a + ⋆ c , z ) ) ≈ negl ( λ ) − Δ ℓ ( b ∣ ( a + ⋆ c , z + b ) ) = − Δ ℓ ( b + c ∣ ( a + ⋆ c , z + b ) ) ≈ negl ( λ ) Δ ℓ ( b + c ∣ ( a + ⋆ c , z + c ) ) = Δ ℓ ( b ∣ ( a + ⋆ c , z + c ) )
The first phase shift is by b \mathbf{b} b , while the second is by b + c \mathbf{b}+\mathbf{c} b + c . Both are rows of G G G since b \mathbf{b} b and c \mathbf{c} c are both standard basis vectors.
So far, we have proved the property holds when the b \mathbf{b} b is a row of G G G and c \mathbf{c} c is arbitrary. We now generalize it to general b \mathbf{b} b .
Proof of the General Version (Lemma 10). First, we decompose b \mathbf{b} b in terms of rows of G G G :
b = ∑ i = 1 m β i g i \mathbf{b}=\sum_{i=1}^{m}\beta_i\mathbf{g}_i b = i = 1 ∑ m β i g i
where g i \mathbf{g}_i g i is the i i i th row of G G G and β i ∈ F 2 \beta_i\in\mathbb{F}_2 β i ∈ F 2 . One such decomposition is given by ( β 1 , … , β N ) = b D (\beta_1,\ldots,\beta_N)=\mathbf{b}D ( β 1 , … , β N ) = b D , since b D G = b \mathbf{b}DG=\mathbf{b} b D G = b . Next, we use these to define a path from 0 \mathbf{0} 0 to b \mathbf{b} b . The k k k th step along the path is
s k : = ∑ i = 1 k β i g i = s k − 1 + β k g k \mathbf{s}_k:=\sum_{i=1}^{k}\beta_i\mathbf{g}_i=\mathbf{s}_{k-1}+\beta_k\mathbf{g}_k s k := i = 1 ∑ k β i g i = s k − 1 + β k g k
We have s 0 = 0 \mathbf{s}_0=\mathbf{0} s 0 = 0 and s m = b \mathbf{s}_m=\mathbf{b} s m = b . Now we expand Δ ℓ ( b ∣ ( a , z ) ) \Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z})\right) Δ ℓ ( b ∣ ( a , z ) ) by both adding and subtracting every intermediate step, to obtain
Δ ℓ ( b ∣ ( a , z ) ) = Pr 1 , ℓ ( a , z ) − Pr 1 , ℓ ( a + b , z ) = ∑ k = 0 m − 1 Pr 1 , ℓ ( a + s k , z ) − ∑ k = 1 m Pr 1 , ℓ ( a + s k , z ) = ∑ k = 0 m − 1 Δ ℓ ( β k g k ∣ ( a + s k , z ) ) \begin{aligned}
\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},\mathbf{z})\right)&=\Pr_{1,\ell}(\mathbf{a},\mathbf{z})-\Pr_{1,\ell}(\mathbf{a}+\mathbf{b},\mathbf{z})\\
&=\sum_{k=0}^{m-1}\Pr_{1,\ell}(\mathbf{a}+\mathbf{s}_k,\mathbf{z})-\sum_{k=1}^{m}\Pr_{1,\ell}(\mathbf{a}+\mathbf{s}_k,\mathbf{z})\\
&=\sum_{k=0}^{m-1}\Delta_{\ell}\left(\beta_k\mathbf{g}_k\mid(\mathbf{a}+\mathbf{s}_k,\mathbf{z})\right)
\end{aligned} Δ ℓ ( b ∣ ( a , z ) ) = 1 , ℓ Pr ( a , z ) − 1 , ℓ Pr ( a + b , z ) = k = 0 ∑ m − 1 1 , ℓ Pr ( a + s k , z ) − k = 1 ∑ m 1 , ℓ Pr ( a + s k , z ) = k = 0 ∑ m − 1 Δ ℓ ( β k g k ∣ ( a + s k , z ) )
The last line follows by grouping the positive k k k th and negative ( k + 1 ) (k+1) ( k + 1 ) th terms. Claim 4 shows that translating the baseline in every gap k k k by ( c , c ) (\mathbf{c},\mathbf{c}) ( c , c ) only incurs negligible error μ k ( λ ) \mu_k(\lambda) μ k ( λ ) .
We may group the m m m negligible terms into one because m = poly ( λ ) m = \operatorname{poly}(\lambda) m = poly ( λ ) . Then, expanding the Δ ℓ \Delta_{\ell} Δ ℓ terms and canceling the intermediate steps yields
Δ ℓ ( b ∣ ( a , z ) ) = ∑ k = 0 m − 1 ( Δ ℓ ( β k g k ∣ ( ( a + c ) + s k , z + c ) ) ± μ k ( λ ) ) = ( ∑ k = 0 m − 1 Pr 1 , ℓ ( ( a + c ) + s k , z + c ) − ∑ k = 1 m Pr 1 , ℓ ( ( a + c ) + s k , z + c ) ) ± negl ( λ ) = ( Pr 1 , ℓ ( a + c , z + c ) − ∑ k = 1 m Pr 1 , ℓ ( ( a + c ) + b , z + c ) ) ± negl ( λ ) = Δ ℓ ( b ∣ ( a + c , z + c ) ) ± negl ( λ ) \begin{aligned}
\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a},z)\right)=\sum_{k=0}^{m-1}\left(\Delta_{\ell}\left(\beta_{k}\mathbf{g}_{k}\mid((\mathbf{a}+\mathbf{c})+\mathbf{s}_{k},z+c)\right)\pm\mu_{k}(\lambda)\right) \\
&=\left(\sum_{k=0}^{m-1}\Pr_{1,\ell}((\mathbf{a}+\mathbf{c})+\mathbf{s}_{k},z+c)-\sum_{k=1}^{m}\Pr_{1,\ell}((\mathbf{a}+\mathbf{c})+\mathbf{s}_{k},z+c)\right)\pm\operatorname{negl}(\lambda) \\
&=\left(\Pr_{1,\ell}(\mathbf{a}+\mathbf{c},z+c)-\sum_{k=1}^{m}\Pr_{1,\ell}((\mathbf{a}+\mathbf{c})+\mathbf{b},z+c)\right)\pm\operatorname{negl}(\lambda) \\
&=\Delta_{\ell}\left(\mathbf{b}\mid(\mathbf{a}+\mathbf{c},z+c)\right)\pm\operatorname{negl}(\lambda)
\end{aligned} Δ ℓ ( b ∣ ( a , z ) ) = k = 0 ∑ m − 1 ( Δ ℓ ( β k g k ∣ (( a + c ) + s k , z + c ) ) ± μ k ( λ ) ) = ( k = 0 ∑ m − 1 1 , ℓ Pr (( a + c ) + s k , z + c ) − k = 1 ∑ m 1 , ℓ Pr (( a + c ) + s k , z + c ) ) ± negl ( λ ) = ( 1 , ℓ Pr ( a + c , z + c ) − k = 1 ∑ m 1 , ℓ Pr (( a + c ) + b , z + c ) ) ± negl ( λ ) = Δ ℓ ( b ∣ ( a + c , z + c ) ) ± negl ( λ )
Security Against Honest-But-Curious P C P_C P C
In this section we show that the functionality specification itself implies security against honest-but-curious classical parties P C P_C P C . Intuitively, the state-preservation property ensures honest-but-curious statistical indistinguishability between any two inputs which have the same output distribution; otherwise, the classical party’s registers would collapse a superposition between those two inputs. Then, the linearity allows the simulator to find some arbitrary input which matches the output.
We remark that it is also possible to show security by relying on the semi-honest zero-knowledge of [27 ] ’s witness-preserving argument (inherited from GMW’s 3-coloring ZK).
Theorem 10 (Statistical Privacy against honest-but-curious P C P_C P C ). Protocol 1 is statistically secure against any honest-but-curious P C ∗ P_C^* P C ∗ . That is, there exists a QPT algorithm Sim with access to P C ∗ P_C^* P C ∗ ’s code and inputs ( L , C ) (L,C) ( L , C ) which uses the output u \mathbf{u} u prescribed by the ideal functionality to produce a view statistically indistinguishable from a real execution:
{ V ∗ : ( V ∗ , ρ u ) ← 2 P C ⟨ P C ∗ ( L , C ) , P Q ( ρ ) ⟩ } ≡ { u ← M [ L ] ( ρ ) V ∗ ← Sim ( P C ∗ , ( L , C ) , u ) \left\{\mathcal{V}^*:(\mathcal{V}^*,\rho_{\mathbf{u}})\leftarrow2\mathrm{PC}\langle P_C^*(L,C),P_Q(\rho)\rangle\right\}\equiv\left\{\begin{array}{ll}
\mathbf{u}\leftarrow M[L](\rho)\\
\mathcal{V}^*\leftarrow\operatorname{Sim}(P_C^*,(L,C),\mathbf{u})
\end{array}\right. { V ∗ : ( V ∗ , ρ u ) ← 2 PC ⟨ P C ∗ ( L , C ) , P Q ( ρ )⟩ } ≡ { u ← M [ L ] ( ρ ) V ∗ ← Sim ( P C ∗ , ( L , C ) , u ) where
Proof. We describe a simulator for the honest-but-curious view of P C ∗ P_C^* P C ∗ . The simulator begins with the input of P C ∗ P_C^* P C ∗ , which consists of a linear function L ∈ { 0 , 1 } ℓ × m L\in\{0,1\}^{\ell\times m} L ∈ { 0 , 1 } ℓ × m and a poly-size circuit C : { 0 , 1 } ℓ → { 0 , 1 } C:\{0,1\}^{\ell}\to\{0,1\} C : { 0 , 1 } ℓ → { 0 , 1 } . It sends ( L , C ) (L,C) ( L , C ) to the ideal functionality to get u \mathbf{u} u , then computes any v \mathbf{v} v such that L v ′ = u L\mathbf{v}'=\mathbf{u} L v ′ = u . Finally, it interacts with P C ∗ P_C^* P C ∗ in an honest execution of 2PC using ∣ v ′ ⟩ \lvert\mathbf{v}'\rangle ∣ v ′ ⟩ as the input of P Q P_Q P Q .
It suffices to show statistical indistinguishability of P C ∗ P_C^* P C ∗ ’s view between P Q P_Q P Q ’s use of any two inputs
∣ ψ ⟩ = ∑ u Π u ∣ ψ ⟩ and ∣ ϕ ⟩ = ∑ u Π u ∣ ϕ ⟩ \lvert\psi\rangle=\sum_{u}\Pi_{u}\lvert\psi\rangle\qquad\text{and}\qquad\lvert\phi\rangle=\sum_{u}\Pi_{u}\lvert\phi\rangle ∣ ψ ⟩ = u ∑ Π u ∣ ψ ⟩ and ∣ ϕ ⟩ = u ∑ Π u ∣ ϕ ⟩
where for all u \mathbf{u} u ,
Tr [ Π u ∣ ψ ⟩ ] = Tr [ Π u ∣ ϕ ⟩ ] . \operatorname{Tr}[\Pi_{\mathbf{u}} \lvert\psi\rangle] = \operatorname{Tr}[\Pi_{\mathbf{u}} \lvert\phi\rangle]. Tr [ Π u ∣ ψ ⟩] = Tr [ Π u ∣ ϕ ⟩] .
It suffices to prove input-indistinguishability for C C C which never aborts. For general C C C , the classical view is obtained from the always-deliver execution by recording the actual input C C C and, whenever C ( u ) = 1 C(\mathbf{u}) = 1 C ( u ) = 1 , truncating at that decision and appending the prescribed abort message.
Let ρ , σ \rho, \sigma ρ , σ be two input states such that
Tr ( Π L , u ρ ) = Tr ( Π L , u σ ) = p u for every u . \operatorname{Tr}(\Pi_{L,\mathbf{u}}\rho) = \operatorname{Tr}(\Pi_{L,\mathbf{u}}\sigma) = p_{\mathbf{u}} \qquad\text{for every }\mathbf{u}. Tr ( Π L , u ρ ) = Tr ( Π L , u σ ) = p u for every u .
Choose purifications ∣ ψ ⟩ A B \lvert\psi\rangle_{AB} ∣ ψ ⟩ A B and ∣ ϕ ⟩ A B \lvert\phi\rangle_{AB} ∣ ϕ ⟩ A B of ρ \rho ρ and σ \sigma σ , respectively, and consider an honest execution on register A A A of
∣ Ω ⟩ F A B = ∣ 0 ⟩ F ∣ ψ ⟩ A B + ∣ 1 ⟩ F ∣ ϕ ⟩ A B 2 , \lvert\Omega\rangle_{FAB} = \frac{\lvert0\rangle_F\lvert\psi\rangle_{AB} + \lvert1\rangle_F\lvert\phi\rangle_{AB}}{\sqrt{2}}, ∣ Ω ⟩ F A B = 2 ∣ 0 ⟩ F ∣ ψ ⟩ A B + ∣ 1 ⟩ F ∣ ϕ ⟩ A B ,
where F B FB F B is an untouched reference register. For every u \mathbf{u} u with p u > 0 p_{\mathbf{u}} > 0 p u > 0 , the ideal normalized residual state is
∣ Ω u ⟩ = ( I F ⊗ Π L , u ⊗ I B ) ∣ Ω ⟩ p u . \lvert\Omega_{\mathbf{u}}\rangle= \frac{(I_F \otimes\Pi_{L,\mathbf{u}} \otimes I_B)\lvert\Omega\rangle}{\sqrt{p_{\mathbf{u}}}}. ∣ Ω u ⟩ = p u ( I F ⊗ Π L , u ⊗ I B ) ∣ Ω ⟩ .
By Lemma 7, the test that, controlled by the classical output u \mathbf{u} u , projects F A B FAB F A B onto ∣ Ω u ⟩ \lvert\Omega_{\mathbf{u}}\rangle ∣ Ω u ⟩ succeeds with probability at least 1 − ε 1-\varepsilon 1 − ε , where ε = negl ( λ ) \varepsilon= \operatorname{negl}(\lambda) ε = negl ( λ ) ; the test rejects aborts and outcomes with p u = 0 p_{\mathbf{u}} = 0 p u = 0 . By gentle measurement, conditioning on success changes the full joint state, including P C ∗ P_C^* P C ∗ 's view, by trace distance at most ε \sqrt{\varepsilon} ε .
After this projection, conditioned on u \mathbf{u} u , register F A B FAB F A B is pure and hence independent of P C ∗ P_C^* P C ∗ 's view. Moreover, the equality of the two output distributions implies that measuring F F F in ∣ Ω u ⟩ \lvert\Omega_{\mathbf{u}}\rangle ∣ Ω u ⟩ yields a uniform bit for every u \mathbf{u} u . Thus, after the projection, this bit is independent of the classical view even without conditioning on u \mathbf{u} u . Before the projection, measuring F F F gives a uniform bit whose two conditional views are exactly the real views on inputs ρ \rho ρ and σ \sigma σ . Contractivity of trace distance and the triangle inequality therefore bound the distance between these two views by 2 ε = negl ( λ ) 2\sqrt{\varepsilon} = \operatorname{negl}(\lambda) 2 ε = negl ( λ ) .
Finally, for each u ∈ im ( L ) \mathbf{u} \in\operatorname{im}(L) u ∈ im ( L ) , fix a vector v u ′ \mathbf{v}'_{\mathbf{u}} v u ′ satisfying L v u ′ = u L\mathbf{v}'_{\mathbf{u}} = \mathbf{u} L v u ′ = u , computable by Gaussian elimination. Apply the preceding argument to the actual input ρ \rho ρ and
σ = ∑ u ∈ im ( L ) Tr ( Π L , u ρ ) ∣ v u ′ ⟩ ⟨ v u ′ ∣ . \sigma= \sum_{\mathbf{u}\in\operatorname{im}(L)} \operatorname{Tr}(\Pi_{L,\mathbf{u}}\rho)\lvert\mathbf{v}'_{\mathbf{u}}\rangle\langle\mathbf{v}'_{\mathbf{u}}\rvert. σ = u ∈ im ( L ) ∑ Tr ( Π L , u ρ ) ∣ v u ′ ⟩ ⟨ v u ′ ∣ .
These states induce the same ideal output distribution, and the real view on σ \sigma σ is exactly the simulator’s view averaged over the ideal output. This proves the claimed statistical indistinguishability.
Input-Preserving Classical 2PC for Constant Degree Functions
We note that our input-preserving classical 2PC for linear functions can be easily extended to a 2PC for constant degree functions. Specifically, suppose the classical party P C P_C P C takes as input an m m m -variate polynomial f f f of total degree d d d , where d d d is a constant, and the quantum party takes as input a state ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ \sum_{\mathbf{v}\in\{0,1\}^{m}} \alpha_{\mathbf{v}} \lvert\mathbf{v}\rangle ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ . The state preserving 2PC protocol for computing f ( v ) f(\mathbf{v}) f ( v ) is identical to the linear 2PC, but where the quantum party, rather than using its input ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ \sum_{\mathbf{v}\in\{0,1\}^{m}} \alpha_{\mathbf{v}} \lvert\mathbf{v}\rangle ∑ v ∈ { 0 , 1 } m α v ∣ v ⟩ , it uses the extended input ∑ v ∈ { 0 , 1 } m α v ∣ mon d ( v ) ⟩ \sum_{\mathbf{v}\in\{0,1\}^{m}} \alpha_{\mathbf{v}} \lvert\operatorname{mon}_{d}(\mathbf{v})\rangle ∑ v ∈ { 0 , 1 } m α v ∣ mon d ( v )⟩ where mon d ( v ) \operatorname{mon}_{d}(\mathbf{v}) mon d ( v ) consists of all the monomials of v \mathbf{v} v of degree ≤ d \le d ≤ d . Namely,
mon d ( v ) = ( v i 1 ⋯ v i j ) j ≤ d , ( i 1 , … , i j ) ∈ [ m ] j \operatorname{mon}_{d}(\mathbf{v}) = (v_{i_1}\cdots v_{i_j})_{j\le d,(i_1,\ldots,i_j)\in[m]^j} mon d ( v ) = ( v i 1 ⋯ v i j ) j ≤ d , ( i 1 , … , i j ) ∈ [ m ] j
Similarly, the classical party, rather than using its polynomial f f f as input, it uses its linearized version which is the linear function whose coefficients are all the monomials of f f f . In addition, in both the indistinguishably-extractable argumentss the quantum party also proves that the preimages are of the form mon d ( v ) \operatorname{mon}_{d}(\mathbf{v}) mon d ( v ) for some v \mathbf{v} v . Therefore we obtain the following theorem
Theorem 11. There exists a input-preserving classical 2PC for all constant degree functions, assuming the existence of a noisy trapdoor claw-free function family with the adaptive 2-query hardcore predicate property and assuming a witness-preserving indistinguishably-extractable argument for NP, both which can be instantiated under the LWE assumption.
II Classical Commitments to Quantum States
Remote State Preparation of Coset States
In this section, we construct a remote-state preparation protocol for random coset states
X x Z z ∣ S ⟩ . X^{x} Z^{z} \lvert S\rangle. X x Z z ∣ S ⟩ .
Our protocol allows the classical sender to choose S S S , while the x x x and z z z offsets are randomized. Intuitively, the security guarantees that any information learned from the protocol could also be learned from directly receiving the coset state, along with oracle access to S + x S+x S + x and S ⊥ + z S^{\perp}+z S ⊥ + z .
Notation. We briefly recall some notation for coset states from § 3.5 . Can ( S ) ⊂ F 2 d \operatorname{Can}(S) \subset\mathbb{F}_{2}^{d} Can ( S ) ⊂ F 2 d is a set of canonical elements of each S + x S+x S + x and is isomorphic to the quotient group F 2 d / S = { S + x : x ∈ F 2 d } \mathbb{F}_{2}^{d}/S = \{S+x:x\in\mathbb{F}_{2}^{d}\} F 2 d / S = { S + x : x ∈ F 2 d } . We denote one such isomorphism by Can S : F 2 d → F 2 d \operatorname{Can}_{S}:\mathbb{F}_{2}^{d}\to\mathbb{F}_{2}^{d} Can S : F 2 d → F 2 d . Thus, Can S ( x ) \operatorname{Can}_{S}(x) Can S ( x ) identifies a unique canonical element of S + x S+x S + x .
Definition
A remote state preparation protocol for coset states RSP d \operatorname{RSP}_{d} RSP d is an interactive protocol between a classical sender C C C and a quantum sender Q Q Q . It is parameterized by a polynomial d = d ( λ ) d=d(\lambda) d = d ( λ ) representing the dimension of the ambient space F 2 d \mathbb{F}_{2}^{d} F 2 d .
Both parties input the security parameter 1 λ 1^\lambda 1 λ in unary. The classical party additionally inputs a description of a subspace S ∈ F 2 d S \in\mathbb{F}_2^d S ∈ F 2 d . The quantum party Q Q Q outputs a register R \mathcal{R} R containing a coset state X x Z z ∣ S ⟩ X^x Z^z |S\rangle X x Z z ∣ S ⟩ and the classical party C C C outputs the description ( S , x , z ) (S,x,z) ( S , x , z ) of the coset state.
We denote an execution of R S P d \mathrm{RSP}_d RSP d with quantum output register R \mathcal{R} R and classical output ( x , z ) (x,z) ( x , z ) by
( R , ( x , z ) ) ← R S P d ⟨ Q , C ( S ) ⟩ ( 1 λ ) (\mathcal{R},(x,z)) \leftarrow\mathrm{RSP}_d\langle Q,C(S)\rangle(1^\lambda) ( R , ( x , z )) ← RSP d ⟨ Q , C ( S )⟩ ( 1 λ )
A remote state preparation protocol for coset states must satisfy correctness and security .
Definition 14 (Coset RSP Correctness). A remote state preparation protocol R S P d \mathrm{RSP}_d RSP d for coset states is correct with respect to a family of subspace sets { S λ } λ ∈ N \{\mathcal{S}_\lambda\}_{\lambda\in\mathbb{N}} { S λ } λ ∈ N if for all λ ∈ N \lambda\in\mathbb{N} λ ∈ N and all S ∈ S λ S \in\mathcal{S}_\lambda S ∈ S λ ,
Pr [ R contains X x Z z ∣ S ⟩ : ( R , ( S , x , z ) ) ← R S P ⟨ Q , C ( S ) ⟩ ( 1 λ ) ] = 1 − negl ( λ ) \Pr\left[\mathcal{R}\text{ contains }X^x Z^z|S\rangle: (\mathcal{R},(S,x,z)) \leftarrow\mathrm{RSP}\langle Q,C(S)\rangle(1^\lambda)\right] = 1-\operatorname{negl}(\lambda) Pr [ R contains X x Z z ∣ S ⟩ : ( R , ( S , x , z )) ← RSP ⟨ Q , C ( S )⟩ ( 1 λ ) ] = 1 − negl ( λ )
For any coset S + x S+x S + x , we denote the oracle which decides membership in S + x S+x S + x as O S + x \mathcal{O}_{S+x} O S + x .
Definition 15 (Coset RSP Security). A remote state preparation protocol R S P d \mathrm{RSP}_d RSP d for a family of subspace sets { S λ } λ ∈ N \{\mathcal{S}_\lambda\}_{\lambda\in\mathbb{N}} { S λ } λ ∈ N is secure up to membership oracles if there exists a QPT algorithm Sim \operatorname{Sim} Sim such that for all adversarial quantum receivers Q ∗ Q^* Q ∗ , all sufficiently large λ ∈ N \lambda\in\mathbb{N} λ ∈ N and all S ∈ S λ S \in\mathcal{S}_\lambda S ∈ S λ ,
{ ( R ∗ , Y ) ← R S P d ⟨ Q ∗ , C ( S ) ⟩ ( 1 λ ) } ≈ c { ( R ∗ , Y ) : x ← Can ( S ) , z ← Can ( S ⊥ ) ( R ∗ , a ) ← Sim O S + x , O S ⊥ + z ( Q ∗ , X x Z z ∣ S ⟩ ) } \left\{(\mathcal{R}^*,Y)\leftarrow\mathrm{RSP}_d\langle Q^*,C(S)\rangle(1^\lambda)\right\}\approx_c\left\{(\mathcal{R}^*,Y):\begin{aligned}
&x\leftarrow\operatorname{Can}(S),\ z\leftarrow\operatorname{Can}(S^\perp)\\
&(\mathcal{R}^*,a)\leftarrow\operatorname{Sim}^{\mathcal{O}_{S+x},\mathcal{O}_{S^\perp+z}}(Q^*,X^xZ^z|S\rangle)
\end{aligned}\right\} { ( R ∗ , Y ) ← RSP d ⟨ Q ∗ , C ( S )⟩ ( 1 λ ) } ≈ c { ( R ∗ , Y ) : x ← Can ( S ) , z ← Can ( S ⊥ ) ( R ∗ , a ) ← Sim O S + x , O S ⊥ + z ( Q ∗ , X x Z z ∣ S ⟩) } where the classical sender’s output is
Y = { ( x , z ) if C accepts (respectively, a = 0 ) ⊥ if C rejects (respectively, a = 1 ) Y=\begin{cases}
(x,z) & \text{if } C \text{ accepts (respectively, } a=0\text{)}\\
\perp& \text{if } C \text{ rejects (respectively, } a=1\text{)}
\end{cases} Y = { ( x , z ) ⊥ if C accepts (respectively, a = 0 ) if C rejects (respectively, a = 1 ) We say it is ϵ \epsilon ϵ -secure up to membership oracles if there exists a uniform family of poly ( λ , n ) \operatorname{poly}(\lambda,n) poly ( λ , n ) -sized QPT algorithms { { Sim λ , n } n ∈ N } λ ∈ N \{\{\operatorname{Sim}_{\lambda,n}\}_{n\in\mathbb{N}}\}_{\lambda\in\mathbb{N}} {{ Sim λ , n } n ∈ N } λ ∈ N such that the two distributions above (where Sim \operatorname{Sim} Sim is replaced by Sim λ , n \operatorname{Sim}_{\lambda,n} Sim λ , n ) are 1 / n 1/n 1/ n -indistinguishable for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N and n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) .
Note that we require the joint distribution of the receiver’s view and the sender’s output is indistinguishable.
Construction Before describing our protocol, we first give some intuition about the construction. Suppose that we instead wanted to construct states of the simpler form
Such a state can be constructed by using a state-preserving 2PC for linear functions to partition a ∣ + λ ⟩ \lvert+^\lambda\rangle ∣ + λ ⟩ state into cosets S + x S+x S + x of S S S , then measuring which coset the state is supported on. In other words, measure Can S ( ∙ ) \operatorname{Can}_S(\bullet) Can S ( ∙ ) on a ∣ + λ ⟩ \lvert+^\lambda\rangle ∣ + λ ⟩ state.
Although this approach provides a good starting point, a single repetition does not suffice for our purposes. In fact, an adversarial receiver can even control the x x x offset which the sender outputs by simply inputting ∣ x ⟩ \lvert x\rangle ∣ x ⟩ instead of ∣ + λ ⟩ \lvert+^\lambda\rangle ∣ + λ ⟩ to the 2PC. The solution to hiding x x x lies in the missing z z z offset. To add a (mostly) random z z z offset, we can add an extra measurement round, implemented via 2PC, and slightly adjust the first round as follows:
Measure the coset of a random R ⊂ S R \subset S R ⊂ S to get x R x_R x R and residual state ∣ R + x R ⟩ \lvert R+x_R\rangle ∣ R + x R ⟩ .
Hadamard ∣ R + x R ⟩ \lvert R+x_R\rangle ∣ R + x R ⟩ to get Z x R ∣ R ⟩ Z^{x_R}\lvert R\rangle Z x R ∣ R ⟩ , then measure the coset of S ⊥ S^\perp S ⊥ to get z z z .
Now the z z z offset is randomized within R ⊥ ⊃ S ⊥ R^\perp\supset S^\perp R ⊥ ⊃ S ⊥ . Moreover, if the adversary is forced to input Z x R ∣ R ⊥ ⟩ Z^{x_R}\lvert R^\perp\rangle Z x R ∣ R ⊥ ⟩ , then they have no control over z z z . We force this by checking that the input to the second 2PC is supported on R ⊥ R^\perp R ⊥ . Intuitively, the adversary should not be able to find a vector in R ⊥ R^\perp R ⊥ , except by inputting H ∣ R + x R ⟩ H\lvert R+x_R\rangle H ∣ R + x R ⟩ .
Now we have forced a random z z z which is hidden within R ⊥ R^\perp R ⊥ . The adversary also cannot directly pick x x x by inputting ∣ x ⟩ \lvert x\rangle ∣ x ⟩ to the first measurement because that would leave them unable to find a valid input in R ⊥ R^\perp R ⊥ for the second measurement. This does not rule out indirect influence over x x x , however.
For achieving simulation security, we also add a third round to be able to treat x x x in the same way as z z z . Concretely, the three measurements become:
Measure a coset of a random R ⊂ S R \subset S R ⊂ S to get x R x_R x R .
Check membership in R ⊥ R^\perp R ⊥ , then measure a coset of a random T ⊥ ⊂ S ⊥ T^\perp\subset S^\perp T ⊥ ⊂ S ⊥ to get z z z .
Check membership in T + x R T+x_R T + x R , then measure a coset of S S S to get x x x .
In the final version, R ⊥ R^\perp R ⊥ randomizes z z z , while T T T randomizes x x x . Moreover, R ⊥ R^\perp R ⊥ and T T T are already quite randomized, resulting in nearly uniform x x x and z z z . We describe the protocol formally below.
Protocol 2 (Remote State Preparation of Coset States). The parties start with the security parameter 1 λ 1^\lambda 1 λ and the parameterized polynomial d = d ( λ ) d=d(\lambda) d = d ( λ ) . Additionally, the classical sender C C C starts with a subspace S ⊂ F 2 d S\subset\mathbb{F}_2^d S ⊂ F 2 d such that dim ( S ) ∈ [ 2 λ , d − 2 λ + O ( 1 ) ] \dim(S)\in[2\lambda,d-2\lambda+O(1)] dim ( S ) ∈ [ 2 λ , d − 2 λ + O ( 1 )] . The additive constant in the upper bound is fixed independently of λ \lambda λ and d d d ; the construction is defined for all sufficiently large λ \lambda λ . The parties interact as follows.
Classical Sender: Sample subspaces R R R and T T T of dimension λ \lambda λ and d − λ d-\lambda d − λ , respectively, such that R ⊂ S ⊂ T R\subset S\subset T R ⊂ S ⊂ T .27
Quantum Receiver: Prepare the uniform superposition 1 2 d ∑ v ∈ F 2 d ∣ v ⟩ \frac{1}{\sqrt{2^d}}\sum_{v\in\mathbb{F}_2^d}\lvert v\rangle 2 d 1 ∑ v ∈ F 2 d ∣ v ⟩ in register V \mathcal{V} V .
First 2PC: Do a state-preserving 2PC with the following functionality and inputs.
Quantum Party Input: Register V \mathcal{V} V . Classical Party Input: The subspace R R R . Functionality: On computational-basis input v v v , output
x R = Can R ( v ) . x_R = \operatorname{Can}_{R}(v). x R = Can R ( v ) .
If the 2PC output is x R x_R x R , then the quantum receiver’s resulting state in register V \mathcal{V} V is
∣ R + x R ⟩ = X x R ∣ R ⟩ \lvert R+x_R\rangle= X^{x_R}\lvert R\rangle ∣ R + x R ⟩ = X x R ∣ R ⟩
Quantum Receiver: Hadamard register V \mathcal{V} V . At this point, an honest quantum receiver’s state is
Z x R ∣ R ⊥ ⟩ Z^{x_R}\lvert R^\perp\rangle Z x R ∣ R ⊥ ⟩
Second 2PC: Do a state-preserving 2PC with the following functionality.
Quantum Party Input: The register V \mathcal{V} V . Classical Party Input: The subspaces R R R and T ⊥ T^\perp T ⊥ . Functionality: On computational-basis input v v v , output
z T ⊥ = { Can T ⊥ ( v ) if v ∈ R ⊥ ∖ S ⊥ , ⊥ else . z_{T^\perp} =
\begin{cases}
\operatorname{Can}_{T^\perp}(v) & \text{if } v\in R^\perp\setminus S^\perp,\\
\perp& \text{else}.
\end{cases} z T ⊥ = { Can T ⊥ ( v ) ⊥ if v ∈ R ⊥ ∖ S ⊥ , else .
If any output is ⊥ \perp ⊥ , abort. Otherwise, the classical sender’s output is z z z where z T ⊥ ∈ R ⊥ z_{T^\perp}\in R^\perp z T ⊥ ∈ R ⊥ and the quantum receiver’s state is
Z x R ∣ T ⊥ + z T ⊥ ⟩ = Z x R X z T ⊥ ∣ T ⊥ ⟩ Z^{x_R}\lvert T^\perp+z_{T^\perp}\rangle= Z^{x_R}X^{z_{T^\perp}}\lvert T^\perp\rangle Z x R ∣ T ⊥ + z T ⊥ ⟩ = Z x R X z T ⊥ ∣ T ⊥ ⟩
Quantum Receiver: Hadamard register V \mathcal{V} V . At this point, an honest quantum receiver’s state in each register R o u t , i R_{\mathrm{out},i} R out , i is
X x R Z z T ⊥ ∣ T ⟩ X^{x_R}Z^{z_{T^\perp}}\lvert T\rangle X x R Z z T ⊥ ∣ T ⟩
Third 2PC: Do a state-preserving 2PC with the following functionality.
Quantum Party Input: The register V \mathcal{V} V . Classical Party Input: The subspace S S S and the coset T + x R T+x_R T + x R . Functionality: On computational-basis input v v v , output
x = { Can S ( v ) if v ∈ ( T + x R ) ∖ ( S + x R ) , ⊥ else . x =
\begin{cases}
\operatorname{Can}_{S}(v) & \text{if } v\in(T+x_R)\setminus(S+x_R),\\
\perp& \text{else}.
\end{cases} x = { Can S ( v ) ⊥ if v ∈ ( T + x R ) ∖ ( S + x R ) , else .
If any output is ⊥ \perp ⊥ , abort. Otherwise, the classical sender’s output is x x x where x ∈ T + x R x \in T+x_R x ∈ T + x R and the quantum receiver’s state is
X x Z z T ⊥ ∣ S ⟩ X^x Z^{z_{T^\perp}} |S\rangle X x Z z T ⊥ ∣ S ⟩
We can equivalently interpret Z z T ⊥ Z^{z_{T^\perp}} Z z T ⊥ as Z z Z^z Z z for any z ∈ S ⊥ + z T ⊥ z \in S^\perp+z_{T^\perp} z ∈ S ⊥ + z T ⊥ .
Classical Sender: Compute z = Can S ⊥ ( z T ⊥ ) z=\operatorname{Can}_{S^\perp}(z_{T^\perp}) z = Can S ⊥ ( z T ⊥ ) , then output ( S , x , z ) (S,x,z) ( S , x , z ) .
Quantum Receiver: Output register V \mathcal{V} V .
Theorem 12. If 2PC is an ϵ \epsilon ϵ -secure (respectively, secure) state-preserving 2PC for linear functions with post-processed abort, then Protocol 2 is an ϵ \epsilon ϵ -secure (respectively, secure) remote state preparation protocol for coset states for all polynomials d d d and all S S S such that dim ( S ) ∈ [ 2 λ , d − 2 λ + O ( 1 ) ] \dim(S)\in[2\lambda,d-2\lambda+O(1)] dim ( S ) ∈ [ 2 λ , d − 2 λ + O ( 1 )] .
Proof. We begin with correctness. The evolution of the receiver’s state when no abort occurs is documented as part of the protocol description. By definition, z = s + z T ⊥ z=s+z_{T^\perp} z = s + z T ⊥ for some s ∈ S ⊥ s\in S^\perp s ∈ S ⊥ , so X x Z z T ⊥ ∣ S ⟩ = X x Z z ∣ S ⟩ X^xZ^{z_{T^\perp}}|S\rangle=X^xZ^z|S\rangle X x Z z T ⊥ ∣ S ⟩ = X x Z z ∣ S ⟩ .
An abort occurs only if the quantum receiver inputs v ∈ S ⊥ v\in S^\perp v ∈ S ⊥ in the second 2PC or if they input v ∈ S + x R v\in S+x_R v ∈ S + x R in the third 2PC . For dim ( S ) ≤ d − 2 λ \dim(S)\le d-2\lambda dim ( S ) ≤ d − 2 λ , these events happen with negligible probability because v v v is a uniform element from R ⊥ R^\perp R ⊥ and T + x R T+x_R T + x R , respectively, and the two failure cases form a negligible portion of these spaces: ∣ S ⊥ ∣ / ∣ R ⊥ ∣ ≤ 2 − λ |S^\perp|/|R^\perp|\le2^{-\lambda} ∣ S ⊥ ∣/∣ R ⊥ ∣ ≤ 2 − λ and ∣ S + x R ∣ / ∣ T + x R ∣ ≤ 2 − λ |S+x_R|/|T+x_R|\le2^{-\lambda} ∣ S + x R ∣/∣ T + x R ∣ ≤ 2 − λ . Increasing dim ( S ) \dim(S) dim ( S ) by a constant above d − 2 λ d-2\lambda d − 2 λ multiplies the latter bound by at most 2 O ( 1 ) 2^{O(1)} 2 O ( 1 ) , so it remains negligible.
We show security in § 5.2.2 . □
Security
Before proving security, we first prove an equivalence between measurement coset representatives and applying a Z z Z^z Z z operation for a random z ← S ⊥ z\leftarrow S^\perp z ← S ⊥ . This generalizes the well-known equivalence between measuring in the computational basis and randomly applying a Z Z Z gate.
Lemma 11. For any subspace S ⊆ F 2 n S\subseteq\mathbb{F}_2^n S ⊆ F 2 n and any mixed state ρ \rho ρ , the following two mixed states are equivalent:
Measure Can S ( ρ ) \operatorname{Can}_S(\rho) Can S ( ρ ) , discard the measurement result, and output the residual state.
Sample s ← S ⊥ s\leftarrow S^\perp s ← S ⊥ and output Z s ρ Z s Z^s\rho Z^s Z s ρ Z s .
Proof. By linearity, it suffices to consider the effect on any ∣ x ⟩ ⟨ y ∣ |x\rangle\langle y| ∣ x ⟩ ⟨ y ∣ term. The measurement channel preserves the term if S + x = S + y S+x=S+y S + x = S + y , i.e. if x + y ∈ S x+y\in S x + y ∈ S , and otherwise erases the term. The phase channel results in
∣ x ⟩ ⟨ y ∣ 1 ∣ S ⊥ ∣ ∑ s ∈ S ⊥ ( − 1 ) s ⋅ x + s ⋅ y |x\rangle\langle y|\frac{1}{|S^\perp|}\sum_{s\in S^\perp}(-1)^{s\cdot x+s\cdot y} ∣ x ⟩ ⟨ y ∣ ∣ S ⊥ ∣ 1 s ∈ S ⊥ ∑ ( − 1 ) s ⋅ x + s ⋅ y
Similarly, the summation becomes 1 if x + y ∈ S x+y\in S x + y ∈ S and 0 otherwise. □
The equivalence of measurement and random Z Z Z operations will play a crucial role in the proof of security for remote state preparation, which we give next.
The Simulator
The simulator Sim(A \mathcal{A} A ) works as follows.
Take as input the state
X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}\lvert S\rangle X x ′ Z z ′ ∣ S ⟩
in register C \mathcal{C} C .
Run the adversary until the first 2PC (step 3).
First 2PC. Run the 2PC simulator for the following functionality.
Quantum Party Input: Register V 1 \mathcal{V}_1 V 1 . Functionality: Apply CX from register V 1 \mathcal{V}_1 V 1 to register C \mathcal{C} C .
Run the adversary until the second 2PC (step 5).
Second 2PC. Run the 2PC simulator for the following functionality.
Quantum Party Input: Register V 2 \mathcal{V}_2 V 2 . Functionality:
(a) Query O S + Z \mathcal{O}_{S+Z} O S + Z on V 2 \mathcal{V}_2 V 2 . If it rejects, immediately return V 2 \mathcal{V}_2 V 2 to Q ∗ Q^* Q ∗ and output Q ∗ Q^* Q ∗ ’s internal state.
(b) Otherwise, apply CZ from register V 2 \mathcal{V}_2 V 2 to register C \mathcal{C} C .
Run the adversary until the third 2PC (step item 7).
Third 2PC. Run the 2PC simulator for the following functionality.
Quantum Party Input: Register V 3 \mathcal{V}_3 V 3 . Functionality:
(a) Query O S + X \mathcal{O}_{S+X} O S + X on V 3 \mathcal{V}_3 V 3 . If it rejects, immediately return V 3 \mathcal{V}_3 V 3 to Q ∗ Q^* Q ∗ and output Q ∗ Q^* Q ∗ ’s internal state.
(b) Otherwise, apply CX from register V 3 \mathcal{V}_3 V 3 to register C \mathcal{C} C .
Output. Output the adversary’s internal register R ∗ \mathcal{R}^* R ∗ .
Indistinguishability of the Simulator
We now show indistinguishability of Ideal( Sim ( A ) , 1 λ ) (\operatorname{Sim}(\mathcal{A}),1^\lambda) ( Sim ( A ) , 1 λ ) from the real experiment via a series of hybrid experiments. The ideal functionality prescribes the output ( x C a n ′ , z C a n ′ ) ∈ Can ( S ) × Can ( S ⊥ ) (x'_{\mathrm{Can}},z'_{\mathrm{Can}}) \in\operatorname{Can}(S) \times\operatorname{Can}(S^\perp) ( x Can ′ , z Can ′ ) ∈ Can ( S ) × Can ( S ⊥ ) to the classical party and sends X x C a n ′ Z z C a n ′ ∣ S ⟩ X^{x'_{\mathrm{Can}}}Z^{z'_{\mathrm{Can}}}|S\rangle X x Can ′ Z z Can ′ ∣ S ⟩ to Sim. It is equivalent, up to a global phase, to assume that Sim instead receives X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}|S\rangle X x ′ Z z ′ ∣ S ⟩ where x ′ ← S + x C a n ′ x' \leftarrow S+x'_{\mathrm{Can}} x ′ ← S + x Can ′ and z ′ ← S ⊥ + z C a n ′ z' \leftarrow S^\perp+z'_{\mathrm{Can}} z ′ ← S ⊥ + z Can ′ .
We divide the hybrids into 4 high-level phases: 1) setup, 2) force the Z Z Z key to be z C a n ′ z'_{\mathrm{Can}} z Can ′ , 3) force the X X X key to be x C a n ′ x'_{\mathrm{Can}} x Can ′ , and 4) replace the 2PC ideal functionalities by CX and CZ operations with the prescribed state X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}|S\rangle X x ′ Z z ′ ∣ S ⟩ .
H y b 0 ‾ \underline{\mathrm{Hyb}_0} Hyb 0 is the real execution of the remote state preparation protocol. Its output is ( R ∗ , Y ) (R^*,Y) ( R ∗ , Y ) for Y ∈ { ( x , z ) , ⊥ } Y \in\{(x,z),\perp\} Y ∈ {( x , z ) , ⊥ } , the joint distribution of the adversary’s state along with the classical sender’s output Y Y Y .
H y b 2 ‾ \underline{\mathrm{Hyb}_2} Hyb 2 changes H y b 1 \mathrm{Hyb}_1 Hyb 1 by modifying the outputs of the first and second 2PCs . Specifically, compute the ideal functionality for both 2PCs as before, then in the output step:
First 2PC: Instead of outputting x R = Can R ( v ) x_R=\operatorname{Can}_R(v) x R = Can R ( v ) , output x S : = Can S ( x R ) x_S:=\operatorname{Can}_S(x_R) x S := Can S ( x R ) .
Second 2PC: Instead of outputting z T ⊥ = Can T ⊥ ( v ) z_{T^\perp}=\operatorname{Can}_{T^\perp}(v) z T ⊥ = Can T ⊥ ( v ) , output z : = Can S ⊥ ( z T ⊥ ) z:=\operatorname{Can}_{S^\perp}(z_{T^\perp}) z := Can S ⊥ ( z T ⊥ ) .
Forcing z ′ z' z ′ . The next set of hybrids modifies the ideal functionalities of the first and second 2PCs to force the classical sender’s output to be ( x , z C a n ′ ) (x,z'_{\mathrm{Can}}) ( x , z Can ′ ) where z C a n ′ z'_{\mathrm{Can}} z Can ′ is sampled uniformly from Can ( S ⊥ ) \operatorname{Can}(S^\perp) Can ( S ⊥ ) instead of being chosen by the adversary in the second 2PC.
H y b 4 ‾ \underline{\mathrm{Hyb}_4} Hyb 4 changes the distribution of z ′ z' z ′ . In H y b 3 \mathrm{Hyb}_3 Hyb 3 , one may equivalently first sample z ′ z' z ′ from its marginal distribution, then sample R ⊥ ⊃ S ⊥ R^\perp\supset S^\perp R ⊥ ⊃ S ⊥ subject to z ′ ∈ R ⊥ z' \in R^\perp z ′ ∈ R ⊥ .
In H y b 4 \mathrm{Hyb}_4 Hyb 4 , instead of sampling z ′ z' z ′ from its marginal distribution, we sample it uniformly from F 2 d \mathbb{F}_2^d F 2 d . Equivalently, sample z C a n ′ ← Can ( S ⊥ ) z'_{\mathrm{Can}} \leftarrow\operatorname{Can}(S^\perp) z Can ′ ← Can ( S ⊥ ) and z ′ ← S + z C a n ′ z' \leftarrow S+z'_{\mathrm{Can}} z ′ ← S + z Can ′ .
(Modified ) Check that v 2 ∈ S ⊥ + z ′ v_2 \in S^\perp+ z' v 2 ∈ S ⊥ + z ′ . If not, output ⊥ \perp ⊥ .28
Measure z T ⊥ ′ ← Can T ⊥ ( v 2 ) z'_{T^\perp} \leftarrow\operatorname{Can}_{T^\perp}(v_2) z T ⊥ ′ ← Can T ⊥ ( v 2 ) . Discard the measurement result.
(Modified ) Output z C a n ′ z'_{\mathrm{Can}} z Can ′ .
Note that the check forces the output to be z C a n ′ = Can S ( z ′ ) z'_{\mathrm{Can}} = \operatorname{Can}_S(z') z Can ′ = Can S ( z ′ ) , which is eventually output as part of the classical party’s output ( S , x , z C a n ′ ) (S,x,z'_{\mathrm{Can}}) ( S , x , z Can ′ ) .
Forcing x ′ x' x ′ . The next set of hybrids modifies the ideal functionalities of the second and third 2PCs to force the classical sender’s output to be ( x C a n ′ , z C a n ′ ) (x'_{\mathrm{Can}},z'_{\mathrm{Can}}) ( x Can ′ , z Can ′ ) where x C a n ′ x'_{\mathrm{Can}} x Can ′ is sampled uniformly from Can ( S ) \operatorname{Can}(S) Can ( S ) instead of being chosen by the adversary in the third 2PC.
H y b 7 ‾ \underline{\mathrm{Hyb}_7} Hyb 7 changes the distribution of x ′ ′ x'' x ′′ . In H y b 6 \mathrm{Hyb}_6 Hyb 6 , one may equivalently first sample x ′ ′ x'' x ′′ from its marginal distribution, then sample T ⊃ S T \supset S T ⊃ S subject to x ′ ′ ∈ T x'' \in T x ′′ ∈ T .
In H y b 7 \mathrm{Hyb}_7 Hyb 7 , instead of sampling x ′ ′ x'' x ′′ from its marginal distribution, we sample it uniformly from F 2 d \mathbb{F}_2^d F 2 d .
Note that the check forces the output to be x ′ ′ + x S = x'' + x_S = x ′′ + x S = , which is eventually output as part of the classical party’s output ( S , x S + x ′ ′ , z ′ ) (S,x_S+x'',z') ( S , x S + x ′′ , z ′ ) .
Note that this modifies the third 2PC to check membership in S + x ′ S+x' S + x ′ and to always output either ⊥ \perp ⊥ or x C a n ′ = Can S ( x ′ ) x'_{\mathrm{Can}} = \operatorname{Can}_S(x') x Can ′ = Can S ( x ′ ) .
Switching to Controlled X X X and Z Z Z . Finally, we switch the remaining measurements and Z Z Z operations to use the prescribed X x ′ Z z ′ ∣ S ⟩ X^{x'}Z^{z'}|S\rangle X x ′ Z z ′ ∣ S ⟩ state as a black box.
Ideal ( Sim , 1 λ ) ‾ \underline{\operatorname{Ideal}(\operatorname{Sim},1^\lambda)} Ideal ( Sim , 1 λ ) changes H y b 12 \mathrm{Hyb}_{12} Hyb 12 as follows.
Remove all output steps from the three 2PC functionalities (not including abort checks). Directly output ( x C a n ′ , z C a n ′ ) (x'_{\mathrm{Can}},z'_{\mathrm{Can}}) ( x Can ′ , z Can ′ ) as the classical sender’s output.
Do not measure x S ← Can S ( ⋅ ) x_S \leftarrow\operatorname{Can}_{S}(\cdot) x S ← Can S ( ⋅ ) on register V 1 \mathcal{V}_1 V 1 during the first 2PC .
H y b 0 \mathrm{Hyb}_0 Hyb 0 is 1 / n 1/n 1/ n -indistinguishable from H y b 1 \mathrm{Hyb}_1 Hyb 1 by the security of the 2PC, invoked 3 times sequentially. We show indistinguishability of the remaining hybrids in Claims Claims 5 to 16. By triangle inequality, H y b 0 \mathrm{Hyb}_0 Hyb 0 can be distinguished from Ideal ( Sim , 1 λ ) \operatorname{Ideal}(\operatorname{Sim},1^\lambda) Ideal ( Sim , 1 λ ) with at most ( 1 / n + negl ( λ ) ) (1/n+\operatorname{negl}(\lambda)) ( 1/ n + negl ( λ )) probability for any QPT receiver.
Claim 5. H y b 1 \mathrm{Hyb}_1 Hyb 1 and H y b 2 \mathrm{Hyb}_2 Hyb 2 are identically distributed.
Proof. z T ⊥ z_{T^\perp} z T ⊥ is only used to compute the output z = Can S ⊥ ( z T ⊥ ) z=\operatorname{Can}_{S^\perp}(z_{T^\perp}) z = Can S ⊥ ( z T ⊥ ) even in the real protocol. x R x_R x R is only used to check membership in T + x R T+x_R T + x R . Since S ⊂ T S\subset T S ⊂ T , the cosets T + x R = T + x S T+x_R=T+x_S T + x R = T + x S are equal and so it is equivalent to use x S x_S x S instead.
Claim 6. H y b 2 \mathrm{Hyb}_2 Hyb 2 and H y b 3 \mathrm{Hyb}_3 Hyb 3 are identically distributed.
Proof. First, observe that x S x_S x S may be directly measured from v 1 v_1 v 1 without modifying the experiment. Then, measuring and discarding x R ← Can R ( v 1 ) x_R\leftarrow\operatorname{Can}_{R}(v_1) x R ← Can R ( v 1 ) is equivalent to inserting a random Z z ′ Z^{z'} Z z ′ where z ′ ← R ⊥ z'\leftarrow R^\perp z ′ ← R ⊥ by Lemma Lemma 11.
Claim 7. H y b 3 \mathrm{Hyb}_3 Hyb 3 and H y b 4 \mathrm{Hyb}_4 Hyb 4 are statistically close.
Proof. The marginal distribution of z ′ z' z ′ is
{ z ′ ← S ⊥ with probability ∣ S ⊥ ∣ ∣ R ⊥ ∣ ≤ 2 − λ z ′ ← F 2 d ∖ S ⊥ with probability 1 − ∣ S ⊥ ∣ ∣ R ⊥ ∣ \left\{
\begin{aligned}
z' &\leftarrow S^\perp&& \text{with probability } \frac{|S^\perp|}{|R^\perp|} \le2^{-\lambda}\\
z' &\leftarrow\mathbb{F}_2^d\setminus S^\perp&& \text{with probability } 1-\frac{|S^\perp|}{|R^\perp|}
\end{aligned}
\right. ⎩ ⎨ ⎧ z ′ z ′ ← S ⊥ ← F 2 d ∖ S ⊥ with probability ∣ R ⊥ ∣ ∣ S ⊥ ∣ ≤ 2 − λ with probability 1 − ∣ R ⊥ ∣ ∣ S ⊥ ∣ Since dim ( S ⊥ ) ≤ d − 2 λ \dim(S^\perp)\le d-2\lambda dim ( S ⊥ ) ≤ d − 2 λ , the total variation distance from uniform is
1 2 ∣ S ⊥ ∣ ∣ ∣ S ⊥ ∣ ∣ R ⊥ ∣ ∣ S ⊥ ∣ − 1 ∣ F 2 d ∣ ∣ + 1 2 ∣ F 2 d ∖ S ⊥ ∣ ∣ 1 − ∣ S ⊥ ∣ ∣ R ⊥ ∣ ∣ F 2 d ∖ S ⊥ ∣ − 1 ∣ F 2 d ∣ ∣ = ∣ S ⊥ ∣ 2 λ − 1 2 d \frac{1}{2}|S^\perp|\left|\frac{\frac{|S^\perp|}{|R^\perp|}}{|S^\perp|}-\frac{1}{|\mathbb{F}_2^d|}\right|+\frac{1}{2}|\mathbb{F}_2^d\setminus S^\perp|\left|\frac{1-\frac{|S^\perp|}{|R^\perp|}}{|\mathbb{F}_2^d\setminus S^\perp|}-\frac{1}{|\mathbb{F}_2^d|}\right|=|S^\perp|\frac{2^\lambda-1}{2^d} 2 1 ∣ S ⊥ ∣ ∣ S ⊥ ∣ ∣ R ⊥ ∣ ∣ S ⊥ ∣ − ∣ F 2 d ∣ 1 + 2 1 ∣ F 2 d ∖ S ⊥ ∣ ∣ F 2 d ∖ S ⊥ ∣ 1 − ∣ R ⊥ ∣ ∣ S ⊥ ∣ − ∣ F 2 d ∣ 1 = ∣ S ⊥ ∣ 2 d 2 λ − 1
Claim 8. H y b 4 \mathrm{Hyb}_4 Hyb 4 and H y b 5 \mathrm{Hyb}_5 Hyb 5 are statistically close.
Proof. The primary difference between the two experiments is the check during the second 2PC .
Observe that the experiments are identical whenever v 2 ∉ R ⊥ ∖ S ⊥ v_2\notin R^\perp\setminus S^\perp v 2 ∈ / R ⊥ ∖ S ⊥ , in which case they both output ⊥ \perp ⊥ , or whenever v 2 ∈ S ⊥ + z ′ v_2\in S^\perp+z' v 2 ∈ S ⊥ + z ′ , in which case they both output Can S ⊥ ( v 3 ) = z C a n ′ \operatorname{Can}_{S^\perp}(v_3)=z'_{\mathrm{Can}} Can S ⊥ ( v 3 ) = z Can ′ . Thus, it suffices to show that v 2 ∈ R ⊥ ∖ ( S ⊥ + Span ( z ′ ) ) v_2\in R^\perp\setminus(S^\perp+\operatorname{Span}(z')) v 2 ∈ R ⊥ ∖ ( S ⊥ + Span ( z ′ )) with negligible probability.
Observe that before the second 2PC , only S S S and z ′ z' z ′ are used, as part of the first 2PC . Therefore we may consider sampling R ⊥ ⊃ ( S ⊥ + Span ( z ′ ) ) R^\perp\supset(S^\perp+\operatorname{Span}(z')) R ⊥ ⊃ ( S ⊥ + Span ( z ′ )) after the adversary chooses its inputs for the second 2PC .
Thus, the probability of a divergence in the two hybrid experiments is bounded by
max v 2 Pr R ⊥ ⊃ ( S ⊥ + Span ( z ′ ) ) [ v 2 ∈ R ⊥ ∖ ( S ⊥ + Span ( z ′ ) ) ∣ S , z ′ ] \max_{v_2}\Pr_{R^\perp\supset(S^\perp+\operatorname{Span}(z'))}\left[v_2\in R^\perp\setminus(S^\perp+\operatorname{Span}(z'))\mid S,z'\right] v 2 max R ⊥ ⊃ ( S ⊥ + Span ( z ′ )) Pr [ v 2 ∈ R ⊥ ∖ ( S ⊥ + Span ( z ′ )) ∣ S , z ′ ] The probability is 0 0 0 for all v 2 ∈ ( S ⊥ + Span ( z ′ ) ) v_2\in(S^\perp+\operatorname{Span}(z')) v 2 ∈ ( S ⊥ + Span ( z ′ )) . Otherwise, the probability is identical for all v 2 ∉ ( S ⊥ + Span ( z ′ ) ) v_2\notin(S^\perp+\operatorname{Span}(z')) v 2 ∈ / ( S ⊥ + Span ( z ′ )) , using the observation that the distribution of R ⊥ R^\perp R ⊥ is invariant under all linear transformations which leave S ⊥ + Span ( z ′ ) S^\perp+\operatorname{Span}(z') S ⊥ + Span ( z ′ ) invariant, and in particular linear transformations swapping any pair v ↔ v ′ v\leftrightarrow v' v ↔ v ′ not in S ⊥ + Span ( z ′ ) S^\perp+\operatorname{Span}(z') S ⊥ + Span ( z ′ ) . Therefore this probability is
∣ R ⊥ ∖ ( S ⊥ + Span ( z ′ ) ) ∣ ∣ F 2 d ∖ ( S ⊥ + Span ( z ′ ) ) ∣ < 2 − λ + 1 . \frac{|R^\perp\setminus(S^\perp+\operatorname{Span}(z'))|}{|\mathbb{F}_2^d\setminus(S^\perp+\operatorname{Span}(z'))|}<2^{-\lambda+1}. ∣ F 2 d ∖ ( S ⊥ + Span ( z ′ )) ∣ ∣ R ⊥ ∖ ( S ⊥ + Span ( z ′ )) ∣ < 2 − λ + 1 .
Claim 9. H y b 5 \mathrm{Hyb}_5 Hyb 5 and H y b 6 \mathrm{Hyb}_6 Hyb 6 are identically distributed.
Proof. This is immediate from the equivalence of measuring then discarding x R ← Can R ( v 1 ) x_R\leftarrow\operatorname{Can}_R(v_1) x R ← Can R ( v 1 ) and inserting a random Z z ′ Z^{z'} Z z ′ where z ′ ← R ⊥ z'\leftarrow R^\perp z ′ ← R ⊥ (Lemma 11).
Claim 10. Hyb6 _6 6 and Hyb7 _7 7 are statistically close.
Proof. First assume dim ( S ) ≤ d − 2 λ \dim(S) \le d - 2\lambda dim ( S ) ≤ d − 2 λ . The marginal distribution of x ′ ′ x'' x ′′ is
{ x ′ ′ ← S with probability ∣ S ∣ ∣ T ∣ ≤ 2 − λ x ′ ′ ← F 2 d ∖ S with probability 1 − ∣ S ∣ ∣ T ∣ \begin{cases}
x'' \leftarrow S & \text{with probability } \frac{|S|}{|T|} \le2^{-\lambda}\\
x'' \leftarrow\mathbb{F}_2^d \setminus S & \text{with probability } 1-\frac{|S|}{|T|}
\end{cases} { x ′′ ← S x ′′ ← F 2 d ∖ S with probability ∣ T ∣ ∣ S ∣ ≤ 2 − λ with probability 1 − ∣ T ∣ ∣ S ∣ Since dim ( S ) ≤ d − 2 λ \dim(S) \le d - 2\lambda dim ( S ) ≤ d − 2 λ , the total variation distance from uniform is
1 2 ∣ S ∣ ∣ ∣ S ∣ ∣ T ∣ 1 ∣ S ∣ − 1 ∣ F 2 d ∣ ∣ + 1 2 ∣ F 2 d ∖ S ∣ ∣ 1 − ∣ S ∣ ∣ T ∣ ∣ F 2 d ∖ S ∣ − 1 ∣ F 2 d ∣ ∣ = ∣ S ∣ 2 λ − 1 2 d \frac{1}{2}|S|\left|\frac{|S|}{|T|}\frac{1}{|S|}-\frac{1}{|\mathbb{F}_2^d|}\right|+\frac{1}{2}|\mathbb{F}_2^d\setminus S|\left|\frac{1-\frac{|S|}{|T|}}{|\mathbb{F}_2^d\setminus S|}-\frac{1}{|\mathbb{F}_2^d|}\right|=|S|\frac{2^\lambda-1}{2^d} 2 1 ∣ S ∣ ∣ T ∣ ∣ S ∣ ∣ S ∣ 1 − ∣ F 2 d ∣ 1 + 2 1 ∣ F 2 d ∖ S ∣ ∣ F 2 d ∖ S ∣ 1 − ∣ T ∣ ∣ S ∣ − ∣ F 2 d ∣ 1 = ∣ S ∣ 2 d 2 λ − 1 Allowing dim ( S ) ≤ d − 2 λ + O ( 1 ) \dim(S) \le d-2\lambda+O(1) dim ( S ) ≤ d − 2 λ + O ( 1 ) multiplies the final bound by at most 2 O ( 1 ) 2^{O(1)} 2 O ( 1 ) , which preserves negligibility.
Claim 11. Hyb7 _7 7 and Hyb8 _8 8 are statistically close.
Proof. The primary difference between the two experiments is the check during the third 2PC .
Observe that the experiments are identical whenever v 3 ∉ ( T + x S ) ∖ ( S + x S ) v_3 \notin(T+x_S)\setminus(S+x_S) v 3 ∈ / ( T + x S ) ∖ ( S + x S ) , in which case the third 2PC outputs ⊥ \bot ⊥ , or whenever v 3 ∈ S + x ′ ′ + x S v_3 \in S+x''+x_S v 3 ∈ S + x ′′ + x S , in which case the the third 2PC outputs Can S ( v 3 ) = Can S ⊥ ( x S + x ′ ′ ) \operatorname{Can}_S(v_3)=\operatorname{Can}_{S^\perp}(x_S+x'') Can S ( v 3 ) = Can S ⊥ ( x S + x ′′ ) . Thus, it suffices to show that v 3 ∈ ( T + x S ) ∖ ( S + Span ( x ′ ′ ) + x S ) v_3 \in(T+x_S)\setminus(S+\operatorname{Span}(x'')+x_S) v 3 ∈ ( T + x S ) ∖ ( S + Span ( x ′′ ) + x S ) with negligible probability.
Observe that before the third 2PC only the following information is used:
Therefore we may consider sampling T ⊃ ( S + Span ( x ′ ′ ) ) T \supset(S+\operatorname{Span}(x'')) T ⊃ ( S + Span ( x ′′ )) after the adversary chooses its inputs for the third 2PC .
Thus, the probability of a divergence in the two hybrid experiments is bounded by
max v 3 Pr T ⊃ ( S + Span ( x ′ ′ ) ) [ ( v 3 − x S ) ∈ T ∖ ( S + Span ( x ′ ′ ) ) ∣ S , x ′ ′ , x S ] \max_{v_3}\Pr_{T\supset(S+\operatorname{Span}(x''))}\left[(v_3-x_S)\in T\setminus(S+\operatorname{Span}(x''))\mid S,x'',x_S\right] v 3 max T ⊃ ( S + Span ( x ′′ )) Pr [ ( v 3 − x S ) ∈ T ∖ ( S + Span ( x ′′ )) ∣ S , x ′′ , x S ] The probability is 0 for all v 3 ∈ ( S + Span ( x ′ ′ ) ) v_3 \in(S+\operatorname{Span}(x'')) v 3 ∈ ( S + Span ( x ′′ )) . Otherwise, the probability is identical for all v 3 ∉ ( S + Span ( x ′ ′ ) ) v_3 \notin(S+\operatorname{Span}(x'')) v 3 ∈ / ( S + Span ( x ′′ )) , using a similar argument to the proof of Claim 8. Therefore this probability is
∣ T ∖ ( S + Span ( x ′ ′ ) ) ∣ ∣ F 2 d ∖ ( S + Span ( x ′ ′ ) ) ∣ < 2 − λ + 1 . \frac{|T\setminus(S+\operatorname{Span}(x''))|}{|\mathbb{F}_2^d\setminus(S+\operatorname{Span}(x''))|}<2^{-\lambda+1}. ∣ F 2 d ∖ ( S + Span ( x ′′ )) ∣ ∣ T ∖ ( S + Span ( x ′′ )) ∣ < 2 − λ + 1 .
Claim 12. Hyb8 _8 8 and Hyb9 _9 9 are identically distributed.
Proof. The uniform distribution is invariant under linear shifts.
Claim 13. Hyb9 _9 9 and Hyb10 _{10} 10 are identically distributed.
Proof. Consider the hybrid experiment Hyb9 ′ '_9 9 ′ where at the end of the first 2PC , the simulator applies Z z ′ X x S Z z ′ Z^{z'}X^{x_S}Z^{z'} Z z ′ X x S Z z ′ to register C C C . This is equivalent since register C C C is disjoint from the adversary’s view.
The two hybrids differ only in the first 2PC . It suffices to show that the following two operations are equivalent on the residual state.
Hyb9 _9 9 : Apply Z V 1 z ′ ⊗ ( Z z ′ X x S Z z ′ ) C Z^{z'}_{V_1} \otimes(Z^{z'}X^{x_S}Z^{z'})_C Z V 1 z ′ ⊗ ( Z z ′ X x S Z z ′ ) C to registers V 1 ⊗ C V_1 \otimes C V 1 ⊗ C .
Hyb10 _{10} 10 : Apply CX V 1 → C \operatorname{CX}_{V_1\to C} CX V 1 → C to registers V 1 ⊗ C V_1 \otimes C V 1 ⊗ C .
After the measurement, the state on registers V 1 ⊗ C V_1 \otimes C V 1 ⊗ C is supported on
∣ s + x S ⟩ V 1 ⊗ X x ′ Z z ′ ∣ S ⟩ C \lvert s+x_S\rangle_{V_1}\otimes X^{x'}Z^{z'}\lvert S\rangle_C ∣ s + x S ⟩ V 1 ⊗ X x ′ Z z ′ ∣ S ⟩ C
for s ∈ S s\in S s ∈ S . By linearity it suffices to show equivalence on such states. We may write CX \operatorname{CX} CX as
CX = ∑ w Z z ′ ∣ w ⟩ ⟨ w ∣ ⊗ Z z ′ X w Z z ′ \operatorname{CX}=\sum_w Z^{z'}\lvert w\rangle\langle w\rvert\otimes Z^{z'}X^wZ^{z'} CX = w ∑ Z z ′ ∣ w ⟩ ⟨ w ∣ ⊗ Z z ′ X w Z z ′
for any z ′ z' z ′ . Incorporating the existing X x ′ Z z ′ X^{x'}Z^{z'} X x ′ Z z ′ and observing that X s X^s X s commutes with Z z ′ X x ′ Z z ′ Z^{z'}X^{x'}Z^{z'} Z z ′ X x ′ Z z ′ , the state in Hyb10 _{10} 10 becomes
( Z z ′ ⊗ Z z ′ X x S Z z ′ ) ( ∣ s + x S ⟩ V 1 ⊗ X x ′ Z z ′ ( X s ∣ S ⟩ C ) ) \left(Z^{z'}\otimes Z^{z'}X^{x_S}Z^{z'}\right)\left(\lvert s+x_S\rangle_{V_1}\otimes X^{x'}Z^{z'}\left(X^s\lvert S\rangle_C\right)\right) ( Z z ′ ⊗ Z z ′ X x S Z z ′ ) ( ∣ s + x S ⟩ V 1 ⊗ X x ′ Z z ′ ( X s ∣ S ⟩ C ) )
Finally, X s ∣ S ⟩ = ∣ S ⟩ X^s\lvert S\rangle=\lvert S\rangle X s ∣ S ⟩ = ∣ S ⟩ since s ∈ S s\in S s ∈ S . Therefore the net effect of Hyb10 _{10} 10 is to apply Z z ′ ⊗ Z z ′ X x S Z z ′ Z^{z'}\otimes Z^{z'}X^{x_S}Z^{z'} Z z ′ ⊗ Z z ′ X x S Z z ′ , the same as Hyb9 ′ '_9 9 ′ .
Claim 14. Hyb10 _{10} 10 and Hyb11 _{11} 11 are identically distributed.
Proof. Consider the hybrid experiment Hyb10 ′ '_{10} 10 ′ where at the end of the second 2PC , the simulator applies X x ′ + x S Z z ′ X x ′ + x S X^{x'+x_S}Z^{z'}X^{x'+x_S} X x ′ + x S Z z ′ X x ′ + x S to register C C C . This is equivalent since register C C C is disjoint from the adversary’s view after the first 2PC .
The two hybrids differ only in the second 2PC . If the v 2 ∈ S ⊥ + z ′ v_2\in S^\perp+z' v 2 ∈ S ⊥ + z ′ check rejects, then the two hybrids are identical. Otherwise, it suffices to show that the following two operations are equivalent on the residual state.
Hyb10 _{10} 10 : Apply Z V 2 z ′ + x S ⊗ ( X x ′ + x S Z z ′ X x ′ + x S ) C Z^{z'+x_S}_{V_2}\otimes(X^{x'+x_S}Z^{z'}X^{x'+x_S})_C Z V 2 z ′ + x S ⊗ ( X x ′ + x S Z z ′ X x ′ + x S ) C to registers V 2 ⊗ C V_2\otimes C V 2 ⊗ C .
Hyb11 _{11} 11 : Apply CZ V 2 → C \operatorname{CZ}_{V_2\to C} CZ V 2 → C to registers V 2 ⊗ C V_2\otimes C V 2 ⊗ C .
If the check passes, then the state on registers V 2 ⊗ C V_2 \otimes C V 2 ⊗ C is supported on
∣ s + z ′ ⟩ V 2 ⊗ X x ′ + x S Z z ′ ∣ S ⟩ C |s+z'\rangle_{V_2} \otimes X^{x'+x_S}Z^{z'}|S\rangle_C ∣ s + z ′ ⟩ V 2 ⊗ X x ′ + x S Z z ′ ∣ S ⟩ C
for s ∈ S ⊥ s \in S^\perp s ∈ S ⊥ . By linearity it suffices to show equivalence on such states. We may write CZ \operatorname{CZ} CZ as
CZ = ∑ w Z x ′ ′ ∣ w ⟩ ⟨ w ∣ ⊗ X x ′ ′ Z w X x ′ ′ \operatorname{CZ}=\sum_w Z^{x''}|w\rangle\langle w|\otimes X^{x''}Z^wX^{x''} CZ = w ∑ Z x ′′ ∣ w ⟩ ⟨ w ∣ ⊗ X x ′′ Z w X x ′′
for any x ′ ′ x'' x ′′ , and in particular x ′ ′ = x ′ + x S x''=x'+x_S x ′′ = x ′ + x S . Incorporating the existing X x ′ + x S Z z ′ X^{x'+x_S}Z^{z'} X x ′ + x S Z z ′ and observing that Z s Z^s Z s commutes with X x ′ + x S Z z ′ X x ′ + x S X^{x'+x_S}Z^{z'}X^{x'+x_S} X x ′ + x S Z z ′ X x ′ + x S , the state in H y b 10 \mathrm{Hyb}_{10} Hyb 10 becomes
( Z x ′ + x S ⊗ X x ′ + x S Z z ′ X x ′ + x S ) ( ∣ s + z ′ ⟩ V 2 ⊗ X x ′ + x S Z z ′ ( Z s ∣ S ⟩ C ) ) \left(Z^{x'+x_S}\otimes X^{x'+x_S}Z^{z'}X^{x'+x_S}\right)\left(|s+z'\rangle_{V_2}\otimes X^{x'+x_S}Z^{z'}\left(Z^s|S\rangle_C\right)\right) ( Z x ′ + x S ⊗ X x ′ + x S Z z ′ X x ′ + x S ) ( ∣ s + z ′ ⟩ V 2 ⊗ X x ′ + x S Z z ′ ( Z s ∣ S ⟩ C ) )
Finally, Z s ∣ S ⟩ = ∣ S ⟩ Z^s|S\rangle=|S\rangle Z s ∣ S ⟩ = ∣ S ⟩ since s ∈ S ⊥ s\in S^\perp s ∈ S ⊥ . Therefore the net effect of H y b 11 \mathrm{Hyb}_{11} Hyb 11 is to apply Z x ′ + x S ⊗ X x ′ + x S Z z ′ X x ′ + x S Z^{x'+x_S}\otimes X^{x'+x_S}Z^{z'}X^{x'+x_S} Z x ′ + x S ⊗ X x ′ + x S Z z ′ X x ′ + x S , the same as H y b 10 ′ \mathrm{Hyb}'_{10} Hyb 10 ′ .
Claim 15. H y b 11 \mathrm{Hyb}_{11} Hyb 11 and H y b 12 \mathrm{Hyb}_{12} Hyb 12 are identically distributed.
Proof. Consider the hybrid experiment H y b 11 ′ \mathrm{Hyb}'_{11} Hyb 11 ′ where at the end of the second 2PC , the simulator applies X x ′ X^{x'} X x ′ to register C C C . This is equivalent since register C C C is disjoint from the adversary’s view after the second 2PC .
The two hybrids differ only in the third 2PC . If the v 3 ∈ S + x ′ v_3\in S+x' v 3 ∈ S + x ′ check rejects, then the two hybrids are identical. Otherwise, it suffices to show that the following two operations are equivalent on the residual state.
H y b 11 \mathrm{Hyb}_{11} Hyb 11 : Apply I V 3 ⊗ X x C ′ I_{V_3}\otimes X^{x'_C} I V 3 ⊗ X x C ′ to registers V 3 ⊗ C V_3\otimes C V 3 ⊗ C .
H y b 12 \mathrm{Hyb}_{12} Hyb 12 : Apply CX V 3 → C \operatorname{CX}_{V_3\to C} CX V 3 → C to registers V 3 ⊗ C V_3\otimes C V 3 ⊗ C .
If the check passes, then V 3 V_3 V 3 is supported on ∣ s + x ′ ⟩ |s+x'\rangle ∣ s + x ′ ⟩ where s ∈ S s\in S s ∈ S . Thus, the effect of the CX V 3 → C \operatorname{CX}_{V_3\to C} CX V 3 → C in H y b 12 \mathrm{Hyb}_{12} Hyb 12 is to apply X s + x ′ X^{s+x'} X s + x ′ to register C C C . Note that at the start of the third 2PC , register C C C contains X x S + x ′ ∣ S ⟩ X^{x_S+x'}|S\rangle X x S + x ′ ∣ S ⟩ . Commuting X s X^s X s through and observing that X s ∣ S ⟩ = ∣ S ⟩ X^s|S\rangle=|S\rangle X s ∣ S ⟩ = ∣ S ⟩ for all s ∈ S s\in S s ∈ S , the net effect of H y b 12 \mathrm{Hyb}_{12} Hyb 12 is to apply X x ′ X^{x'} X x ′ to register C C C , the same as H y b 11 \mathrm{Hyb}_{11} Hyb 11 .
Claim 16. H y b 12 \mathrm{Hyb}_{12} Hyb 12 and Ideal ( Sim , 1 λ ) \operatorname{Ideal}(\operatorname{Sim},1^\lambda) Ideal ( Sim , 1 λ ) are identically distributed.
Proof. First, observe that the outputs of the three 2PCs are never used. The classical party’s output is guaranteed to be ( x C a n ′ , z C a n ′ ) (x'_{\mathrm{Can}},z'_{\mathrm{Can}}) ( x Can ′ , z Can ′ ) or an abort, and x S x_S x S is unused. Therefore the output steps can be omitted.
Second, we show that the measurement of x S x_S x S can be commuted to after the end of the third 2PC , at which point C C C is discarded and therefore it does not matter whether x S x_S x S was measured from it.
To commute past the first 2PC : the x S x_S x S measurement commutes with the CX V 1 → C \operatorname{CX}_{V_1\to C} CX V 1 → C operation since both are diagonal in the computational basis on register V 1 V_1 V 1 . After the CX \operatorname{CX} CX operation, registers V 1 V_1 V 1 and C C C are supported on ∣ s + x S ⟩ V ⊗ ∣ S + x ′ + x S ⟩ C |s+x_S\rangle_V\otimes|S+x'+x_S\rangle_C ∣ s + x S ⟩ V ⊗ ∣ S + x ′ + x S ⟩ C for s ∈ S s\in S s ∈ S , so it is
equivalent to measure x S ← Can S ( C − x ′ ) x_{S} \leftarrow\operatorname{Can}_{S}(C-x^{\prime}) x S ← Can S ( C − x ′ ) on register C C C instead of measuring it from register V 1 V_{1} V 1 .
To commute past the second 2PC : the x S ← Can S ( C − x ′ ) x_{S} \leftarrow\operatorname{Can}_{S}(C-x^{\prime}) x S ← Can S ( C − x ′ ) measurement commutes with the adversary’s operations in between the first and second 2PC ideal functionalities since it is on a disjoint register. Furthermore, it commutes with the CZ V 2 → C \operatorname{CZ}_{V_{2}\to C} CZ V 2 → C operation since both are diagonal in the computational basis.
To commute past the third 2PC : the x S ← Can S ( C − x ′ ) x_{S} \leftarrow\operatorname{Can}_{S}(C-x^{\prime}) x S ← Can S ( C − x ′ ) measurement commutes with the adversary’s operations in between the first and second 2PC ideal functionalities since it is on a disjoint register. Furthermore, the check forces V 3 V_{3} V 3 to be entirely supported on S + x ′ S+x^{\prime} S + x ′ . Therefore the state before the CX V 3 → C \operatorname{CX}_{V_{3}\to C} CX V 3 → C is supported on ∣ s + x ′ ⟩ V 3 ⊗ ∣ S + x ′ + x S ⟩ C \lvert s+x^{\prime}\rangle_{V_{3}}\otimes\lvert S+x^{\prime}+x_{S}\rangle_{C} ∣ s + x ′ ⟩ V 3 ⊗ ∣ S + x ′ + x S ⟩ C . For such states, afterwards register C C C is supported on ∣ S + x S ⟩ \lvert S+x_{S}\rangle ∣ S + x S ⟩ and so x S ← Can S ( C ) x_{S} \leftarrow\operatorname{Can}_{S}(C) x S ← Can S ( C ) may be directly measured.
Classical Commitments to Quantum States with Ideal Binding
In this section, we show how to classically commit to a quantum state with a new, strong notion of binding. We call this binding “ideal binding” because it is formalized via the real/ideal paradigm. In the “real” binding game, an adversarial committer commits, then opens their commitment in “one shot”. Ideally, the initial commitment defines a single quantum state ρ \rho ρ and the adversary should only be able to open to measurements of ρ \rho ρ . One-shot ideal binding formalizes this by requiring that the real binding game should be indistinguishable from the ideal scenario (see § 5.3.2 ).
We also formulate and achieve a stronger notion of ideal binding which we call continual ideal binding. Whereas one-shot binding considers an adversary who commits then gives a single opening, continual binding allows the adversary to see the results of opening their state many times. This necessarily allows them to change the committed state by measuring it. The ideal world for continual binding requires that after each time the adversary does so, the adversary remains bound to the post-measurement state (see § 5.4 ).
We achieve a single protocol which is ϵ \epsilon ϵ -indistinguishable from the ideal continual binding world for every ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . Since the protocol description is independent of ϵ \epsilon ϵ , this is sufficient for our later applications.29
Theorem 13. *Assuming the existence of ϵ \epsilon ϵ -secure (respectively, secure) state-preserving 2PC for classical linear functions with post-processed abort (§ 4.1 ) there exists a classical commitment scheme for quantum states with state recovery (Definition 17) and ϵ \epsilon ϵ -secure (respectively, secure) continual ideal binding (Definition 20) for the set of ZX-and-linear
measurements (§ 3.5 ). Moreover, its state recovery is compatible with continual binding (Definition 22).
This theorem, together with Theorem 8, immediately yields the following corollary.
Corollary 6. There exists a classical commitment scheme for quantum states with binding-compatible state recovery and ε \varepsilon ε -secure continual ideal binding for the set of ZX-and-linear measurements { M [ H θ L ] } θ ∈ { 0 , 1 } n , L \{M[H^{\theta}L]\}_{\theta\in\{0,1\}^{n},L} { M [ H θ L ] } θ ∈ { 0 , 1 } n , L assuming the post-quantum hardness of LWE.
Authentication versus Commitment. A similar notion of binding was already shown by [26 ] to hold for [4 ] ’s coset-based quantum authentication scheme. Conceptually, commitment is quite similar to authentication – the key difference is that in a commitment, the adversary gets to “authenticate” their own state instead of a trusted party. Showing binding for commitments requires additional work since the adversary may deviate from the honest authentication procedure.
Our construction shows how to use classical interaction to force a dishonest committer to correctly authenticate any state of the committer’s choice according to [4 ] ’s authentication scheme, without learning the authentication key. Thus, we inherit essentially all properties of their scheme, including continual binding and the ability to open to any “ZX-and-linear” measurement. Such measurements are defined by a change of basis H θ L H^{\theta}L H θ L , where L L L is a series of CNOT gates, followed by a computational basis measurement (see § 3.5 ).
Moreover, we show the classical receiver can later help the quantum committer to recover the committed state. This property generalizes [27 ] ’s notion of state recovery beyond commitments to classical messages. The recovery protocol composes safely with continual binding, so that the sender can recover a partially measured state.
Definition
Syntax. A classical commitment scheme to quantum states with classical communication, with respect to a family of projective measurements M [ U ] = { M [ U ] } U ∈ U \mathcal{M}[U]=\{M[U]\}_{U\in\mathcal{U}} M [ U ] = { M [ U ] } U ∈ U , consists of the following algorithms. Here, M [ U ] M[U] M [ U ] denotes the logical measurement implemented by applying U U U and then measuring in the computational basis.
Com ⟨ S ( S i n ) , R ⟩ ( 1 λ , 1 n ) → ( R o p , c o m ) \operatorname{Com}\langle S(\mathcal{S}_{\mathrm{in}}),R\rangle(1^\lambda,1^n)\to(\mathcal{R}_{\mathrm{op}},\mathrm{com}) Com ⟨ S ( S in ) , R ⟩ ( 1 λ , 1 n ) → ( R op , com ) is an interactive protocol between a QPT sender S S S and a classical PPT receiver R R R . S S S inputs a state on register S i n \mathcal{S}_{\mathrm{in}} S in , and both parties input the security parameter 1 λ 1^\lambda 1 λ along with the number n n n of qubits to be committed to. At the end of the protocol, S S S outputs an opening register R o p \mathcal{R}_{\mathrm{op}} R op and R R R outputs a classical commitment key c o m \mathrm{com} com .
Eval ( U ) → U ~ \operatorname{Eval}(U)\to\widetilde{U} Eval ( U ) → U is a classical algorithm that takes as input a description of a unitary U ∈ U U\in\mathcal{U} U ∈ U , then outputs a description of an efficient unitary U ~ \widetilde{U} U which operates on register R o p \mathcal{R}_{\mathrm{op}} R op . U ~ \widetilde{U} U acts as the homomorphic implementation of U U U on committed states.
A classical opening string o p U \mathrm{op}_U op U for the measurement M [ U ] M[U] M [ U ] may be obtained by applying U ~ \widetilde{U} U to R o p \mathcal{R}_{\mathrm{op}} R op , then measuring the state in the computational basis.
KeyEval ( c o m , U ) → c o m U \operatorname{KeyEval}(\mathrm{com}, U) \to\mathrm{com}_U KeyEval ( com , U ) → com U is a classical algorithm that maps a commitment key c o m \mathrm{com} com and a unitary U ∈ U U \in\mathcal{U} U ∈ U to an evaluation key c o m U \mathrm{com}_U com U .
We emphasize that c o m U \mathrm{com}_U com U does not necessarily belong to the same keyspace as c o m \mathrm{com} com .
Dec c o m U ( o p ) → y / ⊥ \operatorname{Dec}_{\mathrm{com}_U}(\mathrm{op}) \to y/\perp Dec com U ( op ) → y / ⊥ is a PPT decoding algorithm that, given a classical opening string o p \mathrm{op} op , returns either its decoded outcome y y y for the measurement M [ U ] M[U] M [ U ] or ⊥ \perp ⊥ . It is parameterized by an evaluation key c o m U \mathrm{com}_U com U .
In addition, a classical commitment to a quantum state may be equipped with a Recover algorithm that allows it to recover the committed state [27 ] .
Recover ⟨ S ( R o p ) , R ( c o m ) ⟩ → S o u t \operatorname{Recover}\langle S(\mathcal{R}_{\mathrm{op}}),R(\mathrm{com})\rangle\to S_{\mathrm{out}} Recover ⟨ S ( R op ) , R ( com )⟩ → S out is an interactive protocol between a QPT committer S S S and a classical PPT receiver R R R . S S S inputs its opening register R o p \mathcal{R}_{\mathrm{op}} R op and R R R inputs the commitment key c o m \mathrm{com} com . At the end of the protocol, S S S outputs a register S o u t S_{\mathrm{out}} S out containing the recovered state.
A functional commitment must satisfy correctness (Definition 16). Additionally, it must satisfy either one-shot ideal binding (Definition 19) or continual ideal binding (Definition 20). If equipped with a Recover protocol, it must also satisfy recovery correctness.
Definition 16 (Commitment Correctness). For any U ∈ U U \in\mathcal{U} U ∈ U and c o m \mathrm{com} com in the support of C o m \mathrm{Com} Com , let U ~ ← Eval ( U ) \widetilde{U} \leftarrow\operatorname{Eval}(U) U ← Eval ( U ) and c o m U ← KeyEval ( c o m , U ) \mathrm{com}_U \leftarrow\operatorname{KeyEval}(\mathrm{com}, U) com U ← KeyEval ( com , U ) . A commitment scheme is correct if for every U ∈ U U \in\mathcal{U} U ∈ U , every n , λ ∈ N n,\lambda\in\mathbb{N} n , λ ∈ N , and every n n n -qubit state in register S i n S_{\mathrm{in}} S in ,
{ ( R o p , c o m ) ← Com ⟨ S ( S i n ) , R ⟩ ( 1 λ , 1 n ) ( y , C ) ← M [ Dec c o m U , U ~ ] ( R o p ) Output ( y , C , c o m ) = { ( y , C ) ← M [ U ] ( S i n ) ( R o p , c o m ) ← Com ⟨ S ( C ) , R ⟩ ( 1 λ , 1 n ) Output ( y , R o p , c o m ) \left\{
\begin{aligned}
(\mathcal{R}_{\mathrm{op}},\mathrm{com}) &\leftarrow\operatorname{Com}\langle S(S_{\mathrm{in}}),R\rangle(1^\lambda,1^n) \\
(y,C) &\leftarrow M[\operatorname{Dec}_{\mathrm{com}_U},\widetilde{U}](\mathcal{R}_{\mathrm{op}}) \\
\operatorname{Output}(y,C,\mathrm{com})
\end{aligned}
\right.
=
\left\{
\begin{aligned}
(y,C) &\leftarrow M[U](S_{\mathrm{in}}) \\
(\mathcal{R}_{\mathrm{op}},\mathrm{com}) &\leftarrow\operatorname{Com}\langle S(C),R\rangle(1^\lambda,1^n) \\
\operatorname{Output}(y,\mathcal{R}_{\mathrm{op}},\mathrm{com})
\end{aligned}
\right. ⎩ ⎨ ⎧ ( R op , com ) ( y , C ) Output ( y , C , com ) ← Com ⟨ S ( S in ) , R ⟩ ( 1 λ , 1 n ) ← M [ Dec com U , U ] ( R op ) = ⎩ ⎨ ⎧ ( y , C ) ( R op , com ) Output ( y , R op , com ) ← M [ U ] ( S in ) ← Com ⟨ S ( C ) , R ⟩ ( 1 λ , 1 n ) In other words, committing then homomorphically measuring is equivalent to first measuring and then committing.
Definition 17 (Recovery Correctness). An interactive commitment to quantum states
( C o m , Eval , KeyEval , Dec , Ver , Recover ) (\mathrm{Com},\operatorname{Eval},\operatorname{KeyEval},\operatorname{Dec},\operatorname{Ver},\operatorname{Recover}) ( Com , Eval , KeyEval , Dec , Ver , Recover ) has state recovery if the following holds. Consider the following quantum channel S R - E x p λ , n \mathrm{SR\text{-}Exp}_{\lambda,n} SR - Exp λ , n , parameterized by the security parameter λ \lambda λ and a number of qubits n n n .
Input: An n n n -qubit state in register A \mathcal{A} A .
Compute ( R o p , c o m ) ← Com ⟨ S ( A ) , R ⟩ ( 1 λ , n ) (R_{\mathrm{op}},\mathrm{com}) \leftarrow\operatorname{Com}\langle\mathcal{S}(\mathcal{A}),R\rangle(1^\lambda,n) ( R op , com ) ← Com ⟨ S ( A ) , R ⟩ ( 1 λ , n ) , a commitment to the contents of register A \mathcal{A} A .
Compute A ′ ← Recover ⟨ S ( R o p ) , R ( c o m ) ⟩ ( 1 λ , n ) \mathcal{A}' \leftarrow\operatorname{Recover}\langle\mathcal{S}(R_{\mathrm{op}}),R(\mathrm{com})\rangle(1^\lambda,n) A ′ ← Recover ⟨ S ( R op ) , R ( com )⟩ ( 1 λ , n ) , the recovered state.
Output: The contents of register A ′ \mathcal{A}' A ′ .
Recover is correct if for all λ , n ∈ N \lambda,n \in\mathbb{N} λ , n ∈ N and all states ∣ ψ ⟩ A , B \lvert\psi\rangle_{\mathcal{A},B} ∣ ψ ⟩ A , B contained in an n n n -qubit register A \mathcal{A} A and arbitrary register B B B ,
1 2 ∥ ( I A ⊗ I B ) ( ∣ ψ ⟩ A , B ) − ( S R - E x p λ , n ⊗ I B ) ( ∣ ψ ⟩ A , B ) ∥ 1 ≤ negl ( λ ) \frac{1}{2}\left\lVert(I_{\mathcal{A}}\otimes I_B)(\lvert\psi\rangle_{\mathcal{A},B})-(\mathrm{SR\text{-}Exp}_{\lambda,n}\otimes I_B)(\lvert\psi\rangle_{\mathcal{A},B})\right\rVert_1\leq\operatorname{negl}(\lambda) 2 1 ( I A ⊗ I B ) (∣ ψ ⟩ A , B ) − ( SR - Exp λ , n ⊗ I B ) (∣ ψ ⟩ A , B ) 1 ≤ negl ( λ )
In other words, the diamond distance between the identity channel I A ⊗ I B I_{\mathcal{A}}\otimes I_B I A ⊗ I B and the commit-and-recover channel S R - E x p λ , n ⊗ I B \mathrm{SR\text{-}Exp}_{\lambda,n}\otimes I_B SR - Exp λ , n ⊗ I B is negligible. As a more granular definition, we say the commitment has ( 1 − δ ) (1-\delta) ( 1 − δ ) -state recovery if the distance is at most δ \delta δ .
It is also useful to define partial recovery where the input register A \mathcal{A} A is divided into A = ( A 1 , A 2 ) \mathcal{A}=(\mathcal{A}_1,\mathcal{A}_2) A = ( A 1 , A 2 ) and only A 1 \mathcal{A}_1 A 1 is recovered. In this case, we require the same distance bound when the identity channel first traces out A 2 \mathcal{A}_2 A 2 . We denote the experiment where Recover only recovers A 1 \mathcal{A}_1 A 1 as S R - E x p λ , n A 1 \mathrm{SR\text{-}Exp}^{\mathcal{A}_1}_{\lambda,n} SR - Exp λ , n A 1 .
Definition 18 (Partial Recovery). An interactive commitment to quantum states satisfies partial recovery of register A 1 \mathcal{A}_1 A 1 if for all states ∣ ψ ⟩ A , B \lvert\psi\rangle_{\mathcal{A},B} ∣ ψ ⟩ A , B where A = ( A 1 , A 2 ) \mathcal{A}=(\mathcal{A}_1,\mathcal{A}_2) A = ( A 1 , A 2 ) ,
1 2 ∥ ( I A ⊗ I B ) Tr A 2 [ ∣ ψ ⟩ A , B ] − ( S R - E x p λ , n A 1 ⊗ I B ) ( ∣ ψ ⟩ A , B ) ∥ 1 ≤ negl ( λ ) \frac{1}{2}\left\lVert(I_{\mathcal{A}}\otimes I_B)\operatorname{Tr}_{\mathcal{A}_2}[\lvert\psi\rangle_{\mathcal{A},B}]-(\mathrm{SR\text{-}Exp}^{\mathcal{A}_1}_{\lambda,n}\otimes I_B)(\lvert\psi\rangle_{\mathcal{A},B})\right\rVert_1\leq\operatorname{negl}(\lambda) 2 1 ( I A ⊗ I B ) Tr A 2 [∣ ψ ⟩ A , B ] − ( SR - Exp λ , n A 1 ⊗ I B ) (∣ ψ ⟩ A , B ) 1 ≤ negl ( λ )
Typically a commitment necessarily must satisfy hiding as well. We omit this property since 1) we do not need it for our applications and 2) it can be generically added by encrypting the state with a one-time pad X x Z z X^xZ^z X x Z z before committing, then separately committing to the classical keys ( x , z ) (x,z) ( x , z ) .
Binding. We define two notions of binding. The first covers the simplest (real world) setting of a commitment: the adversarial receiver commits, then opens their commitment in “one-shot.” After the adversary commits, there is a well-defined (if potentially entangled) state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ which is committed to. Furthermore, any valid opening ( U , o p ) (U,\mathrm{op}) ( U , op ) which the adversary gives in the real world should match the result of directly measuring ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ using M [ U ] M[U] M [ U ] in the ideal world. We formalize this notion in § 5.3.2 .
Second, we define a notion of binding for a more strenuous setting wherein an adversarial committer gains query access to a set of evaluation keys { c o m U i } \{\mathrm{com}_{U_i}\} { com U i } . Using these keys, it may decode certain measurements on the committed state. In fact, correctness necessarily permits the adversary to modify the committed state by measuring it. Despite this, there is a well-defined evolution of the committed state from the original state ∣ ψ 0 ⟩ \lvert\psi_0\rangle ∣ ψ 0 ⟩ to some modified state ∣ ψ t ⟩ \lvert\psi_t\rangle ∣ ψ t ⟩ which is the result of making t t t sequential measurements on the state. Thus, we may ask that the next valid opening ( U , o p ) (U,\mathrm{op}) ( U , op ) which the adversary gives in the real world matches the result of directly measuring ∣ ψ t ⟩ \lvert\psi_t\rangle ∣ ψ t ⟩ . We formalize this notion in § 5.4 .
One-Shot Ideal Binding
We formalize binding via the real/ideal paradigm. Intuitively, the definition compares the value that an adversarial committer is able to open to after playing a real execution of the commitment protocol to an idealized model where the adversary is forced to explicitly declare their state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ and a measurement is performed on ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ by a trusted party. For binding to hold, the adversary’s real opening must match the result of directly measuring their declared state ρ \rho ρ .
Real Experiment. In the real experiment Real ( A , 1 n , 1 λ , U ) \operatorname{Real}(\mathcal{A},1^n,1^\lambda,U) Real ( A , 1 n , 1 λ , U ) , an adversarial QPT committer A = ( A 1 , A 2 ) \mathcal{A}=(\mathcal{A}_1,\mathcal{A}_2) A = ( A 1 , A 2 ) interacts with an honest classical receiver as follows.
Run the commitment protocol ( R A , c o m ) ← Com ⟨ A 1 , R ⟩ ( 1 n , 1 λ ) (R_{\mathcal{A}},\mathsf{com})\leftarrow\operatorname{Com}\langle\mathcal{A}_1,R\rangle(1^n,1^\lambda) ( R A , com ) ← Com ⟨ A 1 , R ⟩ ( 1 n , 1 λ ) .
( o p , R A ′ ) ← A 2 ( R A ) (\mathsf{op},R'_{\mathcal{A}})\leftarrow\mathcal{A}_2(R_{\mathcal{A}}) ( op , R A ′ ) ← A 2 ( R A ) outputs an opening string o p \mathsf{op} op and an arbitrary state in register R A ′ R'_{\mathcal{A}} R A ′ .
Compute c o m U ← KeyEval ( c o m , U ) \mathsf{com}_U\leftarrow\operatorname{KeyEval}(\mathsf{com},U) com U ← KeyEval ( com , U ) and y ← Dec c o m U ( o p ) y\leftarrow\operatorname{Dec}_{\mathsf{com}_U}(\mathsf{op}) y ← Dec com U ( op ) .
The experiment outputs ( y , R A ′ ) (y,R'_{\mathcal{A}}) ( y , R A ′ ) .
Ideal Experiment. In the ideal experiment, the adversarial sender and classical receiver directly interact with a trusted party implementing the ideal functionality of a commitment. The ideal functionality I F \mathsf{IF} IF works as follows:
Commitment. I F \mathsf{IF} IF receives from the sender a register V \mathcal{V} V containing the state to be committed to.
Opening. I F \mathsf{IF} IF receives a bit b b b denoting whether the sender wishes to open its commitment and a choice of unitary U ∈ U n U\in\mathcal{U}_n U ∈ U n . If b = 0 b=0 b = 0 , it outputs ⊥ \perp ⊥ . Otherwise, it measures register V \mathcal{V} V using M [ U ] M[U] M [ U ] and outputs the result y y y to the receiver.
The ideal experiment Ideal ( B , 1 n , 1 λ , U ) \operatorname{Ideal}(\mathcal{B},1^n,1^\lambda,U) Ideal ( B , 1 n , 1 λ , U ) is played by an idealized adversary B = ( B 1 , B 2 ) \mathcal{B}=(\mathcal{B}_1,\mathcal{B}_2) B = ( B 1 , B 2 ) as follows.
Commitment. ( V , R A ) ← B 1 (\mathcal{V},R_{\mathcal{A}})\leftarrow\mathcal{B}_1 ( V , R A ) ← B 1 outputs a register V \mathcal{V} V containing the state they wish to commit to and an internal register R A R_{\mathcal{A}} R A . It sends V \mathcal{V} V to the commitment ideal functionality I F \mathsf{IF} IF .
Optional Abort. ( b , R A ′ ) ← B 2 ( R A ) (b,R'_{\mathcal{A}})\leftarrow\mathcal{B}_2(R_{\mathcal{A}}) ( b , R A ′ ) ← B 2 ( R A ) chooses a bit b b b denoting whether it wishes to open the commitment or not, along with an arbitrary state in register R A ′ R'_{\mathcal{A}} R A ′ .
Opening. y ← I F ( b , U ) y\leftarrow\mathsf{IF}(b,U) y ← IF ( b , U ) is computed by the commitment ideal functionality.
The experiment outputs ( y , R A ′ ) (y,R'_{\mathcal{A}}) ( y , R A ′ ) .
Definition 19 (One-Shot Ideal Binding). A commitment scheme ( C o m , E v a l , K e y E v a l , D e c , V e r ) (\mathrm{Com},\mathrm{Eval},\mathrm{KeyEval},\mathrm{Dec},\mathrm{Ver}) ( Com , Eval , KeyEval , Dec , Ver ) satisfies one-shot ideal binding for the family of measurements M \mathcal{M} M if there exists a QPT algorithm S i m = ( S i m 1 , S i m 2 ) \mathrm{Sim}=(\mathrm{Sim}_1,\mathrm{Sim}_2) Sim = ( Sim 1 , Sim 2 ) such that for every n , λ ∈ N n,\lambda\in\mathbb{N} n , λ ∈ N , every unitary U ∈ U n U\in\mathcal{U}_n U ∈ U n , and every QPT adversary A = ( A 1 , A 2 ) \mathcal{A}=(\mathcal{A}_1,\mathcal{A}_2) A = ( A 1 , A 2 ) , the real and ideal experiments are computationally indistinguishable:
{ ( y , R A ′ ) ← R e a l ( A , 1 n , 1 λ , U ) } ≈ c { ( y , R A ′ ) ← I d e a l ( S i m ( A ) , 1 n , 1 λ , U ) } \{(y,\mathcal{R}'_{\mathcal{A}})\leftarrow\mathrm{Real}(\mathcal{A},1^n,1^\lambda,U)\}\approx_c\{(y,\mathcal{R}'_{\mathcal{A}})\leftarrow\mathrm{Ideal}(\mathrm{Sim}(\mathcal{A}),1^n,1^\lambda,U)\} {( y , R A ′ ) ← Real ( A , 1 n , 1 λ , U )} ≈ c {( y , R A ′ ) ← Ideal ( Sim ( A ) , 1 n , 1 λ , U )} We omit the definition of ϵ \epsilon ϵ -security for this notion because we do not directly use this notion for later applications.
Continual Ideal Binding
Next, we consider a setting where the adversary receives oracle access to the family of decoding algorithms { D e c c o m U } U ∈ U n \{\mathrm{Dec}_{\mathrm{com}_U}\}_{U\in\mathcal{U}_n} { Dec com U } U ∈ U n after committing. This grants a huge amount of power to the adversary, even allowing them to modify the committed state by making targeted measurements.
In this case, the idealized model still requires the adversary to explicitly declare their state ∣ ψ 0 ⟩ \lvert\psi_0\rangle ∣ ψ 0 ⟩ , but now allows them to modify it into some well-defined state ∣ ψ t ⟩ \lvert\psi_t\rangle ∣ ψ t ⟩ by making t t t decoding queries. Then, rather than requiring binding to the originally committed state ∣ ψ 0 ⟩ \lvert\psi_0\rangle ∣ ψ 0 ⟩ , we require binding to the most recent state – that is, the adversary’s real opening must match the result of directly measuring ∣ ψ t ⟩ \lvert\psi_t\rangle ∣ ψ t ⟩ .
Real Experiment. The experiments are parameterized by ℓ = poly ( λ ) \ell=\operatorname{poly}(\lambda) ℓ = poly ( λ ) many unitaries U 1 , … , U ℓ ∈ U n U_1,\ldots,U_\ell\in\mathcal{U}_n U 1 , … , U ℓ ∈ U n and classical functions f 1 , … , f ℓ : { 0 , 1 } n → { 0 , 1 } n ′ f_1,\ldots,f_\ell:\{0,1\}^n\to\{0,1\}^{n'} f 1 , … , f ℓ : { 0 , 1 } n → { 0 , 1 } n ′ .30 In the real continual binding experiment R e a l c ( A , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) \mathrm{Real}_{c}(\mathcal{A},1^n,1^\lambda,(U_i,f_i)_{i\in[\ell]}) Real c ( A , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) , an adversarial QPT committer A \mathcal{A} A interacts with the honest classical receiver, as follows.
Commitment. Run the commitment protocol ( R A , c o m ) ← C o m ⟨ A , R ⟩ ( 1 λ , 1 n ) (\mathcal{R}_{\mathcal{A}},\mathrm{com})\leftarrow\mathrm{Com}\langle\mathcal{A},R\rangle(1^\lambda,1^n) ( R A , com ) ← Com ⟨ A , R ⟩ ( 1 λ , 1 n ) .
Define the oracle f D e c \mathrm{fDec} fDec which works as follows.
Input. On input ( i , o p , R a n s ) (i,\mathrm{op},\mathcal{R}_{\mathrm{ans}}) ( i , op , R ans ) :
(a) Compute v ← D e c c o m i ( o p ) v\leftarrow\mathrm{Dec}_{\mathrm{com}_i}(\mathrm{op}) v ← Dec com i ( op ) , where c o m i = K e y E v a l ( c o m , U i ) \mathrm{com}_i=\mathrm{KeyEval}(\mathrm{com},U_i) com i = KeyEval ( com , U i ) .
(b) Apply W r i t e ( f i ( v ) ) \mathrm{Write}(f_i(v)) Write ( f i ( v )) to R a n s \mathcal{R}_{\mathrm{ans}} R ans , where we define f i ( ⊥ ) = ⊥ f_i(\perp)=\perp f i ( ⊥ ) =⊥ .
Opening. Output R A \mathcal{R}_{\mathcal{A}} R A and coherent quantum oracle access to f D e c \mathrm{fDec} fDec .
Ideal Functionality. In the ideal experiment, an idealized adversary B \mathcal{B} B interacts directly with the ideal functionality I F \mathrm{IF} IF defined below.
Query I F V ( i , R a n s ) \mathrm{IF}_{\mathcal{V}}(i,\mathcal{R}_{\mathrm{ans}}) IF V ( i , R ans ) . Coherently measure and apply W r i t e ( M [ f i , U i ] V ) \mathrm{Write}(M[f_i,U_i]\mathcal{V}) Write ( M [ f i , U i ] V ) to register R a n s \mathcal{R}_{\mathrm{ans}} R ans .
Ideal Experiment. The ideal continual binding experiment Ideal c ( B , 1 λ , 1 n , ( U i , f i ) i ∈ [ n ℓ ] ) \operatorname{Ideal}_{c}(\mathcal{B},1^{\lambda},1^{n},(U_i,f_i)_{i\in[n\ell]}) Ideal c ( B , 1 λ , 1 n , ( U i , f i ) i ∈ [ n ℓ ] ) is played by an idealized adversary B = ( B 1 , B 2 ) \mathcal{B}=(\mathcal{B}_1,\mathcal{B}_2) B = ( B 1 , B 2 ) as follows.
Commitment. ( V , R o u t , R B ) ← B 1 (\mathcal{V},R_{\mathrm{out}},R_{\mathcal{B}})\leftarrow\mathcal{B}_1 ( V , R out , R B ) ← B 1 outputs a register V \mathcal{V} V containing the state it wants to commit to along with two additional registers.
Initialize B 2 \mathcal{B}_2 B 2 with R B R_{\mathcal{B}} R B , then define the oracle fMeas [ B 2 , IF V ] \operatorname{fMeas}[\mathcal{B}_2,\operatorname{IF}_{\mathcal{V}}] fMeas [ B 2 , IF V ] which works as follows.
Input. On input ( i , op , R a n s ) (i,\operatorname{op},R_{\mathrm{ans}}) ( i , op , R ans ) :
(a) Compute b ← B 2 ( i , op ) b\leftarrow\mathcal{B}_2(i,\operatorname{op}) b ← B 2 ( i , op ) .
(b) If b = 0 b=0 b = 0 , apply Write ( ⊥ ) \operatorname{Write}(\perp) Write ( ⊥ ) to register R a n s R_{\mathrm{ans}} R ans . Otherwise, run IF V ( i , R a n s ) \operatorname{IF}_{\mathcal{V}}(i,R_{\mathrm{ans}}) IF V ( i , R ans ) .
Opening. Output register R A R_{\mathcal{A}} R A and coherent quantum oracle access to fMeas [ B 2 , IF V ] \operatorname{fMeas}[\mathcal{B}_2,\operatorname{IF}_{\mathcal{V}}] fMeas [ B 2 , IF V ] .
Definition 20 (Continual Ideal Binding). A commitment scheme ( Com , Eval , KeyEval , Dec , Ver ) (\operatorname{Com},\operatorname{Eval},\operatorname{KeyEval},\operatorname{Dec},\operatorname{Ver}) ( Com , Eval , KeyEval , Dec , Ver ) satisfies continual ideal binding for the family of measurements M [ U ] \mathcal{M}[\mathcal{U}] M [ U ] if there exists a QPT algorithm Sim = ( Sim 1 , Sim 2 ) \operatorname{Sim}=(\operatorname{Sim}_1,\operatorname{Sim}_2) Sim = ( Sim 1 , Sim 2 ) such that for every n , λ ∈ N n,\lambda\in\mathbb{N} n , λ ∈ N , every ℓ = poly ( λ ) \ell=\operatorname{poly}(\lambda) ℓ = poly ( λ ) , every set of ℓ \ell ℓ unitaries U 1 , … , U ℓ ∈ U n U_1,\ldots,U_\ell\in\mathcal{U}_n U 1 , … , U ℓ ∈ U n , every set of (PPT-computable) classical functions f 1 , … , f ℓ : { 0 , 1 } n → { 0 , 1 } n ′ f_1,\ldots,f_\ell:\{0,1\}^{n}\to\{0,1\}^{n'} f 1 , … , f ℓ : { 0 , 1 } n → { 0 , 1 } n ′ ,
{ ( R A ′ , fDec ) ← Real c ( S ∗ , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) } ≈ c { ( R A ′ , fMeas [ Sim 2 , IF V ] ) ← Ideal c ( Sim ( S ∗ ) , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) } . \left\{(R'_{\mathcal{A}},\operatorname{fDec})\leftarrow\operatorname{Real}_{c}(S^*,1^n,1^\lambda,(U_i,f_i)_{i\in[\ell]})\right\}
\approx_c
\left\{(R'_{\mathcal{A}},\operatorname{fMeas}[\operatorname{Sim}_2,\operatorname{IF}_{\mathcal{V}}])\leftarrow\operatorname{Ideal}_{c}(\operatorname{Sim}(S^*),1^n,1^\lambda,(U_i,f_i)_{i\in[\ell]})\right\}. { ( R A ′ , fDec ) ← Real c ( S ∗ , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) } ≈ c { ( R A ′ , fMeas [ Sim 2 , IF V ]) ← Ideal c ( Sim ( S ∗ ) , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) } .
Definition 21 (ϵ \epsilon ϵ -secure Continual Ideal Binding). We say the scheme satisfies ϵ \epsilon ϵ -secure continual ideal binding if Sim 1 \operatorname{Sim}_1 Sim 1 and Sim 2 \operatorname{Sim}_2 Sim 2 are uniform families of poly ( λ , 1 / ϵ ) \operatorname{poly}(\lambda,1/\epsilon) poly ( λ , 1/ ϵ ) -sized circuits such that the above distributions are ϵ \epsilon ϵ -indistinguishable for every ϵ = 1 / poly ( λ ) \epsilon=1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) where Sim 1 , λ , ϵ \operatorname{Sim}_{1,\lambda,\epsilon} Sim 1 , λ , ϵ replaces Sim 1 \operatorname{Sim}_1 Sim 1 and Sim 2 , λ , ϵ \operatorname{Sim}_{2,\lambda,\epsilon} Sim 2 , λ , ϵ replaces Sim 2 \operatorname{Sim}_2 Sim 2 .
We mention a few useful properties of this definition. First, the real-world queries are “one-to-one” with the ideal world queries, in the sense that a query to i i i can only become either a query to i i i or a skipped query. Second, if an adversarial opener at any point produces an opening ( i , op ) (i,\operatorname{op}) ( i , op ) , the result of f ( Dec com i ( op ) ) f(\operatorname{Dec}_{\operatorname{com}_i}(\operatorname{op})) f ( Dec com i ( op )) is either ⊥ \perp ⊥ or distributed according to measuring M [ f i , U i ] \mathcal{M}[f_i,U_i] M [ f i , U i ] on the committed state in register V \mathcal{V} V .
Continual Binding with Recovery
Sometimes it is useful to recover the committed state after doing a sequence of measurements on it, as is allowed in continual binding. However, one must be careful that Recover does not allow distinguishing the ideal binding world from the real after the fact. For example, what if Recover involves giving com to the sender? We augment the definition of continual binding to ensure safe recovery after several openings.
The real and ideal experiments from continual binding are augmented with an additional recovery step. After preparing the oracles fDec (in the real experiment) or fMeas (in the ideal experiment), the adversary gets an opportunity to query them. Then, the new step is to run Recover in the real world. This is matched in the ideal world by a QPT algorithm Sim which directly receives a register V \mathcal{V} V containing the recovered state and must produce an indistinguishable view.
Definition 22 (Continual Binding with Recovery). Let Real c \operatorname{Real}_{\mathrm{c}} Real c and Ideal c \operatorname{Ideal}_{\mathrm{c}} Ideal c be the continual binding experiments from Definition 20.
A commitment scheme with state recovery satisfies continual binding with recovery for the family of measurements M [ U ] \mathcal{M}[\mathcal{U}] M [ U ] if there exists a QPT algorithm Sim = ( Sim 1 , 2 , Sim 3 ) \operatorname{Sim}=(\operatorname{Sim}_{1,2},\operatorname{Sim}_3) Sim = ( Sim 1 , 2 , Sim 3 ) such that for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N , every n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) and ℓ = poly ( λ ) \ell=\operatorname{poly}(\lambda) ℓ = poly ( λ ) , every set of ℓ \ell ℓ unitaries U 1 , … , U ℓ ∈ U n U_1,\ldots,U_\ell\in\mathcal{U}_n U 1 , … , U ℓ ∈ U n , every set of (PPT-computable) classical functions f 1 , … , f ℓ : { 0 , 1 } n → { 0 , 1 } n ′ f_1,\ldots,f_\ell:\{0,1\}^n \to\{0,1\}^{n'} f 1 , … , f ℓ : { 0 , 1 } n → { 0 , 1 } n ′ , and every QPT adversarial committer A = ( A 1 , 2 , A 3 ) \mathcal{A}=(\mathcal{A}_{1,2},\mathcal{A}_3) A = ( A 1 , 2 , A 3 ) , the real and ideal experiments with appended recovery step are computationally indistinguishable:
R A ′ ′ : ( R A , f D e c ) ← Real c ( A 1 , 2 , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) R A ′ ← A 2 f D e c ( R A ) R A ′ ′ ← Recover ⟨ A 3 ( R A ′ ) , R ( c o m ) ⟩ \begin{aligned}
\mathcal{R}_{\mathcal{A}}^{\prime\prime}:&\quad(\mathcal{R}_{\mathcal{A}},\mathsf{fDec}) \leftarrow\operatorname{Real}_{\mathrm{c}}(\mathcal{A}_{1,2},1^n,1^\lambda,(U_i,f_i)_{i\in[\ell]}) \\
&\quad\mathcal{R}_{\mathcal{A}}^{\prime} \leftarrow\mathcal{A}_2^{\mathsf{fDec}}(\mathcal{R}_{\mathcal{A}}) \\
&\quad\mathcal{R}_{\mathcal{A}}^{\prime\prime} \leftarrow\operatorname{Recover}\langle\mathcal{A}_3(\mathcal{R}_{\mathcal{A}}^{\prime}),R(\mathsf{com})\rangle
\end{aligned} R A ′′ : ( R A , fDec ) ← Real c ( A 1 , 2 , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) R A ′ ← A 2 fDec ( R A ) R A ′′ ← Recover ⟨ A 3 ( R A ′ ) , R ( com )⟩ ≈ c R A ′ ′ : ( R A , f M e a s V ) ← Ideal c ( Sim ( S ∗ ) , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) R A ′ ← A 2 f M e a s V ( R A ) R A ′ ′ ← Sim 3 ( A 3 ( R A ′ ) , V ) \approx_{\mathrm{c}}
\begin{aligned}
\mathcal{R}_{\mathcal{A}}^{\prime\prime}:&\quad(\mathcal{R}_{\mathcal{A}},\mathsf{fMeas}_{\mathcal{V}}) \leftarrow\operatorname{Ideal}_{\mathrm{c}}(\operatorname{Sim}(S^*),1^n,1^\lambda,(U_i,f_i)_{i\in[\ell]}) \\
&\quad\mathcal{R}_{\mathcal{A}}^{\prime} \leftarrow\mathcal{A}_2^{\mathsf{fMeas}_{\mathcal{V}}}(\mathcal{R}_{\mathcal{A}}) \\
&\quad\mathcal{R}_{\mathcal{A}}^{\prime\prime} \leftarrow\operatorname{Sim}_3(\mathcal{A}_3(\mathcal{R}_{\mathcal{A}}^{\prime}),\mathcal{V})
\end{aligned} ≈ c R A ′′ : ( R A , fMeas V ) ← Ideal c ( Sim ( S ∗ ) , 1 n , 1 λ , ( U i , f i ) i ∈ [ ℓ ] ) R A ′ ← A 2 fMeas V ( R A ) R A ′′ ← Sim 3 ( A 3 ( R A ′ ) , V ) Here c o m \mathsf{com} com is the commitment key from Real c \operatorname{Real}_{\mathrm{c}} Real c and Sim 3 \operatorname{Sim}_3 Sim 3 receives state from Sim 2 \operatorname{Sim}_2 Sim 2 after A 2 \mathcal{A}_2 A 2 finishes using fMeas.
Definition 23 (ϵ \epsilon ϵ -secure Continual Binding with Recovery). We say the scheme satisfies ϵ \epsilon ϵ -secure continual binding with recovery if Sim 1 \operatorname{Sim}_1 Sim 1 , Sim 2 \operatorname{Sim}_2 Sim 2 , and Sim 3 \operatorname{Sim}_3 Sim 3 are uniform families of poly ( λ , 1 / ϵ ) \operatorname{poly}(\lambda,1/\epsilon) poly ( λ , 1/ ϵ ) -sized circuits such that the above distributions are ϵ \epsilon ϵ -indistinguishable for every ϵ = 1 / poly ( λ ) \epsilon=1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) where Sim i , λ , ϵ \operatorname{Sim}_{i,\lambda,\epsilon} Sim i , λ , ϵ replaces Sim i \operatorname{Sim}_i Sim i for i ∈ { 1 , 2 , 3 } i\in\{1,2,3\} i ∈ { 1 , 2 , 3 } .
Both definitions above can also be easily adapted for partial recovery. In this case, we divide the register which contains the committed state into V = ( V 1 , V 2 ) \mathcal{V}=(\mathcal{V}_1,\mathcal{V}_2) V = ( V 1 , V 2 ) and Sim 3 \operatorname{Sim}_3 Sim 3 only receives register V 1 \mathcal{V}_1 V 1 .
Continual Binding for Authentication
Continual binding can also be defined for authentication. The only difference is in the real world’s initial commitment step, which is replaced by
Receive a register V \mathcal{V} V from the adversary.
Sample k ← Auth.KeyGen ( 1 λ , 1 n ) k \leftarrow\operatorname{Auth.KeyGen}(1^\lambda,1^n) k ← Auth.KeyGen ( 1 λ , 1 n ) , then send V ~ ← Auth.Enc k ( V ) \widetilde{\mathcal{V}} \leftarrow\operatorname{Auth.Enc}_k(\mathcal{V}) V ← Auth.Enc k ( V ) back to the adversary.
[26 ] ’s definition of functional authentication security can be seen as continual binding with a specific simulator.
Lemma 12. Functional authentication security (Definition 6) implies continual binding for quantum authentication.
Proof. Fix any sequence of unitaries U 1 , … , U t ∈ U n U_1,\ldots,U_t \in\mathcal{U}_n U 1 , … , U t ∈ U n . The simulator S i m 1 \mathsf{Sim}_1 Sim 1 works as follows:
Receive V \mathcal{V} V from the adversary and forward it to the continual binding ideal functionality I F \mathsf{IF} IF .
Sample k ← A u t h . K e y G e n ( 1 λ , 1 n ) k \leftarrow\mathsf{Auth.KeyGen}(1^\lambda,1^n) k ← Auth.KeyGen ( 1 λ , 1 n ) then send V ~ ← A u t h . E n c k ( ∣ 0 n ⟩ ) \widetilde{\mathcal{V}} \leftarrow\mathsf{Auth.Enc}_k(\lvert0^n\rangle) V ← Auth.Enc k (∣ 0 n ⟩) to the adversary. Let c o m j = A u t h . K e y E v a l ( c o m , U j ) \mathsf{com}_j = \mathsf{Auth.KeyEval}(\mathsf{com},U_j) com j = Auth.KeyEval ( com , U j ) and send it to S i m 2 \mathsf{Sim}_2 Sim 2 .
The oracle simulator S i m 2 \mathsf{Sim}_2 Sim 2 acts as follows on queries ( i , o p ) (i,\mathsf{op}) ( i , op ) :
Output b ← A u t h . V e r c o m i ( o p ) b \leftarrow\mathsf{Auth.Ver}_{\mathsf{com}_i}(\mathsf{op}) b ← Auth.Ver com i ( op ) , where c o m i = A u t h . K e y E v a l ( c o m , U i ) \mathsf{com}_i = \mathsf{Auth.KeyEval}(\mathsf{com},U_i) com i = Auth.KeyEval ( com , U i ) .
Observe that f M e a s [ S i m 2 , I F V ] \mathsf{fMeas}[\mathsf{Sim}_2,\mathsf{IF}_{\mathcal{V}}] fMeas [ Sim 2 , IF V ] is precisely the oracle f V e r \mathsf{fVer} fVer from Definition 6, and therefore oracle access to it along with V ~ = A u t h . E n c k ( ∣ 0 n ⟩ ) \widetilde{\mathcal{V}} = \mathsf{Auth.Enc}_k(\lvert0^n\rangle) V = Auth.Enc k (∣ 0 n ⟩) is indistinguishable from A u t h . E n c ( V ) \mathsf{Auth.Enc}(\mathcal{V}) Auth.Enc ( V ) and oracle access to f D e c \mathsf{fDec} fDec .
Construction
In the following, we set A u t h \mathsf{Auth} Auth to be the coset-based authentication scheme from [4 ] .
Construction 2 ( C o m ⟨ S ( S i n ) , R ⟩ ( 1 λ , 1 n ) ) \left(\mathsf{Com}\langle S(S_{\mathrm{in}}),R\rangle(1^\lambda,1^n)\right) ( Com ⟨ S ( S in ) , R ⟩ ( 1 λ , 1 n ) ) . To commit to an n n n -qubit state contained in register S i n S_{\mathrm{in}} S in , the quantum sender S ( S i n ) S(S_{\mathrm{in}}) S ( S in ) and classical receiver R R R interact as follows.
Classical Receiver: Sample a 2 λ 2\lambda 2 λ -dimensional subspace S ⊂ F 2 4 λ S \subset\mathbb{F}_2^{4\lambda} S ⊂ F 2 4 λ and a vector Δ ∈ F 2 4 λ ∖ S \Delta\in\mathbb{F}_2^{4\lambda}\setminus S Δ ∈ F 2 4 λ ∖ S . Let S Δ = S + Span ( Δ ) S_\Delta= S + \operatorname{Span}(\Delta) S Δ = S + Span ( Δ ) .
Both: Set d ( λ ) = 4 λ n d(\lambda)=4\lambda n d ( λ ) = 4 λn and remotely prepare a random coset state of S Δ n ⊆ ( F 2 4 λ ) n S_\Delta^n \subseteq(\mathbb{F}_2^{4\lambda})^n S Δ n ⊆ ( F 2 4 λ ) n
( ⨂ i = 1 n X x i Z z i ∣ S Δ ⟩ , ( x , z ) ) ← R S P d ⟨ Q , C ( S Δ n ) ⟩ ( 1 λ ) \left(\bigotimes_{i=1}^{n}X^{x_i}Z^{z_i}\lvert S_\Delta\rangle,(\mathbf{x},\mathbf{z})\right) \leftarrow\mathsf{RSP}_d\left\langle Q,C(S_\Delta^n)\right\rangle(1^\lambda) ( i = 1 ⨂ n X x i Z z i ∣ S Δ ⟩ , ( x , z ) ) ← RSP d ⟨ Q , C ( S Δ n ) ⟩ ( 1 λ )
where the classical receiver R R R acts as the classical party C C C and the quantum sender acts as the quantum party Q Q Q .31 Let Q Q Q ’s output coset state be stored in register R ~ o u t = ( R ~ o u t , 1 , … , R ~ o u t , n ) \widetilde{R}_{\mathrm{out}}=(\widetilde{R}_{\mathrm{out},1},\ldots,\widetilde{R}_{\mathrm{out},n}) R out = ( R out , 1 , … , R out , n ) .
Classical Receiver: Set k = ( S , Δ , x , z ) k=(S,\Delta,\mathbf{x},\mathbf{z}) k = ( S , Δ , x , z ) . Note that the overall prepared coset state in registers ( R ~ o u t , i ) i ∈ [ n ] (\widetilde{R}_{\mathrm{out},i})_{i\in[n]} ( R out , i ) i ∈ [ n ] can be interpreted as the authentication of ∣ + n ⟩ \lvert+^n\rangle ∣ + n ⟩ using key k k k :
⨂ i = 1 n X x i Z z i ∣ S Δ ⟩ = A u t h . E n c k ( ∣ + n ⟩ ) \bigotimes_{i=1}^{n}X^{x_i}Z^{z_i}\lvert S_\Delta\rangle= \mathsf{Auth.Enc}_k(\lvert+^n\rangle) i = 1 ⨂ n X x i Z z i ∣ S Δ ⟩ = Auth.Enc k (∣ + n ⟩)
Quantum Sender: Initialize an n n n -qubit register R i n = ( R i n , 1 , … , R i n , n ) R_{\mathrm{in}}=(R_{\mathrm{in},1},\ldots,R_{\mathrm{in},n}) R in = ( R in , 1 , … , R in , n ) to ∣ + n ⟩ \lvert+^n\rangle ∣ + n ⟩ .
Both: Execute a state-preserving 2PC for the following classical linear-or-abort functionality.
Quantum Party Input: Registers ( R i n , 1 , R ~ o u t , 1 ) , … , ( R i n , n , R ~ o u t , n ) (\mathcal{R}_{\mathrm{in},1},\widetilde{\mathcal{R}}_{\mathrm{out},1}),\ldots,(\mathcal{R}_{\mathrm{in},n},\widetilde{\mathcal{R}}_{\mathrm{out},n}) ( R in , 1 , R out , 1 ) , … , ( R in , n , R out , n ) .
Classical Party Input: The key ( S , Δ , x , z ) (S,\Delta,\mathbf{x},\mathbf{z}) ( S , Δ , x , z ) .
Functionality: On input b ∈ F 2 n \mathbf{b}\in\mathbb{F}_2^n b ∈ F 2 n and v ∈ F 2 Δ n \mathbf{v}\in\mathbb{F}_2^{\Delta n} v ∈ F 2 Δ n :
(a) Let k I = Auth.KeyEval ( k , I ) k_I=\operatorname{Auth.KeyEval}(k,I) k I = Auth.KeyEval ( k , I ) be the homomorphic key for the identity unitary.
(b) Compute b ′ = Auth.Dec k I ( v ) \mathbf{b}'=\operatorname{Auth.Dec}_{k_I}(\mathbf{v}) b ′ = Auth.Dec k I ( v ) .
(c) If b ′ = ⊥ \mathbf{b}'=\bot b ′ = ⊥ , output ⊥ \bot ⊥ . Otherwise output b − b ′ \mathbf{b}-\mathbf{b}' b − b ′ .
If the classical party receives output b ′ ′ \mathbf{b}'' b ′′ , then the quantum sender’s state in registers ( R i n , i , R ~ o u t , i ) i ∈ [ n ] (\mathcal{R}_{\mathrm{in},i},\widetilde{\mathcal{R}}_{\mathrm{out},i})_{i\in[n]} ( R in , i , R out , i ) i ∈ [ n ] is now
1 2 n ∑ b ∈ F 2 n ∣ b ⟩ R i n ⊗ Auth.Enc k ( X b ′ ′ ∣ b ⟩ ) R ~ o u t \frac{1}{\sqrt{2^n}}\sum_{\mathbf{b}\in\mathbb{F}_2^n}|\mathbf{b}\rangle_{\mathcal{R}_{\mathrm{in}}}\otimes\operatorname{Auth.Enc}_{k}\left(X^{\mathbf{b}''}|\mathbf{b}\rangle\right)_{\widetilde{\mathcal{R}}_{\mathrm{out}}} 2 n 1 b ∈ F 2 n ∑ ∣ b ⟩ R in ⊗ Auth.Enc k ( X b ′′ ∣ b ⟩ ) R out
by the correctness of authentication.
Quantum Sender: Perform the sender half of quantum teleportation of S i n , i \mathcal{S}_{\mathrm{in},i} S in , i through register R i n , i \mathcal{R}_{\mathrm{in},i} R in , i into register R ~ o u t , i \widetilde{\mathcal{R}}_{\mathrm{out},i} R out , i for each i ∈ [ n ] i\in[n] i ∈ [ n ] . This yields a list of teleportation corrections ( x t e l , i , z t e l , i ) i ∈ [ n ] (x_{\mathrm{tel},i},z_{\mathrm{tel},i})_{i\in[n]} ( x tel , i , z tel , i ) i ∈ [ n ] . Let x t e l \mathbf{x}_{\mathrm{tel}} x tel and z t e l \mathbf{z}_{\mathrm{tel}} z tel be the concatenations of the X X X and Z Z Z corrections, respectively.
Note that if the state being teleported was ∣ ψ i ⟩ |\psi_i\rangle ∣ ψ i ⟩ , the resulting state in register R ~ o u t \widetilde{\mathcal{R}}_{\mathrm{out}} R out is
Auth.Enc k ( X b ′ ′ + x t e l Z z t e l ∣ ψ i ⟩ ) \operatorname{Auth.Enc}_{k}\left(X^{\mathbf{b}''+\mathbf{x}_{\mathrm{tel}}}Z^{\mathbf{z}_{\mathrm{tel}}}|\psi_i\rangle\right) Auth.Enc k ( X b ′′ + x tel Z z tel ∣ ψ i ⟩ )
Send ( b ′ ′ + x t e l , z t e l ) (\mathbf{b}''+\mathbf{x}_{\mathrm{tel}},\mathbf{z}_{\mathrm{tel}}) ( b ′′ + x tel , z tel ) to the classical receiver and output register
R o p : = R ~ o u t . \mathcal{R}_{\mathrm{op}}:=\widetilde{\mathcal{R}}_{\mathrm{out}}. R op := R out .
Classical Receiver: Perform the key update
c o m : = Auth.KeyEval ( k , X b ′ ′ + x t e l Z z t e l ) \mathsf{com}:=\operatorname{Auth.KeyEval}\left(k,X^{\mathbf{b}''+\mathbf{x}_{\mathrm{tel}}}Z^{\mathbf{z}_{\mathrm{tel}}}\right) com := Auth.KeyEval ( k , X b ′′ + x tel Z z tel )
Output c o m \mathsf{com} com .
Construction 3 (Other Commitment Algorithms). The remaining commitment algorithms are identical to [4 ] ’s authentication code, i.e.
E v a l = Auth.Eval K e y E v a l = Auth.KeyEval D e c c o m U = Auth.Dec c o m U V e r c o m U = Auth.Ver c o m U \begin{aligned}
\mathsf{Eval}&=\operatorname{Auth.Eval}\\
\mathsf{KeyEval}&=\operatorname{Auth.KeyEval}\\
\mathsf{Dec}_{\mathsf{com}_U}&=\operatorname{Auth.Dec}_{\mathsf{com}_U}\\
\mathsf{Ver}_{\mathsf{com}_U}&=\operatorname{Auth.Ver}_{\mathsf{com}_U}
\end{aligned} Eval KeyEval Dec com U Ver com U = Auth.Eval = Auth.KeyEval = Auth.Dec com U = Auth.Ver com U where c o m \mathsf{com} com is interpreted as k k k .
Theorem 14. Constructions 2 and 3 together are a classical commitment to quantum states with ϵ \epsilon ϵ -secure continual ideal binding (Definition 20) for the family of ZX-and-Linear measurements U Z X − L i n \mathcal{U}^{\mathrm{ZX-Lin}} U ZX − Lin . Furthermore, Dec is a linear function with post-processed abort.
Proof. The protocol description already shows that the sender prepares Auth.Encc o m ( V ) _{\mathrm{com}}(\mathcal{V}) com ( V ) , using the correctness of RSPd _d d , the correctness of Auth, and the correctness of teleportation. Moreover, com is in the keyspace of Auth.KeyGen for [4 ] ’s construction. Therefore correctness follows from the correctness of Auth.
Next, we show security. Fix any sequence of unitaries U 1 , … , U t ∈ U Z X − L i n U_1,\ldots,U_t \in\mathcal{U}^{\mathrm{ZX-Lin}} U 1 , … , U t ∈ U ZX − Lin and classical functions f 1 , … , f t f_1,\ldots,f_t f 1 , … , f t . The commitment-phase simulator Sim1 _1 1 works as follows.
Prepare ∣ + n ⟩ |+^n\rangle ∣ + n ⟩ in register V \mathcal{V} V .
Sample k ← A u t h . K e y G e n ( 1 λ , 1 n ) k \leftarrow\mathrm{Auth.KeyGen}(1^\lambda,1^n) k ← Auth.KeyGen ( 1 λ , 1 n ) and prepare
A u t h . E n c k ( ∣ 0 ⟩ n ) = ⨂ i = 1 n X x i Z z i ∣ S ⟩ \mathrm{Auth.Enc}_k(|0\rangle^n)=\bigotimes_{i=1}^{n}X^{x_i}Z^{z_i}|S\rangle Auth.Enc k ( ∣0 ⟩ n ) = i = 1 ⨂ n X x i Z z i ∣ S ⟩
Simulate the RSP protocol using ⨂ i = 1 n X x i Z z i ∣ S ⟩ \bigotimes_{i=1}^{n}X^{x_i}Z^{z_i}|S\rangle ⨂ i = 1 n X x i Z z i ∣ S ⟩ and the membership oracles for ⨂ i = 1 n ( S Δ + x i ) \bigotimes_{i=1}^{n}(S_\Delta+x_i) ⨂ i = 1 n ( S Δ + x i ) and ⨂ i = 1 n ( S ⊥ + z i ) \bigotimes_{i=1}^{n}(S^\perp+z_i) ⨂ i = 1 n ( S ⊥ + z i ) .32
Simulate the state-preserving 2PC protocol. During its ideal functionality, replace the decoding step by checking A u t h . V e r k ( V ) \mathrm{Auth.Ver}_k(\mathcal{V}) Auth.Ver k ( V ) and, if it is not ⊥ \bot ⊥ , computing the output b − b ′ \mathbf{b}-\mathbf{b}' b − b ′ by the XOR of the input register and register V \mathcal{V} V .
Receive the teleportation corrections ( x t e l , z t e l ) (x_{\mathrm{tel}},z_{\mathrm{tel}}) ( x tel , z tel ) from the adversary.
Apply X x t e l Z z t e l X^{x_{\mathrm{tel}}}Z^{z_{\mathrm{tel}}} X x tel Z z tel to register V \mathcal{V} V . Compute k ′ = A u t h . K e y E v a l ( X x t e l Z z t e l ) k'=\mathrm{Auth.KeyEval}(X^{x_{\mathrm{tel}}}Z^{z_{\mathrm{tel}}}) k ′ = Auth.KeyEval ( X x tel Z z tel ) .
Send register V \mathcal{V} V to the commitment ideal functionality and send k ′ k' k ′ to Sim2 _2 2 .
On any query, Sim2 _2 2 simply checks A u t h . V e r k ′ ( ∙ ) \mathrm{Auth.Ver}_{k'}(\bullet) Auth.Ver k ′ ( ∙ ) and allows the query to go through if and only if the output is accepting.
We now show indistinguishability from the real experiment. Fix any ϵ = 1 / poly ( λ ) \epsilon=1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) .
A u t h . E n c k ( ∣ + ⟩ n ) = ⨂ i = 1 n X x i Z z i ∣ S Δ ⟩ \mathrm{Auth.Enc}_k(|+\rangle^n)=\bigotimes_{i=1}^{n}X^{x_i}Z^{z_i}|S_\Delta\rangle Auth.Enc k ( ∣ + ⟩ n ) = i = 1 ⨂ n X x i Z z i ∣ S Δ ⟩
Set the simulation error to ϵ / 2 \epsilon/2 ϵ /2 . This is ϵ / 2 \epsilon/2 ϵ /2 -computationally indistinguishable by the ϵ \epsilon ϵ -security of RSP.
A u t h . E n c k ( ∣ 0 ⟩ n ) = ⨂ i = 1 n X x i Z z i ∣ S ⟩ . \mathrm{Auth.Enc}_k(\lvert0\rangle^{n}) = \bigotimes_{i=1}^{n} X^{x_i}Z^{z_i}\lvert S\rangle. Auth.Enc k (∣ 0 ⟩ n ) = i = 1 ⨂ n X x i Z z i ∣ S ⟩ .
Additionally, it changes all usage of the decoding oracles A u t h . D e c \mathrm{Auth.Dec} Auth.Dec to verification queries A u t h . V e r \mathrm{Auth.Ver} Auth.Ver in combination with operations directly on register V \mathcal{V} V . This includes the RSP preparation. This is statistically indistinguishable by the functional authentication security of A u t h \mathrm{Auth} Auth (Definition 4).
H y b 3 \mathrm{Hyb}_3 Hyb 3 is precisely the simulator listed above with a slight syntactic reinterpretation: since the key update only affects A u t h . V e r \mathrm{Auth.Ver} Auth.Ver , the decoding is updated to match by applying X x t e l Z z t e l X^{x_{\mathrm{tel}}}Z^{z_{\mathrm{tel}}} X x tel Z z tel to register V \mathcal{V} V (Equation (4) ).
Construction with Recovery
Next, we generically add a Recover protocol to the construction from the prior section by teleporting the committed state into an uncommitted register.
Construction 4 (Commitment with Recovery). Here we compile any commitment
( C o m , E v a l , K e y E v a l , D e c , V e r ) (\mathrm{Com},\mathrm{Eval},\mathrm{KeyEval},\mathrm{Dec},\mathrm{Ver}) ( Com , Eval , KeyEval , Dec , Ver )
which supports ZX-and-linear measurements and satisfies continual ideal binding into a commitment
( C o m ′ , E v a l ′ , K e y E v a l ′ , D e c ′ , V e r ′ , R e c o v e r ) (\mathrm{Com}',\mathrm{Eval}',\mathrm{KeyEval}',\mathrm{Dec}',\mathrm{Ver}',\mathrm{Recover}) ( Com ′ , Eval ′ , KeyEval ′ , Dec ′ , Ver ′ , Recover )
which supports the same measurements and additionally has continual binding with recovery. The core algorithms, except for recovery, are as follows.
C o m ′ ⟨ S ( S i n ) , R ⟩ ( 1 n , 1 λ ) \mathrm{Com}'\langle S(S_{\mathrm{in}}),R\rangle(1^n,1^\lambda) Com ′ ⟨ S ( S in ) , R ⟩ ( 1 n , 1 λ ) : The quantum sender S S S prepares n n n EPR pairs in registers ( E i n , E o u t ) (\mathcal{E}_{\mathrm{in}},\mathcal{E}_{\mathrm{out}}) ( E in , E out ) , where the i i i th EPR pair is in register ( E i n , i , E o u t , i ) (\mathcal{E}_{\mathrm{in},i},\mathcal{E}_{\mathrm{out},i}) ( E in , i , E out , i ) . Then, it commits to the 2 n 2n 2 n -qubit state in registers ( S i n , E i n ) (S_{\mathrm{in}},\mathcal{E}_{\mathrm{in}}) ( S in , E in ) using the commitment from Construction 2:
( R o p , c o m ) ← C o m ⟨ S ( S i n , E i n ) , R ⟩ ( 1 2 n , 1 λ ) (\mathcal{R}_{\mathrm{op}},\mathrm{com}) \leftarrow\mathrm{Com}\langle S(S_{\mathrm{in}},\mathcal{E}_{\mathrm{in}}),R\rangle(1^{2n},1^\lambda) ( R op , com ) ← Com ⟨ S ( S in , E in ) , R ⟩ ( 1 2 n , 1 λ )
The sender outputs ( R o p , E o u t ) (\mathcal{R}_{\mathrm{op}},\mathcal{E}_{\mathrm{out}}) ( R op , E out ) , which together form the opening register of the compiled commitment, and the receiver outputs c o m \mathrm{com} com .
E v a l ′ , K e y E v a l ′ , D e c ′ , V e r ′ \mathrm{Eval}',\mathrm{KeyEval}',\mathrm{Dec}',\mathrm{Ver}' Eval ′ , KeyEval ′ , Dec ′ , Ver ′ : On input U ∈ U n U \in\mathcal{U}_n U ∈ U n , set U ′ = U ⊗ I n U'=U\otimes I_n U ′ = U ⊗ I n . The algorithms E v a l ′ \mathrm{Eval}' Eval ′ and K e y E v a l ′ \mathrm{KeyEval}' KeyEval ′ run the corresponding underlying algorithms on U ′ U' U ′ , and E v a l ′ \mathrm{Eval}' Eval ′ acts on R o p \mathcal{R}_{\mathrm{op}} R op while leaving E o u t \mathcal{E}_{\mathrm{out}} E out unchanged. The algorithm D e c ′ \mathrm{Dec}' Dec ′ runs the underlying decoder and
returns ⊥ \bot ⊥ if the underlying decoder returns ⊥ \bot ⊥ ; otherwise, it returns only the first n n n decoded bits. In the coherent implementation of Dec′ ' ′ , all workspace, including the last n n n decoded bits, is uncomputed. The algorithm Ver′ ' ′ runs the underlying verification algorithm.
Next, we describe the recovery protocol. It uses the Bell-measurement unitary
U t e l : = ( H ⊗ n ⊗ I n ) ( ∏ i = 1 n CNOT S i n , i → E i n , i ) . U_{\mathrm{tel}} := \left(H^{\otimes n} \otimes I_n\right)\left(\prod_{i=1}^{n} \operatorname{CNOT}_{S_{\mathrm{in},i}\to E_{\mathrm{in},i}}\right). U tel := ( H ⊗ n ⊗ I n ) ( i = 1 ∏ n CNOT S in , i → E in , i ) .
U t e l U_{\mathrm{tel}} U tel is a ZX-and-linear unitary: the CNOT layer is linear, and it is followed by Hadamards on the first n n n logical qubits.
Construction 5 (Recovery). To recover the state, S S S and R R R interact in Recover ⟨ S ( R o p , E o u t ) , R ( c o m ) ⟩ \operatorname{Recover}\langle S(R_{\mathrm{op}},\mathcal{E}_{\mathrm{out}}),R(\mathrm{com})\rangle Recover ⟨ S ( R op , E out ) , R ( com )⟩ as follows.
Homomorphic teleportation. Let the first n n n logical qubits of the underlying commitment correspond to S i n S_{\mathrm{in}} S in and the last n n n logical qubits correspond to E i n \mathcal{E}_{\mathrm{in}} E in . The sender measures the opening
o p t e l ← M [ U ~ t e l ] ( R o p ) \mathrm{op}_{\mathrm{tel}} \leftarrow M\left[\widetilde{U}_{\mathrm{tel}}\right](R_{\mathrm{op}}) op tel ← M [ U tel ] ( R op ) for the homomorphic teleportation measurement
U ~ t e l ← Eval ( U t e l ) . \widetilde{U}_{\mathrm{tel}} \leftarrow\operatorname{Eval}(U_{\mathrm{tel}}). U tel ← Eval ( U tel ) . It sends o p t e l \mathrm{op}_{\mathrm{tel}} op tel to the receiver.
Decode the teleportation corrections. The receiver computes
c o m t e l ← KeyEval ( c o m , U t e l ) . \mathrm{com}_{\mathrm{tel}} \leftarrow\operatorname{KeyEval}(\mathrm{com},U_{\mathrm{tel}}). com tel ← KeyEval ( com , U tel ) . It then computes
( a , b ) ← Dec c o m t e l ( o p t e l ) , (a,b) \leftarrow\operatorname{Dec}_{\mathrm{com}_{\mathrm{tel}}}(\mathrm{op}_{\mathrm{tel}}), ( a , b ) ← Dec com tel ( op tel ) , where a , b ∈ { 0 , 1 } n a,b \in\{0,1\}^{n} a , b ∈ { 0 , 1 } n are respectively the decoded outcomes of the first and last n n n logical qubits. If decoding returns ⊥ \bot ⊥ , the receiver sends ⊥ \bot ⊥ to the sender and both parties output ⊥ \bot ⊥ . Otherwise, the receiver sends ( a , b ) (a,b) ( a , b ) to the sender.
Apply the teleportation corrections. The sender applies Z a X b Z^{a}X^{b} Z a X b to E o u t \mathcal{E}_{\mathrm{out}} E out and outputs the resulting register as the recovered state.
Theorem 15. Construction 4 and Construction 5 together are a classical commitment to quantum states satisfying ϵ \epsilon ϵ -continual ideal binding with recovery (Definition 22) for the family of ZX-and-Linear measurements U Z X - L i n \mathcal{U}^{\mathrm{ZX\text{-}Lin}} U ZX - Lin . Furthermore, Dec′ ' ′ is a linear function with post-processed abort.
Remark 6. We note that the same construction can be adapted to partial recovery of any sub-register V 1 V_1 V 1 simply by having the receiver only reveal the teleportation corrections corresponding to V 1 V_1 V 1 . Essentially the same security proof applies.
Proof. Correctness and the additional property of Dec ′ \operatorname{Dec}' Dec ′ follow from the underlying commitment. Recovery correctness follows from the correctness of the baseline commitment, which implies that it is equivalent to run U t e l U_{\mathrm{tel}} U tel before committing, and the correctness of teleportation.
For continual binding with recovery, fix ( U i , f i ) i ∈ [ ℓ ] (U_i,f_i)_{i\in[\ell]} ( U i , f i ) i ∈ [ ℓ ] and define
U i ′ : = U i ⊗ I n and f i ′ ( v , w ) : = f i ( v ) U'_i := U_i \otimes I_n \qquad\text{and}\qquad f'_i(v,w) := f_i(v) U i ′ := U i ⊗ I n and f i ′ ( v , w ) := f i ( v )
for i ∈ [ ℓ ] i\in[\ell] i ∈ [ ℓ ] , together with the recovery pair
U ℓ + 1 ′ : = U t e l and f ℓ + 1 ′ ( v , w ) : = ( v , w ) . U'_{\ell+1} := U_{\mathrm{tel}} \qquad\text{and}\qquad f'_{\ell+1}(v,w) := (v,w). U ℓ + 1 ′ := U tel and f ℓ + 1 ′ ( v , w ) := ( v , w ) .
We implicitly pad their outputs to a common length. All of these unitaries are ZX-and-linear. For any adversary A = ( A 1 , 2 , A 3 ) \mathcal{A}=(\mathcal{A}_{1,2},\mathcal{A}_3) A = ( A 1 , 2 , A 3 ) , let ( Sim 1 , Sim 2 ) (\operatorname{Sim}_1,\operatorname{Sim}_2) ( Sim 1 , Sim 2 ) be the underlying continual-binding simulator for this family and the adversarial 2 n 2n 2 n -qubit commitment induced by A 1 , 2 \mathcal{A}_{1,2} A 1 , 2 , with E o u t E_{\mathrm{out}} E out included in its auxiliary state. For any desired ϵ ∗ = 1 / poly ( λ ) \epsilon^*=1/\operatorname{poly}(\lambda) ϵ ∗ = 1/ poly ( λ ) , we set their ϵ \epsilon ϵ -security identical to ϵ ∗ \epsilon^* ϵ ∗ and omit the subscripts in the following.
The simulator Sim 1 , 2 ′ \operatorname{Sim}'_{1,2} Sim 1 , 2 ′ runs Sim 1 \operatorname{Sim}_1 Sim 1 , writes its 2 n 2n 2 n -qubit ideal register as ( V 1 , V 2 ) (V_1,V_2) ( V 1 , V 2 ) , sends V 1 V_1 V 1 to the compiled ideal functionality, and retains V 2 V_2 V 2 and the private simulator state for Sim 2 ′ \operatorname{Sim}'_2 Sim 2 ′ . To queries ( i , op ) (i,\operatorname{op}) ( i , op ) made to f M e a s \mathrm{fMeas} fMeas by A 2 \mathcal{A}_2 A 2 , Sim 2 ′ \operatorname{Sim}'_2 Sim 2 ′ runs Sim 2 \operatorname{Sim}_2 Sim 2 on the corresponding query ( i , op ) (i,\operatorname{op}) ( i , op ) for ( U i ′ , f i ′ ) (U'_i,f'_i) ( U i ′ , f i ′ ) . Then, it returns ⊥ \perp ⊥ if Sim 2 \operatorname{Sim}_2 Sim 2 rejects and otherwise forwards i i i to the compiled ideal functionality. This exactly emulates the underlying ideal oracle since
M [ f i ′ , U i ′ ] V 1 V 2 = M [ f i , U i ] V 1 ⊗ I V 2 . M[f'_i,U'_i]_{V_1V_2}=M[f_i,U_i]_{V_1}\otimes I_{V_2}. M [ f i ′ , U i ′ ] V 1 V 2 = M [ f i , U i ] V 1 ⊗ I V 2 .
For recovery, Sim 3 ′ \operatorname{Sim}'_3 Sim 3 ′ receives the current V 1 V_1 V 1 , then runs A 3 \mathcal{A}_3 A 3 . Upon receiving op t e l \operatorname{op}_{\mathrm{tel}} op tel , it runs Sim 2 \operatorname{Sim}_2 Sim 2 on ( ℓ + 1 , op t e l ) (\ell+1,\operatorname{op}_{\mathrm{tel}}) ( ℓ + 1 , op tel ) . On rejection it returns ⊥ \perp ⊥ . Otherwise it measures ( V 1 , V 2 ) (V_1,V_2) ( V 1 , V 2 ) using M [ f ℓ + 1 ′ , U t e l ] M[f'_{\ell+1},U_{\mathrm{tel}}] M [ f ℓ + 1 ′ , U tel ] , sends the resulting ( a , b ) (a,b) ( a , b ) to A 3 \mathcal{A}_3 A 3 , and outputs its final state.
ϵ ∗ \epsilon^* ϵ ∗ -indistinguishability of the above simulator follows from the ϵ ∗ \epsilon^* ϵ ∗ -indistinguishability of the underlying simulator ( Sim 1 , Sim 2 ) (\operatorname{Sim}_1,\operatorname{Sim}_2) ( Sim 1 , Sim 2 ) from the real experiment and the equivalence of ( Sim 1 ′ , Sim 2 ′ , Sim 3 ′ ) (\operatorname{Sim}'_1,\operatorname{Sim}'_2,\operatorname{Sim}'_3) ( Sim 1 ′ , Sim 2 ′ , Sim 3 ′ ) to ( Sim 1 , Sim 2 , Sim 3 ) (\operatorname{Sim}_1,\operatorname{Sim}_2,\operatorname{Sim}_3) ( Sim 1 , Sim 2 , Sim 3 ) with their respective ideal functionalities.
□ \square □
State-Preserving 2PC for General Quantum Functions
In this section, we combine the tools we have developed to obtain our general 2PC for quantum functionalities. We abstract out a way to verifiably commit to a history state in
Section 7. Once we have this primitive, it is possible to verify any public computation. We show how to do so while also combining it with quantum fully homomorphic encryption for privacy in § 6.2 .
Certified Commitment to History States
In this section we show how to commit to a history state (as defined in § 3.2 ), prove that indeed the state committed to is a history state, in a state-preserving manner, and later open the commitment.
Admissible opening requests. Recall that the continual-binding guarantee (Definition 20) is selective; namely, it is parameterized by a polynomial-size family S = { ( U i , f i ) } i ∈ [ q ] S = \{(U_i, f_i)\}_{i \in[q]} S = {( U i , f i ) } i ∈ [ q ] , fixed before the commitment phase, where each U i U_i U i belongs to the family of unitaries supported by the commitment scheme, and each f i f_i f i is a constant-degree function. During the opening phase of our commitment, P C P_C P C may adaptively invoke any ( U i , f i ) ∈ S (U_i, f_i) \in S ( U i , f i ) ∈ S , with repetitions.
Ideal Experiment. In the ideal experiment the adversary takes as input ( C , ∣ ψ ⟩ ) (C, \lvert\psi\rangle) ( C , ∣ ψ ⟩) , where C C C is a classical description of a quantum circuit and ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ is an input to C C C . The ideal functionality, denoted by IF, is given only C C C .
Commitment. The adversary sends a register V \mathcal{V} V to IF. Denote by H H i s t H_{\mathrm{Hist}} H Hist the Hamiltonian defined in Theorem 2. Let G G G be the projector onto the kernel of H H i s t ( C ) H_{\mathrm{Hist}}(C) H Hist ( C ) , namely
G = Π ker H H i s t ( C ) . G = \Pi_{\ker H_{\mathrm{Hist}}(C)}. G = Π k e r H Hist ( C ) .
Certify. IF checks that V \mathcal{V} V is a history state corresponding to the circuit C C C by projecting V \mathcal{V} V onto { G , I − G } \{G, I-G\} { G , I − G } (see Corollary 4). If it projects onto G G G then set b H i s t = 1 b_{\mathrm{Hist}} = 1 b Hist = 1 and otherwise set b H i s t = 0 b_{\mathrm{Hist}} = 0 b Hist = 0 . In either case, the functionality stores the post-measurement register V \mathcal{V} V and the bit b H i s t b_{\mathrm{Hist}} b Hist .
Adversarial abort. The adversary sends a bit a ∈ { 0 , 1 } a \in\{0, 1\} a ∈ { 0 , 1 } to IF, where a = 0 a = 0 a = 0 indicates abort and a = 1 a = 1 a = 1 is an indication to continue. If a = 0 a = 0 a = 0 , then IF sends 0 to both parties and terminates. Otherwise, IF sends b H i s t b_{\mathrm{Hist}} b Hist to both parties. If b H i s t = 0 b_{\mathrm{Hist}} = 0 b Hist = 0 , it terminates; if b H i s t = 1 b_{\mathrm{Hist}} = 1 b Hist = 1 , it proceeds to the opening phase.
Opening phase (repeated polynomially many times). P C P_C P C sends an opening request of the form ( U i , f i ) ∈ S (U_i, f_i) \in S ( U i , f i ) ∈ S , where ( U i , f i ) (U_i, f_i) ( U i , f i ) are public and are sent to P Q P_Q P Q . P Q P_Q P Q sends a bit indicating an abort or a continue request, and if it does not abort then IF applies M [ f i , U i ] M[f_i, U_i] M [ f i , U i ] on register V \mathcal{V} V , sends the outcome to P C P_C P C , and retains the post-measurement residual state as the new V \mathcal{V} V .
5. Recover. On a recovery request from P C P_C P C , the functionality requests a bit a r e c ∈ { 0 , 1 } a_{\mathrm{rec}} \in\{0,1\} a rec ∈ { 0 , 1 } from P Q P_Q P Q . If a r e c = 0 a_{\mathrm{rec}} = 0 a rec = 0 , it sends ⊥ \perp ⊥ to P C P_C P C and terminates. Otherwise, it sends the current residual register V \mathcal{V} V to P Q P_Q P Q and terminates.33
We denote this ideal experiment, with an an honest classical party with input { ( U i , f i ) } \{(U_i,f_i)\} {( U i , f i )} and adversarial quantum party Sim \operatorname{Sim} Sim , with input ( C , ∣ ψ ⟩ ) (C,\lvert\psi\rangle) ( C , ∣ ψ ⟩) , by
Ideal Sim ( C , ∣ ψ ⟩ , { ( U i , f i ) } ) . \operatorname{Ideal}_{\operatorname{Sim}}(C,\lvert\psi\rangle,\{(U_i,f_i)\}). Ideal Sim ( C , ∣ ψ ⟩ , {( U i , f i )}) .
We realize this ideal functionality via a 3-phase protocol
Π H i s t C o m = ( C e r t C o m , O p e n , R e c o v e r ) \Pi_{\mathrm{HistCom}} = (\mathrm{CertCom},\mathrm{Open},\mathrm{Recover}) Π HistCom = ( CertCom , Open , Recover )
where
CertCom implements Steps 1–3,
O p e n ( U , f ) \mathrm{Open}(U,f) Open ( U , f ) implements Step 4 and may be invoked polynomially many times,
Recover is invoked at most once and implements Step 5.
These protocols make use of the following ingredients:
( C o m , E v a l , K e y E v a l , D e c , V e r , R e c o v e r ) (\mathrm{Com},\mathrm{Eval},\mathrm{KeyEval},\mathrm{Dec},\mathrm{Ver},\mathrm{Recover}) ( Com , Eval , KeyEval , Dec , Ver , Recover )
with the following properties:
– Dec can be implemented via a constant-degree computation with post-processed abort.
– The continual-binding simulator is query-preserving.
We note that the commitment scheme from Construction 2 satisfies these properties (see proof of Theorem 14).
Our Recover protocol is the same Recover protocol from the underlying commitment scheme, which can also be adapted to partial recovery. We define the protocols CertCom and Open in § 6.1.1 and § 6.1.2 , respectively. We provide the security analysis in § 6.1.3 .
Protocol CertCom
In what follows, we construct the protocol CertCom that implements Steps 1–3 in the ideal experiment above.
Protocol 3. The quantum party P Q P_{\mathrm{Q}} P Q takes as input ( C , ∣ ψ ⟩ , 1 λ ) (C, \lvert\psi\rangle,1^{\lambda}) ( C , ∣ ψ ⟩ , 1 λ ) , where C C C is a classical description of a poly ( λ ) \operatorname{poly}(\lambda) poly ( λ ) -size quantum circuit over gates in G X Z \mathcal{G}_{XZ} G X Z , and λ \lambda λ is the security parameter. The classical party P C P_{\mathrm{C}} P C takes as input only ( C , 1 λ , 1 n ) (C,1^{\lambda},1^{n}) ( C , 1 λ , 1 n ) , where n n n is the number of qubits in the history state Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) \operatorname{Hist}_{C}(\lvert\psi\rangle\otimes\lvert0^{a}\rangle) Hist C (∣ ψ ⟩ ⊗ ∣ 0 a ⟩) .
P Q P_{\mathrm{Q}} P Q computes the history state corresponding to running C C C on ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ \lvert\psi\rangle\otimes\lvert0^{a}\rangle ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ . Denote this state by Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) \operatorname{Hist}_{C}(\lvert\psi\rangle\otimes\lvert0^{a}\rangle) Hist C (∣ ψ ⟩ ⊗ ∣ 0 a ⟩) .
P Q P_{\mathrm{Q}} P Q and P C P_{\mathrm{C}} P C execute protocol Com on input ( 1 λ , 1 n ) (1^{\lambda},1^{n}) ( 1 λ , 1 n ) , and P Q P_{\mathrm{Q}} P Q takes as additional input the history state Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 a ⟩ ) \operatorname{Hist}_{C}(\lvert\psi\rangle\otimes\lvert0^{a}\rangle) Hist C (∣ ψ ⟩ ⊗ ∣ 0 a ⟩) . Denote the output of P C P_{\mathrm{C}} P C by c o m \mathsf{com} com and the output of P Q P_{\mathrm{Q}} P Q by R o p \mathcal{R}_{\mathrm{op}} R op .
P Q P_{\mathrm{Q}} P Q proves to P C P_{\mathrm{C}} P C that it committed to a history state, by running the repeated history state test from Theorem 3 (§ 3.2 ). This is done by repeating the following sub-protocol r = M ⋅ ( T + 1 ) 2 ⋅ λ r=M\cdot(T+1)^2\cdot\lambda r = M ⋅ ( T + 1 ) 2 ⋅ λ times, where M M M is the number of local Hamiltonians in the history state Hamiltonian H Hist ( C ) = ∑ j = 1 M Π C , j H_{\operatorname{Hist}}(C)=\sum_{j=1}^{M}\Pi_{C,j} H Hist ( C ) = ∑ j = 1 M Π C , j (Theorem 2), and T T T is the number of gates in the circuit C C C .
(a) P C P_{\mathrm{C}} P C samples j ← [ M ] j\leftarrow[M] j ← [ M ] uniformly at random, and sends j j j to P Q P_{\mathrm{Q}} P Q . Let U j = H θ j U_j=H^{\theta_j} U j = H θ j as defined in Theorem 2.34
(b) P Q P_{\mathrm{Q}} P Q computes U ~ j ← Eval ( U j ) \widetilde{U}_j\leftarrow\operatorname{Eval}(U_j) U j ← Eval ( U j ) and applies U ~ j \widetilde{U}_j U j to its R o p \mathcal{R}_{\mathrm{op}} R op register.
(c) P C P_{\mathrm{C}} P C computes c o m U j ← KeyEval ( c o m , U j ) \mathsf{com}_{U_j}\leftarrow\operatorname{KeyEval}(\mathsf{com},U_j) com U j ← KeyEval ( com , U j ) .
(d) P C P_{\mathrm{C}} P C and P Q P_{\mathrm{Q}} P Q run a state-preserving classical 2PC, where P Q P_{\mathrm{Q}} P Q takes as input register R o p \mathcal{R}_{\mathrm{op}} R op , P C P_{\mathrm{C}} P C takes as input c o m U j \mathsf{com}_{U_j} com U j , and P C P_{\mathrm{C}} P C obtains the output of the computation
F j ( c o m U j , o p ) : = ( Ver c o m U j ( o p ) , ( g j ∘ Dec c o m U j ) ( o p ) ) F_j(\mathsf{com}_{U_j},\mathsf{op}) := \left(\operatorname{Ver}_{\mathsf{com}_{U_j}}(\mathsf{op}), (g_j\circ\operatorname{Dec}_{\mathsf{com}_{U_j}})(\mathsf{op})\right) F j ( com U j , op ) := ( Ver com U j ( op ) , ( g j ∘ Dec com U j ) ( op ) )
where o p \mathsf{op} op is the value in register R o p \mathcal{R}_{\mathrm{op}} R op , and g j g_j g j is defined in Equation (1) in Theorem 2 (§ 3.2 ). Note that g j ∘ Dec c o m U j g_j\circ\operatorname{Dec}_{\mathsf{com}_{U_j}} g j ∘ Dec com U j is constant degree because g j g_j g j is constant degree and Dec c o m U j \operatorname{Dec}_{\mathsf{com}_{U_j}} Dec com U j is linear. P C P_{\mathrm{C}} P C outputs b = 1 b=1 b = 1 if Ver c o m U j ( o p ) = ⊥ \operatorname{Ver}_{\mathsf{com}_{U_j}}(\mathsf{op})=\perp Ver com U j ( op ) =⊥ or if ( g j ∘ Dec c o m U j ) ( o p ) = 1 (g_j\circ\operatorname{Dec}_{\mathsf{com}_{U_j}})(\mathsf{op})=1 ( g j ∘ Dec com U j ) ( op ) = 1 . Namely, b b b is the rejection bit and that the residual state is released only when b = 0 b=0 b = 0 .
(e) If b = 1 b=1 b = 1 then P C P_{\mathrm{C}} P C aborts and both parties output reject.
(f) P Q P_{\mathrm{Q}} P Q applies U ~ j † \widetilde{U}_j^{\dagger} U j † to R o p \mathcal{R}_{\mathrm{op}} R op .
P C P_{\mathrm{C}} P C outputs c o m \mathsf{com} com and P Q P_{\mathrm{Q}} P Q outputs R o p \mathcal{R}_{\mathrm{op}} R op .
Protocol Open(U , f U,f U , f )
We next describe the protocol Open. In this protocol, P Q P_Q P Q takes as input a state R o p \mathcal{R}_{\mathrm{op}} R op and P C P_C P C takes as input com, corresponding to an output of the commitment protocol Com. They both take as an additional input a pair ( U , f ) (U,f) ( U , f ) , where U U U is a unitary that acts on the committed register and f f f is a constant degree polynomial.
Protocol 4. The protocol proceeds as follows.
P Q P_Q P Q computes U ~ ← Eval ( U ) \widetilde{U} \leftarrow\operatorname{Eval}(U) U ← Eval ( U ) , and applies U ~ \widetilde{U} U to R o p \mathcal{R}_{\mathrm{op}} R op .
P C P_C P C computes c o m U ← KeyEval ( c o m , U ) \mathrm{com}_U \leftarrow\operatorname{KeyEval}(\mathrm{com},U) com U ← KeyEval ( com , U ) .
The parties execute the state-preserving classical 2PC from § 4.1 for the following functionality:
F f , U ( c o m U , o p ) : = ( Ver c o m U ( o p ) , ( f ( Dec c o m U ( o p ) ) ) ) , F_{f,U}(\mathrm{com}_U,\mathrm{op}) := \left(\operatorname{Ver}_{\mathrm{com}_U}(\mathrm{op}),\left(f\left(\operatorname{Dec}_{\mathrm{com}_U}(\mathrm{op})\right)\right)\right), F f , U ( com U , op ) := ( Ver com U ( op ) , ( f ( Dec com U ( op ) ) ) ) ,
where P Q P_Q P Q supplies the contents op of R o p \mathcal{R}_{\mathrm{op}} R op , and P C P_C P C supplies c o m U \mathrm{com}_U com U .35
The post-processed abort predicate releases the residual quantum state to P Q P_Q P Q if and only if Ver c o m U ( o p ) = ⊤ \operatorname{Ver}_{\mathrm{com}_U}(\mathrm{op})=\top Ver com U ( op ) = ⊤ .
If the 2PC aborts or Ver c o m U ( o p ) = ⊥ \operatorname{Ver}_{\mathrm{com}_U}(\mathrm{op})=\bot Ver com U ( op ) = ⊥ , then P C P_C P C outputs ⊥ \bot ⊥ and the protocol terminates.
Otherwise, let y = f ( Dec c o m U ( o p ) ) y=f(\operatorname{Dec}_{\mathrm{com}_U}(\mathrm{op})) y = f ( Dec com U ( op )) be the value obtained by P C P_C P C . Party P Q P_Q P Q applies U ~ † \widetilde{U}^{\dagger} U † to the residual register R o p \mathcal{R}_{\mathrm{op}} R op .
Party P C P_C P C outputs y y y , while P Q P_Q P Q retains the resulting state R o p \mathcal{R}_{\mathrm{op}} R op .
Analysis
In this section we prove the security of the protocol
Π H i s t C o m = ( C e r t C o m , O p e n , R e c o v e r ) . \Pi_{\mathrm{HistCom}}=(\mathrm{CertCom},\mathrm{Open},\mathrm{Recover}). Π HistCom = ( CertCom , Open , Recover ) .
We focus on the case of full recovery, but the same proof also shows partial recovery when Recover is replaced by its partial recovery counterpart from the underlying commitment scheme.
Theorem 16. There exists a uniform sequence of QPT oracle circuits { S i m λ , n } λ , n ∈ N \{\mathrm{Sim}_{\lambda,n}\}_{\lambda,n\in\mathbb{N}} { Sim λ , n } λ , n ∈ N such that for every QPT malicious quantum party P Q P_Q P Q in protocol Π H i s t C o m \Pi_{\mathrm{HistCom}} Π HistCom , every input ( C , ∣ ψ ⟩ , ( U i , f i ) i ∈ [ ℓ ] ) (C,\lvert\psi\rangle,(U_i,f_i)_{i\in[\ell]}) ( C , ∣ ψ ⟩ , ( U i , f i ) i ∈ [ ℓ ] ) , every sufficiently large λ ∈ N \lambda\in\mathbb{N} λ ∈ N and every n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) ,
Real P Q Π H i s t C o m ( C , ∣ ψ ⟩ , ( U i , f i ) i ∈ [ ℓ ] , 1 λ ) ≈ 1 / n Ideal S i m H i s t C o m ( C , ∣ ψ ⟩ , ( U i , f i ) i ∈ [ ℓ ] , 1 λ ) . \operatorname{Real}^{\Pi_{\mathrm{HistCom}}}_{P_Q}\left(C,\lvert\psi\rangle,(U_i,f_i)_{i\in[\ell]},1^\lambda\right)\approx_{1/n}\operatorname{Ideal}^{\mathrm{Sim}_{\mathrm{HistCom}}}\left(C,\lvert\psi\rangle,(U_i,f_i)_{i\in[\ell]},1^\lambda\right). Real P Q Π HistCom ( C , ∣ ψ ⟩ , ( U i , f i ) i ∈ [ ℓ ] , 1 λ ) ≈ 1/ n Ideal Sim HistCom ( C , ∣ ψ ⟩ , ( U i , f i ) i ∈ [ ℓ ] , 1 λ ) .
We prove Theorem 16 by defining for any fixed P Q ∗ P_{\mathrm{Q}}^* P Q ∗ , λ \lambda λ , and n n n , a simulator S i m H i s t C o m \mathrm{Sim}_{\mathrm{HistCom}} Sim HistCom composed of three simulators:
S i m H i s t C o m = ( S i m C e r t , S i m O p e n , S i m R e c o v e r ) \mathrm{Sim}_{\mathrm{HistCom}} = (\mathrm{Sim}_{\mathrm{Cert}}, \mathrm{Sim}_{\mathrm{Open}}, \mathrm{Sim}_{\mathrm{Recover}}) Sim HistCom = ( Sim Cert , Sim Open , Sim Recover )
with the following interfaces. We suppress the dependence on λ \lambda λ and n n n to ease notational density and explicitly mention them where they are directly relevant.
S i m C e r t ( C , ∣ ψ ⟩ ) \mathrm{Sim}_{\mathrm{Cert}}(C, \lvert\psi\rangle) Sim Cert ( C , ∣ ψ ⟩) emulates the communication in CertCom and outputs an ideal register V \mathcal{V} V , a private simulator state τ \tau τ , and the certification outcome b H i s t b_{\mathrm{Hist}} b Hist .
S i m O p e n ( U , f ; V , τ ) \mathrm{Sim}_{\mathrm{Open}}(U, f; \mathcal{V}, \tau) Sim Open ( U , f ; V , τ ) emulates the communication in one invocation of Open( U , f ) (U, f) ( U , f ) , given oracle access to the ideal functionality that takes as input ( U , f ) (U, f) ( U , f ) from P C P_{\mathrm{C}} P C and from a register V \mathcal{V} V from S i m O p e n \mathrm{Sim}_{\mathrm{Open}} Sim Open . It also receives a bit a ∈ { 0 , 1 } a \in\{0,1\} a ∈ { 0 , 1 } from S i m O p e n \mathrm{Sim}_{\mathrm{Open}} Sim Open , where a = 1 a = 1 a = 1 indicates abort. If a = 1 a = 1 a = 1 the ideal functionality outputs ⊥ \bot ⊥ . Otherwise, it performs the ideal measurement
( y , V ′ ) ← M [ f , U ] ( V ) , (y,\mathcal{V}') \leftarrow M[f,U](\mathcal{V}), ( y , V ′ ) ← M [ f , U ] ( V ) ,
and sends y y y to P C P_{\mathrm{C}} P C , and sends the updated post-measurement ideal register V ′ \mathcal{V}' V ′ to S i m O p e n \mathrm{Sim}_{\mathrm{Open}} Sim Open , who outputs V ′ \mathcal{V}' V ′ together with a private auxiliary state τ ′ \tau' τ ′ .
S i m R e c o v e r ( V ′ , τ ′ ) \mathrm{Sim}_{\mathrm{Recover}}(\mathcal{V}',\tau') Sim Recover ( V ′ , τ ′ ) emulates Recover using the current ideal register V ′ \mathcal{V}' V ′ and the current simulator state τ ′ \tau' τ ′ , and terminates the certified-history execution.
We prove that for every polynomial-size admissible opening family and every polynomial-length adaptively chosen sequence of opening requests, followed by at most one recovery request, the execution obtained by invoking these simulators sequentially, always passing the updated pair ( V , τ ) (\mathcal{V},\tau) ( V , τ ) from one invocation to the next, is computationally indistinguishable from the corresponding real execution. More formally, the proof of Theorem 16 relies on Theorem 17 and Theorem 18, stated and proved in Section 7.3.1 and Section 7.3.2, respectively.
Security of CertCom
Theorem 17. For every QPT adversary P Q ∗ P_{\mathrm{Q}}^* P Q ∗ in Protocol 3 there exists a uniform family of QPT simulators { S i m C e r t , n } n ∈ N \{\mathrm{Sim}_{\mathrm{Cert},n}\}_{n\in\mathbb{N}} { Sim Cert , n } n ∈ N 36 in the ideal experiment, such that
Real P Q ∗ C e r t C o m ( C , ∣ ψ ⟩ , 1 λ ) ≈ 1 / n Ideal S i m C e r t C e r t C o m ( C , ∣ ψ ⟩ ) . \operatorname{Real}_{P_{\mathrm{Q}}^*}^{\mathrm{CertCom}}(C,\lvert\psi\rangle,1^\lambda) \approx_{1/n} \operatorname{Ideal}_{\mathrm{Sim}_{\mathrm{Cert}}}^{\mathrm{CertCom}}(C,\lvert\psi\rangle). Real P Q ∗ CertCom ( C , ∣ ψ ⟩ , 1 λ ) ≈ 1/ n Ideal Sim Cert CertCom ( C , ∣ ψ ⟩) . where Ideal S i m C e r t C e r t C o m ( C , ∣ ψ ⟩ ) \operatorname{Ideal}_{\mathrm{Sim}_{\mathrm{Cert}}}^{\mathrm{CertCom}}(C,\lvert\psi\rangle) Ideal Sim Cert CertCom ( C , ∣ ψ ⟩) is the output of the simulator S i m C e r t \mathrm{Sim}_{\mathrm{Cert}} Sim Cert that only executes Steps 1-3 of the ideal experiment.
Proof. Fix a QPT adversary P Q ∗ P_{\mathrm{Q}}^* P Q ∗ , and as above, let
H H i s t ( C ) = ∑ j = 1 M Π C , j , G : = Π ker H H i s t ( C ) . H_{\mathrm{Hist}}(C)=\sum_{j=1}^{M}\Pi_{C,j},\qquad G:=\Pi_{\ker H_{\mathrm{Hist}}(C)}. H Hist ( C ) = j = 1 ∑ M Π C , j , G := Π k e r H Hist ( C ) .
By Theorem 2,
H H i s t ( C ) ⪰ γ ( I − G ) , γ : = c ( T + 1 ) 2 . H_{\mathrm{Hist}}(C)\succeq\gamma(I-G),\qquad\gamma:=\frac{c}{(T+1)^2}. H Hist ( C ) ⪰ γ ( I − G ) , γ := ( T + 1 ) 2 c .
Set
ε : = ( 1 − γ M ) r ≤ e − γ r / M . \varepsilon:=\left(1-\frac{\gamma}{M}\right)^r\leq e^{-\gamma r/M}. ε := ( 1 − M γ ) r ≤ e − γ r / M .
The fact that r = M ( T + 1 ) 2 λ r=M(T+1)^2\lambda r = M ( T + 1 ) 2 λ implies that ε ≤ e − c λ = negl ( λ ) \varepsilon\leq e^{-c\lambda}=\operatorname{negl}(\lambda) ε ≤ e − c λ = negl ( λ ) . Fix an n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) and set η = 2 r n \eta=2rn η = 2 r n .
The proof proceeds through the following hybrids.
Hybrid H0 _0 0 . This is the real execution of Protocol 3 with P Q ∗ P_{\mathrm{Q}}^* P Q ∗ .
Hybrid H1 _1 1 : idealizing the 2PC executions. Replace each of the r r r state-preserving 2PC executions by 1 / η 1/\eta 1/ η -simulated transcripts using calls to the ideal functionality. For the j j j ’th test, the functionality measures the
F j ( com U j , op ) = ( Ver com U j , ( g j ∘ Dec com U j ) ( op ) ) , F_j(\operatorname{com}_{U_j},\operatorname{op})=\left(\operatorname{Ver}_{\operatorname{com}_{U_j}},(g_j\circ\operatorname{Dec}_{\operatorname{com}_{U_j}})(\operatorname{op})\right), F j ( com U j , op ) = ( Ver com U j , ( g j ∘ Dec com U j ) ( op ) ) ,
and aborts if Ver com U j ( op ) = ⊥ \operatorname{Ver}_{\operatorname{com}_{U_j}}(\operatorname{op})=\bot Ver com U j ( op ) = ⊥ or if ( g j ∘ Dec com U j ) ( op ) = 1 (g_j\circ\operatorname{Dec}_{\operatorname{com}_{U_j}})(\operatorname{op})=1 ( g j ∘ Dec com U j ) ( op ) = 1 . By the 1 / η 1/\eta 1/ η -security of the state-preserving 2PC against a malicious quantum party, and a standard sequential hybrid over the r = poly ( λ ) r=\operatorname{poly}(\lambda) r = poly ( λ ) executions where η = 2 r n \eta=2rn η = 2 r n ,
H 0 ≈ c 1 / ( 2 n ) H 1 . H_0\mathrel{\approx_{\mathrm{c}}^{1/(2n)}}H_1. H 0 ≈ c 1/ ( 2 n ) H 1 .
Hybrid H2 _2 2 : idealizing the commitment. Note that Hybrid H1 _1 1 can be thought of as a real continual-binding-with-recovery experiment (Definition 22), with an adversary that is defined by P Q ∗ P_{\mathrm{Q}}^* P Q ∗ , where the permitted logical measurements are the fixed family
M H i s t = { M [ g j , U j ] } j ∈ [ M ] , U j = H θ j . \mathcal{M}_{\mathrm{Hist}}=\{\mathrm{M}[g_j,U_j]\}_{j\in[M]},\qquad U_j=H^{\theta_j}. M Hist = { M [ g j , U j ] } j ∈ [ M ] , U j = H θ j .
Let
M O p e n : = { M [ f i , U i ] } i ∈ [ q ] , \mathcal{M}_{\mathrm{Open}}:=\{\mathrm{M}[f_i,U_i]\}_{i\in[q]}, M Open := { M [ f i , U i ] } i ∈ [ q ] ,
M a l l : = M H i s t ∪ M O p e n . \mathcal{M}_{\mathrm{all}}:=\mathcal{M}_{\mathrm{Hist}}\cup\mathcal{M}_{\mathrm{Open}}. M all := M Hist ∪ M Open .
H 2 H_2 H 2 instantiates the continual-binding-with-recovery simulator (Definition 22) w.r.t. the entire fixed family M a l l \mathcal{M}_{\mathrm{all}} M all and with indistinguishability parameter 2 n 2n 2 n . During the present CertCom phase, only measurements from M H i s t \mathcal{M}_{\mathrm{Hist}} M Hist are invoked. By Equation (1) ,
U j † ( ∑ z : g j ( z ) = 1 ∣ z ⟩ ⟨ z ∣ ) U j = Π C , j . U_j^\dagger\left( \sum_{z:g_j(z)=1} \lvert z\rangle\langle z\rvert\right) U_j = \Pi_{C,j}. U j † z : g j ( z ) = 1 ∑ ∣ z ⟩ ⟨ z ∣ U j = Π C , j .
By the query-preserving continual ideal binding property (Definition 20), the commitment can therefore be replaced by a single ideal register V \mathcal{V} V , possibly entangled with the adversary’s remaining registers, denoted by E \mathcal{E} E , such that every valid j j j -th query performs the measurement
{ I − Π C , j , Π C , j } \{I-\Pi_{C,j},\Pi_{C,j}\} { I − Π C , j , Π C , j }
on V \mathcal{V} V , while an invalid query causes an abort and induces no operation on V \mathcal{V} V . Hence
H 1 ≈ c 1 / ( 2 n ) H 2 . H_1 \mathrel{\mathop{\approx}\limits_{\mathrm{c}}^{1/(2n)}} H_2. H 1 c ≈ 1/ ( 2 n ) H 2 .
Comparison with the history-state ideal functionality. We next construct the simulator Sim that can subsequently be continued through the protocols Open and Recover. Sim proceeds as follows:
Emulate the entire CertCom protocol using the internally run continual-binding functionality. For each sampled index j j j , the continual-binding functionality performs the measurement
{ I − Π C , j , Π C , j } \{I-\Pi_{C,j},\Pi_{C,j}\} { I − Π C , j , Π C , j } on the current ideal register V \mathcal{V} V . Thus, the simulator reproduces the sequence of sampled indices and the first rejecting test, if one occurs.
Transfer the current private register V \mathcal{V} V from the continual-binding ideal functionality to the history-state ideal functionality, which projects V \mathcal{V} V onto { G , I − G } \{G,I-G\} { G , I − G } . If the emulated CertCom protocol aborts then send a = 0 a=0 a = 0 . Otherwise, send a = 1 a=1 a = 1 .
It remains to show that inserting the measurement { G , I − G } \{G,I-G\} { G , I − G } changes the experiment only negligibly. We argue this separately for the aborting branch and the non-aborting branch.
On the aborting branch (i.e., the branch that eventually rejects), the simulator sends an abort message a = 0 a=0 a = 0 to the ideal functionality. As a result, V \mathcal{V} V is not included in the simulated adversary’s view, and the outcome of the projection { G , I − G } \{G,I-G\} { G , I − G } is ignored on the aborting branch. Hence the measurement { G , I − G } \{G,I-G\} { G , I − G } does not change the output of the experiment.
We next focus on the non-aborting branch. Let ρ V E \rho_{\mathcal{V}\mathcal{E}} ρ V E be the state immediately before the first local test, where V \mathcal{V} V is the ideal committed register and E \mathcal{E} E contains all other registers. Let σ a c c \sigma_{\mathrm{acc}} σ acc denote the resulting subnormalized state on the non-aborting branch,37 and set
δ : = Tr ( ( ( I − G ) ⊗ I E ) σ a c c ) . \delta:= \operatorname{Tr}\left(((I-G)\otimes I_{\mathcal{E}})\sigma_{\mathrm{acc}}\right). δ := Tr ( (( I − G ) ⊗ I E ) σ acc ) .
For a sequence j = ( j 1 , … , j r ) ∈ [ M ] r \mathbf{j}=(j_1,\ldots,j_r)\in[M]^r j = ( j 1 , … , j r ) ∈ [ M ] r , denote by P j i : = I − Π C , j i P_{j_i}:=I-\Pi_{C,j_i} P j i := I − Π C , j i , and let
K j : = P j r ⋯ P j 1 . K_{\mathbf{j}}:=P_{j_r}\cdots P_{j_1}. K j := P j r ⋯ P j 1 .
Note that all operations other than the projections P j i P_{j_i} P j i act only on register E \mathcal{E} E . This follows from the fact that in the continual-binding ideal experiment, after register V \mathcal{V} V is sent to the ideal functionality, the functionality keeps V \mathcal{V} V , and the adversary retains only register E \mathcal{E} E . Moreover, the simulator constructed in the proof of Theorem 14 is query-preserving, in the sense that after the commitment phase, every valid protocol query with index j j j induces exactly one query with the same index to the continual-binding ideal functionality, whereas an invalid query induces no operation on the ideal register V \mathcal{V} V . Consequently, on the non-aborting branch, the only operations on V \mathcal{V} V are P j 1 , … , P j r P_{j_1},\ldots,P_{j_r} P j 1 , … , P j r . Conditioned on this branch, all remaining operations form a positive trace-nonincreasing map acting only on E \mathcal{E} E . Therefore,
δ ≤ E j ← [ M ] r Tr [ ( K j ( I − G ) ⊗ I E ) ρ V E ( ( I − G ) K j † ⊗ I E ) ] = E j ← [ M ] r Tr [ ( K j † ( I − G ) K j ⊗ I E ) ρ V E ] . \begin{aligned}
\delta\leq\mathbb{E}_{\mathbf{j}\leftarrow[M]^r}\operatorname{Tr}\left[\left(K_{\mathbf{j}}(I-G)\otimes I_{\mathcal{E}}\right)\rho_{\mathcal{V}\mathcal{E}}\left((I-G)K_{\mathbf{j}}^\dagger\otimes I_{\mathcal{E}}\right)\right] \\
&=\mathbb{E}_{\mathbf{j}\leftarrow[M]^r}\operatorname{Tr}\left[\left(K_{\mathbf{j}}^\dagger(I-G)K_{\mathbf{j}}\otimes I_{\mathcal{E}}\right)\rho_{\mathcal{V}\mathcal{E}}\right].
\end{aligned} δ ≤ E j ← [ M ] r Tr [ ( K j ( I − G ) ⊗ I E ) ρ V E ( ( I − G ) K j † ⊗ I E ) ] = E j ← [ M ] r Tr [ ( K j † ( I − G ) K j ⊗ I E ) ρ V E ] .
Note that by the definition of P j P_j P j ,
P j ( I − G ) P j = ( I − Π C , j ) ( I − G ) ( I − Π C , j ) = ( I − G ) − Π C , j ( I − G ) − ( I − G ) Π C , j + Π C , j ( I − G ) Π C , j = ( I − G ) − Π C , j − Π C , j + Π C , j 2 = ( I − G ) − Π C , j . \begin{aligned}
P_j(I-G)P_j&=(I-\Pi_{C,j})(I-G)(I-\Pi_{C,j})\\
&=(I-G)-\Pi_{C,j}(I-G)-(I-G)\Pi_{C,j}+\Pi_{C,j}(I-G)\Pi_{C,j}\\
&=(I-G)-\Pi_{C,j}-\Pi_{C,j}+\Pi_{C,j}^{2}\\
&=(I-G)-\Pi_{C,j}.
\end{aligned} P j ( I − G ) P j = ( I − Π C , j ) ( I − G ) ( I − Π C , j ) = ( I − G ) − Π C , j ( I − G ) − ( I − G ) Π C , j + Π C , j ( I − G ) Π C , j = ( I − G ) − Π C , j − Π C , j + Π C , j 2 = ( I − G ) − Π C , j .
This, together with Theorem 2 (§ 3.2 ), implies that
E j ← [ M ] [ P j ( I − G ) P j ] = ( I − G ) − 1 M H H i s t ( C ) \mathbb{E}_{j\leftarrow[M]}\left[P_j(I-G)P_j\right]=(I-G)-\frac{1}{M}H_{\mathrm{Hist}}(\mathcal{C}) E j ← [ M ] [ P j ( I − G ) P j ] = ( I − G ) − M 1 H Hist ( C )
⪯ ( 1 − γ M ) ( I − G ) . \preceq\left(1-\frac{\gamma}{M}\right)(I-G). ⪯ ( 1 − M γ ) ( I − G ) .
where γ : = c ( T + 1 ) 2 \gamma:=\frac{c}{(T+1)^2} γ := ( T + 1 ) 2 c . Iterating this operator inequality gives
E j ← [ M ] r [ K j † ( I − G ) K j ] ⪯ ( 1 − γ M ) r ( I − G ) . \mathbb{E}_{\mathbf{j}\leftarrow[M]^r}\left[K_{\mathbf{j}}^\dagger(I-G)K_{\mathbf{j}}\right]\preceq\left(1-\frac{\gamma}{M}\right)^r(I-G). E j ← [ M ] r [ K j † ( I − G ) K j ] ⪯ ( 1 − M γ ) r ( I − G ) .
Therefore,
δ ≤ ( 1 − γ M ) r Tr ( ( ( I − G ) ⊗ I E ) ρ V E ) ≤ ( 1 − γ M ) r . \delta\leq\left(1-\frac{\gamma}{M}\right)^r\operatorname{Tr}\left(((I-G)\otimes I_{\mathcal{E}})\rho_{\mathcal{V}\mathcal{E}}\right)\leq\left(1-\frac{\gamma}{M}\right)^r. δ ≤ ( 1 − M γ ) r Tr ( (( I − G ) ⊗ I E ) ρ V E ) ≤ ( 1 − M γ ) r .
In Hybrid H 2 H_2 H 2 , all of σ a c c \sigma_{\mathrm{acc}} σ acc is labeled with verifier output 1. After inserting the global measurement, the part G σ a c c G G\sigma_{\mathrm{acc}}G G σ acc G is labeled with verifier output 1, while the part
( I − G ) σ a c c ( I − G ) (I-G)\sigma_{\mathrm{acc}}(I-G) ( I − G ) σ acc ( I − G )
is labeled with verifier output 0. In what follows, we suppress the identity operator on E \mathcal{E} E . By the subnormalized gentle-measurement bound,
∥ σ a c c − G σ a c c G ∥ 1 ≤ 2 Tr ( σ a c c ) Tr ( ( I − G ) σ a c c ) ≤ 2 Tr ( ( I − G ) σ a c c ) = 2 δ . \left\lVert\sigma_{\mathrm{acc}}-G\sigma_{\mathrm{acc}}G\right\rVert_{1}\le2\sqrt{\operatorname{Tr}(\sigma_{\mathrm{acc}})\operatorname{Tr}((I-G)\sigma_{\mathrm{acc}})}\le2\sqrt{\operatorname{Tr}((I-G)\sigma_{\mathrm{acc}})}=2\sqrt{\delta}. ∥ σ acc − G σ acc G ∥ 1 ≤ 2 Tr ( σ acc ) Tr (( I − G ) σ acc ) ≤ 2 Tr (( I − G ) σ acc ) = 2 δ .
Note that the acceptance branch in Hybrid H 2 H_2 H 2 is
ρ H 2 : = ∣ 1 ⟩ ⟨ 1 ∣ ⊗ σ a c c . \rho_{H_2}:=|1\rangle\langle1|\otimes\sigma_{\mathrm{acc}}. ρ H 2 := ∣1 ⟩ ⟨ 1∣ ⊗ σ acc .
The accepted branch in Ideal S i m ( C , ∣ ψ ⟩ ) \operatorname{Ideal}_{\mathrm{Sim}}(C,|\psi\rangle) Ideal Sim ( C , ∣ ψ ⟩) is
ρ I d e a l : = ∣ 1 ⟩ ⟨ 1 ∣ ⊗ G σ a c c G + ∣ 0 ⟩ ⟨ 0 ∣ ⊗ ( I − G ) σ a c c ( I − G ) . \rho_{\mathrm{Ideal}}:=|1\rangle\langle1|\otimes G\sigma_{\mathrm{acc}}G+|0\rangle\langle0|\otimes(I-G)\sigma_{\mathrm{acc}}(I-G). ρ Ideal := ∣1 ⟩ ⟨ 1∣ ⊗ G σ acc G + ∣0 ⟩ ⟨ 0∣ ⊗ ( I − G ) σ acc ( I − G ) .
Therefore, the trace distance is
1 2 ∥ ρ H 2 − ρ I d e a l ∥ 1 = 1 2 ∥ ∣ 1 ⟩ ⟨ 1 ∣ ⊗ σ a c c − ∣ 1 ⟩ ⟨ 1 ∣ ⊗ G σ a c c G − ∣ 0 ⟩ ⟨ 0 ∣ ⊗ ( I − G ) σ a c c ( I − G ) ∥ 1 ≤ 1 2 ∥ σ a c c − G σ a c c G ∥ 1 + 1 2 Tr ( ( I − G ) σ a c c ) ≤ δ + δ 2 , \begin{aligned}
\frac{1}{2}\left\lVert\rho_{H_2}-\rho_{\mathrm{Ideal}}\right\rVert_{1}
&=\frac{1}{2}\left\lVert|1\rangle\langle1|\otimes\sigma_{\mathrm{acc}}-|1\rangle\langle1|\otimes G\sigma_{\mathrm{acc}}G-|0\rangle\langle0|\otimes(I-G)\sigma_{\mathrm{acc}}(I-G)\right\rVert_{1}\\
&\le\frac{1}{2}\left\lVert\sigma_{\mathrm{acc}}-G\sigma_{\mathrm{acc}}G\right\rVert_{1}+\frac{1}{2}\operatorname{Tr}((I-G)\sigma_{\mathrm{acc}})\\
&\le\sqrt{\delta}+\frac{\delta}{2},
\end{aligned} 2 1 ∥ ρ H 2 − ρ Ideal ∥ 1 = 2 1 ∥ ∣1 ⟩ ⟨ 1∣ ⊗ σ acc − ∣1 ⟩ ⟨ 1∣ ⊗ G σ acc G − ∣0 ⟩ ⟨ 0∣ ⊗ ( I − G ) σ acc ( I − G ) ∥ 1 ≤ 2 1 ∥ σ acc − G σ acc G ∥ 1 + 2 1 Tr (( I − G ) σ acc ) ≤ δ + 2 δ ,
which is negligible. Thus
H 2 ≡ s Ideal S i m 1 − 3 ( C , ∣ ψ ⟩ ) . H_2\equiv_s \operatorname{Ideal}_{\mathrm{Sim}}^{1-3}(C,|\psi\rangle). H 2 ≡ s Ideal Sim 1 − 3 ( C , ∣ ψ ⟩) .
as desired. Combining the hybrids gives the claimed result
Real P Q ∗ ( C , ∣ ψ ⟩ , 1 λ ) ≈ 1 / n c Ideal S i m 1 − 3 ( C , ∣ ψ ⟩ , 1 λ ) . \operatorname{Real}_{P_Q^*}(C,|\psi\rangle,1^\lambda)\mathrel{\overset{1/n}{\approx}_{c}}\operatorname{Ideal}_{\mathrm{Sim}}^{1-3}(C,|\psi\rangle,1^\lambda). Real P Q ∗ ( C , ∣ ψ ⟩ , 1 λ ) ≈ 1/ n c Ideal Sim 1 − 3 ( C , ∣ ψ ⟩ , 1 λ ) .
for every n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) .
Security of Open
The hybrid opening protocol. Let Open h y b ( U , f ) \operatorname{Open}^{\mathrm{hyb}}(U,f) Open hyb ( U , f ) denote the protocol obtained from Open ( U , f ) \operatorname{Open}(U,f) Open ( U , f ) by replacing the state-preserving classical 2PC in Step 3 with its ideal functionality. All other steps of the protocol remain unchanged.
Theorem 18 (Security of Open). For every n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) and every QPT malicious quantum party P Q ∗ P_Q^* P Q ∗ , there exists a QPT party P Q H y b P_Q^{\mathrm{Hyb}} P Q Hyb such that for every admissible opening request ( U , f ) (U,f) ( U , f ) , every classical input string c o m \mathrm{com} com , and every quantum input ρ \rho ρ , containing register R o p \mathcal{R}_{\mathrm{op}} R op and auxiliary register E \mathcal{E} E , and thus denoted by ρ R o p E \rho_{\mathcal{R}_{\mathrm{op}}\mathcal{E}} ρ R op E ,
Open P Q ∗ ( U , f ; c o m , ρ R o p E ) ≈ 1 / n c Open P Q H y b H y b ( U , f ; c o m , ρ R o p E ) . \operatorname{Open}_{P_Q^*}(U,f;\mathrm{com},\rho_{\mathcal{R}_{\mathrm{op}}\mathcal{E}})\mathrel{\overset{1/n}{\approx}_{c}}\operatorname{Open}_{P_Q^{\mathrm{Hyb}}}^{\mathrm{Hyb}}(U,f;\mathrm{com},\rho_{\mathcal{R}_{\mathrm{op}}\mathcal{E}}). Open P Q ∗ ( U , f ; com , ρ R op E ) ≈ 1/ n c Open P Q Hyb Hyb ( U , f ; com , ρ R op E ) . In both experiments, P C P_C P C starts with c o m \mathrm{com} com and P Q ∗ P_Q^* P Q ∗ starts with the state ρ R o p E \rho_{\mathcal{R}_{\mathrm{op}}\mathcal{E}} ρ R op E , and both are given ( U , f ) (U,f) ( U , f ) . The experiments output the output of P C P_C P C and the entire final view of P Q ∗ P_Q^* P Q ∗ . The experiment Open executes Protocol 4, whereas O p e n H y b \mathrm{Open}^{\mathrm{Hyb}} Open Hyb is identical except that the state-preserving classical 2PC in Step 3 is replaced by its ideal functionality.
Proof. The two experiments start with the same inputs and differ only in Step 3 of Protocol 4. In Open, the parties execute the real state-preserving classical 2PC, whereas in Open h y b \operatorname{Open}^{\mathrm{hyb}} Open hyb they invoke its ideal functionality with 1 / n 1/n 1/ n simulation. All operations before and after Step 3 are identical.
The claim therefore follows directly from the security of the state-preserving classical 2PC against a malicious quantum party, with E \mathcal{E} E included as part of the auxiliary input and residual state of P Q ∗ P_{\mathsf{Q}}^* P Q ∗ .
Security of the Composed Protocol
We next show how to use Theorem 17 and Theorem 18 to prove Theorem 16.
Proof of Theorem 16 Fix a QPT malicious quantum party P Q ∗ P_{\mathsf{Q}}^* P Q ∗ , and let L = poly ( λ ) L=\operatorname{poly}(\lambda) L = poly ( λ ) be an upper bound on the number of invocations of Open. Set η = L n \eta=Ln η = L n .
For every j ∈ { 0 , … , L } j\in\{0,\ldots,L\} j ∈ { 0 , … , L } , let H j H_j H j denote the execution in which the first j j j invocations of Open are replaced by Open h y b \operatorname{Open}^{\mathrm{hyb}} Open hyb , while all subsequent invocations use the real protocol Open. Thus, H 0 H_0 H 0 is the real execution of Π H i s t C o m \Pi_{\mathsf{HistCom}} Π HistCom . In what follows we prove that
H 0 ≈ 1 / n c H L . (13) H_0 \mathrel{\overset{1/n}{\approx}_{c}} H_L . \tag*{(13)} H 0 ≈ 1/ n c H L . (13)
By a standard hybrid argument, it suffices to prove that for every j ∈ [ L ] j\in[L] j ∈ [ L ] ,
H j − 1 ≈ 1 / η c H j . H_{j-1} \mathrel{\overset{1/\eta}{\approx}_{c}} H_j . H j − 1 ≈ 1/ η c H j .
This follows immediately by Theorem 18 with indistinguishability parameter η \eta η applied to the actual inputs of the two parties immediately before the j j j ’th invocation. The fact that Theorem 18 includes the entire residual state of P Q ∗ P_{\mathsf{Q}}^* P Q ∗ in its output, the remainder of the execution is QPT post-processing. Hence H j − 1 H_{j-1} H j − 1 is computationally 1 / η 1/\eta 1/ η -indistinguishable from H j H_j H j as desired.
It remains to prove that
H L ≈ c I d e a l S i m H i s t C o m . H_L \approx_c \mathsf{Ideal}_{\mathsf{Sim}_{\mathsf{HistCom}}}. H L ≈ c Ideal Sim HistCom .
Recall that the continual-binding-with-recovery simulator was instantiated with respect to
M a l l = M H i s t ∪ M O p e n . \mathcal{M}_{\mathrm{all}}=\mathcal{M}_{\mathrm{Hist}}\cup\mathcal{M}_{\mathrm{Open}}. M all = M Hist ∪ M Open .
Consider an invocation Open h y b ( U i , f i ) \operatorname{Open}^{\mathrm{hyb}}(U_i,f_i) Open hyb ( U i , f i ) . The ideal 2PC invocation evaluates the corresponding decoding query on the current opening register. The simulator Sim O p e n \operatorname{Sim}_{\mathrm{Open}} Sim Open runs the query simulator from the continual-binding with recovery experiment on this query (see Definition 22). If the query simulator rejects, Sim O p e n \operatorname{Sim}_{\mathrm{Open}} Sim Open requests abort, outputs ⊥ \perp ⊥ , and induces no operation on the ideal register V \mathcal{V} V . Otherwise, by query preservation, it forwards the same request ( U i , f i ) (U_i,f_i) ( U i , f i ) to the history-state ideal functionality. The functionality applies
M [ f i , U i ] M[f_i,U_i] M [ f i , U i ]
to its current register V \mathcal{V} V , sends the outcome to P C P_C P C , and retains the post-measurement residual state as the new V \mathcal{V} V .
Thus, every invocation of Open h y b \operatorname{Open}^{\mathrm{hyb}} Open hyb is simulated by Sim O p e n \operatorname{Sim}_{\mathrm{Open}} Sim Open , with all invocations acting on the same evolving ideal register V \mathcal{V} V . Upon a recovery request, the recovery component of the continual-binding-with-recovery simulator receives the final residual register V \mathcal{V} V and emulates Recover \operatorname{Recover} Recover . The CerCom \operatorname{CerCom} CerCom protocol is simulated by Sim c e r t \operatorname{Sim}_{\mathrm{cert}} Sim cert , as established in Theorem 17.
By the continual-binding-with-recovery guarantee (Definition 22), replacing the underlying commitment together with all subsequent opening and recovery queries by this single stateful simulation changes the execution only negligibly. Moreover, inserting the projection { G , I − G } \{G,I-G\} { G , I − G } can only change the experiment by a negligible statistical error, as argued in the proof of Theorem 17. Therefore,
H L ≈ c Ideal SimHistCom . H_L \approx_c \operatorname{Ideal}_{\operatorname{SimHistCom}}. H L ≈ c Ideal SimHistCom .
Combining this with Equation (13) proves the theorem.
State-Preserving 2PC for General Quantum Functions
Next, we give a secure two-party computation protocol which computes any polynomial-time quantum functionality which can be implemented using only real gates. That is, it computes a general quantum circuit G G G which takes as input ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ from the quantum party and input x x x from the classical party, applies a unitary, discards part of the output, measures the classical output, and sends the coherent and classical outputs to the quantum and classical parties, respectively. The 2PC guarantees privacy for both parties: neither party learns any more information other than their part of the output G ( ∣ ψ ⟩ , x ) G(|\psi\rangle,x) G ( ∣ ψ ⟩ , x ) . Moreover, the parties receive the correct outputs (up to computational indistinguishability) or ⊥ \perp ⊥ , regardless of the other party’s behavior.
This allows a classical client to implement any “single-shot” quantum computation on untrusted quantum hardware, including those with randomized or quantum outputs. We show in § 7 how to extend this to maintain persistent quantum memory across executions.
Theorem 19. There exists an ϵ \epsilon ϵ -secure (respectively, secure) semi-quantum 2PC for general real quantum circuits, assuming the following primitives:
A classical commitment to quantum states with ϵ \epsilon ϵ -secure (respectively, secure) continual binding with partial recovery.
An ϵ \epsilon ϵ -secure (respectively, secure) state-preserving 2PC for constant-degree classical functions with classical post-processed abort.
A circuit-private quantum fully-homomorphic encryption scheme.
All of these primitives exist with ϵ \epsilon ϵ -security assuming the post-quantum hardness of LWE.
Construction
In what follows we give a protocol that is secure against a QPT malicious quantum party P Q ∗ P_{\mathrm{Q}}^* P Q ∗ and an honest-but-curious classical party P C P_{\mathrm{C}} P C . Using standard techniques one can upgrade this protocol to make it secure against a malicious poly-size classical party as well. See § 3.9 for more details.
Our protocol makes use of the following ingredients:
A circuit-private quantum fully homomorphic encryption scheme (QFHE)
( G e n Q F H E , Q E n c , Q E v a l , Q D e c ) (\mathrm{Gen}_{\mathrm{QFHE}},\mathrm{QEnc},\mathrm{QEval},\mathrm{QDec}) ( Gen QFHE , QEnc , QEval , QDec ) as defined in § 3.3 . We assume that this QFHE uses as a building block a circuit-private classical FHE scheme
( G e n F H E , E n c , E v a l , D e c ) (\mathrm{Gen}_{\mathrm{FHE}},\mathrm{Enc},\mathrm{Eval},\mathrm{Dec}) ( Gen FHE , Enc , Eval , Dec ) where G e n F H E = G e n Q F H E \mathrm{Gen}_{\mathrm{FHE}}=\mathrm{Gen}_{\mathrm{QFHE}} Gen FHE = Gen QFHE and E n c \mathrm{Enc} Enc is a bit-by-bit encryption, and we assume that QEnc is of the form
Q E n c ( p k , ∣ ψ ⟩ ) = X x Z z ∣ ψ ⟩ , E n c ( p k , ( x , z ) ) . \mathrm{QEnc}(\mathrm{pk},\lvert\psi\rangle)=X^{x}Z^{z}\lvert\psi\rangle,\ \mathrm{Enc}(\mathrm{pk},(x,z)). QEnc ( pk , ∣ ψ ⟩) = X x Z z ∣ ψ ⟩ , Enc ( pk , ( x , z )) . Moreover, we assume that for every quantum circuit C C C that takes as input a state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ and classical input w w w , the state obtained by running Q E v a l ( C , ( ∣ ψ ^ ⟩ , w ^ ) ) \mathrm{QEval}(C,(\lvert\widehat{\psi}\rangle,\widehat{w})) QEval ( C , (∣ ψ ⟩ , w )) , where ∣ ψ ^ ⟩ ← Q E n c ( p k , ∣ ψ ⟩ ) \lvert\widehat{\psi}\rangle\leftarrow\mathrm{QEnc}(\mathrm{pk},\lvert\psi\rangle) ∣ ψ ⟩ ← QEnc ( pk , ∣ ψ ⟩) and w ^ ← Q E n c ( p k , w ) \widehat{w}\leftarrow\mathrm{QEnc}(\mathrm{pk},w) w ← QEnc ( pk , w ) , is of the form
X x Z z C ( ∣ ψ ⟩ , w ) , x ^ , z ^ , X^{x}Z^{z}C(\lvert\psi\rangle,w),\widehat{x},\widehat{z}, X x Z z C (∣ ψ ⟩ , w ) , x , z , where x = D e c ( s k , x ^ ) x=\mathrm{Dec}(\mathrm{sk},\widehat{x}) x = Dec ( sk , x ) and z = D e c ( s k , z ^ ) z=\mathrm{Dec}(\mathrm{sk},\widehat{z}) z = Dec ( sk , z ) .
Protocols ( C e r t C o m , O p e n , R e c o v e r ) (\mathrm{CertCom},\mathrm{Open},\mathrm{Recover}) ( CertCom , Open , Recover ) from § 6.1 , where Recover allows partial recovery. These protocols in turn rely on a classical commitment scheme for quantum states with continual binding with recovery, as defined in § 5.3 (specifically, § 5.4.1 ), and on a state-preserving 2PC for constant-degree classical functions with classical post-processed abort (see § 4.1 ).
Protocol 5. The quantum party P Q P_{\mathrm{Q}} P Q takes as input a quantum state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ , the classical party P C P_{\mathrm{C}} P C takes as input a classical input w ∈ { 0 , 1 } n w\in\{0,1\}^{n} w ∈ { 0 , 1 } n , and their goal is to securely compute G ( ∣ ψ ⟩ , w ) G(\lvert\psi\rangle,w) G (∣ ψ ⟩ , w ) , where G G G is a general quantum circuit.
Let U G U_G U G be the unitary circuit component of G G G and recall that its output may be divided into a coherent output register B \mathcal{B} B , a measured output register C \mathcal{C} C , and a discarded output register D \mathcal{D} D .
Encrypting w w w . P C P_{\mathrm{C}} P C does the following: (a) Sample ( p k , s k ) ← G e n Q F H E ( 1 λ ) (\mathrm{pk},\mathrm{sk})\leftarrow\mathrm{Gen}_{\mathrm{QFHE}}(1^{\lambda}) ( pk , sk ) ← Gen QFHE ( 1 λ ) . (b) Compute w ^ ← Q E n c ( p k , w ) \widehat{w}\leftarrow\mathrm{QEnc}(\mathrm{pk},w) w ← QEnc ( pk , w ) .
(c) Choose random pads x 0 , z 0 ← { 0 , 1 } k x_0, z_0 \leftarrow\{0,1\}^{k} x 0 , z 0 ← { 0 , 1 } k , where k k k is the number of output qubits of U G U_G U G , and compute x ^ 0 , z ^ 0 ← QEnc ( p k , ( x 0 , z 0 ) ) \hat{x}_0, \hat{z}_0 \leftarrow\operatorname{QEnc}(\mathrm{pk},(x_0,z_0)) x ^ 0 , z ^ 0 ← QEnc ( pk , ( x 0 , z 0 )) .
(d) Send ( p k , w ^ , x ^ 0 , z ^ 0 ) (\mathrm{pk},\hat{w},\hat{x}_0,\hat{z}_0) ( pk , w ^ , x ^ 0 , z ^ 0 ) to P Q P_Q P Q .
In what follows we let C = C p k , w ^ , x ^ 0 , z ^ 0 C = C_{\mathrm{pk},\hat{w},\hat{x}_0,\hat{z}_0} C = C pk , w ^ , x ^ 0 , z ^ 0 be the unitary circuit that takes as input a quantum state ∣ ψ ⟩ |\psi\rangle ∣ ψ ⟩ along with ancilla registers ∣ 0 λ ⟩ |0^{\lambda}\rangle ∣ 0 λ ⟩ , and uses the ancilla registers to compute ∣ ψ ^ ⟩ ← QEnc ( p k , ∣ ψ ⟩ ) |\hat{\psi}\rangle\leftarrow\operatorname{QEnc}(\mathrm{pk},|\psi\rangle) ∣ ψ ^ ⟩ ← QEnc ( pk , ∣ ψ ⟩) and compute QEval ( U ~ G , ∣ ψ ^ ⟩ , w ^ , x ^ 0 , z ^ 0 ) \operatorname{QEval}(\widetilde{U}_G,|\hat{\psi}\rangle,\hat{w},\hat{x}_0,\hat{z}_0) QEval ( U G , ∣ ψ ^ ⟩ , w ^ , x ^ 0 , z ^ 0 ) , where
U ~ G ( ∣ ψ ⟩ , w , x 0 , z 0 ) = X x 0 Z z 0 U G ( ∣ ψ ⟩ , w ) . \widetilde{U}_G(|\psi\rangle,w,x_0,z_0) = X^{x_0}Z^{z_0}U_G(|\psi\rangle,w). U G ( ∣ ψ ⟩ , w , x 0 , z 0 ) = X x 0 Z z 0 U G ( ∣ ψ ⟩ , w ) .
If one were to compute C C C on ( ∣ ψ ⟩ , w ^ ) (|\psi\rangle,\hat{w}) ( ∣ ψ ⟩ , w ^ ) and discard the garbage ancillas, then the resulting state would be of the form
X x ⊕ x 0 Z z ⊕ z 0 U G ( ∣ ψ ⟩ , w ) , x ^ , z ^ . X^{x\oplus x_0}Z^{z\oplus z_0}U_G(|\psi\rangle,w),\hat{x},\hat{z}. X x ⊕ x 0 Z z ⊕ z 0 U G ( ∣ ψ ⟩ , w ) , x ^ , z ^ .
where Dec ( s k , x ^ ) = x \operatorname{Dec}(\mathrm{sk},\hat{x})=x Dec ( sk , x ^ ) = x and Dec ( s k , z ^ ) = z \operatorname{Dec}(\mathrm{sk},\hat{z})=z Dec ( sk , z ^ ) = z . We denote the register containing the output ciphertext (and excluding the ancillas) as R o u t \mathcal{R}_{\mathrm{out}} R out . By partitioning the padded state, R o u t \mathcal{R}_{\mathrm{out}} R out may be further subdivided into R o u t = ( B ~ , C ~ , D ~ , P ~ ) \mathcal{R}_{\mathrm{out}}=(\widetilde{B},\widetilde{C},\widetilde{D},\widetilde{P}) R out = ( B , C , D , P ) , the padded registers for coherent output ( B ~ ) (\widetilde{B}) ( B ) , measured output ( C ~ ) (\widetilde{C}) ( C ) , discards ( D ~ ) (\widetilde{D}) ( D ) , and the encrypted pads ( P ~ ) (\widetilde{P}) ( P ) .
We assume without loss of generality that all the gates of C C C are in the set G X , Z \mathcal{G}_{X,Z} G X , Z and denote the number of such gates by T T T . This assumption is without loss of generality since G X , Z \mathcal{G}_{X,Z} G X , Z is universal for real-valued quantum computation. We denote C = U T ⋯ U 1 C=U_T\cdots U_1 C = U T ⋯ U 1 .
Certified commitment to the history state. P Q P_Q P Q and P C P_C P C run protocol CertCom (Protocol 3), where party P Q P_Q P Q takes as input ( C , ∣ ψ ⟩ , 1 λ ) (C,|\psi\rangle,1^{\lambda}) ( C , ∣ ψ ⟩ , 1 λ ) and P C P_C P C takes as input ( C , 1 λ , 1 N ) (C,1^{\lambda},1^N) ( C , 1 λ , 1 N ) , where N N N is the number of qubits in the history state Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 λ ⟩ ) \operatorname{Hist}_C(|\psi\rangle\otimes|0^{\lambda}\rangle) Hist C ( ∣ ψ ⟩ ⊗ ∣ 0 λ ⟩) .
If at the end of CertCom P C P_C P C or P Q P_Q P Q output reject, then this protocol is terminated and the parties output ⊥ \bot ⊥ . Otherwise, at the end of CertCom, P Q P_Q P Q has a register R o p R_{\mathrm{op}} R op , and P C P_C P C has a classical string c o m \mathrm{com} com that is used to decode the openings.
Clock measurement. P Q P_Q P Q and P C P_C P C run the protocol Open ( I , f c l o c k ) \operatorname{Open}(I,f_{\mathrm{clock}}) Open ( I , f clock ) (Protocol 4, § 6.1.2 ) where I I I is the identity unitary and f c l o c k f_{\mathrm{clock}} f clock is the classical function that projects onto the clock register, to obtain an output t t t .
Note that f c l o c k f_{\mathrm{clock}} f clock is a linear function.
If t < T t<T t < T then the parties do the following:
(a) Run the Recover protocol (of the underlying commitment scheme) where P Q P_Q P Q takes as input R o p R_{\mathrm{op}} R op and P C P_C P C takes as input c o m \mathrm{com} com , and they both take as input ( 1 λ , 1 N ) (1^{\lambda},1^N) ( 1 λ , 1 N ) . At the end of this protocol P Q P_Q P Q obtains a state ∣ φ ⟩ |\varphi\rangle ∣ φ ⟩ .
(b) P Q P_Q P Q computes ∣ ψ ⟩ = U 1 † ⋯ U t † ∣ φ ⟩ |\psi\rangle=U_1^{\dagger}\cdots U_t^{\dagger}|\varphi\rangle ∣ ψ ⟩ = U 1 † ⋯ U t † ∣ φ ⟩ .
(c) The parties restart the protocol from Item 2.
This step is repeated at most K : = λ ( T + 1 ) K := \lambda(T + 1) K := λ ( T + 1 ) times, and if t < T t < T t < T for K K K times then the parties output ⊥ \perp ⊥ .
If t = T t = T t = T then P Q P_Q P Q has a commitment to the state
X x ⊕ x 0 Z z ⊕ z 0 U G ( ∣ ψ ⟩ , w ) ⊗ ∣ x ^ ⟩ ⊗ ∣ z ^ ⟩ ⊗ ∣ T ⟩ X^{x\oplus x_0} Z^{z\oplus z_0} U_G(\lvert\psi\rangle,w) \otimes\lvert\hat{x}\rangle\otimes\lvert\hat{z}\rangle\otimes\lvert T\rangle X x ⊕ x 0 Z z ⊕ z 0 U G (∣ ψ ⟩ , w ) ⊗ ∣ x ^ ⟩ ⊗ ∣ z ^ ⟩ ⊗ ∣ T ⟩
together with the ancilla registers from homomorphic evaluation. It continues as follows.
Certified opening of the pad ciphertext. Let f p a d f_{\mathrm{pad}} f pad be the projection onto the subregister P ~ \widetilde{\mathcal{P}} P containing the encrypted pad ( x ^ , z ^ ) (\hat{x},\hat{z}) ( x ^ , z ^ ) .38 The parties run
( x ^ , z ^ ) ← Open ( I , f p a d ) . (\hat{x},\hat{z}) \leftarrow\operatorname{Open}(I,f_{\mathrm{pad}}). ( x ^ , z ^ ) ← Open ( I , f pad ) .
If this invocation outputs ⊥ \perp ⊥ , then both parties output ⊥ \perp ⊥ and terminate. Otherwise, P C P_C P C computes
x = Dec ( s k , x ^ ) and z = Dec ( s k , z ^ ) x = \operatorname{Dec}(\mathsf{sk},\hat{x}) \quad\text{and} \quad z = \operatorname{Dec}(\mathsf{sk},\hat{z}) x = Dec ( sk , x ^ ) and z = Dec ( sk , z ^ )
If decryption fails, then P C P_C P C sends an abort message, both parties output ⊥ \perp ⊥ , and the protocol terminates. If it succeeds, P C P_C P C partitions the pads as
x = ( x B , x C , x D ) x 0 = ( x 0 , B , x 0 , C , x 0 , D ) x = (x_B,x_C,x_D) \qquad x_0 = (x_{0,B},x_{0,C},x_{0,D}) x = ( x B , x C , x D ) x 0 = ( x 0 , B , x 0 , C , x 0 , D )
z = ( z B , z C , z D ) z 0 = ( z 0 , B , z 0 , C , z 0 , D ) z = (z_B,z_C,z_D) \qquad z_0 = (z_{0,B},z_{0,C},z_{0,D}) z = ( z B , z C , z D ) z 0 = ( z 0 , B , z 0 , C , z 0 , D )
Measured Output. P Q P_Q P Q and P C P_C P C execute the protocol Open ( I , f ~ C ~ ) \operatorname{Open}(I,\tilde{f}_{\widetilde{C}}) Open ( I , f ~ C ) (Protocol 4, § 6.1.2 ) where I I I is the identity unitary and f ~ C ~ \tilde{f}_{\widetilde{C}} f ~ C is the function that projects onto the subregister C ~ \widetilde{C} C . Note that f ~ C ~ \tilde{f}_{\widetilde{C}} f ~ C is a linear function. After running this protocol, P C P_C P C obtains the padded measured output
c ~ = c ⊕ x C ⊕ x 0 , C \tilde{c} = c \oplus x_C \oplus x_{0,C} c ~ = c ⊕ x C ⊕ x 0 , C
and P Q P_Q P Q holds a commitment opening to state
X x ⊕ x 0 Z z ⊕ z 0 ∣ ψ c ⟩ B ~ , C ~ , D ~ ⊗ ∣ x ^ , z ^ ⟩ P ~ ⊗ ∣ T ⟩ X^{x\oplus x_0} Z^{z\oplus z_0} \lvert\psi_c\rangle_{\widetilde{B},\widetilde{C},\widetilde{D}} \otimes\lvert\hat{x},\hat{z}\rangle_{\widetilde{\mathcal{P}}} \otimes\lvert T\rangle X x ⊕ x 0 Z z ⊕ z 0 ∣ ψ c ⟩ B , C , D ⊗ ∣ x ^ , z ^ ⟩ P ⊗ ∣ T ⟩
where ∣ ψ c ⟩ \lvert\psi_c\rangle ∣ ψ c ⟩ is the result of U G ( ∣ ψ ⟩ , w ) U_G(\lvert\psi\rangle,w) U G (∣ ψ ⟩ , w ) post-selected for measured output c c c and we have omitted the homomorphic computation garbage ancillas.
Recovery of the Output Ciphertext.
Parties P Q P_Q P Q and P C P_C P C run the partial recovery protocol Recover to recover R o u t \mathcal{R}_{\mathrm{out}} R out , containing the full final evaluated ciphertext and no evaluation workspace. The opened registers C ~ \widetilde{C} C and P ~ \widetilde{\mathcal{P}} P remain part of this recovered ciphertext. In the execution of Recover, P Q P_Q P Q uses input R o p \mathcal{R}_{\mathrm{op}} R op and P C P_C P C uses input c o m \mathsf{com} com .
If Recover aborts, then both parties output ⊥ \perp ⊥ and terminate. Otherwise, P Q P_Q P Q obtains the state
X x ⊕ x 0 Z z ⊕ z 0 ∣ ψ c ⟩ B ~ , C ~ , D ~ ⊗ ∣ x ^ , z ^ ⟩ P ~ X^{x\oplus x_0} Z^{z\oplus z_0} \lvert\psi_c\rangle_{\widetilde{B},\widetilde{C},\widetilde{D}} \otimes\lvert\hat{x},\hat{z}\rangle_{\widetilde{\mathcal{P}}} X x ⊕ x 0 Z z ⊕ z 0 ∣ ψ c ⟩ B , C , D ⊗ ∣ x ^ , z ^ ⟩ P
Output. Party P C P_C P C sends ( x B ⊕ x 0 , B , z B ⊕ z 0 , B ) (x_B \oplus x_{0,B}, z_B \oplus z_{0,B}) ( x B ⊕ x 0 , B , z B ⊕ z 0 , B ) to P Q P_Q P Q . Party P Q P_Q P Q applies the inverse quantum one-time pad ( X x B ⊕ x 0 , B Z z B ⊕ z 0 , B ) † \left(X^{x_B\oplus x_{0,B}} Z^{z_B\oplus z_{0,B}}\right)^\dagger ( X x B ⊕ x 0 , B Z z B ⊕ z 0 , B ) † to register B ~ \widetilde{B} B and outputs the result. Party P C P_C P C outputs c = c ~ ⊕ x C ⊕ x 0 , C c = \widetilde{c} \oplus x_C \oplus x_{0,C} c = c ⊕ x C ⊕ x 0 , C .
Correctness
Theorem 20. Protocol 5 is correct.
Proof. Suppose both parties are honest. As proved in § 6.1.1 , CertCom succeeds with overwhelming probability. The clock marginal of a valid history state is uniform over { 0 , 1 , … , T } \{0,1,\ldots,T\} { 0 , 1 , … , T } . If the measured clock value is t < T t<T t < T , recovery returns the time-t t t state
U t ⋯ U 1 ( ∣ ψ ⟩ ∣ 0 a ⟩ ) U_t \cdots U_1(|\psi\rangle|0^a\rangle) U t ⋯ U 1 ( ∣ ψ ⟩ ∣ 0 a ⟩) Applying U 1 † ⋯ U t † U_1^\dagger\cdots U_t^\dagger U 1 † ⋯ U t † recovers ∣ ψ ⟩ ∣ 0 a ⟩ |\psi\rangle|0^a\rangle ∣ ψ ⟩ ∣ 0 a ⟩ so the parties can restart without changing the input state. Note that the probability that for K = λ ( T + 1 ) K=\lambda(T+1) K = λ ( T + 1 ) attempts, every history-state clock measurement is smaller than T T T is at most
( T T + 1 ) K = ( 1 1 + 1 / T ) K = ( 1 + 1 T ) − K = ( 1 + 1 T ) − λ ( T + 1 ) ≤ e − λ . \left(\frac{T}{T+1}\right)^K
= \left(\frac{1}{1+1/T}\right)^K
= \left(1+\frac{1}{T}\right)^{-K}
= \left(1+\frac{1}{T}\right)^{-\lambda(T+1)}
\le e^{-\lambda}. ( T + 1 T ) K = ( 1 + 1/ T 1 ) K = ( 1 + T 1 ) − K = ( 1 + T 1 ) − λ ( T + 1 ) ≤ e − λ . Thus, we can assume that for one of the executions we get t = T t=T t = T . By QFHE correctness, omitting the homomorphic computation garbage ancillas, the terminal state has the form
X x ⊕ x 0 Z z ⊕ z 0 U G ( ∣ ψ ⟩ , w ) ⊗ ∣ x ^ , z ^ ⟩ P ~ ⊗ ∣ T ⟩ . X^{x\oplus x_0} Z^{z\oplus z_0} U_G(|\psi\rangle,w) \otimes|\widehat{x},\widehat{z}\rangle_{\widetilde{P}} \otimes|T\rangle. X x ⊕ x 0 Z z ⊕ z 0 U G ( ∣ ψ ⟩ , w ) ⊗ ∣ x , z ⟩ P ⊗ ∣ T ⟩ . where x = Dec ( s k , x ^ ) x=\operatorname{Dec}(\mathsf{sk},\widehat{x}) x = Dec ( sk , x ) and z = Dec ( s k , z ^ ) z=\operatorname{Dec}(\mathsf{sk},\widehat{z}) z = Dec ( sk , z ) . The opening f p a d f_{\mathrm{pad}} f pad gives P C P_C P C the ciphertexts ( x ^ , z ^ ) (\widehat{x},\widehat{z}) ( x , z ) , which it decrypts and partitions as in Protocol 5. If the unpadded measured output is c c c , then opening f C ~ f_{\widetilde{C}} f C gives
c ~ = c ⊕ x C ⊕ x 0 , C . \widetilde{c}=c\oplus x_C\oplus x_{0,C}. c = c ⊕ x C ⊕ x 0 , C . The Z Z Z -pad on C ~ \widetilde{C} C contributes only an outcome-dependent global phase. Conditioned on this outcome, the padded quantum state is
X x ⊕ x 0 Z z ⊕ z 0 ∣ ψ c ⟩ B ~ , C ~ , D ~ , X^{x\oplus x_0} Z^{z\oplus z_0} |\psi_c\rangle_{\widetilde{B},\widetilde{C},\widetilde{D}}, X x ⊕ x 0 Z z ⊕ z 0 ∣ ψ c ⟩ B , C , D , where ∣ ψ c ⟩ |\psi_c\rangle ∣ ψ c ⟩ is the post-selected state defined in Protocol 5. Consequently, P C P_C P C outputs
c ~ ⊕ x C ⊕ x 0 , C = c , \widetilde{c}\oplus x_C\oplus x_{0,C}=c, c ⊕ x C ⊕ x 0 , C = c , as desired.
Recovery returns a state negligibly far from
X x ⊕ x 0 Z z ⊕ z 0 ∣ ψ c ⟩ B ~ , C ~ , D ~ ⊗ ∣ x ^ , z ^ ⟩ P ~ . X^{x\oplus x_0} Z^{z\oplus z_0} |\psi_c\rangle_{\widetilde{B},\widetilde{C},\widetilde{D}} \otimes|\widehat{x},\widehat{z}\rangle_{\widetilde{P}}. X x ⊕ x 0 Z z ⊕ z 0 ∣ ψ c ⟩ B , C , D ⊗ ∣ x , z ⟩ P . After receiving ( x B ⊕ x 0 , B , z B ⊕ z 0 , B ) (x_B\oplus x_{0,B}, z_B\oplus z_{0,B}) ( x B ⊕ x 0 , B , z B ⊕ z 0 , B ) , P Q P_Q P Q removes the Pauli pad on B ~ \widetilde{B} B and outputs that register. Its output is therefore negligibly close to the reduced state on B B B of ∣ ψ c ⟩ |\psi_c\rangle ∣ ψ c ⟩ , with C C C and D D D traced out, as prescribed by G G G . Thus the joint output of the parties is negligibly close to the output in the ideal world.
Security Against Malicious Quantum Parties
Theorem 21. There exists a uniform sequence of QPT oracle circuits { Sim λ , n } λ , n ∈ N \{\operatorname{Sim}_{\lambda,n}\}_{\lambda,n\in\mathbb{N}} { Sim λ , n } λ , n ∈ N such that for every QPT adversary P Q ∗ P_Q^* P Q ∗ , every sufficiently large λ ∈ N \lambda\in\mathbb{N} λ ∈ N , and every n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) ,
Real P Q ∗ ( G , ∣ ψ ⟩ , w ) ≈ 1 / n Ideal Sim ( G , ∣ ψ ⟩ , w , n ) \operatorname{Real}_{P_Q^*}(G,\lvert\psi\rangle,w) \overset{1/n}{\approx} \operatorname{Ideal}_{\operatorname{Sim}}(G,\lvert\psi\rangle,w,n) Real P Q ∗ ( G , ∣ ψ ⟩ , w ) ≈ 1/ n Ideal Sim ( G , ∣ ψ ⟩ , w , n ) Proof. Let ξ = ( p k , w ^ , x ^ 0 , z ^ 0 ) \xi=(\mathrm{pk},\widehat{w},\widehat{x}_0,\widehat{z}_0) ξ = ( pk , w , x 0 , z 0 ) be the first message sent by P C P_C P C in the protocol, and let C = C ξ C=C_{\xi} C = C ξ the circuit as defined in Step 1 of Protocol 5. The three opening functions used after the certification step (Step 2) are f c l o c k f_{\mathrm{clock}} f clock , f p a d f_{\mathrm{pad}} f pad , and f C ~ f_{\widetilde{C}} f C , all of which are linear. Here f p a d f_{\mathrm{pad}} f pad projects onto P ~ \widetilde{\mathcal{P}} P , as in Protocol 5. Protocol 5 invokes protocol CertCom, then invokes Open with respect to the identity unitary and these linear functions, and finally invokes Recover.
The Simulator. Fix an arbitrary QPT P Q ∗ P_Q^* P Q ∗ . We use the register partition ( B , C , D ) (\mathcal{B},\mathcal{C},\mathcal{D}) ( B , C , D ) and the corresponding pad components from Protocol 5. The recovered ciphertext includes ( B ~ , C ~ , D ~ , P ~ ) (\widetilde{\mathcal{B}},\widetilde{\mathcal{C}},\widetilde{\mathcal{D}},\widetilde{\mathcal{P}}) ( B , C , D , P ) , while the ideal G G G -functionality returns only B \mathcal{B} B to the simulator.
Let n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) and let η = K n \eta=Kn η = K n . Define the following QPT algorithm Sim n \operatorname{Sim}_n Sim n that on input ( G , ∣ ψ ⟩ ) (G,\lvert\psi\rangle) ( G , ∣ ψ ⟩) does the following:39
Let w ∗ = 0 n w^*=0^n w ∗ = 0 n and emulate P C P_C P C in Step 1 of Protocol 5 using w ∗ w^* w ∗ in place of the unknown input w w w , and encrypting zero pads:
( x ^ 0 , z ^ 0 ) ← QEnc ( p k , ( 0 k , 0 k ) ) . (\widehat{x}_0,\widehat{z}_0)\leftarrow\operatorname{QEnc}(\mathrm{pk},(0^k,0^k)). ( x 0 , z 0 ) ← QEnc ( pk , ( 0 k , 0 k )) .
Independently sample x 0 , z 0 ← { 0 , 1 } k x_0,z_0\leftarrow\{0,1\}^k x 0 , z 0 ← { 0 , 1 } k for use in the simulated terminal ciphertext and final output. Let C = C p k , w ∗ , x ^ 0 , z ^ 0 C=C_{\mathrm{pk},w^*,\widehat{x}_0,\widehat{z}_0} C = C pk , w ∗ , x 0 , z 0 , and store ( s k , x 0 , z 0 ) (\mathrm{sk},x_0,z_0) ( sk , x 0 , z 0 ) .
For each attempt j ∈ [ K ] j\in[K] j ∈ [ K ] , emulate
( CertCom , Open ( I , f c l o c k ) , Recover ) (\operatorname{CertCom},\operatorname{Open}(I,f_{\mathrm{clock}}),\operatorname{Recover}) ( CertCom , Open ( I , f clock ) , Recover )
using the stateful simulator
( Sim C e r t , Sim O p e n , Sim R e c o v e r ) (\operatorname{Sim}_{\mathrm{Cert}},\operatorname{Sim}_{\mathrm{Open}},\operatorname{Sim}_{\mathrm{Recover}}) ( Sim Cert , Sim Open , Sim Recover )
with indistinguishability parameter η = K n \eta=Kn η = K n from Theorem 16, where throughout each attempt the stateful simulator passes the same evolving pair ( V , τ ) (\mathcal{V},\tau) ( V , τ ) from one simulated invocation to the next.
If the clock outcome is t < T t<T t < T and recovery succeeds, continue to the next attempt with the resulting adversarial state. If certification, opening, or recovery aborts, request abort from the ideal functionality and output the simulated view.
If all K K K attempts return a value smaller than T T T , request abort from the ideal functionality and terminate.
Suppose that for the first time the clock outcome is t = T t = T t = T . At this point the clock register has been measured, and the current ideal register V \mathcal{V} V contains a valid terminal state of C \mathcal{C} C . Before either terminal opening, starting with Open ( I , f p a d ) \operatorname{Open}(\mathcal{I}, f_{\mathrm{pad}}) Open ( I , f pad ) , apply C T \mathcal{C}^{\mathsf{T}} C T to the current ideal register V \mathcal{V} V . Since V \mathcal{V} V contains a valid terminal state of C \mathcal{C} C , this produces an effective input register I \mathcal{I} I , possibly entangled with the adversary’s auxiliary register E \mathcal{E} E , together with zero ancillas.
Send I \mathcal{I} I to the ideal functionality. It applies U G ( ⋅ , w ) U_G(\cdot,w) U G ( ⋅ , w ) , measures C \mathcal{C} C to obtain c c c , discards D \mathcal{D} D , and returns only B \mathcal{B} B to Sim. The classical output c c c remains hidden inside the ideal functionality pending the final abort decision.
Append fresh registers C \mathcal{C} C and D \mathcal{D} D , each initialized to an all-zero state of the appropriate size, to the returned register B \mathcal{B} B . Apply X x 0 Z z 0 X^{x_0}Z^{z_0} X x 0 Z z 0 to ( B , C , D ) (\mathcal{B},\mathcal{C},\mathcal{D}) ( B , C , D ) , then apply QEnc ( p k , ⋅ ) \operatorname{QEnc}(\mathrm{pk},\cdot) QEnc ( pk , ⋅ ) followed by QEval ( p k , I , ⋅ ) \operatorname{QEval}(\mathrm{pk},\mathcal{I},\cdot) QEval ( pk , I , ⋅ ) , retaining the resulting Pauli keys ( x , z ) (x,z) ( x , z ) in the clear as in Remark 3 and Theorem 4. Use the resulting ciphertext on ( B ~ , C ~ , D ~ , P ~ ) (\widetilde{\mathcal{B}},\widetilde{\mathcal{C}},\widetilde{\mathcal{D}},\widetilde{\mathcal{P}}) ( B , C , D , P ) as the terminal ciphertext in the current ideal register V \mathcal{V} V .
Emulate Open ( I , f p a d ) \operatorname{Open}(\mathcal{I}, f_{\mathrm{pad}}) Open ( I , f pad ) using Sim O p e n \operatorname{Sim}_{\mathrm{Open}} Sim Open . When the internally emulated classical party would decrypt ( x ^ , z ^ ) (\widehat{x},\widehat{z}) ( x , z ) , use the stored values ( x , z ) (x,z) ( x , z ) instead. If this opening succeeds, emulate Open ( I , f C ~ ) \operatorname{Open}(\mathcal{I}, f_{\widetilde{\mathcal{C}}}) Open ( I , f C ) using Sim O p e n \operatorname{Sim}_{\mathrm{Open}} Sim Open and ignore the outcome delivered to the internally emulated classical party. If it also succeeds, emulate partial recovery of R o u t \mathcal{R}_{\mathrm{out}} R out using Sim R e c o v e r \operatorname{Sim}_{\mathrm{Recover}} Sim Recover . Both measured registers remain in the ciphertext returned by recovery.
If any of the final opening or recovery invocations aborts, send abort to the ideal functionality. Otherwise, send
( x B ⊕ x 0 , B , z B ⊕ z 0 , B ) (x_{\mathcal{B}} \mathbin{\oplus} x_{0,\mathcal{B}}, z_{\mathcal{B}} \mathbin{\oplus} z_{0,\mathcal{B}}) ( x B ⊕ x 0 , B , z B ⊕ z 0 , B )
to P Q ∗ \mathsf{P}^{*}_{\mathsf{Q}} P Q ∗ and send continue to the ideal functionality. The ideal functionality then releases c c c to P C \mathsf{P}_{\mathcal{C}} P C .
We prove security by considering the following hybrids:
Hybrid H 0 H_0 H 0 . This is the real execution of Protocol 5 with P Q ∗ \mathsf{P}^{*}_{\mathsf{Q}} P Q ∗ .
Hybrid H 1 H_1 H 1 : Idealizing Π H i s t C o m \Pi_{\mathrm{HistCom}} Π HistCom . Replace each execution of
( CertCom , Open ( I , f c l o c k ) , Recover ) (\operatorname{CertCom},\operatorname{Open}(\mathcal{I},f_{\mathrm{clock}}),\operatorname{Recover}) ( CertCom , Open ( I , f clock ) , Recover )
where the clock measures t < T t < T t < T , by its simulated execution from Theorem 16. Similarly, replace the final execution of
( CertCom , Open ( I , f c l o c k ) , Open ( I , f p a d ) , Open ( I , f C ~ ) , Recover ) (\operatorname{CertCom},\operatorname{Open}(\mathcal{I},f_{\mathrm{clock}}),\operatorname{Open}(\mathcal{I},f_{\mathrm{pad}}),\operatorname{Open}(\mathcal{I},f_{\widetilde{\mathcal{C}}}),\operatorname{Recover}) ( CertCom , Open ( I , f clock ) , Open ( I , f pad ) , Open ( I , f C ) , Recover )
by its simulated execution from Theorem 16 with indistinguishability parameter η = K n \eta= K n η = K n . Note that the opening family is fixed, every opening function is linear, and there is at most one recovery invocation per attempt. Since there are at most K = poly ( λ ) K = \operatorname{poly}(\lambda) K = poly ( λ ) attempts, sequential composition of Theorem 16 implies that
H 0 ≈ 1 / n H 1 . H_0 \overset{1/n}{\approx} H_1. H 0 ≈ 1/ n H 1 .
Hybrid H 2 H_2 H 2 : Circuit-private simulation of the final ciphertext. Hybrid H 2 H_2 H 2 is identical to H 1 H_1 H 1 , except on a non-aborting branch on which the clock opening returns t = T t = T t = T . In this case, immediately after the simulated clock opening and before either Open ( I , f p a d ) \operatorname{Open}(I, f_{\mathrm{pad}}) Open ( I , f pad ) , Open ( I , f ~ C ) \operatorname{Open}(I, \tilde{f}_{\mathcal{C}}) Open ( I , f ~ C ) opening, the history state commitment ideal functionality register contains a terminal state for C C C , which is supported on pure states of the form
C ( ∣ ψ ⟩ I ⊗ ∣ w ^ , x ^ 0 , z ^ 0 ⟩ ⊗ ∣ 0 a ⟩ A ) . C\left(|\psi\rangle_{\mathcal{I}} \otimes|\hat{w}, \hat{x}_0, \hat{z}_0\rangle\otimes|0^a\rangle_{\mathcal{A}}\right). C ( ∣ ψ ⟩ I ⊗ ∣ w ^ , x ^ 0 , z ^ 0 ⟩ ⊗ ∣ 0 a ⟩ A ) .
where C C C has been applied to an input register I \mathcal{I} I , the encrypted classical inputs and pads, and an ancilla register A \mathcal{A} A . Apply C † C^\dagger C † to this state to obtain the unprocessed input register I \mathcal{I} I . Then, letting U ~ G \tilde{U}_G U ~ G be the padded unitary from Protocol 5, apply U ~ G ( ⋅ , w , x 0 , z 0 ) \tilde{U}_G(\cdot, w, x_0, z_0) U ~ G ( ⋅ , w , x 0 , z 0 ) to I \mathcal{I} I and compute Sim Q F H E \operatorname{Sim}_{\mathrm{QFHE}} Sim QFHE on the result. Substitute the simulated ciphertext into the history state commitment ideal functionality register, then continue with the simulated executions of Open ( I , f p a d ) \operatorname{Open}(I, f_{\mathrm{pad}}) Open ( I , f pad ) , Open ( I , f ~ C ) \operatorname{Open}(I, \tilde{f}_{\mathcal{C}}) Open ( I , f ~ C ) , and partial recovery of the evaluated ciphertext in register R o u t \mathcal{R}_{\mathrm{out}} R out .
Claim 17. H 1 ≈ c H 2 H_1 \approx_{\mathrm{c}} H_2 H 1 ≈ c H 2
Proof. It is equivalent in H 1 H_1 H 1 to consider applying C C † CC^\dagger C C † to the history state commitment ideal functionality register after measuring the clock opening to get result t = T t = T t = T . Additionally, it is equivalent to discard the garbage ancillas from C C C after applying C C † CC^\dagger C C † , since they are not used in future steps (due to being excluded from the partial recovery step).
Let ρ I , E \rho_{\mathcal{I},\mathcal{E}} ρ I , E be the joint state of register I \mathcal{I} I and all retained auxiliary registers E \mathcal{E} E , including the adversary and commitment simulator states, the keys, and the external reference right after applying C † C^\dagger C † . H 1 H_1 H 1 then proceeds by computing
Tr A ′ [ C ρ I E C † ] = ( ( Eval ( p k , U ~ G , ⋅ , w ^ , x ^ 0 , z ^ 0 ) ∘ Enc p k ) ⊗ I E ) ( ρ I E ) \operatorname{Tr}_{\mathcal{A}'}\left[C\rho_{\mathcal{I}\mathcal{E}}C^\dagger\right] = \left(\left(\operatorname{Eval}(\mathrm{pk},\tilde{U}_G,\cdot,\hat{w},\hat{x}_0,\hat{z}_0)\circ\operatorname{Enc}_{\mathrm{pk}}\right)\otimes I_{\mathcal{E}}\right)(\rho_{\mathcal{I}\mathcal{E}}) Tr A ′ [ C ρ I E C † ] = ( ( Eval ( pk , U ~ G , ⋅ , w ^ , x ^ 0 , z ^ 0 ) ∘ Enc pk ) ⊗ I E ) ( ρ I E )
where A ′ \mathcal{A}' A ′ is the traced out garbage ancilla register. In contrast, H 2 H_2 H 2 first computes the plaintext evaluation
σ B C D E : = ( U ~ G ( ⋅ , w , x 0 , z 0 ) ⊗ I E ) ρ I E ( U ~ G ( ⋅ , w , x 0 , z 0 ) † ⊗ I E ) , \sigma_{\mathcal{B}\mathcal{C}\mathcal{D}\mathcal{E}} := \left(\tilde{U}_G(\cdot,w,x_0,z_0)\otimes I_{\mathcal{E}}\right)\rho_{\mathcal{I}\mathcal{E}}\left(\tilde{U}_G(\cdot,w,x_0,z_0)^\dagger\otimes I_{\mathcal{E}}\right), σ BC D E := ( U ~ G ( ⋅ , w , x 0 , z 0 ) ⊗ I E ) ρ I E ( U ~ G ( ⋅ , w , x 0 , z 0 ) † ⊗ I E ) ,
then replaces the contents of the commitment ideal functionality register by
( Sim Q F H E ⊗ I E ) ( p k , σ B C D E ) \left(\operatorname{Sim}_{\mathrm{QFHE}}\otimes I_{\mathcal{E}}\right)(\mathrm{pk},\sigma_{\mathcal{B}\mathcal{C}\mathcal{D}\mathcal{E}}) ( Sim QFHE ⊗ I E ) ( pk , σ BC D E )
After this step, H 1 H_1 H 1 and H 2 H_2 H 2 behave identically. This substitution is indistinguishable by the circuit privacy guarantee for QFHE (Definition 3) in the presence of external entanglement.
Hybrid H 3 H_3 H 3 : Fresh encryption of the simulated plaintext with explicit pads. Hybrid H 3 H_3 H 3 is identical to H 2 H_2 H 2 , except that the output of the QFHE circuit-privacy simulator is replaced by a fresh encryption of the same plaintext, followed by homomorphic evaluation of the identity circuit:
( Sim Q F H E ⊗ I E ) ( p k , σ B C D E ) ⟶ ( QEval ( p k , I ) ⊗ I E ) ( ( QEnc ( p k , ⋅ ) ⊗ I E ) ( σ B C D E ) ) . (\operatorname{Sim}_{\mathrm{QFHE}} \otimes I_{\mathcal{E}})(pk,\sigma_{BCDE}) \longrightarrow(\operatorname{QEval}(pk,I) \otimes I_{\mathcal{E}})((\operatorname{QEnc}(pk,\cdot) \otimes I_{\mathcal{E}})(\sigma_{BCDE})). ( Sim QFHE ⊗ I E ) ( p k , σ B C D E ) ⟶ ( QEval ( p k , I ) ⊗ I E ) (( QEnc ( p k , ⋅ ) ⊗ I E ) ( σ B C D E )) .
Moreover, this is done by retaining the pauli keys x , z x,z x , z in the clear. This can be done efficiently by Remark 3 and Theorem 4. Applying circuit privacy to the identity circuit shows that this change is computationally indistinguishable, jointly with s k \mathsf{sk} sk , E \mathcal{E} E , and all other registers. Crucially, the ancillas used for homomorphic evaluation do not appear in this view as they are held by the commitment ideal functionality. Hence
H 2 ≈ c H 3 . H_2 \approx_{\mathrm{c}} H_3. H 2 ≈ c H 3 .
Hybrid H 4 H_4 H 4 : Encrypting a dummy classical input and dummy pads. Hybrid H 4 H_4 H 4 is identical to H 3 H_3 H 3 , except that the first message contains
w ^ ∗ ← QEnc ( p k , 0 n ) , ( x ^ 0 , z ^ 0 ) ← QEnc ( p k , ( 0 k , 0 k ) ) \widehat{w}^{*} \leftarrow\operatorname{QEnc}(pk,0^{n}), \qquad(\widehat{x}_0,\widehat{z}_0) \leftarrow\operatorname{QEnc}(pk,(0^{k},0^{k})) w ∗ ← QEnc ( p k , 0 n ) , ( x 0 , z 0 ) ← QEnc ( p k , ( 0 k , 0 k ))
in place of encryptions of w w w and ( x 0 , z 0 ) (x_0,z_0) ( x 0 , z 0 ) . The independently sampled original pads x 0 , z 0 x_0,z_0 x 0 , z 0 are retained privately and are still used to prepare the simulated terminal ciphertext and compute the final B \mathcal{B} B sub-pad. Here x ^ 0 , z ^ 0 \widehat{x}_0,\widehat{z}_0 x 0 , z 0 denote the transmitted ciphertexts, which now encrypt zeros.
Write C w C_w C w for the public circuit in H 3 H_3 H 3 and C 0 = C p k , w ^ ∗ , x ^ 0 , z ^ 0 C_0=C_{pk,\widehat{w}^{*},\widehat{x}_0,\widehat{z}_0} C 0 = C p k , w ∗ , x 0 , z 0 for the circuit defined by the dummy first message in H 4 H_4 H 4 . Every certified-history attempt uses C 0 C_0 C 0 . On a terminal branch, after applying C 0 † C_0^\dagger C 0 † to recover the effective input, the hybrid still applies U G ( ⋅ , w ) U_G(\cdot,w) U G ( ⋅ , w ) and the original outer pads x 0 , z 0 x_0,z_0 x 0 , z 0 . Thus the plaintext computation continues to use the honest input w w w and original pads x 0 , z 0 x_0,z_0 x 0 , z 0 .
We claim that
H 3 ≈ c H 4 . H_3 \approx_{\mathrm{c}} H_4. H 3 ≈ c H 4 .
Replace the encryptions of w w w , x 0 x_0 x 0 , and z 0 z_0 z 0 by encryptions of zero in sequence. For each replacement, a semantic-security reduction samples and retains the original pads, places its challenge ciphertext in the corresponding position of the first message, constructs the resulting public circuit, and runs the remaining experiment. All certified-history simulations, inverse-circuit operations, and fresh terminal encryptions are efficient public operations. The reduction uses the retained w , x 0 , z 0 w,x_0,z_0 w , x 0 , z 0 in the plaintext computation, and knows the fresh inner Pauli keys ( x , z ) (x,z) ( x , z ) explicitly, so it does not need s k \mathsf{sk} sk for the terminal pad opening. The decryption-failure branch differs from this use of explicit keys only with negligible probability by correctness. A distinguisher for H 3 H_3 H 3 and H 4 H_4 H 4 would therefore distinguish at least one of these ciphertext replacements, contradicting semantic security.
Hybrid H 5 H_5 H 5 : Measuring the plaintext output. Hybrid H 5 H_5 H 5 is identical to H 4 H_4 H 4 , except that it measures the plaintext register C \mathcal{C} C before preparing the fresh terminal ciphertext. After applying C 0 † C^\dagger_0 C 0 † , let ρ I E \rho_{\mathcal{I}\mathcal{E}} ρ I E denote the recovered effective input and the auxiliary register held by the adversary. Apply U G ( ⋅ , w ) ⊗ I E U_G(\cdot,w)\otimes I_{\mathcal{E}} U G ( ⋅ , w ) ⊗ I E , measure C \mathcal{C} C to obtain c c c , and retain the post-measurement register C \mathcal{C} C in state ∣ c ⟩ |c\rangle ∣ c ⟩ . Let ρ B D E c \rho_{\mathcal{B}\mathcal{D}\mathcal{E}}^c ρ B D E c denote the corresponding conditional state on the other registers. In particular, the discarded-output register D \mathcal{D} D is still present in this hybrid. Store c c c privately as the prospective honest classical output.
Using the pad partition from Protocol 5, prepare
σ B C D E c : = ( X x 0 Z z 0 ⊗ I E ) ( ∣ c ⟩ ⟨ c ∣ C ⊗ ρ B D E c ) ( Z z 0 X x 0 ⊗ I E ) . \sigma^c_{\mathcal{B}\mathcal{C}\mathcal{D}\mathcal{E}} := (X^{x_0}Z^{z_0}\otimes I_{\mathcal{E}})(|c\rangle\langle c|_{\mathcal{C}}\otimes\rho^c_{\mathcal{B}\mathcal{D}\mathcal{E}})(Z^{z_0}X^{x_0}\otimes I_{\mathcal{E}}). σ BC D E c := ( X x 0 Z z 0 ⊗ I E ) ( ∣ c ⟩ ⟨ c ∣ C ⊗ ρ B D E c ) ( Z z 0 X x 0 ⊗ I E ) .
where the Pauli operators act on the named registers ( B , C , D ) (\mathcal{B},\mathcal{C},\mathcal{D}) ( B , C , D ) and leave E \mathcal{E} E untouched. Then prepare the fresh identity-evaluated ciphertext
σ ^ B ~ C ~ D ~ E ~ c : = ( QEval ( p k , I ) ⊗ I E ) ( ( QEnc ( p k , ⋅ ) ⊗ I E ) ( σ B C D E c ) ) . \widehat{\sigma}^c_{\widetilde{\mathcal{B}}\widetilde{\mathcal{C}}\widetilde{\mathcal{D}}\widetilde{\mathcal{E}}} := (\operatorname{QEval}(\mathrm{pk},I)\otimes I_{\mathcal{E}})((\operatorname{QEnc}(\mathrm{pk},\cdot)\otimes I_{\mathcal{E}})(\sigma^c_{\mathcal{B}\mathcal{C}\mathcal{D}\mathcal{E}})). σ B C D E c := ( QEval ( pk , I ) ⊗ I E ) (( QEnc ( pk , ⋅ ) ⊗ I E ) ( σ BC D E c )) .
retaining the inner pads x = ( x B , x C , x D ) x=(x_{\mathcal{B}},x_{\mathcal{C}},x_{\mathcal{D}}) x = ( x B , x C , x D ) and z = ( z B , z C , z D ) z=(z_{\mathcal{B}},z_{\mathcal{C}},z_{\mathcal{D}}) z = ( z B , z C , z D ) explicitly. The register P ~ \widetilde{\mathcal{P}} P contains their classical ciphertexts ( x ~ , z ~ ) (\widetilde{x},\widetilde{z}) ( x , z ) .
Emulate Open ( I , f p a d ) \operatorname{Open}(I,f_{\mathrm{pad}}) Open ( I , f pad ) , then Open ( I , f C ~ ) \operatorname{Open}(I,f_{\widetilde{\mathcal{C}}}) Open ( I , f C ) , and then partial recovery of R o u t \mathcal{R}_{\mathrm{out}} R out , using the retained inner pads in place of decryption. On successful opening of the measured output, its value is
c ~ = c ⊕ x C ⊕ x 0 , C . \widetilde{c}=c\oplus x_{\mathcal{C}}\oplus x_{0,\mathcal{C}}. c = c ⊕ x C ⊕ x 0 , C .
The post-measurement register C ~ \widetilde{\mathcal{C}} C is retained, and recovery returns all four ciphertext registers, including C ~ \widetilde{\mathcal{C}} C and P ~ \widetilde{\mathcal{P}} P . If any invocation aborts, the honest classical party outputs ⊥ \perp ⊥ . Otherwise, send ( x B ⊕ x 0 , B , z B ⊕ z 0 , B ) (x_{\mathcal{B}}\oplus x_{0,\mathcal{B}},z_{\mathcal{B}}\oplus z_{0,\mathcal{B}}) ( x B ⊕ x 0 , B , z B ⊕ z 0 , B ) to P Q ∗ P^*_{\mathsf{Q}} P Q ∗ and output the stored value c c c for the honest classical party. The measured-output opening value is not used in subsequent messages or abort decisions.
Claim 18.
H 4 ≡ s H 5 . H_4 \equiv_s H_5. H 4 ≡ s H 5 .
Proof of Claim 18. In H 4 H_4 H 4 , the experiment freshly encrypts the coherent output of U G ( ⋅ , w ) U_G(\cdot,w) U G ( ⋅ , w ) , opens the inner-pad ciphertexts, and then measures C ~ \widetilde{\mathcal{C}} C . In H 5 H_5 H 5 , it measures the plaintext C \mathcal{C} C first and then prepares the fresh encryption of the resulting post-measurement state, retaining C \mathcal{C} C . By the explicit Pauli form of the ciphertext and QFHE correctness, the two measurement orders give the same outcome relation and post-measurement ciphertext, up to negligible error. The Z Z Z -pad on C \mathcal{C} C contributes only an outcome-dependent global phase, while the X X X -pad changes c c c to c ~ = c ⊕ x C ⊕ x 0 , C \widetilde{c}=c\oplus x_{\mathcal{C}}\oplus x_{0,\mathcal{C}} c = c ⊕ x C ⊕ x 0 , C . The pad opening acts on P ~ \widetilde{\mathcal{P}} P , so it commutes with the measurement of C ~ \widetilde{\mathcal{C}} C . Ideal binding ensures that the two experiments agree jointly on the opened pad ciphertexts, the post-measurement registers ( B ~ , C ~ , D ~ , P ~ ) (\widetilde{\mathcal{B}},\widetilde{\mathcal{C}},\widetilde{\mathcal{D}},\widetilde{\mathcal{P}}) ( B , C , D , P ) , and the auxiliary state. Finally, the classical output in H 4 H_4 H 4 is c ~ ⊕ x C ⊕ x 0 , C = c \widetilde{c}\oplus x_{\mathcal{C}}\oplus x_{0,\mathcal{C}}=c c ⊕ x C ⊕ x 0 , C = c , which is the stored output in H 5 H_5 H 5 .
Hybrid H 6 H_6 H 6 : Replacing the measured and discarded plaintext registers by zeros. Hybrid H 6 H_6 H 6 is identical to H 5 H_5 H 5 , except that after obtaining the private outcome c c c , it discards the genuine registers C \mathcal{C} C and D \mathcal{D} D and replaces them by fresh all-zero registers of the same sizes before preparing the terminal ciphertext.
H 5 ≡ H 6 H_5 \equiv H_6 H 5 ≡ H 6
by the perfect security of the quantum one-time pad. To see this, observe that the only difference between the two hybrids is whether the masked registers C ~ \widetilde{\mathcal{C}} C and D ~ \widetilde{\mathcal{D}} D contain the masked original state or masked ∣ 0 ⟩ \lvert0\rangle ∣ 0 ⟩ states, and the sub-pads ( x 0 , C , x 0 , D ) (x_{0,C},x_{0,D}) ( x 0 , C , x 0 , D ) are not used anywhere else in either hybrid experiment.
Hybrid H 7 H_7 H 7 : Invoking the ideal functionality. Hybrid H 7 H_7 H 7 is identical to H 6 H_6 H 6 , except that the plaintext computation, measurement, and discarding are performed by the ideal G G G -functionality. On the first non-aborting terminal branch, apply C 0 † C_0^\dagger C 0 † and send the recovered effective input register I I I to the ideal functionality. It applies U G ( ⋅ , w ) U_G(\cdot,w) U G ( ⋅ , w ) , measures C \mathcal{C} C to obtain c c c , discards D \mathcal{D} D , and returns only B \mathcal{B} B to the simulator. Conditioned on c c c , the joint state of the returned register and the untouched auxiliary register is ρ B E c \rho^c_{\mathcal{B}\mathcal{E}} ρ B E c . The functionality retains c c c pending the simulator’s final abort decision.
The simulator appends all-zero registers C \mathcal{C} C and D \mathcal{D} D of the prescribed sizes and prepares the padded plaintext and its fresh identity-evaluated encryption exactly as in H 6 H_6 H 6 . It retains the inner pads ( x , z ) (x,z) ( x , z ) explicitly and emulates
Open ( I , f p a d ) , Open ( I , f C ~ ) , Recover , \operatorname{Open}(I,f_{\mathrm{pad}}),\qquad\operatorname{Open}(I,f_{\widetilde{C}}),\qquad\operatorname{Recover}, Open ( I , f pad ) , Open ( I , f C ) , Recover ,
where recovery returns R o u t \mathcal{R}_{\mathrm{out}} R out and the measured-output opening value is ignored. If any invocation aborts, the simulator sends an abort request to the ideal functionality, causing the honest classical party to output ⊥ \perp ⊥ . Otherwise, it sends
( x B ⊕ x 0 , B , z B ⊕ z 0 , B ) (x_B \oplus x_{0,B},z_B \oplus z_{0,B}) ( x B ⊕ x 0 , B , z B ⊕ z 0 , B )
to P Q ∗ P_Q^* P Q ∗ and sends a continue request to the ideal functionality, which releases c c c to the honest classical party.
We have
H 6 ≡ H 7 . H_6 \equiv H_7. H 6 ≡ H 7 .
Indeed, both hybrids produce the same joint distribution of the private classical outcome c c c and the residual state ρ B E c \rho^c_{\mathcal{B}\mathcal{E}} ρ B E c . After this operation, the simulated ciphertext and all subsequent messages and abort decisions use only the returned B \mathcal{B} B register, the dummy registers, and the sampled pads; they do not require knowledge of c c c or access to the genuine D \mathcal{D} D . In H 6 H_6 H 6 , the experiment stores c c c and outputs it on successful completion; in H 7 H_7 H 7 , the ideal functionality stores and releases it on the same condition. By construction, H 7 H_7 H 7 is the ideal execution with the simulator described above:
H 7 = Ideal s i m ( G , ∣ ψ ⟩ , w ) . H_7 = \operatorname{Ideal}_{\mathrm{sim}}(G,\lvert\psi\rangle,w). H 7 = Ideal sim ( G , ∣ ψ ⟩ , w ) .
Security Against Semi-Honest Classical Parties
Theorem 22 (Security against honest-but-curious P C P_C P C ). With the commitment and recovery protocols of Constructions 2, 4 and 5, Protocol 5 is statistically secure against honest-but-curious classical parties.
Proof. We use a specific property from these protocols, which is inherited from Construction 2: a valid opening is an authentication of a string underneath an authentication key c o m \mathrm{com} com held by the semi-honest classical party. Thus, given c o m \mathrm{com} com , it is possible to generate arbitrary openings.
The simulator sends w w w to the ideal functionality and obtains its classical output c c c . It generates the classical view as follows.
Run the honest protocol with classical input w w w and an all-zero quantum input, stopping immediately after the opening of ( x ~ , z ~ ) (\tilde{x},\tilde{z}) ( x ~ , z ~ ) .
Set
c ~ = c ⊕ x C ′ ⊕ x 0 , C . \tilde{c} = c \oplus x'_C \oplus x_{0,C}. c ~ = c ⊕ x C ′ ⊕ x 0 , C . Using c o m \mathrm{com} com , discard the authenticated blocks for C ~ \tilde{C} C ~ and replace them by an authentication of ∣ c ~ ⟩ |\tilde{c}\rangle ∣ c ~ ⟩ under the same key.
Continue the remaining protocol honestly and output the classical view. Allow the ideal functionality to release B B B .
On any abort, the simulator requests abort and returns the view obtained so far.
Indistinguishability. Using a similar state-preserving argument from the proof of Theorem 10, any execution that restores every state in its subspace (including its external entanglement) must have a classical view which is independent of that state. We will use this to show that the replacement of the quantum input in the initial history commitment, clock opening, and pad opening steps is indistinguishable.
First, consider the state immediately after the simulator’s initial stopping point. If one were to apply the full recovery guaranteed by the history state, decrypt the entire evaluated ciphertext, remove ( x 0 , z 0 ) (x_0,z_0) ( x 0 , z 0 ) , and apply U G † U_G^\dagger U G † , then correctness of QFHE implies they would have restored the original quantum input.
Next, the final opening performs the prescribed projective measurement of C ~ \tilde{C} C ~ and preserves the logical state within each outcome subspace. Following the opening by full recovery therefore returns every state in that subspace. The same observation shows that, conditioned on the preceding view and c ~ \tilde{c} c ~ , the remaining classical view is independent of the residual state and its reference. It can therefore be generated from the simulator’s modified dummy state, which is correctly authenticated under c o m \mathrm{com} com .
2PC with Persistent Memory
Finally, we show how to implement persistent private memory using the single-use 2PC. In this, we consider an interactive ideal functionality which works as follows:
Initialization. The ideal functionality initializes its memory register M \mathcal{M} M to ∣ 0 ∣ M ∣ ⟩ |0^{|\mathcal{M}|}\rangle ∣ 0 ∣ M ∣ ⟩ .
Evaluation: Any polynomial number of times, until the adversary aborts: (a) The classical party P C P_C P C specifies a general quantum circuit G G G and the quantum party P Q P_Q P Q provides a quantum input in register Q Q Q . G G G also specifies how to split the coherent output register between the ideal functionality and P Q P_Q P Q . (b) The ideal functionality runs G G G on registers M \mathcal{M} M and Q Q Q . (c) The ideal functionality sends the classical result to P C P_C P C and P Q P_Q P Q ’s half of the coherent output to P Q P_Q P Q . It retains its half of the coherent output in M \mathcal{M} M .
The adversary may abort the execution at any time.
Security is otherwise defined identically to § 3.9 , with additional quantification over the multiple rounds of inputs. The established terminology for ideal functionalities which maintain persistent memory across interactions is a “reactive” functionality.
Theorem 23. Assuming an ϵ \epsilon ϵ -secure (respectively, secure) 2PC for general real quantum circuits, there exists an ϵ \epsilon ϵ -secure (respectively, secure) 2PC for polynomial-size general reactive quantum functionalities.
Construction and Analysis
The construction enforces persistent memory by having the ideal functionality authenticate its memory register under a key only known to the classical party. Once M \mathcal{M} M is protected, the quantum party can hold it until the next evaluation. Such authentication schemes exist unconditionally.
Construction 6. The construction uses a quantum authentication scheme Auth.(KeyGen, Enc, Dec, Ver).
Initialization. (a) P C P_C P C samples an authentication key k 0 ← A u t h . K e y G e n ( 1 λ , ∣ M ∣ ) k_0 \leftarrow\mathrm{Auth.KeyGen}(1^\lambda, |\mathcal{M}|) k 0 ← Auth.KeyGen ( 1 λ , ∣ M ∣ ) . (b) P C P_C P C and P Q P_Q P Q engage in a 2PC for the quantum circuit which takes in a key k k k and ∣ M ∣ |\mathcal{M}| ∣ M ∣ ancillas initialized to ∣ 0 ⟩ |0\rangle ∣0 ⟩ , then outputs A u t h . E n c ( k 0 , ∣ 0 ∣ M ∣ ⟩ ) \mathrm{Auth.Enc}(k_0, |0^{|\mathcal{M}|}\rangle) Auth.Enc ( k 0 , ∣ 0 ∣ M ∣ ⟩) to the quantum party.
Evaluation. On the i i i ’th evaluation, where P C P_C P C has input G i G_i G i and P Q P_Q P Q has input Q i Q_i Q i : (a) P C P_C P C samples a fresh authentication key k i ← A u t h . K e y G e n ( 1 λ , ∣ M ∣ ) k_i \leftarrow\mathrm{Auth.KeyGen}(1^\lambda, |\mathcal{M}|) k i ← Auth.KeyGen ( 1 λ , ∣ M ∣ ) .
(b) P C P_C P C and P Q P_Q P Q engage in a 2PC for the following circuit. P C P_C P C inputs the circuit G i G_i G i , the old key k i − 1 k_{i-1} k i − 1 , and the new key k i k_i k i . P Q P_Q P Q inputs Q i Q_i Q i and the authenticated memory register M ~ \widetilde{\mathcal{M}} M .
The 2PC circuit computes M ← Auth.Dec ( k i − 1 , M ~ ) \mathcal{M} \leftarrow\operatorname{Auth.Dec}(k_{i-1},\widetilde{\mathcal{M}}) M ← Auth.Dec ( k i − 1 , M ) , then computes G i ( ( M , Q i ) ) G_i((\mathcal{M},Q_i)) G i (( M , Q i )) .
It parses the output as P C P_C P C ’s output y y y , P Q P_Q P Q ’s output Q i ′ Q'_i Q i ′ , and the updated memory register M ′ \mathcal{M}' M ′ .
It computes M ~ ← Auth.Enc ( k i , M ′ ) \widetilde{\mathcal{M}} \leftarrow\operatorname{Auth.Enc}(k_i,\mathcal{M}') M ← Auth.Enc ( k i , M ′ ) .
y y y is the classical party’s output and ( Q i ′ , M ~ ) (Q'_i,\widetilde{\mathcal{M}}) ( Q i ′ , M ) is the quantum party’s output.
Proof of Theorem 23. Correctness follows immediately from the correctness of the underlying 2PC for general quantum circuits and the authentication scheme. The addition of the authentication encoding and decoding keeps the circuit as polynomial size.
Next we show ϵ \epsilon ϵ -security against malicious P Q P_Q P Q . Let T = poly ( λ ) T = \operatorname{poly}(\lambda) T = poly ( λ ) be an upper bound on the number of evaluations. Fix any ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . Consider the hybrid experiment where we simulate each each 2PC with error ϵ / T \epsilon/T ϵ / T . This is computationally indistinguishable from the real execution except with probability T ( ϵ / T ) = ϵ T(\epsilon/T) = \epsilon T ( ϵ / T ) = ϵ . Next, the security of authentication allows replacing M ~ \widetilde{\mathcal{M}} M by a dummy authentication of ∣ 0 ∣ M ∣ ⟩ \lvert0^{\lvert\mathcal{M}\rvert}\rangle ∣ 0 ∣ M ∣ ⟩ and keeping M ′ \mathcal{M}' M ′ for direct use in the next execution if P Q P_Q P Q submits a M ~ \widetilde{\mathcal{M}} M register which passes Auth.Ver \operatorname{Auth.Ver} Auth.Ver . At this point, the experiment matches the ideal functionality: P Q P_Q P Q submits its input on each execution and gets its output, and the ideal functionality maintains M \mathcal{M} M across executions.
Security against semi-honest P C P_C P C follows immediately from the security of the underlying 2PC and the observation that M ~ \widetilde{\mathcal{M}} M is never seen by P C P_C P C . In particular, simulating each of the underlying 2PCs already matches the ideal functionality: P C P_C P C provides its input for each evaluation, then gets its output.
IV Applications
Highlighted Applications
In this section, we give applications to two open problems: classical verification of quantum sampling and remote state preparation. Previously, constructions for both primitives which run in time T T T incurred a 1 / poly ( T ) 1/\operatorname{poly}(T) 1/ poly ( T ) security error. In the following subsections, we give a single protocol for each problem which runs in time T T T , but has ϵ \epsilon ϵ error for every ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . As such, the constructions are suitable for achieving any falsifiable game-based security notion with negligible security error. We give explicit example applications in Section 11. Moreover, our construction of remote state preparation holds for any efficiently preparable state. We provide a further discussion of this in Section 10.2.
The third highlighted application complements remote state preparation by demonstrating the receipt and processing of a quantum message, followed by either storing or discarding it. Specifically, we give a way for a classical verifier to receive, verify, and hold a quantum certificate. We describe it for the specific application of secure key leasing, which allows a lessor to lend out a quantum decryption key to a quantum lessee, who can use it to decrypt ciphertexts. Later, the return of a valid certificate ensures that the quantum sender can no longer decrypt future ciphertexts. We obtain the same guarantees where the revocation process is a classical interaction instead of requiring quantum communication.
Classical Verification of Quantum Sampling
The goal of a quantum sampling algorithm is to sample from some uniformly-generated family of distributions { D x } x ∈ { 0 , 1 } ∗ \{D_x\}_{x\in\{0,1\}^*} { D x } x ∈ { 0 , 1 } ∗ , potentially with some approximation error. More specifically, such an algorithm produces samples from some alternate distribution C x C_x C x and the goal is to minimize the distance between C x C_x C x and D x D_x D x .
We show in this section that every quantumly-sampleable distribution C x C_x C x can be classically verified with negligible error. Thus, if ∥ C − D ∥ T V ≤ ϵ \lVert C-D\rVert_{\mathrm{TV}}\le\epsilon ∥ C − D ∥ TV ≤ ϵ , then a classical party V V V can verify samples from D x D_x D x with computational distance ϵ \epsilon ϵ .
Definition 24 (Quantum-Sampleable Distribution). A distribution D \mathcal{D} D is quantum-sampleable if there exists a QPT algorithm A A A without quantum advice such that A A A outputs samples from D \mathcal{D} D . We say that a family of distributions { D x } x ∈ { 0 , 1 } ∗ \{D_x\}_{x\in\{0,1\}^*} { D x } x ∈ { 0 , 1 } ∗ is (uniformly) quantum-sampleable if there exists a (uniform) sequence of QPT algorithms { A x } x \{A_x\}_x { A x } x such that A x A_x A x outputs samples from D x D_x D x .
Definition 25 (Classical Verification of Quantum Sampling). A classical verification of quantum sampling protocol C V Q S = { C V Q S x } x \mathrm{CVQS}=\{\mathrm{CVQS}_x\}_x CVQS = { CVQS x } x for a family of distributions { D x } x \{D_x\}_x { D x } x is a uniformly generated set of protocols
C V Q S x ⟨ P , V ⟩ ( 1 λ ) → ( d , z ) \mathrm{CVQS}_x\langle P,V\rangle(1^\lambda)\to(d,z) CVQS x ⟨ P , V ⟩ ( 1 λ ) → ( d , z ) between a quantum prover P P P and a classical verifier V V V . At the end of the protocol, the classical verifier outputs a decision bit d ∈ { ⊤ , ⊥ } d\in\{\top,\bot\} d ∈ { ⊤ , ⊥ } and a sample z z z .
It must satisfy completeness and soundness.
Completeness. A CVQS protocol has completeness error c ( λ ) c(\lambda) c ( λ ) if for all λ ∈ N \lambda\in\mathbb{N} λ ∈ N and all x ∈ { 0 , 1 } poly ( λ ) x\in\{0,1\}^{\operatorname{poly}(\lambda)} x ∈ { 0 , 1 } poly ( λ ) ,
Pr [ d = ⊥ : ( d , z ) ← C V Q S x ⟨ P , V ⟩ ( 1 λ ) ] ≤ c ( λ ) \Pr[d=\bot:(d,z)\leftarrow\mathrm{CVQS}_x\langle P,V\rangle(1^\lambda)]\le c(\lambda) Pr [ d = ⊥ : ( d , z ) ← CVQS x ⟨ P , V ⟩ ( 1 λ )] ≤ c ( λ ) If c ( λ ) c(\lambda) c ( λ ) is negligible, we simply say that the protocol is complete.
Soundness. For any QPT cheating prover P ∗ P^* P ∗ , sufficiently large λ ∈ N \lambda\in\mathbb{N} λ ∈ N , and any x ∈ { 0 , 1 } poly ( λ ) x\in\{0,1\}^{\operatorname{poly}(\lambda)} x ∈ { 0 , 1 } poly ( λ ) , consider the following experiment.
Sample ( d , z ) ← C V Q S x ⟨ P ∗ , V ⟩ ( 1 λ ) (d,z)\leftarrow\mathrm{CVQS}_x\langle P^*,V\rangle(1^\lambda) ( d , z ) ← CVQS x ⟨ P ∗ , V ⟩ ( 1 λ ) .
Define z I d e a l z_{\mathrm{Ideal}} z Ideal by
{ z I d e a l = ⊥ if d = ⊥ z I d e a l ← D x if d = ⊤ \begin{cases}
z_{\mathrm{Ideal}}=\bot& \text{if } d=\bot\\
z_{\mathrm{Ideal}}\leftarrow D_x & \text{if } d=\top
\end{cases} { z Ideal = ⊥ z Ideal ← D x if d = ⊥ if d = ⊤
CVQS has computational soundness error s ( λ ) s(\lambda) s ( λ ) if the real and ideal distributions can be QPT-distinguished with advantage at most s ( λ ) s(\lambda) s ( λ ) :
{ ( d , z ) } ≈ s ( λ ) c { ( d , z I d e a l ) } \{(d,z)\} \overset{s(\lambda)}{\approx}_{c} \{(d,z_{\mathrm{Ideal}})\} {( d , z )} ≈ s ( λ ) c {( d , z Ideal )}
If s ( λ ) s(\lambda) s ( λ ) is negligible then we simply say that CVQS is sound.
Theorem 24. Assuming the post-quantum hardness of LWE, there is a complete and computationally sound CVQS protocol for every family of quantum-sampleable distributions { D x } x \{\mathcal{D}_x\}_x { D x } x .
Proof. Let { A x } x \{A_x\}_x { A x } x be the sequence of QPT algorithms without advice which sample from { D x } x \{\mathcal{D}_x\}_x { D x } x . To sample from D x \mathcal{D}_x D x , P P P and V V V run a state-preserving 2PC (§ 6.2 ) for the quantum functionality which computes A x A_x A x and outputs its result. □
We remark that since { A x } x \{A_x\}_x { A x } x is uniformly generated, it is even possible to hide precisely which distribution D x \mathcal{D}_x D x the verifier wishes to obtain samples from, up to the size of the implemented circuit.
As an immediate corollary, it is possible to classically verify samples from SampBQP with negligible overhead over the approximation error which is baked into the definition of SampBQP.
Definition 26 (SampBQP). A sampling problem { D x } x ∈ { 0 , 1 } ∗ \{\mathcal{D}_x\}_{x\in\{0,1\}^*} { D x } x ∈ { 0 , 1 } ∗ is in SampBQP if there exists a family of uniformly quantum-sampleable distributions { C x , 1 / ϵ } x ∈ { 0 , 1 } ∗ , ϵ ∈ R + \{\mathcal{C}_{x,1/\epsilon}\}_{x\in\{0,1\}^*,\epsilon\in\mathbb{R}^+} { C x , 1/ ϵ } x ∈ { 0 , 1 } ∗ , ϵ ∈ R + such that for all x x x and all ϵ \epsilon ϵ ,
∥ D x − C x , 1 / ϵ ∥ T V ≤ ϵ \lVert\mathcal{D}_x-\mathcal{C}_{x,1/\epsilon}\rVert_{\mathrm{TV}} \le\epsilon ∥ D x − C x , 1/ ϵ ∥ TV ≤ ϵ where ∥ ⋅ ∥ T V \lVert\cdot\rVert_{\mathrm{TV}} ∥ ⋅ ∥ TV is the total variation distance.
Remote State Preparation
Remote state preparation allows a classical party to “send” a quantum state ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ to a quantum party, so long as it knows a classical description of how to efficiently prepare the state. The goal is for the quantum party to receive no more information than if it had directly received ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ .
There are several limitations to existing constructions of remote state preparation [24 , 20 Zha25] .
1 / poly ( λ ) 1/\operatorname{poly}(\lambda) 1/ poly ( λ ) Error. Existing protocols are parameterized by a tunable security error ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) .40 Consider a security game which can only be won with negl ( λ ) \operatorname{negl}(\lambda) negl ( λ ) probability if directly given ∣ ψ x ⟩ \lvert\psi_x\rangle ∣ ψ x ⟩ . An ϵ \epsilon ϵ error in remote state preparation allows the adversary’s winning probability to rise to ϵ + negl ( λ ) \epsilon+\operatorname{negl}(\lambda) ϵ + negl ( λ ) if they instead receive ∣ ψ x ⟩ \lvert\psi_x\rangle ∣ ψ x ⟩ via a remote state preparation protocol.
Limited State Families. Prior works only allow for constructing a limited selection of states { ∣ ψ x ⟩ } x \{\lvert\psi_x\rangle\}_x {∣ ψ x ⟩ } x , such as BB84 states [24 , 20 ] or T θ ∣ + ⟩ T^\theta\lvert+\rangle T θ ∣ + ⟩ states for θ ∈ [ 8 ] \theta\in[8] θ ∈ [ 8 ] [24 ] .
Randomized States. Existing approaches produce a random ∣ ψ x ⟩ |\psi_x\rangle ∣ ψ x ⟩ from the family of possible states (for example, the sender can choose to send a computational basis state, but not which of ∣ 0 ⟩ |0\rangle ∣0 ⟩ or ∣ 1 ⟩ |1\rangle ∣1 ⟩ ).
In this section, we give a remote state preparation protocol for any state efficiently preparable by a real circuit of the sender’s choice, with ϵ \epsilon ϵ -security and negligible-loss falsifiable security. A family of states { ∣ ψ x ⟩ } x \{|\psi_x\rangle\}_x { ∣ ψ x ⟩ } x is efficiently preparable if there exists a QPT algorithm P P P without advice such that P ( x ) P(x) P ( x ) outputs a state negligibly far from ∣ ψ x ⟩ |\psi_x\rangle ∣ ψ x ⟩ for all x x x .
Syntax and Correctness. A remote state preparation protocol for a family of states { ∣ ψ x ⟩ } x ∈ { 0 , 1 } n \{|\psi_x\rangle\}_{x\in\{0,1\}^n} { ∣ ψ x ⟩ } x ∈ { 0 , 1 } n is an interactive protocol between a classical sender S C S_C S C and a quantum receiver R Q R_Q R Q . S C S_C S C inputs a description x ∈ { 0 , 1 } n x\in\{0,1\}^n x ∈ { 0 , 1 } n . At the end of the protocol, R Q R_Q R Q outputs a state ∣ ψ ′ ⟩ |\psi'\rangle ∣ ψ ′ ⟩ . We denote an execution by
∣ ψ ′ ⟩ ← RSP ⟨ S C ( x ) , R Q ⟩ ( 1 λ ) |\psi'\rangle\leftarrow\operatorname{RSP}\langle S_C(x),R_Q\rangle(1^\lambda) ∣ ψ ′ ⟩ ← RSP ⟨ S C ( x ) , R Q ⟩ ( 1 λ )
Correctness requires that for all x ∈ { 0 , 1 } n x\in\{0,1\}^n x ∈ { 0 , 1 } n and all λ ∈ N \lambda\in\mathbb{N} λ ∈ N , R Q R_Q R Q outputs a state overwhelmingly close to ∣ ψ x ⟩ |\psi_x\rangle ∣ ψ x ⟩ :
Pr ∣ ψ ′ ⟩ ← RSP ⟨ S C ( x ) , R Q ⟩ ( 1 λ ) [ 1 2 ∥ ∣ ψ ′ ⟩ − ∣ ψ x ⟩ ∥ 1 ≤ negl ( λ ) ] ≥ 1 − negl ( λ ) \Pr_{|\psi'\rangle\leftarrow\operatorname{RSP}\langle S_C(x),R_Q\rangle(1^\lambda)}\left[\frac{1}{2}\left\||\psi'\rangle-|\psi_x\rangle\right\|_1\leq\operatorname{negl}(\lambda)\right]\geq1-\operatorname{negl}(\lambda) ∣ ψ ′ ⟩ ← RSP ⟨ S C ( x ) , R Q ⟩ ( 1 λ ) Pr [ 2 1 ∥ ∣ ψ ′ ⟩ − ∣ ψ x ⟩ ∥ 1 ≤ negl ( λ ) ] ≥ 1 − negl ( λ )
Definition 27 (General RSP Security). A remote state preparation protocol is secure if there exists a QPT algorithm Sim \operatorname{Sim} Sim such that for all adversarial QPT receivers R Q ∗ R_Q^* R Q ∗ and all x ∈ { 0 , 1 } n x\in\{0,1\}^n x ∈ { 0 , 1 } n ,
{ R A ← RSP ⟨ S C ( x ) , R Q ∗ ⟩ ( 1 λ ) } ≈ c { R ∗ ← Sim ( R Q ∗ , ∣ ψ x ⟩ ) } \left\{\mathcal{R}_A\leftarrow\operatorname{RSP}\langle S_C(x),R_Q^*\rangle(1^\lambda)\right\}\approx_c\left\{\mathcal{R}^*\leftarrow\operatorname{Sim}(R_Q^*,|\psi_x\rangle)\right\} { R A ← RSP ⟨ S C ( x ) , R Q ∗ ⟩ ( 1 λ ) } ≈ c { R ∗ ← Sim ( R Q ∗ , ∣ ψ x ⟩) } where R ∗ \mathcal{R}^* R ∗ is R Q ∗ R_Q^* R Q ∗ ’s output register.
We say it is ϵ \epsilon ϵ -secure if there is a uniform sequence of poly ( λ , n ) \operatorname{poly}(\lambda,n) poly ( λ , n ) -sized quantum circuits { Sim λ , n } n , λ ∈ N \{\operatorname{Sim}_{\lambda,n}\}_{n,\lambda\in\mathbb{N}} { Sim λ , n } n , λ ∈ N such that for all sufficiently large λ \lambda λ and all n = poly ( λ ) n=\operatorname{poly}(\lambda) n = poly ( λ ) ,
{ R A ← RSP ⟨ S C ( x ) , R Q ∗ ⟩ ( 1 λ ) } ≈ c 1 / n { R ∗ ← Sim ( R Q ∗ , ∣ ψ x ⟩ ) } \left\{\mathcal{R}_A\leftarrow\operatorname{RSP}\langle S_C(x),R_Q^*\rangle(1^\lambda)\right\}\approx_c^{1/n}\left\{\mathcal{R}^*\leftarrow\operatorname{Sim}(R_Q^*,|\psi_x\rangle)\right\} { R A ← RSP ⟨ S C ( x ) , R Q ∗ ⟩ ( 1 λ ) } ≈ c 1/ n { R ∗ ← Sim ( R Q ∗ , ∣ ψ x ⟩) }
There are two main differences from prior works. First, the sender may directly choose the state ∣ ψ x ⟩ |\psi_x\rangle ∣ ψ x ⟩ to prepare. Second, ϵ \epsilon ϵ is a parameter of the simulator, not the protocol itself. That is, the same protocol must satisfy every ϵ = 1 / poly ( λ ) \epsilon=1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) .
Any RSP with ϵ \epsilon ϵ -security may be used to replace one round of quantum communication in any efficiently falsifiable security game with negligible security loss. An efficiently falsifiable game G G G is an interaction between a QPT challenger and a QPT adversary where at the end of the game, the challenger outputs a bit denoting win or loss. Falsifiable security of RSP guarantees that replacing one round of quantum communication in this game changes the adversary’s maximum winning advantage negligibly.
Definition 28 (RSP Falsifiable Security). Let G Q G_Q G Q be an efficiently falsifiable game where the challenger sends one quantum message. Let G C ( A ) G_C(\mathcal{A}) G C ( A ) be the same game, except the quantum message is replaced by a remote state preparation protocol between the challenger and adversary A \mathcal{A} A .
A remote state preparation protocol has falsifiable security if for every efficiently falsifiable game G Q G_Q G Q with one message from the challenger,
max Q P T A Pr [ w i n ← G C ] ≤ max Q P T A Pr [ w i n ← G Q ] + negl ( λ ) \max_{\mathsf{QPT}_{\mathcal{A}}} \Pr[\mathsf{win} \leftarrow G_C] \leq\max_{\mathsf{QPT}_{\mathcal{A}}} \Pr[\mathsf{win} \leftarrow G_Q] + \operatorname{negl}(\lambda) QPT A max Pr [ win ← G C ] ≤ QPT A max Pr [ win ← G Q ] + negl ( λ )
Theorem 25. Assuming the post-quantum hardness of L W E LWE L W E , there exists a remote state preparation protocol with ϵ \epsilon ϵ -security and (negligible loss) falsifiable security for every family of states { ∣ ψ x ⟩ } x \{\lvert\psi_x\rangle\}_x {∣ ψ x ⟩ } x which can be efficiently prepared by a real circuit.
Proof. The parties run a state-preserving 2PC (Section § 6.2 ) for the functionality P P P which efficiently prepares states from the family. Correctness and security are immediate from the correctness and security of the state-preserving 2PC.
Falsifiable security follows by observing that the sequence of ϵ \epsilon ϵ -simulators gives a sequence of reductions against every ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . Therefore the adversary’s additional advantage in the compiled game can only increase negligibly.
Classical Revocation of Quantum Certificates
Many quantum cryptographic primitives involve a quantum certificate that can be verified by a quantum party. For example, a user may hold a quantum decryption key, token, or certificate, and at some later point be required to return it to a verifier who runs a quantum verification procedure.
Our state-preserving 2PC gives a generic way to make such a verifier classical. Suppose that a quantum verification procedure V e r \mathrm{Ver} Ver takes as input a classical verification key v k \mathit{vk} vk and a quantum certificate ρ \rho ρ , and outputs a classical decision bit b b b , and possibly a residual quantum state ρ ′ \rho' ρ ′ . Instead of sending ρ \rho ρ to a quantum verifier, the certificate holder and a classical verifier can simply run our 2PC for the functionality
( b , ρ ′ ) ← V e r ( v k , ρ ) , (b,\rho') \leftarrow\mathrm{Ver}(\mathit{vk},\rho), ( b , ρ ′ ) ← Ver ( vk , ρ ) ,
where the classical verifier inputs v k \mathit{vk} vk and the quantum party inputs ρ \rho ρ . The classical verifier learns only the prescribed verification outcome, while the residual state is discarded entirely.
Thus, any protocol in which a quantum certificate is checked by an efficient quantum verification procedure can, in a black-box manner, be transformed into one in which the verification is performed through classical interaction. In particular, when successful verification certifies that the quantum certificate has been revoked, this gives a classical revocation procedure.
Classical Revocation for Secure Key Leasing. To make this generic transformation concrete, we instantiate it below for public-key encryption with secure key leasing (PKE-SKL), where the quantum certificate is a leased decryption key and revocation consists of verifying its return. We emphasize, however, that there is nothing specific to PKE-SKL in this transformation. The same approach applies to any primitive in which revocation is implemented by an efficient quantum verification procedure applied to a quantum certificate. In what follows we recall the syntax, correctness, and indistinguishability definitions of PKE-SKL from [3 Definitions 3.1 and 3.4 of the full version] . We use the font K G \mathcal{KG} K G , E n c \mathsf{Enc} Enc , D e c \mathsf{Dec} Dec , V r f y \mathcal{Vrfy} V r f y , d k \mathsf{dk} dk for quantum algorithms or quantum states.
Definition 29 (PKE with Secure Key Leasing). A PKE-SKL scheme SKL is a tuple of four algorithms ( K G , E n c , D e c , V r f y ) (\mathcal{KG}, \mathsf{Enc}, \mathsf{Dec}, \mathcal{Vrfy}) ( K G , Enc , Dec , V r f y ) . Below, let X \mathcal{X} X be the message space of SKL.
K G ( 1 λ ) → ( e k , d k , v k ) \mathcal{KG}(1^\lambda) \to(\mathbf{ek}, \mathsf{dk}, \mathbf{vk}) K G ( 1 λ ) → ( ek , dk , vk ) : The key generation algorithm is a QPT algorithm that takes as input a security parameter 1 λ 1^\lambda 1 λ , and outputs an classical encryption key e k \mathbf{ek} ek , a quantum decryption key d k \mathsf{dk} dk , and a classical verification key v k \mathbf{vk} vk .
E n c ( e k , m ) → c t \mathsf{Enc}(\mathbf{ek},\mathbf{m}) \to\mathbf{ct} Enc ( ek , m ) → ct : The encryption algorithm is a PPT algorithm that takes as input an encryption key e k \mathbf{ek} ek and a message m ∈ X \mathbf{m} \in\mathcal{X} m ∈ X , and outputs a ciphertext c t \mathbf{ct} ct .
D e c ( d k , c t ) → m ~ \mathsf{Dec}(\mathsf{dk},\mathbf{ct}) \to\widetilde{\mathbf{m}} Dec ( dk , ct ) → m : The decryption algorithm is a QPT algorithm that takes as input a quantum decryption key d k \mathsf{dk} dk and a classical ciphertext c t \mathbf{ct} ct , and outputs a classical message m ~ \widetilde{\mathbf{m}} m .
V r f y ( v k , d k ~ ) → ⊤ / ⊥ \mathcal{Vrfy}(\mathbf{vk},\widetilde{\mathsf{dk}}) \to\top/\bot V r f y ( vk , dk ) → ⊤/⊥ : The verification algorithm is a QPT algorithm that takes as input a classical verification key v k \mathbf{vk} vk and a (possibly malformed) quantum decryption key d k ~ \widetilde{\mathsf{dk}} dk , and outputs ⊤ \top ⊤ or ⊥ \bot ⊥ .
Decryption correctness: For every m ∈ X \mathbf{m} \in\mathcal{X} m ∈ X ,
Pr [ D e c ( d k , c t ) = m | ( e k , d k , v k ) ← K G ( 1 λ ) c t ← E n c ( e k , m ) ] = 1 − negl ( λ ) . \Pr\left[\mathsf{Dec}(\mathsf{dk},\mathbf{ct})=\mathbf{m}\ \middle|\
\begin{aligned}
(\mathbf{ek},\mathsf{dk},\mathbf{vk}) &\leftarrow\mathcal{KG}(1^\lambda)\\
\mathbf{ct} &\leftarrow\mathsf{Enc}(\mathbf{ek},\mathbf{m})
\end{aligned}
\right]=1-\operatorname{negl}(\lambda). Pr [ Dec ( dk , ct ) = m ( ek , dk , vk ) ct ← K G ( 1 λ ) ← Enc ( ek , m ) ] = 1 − negl ( λ ) .
Verification correctness:
Pr [ V r f y ( v k , d k ) = ⊤ | ( e k , d k , v k ) ← K G ( 1 λ ) ] = 1 − negl ( λ ) . \Pr\left[\mathcal{Vrfy}(\mathbf{vk},\mathsf{dk})=\top\ \middle|\
(\mathbf{ek},\mathsf{dk},\mathbf{vk})\leftarrow\mathcal{KG}(1^\lambda)\right]=1-\operatorname{negl}(\lambda). Pr [ V r f y ( vk , dk ) = ⊤ ( ek , dk , vk ) ← K G ( 1 λ ) ] = 1 − negl ( λ ) .
Definition 30 (Indistinguishability Against Key Leasing Attacks (IND-KLA) Security). We say that a PKE-SKL scheme SKL with the message space X \mathcal{X} X is IND-KLA secure, if it satisfies the following requirement, formalized from the experiment Exp S K L , A i n d - k l a ( 1 λ , c o i n ) \operatorname{Exp}^{\mathrm{ind\text{-}kla}}_{\mathrm{SKL},\mathcal{A}}(1^\lambda,\mathrm{coin}) Exp SKL , A ind - kla ( 1 λ , coin ) between an adversary A \mathcal{A} A and a challenger C \mathcal{C} C :
C \mathcal{C} C runs ( e k , d k , v k ) ← K G ( 1 λ ) (\mathbf{ek},\mathsf{dk},\mathbf{vk}) \leftarrow\mathcal{KG}(1^\lambda) ( ek , dk , vk ) ← K G ( 1 λ ) and sends e k \mathbf{ek} ek and d k \mathsf{dk} dk to A \mathcal{A} A .
Throughout the experiment, A \mathcal{A} A can access the following (stateful) verification oracle O V r f y \mathcal{O}_{\mathcal{Vrfy}} O V r f y where V V V is initialized to be ⊥ \bot ⊥ :
O V r f y ( d k ~ ) O_{\mathsf{Vrfy}}(\widetilde{\mathsf{dk}}) O Vrfy ( dk ) : It runs d ← V r f y ( v k , d k ~ ) d \leftarrow\mathsf{Vrfy}(\mathsf{vk},\widetilde{\mathsf{dk}}) d ← Vrfy ( vk , dk ) and returns d d d . If V = ⊥ V = \bot V = ⊥ and d = ⊤ d = \top d = ⊤ , it updates V : = ⊤ V := \top V := ⊤ .
A \mathcal{A} A sends ( m 0 ∗ , m 1 ∗ ) ∈ X 2 (m_0^*,m_1^*) \in\mathcal{X}^2 ( m 0 ∗ , m 1 ∗ ) ∈ X 2 to C \mathcal{C} C . If V = ⊥ V = \bot V = ⊥ , C \mathcal{C} C outputs 0 as the final output of this experiment. Otherwise, C \mathcal{C} C generates c t ∗ ← E n c ( e k , m c o i n ∗ ) \mathsf{ct}^* \leftarrow\mathsf{Enc}(\mathsf{ek},m_{\mathsf{coin}}^*) ct ∗ ← Enc ( ek , m coin ∗ ) and sends c t ∗ \mathsf{ct}^* ct ∗ to A \mathcal{A} A .
A \mathcal{A} A outputs a guess c o i n ′ \mathsf{coin}' coin ′ for c o i n \mathsf{coin} coin . C \mathcal{C} C outputs c o i n ′ \mathsf{coin}' coin ′ as the final output of the experiment.
For any QPT A \mathcal{A} A , it holds that
Adv S K L , A i n d - k l a ( λ ) : = ∣ Pr [ Exp S K L , A i n d - k l a ( 1 λ , 0 ) → 1 ] − Pr [ Exp S K L , A i n d - k l a ( 1 λ , 1 ) → 1 ] ∣ ≤ negl ( λ ) . \begin{aligned}
\operatorname{Adv}^{\mathrm{ind\text{-}kla}}_{\mathsf{SKL},\mathcal{A}}(\lambda) := \left|\Pr\left[\operatorname{Exp}^{\mathrm{ind\text{-}kla}}_{\mathsf{SKL},\mathcal{A}}(1^\lambda,0)\to1\right] - \Pr\left[\operatorname{Exp}^{\mathrm{ind\text{-}kla}}_{\mathsf{SKL},\mathcal{A}}(1^\lambda,1)\to1\right]\right| \\
&\leq\operatorname{negl}(\lambda).
\end{aligned} Adv SKL , A ind - kla ( λ ) := Pr [ Exp SKL , A ind - kla ( 1 λ , 0 ) → 1 ] − Pr [ Exp SKL , A ind - kla ( 1 λ , 1 ) → 1 ] ≤ negl ( λ ) .
Classical revocation. We now observe that any PKE-SKL scheme with an efficient quantum verification algorithm can be generically compiled into one where revocation requires only classical interaction.
Let S K L = ( K G , E n c , D e c , V r f y ) \mathsf{SKL} = (\mathcal{KG},\mathsf{Enc},\mathsf{Dec},\mathcal{Vrfy}) SKL = ( K G , Enc , Dec , V r f y ) be a PKE-SKL scheme. The algorithms K G , E n c , D e c \mathcal{KG},\mathsf{Enc},\mathsf{Dec} K G , Enc , Dec remain unchanged. We replace the verification algorithm by an interactive protocol V r f y c l \mathsf{Vrfy}_{\mathrm{cl}} Vrfy cl between the holder of the quantum decryption key and a classical verifier holding v k \mathsf{vk} vk . On input a purported quantum decryption key d k ~ \widetilde{\mathsf{dk}} dk from the quantum party and v k \mathsf{vk} vk from the classical party, the parties run our 2PC from § 6.2 for the functionality
b ← V r f y ( v k , d k ~ ) . b \leftarrow\mathcal{Vrfy}(\mathsf{vk},\widetilde{\mathsf{dk}}). b ← V r f y ( vk , dk ) .
The bit b b b is returned to the classical verifier, and all quantum output registers are discarded. Thus, the verification procedure consumes the submitted quantum key, exactly as in the original PKE-SKL verification experiment, while requiring only classical communication.
Correctness. Correctness follows immediately from the correctness of the 2PC. Security follows from the ϵ \epsilon ϵ -security of the underlying 2PC protocol, together with the fact that IND-KLA security is defined by an efficiently testable game, as follows:
Security. Security follows from the ϵ \epsilon ϵ -security of the underlying 2PC protocol, together with the fact that IND-KLA security is defined by an efficiently testable game, as follows. Suppose towards contradiction that there exists a QPT adversary that breaks IND-KLA security of the compiled scheme with advantage at least 1 / p ( λ ) 1/p(\lambda) 1/ p ( λ ) , and let q ( λ ) q(\lambda) q ( λ ) be a polynomial upper bound on the number of verification queries it makes. For each verification query, use the 2PC simulator with error
ϵ = 1 4 p ( λ ) q ( λ ) . \epsilon= \frac{1}{4p(\lambda)q(\lambda)}. ϵ = 4 p ( λ ) q ( λ ) 1 .
For each choice of coin, a sequential hybrid replacing the q ( λ ) q(\lambda) q ( λ ) executions of the classical verification protocol by their ideal functionalities changes the output probability by at most
q ( λ ) ϵ + negl ( λ ) . q(\lambda)\epsilon+ \operatorname{negl}(\lambda). q ( λ ) ϵ + negl ( λ ) .
Therefore, the IND-KLA advantage changes by at most
2 q ( λ ) ϵ + negl ( λ ) ≤ 1 2 p ( λ ) + negl ( λ ) . 2q(\lambda)\epsilon+ \operatorname{negl}(\lambda) \le\frac{1}{2p(\lambda)} + \operatorname{negl}(\lambda). 2 q ( λ ) ϵ + negl ( λ ) ≤ 2 p ( λ ) 1 + negl ( λ ) .
After these replacements, the experiment is precisely the IND-KLA experiment for the underlying PKE-SKL scheme, where each ideal verification invocation corresponds to a query to O V r f y \mathcal{O}_{\mathit{Vrfy}} O Vrfy . Thus, a non-negligible IND-KLA advantage against the compiled scheme yields a non-negligible IND-KLA advantage against the underlying scheme, contradicting its security. Importantly, only the simulator depends on ϵ \epsilon ϵ ; the compiled verification protocol itself is fixed.
Thus, we obtain the following corollary.
Corollary 7. Assuming the post-quantum hardness of LWE, every IND-KLA secure PKE-SKL scheme with an efficient quantum verification algorithm can be compiled into an IND-KLA secure PKE-SKL scheme in which revocation is performed by an interactive protocol between a classical verifier and the quantum key holder, using only classical communication.
Other Applications
In this section we give some further example applications of our state-preserving 2PC for quantum functionalities. Many of these applications are straightforward communication-dequantizations of existing primitives which rely on quantum communication.
We achieve negligible security loss for each application with a falsifiable security property. The reductions all follow along similar lines: fix any ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) and use the quantum-communication messages to ϵ \epsilon ϵ -simulate the 2PC that implements the classical communication. Any adversary with 2 ϵ 2\epsilon 2 ϵ advantage would then violate the security of the underlying primitive. Since this holds for all ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) , independently of the protocol description, the adversary’s advantage must be negligible in the compiled version.
Unclonable Encryption over a Classical Channel
Unclonable encryption encodes a classical message in a quantum ciphertext so that an adversary cannot split the ciphertext into two systems that both suffice to recover the message, even after the key is revealed [11 ] . Our remote state preparation protocol allows the sender of such a ciphertext to be entirely classical.
Let ( G e n , E n c , D e c ) (\mathrm{Gen}, \mathrm{Enc}, \mathrm{Dec}) ( Gen , Enc , Dec ) be an unclonable encryption scheme. KeyGen and Dec are identical to the original scheme. Instead of preparing the ciphertext and sending it over a quantum channel, the sender uses the 2PC from § 6.2 to remotely prepare
ρ k , m ← Enc ( k , m ) . \rho_{k,m} \leftarrow\operatorname{Enc}(k,m). ρ k , m ← Enc ( k , m ) .
Note that the sender does not need to know a classical description of the ciphertext, since the entire encryption process is delegated.
Security follows by replacing the 2PC with its simulation given a single ciphertext, before the adversary splits its state. Afterwards, the two separated parties run exactly the same algorithms as in the original unclonability game. Any adversary with, say, 2 ϵ 2\epsilon 2 ϵ cloning advantage in the classical communication game can therefore be converted to an adversary with ϵ \epsilon ϵ cloning advantage for the original quantum communication game, for any ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . Therefore the adversary’s advantage must be negligible.
Combining this compiler with recent advances in unclonable encryption, we obtain the following corollary.
Corollary 8. Assuming the post-quantum hardness of LWE, there exists an unclonable encryption scheme with a classical encryptor.
Previously, the best known approach allowed 1 / poly ( λ ) 1/\operatorname{poly}(\lambda) 1/ poly ( λ ) advantage in the cloning game [20 ] .
Public-Key Quantum Money with a Classical Bank from Polynomial Hardness
A public-key quantum money scheme allows a bank to issue quantum banknotes that can be verified using public information, but cannot be counterfeited. Namely, a QPT adversary that receives q q q banknotes should not be able to produce q + 1 q+1 q + 1 valid banknotes. We show how to make the bank classical without strengthening the hardness assumptions used by the underlying money scheme, other than adding the post-quantum hardness of LWE.
To mint a banknote, the classical bank and quantum recipient run the 2PC from § 6.2 to implement the minting circuit. The bank provides its secret key as input. The recipient does not input anything, but obtains the banknote and the serial number as a result of the 2PC.41 The verification algorithm is unchanged.
Correctness follows from correctness of the 2PC and the minting procedure. To prove security, we reduce to the security of the original quantum money scheme. Fix any ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . Given a banknote and serial number, ϵ / 2 \epsilon/2 ϵ /2 -simulate the 2PC, then finish running the cloner. The cloner’s success can drop by at most ϵ / 2 \epsilon/2 ϵ /2 , so any ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) advantage contradicts security of the original quantum money scheme.
In particular, this approach applies to Zhandry’s instantiation of subspace-based quantum money using post-quantum indistinguishability obfuscation [39 ] . The resulting corollary avoids the subexponential-LWE assumption in the classical-bank construction of [35 ] .
Corollary 9. Assuming post-quantum indistinguishability obfuscation and the polynomial post-quantum hardness of LWE, there exists a public-key quantum money scheme with a classical bank and classical communication during minting.
Improved Extraction for Classical Verification of QMA
There are two general measures of extraction quality in an argument of knowledge: knowledge error κ \kappa κ and extraction error δ \delta δ . In the case of an argument of quantum knowledge, the number of witnesses extracted also becomes important, which we call the copy error.
Knowledge error κ \kappa κ guarantees the extractor’s behavior if the prover passes with probability p ≥ κ p \ge\kappa p ≥ κ .
Extraction Error δ \delta δ is the loss between the probability that the prover passes p p p and the probability that the state extracted passes QMA verification with probability q q q . In particular, δ \delta δ is a function such that q = 1 − δ ( p ) q = 1 - \delta(p) q = 1 − δ ( p ) . We distinguish between functions δ \delta δ and the additive loss Δ = p − q \Delta= p - q Δ = p − q .
Copy Error is the difference between the number of witness copies needed for an honest prover and the number of witness copies the extractor can procure.
Previously, [37 ] achieved constant knowledge error κ \kappa κ , extraction error δ ( p ) = poly ( p ) \delta(p) = \operatorname{poly}(p) δ ( p ) = poly ( p ) (which translates to additive error Δ = p ( 1 − poly ( p ) ) \Delta= p(1 - \operatorname{poly}(p)) Δ = p ( 1 − poly ( p )) , and 0 copy error. They also present an amplified version which achieves κ = negl ( λ ) \kappa= \operatorname{negl}(\lambda) κ = negl ( λ ) and δ ( p ) = p − negl ( λ ) \delta(p) = p - \operatorname{negl}(\lambda) δ ( p ) = p − negl ( λ ) (or Δ = negl ( λ ) \Delta= \operatorname{negl}(\lambda) Δ = negl ( λ ) ), but at the cost of blowing up the copy error: the honest prover needs λ \lambda λ copies of the witness, but the extractor only procures one. [27 ] achieved negligible knowledge error κ = negl ( λ ) \kappa= \operatorname{negl}(\lambda) κ = negl ( λ ) , extraction error δ ( p ) = poly ( p ) \delta(p) = \operatorname{poly}(p) δ ( p ) = poly ( p ) , and 0 copy error.
Our results improve the extraction error while keeping κ = negl ( λ ) \kappa= \operatorname{negl}(\lambda) κ = negl ( λ ) and 0 copy error. In particular, there is a uniform sequence of extractors achieving Δ = ϵ \Delta= \epsilon Δ = ϵ in time poly ( 1 / ϵ ) \operatorname{poly}(1/\epsilon) poly ( 1/ ϵ ) , all for the same protocol . Moreover, the prover may use any witness which the original QMA verifier would accept with probability α \alpha α to convince the classical verifier with probability α − negl ( λ ) \alpha- \operatorname{negl}(\lambda) α − negl ( λ ) . [27 ] achieved this for α = 1 − negl ( λ ) \alpha= 1 - \operatorname{negl}(\lambda) α = 1 − negl ( λ ) and left open the problem for general α \alpha α .
To construct a classical verification of QMA with these properties, simply use the 2PC to implement the original QMA verifier. Correctness of the 2PC ensures that the classical verifier accepts with probability negligibly far from the original QMA verifier. The claimed sequence of extractors is given by ϵ \epsilon ϵ -simulation. ϵ \epsilon ϵ simulation guarantees that the output distribution of the ideal functionality is at most ϵ \epsilon ϵ far from the real execution. Therefore the extracted input which the simulator provides to the ideal functionality must be accepted by the original QMA verifier with probability ≥ p − ϵ \ge p - \epsilon ≥ p − ϵ .
Corollary 10. Assuming the post-quantum hardness of LWE, there exists a classical verification for QMA where the prover uses one copy of the witness, with knowledge error κ = negl ( λ ) \kappa= \operatorname{negl}(\lambda) κ = negl ( λ ) , 0 copy error, and which simultaneously satisfies additive extraction error Δ = ϵ \Delta= \epsilon Δ = ϵ for every ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) .
Proofs of No-Intrusion for Decryption Keys
A proof of no-intrusion allows a server to convince a client that an intruder has not retained a useful copy of a protected quantum resource, while leaving that resource available to the server. This was original proposed in the context of protecting ciphertexts, with the protection of other resources left as an open problem [23 ] . For decryption keys, the desired guarantee is that the server can continue decrypting, whereas a separated intruder cannot decrypt fresh ciphertexts if the server passes verification.
The construction is very similar to the previously-discussed classical revocation of quantum certificates construction for secure key leasing from § 8.1.3 . It starts with any secure key leasing scheme which is secure against adversaries with oracle access to the verification algorithm, where the oracle returns the tested state.42 e.g. [3 ] . The PoNI is a 2PC for the circuit which runs verification coherently, copies the result to the classical output register, and inverts verification. It also discards the ancillas used for verification. The difference from before is that the post-measurement state is retained as output instead of discarded. We also mention that the initial leasing step can be replaced with a classical interactive protocol.
Correctness and state preservation follows from correctness of the 2PC and correctness of the revocation circuit. The latter uses the gentle measurement principle and the correctness requirement that revocation accepts honest certificates with overwhelming probability.
Security reduces to the security of the original SKL scheme by simulating each of the 2PCs using a verification oracle. Similarly to before, any adversary with advantage 2 ϵ 2\epsilon 2 ϵ translates to an adversary with ϵ \epsilon ϵ advantage against the original SKL scheme, for any ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . Therefore any adversary’s advantage must be negligible.
Corollary 11. Assuming the post-quantum hardness of LWE, any key-leasing scheme with security in the presence of a verification oracle that returns the tested state admits proofs of no-intrusion with a classical verifier. Moreover, the key can be leased using classical communication.
Quantum Obfuscation with Interactive Classical Communication
Finally, our construction allows a classical party to distribute a quantum obfuscation via an interactive protocol. Let Obf \operatorname{Obf} Obf be any quantum obfuscator, and let
ρ U ← Obf ( U ) \rho_U \leftarrow\operatorname{Obf}(U) ρ U ← Obf ( U )
be its output on a classical description of a unitary U U U . Rather than generating ρ U \rho_U ρ U locally, the classical party and the quantum recipient run our 2PC for this preparation procedure, with U U U (and optionally the private preparation randomness) supplied by the classical party. The quantum recipient obtains the prescribed obfuscation, without learning its preparation description.
Correctness follows from correctness of the 2PC. Security of the preparation protocol gives a ϵ \epsilon ϵ -simulation using only ρ U \rho_U ρ U , for any ϵ = 1 / poly ( λ ) \epsilon= 1/\operatorname{poly}(\lambda) ϵ = 1/ poly ( λ ) . By quantifying over all such ϵ \epsilon ϵ , the classically-sent obfuscated program satisfies the standard notion of indistinguishability obfuscation.
Corollary 12. Any indistinguishability obfuscator for quantum circuits can be generically compiled into an indistinguishability obfuscator for quantum circuits where the obfuscation process is an interactive protocol with classical communication.
In the classical oracle model, there exists an obfuscation scheme for quantum circuits with an interactive classical obfuscation process satisfying both ϵ \epsilon ϵ -ideal obfuscation and indistinguishability obfuscation.
We leave open the question of removing interaction to obtain a truly classical obfuscation of quantum circuits.
Appendix
Proofs of Additional NTCF Properties
NTCF Collapsing with 1 Bit Leakage
Lemma 13 (Collapsing with a leaked inner product). Let ( S e t u p , E v a l , I n v e r t , C h e c k , S y n d ) (\mathsf{Setup},\mathsf{Eval},\mathsf{Invert},\mathsf{Check},\mathsf{Synd}) ( Setup , Eval , Invert , Check , Synd ) be a NTCF family. For a QPT adversary A A A and c ∈ { 0 , 1 } c \in\{0,1\} c ∈ { 0 , 1 } , define the experiment Coll-IP c A ( 1 λ ) \operatorname{Coll\text{-}IP}_{c}^{A}(1^\lambda) Coll - IP c A ( 1 λ ) as follows:
The challenger samples ( p p , t d ) ← S e t u p ( 1 λ ) (\mathsf{pp},\mathsf{td}) \leftarrow\mathsf{Setup}(1^\lambda) ( pp , td ) ← Setup ( 1 λ ) and sends p p \mathsf{pp} pp to A A A .
A A A sends a classical image y y y to the challenger. The challenger computes ( ( 0 , x 0 ) , ( 1 , x 1 ) ) ← I n v e r t ( t d , y ) ((0,x_0),(1,x_1)) \leftarrow\mathsf{Invert}(\mathsf{td},y) (( 0 , x 0 ) , ( 1 , x 1 )) ← Invert ( td , y ) . If inversion fails, the experiment outputs 0 and terminates.
The challenger samples d ← { 0 , 1 } n + 1 d \leftarrow\{0,1\}^{n+1} d ← { 0 , 1 } n + 1 and defines Δ = ( 0 , x 0 ) ⊕ ( 1 , x 1 ) \Delta=(0,x_0)\oplus(1,x_1) Δ = ( 0 , x 0 ) ⊕ ( 1 , x 1 ) . Then, it sends ( d , d ⋅ Δ ) (d,d\cdot\Delta) ( d , d ⋅ Δ ) to A A A .
A A A sends a ( n + 1 ) (n+1) ( n + 1 ) -qubit register X \mathcal{X} X to the challenger, retaining its private registers. The challenger performs the two-outcome projective measurement { Π y , I − Π y } \{\Pi_y,I-\Pi_y\} { Π y , I − Π y } on X \mathcal{X} X , where
Π y = ∑ b ∈ { 0 , 1 } , x C h e c k ( p p , b , x , y ) = 1 ∣ b , x ⟩ ⟨ b , x ∣ . \Pi_y=\sum_{\substack{b\in\{0,1\},\,x\\ \mathsf{Check}(\mathsf{pp},b,x,y)=1}} |b,x\rangle\langle b,x|. Π y = b ∈ { 0 , 1 } , x Check ( pp , b , x , y ) = 1 ∑ ∣ b , x ⟩ ⟨ b , x ∣.
If the outcome is I − Π y I-\Pi_y I − Π y , the experiment outputs 0 and terminates.
If c = 1 c=1 c = 1 , the challenger measures X \mathcal{X} X in the computational basis and discards the outcome. If c = 0 c=0 c = 0 , it leaves X \mathcal{X} X unchanged. It then returns X \mathcal{X} X to A \mathcal{A} A .
A \mathcal{A} A outputs a bit, which is the output of the experiment.
Then, for every QPT adversary A \mathcal{A} A ,
∣ Pr [ Coll-IPA 0 A ( 1 λ ) = 1 ] − Pr [ Coll-IPA 1 A ( 1 λ ) = 1 ] ∣ ≤ negl ( λ ) . \left|\Pr\left[\operatorname{Coll\text{-}IPA}_{0}^{\mathcal{A}}(1^\lambda)=1\right]-\Pr\left[\operatorname{Coll\text{-}IPA}_{1}^{\mathcal{A}}(1^\lambda)=1\right]\right|\le\operatorname{negl}(\lambda). Pr [ Coll - IPA 0 A ( 1 λ ) = 1 ] − Pr [ Coll - IPA 1 A ( 1 λ ) = 1 ] ≤ negl ( λ ) .
Proof. 43 We use the bounded-preimage collapsing-to-collision reduction of Cao–Xue and Zhandry [17 , 40 ] , followed by guessing the leaked bit. We give the two-preimage argument explicitly.
Fix A \mathcal{A} A , and let ε \varepsilon ε denote its distinguishing gap in the statement. We construct a QPT claw finder with success probability at least
ε 2 2 − negl ( λ ) . \frac{\varepsilon^2}{2}-\operatorname{negl}(\lambda). 2 ε 2 − negl ( λ ) .
We use the branchwise uniqueness and inversion guarantees of the NTCF family: for a fixed image, there is at most one valid preimage on each branch, and two valid preimages on opposite branches form a claw. Any negligible correctness error is absorbed into the final bound.
Extraction with the correct leakage. First consider a procedure that runs A \mathcal{A} A through the validity check, supplying the correct leakage ( d , d ⋅ Δ ) (d,d\cdot\Delta) ( d , d ⋅ Δ ) . If the check rejects, the procedure fails.
To analyze this procedure, fix the key pair and the classical transcript through delivery of ( d , d ⋅ Δ ) (d,d\cdot\Delta) ( d , d ⋅ Δ ) . 44 Let W \mathcal{W} W contain the adversary’s private registers and any fresh workspace needed for its final computation, and let R \mathcal{R} R be an inaccessible reference register. Write ∣ ψ ⟩ X W R \lvert\psi\rangle_{\mathcal{XWR}} ∣ ψ ⟩ X WR for a subnormalized purification of the accepting branch of the validity check. Thus ∥ ψ ∥ 2 \lVert\psi\rVert^2 ∥ ψ ∥ 2 equals the probability that the check accepts, conditioned on the fixed key pair and transcript.
For b ∈ { 0 , 1 } b\in\{0,1\} b ∈ { 0 , 1 } , define
P b = ( ∑ x : Check ( p p , b , x , y ) = 1 ∣ b , x ⟩ ⟨ b , x ∣ X ) ⊗ I W R , ∣ ψ b ⟩ = P b ∣ ψ ⟩ . P_b=\left(\sum_{x:\operatorname{Check}(\mathsf{pp},b,x,y)=1}\lvert b,x\rangle\langle b,x\rvert_{\mathcal{X}}\right)\otimes I_{\mathcal{W}\mathcal{R}},\qquad\lvert\psi_b\rangle=P_b\lvert\psi\rangle. P b = x : Check ( pp , b , x , y ) = 1 ∑ ∣ b , x ⟩ ⟨ b , x ∣ X ⊗ I WR , ∣ ψ b ⟩ = P b ∣ ψ ⟩ .
Each sum contains at most one term, and
∣ ψ ⟩ = ∣ ψ 0 ⟩ + ∣ ψ 1 ⟩ , ⟨ ψ 0 ∣ ψ 1 ⟩ = 0. \lvert\psi\rangle=\lvert\psi_0\rangle+\lvert\psi_1\rangle,\qquad\langle\psi_0\vert\psi_1\rangle=0. ∣ ψ ⟩ = ∣ ψ 0 ⟩ + ∣ ψ 1 ⟩ , ⟨ ψ 0 ∣ ψ 1 ⟩ = 0.
In particular, measuring the entire valid preimage register produces the subnormalized state
∣ ψ 0 ⟩ ⟨ ψ 0 ∣ + ∣ ψ 1 ⟩ ⟨ ψ 1 ∣ . \lvert\psi_0\rangle\langle\psi_0\rvert+\lvert\psi_1\rangle\langle\psi_1\rvert. ∣ ψ 0 ⟩ ⟨ ψ 0 ∣ + ∣ ψ 1 ⟩ ⟨ ψ 1 ∣ .
Let U U U be a coherent implementation of A \mathcal{A} A ’s final computation, obtained by deferring its measurements and retaining its workspace. Let O \mathcal{O} O be its output qubit, and define
M = U † ( ∣ 1 ⟩ ⟨ 1 ∣ O ⊗ I ) U , V = U † Z O U = I − 2 M . M=U^{\dagger}(\lvert1\rangle\langle1\rvert_{\mathcal{O}}\otimes I)U,\qquad V=U^{\dagger}Z_{\mathcal{O}}U=I-2M. M = U † (∣ 1 ⟩ ⟨ 1 ∣ O ⊗ I ) U , V = U † Z O U = I − 2 M .
These operators act trivially on R \mathcal{R} R . The circuit U U U , and hence the reflection V V V , is efficiently implementable from the description of A \mathcal{A} A and the classical transcript. In particular, the final computation makes no further secret-dependent queries to the challenger.
The signed difference between the two experiments’ probabilities of outputting 1, conditioned on the fixed key pair and transcript but not on acceptance of the validity check, is
δ = ⟨ ψ ∣ M ∣ ψ ⟩ − ∑ b ∈ { 0 , 1 } ⟨ ψ b ∣ M ∣ ψ b ⟩ = 2 Re ⟨ ψ 0 ∣ M ∣ ψ 1 ⟩ = − Re ⟨ ψ 0 ∣ V ∣ ψ 1 ⟩ . (14) \begin{aligned}
\delta&=\langle\psi|M|\psi\rangle-\sum_{b\in\{0,1\}}\langle\psi_b|M|\psi_b\rangle\\
&=2\operatorname{Re}\langle\psi_0|M|\psi_1\rangle\\
&=-\operatorname{Re}\langle\psi_0|V|\psi_1\rangle. \tag*{(14)}
\end{aligned} δ = ⟨ ψ ∣ M ∣ ψ ⟩ − b ∈ { 0 , 1 } ∑ ⟨ ψ b ∣ M ∣ ψ b ⟩ = 2 Re ⟨ ψ 0 ∣ M ∣ ψ 1 ⟩ = − Re ⟨ ψ 0 ∣ V ∣ ψ 1 ⟩ . (14)
The extraction procedure now measures X \mathcal{X} X in the computational basis and saves the resulting preimage in a separate classical register. It applies V V V to the adversary’s registers, leaving the saved outcome untouched, and measures X \mathcal{X} X again. If the second outcome is a valid preimage on the opposite branch, it outputs y y y and the two preimages; otherwise, it fails. Both outcomes can be checked publicly using Check.
For the fixed key pair and transcript, the probability of finding a claw is
p c l a w = ∥ P 1 V ∣ ψ 0 ⟩ ∥ 2 + ∥ P 0 V ∣ ψ 1 ⟩ ∥ 2 . p_{\mathrm{claw}}=\lVert P_1V\lvert\psi_0\rangle\rVert^2+\lVert P_0V\lvert\psi_1\rangle\rVert^2. p claw = ∥ P 1 V ∣ ψ 0 ⟩ ∥ 2 + ∥ P 0 V ∣ ψ 1 ⟩ ∥ 2 .
This expression includes the probability of passing the validity check because ∣ ψ ⟩ \lvert\psi\rangle ∣ ψ ⟩ is subnormalized. By (14) and Cauchy–Schwarz,
δ 2 ≤ ∣ ⟨ ψ 0 ∣ V ∣ ψ 1 ⟩ ∣ 2 = ∣ ⟨ ψ 0 ∣ P 0 V ∣ ψ 1 ⟩ ∣ 2 ≤ ∥ ψ 0 ∥ 2 ∥ P 0 V ∣ ψ 1 ⟩ ∥ 2 ≤ p c l a w . \begin{aligned}
\delta^2&\leq\left|\langle\psi_0|V|\psi_1\rangle\right|^2\\
&=\left|\langle\psi_0|P_0V|\psi_1\rangle\right|^2\\
&\leq\lVert\psi_0\rVert^2\lVert P_0V\lvert\psi_1\rangle\rVert^2\\
&\leq p_{\mathrm{claw}}.
\end{aligned} δ 2 ≤ ∣ ⟨ ψ 0 ∣ V ∣ ψ 1 ⟩ ∣ 2 = ∣ ⟨ ψ 0 ∣ P 0 V ∣ ψ 1 ⟩ ∣ 2 ≤ ∥ ψ 0 ∥ 2 ∥ P 0 V ∣ ψ 1 ⟩ ∥ 2 ≤ p claw .
For executions on which inversion fails, take δ = 0 \delta=0 δ = 0 and let the correct-leakage extraction procedure fail. Averaging over the keys and transcripts therefore gives
Pr [ correct-leakage extraction finds a claw ] ≥ E [ δ 2 ] ≥ ( E [ δ ] ) 2 = ε 2 , \Pr[\text{correct-leakage extraction finds a claw}]\geq\mathbb{E}[\delta^2]\geq(\mathbb{E}[\delta])^2=\varepsilon^2, Pr [ correct-leakage extraction finds a claw ] ≥ E [ δ 2 ] ≥ ( E [ δ ] ) 2 = ε 2 ,
up to the negligible correctness error.
Guessing the leakage. We now construct the actual claw finder B \mathcal{B} B , which is given only pp. It runs A \mathcal{A} A until A \mathcal{A} A declares y y y , samples
d ← { 0 , 1 } n + 1 , β ~ ← { 0 , 1 } , d \leftarrow\{0,1\}^{n+1}, \qquad\widetilde{\beta} \leftarrow\{0,1\}, d ← { 0 , 1 } n + 1 , β ← { 0 , 1 } ,
and supplies ( d , β ~ ) (d,\widetilde{\beta}) ( d , β ) to A \mathcal{A} A . It then performs the public validity check and the measure–reflect–measure extraction procedure above, using β ~ \widetilde{\beta} β as the supplied leakage bit. For every fixed key pair, preceding transcript, and d d d on which inversion succeeds,
Pr [ β ~ = d ⋅ Δ ] = 1 2 . \Pr[\widetilde{\beta}=d\cdot\Delta]=\frac{1}{2}. Pr [ β = d ⋅ Δ ] = 2 1 .
Conditioned on this event, the adversary’s entire execution, including its quantum state, has exactly the distribution of the correct-leakage execution. Since the event has probability 1 / 2 1/2 1/2 for every such fixed classical history, conditioning on it does not bias the distribution of those histories or their correlated quantum states. Hence
Pr [ B finds a claw ] ≥ 1 2 Pr [ correct-leakage extraction finds a claw ] ≥ ε 2 2 − negl ( λ ) . \Pr[\mathcal{B}\text{ finds a claw}] \geq\frac{1}{2}\Pr[\text{correct-leakage extraction finds a claw}] \geq\frac{\varepsilon^2}{2}-\operatorname{negl}(\lambda). Pr [ B finds a claw ] ≥ 2 1 Pr [ correct-leakage extraction finds a claw ] ≥ 2 ε 2 − negl ( λ ) .
Incorrect guesses contribute a nonnegative success probability. Likewise, B \mathcal{B} B need not determine whether trapdoor inversion would have failed: executions on which the original experiment would abort cannot decrease its claw-finding probability.
The reduction uses only one copy of A \mathcal{A} A ’s auxiliary input. That input is included in the adversary’s workspace, and the reflection reverses only its final computation; it does not prepare or restore the auxiliary state. The first preimage measurement may disturb that state arbitrarily. The extraction bound already accounts for this disturbance, and no operation acts on the purifying reference register.
Since B \mathcal{B} B is QPT, claw-freeness implies that its success probability is negligible. Therefore ε \varepsilon ε is negligible, as required. □
2-Query Adaptive Hardcore Bit Property
We first recall the 2-query adaptive hardcore bit property. A NTCF family is said to satisfy the 2-query adaptive hardcore bit property if every QPT adversary A \mathcal{A} A wins in the following game with probability 1 2 + negl ( λ ) \frac{1}{2}+\operatorname{negl}(\lambda) 2 1 + negl ( λ ) .
The challenger samples ( p p , t d ) ← Setup ( 1 λ ) (\mathsf{pp},\mathsf{td})\leftarrow\operatorname{Setup}(1^\lambda) ( pp , td ) ← Setup ( 1 λ ) and sends p p \mathsf{pp} pp to A \mathcal{A} A .
A \mathcal{A} A sends a classical tuple ( b , x , y ) (b,x,y) ( b , x , y ) to the challenger. It may retain arbitrary quantum side information.
The challenger checks that Check ( p p , b , x , y ) = 1 \operatorname{Check}(\mathsf{pp},b,x,y)=1 Check ( pp , b , x , y ) = 1 . If this is not the case then the game is terminated with the default guess c ′ = 0 c'=0 c ′ = 0 . Otherwise, the challenger does the following:
(a) Compute ( ( 0 , x 0 ) , ( 1 , x 1 ) ) = Invert ( t d , y ) ((0,\mathbf{x}_0),(1,\mathbf{x}_1)) = \operatorname{Invert}(\mathsf{td},\mathbf{y}) (( 0 , x 0 ) , ( 1 , x 1 )) = Invert ( td , y ) .
(b) Sample uniformly at random c ← { 0 , 1 } c \leftarrow\{0,1\} c ← { 0 , 1 } and d ← { 0 , 1 } n + 1 \mathbf{d} \leftarrow\{0,1\}^{n+1} d ← { 0 , 1 } n + 1 .
(c) Compute p = d ⋅ ( 1 , x 0 ⊕ x 1 ) ⊕ c p = \mathbf{d} \cdot(1,\mathbf{x}_0 \oplus\mathbf{x}_1) \oplus c p = d ⋅ ( 1 , x 0 ⊕ x 1 ) ⊕ c .
(d) Send ( d , p ) (\mathbf{d},p) ( d , p ) .
A \mathcal{A} A sends a classical vector e ∈ { 0 , 1 } n \mathbf{e} \in\{0,1\}^{n} e ∈ { 0 , 1 } n .
The challenger checks that Synd ( b , x b , e ) ∉ { 0 k , Synd ( b , x b , d ) } \operatorname{Synd}(b,\mathbf{x}_b,\mathbf{e}) \notin\{0^k,\operatorname{Synd}(b,\mathbf{x}_b,\mathbf{d})\} Synd ( b , x b , e ) ∈ / { 0 k , Synd ( b , x b , d )} for both b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } . If either check fails then the game is terminated with a default guess c ′ = 0 c' = 0 c ′ = 0 . Otherwise, the challenger sends β = e ⋅ ( x 0 ⊕ x 1 ) \beta= \mathbf{e} \cdot(\mathbf{x}_0 \oplus\mathbf{x}_1) β = e ⋅ ( x 0 ⊕ x 1 ) to A \mathcal{A} A .
A \mathcal{A} A outputs a bit c ′ ∈ { 0 , 1 } c' \in\{0,1\} c ′ ∈ { 0 , 1 } .
A \mathcal{A} A wins if c ′ = c c' = c c ′ = c .
Lemma 4 states that any NTCF with linear Synd \operatorname{Synd} Synd satisfies this property.
Proof of Lemma 4. Suppose towards contradiction that there exists a QPT adversary A \mathcal{A} A that wins the 2-query adaptive hardcore bit game with probability 1 2 + ϵ \frac{1}{2}+\epsilon 2 1 + ϵ , for some non-negligible ϵ = ϵ ( λ ) \epsilon= \epsilon(\lambda) ϵ = ϵ ( λ ) . We construct a QPT adversary B \mathcal{B} B that violates the adaptive hardcore bit property.
Given p p \mathsf{pp} pp , adversary B \mathcal{B} B does the following:
Run A ( p p ) \mathcal{A}(\mathsf{pp}) A ( pp ) to obtain a classical tuple ( b , x , y ) (b,\mathbf{x},y) ( b , x , y ) . If
Check ( p p , b , x , y ) = 0 \operatorname{Check}(\mathsf{pp},b,\mathbf{x},y) = 0 Check ( pp , b , x , y ) = 0
then output an honestly generated valid tuple ( b , x , y ) (b,\mathbf{x},y) ( b , x , y ) together with a uniformly random guess for the hardcore bit. This succeeds with probability ≥ 1 2 − negl ( λ ) \ge\frac{1}{2} - \operatorname{negl}(\lambda) ≥ 2 1 − negl ( λ ) .
Otherwise, sample uniformly at random d ← { 0 , 1 } n + 1 \mathbf{d} \leftarrow\{0,1\}^{n+1} d ← { 0 , 1 } n + 1 and p ← { 0 , 1 } p \leftarrow\{0,1\} p ← { 0 , 1 } , send ( d , p ) (\mathbf{d},p) ( d , p ) to A \mathcal{A} A , and obtain a vector e \mathbf{e} e .
Notice that this is distributed exactly as in the 2-query game: Denoting by
Δ : = ( 1 , x 0 ⊕ x 1 ) , \Delta:= (1,\mathbf{x}_0 \oplus\mathbf{x}_1), Δ := ( 1 , x 0 ⊕ x 1 ) ,
where ( ( 0 , x 0 ) , ( 1 , x 1 ) ) = Invert ( t d , y ) ((0,\mathbf{x}_0),(1,\mathbf{x}_1)) = \operatorname{Invert}(\mathsf{td},y) (( 0 , x 0 ) , ( 1 , x 1 )) = Invert ( td , y ) , then in the 2-query game p = d ⋅ Δ ⊕ c p = \mathbf{d} \cdot\Delta\oplus c p = d ⋅ Δ ⊕ c , and since c c c is uniform, p p p is uniform and independent of d \mathbf{d} d and everything that precedes it.
If
Synd ( b , x , e ) ∈ { 0 k , Synd ( b , x , d ) } , \operatorname{Synd}(b,\mathbf{x},\mathbf{e}) \in\{0^k,\operatorname{Synd}(b,\mathbf{x},\mathbf{d})\}, Synd ( b , x , e ) ∈ { 0 k , Synd ( b , x , d )} ,
then again output an honestly generated valid adaptive-hardcore-bit tuple together with a uniformly random guess.
If Synd ( b , x , d ) = 0 k \operatorname{Synd}(\mathbf{b},\mathbf{x},\mathbf{d})=\mathbf{0}^{k} Synd ( b , x , d ) = 0 k then again B \mathcal{B} B outputs an honestly generated valid adaptive-hardcore-bit tuple together with a uniformly random guess.
Notice that this happens only with negligible probability.
Let e ~ : = ( 0 , e ) \tilde{\mathbf{e}} := (0,\mathbf{e}) e ~ := ( 0 , e ) and define d ^ : = d ⊕ e ~ \hat{\mathbf{d}} := \mathbf{d} \oplus\tilde{\mathbf{e}} d ^ := d ⊕ e ~ . By linearity of Synd \operatorname{Synd} Synd ,
Synd ( b , x , d ^ ) = Synd ( b , x , d ) ⊕ Synd ( b , x , e ) ≠ 0 k . \operatorname{Synd}(\mathbf{b},\mathbf{x},\hat{\mathbf{d}})=\operatorname{Synd}(\mathbf{b},\mathbf{x},\mathbf{d})\oplus\operatorname{Synd}(\mathbf{b},\mathbf{x},\mathbf{e})\ne\mathbf{0}^{k}. Synd ( b , x , d ^ ) = Synd ( b , x , d ) ⊕ Synd ( b , x , e ) = 0 k .
If the two-query game accepts both branch checks, the same calculation holds for both branches. Provided d ∈ G o o d 0 , x 0 ∩ G o o d 1 , x 1 \mathbf{d}\in\mathrm{Good}_{0,\mathbf{x}_{0}}\cap\mathrm{Good}_{1,\mathbf{x}_{1}} d ∈ Good 0 , x 0 ∩ Good 1 , x 1 , both d \mathbf{d} d and d ^ \hat{\mathbf{d}} d ^ are then valid hardcore bit vectors.
Sample independent uniform bits r , i ← { 0 , 1 } r,i\leftarrow\{0,1\} r , i ← { 0 , 1 } , and send r r r to A \mathcal{A} A in place of the bit β \beta β in the 2-query game, and receives a bit c ′ c' c ′ .
If i = 0 i=0 i = 0 , then output ( y , b , x , d , p ⊕ c ′ ) (\mathbf{y},\mathbf{b},\mathbf{x},\mathbf{d},p\oplus c') ( y , b , x , d , p ⊕ c ′ ) .
Otherwise, if i = 1 i=1 i = 1 , then B \mathcal{B} B output ( y , b , x , d ^ , p ⊕ c ′ ⊕ r ) (\mathbf{y},\mathbf{b},\mathbf{x},\hat{\mathbf{d}},p\oplus c'\oplus r) ( y , b , x , d ^ , p ⊕ c ′ ⊕ r ) .
We show that B \mathcal{B} B predicts an adaptive hardcore bit with non-negligible advantage. To this end, fix the transcript up to the point that e \mathbf{e} e is chosen, and write
h : = d ⋅ Δ , β : = e ⋅ ( x 0 ⊕ x 1 ) = e ~ ⋅ Δ . h:=\mathbf{d}\cdot\Delta,\qquad\beta:=\mathbf{e}\cdot(\mathbf{x}_{0}\oplus\mathbf{x}_{1})=\tilde{\mathbf{e}}\cdot\Delta. h := d ⋅ Δ , β := e ⋅ ( x 0 ⊕ x 1 ) = e ~ ⋅ Δ.
For r ∈ { 0 , 1 } r\in\{0,1\} r ∈ { 0 , 1 } , let c r ′ c'_r c r ′ denote the output of A \mathcal{A} A when it is given r r r , and define
g r : = p ⊕ c r ′ . g_r:=p\oplus c'_r. g r := p ⊕ c r ′ .
If i = 0 i=0 i = 0 then B \mathcal{B} B succeeds exactly when g r = h g_r=h g r = h . If i = 1 i=1 i = 1 then
d ^ ⋅ Δ = ( d ⊕ e ~ ) ⋅ Δ = h ⊕ β , \hat{\mathbf{d}}\cdot\Delta=(\mathbf{d}\oplus\tilde{\mathbf{e}})\cdot\Delta=h\oplus\beta, d ^ ⋅ Δ = ( d ⊕ e ~ ) ⋅ Δ = h ⊕ β ,
and hence B \mathcal{B} B succeeds exactly when
g r ⊕ r = h ⊕ β . g_r\oplus r=h\oplus\beta. g r ⊕ r = h ⊕ β .
Averaging over the uniform choices of i i i and r r r , we obtain
Pr [ B succeeds ∣ fixed transcript ] = 1 4 + 1 2 ⋅ 1 [ g β = h ] . \Pr[\mathcal{B}\text{ succeeds}\mid\text{fixed transcript}]=\frac{1}{4}+\frac{1}{2}\cdot\mathbf{1}[g_{\beta}=h]. Pr [ B succeeds ∣ fixed transcript ] = 4 1 + 2 1 ⋅ 1 [ g β = h ] .
Indeed, if β = 0 \beta=0 β = 0 , the two possible predictions corresponding to r = 1 r=1 r = 1 are complementary, whereas the two predictions corresponding to r = 0 r=0 r = 0 both succeed exactly when g 0 = h g_0=h g 0 = h . The case β = 1 \beta=1 β = 1 is symmetric.
Finally, observe that
g β = h ⟺ p ⊕ c β ′ = h ⟺ c β ′ = p ⊕ h = c . g_{\beta}=h\quad\Longleftrightarrow\quad p\oplus c'_{\beta}=h\quad\Longleftrightarrow\quad c'_{\beta}=p\oplus h=c. g β = h ⟺ p ⊕ c β ′ = h ⟺ c β ′ = p ⊕ h = c .
Thus, this event is exactly the event that A \mathcal{A} A wins the 2-query game. Let E E E denote the event that the 2-query game does not terminate before sending β \beta β . Since a terminating execution contributes probability 1 2 \frac{1}{2} 2 1 of guessing c c c , our assumption that A \mathcal{A} A wins with probability 1 2 + ϵ \frac{1}{2}+\epsilon 2 1 + ϵ implies
Pr [ E ∧ ( c ′ = c ) ] = 1 2 Pr [ E ] + ϵ . \Pr[E \land(c'=c)] = \frac{1}{2}\Pr[E] + \epsilon. Pr [ E ∧ ( c ′ = c )] = 2 1 Pr [ E ] + ϵ .
On executions outside E E E , B \mathcal{B} B uses a uniformly random guess and therefore succeeds with probability 1 2 − negl ( λ ) \frac{1}{2}-\operatorname{negl}(\lambda) 2 1 − negl ( λ ) . On executions in E E E , the calculation above gives
Pr [ B succeeds ∣ E ] = 1 4 + 1 2 Pr [ c ′ = c ∣ E ] . \Pr[\mathcal{B}\text{ succeeds}\mid E] = \frac{1}{4}+\frac{1}{2}\Pr[c'=c\mid E]. Pr [ B succeeds ∣ E ] = 4 1 + 2 1 Pr [ c ′ = c ∣ E ] .
Combining these equations,
Pr [ B succeeds ] ≥ 1 2 + ϵ 2 − negl ( λ ) . \Pr[\mathcal{B}\text{ succeeds}] \ge\frac{1}{2}+\frac{\epsilon}{2}-\operatorname{negl}(\lambda). Pr [ B succeeds ] ≥ 2 1 + 2 ϵ − negl ( λ ) .
Since ϵ \epsilon ϵ is non-negligible, this contradicts the adaptive hardcore bit property. Therefore every NTCF family with linear Synd satisfies the 2-query adaptive hardcore bit property.
Phase Injection with 1 Bit Leakage
Recall the security game from Lemma 5:
Challenger: Sample ( p p , t d ) ← Setup ( 1 λ ) (\mathrm{pp},\mathrm{td}) \leftarrow\operatorname{Setup}(1^\lambda) ( pp , td ) ← Setup ( 1 λ ) and sample a random bit p ← { 0 , 1 } p \leftarrow\{0,1\} p ← { 0 , 1 } . Send p p \mathrm{pp} pp to A \mathcal{A} A .
A \mathcal{A} A sends back a classical value y y y and a register R \mathcal{R} R (which should store a preimage of y y y ).
Challenger: Perform the projective measurement { Π y , I − Π y } \{\Pi_y,I-\Pi_y\} { Π y , I − Π y } on R \mathcal{R} R where Π y \Pi_y Π y projects onto ( b , r b ) (b,r_b) ( b , r b ) such that Check ( p p , b , r b , y ) = 1 \operatorname{Check}(\mathrm{pp},b,r_b,y)=1 Check ( pp , b , r b , y ) = 1 . If the result is I − Π y I-\Pi_y I − Π y , then A \mathcal{A} A needs to guess p p p (without being given any information about p p p ), and the game is over.
Challenger: Otherwise, if p = 1 p=1 p = 1 then apply a Z Z Z gate to the first qubit of R \mathcal{R} R . Send R \mathcal{R} R back to A \mathcal{A} A .
Challenger (Leakage): Compute ( ( 0 , r 0 ) , ( 1 , r 1 ) ) ← Invert ( t d , y ) ((0,r_0),(1,r_1)) \leftarrow\operatorname{Invert}(\mathrm{td},y) (( 0 , r 0 ) , ( 1 , r 1 )) ← Invert ( td , y ) . Set Δ = ( 0 , r 0 ) ⊕ ( 1 , r 1 ) \Delta=(0,r_0)\oplus(1,r_1) Δ = ( 0 , r 0 ) ⊕ ( 1 , r 1 ) . Then sample d ← { 0 , 1 } n + 1 \mathbf{d}\leftarrow\{0,1\}^{n+1} d ← { 0 , 1 } n + 1 and send ( d , d ⋅ Δ ) (\mathbf{d},\mathbf{d}\cdot\Delta) ( d , d ⋅ Δ ) to the adversary.
A \mathcal{A} A sends a string e \mathbf{e} e to the challenger.
Challenger: If Synd ( b , r b , e ) ∉ { 0 k , Synd ( b , r b , d ) } \operatorname{Synd}(b,r_b,\mathbf{e})\notin\{0^k,\operatorname{Synd}(b,r_b,\mathbf{d})\} Synd ( b , r b , e ) ∈ / { 0 k , Synd ( b , r b , d )} for both b ∈ { 0 , 1 } b\in\{0,1\} b ∈ { 0 , 1 } , send ( e ⋅ Δ ) ⊕ p (\mathbf{e}\cdot\Delta)\oplus p ( e ⋅ Δ ) ⊕ p to A \mathcal{A} A . Otherwise send a random bit b ′ b' b ′ .
A A A outputs a bit p ′ p' p ′ . They win if and only if p ′ = p p' = p p ′ = p .
Lemma 5 states that any QPT adversary wins with probability at most 1 / 2 + negl ( λ ) 1/2+\operatorname{negl}(\lambda) 1/2 + negl ( λ ) . The following proof is almost identical to [28 ] 's. The only difference is the usage of collapsing and adaptive hardcore bit properties which permit one bit of random inner product leakage. The latter follows from the standard adaptive hardcore bit property and the 2-query adaptive hardcore bit property, which allows replacing the leakage bit with pure randomness.
Proof. We define four hybrid experiments H y b a b \mathsf{Hyb}_{ab} Hyb ab for a , b ∈ { 0 , 1 } a,b \in\{0,1\} a , b ∈ { 0 , 1 } . H y b a b \mathsf{Hyb}_{ab} Hyb ab is the same experiment described in the lemma statement, except for two modifications. First, apply Z a Z^a Z a in step 4. Second, send d ⋅ ( r 0 ⊕ r 1 ) ⊕ b d \cdot(r_0 \oplus r_1) \oplus b d ⋅ ( r 0 ⊕ r 1 ) ⊕ b in 7. Observe that the original game with bit p p p is exactly H y b p p ′ \mathsf{Hyb}_{pp'} Hyb p p ′ .
Consider the distributions H y b a ∗ = 1 / 2 ( H y b a 0 + H y b a 1 ) \mathsf{Hyb}_{a*} = 1/2(\mathsf{Hyb}_{a0} + \mathsf{Hyb}_{a1}) Hyb a ∗ = 1/2 ( Hyb a 0 + Hyb a 1 ) for a ∈ { 0 , 1 } a \in\{0,1\} a ∈ { 0 , 1 } . These are the distributions resulting from inserting a fixed phase a a a in step 4, but sending a uniformly random bit in step 7 (regardless of whether both syndrome checks pass ).
Claim 19.
∣ Pr H y b 0 ∗ [ p ′ = 1 ] − Pr H y b 1 ∗ [ p ′ = 1 ] ∣ = negl ( λ ) (15) \left| \Pr_{\mathsf{Hyb}_{0*}}[p'=1] - \Pr_{\mathsf{Hyb}_{1*}}[p'=1] \right| = \operatorname{negl}(\lambda) \tag*{(15)} Hyb 0 ∗ Pr [ p ′ = 1 ] − Hyb 1 ∗ Pr [ p ′ = 1 ] = negl ( λ ) (15)
Proof. Define the sub-hybrid H y b a ∗ ′ \mathsf{Hyb}'_{a*} Hyb a ∗ ′ where register R \mathcal{R} R is measured in the computational basis in step 4. Neither H y b a ∗ \mathsf{Hyb}_{a*} Hyb a ∗ needs the trapdoor since step 7 always reveals a random bit regardless of whether both syndrome checks pass, so H y b a ∗ \mathsf{Hyb}_{a*} Hyb a ∗ is indistinguishable from H y b a ∗ ′ \mathsf{Hyb}'_{a*} Hyb a ∗ ′ by the collapsing property of the NTCF with one bit leakage (Lemma 13). Furthermore, H y b 0 ∗ ′ = H y b 1 ∗ ′ \mathsf{Hyb}'_{0*} = \mathsf{Hyb}'_{1*} Hyb 0 ∗ ′ = Hyb 1 ∗ ′ since the phase is destroyed by measuring in the computational basis.
Now consider the distributions H y b ∗ b = 1 / 2 ( H y b 0 b + H y b 1 b ) \mathsf{Hyb}_{*b} = 1/2(\mathsf{Hyb}_{0b} + \mathsf{Hyb}_{1b}) Hyb ∗ b = 1/2 ( Hyb 0 b + Hyb 1 b ) for b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } . These are the distributions resulting from inserting a random phase in step 4, but sending d ⋅ ( r 0 ⊕ r 1 ) ⊕ b d \cdot(r_0 \oplus r_1) \oplus b d ⋅ ( r 0 ⊕ r 1 ) ⊕ b for a fixed b b b in step 7.
Claim 20.
∣ Pr H y b ∗ 0 [ p ′ = 1 ] − Pr H y b ∗ 1 [ p ′ = 1 ] ∣ = negl ( λ ) (16) \left| \Pr_{\mathsf{Hyb}_{*0}}[p'=1] - \Pr_{\mathsf{Hyb}_{*1}}[p'=1] \right| = \operatorname{negl}(\lambda) \tag*{(16)} Hyb ∗ 0 Pr [ p ′ = 1 ] − Hyb ∗ 1 Pr [ p ′ = 1 ] = negl ( λ ) (16)
Proof. Conditioned on the { Π y , I − Π y } \{\Pi_y, I-\Pi_y\} { Π y , I − Π y } measurement returning Π y \Pi_y Π y , the adversary's view after receiving register R \mathcal{R} R following step 4 is an equal mixed state over
α ∣ ϕ 0 ⟩ ⊗ ∣ 0 , r 0 ⟩ R + β ∣ ϕ 1 ⟩ ⊗ ∣ 1 , r 1 ⟩ R \alpha|\phi_0\rangle\otimes|0,r_0\rangle_{\mathcal{R}} + \beta|\phi_1\rangle\otimes|1,r_1\rangle_{\mathcal{R}} α ∣ ϕ 0 ⟩ ⊗ ∣0 , r 0 ⟩ R + β ∣ ϕ 1 ⟩ ⊗ ∣1 , r 1 ⟩ R
and
α ∣ ϕ 0 ⟩ ⊗ ∣ 0 , r 0 ⟩ R − β ∣ ϕ 1 ⟩ ⊗ ∣ 1 , r 1 ⟩ R \alpha|\phi_0\rangle\otimes|0,r_0\rangle_{\mathcal{R}} - \beta|\phi_1\rangle\otimes|1,r_1\rangle_{\mathcal{R}} α ∣ ϕ 0 ⟩ ⊗ ∣0 , r 0 ⟩ R − β ∣ ϕ 1 ⟩ ⊗ ∣1 , r 1 ⟩ R
This is precisely the mixed state
∣ α ∣ 2 ∣ ϕ 0 ⟩ ⟨ ϕ 0 ∣ ⊗ ∣ 0 , r 0 ⟩ ⟨ 0 , r 0 ∣ R + ∣ β ∣ 2 ∣ ϕ 1 ⟩ ⟨ ϕ 1 ∣ ⊗ ∣ 1 , r 1 ⟩ ⟨ 1 , r 1 ∣ R |\alpha|^2 |\phi_0\rangle\langle\phi_0| \otimes|0,r_0\rangle\langle0,r_0|_{\mathcal{R}} + |\beta|^2 |\phi_1\rangle\langle\phi_1| \otimes|1,r_1\rangle\langle1,r_1|_{\mathcal{R}} ∣ α ∣ 2 ∣ ϕ 0 ⟩ ⟨ ϕ 0 ∣ ⊗ ∣0 , r 0 ⟩ ⟨ 0 , r 0 ∣ R + ∣ β ∣ 2 ∣ ϕ 1 ⟩ ⟨ ϕ 1 ∣ ⊗ ∣1 , r 1 ⟩ ⟨ 1 , r 1 ∣ R
Thus, it is equivalent in the adversary's view to measure register R \mathcal{R} R in the computational basis in step 4. By Lemma 4, the leaked bit d ⋅ Δ d \cdot\Delta d ⋅ Δ may be indistinguishably replaced by pure randomness.
Now suppose Hyb ∗ 0 \operatorname{Hyb}_{*0} Hyb ∗ 0 were distinguishable from Hyb ∗ 1 \operatorname{Hyb}_{*1} Hyb ∗ 1 , with R \mathcal{R} R measurement, with advantage ϵ \epsilon ϵ . We construct an adversary for the adaptive hardcore bit property with advantage ϵ \epsilon ϵ . Takes as input public parameters p p \mathrm{pp} pp , then use them to run b ′ ← Hyb ∗ 0 b' \leftarrow\operatorname{Hyb}_{*0} b ′ ← Hyb ∗ 0 , except report a random bit b b b instead of the inner product d ⋅ ( r 0 ⊕ r 1 ) d \cdot(r_0 \oplus r_1) d ⋅ ( r 0 ⊕ r 1 ) . As part of this, obtain x x x from measuring R \mathcal{R} R and d d d from A \mathcal{A} A in step 6 and obtain ( x , y ) (x,y) ( x , y ) such that f p p ( x ) = y f_{\mathrm{pp}}(x)=y f pp ( x ) = y from the measurement of R \mathcal{R} R . Output ( ( x , y ) , ( d , b ⊕ b ′ ) ) ((x,y),(d,b\oplus b')) (( x , y ) , ( d , b ⊕ b ′ )) .
Observe that if b = d ⋅ ( r 0 ⊕ r 1 ) b=d\cdot(r_0\oplus r_1) b = d ⋅ ( r 0 ⊕ r 1 ) and d d d is good, then this corresponds to H ∗ 0 H_{*0} H ∗ 0 ; if b ≠ d ⋅ ( r 0 ⊕ r 1 ) b\ne d\cdot(r_0\oplus r_1) b = d ⋅ ( r 0 ⊕ r 1 ) and d d d is good then it corresponds to H ∗ 1 H_{*1} H ∗ 1 . If d d d is not good, it is identically distributed to both. Since the adversary successfully guesses b ′ = b ⊕ ( d ⋅ ( r 0 ⊕ r 1 ) ) b'=b\oplus(d\cdot(r_0\oplus r_1)) b ′ = b ⊕ ( d ⋅ ( r 0 ⊕ r 1 )) with ϵ \epsilon ϵ advantage and their advantage conditioned on invalid x x x is 0 0 0 , the reduction has advantage ϵ \epsilon ϵ in guessing a valid x x x and correct inner product ( x , d , d ⋅ ( r 0 ⊕ r 1 ) ) (x,d,d\cdot(r_0\oplus r_1)) ( x , d , d ⋅ ( r 0 ⊕ r 1 )) versus guessing a valid x x x and incorrect inner product ( x , d , 1 ⊕ ( d ⋅ ( r 0 ⊕ r 1 ) ) ) (x,d,1\oplus(d\cdot(r_0\oplus r_1))) ( x , d , 1 ⊕ ( d ⋅ ( r 0 ⊕ r 1 ))) , violating the adaptive hardcore bit property. □ \square □
Finally, we show that A \mathcal{A} A guesses 1 1 1 with almost the same probability in both the p = 0 p=0 p = 0 and p = 1 p=1 p = 1 case by combining Equation (15) with Equation (16) .
∣ Pr Hyb 00 [ p ′ = 1 ] − Pr Hyb 11 [ p ′ = 1 ] ∣ = ∣ 1 2 ( Pr Hyb 00 [ p ′ = 1 ] + Pr Hyb 01 [ p ′ = 1 ] ) + 1 2 ( Pr Hyb 00 [ p ′ = 1 ] + Pr Hyb 10 [ p ′ = 1 ] ) − 1 2 ( Pr Hyb 11 [ p ′ = 1 ] + Pr Hyb 01 [ p ′ = 1 ] ) − 1 2 ( Pr Hyb 11 [ p ′ = 1 ] + Pr Hyb 10 [ p ′ = 1 ] ) ∣ ≤ ∣ Pr Hyb 0 ∗ [ p ′ = 1 ] − Pr Hyb 1 ∗ [ p ′ = 1 ] ∣ + ∣ Pr Hyb ∗ 0 [ p ′ = 1 ] − Pr Hyb ∗ 1 [ p ′ = 1 ] ∣ = negl ( λ ) \begin{aligned}
\left|\Pr_{\operatorname{Hyb}_{00}}[p'=1]-\Pr_{\operatorname{Hyb}_{11}}[p'=1]\right|
={}&\left|\frac{1}{2}\left(\Pr_{\operatorname{Hyb}_{00}}[p'=1]+\Pr_{\operatorname{Hyb}_{01}}[p'=1]\right)+\frac{1}{2}\left(\Pr_{\operatorname{Hyb}_{00}}[p'=1]+\Pr_{\operatorname{Hyb}_{10}}[p'=1]\right)\right.\\
&\left.-\frac{1}{2}\left(\Pr_{\operatorname{Hyb}_{11}}[p'=1]+\Pr_{\operatorname{Hyb}_{01}}[p'=1]\right)-\frac{1}{2}\left(\Pr_{\operatorname{Hyb}_{11}}[p'=1]+\Pr_{\operatorname{Hyb}_{10}}[p'=1]\right)\right|\\
\le{}&\left|\Pr_{\operatorname{Hyb}_{0*}}[p'=1]-\Pr_{\operatorname{Hyb}_{1*}}[p'=1]\right|+\left|\Pr_{\operatorname{Hyb}_{*0}}[p'=1]-\Pr_{\operatorname{Hyb}_{*1}}[p'=1]\right|\\
={}&\operatorname{negl}(\lambda)
\end{aligned} Hyb 00 Pr [ p ′ = 1 ] − Hyb 11 Pr [ p ′ = 1 ] = ≤ = 2 1 ( Hyb 00 Pr [ p ′ = 1 ] + Hyb 01 Pr [ p ′ = 1 ] ) + 2 1 ( Hyb 00 Pr [ p ′ = 1 ] + Hyb 10 Pr [ p ′ = 1 ] ) − 2 1 ( Hyb 11 Pr [ p ′ = 1 ] + Hyb 01 Pr [ p ′ = 1 ] ) − 2 1 ( Hyb 11 Pr [ p ′ = 1 ] + Hyb 10 Pr [ p ′ = 1 ] ) Hyb 0 ∗ Pr [ p ′ = 1 ] − Hyb 1 ∗ Pr [ p ′ = 1 ] + Hyb ∗ 0 Pr [ p ′ = 1 ] − Hyb ∗ 1 Pr [ p ′ = 1 ] negl ( λ )