text:
# Uncloneable Encryption

## 1 Introduction

The primary application of cryptography is to send secret messages. Typically, there is a sender Alice who wishes to communicate with a receiver Bob, but an eavesdropper Eve is listening to their messages. To stop her, Alice will encrypt anything she wishes to say. In order to decrypt these messages, Bob must possess a secret key which is unknown to Eve, giving him an advantage over Eve. While Bob can easily read the secret message, Eve, lacking the key, will find it much harder to do so, or even impossible. Another common task is authentication of a message: Alice and Bob do not care if Eve reads the message, but want to make sure she does not change it. Naturally, a message can be both encrypted and authenticated.

Many cryptographic systems are based on computational assumptions. In this case, Eve’s task of learning the contents of a message (or even learning a single bit of information about the message) is equivalent to solving some computationally difficult problem, one that cannot be answered in polynomial time in some security parameter $`s`$. These cryptosystems come in two flavors: symmetric systems, in which Alice’s encryption key is the same as Bob’s decryption key; and asymmetric systems, in which they are different. Asymmetric systems are usually public key systems in which Alice’s encryption key is also known to Eve. However, Bob’s key must always be secret, or else Eve can decode the message just as easily as Bob.

Stronger security can be provided by the one-time pad. In this scheme, Alice and Bob share a secret key that is as long as the message. The ciphertext for the encrypted message consists of the bits of the original plaintext XORed with the corresponding bits of the key. When the key is only used once, this scheme is unconditionally secure: lacking information about the key, Eve cannot learn anything at all about the message, no matter what computational power she has.

However, the following “cloning” attack will break even the one-time pad:

1. Alice and Bob share a secret (classical) key $`k`$.
2. Alice encrypts a (classical) message $`m`$ to Bob using an encryption scheme with the key $`k`$.
3. Eve receives the message, and performs an attack of her choice. In particular, she attempts to copy the encrypted message.
4. Eve passes the original message on to Bob, who checks if it has been tampered with.
5. Eve acquires a copy of the secret key $`k`$.

When the ciphertext is classical, Eve can copy the message without changing it at all. Therefore, when Bob receives the message, he does not know Eve has interfered with the transmission. Still, when Eve learns the key in the final step, she can read the message without difficulty.

For the one-time pad, perhaps this attack is not a severe worry. Since the key is not needed again once the message is read, it makes sense to destroy it immediately. However, this is not as easy as it sounds: typically the key must be stored for a while, perhaps on a magnetic medium such as a hard drive. Simply asking a computer to “delete” a file only eliminates the directory entry for the file. Actually erasing a file requires a separate program to overwrite the bits of the file. Even then, traces remain which are accessible to forensic techniques. Schneier , for instance, recommends multiple overwriting or physical destruction of magnetic media containing expired keys. The message, in contrast, can be deleted immediately upon being read, and need never leave RAM. It is thus much easier to erase without leaving any traces behind.

The cloning attack is a more serious problem for computationally secure schemes. In such schemes, the same key is typically used repeatedly, giving Eve more opportunity to steal it, enabling her to read not only future messages, but past ones as well. In fact, Eve may not even need to steal the key: she can simply copy down the message and begin a time-consuming brute-force attack on the computational assumption. Alternately, she could wait in the hopes that future improvements in computer hardware or algorithms make it easier to break the encryption scheme. Furthermore, having the ciphertext of many encrypted messages to examine is very helpful when performing cryptanalysis.

Quantum states have the property that they cannot be copied . (See the textbook of Nielsen and Chuang  for an introduction to quantum information.) However, on the surface, this only applies to superpositions of states. For instance, if a classical message is sent using a standard set of basis states, it can easily be copied without being disturbed. In general, an unencrypted classical message can always be copied: reading it constitutes making a copy. However, when we move to encrypted classical messages, the picture is very different. By encrypting a classical message using quantum states, we can produce uncloneable encryption schemes, which are secure even against the cloning attack. In particular, for any attack by Eve, either she gets caught by Bob with high probability (for instance, if she steals the message), or she gets almost no information about the message.

Quantum mechanics has other cryptographic applications as well (see  for a survey). The best-known is quantum key distribution (QKD) , which enables Alice and Bob to create a secure classical secret key despite the potential presence of an eavesdropper. QKD requires only an insecure quantum channel and authenticated (but unencrypted) classical channels, but unfortunately requires multiple rounds of back-and-forth communication between Alice and Bob. The primary proposed application of QKD is to create a secret key which is then used with the one-time pad to send unconditionally secure messages. In contrast, uncloneable encryption is a noninteractive protocol which can be used to enhance the security of the one-time pad or computationally secure encryption schemes. Alternatively, it can be used to perform QKD in a way requiring relatively little interaction, and with other small improvements in efficiency and security. Noninteractivity is useful in a variety of contexts. It is essential for storage of information, and important when there is a substantial transmission lag (for instance, when communicating with a space probe in the outer solar system). It is also very convenient for more mundane communication contexts where there is a modest, but not completely negligible, time cost for transmissions. Uncloneable encryption is closely related to some forms of QKD, but it can be best viewed as a stronger version of symmetric encryption that shares the intrusion-detection ability of quantum key distribution. Another related concept is that of “secure direct communication,”  which is, however, also explicitly interactive. Curiously, the protocol most closely related to uncloneable encryption is actually an unpublished precursor  to BB84 (which I only learned of after completing the first version of this paper), in which messages are encrypted in a way similar to that described below. The notion of uncloneability did not exist; instead, the purpose of that protocol was to reuse the secret key if no intrusion was detected.

Another side of the subject of quantum cryptography is to create cryptographic protocols to protect quantum states. For instance, protocols for encryption  and authentication  of quantum states exist. The quantum authentication schemes, in particular, differ substantially from classical schemes in that any quantum authentication scheme must also encrypt a message. It turns out that quantum authentication protocols have precisely the properties needed to create uncloneable encryption schemes. In the past, cryptographic protocols for quantum and classical messages have been viewed largely as parallel subjects which have a good deal of similarity, but little direct connection; this result establishes a more intimate relationship, where a protocol for quantum states can be used to perform a task protecting classical data.

In section 2, I give a technical definition of uncloneable encryption, and show that any authentication scheme for quantum states can be used as a secure uncloneable encryption scheme. In section 3, I go on to discuss the relationship between uncloneable encryption and QKD. Section 4 describes a “prepare-and-measure” uncloneable encryption scheme similar to the well-known BB84 QKD protocol. Such a scheme does not require entangling quantum operations or a quantum memory, and therefore might be experimentally implementable in the near future. In section 5, I show that uncloneable encryption remains secure when the key is not a single-use item, but is instead generated with a pseudorandom number generator based on a computational assumption. Finally, I conclude in section 6 with some remaining open questions.

## 2 Uncloneable Encryption and Quantum Authentication

I will suppose throughout most of this paper that Alice and Bob share a secret classical key $`k𝒦`$ which they will only use to send one message. If Alice wants to send a classical message $`m`$ to Bob, she will use some encoding that depends on $`k`$; in general this could be a mixed state $`\sigma _k(m)`$. In order for this to be a good encryption scheme, the transmitted density matrix, averaged over possible values of the key, should not depend on the message:

###### Definition 1

Let $`\sigma (m)=(_k\sigma _k(m))/|𝒦|`$. Then $`\sigma _k(m)`$ is an (unconditionally secure) encryption scheme with error $`ϵ`$ if the trace distance $`D(\sigma (m),\sigma (m^{}))=\frac{1}{2}\mathrm{Tr}|\sigma (m)\sigma (m^{})|ϵ`$ for $`mm^{}`$.

That is, someone who does not know the key has essentially no information about the message. Definition 1 only addresses the secrecy of the message; for a useful protocol, we also require that someone who does know the key is able to read the message. In fact, we usually restrict attention to encoding schemes for which there are computationally efficient procedures to encode $`(m,k)\sigma _k(m)`$ and decode $`(\sigma _k(m),k)m`$.

In order to have an uncloneable encryption scheme, we need an additional condition. A general attack by Eve is a superoperator $`𝒜`$ acting on $`\sigma _k(m)`$. This represents the action Eve performs when she first gets the encrypted state, before she learns the key, so $`𝒜`$ cannot depend on $`k`$. The output of $`𝒜`$ can be divided into two parts, a density matrix $`\sigma _{\mathrm{Bob},k}(m)`$ which is sent on to Bob and the remainder which is kept by Eve.

To take the next step, we must assume Bob has some efficient checking procedure $`(\sigma _{\mathrm{Bob},k}(m),k)\{\mathrm{ACC},\mathrm{REJ}\}`$ which allows him to detect Eve’s tampering. He accepts the message when he gets outcome $`\mathrm{ACC}`$; when he gets outcome $`\mathrm{REJ}`$ he concludes Eve may have stolen the encrypted message, and he and Alice can take whatever steps are necessary to protect themselves. They may need to protect the key $`k`$ especially well, for instance, or act to neutralize any damage caused if Eve learns $`m`$. We let $`\rho _k(m)`$ be Eve’s residual density matrix conditioned on the case that Bob gets outcome $`\mathrm{ACC}`$, and let $`P_k(m)`$ be the probability that Bob accepts the message $`m`$. In general, $`\rho _k(m)`$ and $`P_k(m)`$ can depend on the attack $`𝒜`$. For notational simplicity, I will hereafter write $`P_k(m)`$ simply as $`P(m)`$.

###### Definition 2

An encryption scheme $`\sigma _k(m)`$ with error $`ϵ`$ is an uncloneable encryption scheme with error $`ϵ`$ if, for any two messages $`mm^{}`$ and all attacks $`𝒜`$ by Eve, for a fraction of at least $`1ϵ`$ of the possible values of the key $`k`$, the trace distance $`D(P(m)\rho _k(m),P(m^{})\rho _k(m^{}))ϵ`$.

Note that it is easy from this definition to prove two useful properties: that $`|P(m)P(m^{})|`$ is small and that, except when $`P(m)`$ is very small, $`D(\rho _k(m),\rho _k(m^{}))`$ is small. That is, Eve’s chance of being caught does not depend much on the message being sent, and, unless she has a large chance of being caught, she has little information about the message, even after learning the key. In particular, Eve cannot tell whether the message was $`m`$ or $`m^{}`$. Note that an uncloneable encryption scheme by definition must also encrypt the message, so that Eve, even if she gets caught, cannot read the message until she learns the key. It is unclear whether this is an independent condition, or whether it would follow from the uncloneability requirement alone. (A classical message sent completely unencrypted can always be copied, but it may be possible to create partially encrypted messages which are uncloneable.)

To create uncloneable encryption schemes, we can use quantum authentication schemes. A quantum authentication scheme is an encoding that works on unknown quantum states: $`(|\psi ,k)\sigma _k(|\psi )`$, where $`|\psi `$ is from some Hilbert space $``$. This map should be a quantum operation (for instance, it must be linear on the Hilbert space for $`|\psi `$) and should be implementable efficiently. Eve then performs an attack $`𝒜`$, producing a state $`\sigma _{\mathrm{Bob},k}(|\psi )`$ which is sent on to Bob. Bob then has an efficient decoding quantum operation $`𝒟(\sigma _{\mathrm{Bob},k}(|\psi ),k)`$. The image of $`𝒟`$ is $`_2`$, where $`_2`$ is a two-dimensional Hilbert space with basis $`|\mathrm{ACC}`$, $`|\mathrm{REJ}`$.

A secure authentication scheme should, for any attack $`𝒜`$, produce either the outcome $`|\mathrm{REJ}`$ or the original state $`|\psi `$. Of course, for a quantum system, a superposition of these would also be acceptable. Therefore, we let $`\mathrm{\Pi }(|\psi )`$ be the projector onto the “bad” subspace containing states $`|\mathrm{ACC}|\varphi `$, where $`|\varphi `$ is orthogonal to $`|\psi `$. We can then define a secure quantum authentication scheme:

###### Definition 3

The encoding $`\sigma _k(|\psi )`$ is a quantum authentication scheme with error $`ϵ`$ if, for all $`|\psi `$,

$$\frac{1}{|𝒦|}\underset{k}{}\mathrm{Tr}\left[\mathrm{\Pi }(|\psi )𝒟(\sigma _{\mathrm{Bob},k}(|\psi ),k)\right]ϵ.$$
(1)
The following theorem was proved in previous work:

###### Theorem 4

A quantum authentication scheme with error $`ϵ`$ is an encryption scheme with error at most $`4ϵ^{1/6}`$.

In fact, the family of quantum authentication schemes presented previously  all provided perfect encryption. As a consequence of theorem 4, if we send a classical message as a basis state for a quantum authentication scheme, it is necessarily encrypted as well. In fact, we can go even further: it satisfies definition 2 for security against cloning attacks.

###### Theorem 5

A quantum authentication scheme with error $`ϵ`$ is an uncloneable encryption scheme with error at most $`(15/2)ϵ^{1/6}`$ (for small $`ϵ`$).

Proof:

We can work with a purification of the original quantum authentication scheme, so that Alice’s encoding of a pure state $`|\psi `$ is again a pure state for a given value $`k`$ of the classical key. Then for a particular value of the key, after Eve’s attack and Bob’s decoding, we can write the state as

$$|\mathrm{ACC}|\psi |\varphi _k+|\mathrm{REJ}|\xi _k+|\mathrm{ACC}|\eta _k,$$
(2)
where $`|\xi _k`$ and $`|\eta _k`$ are split between Bob and Eve, with $`|\eta _k`$ orthogonal to $`|\psi `$. $`|\varphi _k`$ is held by Eve. Since this is a secure authentication scheme, $`(_k|\eta _k^2)/|𝒦|ϵ`$. In general, the various states depend on $`|\psi `$ as well as $`k`$ and $`𝒜`$.

When we send two possible classical messages $`m`$ and $`m^{}`$ with this authentication scheme, we get

$`m`$ $``$ $`|\mathrm{ACC}|m|\varphi _k(m)+|\mathrm{REJ}|\xi _k(m)+|\mathrm{ACC}|\eta _k(m),`$ (3)
$`m^{}`$ $``$ $`|\mathrm{ACC}|m^{}|\varphi _k(m^{})+|\mathrm{REJ}|\xi _k(m^{})+|\mathrm{ACC}|\eta _k(m^{}).`$ (4)
However, since it is a quantum authentication scheme, Alice could have sent $`|m+|m^{}`$ and it would have arrived safely:

$$(|m+|m^{})|\mathrm{ACC}\left(|m+|m^{}\right)|\varphi _k+|\mathrm{REJ}|\xi _k+|\mathrm{ACC}|\eta _k.$$
(5)
(Since $`|m+|m^{}`$ is not normalized, $`|\varphi _k`$, $`|\xi _k`$, and $`|\eta _k`$ are all bigger by a factor of $`\sqrt{2}`$ than the corresponding terms in (2).) By linearity,

$`|m+|m^{}`$ $``$ $`|\mathrm{ACC}\left(|m|\varphi _k(m)+|m^{}|\varphi _k(m^{})\right)`$
$`+|\mathrm{REJ}\left(|\xi _k(m)+|\xi _k(m^{})\right)+|\mathrm{ACC}\left(|\eta _k(m)+|\eta _k(m^{})\right).`$
The first term is the most interesting: if Eve’s residual states $`|\varphi _k(m)`$ and $`|\varphi _k(m^{})`$ are too different, they become entangled with the message ket, and the state received by Bob is no longer the superposition $`|m+|m^{}`$, but a mixture of $`|m`$ and $`|m^{}`$. In particular, we can write

$`|m|\varphi _k(m)+|m^{}|\varphi _k(m^{})`$ $`=`$ $`\left(|m+|m^{}\right)\left(|\varphi _k(m)+|\varphi _k(m^{})\right)/2`$
$`+\left(|m|m^{}\right)\left(|\varphi _k(m)|\varphi _k(m^{})\right)/2.`$
Thus

$$|\eta _k=|\eta _k(m)+|\eta _k(m^{})+\left(|m|m^{}\right)\left(|\varphi _k(m)|\varphi _k(m^{})\right)/2.$$
(8)
(Actually, some part of the first two terms could conceivably contribute to $`|\varphi _k`$, but that will only help the bound of equation (10).) Since $`|\eta _k`$, $`|\eta _k(m)`$, and $`|\eta _k(m^{})`$ must all have small norm for most $`k`$, so must the difference $`|\varphi _k(m)|\varphi _k(m^{})`$. In particular, for a fraction at least $`11/q`$ values of $`k`$, $`|\eta _k(m)^2qϵ`$, and similarly for $`|\eta _k(m^{})`$ (with $`q>1`$). $`|\eta _k^22qϵ`$ instead, because of normalization. Thus, for a fraction at least $`13/q`$, all three of the norms squared are less than $`qϵ`$ (or $`2qϵ`$). From (8),

$$|\varphi _k(m)|\varphi _k(m^{})/\sqrt{2}|\eta _k+|\eta _k(m)+|\eta _k(m^{}).$$
(9)
It follows that

$$|\varphi _k(m)|\varphi _k(m^{})2(1+\sqrt{2})\sqrt{qϵ}5\sqrt{qϵ}$$
(10)
for the same fraction at least $`13/q`$ of the $`k`$’s. At this point, we are effectively done, since we have shown that Eve’s residual states are very similar for the two messages. The remainder of the proof is just massaging the formulas to get back to the correct form for the definition of security.

###### Claim 6

For those $`k`$s satisfying the above constraints,

$$D(P(m)\rho _k(m),P(m^{})\rho _k(m^{}))qϵ+\sqrt{20\sqrt{qϵ}}+5\sqrt{qϵ}$$
(11)
The proof of this claim is fairly mechanical, and is given in appendix A.

Equation (11) is valid for a fraction $`13/q`$ of the possible values of $`k`$. If we set $`q=2/(5ϵ^{1/5})`$ (which will be greater than $`1`$ for small $`ϵ`$), we find that

$$D(P(m)\rho _k(m),P(m^{})\rho _k(m^{}))(1/2)ϵ^{4/5}+3.6ϵ^{1/5}+3.2ϵ^{2/5}\frac{15}{2}ϵ^{1/6}$$
(12)
Note that $`3/q`$ is also less than $`(15/2)ϵ^{1/6}`$, completing the proof of the theorem. $`\mathrm{}`$

Theorem 5 provides a good way of constructing uncloneable encryption schemes. We need to come up with efficient quantum authentication schemes, such as those given by Barnum et al , and that gives us uncloneable encryption schemes. However, it is not clear if this is the only way to produce uncloneable encryption protocols. Quantum authentication schemes must authenticate the data in both the computational and Fourier-transformed basis. The proof of theorem 5 suggests that authenticating in the Fourier basis is what produces the uncloneability property, but there is no apparent reason we need to also authenticate in the computational basis. I therefore conjecture that uncloneable encryption schemes exist which do not authenticate the classical message and do not come from quantum authentication schemes, but I am not aware of any examples. If true, the conjecture would imply that quantum authentication is a strictly stronger property than uncloneability.

There is another point worth noting about theorem 5: it is an efficient reduction. That is, given an attack against the uncloneable encryption scheme, we can efficiently generate an attack against the parent quantum authentication scheme. This fact will be critical in section 5, which discusses computationally secure uncloneable encryption schemes.

## 3 Uncloneable Encryption and QKD

A careful consideration of uncloneable encryption reveals that it is closely related to another well-known quantum cryptographic task: quantum key distribution. In fact, any uncloneable encryption scheme can be used to perform secure quantum key distribution. In QKD, Alice and Bob share authenticated classical channels and an insecure quantum channel, and use just those resources to create a shared secret key. Alice and Bob do not (generally) use any pre-existing secret key beyond whatever is used in the classical authentication.

Given these same resources and an uncloneable encryption scheme, Alice can perform QKD with the following protocol:

1. Alice generates random strings $`k`$ and $`x`$.
2. Alice sends the message $`x`$ to Bob using the uncloneable encryption scheme with key $`k`$.
3. Bob announces (on the authenticated classical channel) that he received the message.
4. Alice announces $`k`$ (again using the authenticated classical channel).
5. Bob checks if the message is valid, and reports the result. If it is, Alice and Bob use $`x`$ as their new secret key.

The properties of uncloneable encryption guarantee that this is a secure QKD scheme: Eve gets the quantum state and then later learns the key, but we know that her residual density matrices, conditioned on Bob’s accepting the transmission, are very similar. Therefore, she almost always (for most values of $`k`$) has little information about the established key $`x`$.<sup>1</sup><sup>1</sup>1In fact, most QKD schemes ask for an additional property: that Alice and Bob should have the same value for the agreed-on key. Since we do not require that an uncloneable encryption scheme authenticate the classical message, we do not necessarily have this property of QKD. However, it can easily be guaranteed in one of two ways: either classically authenticate $`x`$ before sending it with the uncloneable encryption, or use an uncloneable encryption scheme derived from quantum authentication, which will automatically authenticate the classical message as well.

In fact, this is a stronger security condition than what is usually proved about QKD: most proofs only let Eve retain classical information after QKD terminates, whereas here we are letting Eve retain quantum information (although one argument  contains a very similar statement imbedded in the proof). This is an important improvement, since it makes it much easier to prove that the key generated via QKD can be used in other cryptographic tasks. For instance, a proof of the security of the one-time pad goes as follows: We wish to show that Eve cannot distinguish between two messages $`a`$ and $`b`$ given the ciphertext $`y`$. But this is equivalent to Eve distinguishing between the two keys $`x=ay`$ and $`x^{}=by`$, and we know that the trace distance between Eve’s residual density matrices for these two cases is very small. Therefore, Eve has little chance of being able to distinguish the messages $`a`$ and $`b`$.

While we can produce a QKD protocol from any uncloneable encryption scheme, the converse is not necessarily true. We shall see in the next section that there is an uncloneable encryption scheme that corresponds very closely to the BB84 QKD protocol, but there are other QKD protocols which do not appear to have any uncloneable encryption analogue. For instance, QKD protocols with two-way classical post-processing  are too interactive to become uncloneable encryption schemes, but this is perhaps not an important distinction since there are certainly interactive quantum authentication schemes of the same form.

More interesting is the B92 QKD protocol . In B92, Alice sends one of two nonorthogonal states. Each is part of a particular basis for the Hilbert space. Bob, when he receives the transmission, randomly chooses one of the two bases to measure in for each qubit. If he chooses the wrong basis, he has a chance of getting a state orthogonal to the one Alice could have sent; in that case, he knows he chose the wrong basis, and therefore knows which basis Alice used. In all other cases, the qubit is discarded and does not influence the final key. In BB84, many qubits are also discarded, but this is simply an artifact of Bob’s initial ignorance of the basis, and is unnecessary if Bob has quantum storage or, in the case of uncloneable encryption, prior information about what the basis will be. In contrast, in B92, the basis choice determines the message sent, so Alice cannot ever announce it and Bob cannot know it ahead of time. Consequently, discarding transmitted states is an intrinsic part of the protocol. For this reason, there does not appear to be an uncloneable encryption analogue of B92.

We therefore have a situation where quantum authentication is slightly stronger than uncloneable encryption, which is in turn slightly stronger than quantum key distribution. Nevertheless, the differences are really quite small, meaning quantum authentication and quantum key distribution are closely related. This is rather surprising, given that the tasks of authenticating quantum information and encrypting classical information at first sight appear completely unrelated.

The connection between quantum authentication and quantum key distribution helps us understand the conceptual structure of QKD. The Shor-Preskill proof of security  showed us that the error correction and privacy amplification steps of QKD could be seen as parts of a virtual quantum error correction procedure taking place on some purification of the state. Similarly, the process of testing bit error rate can now be seen as coming from quantum authentication: the error test in QKD comes from the authentication test in the parent quantum authentication protocol.

## 4 Uncloneable Encryption Without Entangled States

In order to realize uncloneable encryption with near-future technology, it is necessary to have a protocol which does not require much in the way of coherent quantum manipulations, transmission, or storage. QKD is a good source of models; for instance, both BB84 and B92 are “prepare-and-measure” protocols where Alice sends unentangled qubits to Bob and Bob measures them immediately upon receiving them, without having to store them at all. We now wish to find an uncloneable encryption protocol with this same structure.

One straightforward solution is simply to take BB84 and add a layer of encryption. That is, Alice encrypts her message with a one-time pad, encodes it with an error-correcting code, and further encodes it as a set of parity checks (coming from privacy amplification). Then she sends each bit of the resulting expanded message in one of two bases, and intersperses at random a number of check bits. The state of the check bits, as well as the bases and other parameters, are determined by the key, and Bob accepts the message only if the error rate on the check bits is within an acceptable range.

The above proposal, when appropriately fleshed out, gives a secure uncloneable encryption protocol. However, the connection with quantum authentication suggests more efficient ways of checking for eavesdropping. To start, I will construct a quantum authentication protocol, and then use theorem 5 to convert it to an uncloneable encryption protocol. The resulting protocol will involve a good deal of entanglement. Then I will use the technique of Shor and Preskill  to convert this to a “prepare-and-measure” protocol free of entanglement. The details of the construction require a certain amount of technical background beyond the scope of this paper, so I postpone the derivation and proof of security to appendix B. In this section, I simply present the resulting “prepare-and-measure” protocol and discuss some extensions and applications to QKD.

The uncloneable encryption scheme will be designed to work through a noisy channel and will depend on a choice of two classical linear codes. $`C_1`$ will be used to correct bit flip errors in the data. Let $`\delta `$ be the average of the rates of bit flip and phase errors introduced by the noisy channel; since the qubits transmitted will be sent in one of two bases, $`\delta `$ will be the actual rate of errors in the transmitted message in the absence of an eavesdropper. $`C_1`$ will encode $`K`$ bits in $`N`$ bits and will have distance $`2\delta N`$; that is, it will correct a fraction $`\delta `$ errors. By the Gilbert-Varshamov bound, such a code exists (for large $`N`$) with $`K/N1h(2\delta )`$, where $`h(x)=x\mathrm{log}_2x(1x)\mathrm{log}_2(1x)`$ is the binary entropy function. $`C_1`$ is defined by $`NK`$ parity checks, which can be encapsulated in a parity check matrix $`H`$. The set of vectors $`𝐯`$ with a particular value for $`H𝐯`$ is called a coset of $`C_1`$; the error-correcting code is generally considered to be the coset with $`H𝐯=\mathrm{𝟎}`$, but all the other cosets have the same error-correcting properties. We have, for a particular $`C_1`$, some standard decoding algorithm $`M`$ which maps elements of one coset into another. Since the code has distance $`2\delta N`$, different errors of weight less than $`\delta N`$ take us to different cosets, and $`M`$ can therefore be chosen to correct any such error. In order to have a practical protocol, we actually need to choose a carefully-constructed $`C_1`$ so that $`M`$ can be implemented efficiently. This is a challenging task, and the focus of much of classical coding theory, and I will for this paper simply assume that we have an efficient decoding algorithm.

The second classical code, $`C_2`$, is used to perform what, in the context of BB84, would be called privacy amplification. Eve might choose to measure only a few of the transmitted qubits, in which case she is unlikely to be detected by Bob; if she gets lucky in choosing bases, we need to be sure she still gets little information about the data (after she learns the key). $`C_2`$ must correct a slightly larger fraction of errors than $`C_1`$, so we will give it distance $`2(\delta +\eta )N`$. $`C_2`$ encodes $`K^{}`$ bits in $`N`$ bits and satisfies $`C_2^{}C_1`$ (where $`C_2^{}`$ is the standard classical dual code containing all vectors orthogonal to $`C_2`$ in the usual binary inner product). We can choose a $`C_2`$ with these properties and $`K^{}/N1h(2\delta +2\eta )`$ . We will not require that $`C_2`$ have an efficient decoding algorithm.<sup>2</sup><sup>2</sup>2Actually, we only require that $`C_2`$ correct errors modulo $`C_1^{}`$ (i.e., errors which sum to elements of $`C_1^{}`$ are considered equivalent) due to the existence of degenerate quantum codes. This is potentially important, as it is unclear whether it is possible to choose an efficiently decodeable $`C_1`$ such that $`C_2`$ has good minimum distance, but it is much easier to do so with the looser requirement on $`C_2`$.

The actual uncloneable encryption protocol will encrypt a message $`m`$ of length $`n`$ bits. There will be a security parameter $`s`$ and we will choose $`K+K^{}N=n+s`$. The protocol will transmit $`N`$ qubits and will use a classical key consisting of four parts: $`(k,e,c_1,b)`$. All are chosen uniformly at random; their lengths are described below.

1. Divide the $`n`$ input bits into $`r`$ groups of size $`s`$. View each group of $`s`$ bits as an element of the finite field $`GF(2^s)`$. $`k`$ is a string of size $`s`$, and we can also view it as an element of $`GF(2^s)`$.
2. The $`r`$ resulting registers $`m_0,\mathrm{},m_{r1}`$ can be viewed as the first $`r`$ coefficients of a degree $`r`$ polynomial $`f`$. The final coefficient $`m_r`$, the constant term, is chosen so that $`f(k)=0`$. That is, $`_im_ik^{ri}=0`$ (in $`GF(2^s)`$).
3. Alice XORs the string $`(m_0,\mathrm{},m_r)`$ with the $`(n+s)`$-bit string $`e`$, producing a new classical string $`y`$ of length $`n+s`$ bits.
4. Alice considers the particular coset of the classical error-correcting code $`C_1`$ given by the syndrome $`c_1`$; that is, she considers the coset satisfying $`H𝐯=𝐜_\mathrm{𝟏}`$. (The length of $`c_1`$ is equal to the number of parity checks, namely $`NK`$.)
5. Within that coset of $`C_1`$ are various cosets of $`C_2^{}`$ (which, recall, is a subset of $`C_1`$). In fact, there are exactly $`2^{n+s}`$ of them, and they can be distinguished by parity checks which are elements of the code $`C_2`$ but are not in $`C_1^{}`$ (since all elements of a given coset of $`C_1`$ have the same value for parity checks from $`C_1^{}`$). There is thus a correspondence between the cosets $`C_1/C_2^{}`$ and strings $`y`$ (from step $`3`$). Alice selects the coset corresponding to $`y`$ and then picks a random $`N`$-bit string $`z`$ within that coset.
6. Alice transmits $`N`$ qubits as follows: When the $`i`$th bit of $`b`$ is $`0`$, Alice transmits the $`i`$th bit of $`z`$ in the $`Z`$ basis ($`|0`$, $`|1`$). When the $`i`$th bit of $`b`$ is $`1`$, Alice transmits the $`i`$th bit of $`z`$ in the $`X`$ basis ($`|0+|1`$, $`|0|1`$).

To decode, Bob simply reverses this series of actions:

1. Bob receives $`N`$ qubits. When the $`i`$th bit of $`b`$ is $`0`$, he measures the $`i`$th qubit in the $`Z`$ basis; when the $`i`$th bit of $`b`$ is $`1`$, he measures the $`i`$th qubit in the $`X`$ basis. He now has an $`N`$-bit classical string $`z`$.
2. Bob calculates the parity checks of the classical code $`C_1^{}`$. If they are not equal to the string $`c_1`$, there are errors in the state, which he corrects using the standard decoding map $`M`$.
3. Bob evaluates the parity checks of $`C_2/C_1^{}`$, producing a $`(n+s)`$-bit string $`y`$. (This step is effectively the privacy amplification step in BB84.)
4. Bob XORs $`y`$ with the $`(n+s)`$-bit string $`e`$, producing a new string $`(m_0,\mathrm{},m_r)`$.
5. Bob has now received the $`n`$-bit message $`(m_0,\mathrm{},m_{r1})`$. To check whether he accepts this or not (that is, to detect eavesdropping by Eve), he considers the $`s`$-bit registers $`m_0,\mathrm{},m_r`$ as elements of $`GF(2^s)`$ and coefficients of a degree $`r`$ polynomial $`f`$ over $`GF(2^s)`$. He evaluates $`f(k)`$ and accepts the message only if $`f(k)=0`$.

The shared classical key, as noted above, consists of $`(k,e,c_1,b)`$. $`k`$ is an $`s`$-bit string, $`e`$ is $`n+s`$ bits long, $`c_1`$ is $`NKh(2\delta )N`$ bits, and $`b`$ is $`N`$ bits long. $`s`$ and $`\eta \sqrt{N}`$ are the security parameters: the security $`ϵ`$ of the uncloneable encryption protocol is exponentially small when the two security parameters are large. In particular, $`\eta `$ can go to $`0`$ as $`n`$ becomes large without severely impacting the security of the protocol. All in all, then, Alice and Bob use $`n+2s+NK`$ bits of key. In the limit of a perfect channel (i.e., $`\delta =0`$), they use $`n+2s+(n+s)/[1h(2\eta )]`$ bits of key, which asymptotes to $`2n+3s`$ as $`n`$ becomes large and $`\eta `$ becomes small. In addition, Alice chooses $`NK^{}`$ random bits which are not part of the key. Bob need not know the values of these bits ahead of time. On the other hand, these random bits must never be revealed to Eve, even after Bob has successfully received the transmission (when, by the uncloneability property, it is safe for Eve to learn the key). Otherwise the benefits of the privacy amplification step would be eliminated, and Eve could possibly learn a few bits of information about the message (though only if she also knows $`e`$).

For the basic protocol, we assume the full key is used for just a single message, which would suggest uncloneable encryption uses up more than twice as much key as the one-time pad. However, we can partially lift this restriction by encrypting the whole message. Instead of the secret keys $`e`$ and $`c_1`$, we use a key $`e^{}`$ of length $`N`$ to encrypt the final string $`z`$ before encoding it as quantum states. Because of this encoding, the state being transmitted is the identity density matrix, and therefore Eve, even if she knows the original message $`m`$, has no information about the keys $`k`$ and $`b`$. (She does learn something about $`e^{}`$, though.) We can therefore reuse the keys $`k`$ and $`b`$ in later messages and the system remains secure, so long as we use a new $`e^{}`$ for each message. This gives us a reusable key $`(k,b)`$ of size $`s+N`$ and a one-time key $`e^{}`$ of length $`N`$ which must be refreshed for each new message. In the limit of long messages and low channel error rate, the key expended per uncloneably encrypted message is asymptotically the same as that used by a message encrypted with the one-time pad.

In a very real sense, the reusable key provides the uncloneability property and the one-time key provides the encryption. If Eve, after seeing many messages, ever learns the reusable key $`(k,b)`$, by the uncloneability property, she still has no information about past messages. Future messages remain encrypted with the one-time pad, since they use new values of $`e^{}`$, but Eve can easily copy these messages, and if she eventually learns $`e^{}`$ for one of these later messages, she can read the message. On the other hand, if after transmission, Eve ever learns $`e^{}`$ for a particular message, she again has no information about that message (by uncloneability), but she might be able to learn information about the values of $`k`$ and/or $`b`$ used for that message. This would imperil unclonability of future messages.

The above protocol has a “prepare-and-measure” form and therefore might be suited to experimental realization sometime in the near future. However, it is somewhat more challenging than the closely related BB84 QKD protocol. In particular, in BB84, it is harmless to discard any qubits which are not received by Bob for whatever reason. In contrast, for uncloneable encryption, discarded bits cut away at the error-correcting code protecting the data. In fact, they act as erasure errors and should be treated as such. A quantum error-correcting code can only tolerate a certain proportion of erasures (half if there are no other errors in the system), and therefore uncloneable encryption will only work if the rate of photon absorption is not too high. Therefore, uncloneable encryption requires high efficiency single-photon sources and detectors, which are useful for QKD but not required. This restriction can be seen as a cost of going to a non-interactive uncloneable encryption protocol rather than an interactive QKD protocol. One possible solution is to use a squeezed-state cryptographic scheme , which largely avoids this problem.

Alternatively, it is straightforward to use the above protocol for QKD. Alice simply sends a string of bits in some series of bases $`b`$, Bob measures in whichever bases he likes, and they keep only those qubits which are received and for which their bases agree. Alice announces $`b`$ along with randomly chosen values for the other parts of the key, and then does the same decoding procedure as Bob, ensuring that they agree on a final secret key. There are a few advantages to doing this over the usual approach to QKD. First, we get the strong security condition described in section 3. Second, because of the connection with quantum authentication, it is clear how to create protocols like the one from this section which use a much more efficient test for eavesdropping than the usual prescription for BB84 (which reveals a substantial fraction of the originally transmitted bits to compare error rates). Third, Alice and Bob could take their bases from a pseudorandom sequence generated by a short shared key, as discussed in the next section. Then, instead of discarding half of all bits received, Bob can be sure he measures every qubit in the same basis Alice used. The result is no longer unconditionally secure, but they instead have unconditional forward secrecy: provided Eve is faced with a computational limitation during the initial transmission, she cannot ever learn the established key, even after her computational bound is lifted. (This result will be shown in the following section.) Unconditional forward secrecy is also available in some classical protocols, but those require an external source of randomness and a potentially unrealistic temporary memory bound on the adversary . Efficient QKD protocols  (in which Alice and Bob use the two bases with unequal probabilities) can also reduce the number of qubits discarded. The efficient QKD protocols do not require even a temporary computational assumption, but also do not completely eliminate wasted transmissions.

Note that it is insecure to combine the reusable key refinement with QKD. Since the one-time key $`e^{}`$ must be announced when performing QKD, Eve learns it and can therefore learn information about the supposedly reusable key $`(k,b)`$. She could then use this information to break later QKD protocols which attempt to reuse $`(k,b)`$.

## 5 Computational Security

The key requirements of uncloneable encryption are not immense (roughly $`2n`$ for long messages), but are still more than is desireable in a truly non-interactive setting (where QKD is not available to produce more key). In classical cryptography, we frequently use a computational assumption to encrypt long messages with a short key. Does uncloneable encryption still work if the key is not truly random, but is instead a pseudorandom sequence generated from a much shorter secret key shared by Alice and Bob?

A similar question arises in the context of QKD. Alice must make a lot of random choices when preparing the qubits to send to Bob. Generating truly random numbers can be a difficult task. If she instead generates a long pseudorandom sequence, what does that do to the security of QKD?

In both cases, the answer is that Eve still cannot learn the secret message, provided she has no quantum algorithm to break the pseudorandom sequence. Furthermore, even if she can eventually break the computational assumption, it will do her no good: in order to defeat Alice and Bob, Eve must break the pseudorandom sequence before Bob receives the quantum transmission from Alice. Intuitively, this makes a lot of sense: unless she can defeat the scheme during transmission, the uncloneability property holds, preventing her from copying the message down to work on it later. (Note, though, that the values of the bits Alice transmits in QKD, including any lost to privacy amplification, should be truly random or there is no hope of long-term security once the computational restriction is lifted.)

I will prove this in the case of an uncloneable encryption scheme $`𝒮`$ derived from quantum authentication schemes under theorem 5. In particular, this holds for the uncloneable encryption scheme presented in section 4. The definition of a pseudorandom sequence is one which a computationally-bounded Eve cannot distinguish from a truly random sequence.

###### Theorem 7

If Eve can break uncloneable encryption scheme $`𝒮`$ (which is derived from a quantum authentication scheme) with a pseudorandom key (from oracle $`𝒦`$) using an attack of low complexity during transmission, then she has an efficient quantum algorithm that can distinguish $`𝒦`$ from a truly random sequence.

Proof:

The proof is straightforward. Eve is given a string $`k`$, and wishes to determine if it is a pseudorandom string generated by $`𝒦`$ or a truly random sequence. Now, she has an attack $`𝒜`$ which breaks the uncloneable encryption scheme $`𝒮`$ when it uses a pseudorandom key. That is, there are two messages $`m`$, $`m^{}`$ for which the probabilities $`P(m)`$, $`P(m^{})`$ of being accepted are not both small, and for which Eve’s residual density matrices $`\rho _k(m)`$, $`\rho _k(m^{})`$ are substantially different.

By theorem 5, she therefore can efficiently generate an attack $`𝒜^{}`$ against the quantum authentication scheme $`𝒮`$ with key drawn from $`𝒦`$. That is, there is some input state $`|\psi `$ (which, by the proof of theorem 5, we know can be chosen to be $`|m+|m^{}`$) for which the output of the authentication scheme with attack $`𝒜^{}`$ has a large component which is accepted but is orthogonal to $`|\psi `$.

To break the pseudorandom sequence, Eve therefore creates a simulated Alice sending messages to a simulated Bob using the quantum authentication scheme $`𝒮`$ and key $`k`$. The pretend Alice repeatedly sends the message $`|\psi `$ to pretend Bob using this key. Each time, Eve performs the attack $`𝒜`$ and measures the state received by Bob in an orthonormal basis including $`|\psi `$.

We know the quantum authentication scheme is secure when used with a truly random key. Therefore, if the key is truly random, Eve will essentially always find that the simulated Bob either rejects the message or receives the state $`|\psi `$. On the other hand, the attack $`𝒜^{}`$ breaks the protocol when the key is pseudorandom, so when $`k`$ is generated by $`𝒦`$, Eve will occasionally find that the simulated Bob accepts a state which she measures to be orthogonal to $`|\psi `$. Therefore, if Eve ever gets such an outcome, she concludes $`k`$ is pseudorandom; otherwise, she decides it is random. $`\mathrm{}`$

Note that, while the protocol given in section 4 does not come directly from a quantum authentication protocol, it still is derived from one indirectly. In particular, combining theorem 5 and appendix B, we produce an efficient reduction to a quantum authentication scheme. Thus, theorem 7 also holds for that protocol and similar prepare-and-measure BB84 protocols.

## 6 Open Questions

One serious drawback of theorem 7 is that it only proves security when the pseudorandom sequence is secure against quantum attacks. Intuitively, we should expect that if we use a “prepare-and-measure” protocol, such as that in section 4, and Eve can make only attacks against individual photons, she should not be able to copy the state, even if the pseudorandom sequence is only secure against classical attacks. The whole protocol and attack can be simulated classically, so Eve is not sneaking in any additional computational power with the attack, and therefore should not be able to copy the state. It would be extremely useful to prove that under these circumstances, the uncloneability property still holds. That would allow us, for instance, to perform “prepare-and-measure” uncloneable encryption for message $`m`$ today based on an RSA-protected key, and still have information-theoretic security for $`m`$ in the distant future once quantum computers able to break RSA become available.

A useful practical improvement for the “prepare-and-measure” protocol from section 4 would be to give it more tolerance to channel noise. In particular, the requirement that $`C_1`$ and $`C_2`$ have good minimum distance is rather strict. Perhaps this can be improved to allow $`C_1`$ and $`C_2`$ to correct general errors, rather than worst-case errors, with error rates $`\delta `$ and $`\delta +\eta `$.

It would also be interesting to understand the connection, if any, between uncloneability and key reuse for quantum authentication. Recent work  has shown that much (but not all) of the key for quantum authentication can be reused, provided the authentication test indicates no tampering. There is clearly some similarity with the fact that quantum authentication schemes provide uncloneable encryption, but neither result is strictly stronger or weaker than the other: The fact that part of the key can be reused indicates that it can safely be exposed after the message is successfully received, but uncloneability allows all of the key to become public. On the other hand, key can be reused in ways other than publishing it to Eve, and uncloneability does not imply the security of those other applications.

One might also wish to give the uncloneability property to other types of classical protocols. For instance, one can make a simple uncloneable secret sharing scheme with two shares. To do this, take a classical secret string $`m`$ and share it as $`(a_0,a_1)`$ for random string $`a_0`$, and $`a_1=ma_0`$. Both shares are now needed to reconstruct $`m`$. We can make this scheme uncloneable by using an uncloneable encryption scheme $`𝒮_k`$. Encrypt $`a_i`$ with $`𝒮`$ using key $`k_i`$. The first share of the new uncloneable scheme is $`(𝒮_{k_0}(a_0),k_1)`$, and the second share is $`(𝒮_{k_1}(a_1),k_0)`$. That is, each share contains an encrypted share of the original classical scheme, plus the key needed to decode the other share. Someone with only one share of this new scheme cannot copy it without being detected, although of course anyone with both shares can read them and copy them without difficulty. To create more complex secret-sharing schemes, we need a good definition of uncloneable secret sharing in general. What shares is the adversary allowed access to, and when (and with what shares) do the users check for intrusion?

One difficulty with such generalizations is that it is unclear to what extent the name “uncloneable encryption” is really deserved. I have not shown that a message protected by uncloneable encryption cannot be copied — only that Eve cannot copy it without being detected. Is it possible for Eve to create two states, neither of which will pass Bob’s test, but which can each be used (in conjunction with the secret key) to extract a good deal of information about the message? Or can one instead prove bounds, for instance, on the sum of the information content of the various purported copies?

Another interesting open question is to better understand the relationships of various cryptographic tasks. Is quantum authentication exactly equivalent to quantum key distribution in some sense, or is there a real distinction between the two? Also, are other cryptographic tasks for quantum information related to cryptographic tasks for classical data? There may well be a rich structure of interconnections between quantum and classical protocols waiting to be uncovered.

Finally, the task of uncloneable encryption is not really conceivable in a purely classical context. Are there other useful tasks waiting to be discovered which simply make no sense for a classical protocol yet are achievable with the aid of quantum information?

## Acknowledgements

I would like to thank Claude Crépeau, Hoi-Kwong Lo, Dominic Mayers, and Adam Smith for helpful discussions. This work was performed in part while the author was a Clay Long-Term CMI Prize Fellow.

## Appendix A Proof of Claim 6

We wish to show equation (11):

$$D(P(m)\rho _k(m),P(m^{})\rho _k(m^{}))qϵ+\sqrt{20\sqrt{qϵ}}+5\sqrt{qϵ}.$$
(13)
The residual density matrices $`\rho _k`$ for Eve in the case she is not caught are

$`\rho _k(m)`$ $`=`$ $`{\displaystyle \frac{|\varphi _k(m)\varphi _k(m)|+\mathrm{Tr}_{\mathrm{Bob}}|\eta _k(m)\eta _k(m)|}{N(m)^2+|\eta _k(m)^2}},`$ (14)
$`\rho _k(m^{})`$ $`=`$ $`{\displaystyle \frac{|\varphi _k(m^{})\varphi _k(m^{})|+\mathrm{Tr}_{\mathrm{Bob}}|\eta _k(m^{})\eta _k(m^{})|}{N(m^{})^2+|\eta _k(m^{})^2}},`$ (15)
where $`N(m)=|\varphi _k(m)`$ and $`N(m^{})=|\varphi _k(m^{})`$.

Then, by the triangle inequality,

$`D(P(m)\rho _k(m),P(m^{})\rho _k(m^{}))`$ $``$ $`D(P(m)\rho _k(m),|\varphi _k(m)\varphi _k(m)|)`$
$`+D(|\varphi _k(m)\varphi _k(m)|,|\varphi _k(m^{})\varphi _k(m^{})|)`$
$`+D(P(m^{})\rho _k(m^{}),|\varphi _k(m^{})\varphi _k(m^{})|).`$
Now,

$`D(P(m)\rho _k(m),|\varphi _k(m)\varphi _k(m)|)`$ $`=`$ $`{\displaystyle \frac{1}{2}}\mathrm{Tr}\left|\mathrm{Tr}_{\mathrm{Bob}}|\eta _k(m)\eta _k(m)|\right|`$ (17)
$``$ $`qϵ/2,`$ (18)
and similarly,

$$D(P(m^{})\rho _k(m^{}),|\varphi _k(m^{})\varphi _k(m^{})|)qϵ/2.$$
(19)
We need, therefore, only to bound

$$D(|\varphi _k(m)\varphi _k(m)|,|\varphi _k(m^{})\varphi _k(m^{})|).$$

First, note that

$`D(|\varphi _k(m)\varphi _k(m)|,|\varphi _k(m^{})\varphi _k(m^{})|)`$ (21)
$`N(m)^2D({\displaystyle \frac{1}{N(m)^2}}|\varphi _k(m)\varphi _k(m)|,{\displaystyle \frac{1}{N(m^{})^2}}|\varphi _k(m^{})\varphi _k(m^{})|)`$
$`+D({\displaystyle \frac{N(m)^2}{N(m^{})^2}}|\varphi _k(m^{})\varphi _k(m^{})|,|\varphi _k(m^{})\varphi _k(m^{})|)`$
$`=`$ $`N(m)^2D({\displaystyle \frac{1}{N(m)^2}}|\varphi _k(m)\varphi _k(m)|,{\displaystyle \frac{1}{N(m^{})^2}}|\varphi _k(m^{})\varphi _k(m^{})|)`$
$`+{\displaystyle \frac{1}{2}}\left|N(m)^2N(m^{})^2\right|.`$
Now,

$`\varphi _k(m^{})|\varphi _k(m^{})\varphi _k(m^{})|\varphi _k(m)=`$ (22)
$`N(m^{})^2N(m)N(m^{})F({\displaystyle \frac{1}{N(m)}}|\varphi _k(m),{\displaystyle \frac{1}{N(m^{})}}|\varphi _k(m^{}))`$
$``$ $`|\varphi _k(m^{})|\varphi _k(m)|\varphi _k(m^{})`$ (23)
$``$ $`N(m^{})5\sqrt{qϵ},`$ (24)
where the last line follows from equation (10). That is,

$`F({\displaystyle \frac{1}{N(m)}}|\varphi _k(m),{\displaystyle \frac{1}{N(m^{})}}|\varphi _k(m^{}))`$ $``$ $`{\displaystyle \frac{N(m^{})5\sqrt{qϵ}}{N(m)}}`$ (25)
$`=`$ $`1{\displaystyle \frac{(N(m)N(m^{}))+5\sqrt{qϵ}}{N(m)}}.`$ (26)
By the triangle inequality and equation (10),

$$N(m)N(m^{})5\sqrt{qϵ},$$
(27)
so

$$F(\frac{1}{N(m)}|\varphi _k(m),\frac{1}{N(m^{})}|\varphi _k(m^{}))1\frac{10\sqrt{qϵ}}{N(m)}.$$
(28)
Thus,

$`D({\displaystyle \frac{1}{N(m)^2}}|\varphi _k(m)\varphi _k(m)|,{\displaystyle \frac{1}{N(m^{})^2}}|\varphi _k(m^{})\varphi _k(m^{})|)`$ $``$ $`\sqrt{1F^2}`$ (29)
$``$ $`\sqrt{{\displaystyle \frac{20\sqrt{qϵ}}{N(m)}}}.`$ (30)
Putting together equations (A), (18), (19), (21), and (30), we get

$`D(P(m)\rho _k(m),P(m^{})\rho _k(m^{}))`$ $``$ $`qϵ+N(m)\sqrt{20N(m)\sqrt{qϵ}}`$ (31)
$`+{\displaystyle \frac{1}{2}}\left|N(m)^2N(m^{})^2\right|`$
$``$ $`qϵ+\sqrt{20\sqrt{qϵ}}+5\sqrt{qϵ},`$ (32)
where we have used $`N(m)1`$ and equation (27) to bound $`|N(m)^2N(m^{})^2|`$.

## Appendix B Constructing a Prepare-and-Measure Protocol

We wish to construct a “prepare-and-measure” protocol by starting with a quantum authentication protocol of an appropriate form. The easiest way to create an efficient quantum authentication protocol is to use the technique of Barnum et al : create a set of stabilizer codes with the right properties — in the terminology of Barnum et al, they form a “Purity Testing Code.” Then this will give us a quantum authentication protocol.

However, there is a complication. We wish to end up with a protocol that, like BB84, works even through a noisy channel. One obvious way to do this would be to encode the quantum authentication protocol with a quantum error-correcting code, but this would destroy the prepare-and-measure structure we wish to have for the final protocol. Instead, we will devise a quantum authentication protocol with the additional ability to correct errors. An examination of  reveals that this does not require modification of the definition of quantum authentication; we simply add the property that the transmission (almost always) is accepted when the data is sent through some particular channel $`𝒞`$.

We will again construct such a protocol from a family of stabilizer codes. Recall that a stabilizer quantum error-correcting code is an abelian subgroup of the Pauli group generated by tensor products of the Pauli matrices

$$X=\left(\begin{array}{cc}0& 1\\ 1& 0\end{array}\right),Y=\left(\begin{array}{cc}0& i\\ i& 0\end{array}\right),Z=\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right).$$
(33)
A stabilizer code $`Q`$ detects a Pauli error unless that error is in the set $`Q^{}Q`$, where $`Q^{}`$ is the set of Pauli operations that commute with every element of the stabilizer. A stabilizer code corrects a set of Pauli errors $``$ if it detects the product of any two elements of $``$. We can also talk about a stabilizer code which corrects a set $``$ and detects a larger set $``$. This occurs if the code detects all operators which are the product of an element from $``$ and an element from $``$. (When this is true, the code can distinguish elements of $``$ from elements of $``$ and can distinguish elements of $``$ from each other, but cannot necessarily tell elements of $``$ apart.) For more detailed background on stabilizer codes, see .

###### Definition 8

Let $`\{Q_k\}`$ be a family of stabilizer codes. Suppose the code $`Q_k`$ corrects the set $`_k`$ and detects the set $`_k`$ (for some decoding algorithm, which will vary with $`k`$). Let $`𝒞`$ be a Pauli channel (i.e., it produces Pauli errors with various probabilities). Then the set $`\{Q_k\}`$ is a purity testing code with error $`ϵ`$ which corrects the channel $`𝒞`$ if the following conditions hold true:

1. For a fraction at least $`1ϵ`$ of the possible values of $`k`$, $`_k`$ contains a typical set of Pauli errors produced by $`𝒞`$ (one that occurs with probability at least $`1ϵ`$).
2. For any Pauli error $`E`$ (not the identity), $`E_k`$ for a fraction at least $`1ϵ`$ of the possible values of $`k`$.

The first condition is straightforward — it simply means that most codes in the family should correct errors from the channel. The second condition is a little more slippery. It says that most of the codes will detect any particular Pauli error, despite the general error correction that is going on. A slight modification of the theorems in  shows that a family of codes satisfying definition 8 can be used to construct a quantum authentication protocol which also corrects the channel $`𝒞`$.

To create such a family of codes, I will use a concatenated structure. The inner layer will be a classical authentication protocol, giving a family of modest size. This part will serve to detect errors which are not corrected. Then will come a fixed quantum error-correcting code (or perhaps a family of quantum error-correcting codes), which are designed to correct a channel related to $`𝒞`$, which I assume is memoryless. Finally, for the outside layer, we will perform Hadamard transforms on some of the qubits; the set of qubits transformed is determined by part of $`k`$. This will serve to mix phase and bit flip errors, allowing the classical authentication protocol to detect the phase errors as well as the bit flip errors.

In principle, any classical authentication protocol should suffice for the inner layer of encoding. However, the proof techniques used require it to be describable in the stabilizer language, which limits us somewhat. On the other hand, the condition for definition 8 is somewhat weaker than an actual classical authentication protocol. For instance, we can use the following encoding: Suppose we have an $`n`$ bit message $`m`$, with $`n=rs`$.

1. Divide the $`n`$ input bits into $`r`$ groups of size $`s`$. View each group of $`s`$ bits as an element of the finite field $`GF(2^s)`$. Let $`k`$ be a secret string of size $`s`$, also viewed as an element of $`GF(2^s)`$.
2. The $`r`$ resulting registers $`m_0,\mathrm{},m_{r1}`$ can be viewed as the first $`r`$ coefficients of a degree $`r`$ polynomial $`f(z)`$. The final coefficient $`m_r`$, the constant term, will be chosen so that $`f(k)=0`$. That is, $`_im_ik^{ri}=0`$.
3. Alice sends $`(m_0,\mathrm{},m_r)`$ to Bob, who accepts the message if he receives a list of registers defining a polynomial $`f^{}`$ with $`f^{}(k)=0`$.

The property we will need for definition 8 is that, if Eve adds any nonzero vector to the transmission, then for a fraction $`1ϵ`$ of the values of $`k`$, the resulting string fails the test. To see this, note that the test will be passed only if Eve’s vector corresponds to a degree-$`r`$ polynomial $`g`$ with $`g(k)=0`$. However, a polynomial of degree $`r`$ can have at most $`r`$ zeros, so whatever polynomial $`g`$ Eve picks, it can pass the test for at most a fraction $`r/2^s=n/(s2^s)`$ of the possible values of $`k`$. For suitable $`s`$, we can easily make this very small.

Note that this is not necessarily a complete classical authentication protocol: $`GF(2^s)`$ is not algebraically complete, so whatever polynomial Alice sends might have fewer than $`r`$ zeros. In that case, Eve could safely replace it by a different polynomial with the same (or a larger) set of zeros. Nevertheless, this protocol will suffice to give a quantum authentication protocol in conjunction with the other processing we apply, namely encryption.

We now have a way of encoding an $`n`$-bit classical message as $`n+s`$ bits; we can extend this linearly to encode superpositions as well, so $`n`$ qubits are encoded as $`n+s`$ qubits. We then take a quantum error-correcting code which encodes $`n+s`$ qubits in $`N`$ qubits, and finally, based on an $`N`$-bit classical string $`b`$, perform Hadamard transforms on many of the qubits. If the $`i`$th bit of $`b`$ is a $`0`$, we leave the $`i`$th qubit of the encoded message alone; if the $`i`$th bit of $`b`$ is $`1`$, we perform the Hadamard on the $`i`$th qubit. The result is a purity testing code which also corrects errors.

The quantum error-correcting code must have three properties. First, it must usually correct the channel $`𝒞`$. If we choose a random $`b`$, we are effectively swapping the $`X`$ (bit flip) and $`Z`$ (phase flip) error rates for half the qubits transmitted. In other words, we have transformed to a new channel $`𝒞^{}`$ which is symmetrized between bit and phase flip errors. (The $`Y`$ error, which does both a bit and phase flip, could have a different error rate.) Our error-correcting code should correct this channel.

Second, in order to perform the final Shor-Preskill step of our reduction to a “prepare-and-measure” protocol, we will need a CSS code . Let $`\delta `$ be the bit error rate of the symmetrized channel $`𝒞^{}`$ (i.e., the combined $`X`$ and $`Y`$ error rates, or equivalently the combined $`Y`$ and $`Z`$ error rates). Then, in particular, we want a CSS code that corrects $`\delta N`$ bit flip errors and $`\delta N`$ phase errors. Actually, we should pick $`\delta `$ to be slightly larger than the true error rate so the code can also correct statistical fluctuations from the average error rate.

Third, we need our full concatenated construction to act as a purity testing protocol. That is, suppose Eve presents us with an arbitrary Pauli operation $`E`$. We wish either for this error to be corrected by the quantum code or detected by the authentication procedure. To analyze this, we will see how $`E`$ is treated by each level of the decoding procedure. In the outer layer, we perform Hadamard transforms according to the bit string $`b`$. Whenever we perform a Hadamard, we convert an $`X`$ to a $`Z`$ and vice-versa. This gives us a new Pauli operation $`E^{}`$. In most cases, $`E^{}`$ will have a similar number of $`X`$s and $`Z`$s (the number of $`Y`$s may be different). The total values $`\delta _X`$ (the total fraction of $`X`$s or $`Y`$s) and $`\delta _Z`$ (the total fraction of $`Y`$s or $`Z`$s) will therefore be very similar on average. If $`\delta _X\delta `$, the quantum error-correcting code will correct the bit flip part of the errors; if $`\delta _Z\delta `$, the quantum error-correcting code will correct the phase part of the errors. If there are any bit flip errors left over, they will almost certainly be detected in the inner layer of encoding by the classical authentication scheme. Since it is just a classical authentication scheme, however, residual phase errors will not be detected. Therefore, we want our quantum error-correcting code to have the property that for any $`E`$, for most $`E^{}`$s produced by Hadamard transforms, either the code will correct both bit and phase flip errors, or it will leave uncorrected bit flip errors. That is, it should (almost) never correct all bit flip errors but leave uncorrected phase errors.

One way (though possibly not the only way) to accomplish this is to let the phase error correction rate be slightly higher than the bit flip error correction rate. That is, we choose a CSS code that corrects a fraction $`\delta `$ of bit flip errors and a fraction $`\delta +\eta `$ of phase errors. In section 4, we chose two classical codes $`C_1`$ and $`C_2`$. The CSS code which uses $`C_1`$ to correct bit flips and $`C_2`$ to correct phase flips will have the requisite properties.

We can take this purity testing code and produce a quantum authentication scheme as per Barnum et al . To do this, we take the quantum state, encrypt it, then further encode it using the above purity testing code with random syndromes. Encrypting the quantum state means performing a random Pauli matrix (determined by part of the shared secret key) on each qubit. However, when we move to an uncloneable encryption scheme, we are simply sending classical basis states. Therefore, an initial phase randomization step has no effect on the state. We thus get the following uncloneable encryption protocol for an $`n`$-bit message, based on the classical key $`(k,e,c_1,c_2,b)`$:

1. Divide the $`n`$ input bits into $`r`$ groups of size $`s`$. View each group of $`s`$ bits as an element of the finite field $`GF(2^s)`$. $`k`$ is a string of size $`s`$, which we can also view as an element of $`GF(2^s)`$.
2. The $`r`$ resulting registers $`m_0,\mathrm{},m_{r1}`$ can be viewed as the first $`r`$ coefficients of a degree $`r`$ polynomial $`f(z)`$. The final coefficient $`m_r`$, the constant term, will be chosen so that $`f(k)=0`$. That is, $`_im_ik^{ri}=0`$.
3. Alice XORs the string $`(m_0,\mathrm{},m_r)`$ with the $`(n+s)`$-bit string $`e`$, producing a new classical string $`y`$ of length $`n+s`$ bits.
4. Alice creates the basis state $`|y`$ and encodes it using the CSS code $`\{C_1,C_2\}`$ with syndrome $`c_1`$ for $`C_1`$ and $`c_2`$ for $`C_2`$.
5. Alice takes the resulting $`N`$-qubit state and performs a Hadamard transform on it for each location where the $`N`$-bit string $`b`$ is a $`1`$. The resulting state $`|\psi `$ Alice transmits to Bob.

To decode, Bob simply takes the state he receives, reverses the Hadamard transforms, corrects and decodes the state from the quantum error-correcting code, and measures the resulting state (which should be a basis state if all has gone correctly). He then XORs the resulting classical string $`y`$ with $`e`$ and divides the result into $`r+1`$ $`s`$-bit registers, viewed as elements of $`GF(2^s)`$ — in fact, as coefficients of a degree $`r`$ polynomial over $`GF(2^s)`$. He then evaluates this polynomial at the point $`kGF(2^s)`$, and accepts the message only if he gets $`0`$ as the result. If he does accept, the message is the first $`n`$ bits of $`y`$.

By theorem 5, this is a perfectly good uncloneable encryption scheme. Unfortunately, the use of quantum error-correcting codes means it is not a “prepare-and-measure” scheme. However, following Shor and Preskill , we can note that the phase error correction does not influence the final outcome, so need not be performed. In fact, Alice could simply measure the state before sending, and it would not influence Eve’s attack or Bob’s decoding at all. For a more detailed discussion of the Shor and Preskill technique, see . The end result of this procedure is to give us the “prepare-and-measure” protocol presented in section 4.


format: text

text:
# Formation and Migration of Trans-Neptunian Objects

## 1. Formation of Tran-Neptunian Objects

Many scientists considered that large trans-Neptunian objects (TNOs) and asteroids were formed by accumulation of smaller (e.g., 1-km) planetesimals. Such process of accumulation of TNOs needs small ($``$0.001) eccentricities and a massive belt which probably could not exist during the time needed for such accumulation. Therefore Ipatov (2001) considered that large TNOs and some main-belt asteroids could be formed directly from dust rarefied condensations. It is assumed by many authors that a lot of dust condensations were formed from a dust disk around the forming Sun. These initial condensations coagulated under collisions and formed larger condensations, which compressed and formed solid planetesimals. To our opinion, during the time needed for compression of condensations into planetesimals, some largest final condensations could reach such masses that they formed initial planetesimals with diameter equal to several hundreds kilometers. As in the case of accumulation of planetesimals, there could be a ”run-away” accretion of condensations. Some smaller objects (TNOs, planetesimals, asteroids) could be debris of larger objects, and other such objects could be formed directly by compression of condensations.

A small portion of planetesimals from the feeding zone of the giant planets that entered into the trans-Neptunian region could be left in eccentrical orbits beyond Neptune and became so called ”scattered disk objects” (SDOs). The end of the bombardment of the terrestrial planets could be caused mainly by those planetesimals that had become SDOs. Our estimates (Ipatov 1995, 2001) showed that collisional lifetimes of 1-km TNOs and asteroids are about 1 Gyr. Typical TNOs can be even more often destroyed by SDOs than by other TNOs. Mutual gravitational interactions of TNOs can play a larger role in variations of their orbital elements than collisions.

## 2. Orbital Evolution of Jupiter-Family Comets

The motion of TNOs to Jupiter’s orbit was investigated by several authors (e.g., Levison & Duncan 1997). Proceeding from the total of $`510^9`$ 1-km TNOs within 30$`<`$$`a`$$`<`$50 AU, assuming the mean time $`T_{JCO}`$$``$0.13 Myr for a body to move in a Jupiter-crossing orbit, and using the same formulas and other estimates as those in (Ipatov 2001), we obtain that about $`10^4`$ of former 1-km TNOs now are Jupiter-crossers. In the present paper we pay the main attention to the migration of Jupiter-crossing objects (JCOs). Our present investigations are based on our runs of the orbital evolution of thousands JCOs under gravitational influence of all planets, except for Mercury and Pluto, for intervals $`T_S`$$``$10 Myr (for Comet 2P we also considered Mercury). The integration package by Levison & Duncan (1994) was used. Below we present the results obtained only by the method by Bulirsh and Stoer (BULSTO code), though we also considered the evolution of thousands of objects using a symplectic method. In some cases in our runs (especially, when objects can get close to the Sun) we obtained a considerable difference between the results obtained by BULSTO and a symplectic method. For BULSTO the relative error per integration step was taken (depending on the run) to be less than $`\epsilon `$ which was $`10^9`$, $`10^8`$, or some intermediate value.

In the first series of runs (denoted as $`n1`$) we investigated the orbital evolution of $`N`$=1900 JCOs moving in initial orbits close to those of 20 real JCOs with period 5$`<`$$`P_a`$$`<`$9 yr. In each of other series of runs we considered initial orbits close to that of one comet (2P, 9P, 10P, 22P, 28P, or 39P). We also studied the evolution of asteroids initially moving in the resonances 3:1 and 5:2 with Jupiter. Approximate values of initial semi-major axes $`a`$, eccentricities $`e`$ and inclinations $`i`$ of considered objects are presented in Table 1. For JCOs we varied only initial mean anomaly, and for asteroids we varied also initial value of the longitude of the ascending node. Examples of time variations in orbital elements are presented in Figs. 1-2. As these two objects have large probabilities of collisions with the terrestrial planets, they are not included in the Table. In Fig. 3 we present the time in Myr during which 7852 former JCOs had semi-major axes in the interval with a width of 0.005 AU (left) or 0.1 AU (right).

We did not simulate collisions of objects with planets, but basing on orbital elements obtained with a step 500 yr, for all $`N`$ objects we calculated the total impacting probability $`P_\mathrm{\Sigma }`$ and the total time interval $`T_\mathrm{\Sigma }`$ to reach perihelion distance $`q`$ less than a semi-major axis of a planet, and then impact probabilities per one object $`P`$=$`10^6P_r`$=$`P_\mathrm{\Sigma }/N`$ and $`T_r`$=$`T_\mathrm{\Sigma }/N`$ during $`T_S`$ were estimated.

In Table 1 we also present the ratio $`r`$ of time spent in Apollo orbits ($`a`$$`>`$1 AU, $`q`$=$`a(1e)`$$`<`$1.017 AU) at $`e`$$`<`$0.999 to that in Amor orbits (1.017$`<`$$`q`$$`<`$1.33 AU). One object initially moving in orbit close to that of Comet 10P after having Aten-type orbit ($`a`$$`<`$1 AU, $`Q`$=$`a(1+e)`$$`>`$0.983 AU) during 3 Myr (the probability of its collision with the Earth was 0.34) got orbits with aphelion distance $`Q`$$`<`$0.983 AU (Fig. 1). The probability of its collision with Venus during $`t`$$``$50 Myr was $``$3, so more probable that it collided Venus at $`t`$$``$15 Myr.

Specific mass of the matter delivered by JCOs to an inner planet (normalized to its mass) turns out to be nearly the same for Earth and Venus though greater for Mars. The total collisional probability with the inner planets was mainly caused by a small ($``$0.01-0.001) fraction of bodies residing in orbits deep inside Jupiter’s orbit for more than 1 Myr. Fifteen considered objects with initial orbits close to those of 10P and 2P moved in Earth-crossing orbits with 1$`<`$$`a`$$`<`$2 AU during more than 0.5 Myr each. At $`n1`$, objects moved with periods $`P_a`$$`<`$10 and 10$`<`$$`P_a`$$`<`$20 yr during 11% and 21% of $`T_{JCO}`$, respectively. More details of the runs can be found in our papers in htpp://arXiv.org/archive/astro-ph.

## 3. Migration of Trans-Neptunian Objects to the Near-Earth Space

In total, 6852 considered JCOs moved during more than 160, 470, 65, 140, and 10 Myr in Amor, Apollo, and Aten orbits, orbits with 1$`<`$$`a`$$`<`$2 AU and $`q`$$`<`$1 AU, and orbits with $`Q`$$`<`$0.983, respectively. So, if we consider $`10^4`$ former 1-km TNOs now moving in Jupiter-crosing orbits, then for $`T_{JCO}`$=0.13 Myr their number for the above five types of orbits is about 1600, 4700, 650, 1400, and 100, respectively. As we simulated mainly orbits with large probabilities of collisions with the Earth, the above numbers can be smaller by a factor of several. Mean eccentricities of such orbits are larger and the probabilities of collisions with the terrestrial planets are smaller than those of the observed NEOs. Probably, most of such former TNOs (extinct comets) are not yet observed, as most of the time they move relatively far from the Earth. It is considered that about 750 of 1-km bodies are located in the Earth-crossing orbits (half of them are in orbits with $`a`$$`<`$2 AU), although this number does not include those in high eccentric orbits. Our estimates show that, in principle, the trans-Neptunian belt can provide a considerable portion of Earth-crossing objects, at least many of those with $`a`$$`>`$2 AU, but, of course, some NEOs came from the main asteroid belt. It may be possible to explore former TNOs near the Earth’s orbit without sending spacecrafts beyond Neptune. Based on the estimated collision probability $`P`$=$`610^6`$ (this value is a little larger than that for $`n1`$, but is smaller by an order of magnitude than $`P`$=$`710^5`$ obtained for 7852 JCOs) and assuming the total mass of planetesimals that ever crossed Jupiter’s orbit is $``$100$`m_{}`$ ($`m_{}`$ is mass of the Earth), we found that the total mass of bodies impacted on the Earth is $`610^4m_{}`$. If ices composed only a half of this mass, then the total mass of ices that were delivered to the Earth from the feeding zone of the giant planets turns out by the factor of 1.5 greater than the mass of the Earth oceans. Ancient oceans on Mars and Venus could be also large.

This work was supported by NRC (0158730), NASA (NAG5-10776), INTAS (00-240), and RFBR (01-02-17540).

## References

Ipatov S.I. 1995, Solar System Research, 29, 261-286

Ipatov S.I. 2000, Migration of Celestial Bodies in the Solar System, Editorial URSS Publishing Company, Moscow, in Russian

Ipatov S.I. 2001, Advances in Space Research, Elsevier, 28, 1107-1116

Levison H.F. & Duncan M.J. 1994, Icarus, 108, 18-36

Levison H.F. & Duncan M.J. 1997, Icarus, 127, 13-23