Next Article in Journal
Depthwise Separable Relation Network for Small Sample Hyperspectral Image Classification
Next Article in Special Issue
Nonlinearity of Boolean Functions: An Algorithmic Approach Based on Multivariate Polynomials
Previous Article in Journal
Majority Decision Aggregation with Binarized Data in Wireless Sensor Networks
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Perfect Reconciliation in Quantum Key Distribution with Order-Two Frames

by
Luis Adrián Lizama-Pérez
1,* and
José Mauricio López-Romero
2
1
Dirección de Investigación, Innovación y Posgrado, Universidad Politécnica de Pachuca, Ex-Hacienda de Santa Bárbara, Zempoala 43830, Mexico
2
Cinvestav Querétaro, Libramiento Norponiente 2000, Real de Juriquilla, Santiago de Querétaro 76230, Mexico
*
Author to whom correspondence should be addressed.
Symmetry 2021, 13(9), 1672; https://doi.org/10.3390/sym13091672
Submission received: 10 August 2021 / Revised: 3 September 2021 / Accepted: 7 September 2021 / Published: 10 September 2021
(This article belongs to the Special Issue The Advances in Algebraic Coding Theory)

Abstract

:
We present an error reconciliation method for Quantum Key Distribution (QKD) that corrects 100% of errors generated in regular binary frames transmitted over a noisy quantum channel regardless of the quantum channel error rate. In a previous investigation, we introduced a novel distillation QKD algorithm whose secret key rate descends linearly with respect to the channel error rate. Now, as the main achievement of this work, we demonstrate an improved algorithm capable of retaining almost all the secret information enclosed in the regular binary frames. Remarkably, this technique increases quadratically the secret key rate as a function of the double matching detection events and doubly quadratically in the number of the quantum pulses. Furthermore, this reconciliation method opens up the opportunity to use less attenuated quantum pulses, would allow greater QKD distances at drastically increased secret key rate. Since our method can be implemented as a software update, we hope that quantum key distribution technology would be fast deployed over global data networks in the quantum era.

1. Introduction

The arrival of the quantum era and quantum computers in the short term is imminent. One of the most profound consequences of the quantum era is that the security of digital data as we know it today must be radically changed due to the power of computers to break the security of asymmetric key cryptographic methods and at the same time must increase the sizes of the symmetrical keys.
Countermeasures to address the threat of quantum computers have been led by NIST, which launched a selection process for new cryptographic algorithms for the quantum era in 2017 [1]. However, it is to be expected that it will take years to implement and technologically adapt the new methods to be used in global data networks [2].
Fortunately, the quantum cryptographic key distribution (QKD) is a cryptographic scheme that appeared almost four decades ago that has been widely evaluated and discussed by the scientific community. In addition, QKD can be implemented through satellite links or already installed fiber optic networks. Quantum Key Distribution (QKD) allows the establishment of a secret key between two remote entities taking advantage of the principles of quantum physics and therefore theoretically secure. Unfortunately, the transmission of quantum states through a noisy quantum channel causes errors to appear in the received information, severely limiting the deployment of QKD technology as it reduces the secret bit rate and the distance achievable by the QKD system. For this reason, error correction algorithms have been developed to detect and correct errors during the post-processing phase, which includes sifting, error reconciliation, and privacy amplification. The reconciliation algorithm must be carried out preserving the secrecy of the cryptographic key [3].
Reconciliation methods developed natively for QKD are BBBSS [4] based on binary search, Cascade [5,6] that uses binary search and backtracking, but they are based on the parity computation of the received information blocks and do not take advantage of the properties of communication with quantum states; instead, it is highly interactive, requiring multiple rounds of correction of bits.
In view of the above, it has been necessary to resort to other reconciliation techniques developed in the field of data communications. Reconciliation methods based on error correcting codes are Winnow [7,8,9] which uses parity check and Hamming error correction code. It corrects one error per block, so the choice of block length is very sensitive because additional errors may be introduced if a block contains two or more errors [10]. Also, Forward Error Correction (FEC) is used to achieve reconciliation as the discrete number of Low-Density Parity-Check (LDPC) codes. However, LDPC has the disadvantage that requires redundant information that must be transmitted along the information data [11,12,13,14,15]. Recently, polar encoding has emerged as an encoding method in finding error correction codes that are close to the Shannon limit [16,17,18]. Beyond the mentioned drawbacks, none of these schemes is capable of handling a quantum channel error rate beyond 25% [19].
We published in [20,21] a new reconciliation algorithm that takes advantage of the characteristics of quantum communication, which, simply put, is equivalent to having two classical communication channels, one in the quantum X basis and the other in the Z basis. By means of a reverse reconciliation process, Bob sends parity information from these two channels so that Alice is able to recognize Bob’s chosen bases on which the secret information is encoded as depicted in Figure 1.
A two order frame, as it can be seen in Figure 1, is a 2 × 2 matrix, structured by two rows and two columns. One row represents a pair of non-orthogonal states where the first column of the frame contains the base X encoded quantum bit | i X or | ( 1 i ) X and the second column the base Z quantum bit, that is | i Z or | ( 1 i ) Z where i = 0 , 1 . Once Bob measures a pair of non-orthogonal states and provided he gets a DMDE (Double Matching Detection Event), he obtains the encoded bit in the first or second column of the first row of the frame, as shown in Figure 1 and Figure 2. Bob’s frame is complete once he gets the second DMDE.
In fact, the two rows of a frame are not received sequentially, instead Bob must inform Alice about the DMDE that he obtained, then Alice responds to Bob how to arrange the rows to construct the frames as illustrated in the message exchange in Figure 3. For this reason, each DMDE is labelled by an index that has the form (CSS, i 1 , i 2 ) where i 1 is the number of the first NO-QP and i 2 is the number of the second NO-QP. The index is assigned during transmission, so is known by Alice and Bob, CSS will be explained shortly.
This article is focused on the discussion and explanation of the reconciliation method, rather than on a detailed discussion of the attacks over the system. So, Section 2 contains a detailed discussion of the reconciliation method. In Section 3 we derive the relation for the secret throughput of the frame-based method. Finally, Section 4 contains a brief discussion about the main quantum attacks. But before going to the details of the reconciliation method, let us succinctly state the research problem and the general idea of the new method.

1.1. Research Problem Statement

The reconciliation method must be able to detect the errors produced into the pairs of non-orthogonal quantum states 0 X , 0 Z , 0 X , 0 Z , 0 X , 1 Z , 0 X , 1 Z , 1 X , 0 Z , 1 X , 0 Z , 1 X , 1 Z and 1 X , 1 Z where the overbracket symbol ﹇ represents the error that is produced in a transmitted NO-QP. We argue that if we can detect all these types of errors, we will achieve error correction that is invariant with respect to the error rate of the quantum channel. The following types of frames (which have been enumerated according to [20]) will be used:
1.
Auxiliary frames, of two types, null and unitary frames as well as their conjugate denoted with a math apostrophe. We call f 7 the null frame while f 11 is the unitary frame:
f 7 = 0 X 0 Z 0 X 0 Z f 7 = 1 X 1 Z 1 X 1 Z f 11 = 1 X 1 Z 1 X 1 Z f 11 = 0 X 0 Z 0 X 0 Z
2.
Regular-frames (twelve types) and their conjugate:
f 1 = 0 X 1 Z 1 X 0 Z f 1 = 1 X 0 Z 0 X 1 Z f 5 = 1 X 0 Z 0 X 1 Z f 5 = 0 X 1 Z 1 X 0 Z
f 2 = 1 X 0 Z 1 X 1 Z f 2 = 0 X 1 Z 0 X 0 Z f 6 = 1 X 1 Z 1 X 0 Z f 6 = 0 X 0 Z 0 X 1 Z
f 3 = 0 X 1 Z 1 X 1 Z f 3 = 1 X 0 Z 0 X 0 Z f 4 = 1 X 1 Z 0 X 1 Z f 4 = 0 X 0 Z 1 X 0 Z
f 9 = 0 X 1 Z 0 X 0 Z f 9 = 1 X 0 Z 1 X 1 Z f 10 = 1 X 0 Z 0 X 0 Z f 10 = 0 X 1 Z 1 X 1 Z
f 8 = 0 X 0 Z 1 X 1 Z f 8 = 1 X 1 Z 0 X 0 Z f 12 = 1 X 1 Z 0 X 0 Z f 12 = 0 X 0 Z 1 X 1 Z
f 13 = 0 X 0 Z 0 X 1 Z f 13 = 1 X 1 Z 1 X 0 Z f 14 = 0 X 0 Z 1 X 0 Z f 14 = 1 X 1 Z 0 X 1 Z
The frame f 15 = 0 X 1 Z 0 X 1 Z and the frame f 16 = 1 X 0 Z 1 X 0 Z are not used in this context. Bob obtains the conjugate frames by inverting the measured bits so they are not obtained from the channel measurements.

1.2. General Idea of the Method

It is our goal to demonstrate that using the Composed Sifting String (CSS) is possible that Alice reconciliate 100% of the errors produced in received Bob’s DMDE.
Just to bring it in context, the Sifting String (SS) as stated in [20] is constructed using the sifting bits and the measured bits into Bob’s frames. The sifting bits are obtained applying the XOR function to the bits within the columns (from the left to the right column) of Bob’s frames, where a vacuum bit is taken as a zero bit. The measured bits are taken directly from the bits inside Bob’s frame. This is so because the secret bit is derived from the final configuration of Bob’s frames, that we call Measurement Results (MR) as represented in Table 1. The sifting bits are written first into SS while the measured bits are placed next:
SS = 1 st sifting bit | | 2 nd sifting bit , 1 st measured bit | | 2 nd measured bit
Unfortunately, using SS as designed in [20] is impossible to detect the errors 0 X , 1 Z , 1 X , 0 Z , 1 X , 1 Z and 1 X , 1 Z .
Now, in this new reconciliation method we introduce the Composed Sifting String (CSS) which is constructed taken the sifting bits of Bob’s frame but also the sifting bits of Bob’s conjugate frame, that is:
CSS = 1 st sifting bit | | 2 nd sifting bit | | 1 st sifting bit of conjugate frame | | 2 nd sifting bit of conjugate frame
We will demonstrate that using CSS and without compromising the security of the scheme, is possible to detect the errors 0 X , 0 Z , 0 X , 0 Z , 0 X , 1 Z , 0 X , 1 Z , 1 X , 0 Z , 1 X , 0 Z , 1 X , 1 Z and 1 X , 1 Z .

2. Perfect Reconciliation Using Order-Two Binary Frames

We begin this section by establishing the general steps of the reconciliation method which we will justify throughout the section. To simplify notation, throughout this document we will represent a quantum state using a bold letter instead of the usual ket notation, so we denote | i X as i X .
1.
Alice creates NO-QPL (the Non-Orthogonal Quantum Pair List) and sends, one by one, each NO-QP (the Non-Orthogonal Quantum Pair) across QC (the Quantum Channel). NO-QP can be ( i X , i Z ) or ( i X , ( 1 i ) Z ) where i = 0 , 1 .
2.
Bob chooses randomly the measurement basis: X or Z, that he will use to measure both states inside NO-QP. After Bob registers DDE (the Double Detection Events) he sends DDEL (the Double Detection Event List) to Alice.
3.
Alice receive DDEL from QC, she creates FAIL (the Frame Arrangement Information List) and sends it to Bob.
4.
Bob receives FAIL and he computes CSSL (the Composed Sifting String List). Then he returns CSSL to Alice.
5.
Alice detect errors and identifies MR in regular frames. Alice sends FDL (the Frame to Delete List) to Bob.
6.
Bob eliminates the frames indicated in FDL, then he creates SeS using MRT as written in Table 1.
We call step 3 of the protocol privacy pre-amplification, in this step Alice performs all the combinations of the DMDE to form the frames that she is going to use in order to successfully carry out the error correction process. Then, the number of possible frames is given by the combination formula n 2 = n ! 2 ! ( n 2 ) ! where n is the number of DMDE. The general diagram showing the protocol message exchange is shown in Figure 3.

2.1. Regular and Conjugate 2 × 2 Frames

Conjugate frames are derived from regular frames thus they are not obtained from the physical quantum channel. They are used just to derive a useful complementary set of sifting bits. Below we will show each one of the regular frames, each one with its respective conjugated frame and we will add its corresponding CSS each MR.
0 X 1 Z 1 X 0 Z : + 1 Z + 0 Z 01 0 X + 1 X + 10 0 X + + 0 Z 00 + 1 Z 1 X + 11 1 X 0 Z 0 X 1 Z : + 0 Z + 1 Z 01 1 X + 0 X + 10 1 X + + 1 Z 11 + 0 Z 0 X + 00 CSS : 0101 1010 0011 1100 ( f 1 )
1 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 1 X + 1 X + 00 1 X + + 1 Z 11 + 0 Z 1 X + 10 0 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 0 X + 0 X + 00 0 X + + 0 Z 00 + 1 Z 0 X + 01 CSS : 0101 0000 1100 1001 ( f 2 )
0 X 1 Z 1 X 1 Z : + 1 Z + 1 Z 00 0 X + 1 X + 10 0 X + + 1 Z 01 + 1 Z 1 X + 11 1 X 0 Z 0 X 0 Z : + 0 Z + 0 Z 00 1 X + 0 X + 10 1 X + + 0 Z 10 + 0 Z 0 X + 00 CSS : 0000 1010 0110 1100 ( f 3 )
1 X 1 Z 0 X 1 Z : + 1 Z + 1 Z 00 1 X + 0 X + 10 1 X + + 1 Z 11 + 1 Z 0 X + 01 0 X 0 Z 1 X 0 Z : + 0 Z + 0 Z 00 0 X + 1 X + 10 0 X + + 0 Z 00 + 0 Z 1 X + 10 CSS : 0000 1010 1100 0110 ( f 4 )
1 X 0 Z 0 X 1 Z : + 0 Z + 1 Z 01 1 X + 0 X + 10 1 X + + 1 Z 11 + 0 Z 0 X + 00 0 X 1 Z 1 X 0 Z : + 1 Z + 0 Z 01 0 X + 1 X + 10 0 X + + 0 Z 00 + 1 Z 1 X + 11 CSS : 0101 1010 1100 0011 ( f 5 )
1 X 1 Z 1 X 0 Z : + 1 Z + 0 Z 01 1 X + 1 X + 00 1 X + + 0 Z 10 + 1 Z 1 X + 11 0 X 0 Z 0 X 1 Z : + 0 Z + 1 Z 01 0 X + 0 X + 00 0 X + + 1 Z 01 + 0 Z 0 X + 00 CSS : 0101 0000 1001 1100 ( f 6 )
The sifting algorithm can also be applied to the remaining regular frames f 8 , f 12 , f 9 , f 10 , f 14 , f 14 which we do not show here to facilitate the exposition of the method. The security property or frame-based model states that each CSS must map to at least two MR because the secret bit is derived from MR. The results are presented in Table 2. As can be seen there, the cases CSS 1010 and 0101 should be removed because they map a single MR: 00 and 01, respectively.
Now, we proceed to demonstrate which errors can be detected inside a frame. Due to their structure, is convenient to see the frames grouped as: { f 1 , f 5 }, { f 3 , f 4 }, { f 2 , f 6 }, { f 9 , f 10 }, { f 8 , f 12 }. In the following equations, the top line contains the frame under MR while the second line shows the conjugated frame. The bottom line hold the computed CSS in each case. The error detection illustrated depends on an error-free NO-QP, so we will solve this point as the error correction pre-processing.
1.
The error 1 X , 0 Z is detected with an error-free NO-QP 1 X , 1 Z , as the second row in f 2 because the CSS that is produced by the error is none of the possible error-free CSS.
1 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 1 X + 1 X + 00 1 X + + 1 Z 11 + 0 Z 1 X + 10 0 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 0 X + 0 X + 00 0 X + + 0 Z 00 + 1 Z 0 X + 01 CSS : 0101 0000 1100 1001 1 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 0 X + 1 X + 10 0 X + + 1 Z 01 + 0 Z 1 X + 10 0 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 1 X + 0 X + 10 1 X + + 0 Z 10 + 1 Z 0 X + 01 CSS : 0101 1010 0110 1001 ( f 2 )
2.
The error 1 X , 0 Z is detected with an error-free NO-QP 1 X , 1 Z , as the first row in f 6 because the CSS that is produced by the error is none of the possible error-free CSS.
1 X 1 Z 1 X 0 Z : + 1 Z + 0 Z 01 1 X + 1 X + 00 1 X + + 0 Z 10 + 1 Z 1 X + 11 0 X 0 Z 0 X 1 Z : + 0 Z + 1 Z 01 0 X + 0 X + 00 0 X + + 1 Z 01 + 0 Z 0 X + 00 CSS : 0101 0000 1001 1100 1 X 1 Z 1 X 0 Z : + 1 Z + 0 Z 01 1 X + 0 X + 10 1 X + + 0 Z 10 + 1 Z 0 X + 01 0 X 0 Z 0 X 1 Z : + 0 Z + 1 Z 01 0 X + 1 X + 10 0 X + + 1 Z 01 + 0 Z 1 X + 10 CSS : 0101 1010 1001 0110 ( f 6 )
3.
The error 0 X , 1 Z is detected with an error-free NO-QP 1 X , 1 Z , as the second row in f 3 because the CSS that is produced by the error is none of the possible error-free CSS.
0 X 1 Z 1 X 1 Z : + 1 Z + 1 Z 00 0 X + 1 X + 10 0 X + + 1 Z 01 + 1 Z 1 X + 11 1 X 0 Z 0 X 0 Z : + 0 Z + 0 Z 00 1 X + 0 X + 10 1 X + + 0 Z 10 + 0 Z 0 X + 00 CSS : 0000 1010 0110 1100 0 X 1 Z 1 X 1 Z : + 0 Z + 1 Z 01 0 X + 1 X + 10 0 X + + 1 Z 01 + 0 Z 1 X + 10 1 X 0 Z 0 X 0 Z : + 1 Z + 0 Z 01 1 X + 0 X + 10 1 X + + 0 Z 10 + 1 Z 0 X + 01 CSS : 0101 1010 0110 1001 ( f 3 )
4.
The error 0 X , 1 Z is detected with an error-free NO-QP 1 X , 1 Z , as the first row in f 4 because the CSS that is produced by the error is none of the possible error-free CSS.
1 X 1 Z 0 X 1 Z : + 1 Z + 1 Z 00 1 X + 0 X + 10 1 X + + 1 Z 11 + 1 Z 0 X + 01 0 X 0 Z 1 X 0 Z : + 0 Z + 0 Z 00 0 X + 1 X + 10 0 X + + 0 Z 00 + 0 Z 1 X + 10 CSS : 0000 1010 1100 0110 1 X 1 Z 0 X 1 Z : + 1 Z + 0 Z 01 1 X + 0 X + 10 1 X + + 0 Z 10 + 1 Z 0 X + 01 0 X 0 Z 1 X 0 Z : + 0 Z + 1 Z 01 0 X + 1 X + 10 0 X + + 1 Z 01 + 0 Z 1 X + 10 CSS : 0101 1010 1001 0110 ( f 4 )
5.
The error 0 X , 1 Z is detected with an error-free NO-QP 0 X , 0 Z , as the second row in f 9 because the CSS that is produced by the error is none of the possible error-free CSS.
0 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 0 X + 0 X + 00 0 X + + 0 Z 00 + 1 Z 0 X + 01 1 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 1 X + 1 X + 00 1 X + + 1 Z 11 + 0 Z 1 X + 10 CSS : 0101 0000 0011 0110 0 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 1 X + 0 X + 10 1 X + + 0 Z 10 + 1 Z 0 X + 01 1 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 0 X + 1 X + 10 0 X + + 1 Z 01 + 0 Z 1 X + 10 CSS : 0101 1010 1001 0110 ( f 9 )
6.
The error 1 X , 0 Z is detected with an error-free NO-QP 0 X , 0 Z , as the second row in f 10 because the CSS that is produced by the error is none of the possible error-free CSS.
1 X 0 Z 0 X 0 Z : + 0 Z + 0 Z 00 1 X + 0 X + 10 1 X + + 0 Z 10 + 0 Z 0 X + 00 0 X 1 Z 1 X 1 Z : + 1 Z + 1 Z 00 0 X + 1 X + 10 0 X + + 1 Z 01 + 1 Z 1 X + 11 CSS : 0000 1010 1001 0011 1 X 0 Z 0 X 0 Z : + 1 Z + 0 Z 01 1 X + 0 X + 10 1 X + + 0 Z 10 + 1 Z 0 X + 01 0 X 1 Z 1 X 1 Z : + 0 Z + 1 Z 01 0 X + 1 X + 10 0 X + + 1 Z 01 + 0 Z 1 X + 10 CSS : 0101 1010 1001 0110 ( f 10 )
7.
The error 1 X , 1 Z and also the error 1 X , 1 Z are detected with an error-free NO-QP 0 X , 0 Z , as the first row in f 8 because the CSS that is produced by the error is none of the possible error-free CSS.
0 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 0 X + 1 X + 10 0 X + + 1 Z 01 + 0 Z 1 X + 10 1 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 1 X + 0 X + 10 1 X + + 0 Z 10 + 1 Z 0 X + 01 CSS : 0101 1010 0110 1001 0 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 0 X + 0 X + 00 0 X + + 1 Z 01 + 0 Z 0 X + 00 1 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 1 X + 1 X + 00 1 X + + 0 Z 10 + 1 Z 1 X + 11 CSS : 0101 0000 0110 0011 ( f 8 )
8.
The error 1 X , 1 Z and also the error 1 X , 1 Z are detected with an error-free NO-QP 0 X , 0 Z , as the second row in f 12 because the CSS that is produced by the error is none of the possible error-free CSS.
1 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 1 X + 0 X + 10 1 X + + 0 Z 10 + 1 Z 0 X + 01 0 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 0 X + 1 X + 10 0 X + + 1 Z 01 + 0 Z 1 X + 10 CSS : 0101 1010 1001 0110 1 X 1 Z 0 X 0 Z : + 1 Z + 0 Z 01 0 X + 0 X + 00 0 X + + 0 Z 00 + 1 Z 0 X + 01 0 X 0 Z 1 X 1 Z : + 0 Z + 1 Z 01 1 X + 1 X + 00 1 X + + 1 Z 11 + 0 Z 1 X + 10 CSS : 0101 0000 0011 0110 ( f 12 )

2.2. Error Correction Pre-Processing

In the error-detection cases exhibited above we have assumed that the non-orthogonal quantum pairs (NO-QP) 0 X , 0 Z and 1 X , 1 Z are error-free, which implies being able to detect any error in these NO-QP. In this section, we explain how to detect such errors using null-frames f 7 and unitary-frames f 11 . To achieve this we must note that in the absence of error, f 7 produce CSS that only contain zeros while f 11 produces 0000 and 1100 under MRT.

2.2.1. Null-Frame Errors

The error can arrive in several ways and we need a method to detect them, so the following cases can occur:
Single error:
0 X 0 Z 0 X 0 Z , 0 X 0 Z 0 X 0 Z , 0 X 0 Z 0 X 0 Z , 0 X 0 Z 0 X 0 Z
Non-orthogonal error, two errors in different basis:
0 X 0 Z 0 X 0 Z , 0 X 0 Z 0 X 0 Z
Parallel error, two errors in the same basis:
0 X 0 Z 0 X 0 Z , 0 X 0 Z 0 X 0 Z
As we will see right away, single and parallel errors will be detected as if they were non-orthogonal error using the algorithm for Detection of Parallel-Pair Errors (DPPE) that we explain next:
Alice separates CSSL from null frames into the error-detected-null-frames and the error-free-null-frames just checking that CSS ≠ 0000. The last list contain, however, frames with hidden (parallel) errors. For example, consider Alice’s null frame 0 X 0 Z 0 X 0 Z . If Bob’s frame contains two errors, say 1 X + 1 X + then the errors kept hidden since ( 1100 , x 1 , x 2 ) . Alice takes the row-indices x 1 and x 2 and she looks for them into the error-detected list (see Table 3).
Two cases in the error-detected list reveals the errors in x 1 and x 2 . The frame 1 X + 0 X + with ( 1010 , x 1 , ) where the first row is x 1 , reveals an error in the frame but the result it is ambiguous because the frame 0 X + 1 X + also produces CSS = 1010. Thus, the result is inconclusive because the CSS does not indicate if the error is in the first or the second row. However, Alice keeps searching into the list of errors and she finds ( 1100 , x 1 , ) which comes from the frame 1 X + + 1 X where the first row contains x 1 and the second row also contains an error. Interestingly, this CSS reveals the presence of a non-orthogonal error. Similarly, Alice finds another label that exhibits x 2 and the parallel error is detected using a non-orthogonal error which applies for single errors too.
The following aspects must be remarked here:
1.
Given an error rate in the quantum channel, it is to be expected that about half of the errors will occur in the first quantum state of 0 X , 0 Z and the other half in the second state 0 X , 0 Z . Therefore, the method described to detect single and parallel errors in null-frames is completely feasible.
2.
The algorithm detailed above allows finding all the errors in the null frames, but it does not tell us which of the two non-orthogonal states is the error. To find the position of the error, Alice must use an error free NO-QP say y 1 = 0 X , 0 Z from the list of error-free-null-frames. Then she finds ( 0101 , x 1 , y 1 ) which reveals the error is in the first state while ( 1010 , x 1 , y 1 ) unveils the error in the second state (see Table 3).
How should it be clear, in all cases, Alice must be able to identify the position of the error to perform reconciliation successfully. Importantly here is that detecting the position of the error also allows Alice to find MR when using this error-row inside a frame. For this purpose and assuming Alice has detected all the errors, consider the following frame cases:
1.
First and second rows without errors. Alice applies the usual frame-based sifting algorithm identifying MR in each case.
2.
First and second rows with errors. Since error-detection reveals the position of the error, Alice identifies MR straightforward.
3.
Error-free (first/second) row and error-detected (second/first) row. In the next lines we discuss this case.
Suppose Alice has detected all the errors and she must guess MR when she sends 0 X 1 Z 0 X 0 Z and Bob gets + 1 Z 1 X + thus he returns to Alice CSS = 1100. But Alice knows the following facts:
CSS comes from f 9 .
The first row is error-free but the first state of the second row is error-detected, that is 0 X , 0 Z .
Then Alice tests f 9 under MRT (see Table 1) given 0 X , 0 Z and CSS = 1100, thus she concludes that the unique MR that matches CSS is under MR = 11.

2.2.2. Unitary-Frame Errors

Frames f 11 behave similarly as frames f 7 , so we present the summary results in Table 4. As far as we go, we are able to detect 0 X , 0 Z , 0 X , 0 Z , 1 X , 1 Z , 1 X , 1 Z errors.

2.3. Reconciliation Algorithm

To close this section let us summarize the steps of the reconciliation algorithm. Table 5 shows the error detection results using regular frames.
1.
Identify 0 X , 0 Z and 0 X , 0 Z , 0 X , 0 Z errors in the set of f 7 . Identify single and parallel errors using DPPE algorithm.
2.
Identify 1 X , 1 Z and 1 X , 1 Z , 1 X , 1 Z errors in the set of f 11 . Identify single and parallel errors using DPPE algorithm.
3.
Identify MR using 0 X , 0 Z   0 X , 0 Z , 0 X , 0 Z and 1 X , 1 Z   1 X , 1 Z , 1 X , 1 Z in f 8 , f 12 .
4.
Identify 0 X , 1 Z , 1 X , 0 Z and 0 X , 1 Z , 1 X , 0 Z errors in f 9 , f 10 , f 13 , f 14 using 0 X , 0 Z , 0 X , 0 Z , 0 X , 0 Z . Identify MR in f 9 , f 10 , f 13 , f 14 .
5.
Identify 0 X , 1 Z , 1 X , 0 Z and 0 X , 1 Z , 1 X , 0 Z errors in f 2 , f 6 , f 3 , f 4 using 1 X , 1 Z , 1 X , 1 Z , 1 X , 1 Z , 0 X , 1 Z , 1 X , 0 Z , 0 X , 1 Z , 1 X , 0 Z . Identify MR in f 2 , f 6 , f 3 , f 4 .
6.
Identify MR in f 1 , f 5 using 0 X , 1 Z , 1 X , 0 Z , 0 X , 1 Z , 0 X , 1 Z , 1 X , 0 Z , 1 X , 0 Z .
As has been demonstrated so far, errors can be detected regardless of the number of errors. Thus, the gain of the secret bits does not depend on the error rate of the quantum channel.

3. The Throughput of Frame Reconciliation

Not all the frames are converted into secret bits. In [21] we derived the throughput as 1 4 1 2 ( 1 e ) + 1 6 e that reaches a maximum gain of 1 8 n 2 when e = 0 . Taking into account Table 2, we arrive to the throughput Equation (1) of frame reconciliation T where n is the number or Double Matching Detection Events.
T = 1 16 4 · 1 2 + 8 · 3 4 n 2 = 1 2 n 2 = 1 2 n ( n 1 ) 2 1 4 n 2
Computing the photonic gain of double detection events at Bob’s side as Q ( + , + ) = ( 1 e μ ) 2 (neglecting the losses generated by the quantum channel and the losses of the optical detection system), we derived Equation (2) where N is the total number of quantum pulses sent by Alice to Bob. As a result, the number of secret bits grows doubly quadratically as a function of the number of quantum pulses N.
T = 1 4 ( 1 e μ ) 4 N 4
One of the biggest challenges posed by the Photon Number Splitting (PNS) attack is that the number of photons per pulse ( μ ) should not be increased because an attacker can split the pulse and store a copy of it. However, in frame-based reconciliation, the secret bits do not result only from the quantum pulses that arrive to Bob’s detector, but from the double detection events that occur at Bob’s station. So the security of our approach does no depend on the photon mean μ of the quantum pulse neither the channel error-rate e.

4. Immunity to Quantum Attacks

Produce a double detection event does not depend on the transmittance of the quantum channel but in the quantum probability. This property gives immunity to the quantum key distribution protocol when it relies on double detection event as the vehicle to transmit a secret bit. Since the reconciliation efficiency does not depend on the quantum channel error rate, we will start this section by looking at the effect of quantum channel noise on error production. Later we explain why the frame-based QKD is immune to the Intercept-Resend attack (IR), the Photon Number Splitting attack (PNS) and the Quantum Bases Choice attack (BC). Our research work is still in progress to extend the discussion and demonstrate security of our method over other more general quantum attacks as collective attacks.

4.1. Errors in the Quantum Channel

Whatever the type of the noise in the quantum channel, be it rotation noise or dephasing noise [22], it can be interpreted as a Bloch sphere rotation axis causing a variation in the polarization of the quantum state [23], thus producing errors in the information encoded in it. Suppose, for example, that due to the effect of channel noise, state | 0 Z moves to | 1 X and state | 0 X becomes | 1 Z as represented in Figure 4. If Bob uses the basis X to measure the pair of non-orthogonal states ( | 0 X , | 0 Z ), there are two probable outcomes:
| 1 X as a result of a double matching detection event which according to the reconciliation method is taken as an error.
( | 0 X , | 1 X ) caused by a double non-matching detection event that is useless to perform reconciliation.
The same result applies for the Z basis (see Figure 4). The most important conclusion from this analysis is that | 0 X can never be accepted as | 1 X since it is interpreted as an error. Such behavior comes from the fact that a pair of orthogonal states hold a single bit of information. Let us now proceed to the analysis of the behavior of the protocol in the presence of attacks on the QKD system.

4.2. The Intercept and Resend Attack (IR)

Eve must measure each pair of non-orthogonal quantum pulses that crosses the quantum channel and produce a double matching detection event, then according to the result obtained from her measurement, Eve sends another pair of non-orthogonal quantum pulses to Bob. In addition, Eve must ensure that both states that she forwards to Bob’s station are not lost on the quantum channel, but assuming she can overcome this difficulty, Eve’s final gain, as indicated in Table 6 is 0.25 .

4.2.1. The Photon Number Splitting Attack (PNS)

Eve obtains a copy of the quantum states that Bob receives in his optical station and stores them in a quantum memory. However, the probability that Eve gets a double matching detection event as registered by Bob is 0.5 . In addition, Eve must measure by choosing between two different measurement bases ( X or Z ), so the final gain of the attack is 0.25 (see Table 7).

4.2.2. The Quantum Measurement Bases Choice Attack (BC)

The attacker could use other quantum measurement bases to gain more information, for example Eve could use the pair of measurement bases X + Z , X Z . Now, suppose Bob has registered a double matching detection event and Eve has a copy of those states then she could get Bob’s information with a probability of 0.28. This is so because Eve chooses one of the measurement bases X + Z or X Z with a probability of 0.5. But the non-matching detection events are ambiguous for Eve, which occurs with a probability of 0.37. Rather, she gets a double matching event with probability 0.56. As a result, the probability of getting Bob’s information is 0.28 (see Table 8).
We must highlight that one the main advantages of the immunity to described quantum attacks, is that the mean photon value μ in Equation (2) can be properly increased in the quantum regime, so that longer distance can be achieved in QKD link. Further on, the number of secret bits grows doubly quadratic in the number of quantum pulses.

5. Discussion

Table 9 shows according to [24] a general comparison between some of the most representative reconciliation algorithms where we have included the introduced method. Although we are currently working in the software implementation of the algorithm, we base our evaluation in the following criteria: the algorithm requires only four message exchanges as can be seen in Figure 3. The effectiveness of the protocol is perfect since all errors are corrected regardless of the quantum channel error rate.
The QKD protocol runs in a single process that includes quantum communication and classical post-processing based on two-order frames. The throughput grows doubly quadratically as a function of the number of quantum pulses and the runtime requires only milliseconds as demonstrated in our previous software implementation. Furthermore, our method does not require redundant bits to be sent, and there is no need to estimate quantum channel error rate while is invariant against burst errors. We present an appendix that describes the execution of the QKD protocol and the frame-based reconciliation algorithm (see Appendix A).

6. Conclusions

We introduced a method to achieve complete reconciliation in Quantum Key Distribution which identifies the transmitted errors in a reverse reconciliation that corrects 100% of the errors that is invariant with respect to the error rate of the quantum channel.
The QKD protocol, which is based on sending pairs of non-orthogonal quantum states and reconciliation through frames of two-order, is executed in a single process that includes quantum communication and classical post-processing. Furthermore, it does not require the sending of redundant bits, nor is it necessary to estimate the error rate of the quantum channel.
At least theoretically, the number of secret bits grows doubly quadratically as a function of the number of quantum pulses sent by Alice because the mean photon value can be properly increased in the quantum regime, so that longer distance can be achieved in QKD system.

Author Contributions

L.A.L.-P. conceived of the presented idea, he developed the theoretical formalism, J.M.L.-R. supervised the project and contributed to the interpretation of the results. All authors have read and agreed to the published version of the manuscript.

Funding

This research was funded by National Council of Science and Technology of Mexico (CONACyT) and Center for Research and Advanced Studies of the National Polytechnic Institute of Mexico (Cinvestav-IPN).

Data Availability Statement

The data presented in this study are available within the article.

Conflicts of Interest

The authors declare no conflict of interest in this article.

Appendix A

This appendix contains a simple execution of the protocol using the CSS-based reconciliation algorithm. To simplify the discussion in Figure A1, we assume that the channel causes errors but does not lose any quantum pulses, in addition the pairs of non-orthogonal states are sent sequentially and all of them produce double matching detection events. Let us describe the steps of the QKD protocol:
1.
Alice creates NO-QPL (the Non-Orthogonal Quantum Pair List) and sends, one by one, each NO-QP (the Non-Orthogonal Quantum Pair) across QC (the Quantum Channel). In the simulation NO-QP are 1: ( 0 X , 0 Z ) , 2: ( 0 X , 0 Z ) , 3: ( 1 X , 1 Z ) , 4: ( 1 X , 1 Z ) , 5: ( 0 X , 1 Z ) , 6: ( 0 X , 1 Z ) .
2.
Bob chooses randomly the measurement basis: X or Z , that he will use to measure both states inside NO-QP. After Bob registers DDE (the Double Detection Events) he sends DDEL (the Double Detection Event List) to Alice. In this example, we assume that all NO-QP produce DDE, so DDEL = 1 6 .
3.
Alice receive DDEL from QC, she creates FAIL (the Frame Arrangement Information List) and sends it to Bob. Here we have DDEL = 1:(1, 2), 2:(3, 4), 3:(1, 3), 4:(1, 4), 5:(2, 3), 6:(2, 4), 7:(3, 1), 8:(4, 1), 9:(3, 2), 10:(4, 2), 11:(5, 1), 12:(5, 2), 13:(1, 5), 14:(2, 5), 15:(6, 3), 16:(6, 4), 17:(3, 6), 18:(4, 6).
4.
Bob receives FAIL and he computes CSSL (the Composed Sifting String List). Then he returns CSSL to Alice that in our case corresponds to CSSL= 1:1100, 2:1100, 3:1100, 4:0000, 5:0000, 6:1100, 7:1100, 8:0000, 9:0000, 10:1100, 11:0101, 12:1001, 13:0101, 14:1001, 15:1001, 16:0101, 17:1001, 18:0101.
5.
Alice detect errors and identifies MR in regular frames. Alice sends FDL (the Frame to Delete List) to Bob. Alice achieves error correction as indicated by the reconciliation algorithm discussed in Section 2.3 and illustrated in Table A1. It should be noted that for the simulation we assume a conservative channel so FDL is empty.
6.
Bob eliminates the frames indicated in FDL, then he creates SeS using MRT as written in Table 1. In the example we derive 16 secret bits.
As shown in Table A1, 16 of 18 frames are in error, so e = 0.88. However, 16 bits are distilled while only 6 double detection events have been registered at Bob’s station, demonstrating the high throughput of secret bits that the protocol produces.
A relevant case to be taken into account is when the frame contains double errors. We must clarify that Alice knows in advance that the frame contains two errors, so to get the MR, Alice only has to apply Table 1. This is because the MRs of the error-free frame do not contradict the MRs of the two-error frame. On the contrary, if the frame contains only one error it is necessary that given the error, Alice determines which is the MR that satisfies the CSS.
Figure A1. An illustrative execution of the protocol. In this simulation 16 of 18 frames are in error.
Figure A1. An illustrative execution of the protocol. In this simulation 16 of 18 frames are in error.
Symmetry 13 01672 g0a1
Table A1. Alice’s reconciliation process. Error detection is indicated with an overbracket symbol.
Table A1. Alice’s reconciliation process. Error detection is indicated with an overbracket symbol.
ItemFrameNO-QP IndexCSSMRError-Detection
1. f 7 1, 21100- 1 , 2
2. f 11 3, 41100- 3 , 4
3. f 8 1, 3110011 1 , 3
4.1, 4000001 1 , 4
5.2, 3000000 2 , 3
6.2, 4110010 2 , 4
7. f 12 3, 1110010 3 , 1
8.4, 1000001 4 , 1
9.3, 2000000 3 , 2
10.4, 2110011 4 , 2
11. f 9 5, 1010101 5 , 1
12.5, 2100111 5 , 2
13. f 13 1, 5010101 1 , 5
14.2, 5100110 2 , 5
15. f 3 6, 3100111 6 , 3
16.6, 4010101 6 , 4
17. f 4 3, 6100111 3 , 6
18.4, 6010101 4 , 6

References

  1. Alagic, G.; Alperin-Sheriff, J.; Apon, D.; Cooper, D.; Dang, Q.; Kelsey, J.; Liu, Y.K.; Miller, C.; Moody, D.; Peralta, R.; et al. Status Report on the Second Round of the NIST Post-Quantum Cryptography Standardization Process; US Department of Commerce, NIST: Gaithersburg, MD, USA, 2020. [Google Scholar]
  2. Wiesmaier, A.; Alnahawi, N.; Grasmeyer, T.; Geißler, J.; Zeier, A.; Bauspieß, P.; Heinemann, A. On PQC Migration and Crypto-Agility. arXiv 2021, arXiv:2106.09599. [Google Scholar]
  3. Mehic, M.; Niemiec, M.; Siljak, H.; Voznak, M. Error Reconciliation in Quantum Key Distribution Protocols. In Reversible Computation: Extending Horizons of Computing, Lecture Notes in Computer Science; Ulidowski, I., Lanese, I., Schultz, U., Ferreira, C., Eds.; Springer Nature: Berlin/Heidelberg, Germany, 2020; pp. 222–236. [Google Scholar]
  4. Bennett, C.H.; Bessette, F.; Brassard, G.; Salvail, L.; Smolin, J. Experimental quantum cryptography. J. Cryptol. 1992, 5, 3–28. [Google Scholar] [CrossRef]
  5. Brassard, G.; Salvail, L. Secret-key reconciliation by public discussion. In Workshop on the Theory and Application of of Cryptographic Techniques; Springer Science & Business Media: Berlin/Heidelberg, Germany, 1993; pp. 410–423. [Google Scholar]
  6. Pedersen, T.B.; Toyran, M. High performance information reconciliation for QKD with CASCADE. arXiv 2013, arXiv:1307.7829. [Google Scholar]
  7. Buttler, W.T.; Lamoreaux, S.K.; Torgerson, J.R.; Nickel, G.; Donahue, C.; Peterson, C.G. Fast, efficient error reconciliation for quantum cryptography. Phys. Rev. A 2003, 67, 052303. [Google Scholar] [CrossRef] [Green Version]
  8. Zhao, F.; Fu, M.; Wang, F.; Lu, Y.; Liao, C.; Liu, S. Error reconciliation for practical quantum cryptography. Optik 2007, 118, 502–506. [Google Scholar] [CrossRef]
  9. Yan, H.; Peng, X.; Lin, X.; Jiang, W.; Liu, T.; Guo, H. Efficiency of winnow protocol in secret key reconciliation. In Proceedings of the 2009 WRI World Congress on Computer Science and Information Engineering, Los Angeles, CA, USA, 31 March–2 April 2009; Volume 3, pp. 238–242. [Google Scholar]
  10. Li, Q.; Yang, Z.; Mao, H.; Wang, X. Study on Scrambling Algorithms of Error Reconciliation in QKD. In Proceedings of the 2018 Eighth International Conference on Instrumentation & Measurement, Computer, Communication and Control (IMCCC), Harbin, China, 19–21 July 2018; pp. 1363–1367. [Google Scholar]
  11. Gallager, R. Low-density parity-check codes. IRE Trans. Inf. Theory 1962, 8, 21–28. [Google Scholar] [CrossRef] [Green Version]
  12. Elliott, C.; Colvin, A.; Pearson, D.; Pikalo, O.; Schlafer, J.; Yeh, H. Current status of the DARPA quantum network. In Proceedings of the Quantum Information and Computation III. International Society for Optics and Photonics, Baltimore, MD, USA, 2–3 May 2013; Volume 5815, pp. 138–149. [Google Scholar]
  13. Watanabe, S.; Matsumoto, R.; Uyematsu, T. Tomography increases key rates of quantum-key-distribution protocols. Phys. Rev. A 2008, 78, 042316. [Google Scholar] [CrossRef] [Green Version]
  14. Mink, A.; Nakassis, A. LDPC for QKD reconciliation. arXiv 2012, arXiv:1205.4977. [Google Scholar]
  15. Martinez-Mateo, J.; Elkouss, D.; Martin, V. Key reconciliation for high performance quantum key distribution. Sci. Rep. 2013, 3, 1–6. [Google Scholar] [CrossRef] [PubMed] [Green Version]
  16. Arikan, E. Channel polarization: A method for constructing capacity-achieving codes for symmetric binary-input memoryless channels. IEEE Trans. Inf. Theory 2009, 55, 3051–3073. [Google Scholar] [CrossRef]
  17. Jouguet, P.; Kunz-Jacques, S. High performance error correction for quantum key distribution using polar codes. arXiv 2012, arXiv:1204.5882. [Google Scholar]
  18. Nakassis, A.; Mink, A. Polar codes in a QKD environment. In Proceedings of the Quantum Information and Computation XII. International Society for Optics and Photonics, Baltimore, MD, USA, 5–9 May 2014; Volume 9123, p. 912305. [Google Scholar]
  19. Yan, H.; Ren, T.; Peng, X.; Lin, X.; Jiang, W.; Liu, T.; Guo, H. Information reconciliation protocol in quantum key distribution system. In Proceedings of the 2008 Fourth International Conference on Natural Computation, Jinan, China, 18–20 October 2008; Volume 3, pp. 637–641. [Google Scholar]
  20. Lizama-Perez, L.A.; López, J.M. Quantum key distillation using binary frames. Symmetry 2020, 12, 1053. [Google Scholar] [CrossRef]
  21. Lizama-Pérez, L.A.; Samperio, E.H. Beyond the limits of Shannon’s information in quantum key distribution. Entropy 2021, 23, 229. [Google Scholar] [CrossRef] [PubMed]
  22. Chao, W.; Jianwei, L.; Xiubo, C.; Yagang, B.; Tao, S. Fault tolerant deterministic secure quantum communication using logical Bell states against collective noise. Chin. Phys. B 2015, 24, 040304. [Google Scholar]
  23. Chen, Z.; Bohnet, J.G.; Weiner, J.M.; Thompson, J.K. General formalism for evaluating the impact of phase noise on Bloch vector rotations. Phys. Rev. A 2012, 86, 032313. [Google Scholar] [CrossRef] [Green Version]
  24. Johnson, J.S. An Analysis of Error Reconciliation Protocols for Use in Quantum Key Distribution. Master’s Thesis, Air Force Institute of Technology, Montgomery County, OH, USA, 2012. [Google Scholar]
Figure 1. General scheme of frame-based QKD approach. Each row of the frame is a pair of non-orthogonal states: each position inside the frame encodes a quantum bit, so in the first position is | i X or | ( 1 i ) X while in the second | i Z or | ( 1 i ) Z where i = 0 , 1 . The symbol + denotes an empty state.
Figure 1. General scheme of frame-based QKD approach. Each row of the frame is a pair of non-orthogonal states: each position inside the frame encodes a quantum bit, so in the first position is | i X or | ( 1 i ) X while in the second | i Z or | ( 1 i ) Z where i = 0 , 1 . The symbol + denotes an empty state.
Symmetry 13 01672 g001
Figure 2. Alice sends two pairs of non-orthogonal states to Bob over the quantum channel: ( | 0 X , | 1 Z ) and ( | 1 X , | 1 Z ) . Bob’s gets two events of double matching detection events: ( | 0 X , + ) and ( + , | 1 Z ) .
Figure 2. Alice sends two pairs of non-orthogonal states to Bob over the quantum channel: ( | 0 X , | 1 Z ) and ( | 1 X , | 1 Z ) . Bob’s gets two events of double matching detection events: ( | 0 X , + ) and ( + , | 1 Z ) .
Symmetry 13 01672 g002
Figure 3. The reconciliation message exchange: NO-QP represents the quantum pulses over the quantum channel. Remaining steps take place over the classical channel. The meaning of the acronyms used is shown below. NO-QP: Non-Orthogonal Quantum Pairs. DDEL: the Double Detection Event List. FAIL: the Frame Arrangement Information List. CSSL: the Composed Sifting String List. FDL: the Frame to Delete List.
Figure 3. The reconciliation message exchange: NO-QP represents the quantum pulses over the quantum channel. Remaining steps take place over the classical channel. The meaning of the acronyms used is shown below. NO-QP: Non-Orthogonal Quantum Pairs. DDEL: the Double Detection Event List. FAIL: the Frame Arrangement Information List. CSSL: the Composed Sifting String List. FDL: the Frame to Delete List.
Symmetry 13 01672 g003
Figure 4. We see in the (2-dimensional) Bloch sphere the effect generated by the noise of the quantum channel on the pair of non-orthogonal quantum states.
Figure 4. We see in the (2-dimensional) Bloch sphere the effect generated by the noise of the quantum channel on the pair of non-orthogonal quantum states.
Symmetry 13 01672 g004
Table 1. Matching Results Table (MRT) for 2 × 2 frames. Since the bit that results from the measurement is not relevant to define MR but the position in which it appears, we use the symbol • to represent a quantum measurement while + denotes an empty state.
Table 1. Matching Results Table (MRT) for 2 × 2 frames. Since the bit that results from the measurement is not relevant to define MR but the position in which it appears, we use the symbol • to represent a quantum measurement while + denotes an empty state.
MR = 00 | X + | X + MR = 10 | X + + | Z
MR = 01 + | Z + | Z MR = 11 + | Z | X +
Table 2. Each Composed Sifting String (CSS) must be correlated at least to two Matching Results (MR). The symbol sb denotes the secret bit.
Table 2. Each Composed Sifting String (CSS) must be correlated at least to two Matching Results (MR). The symbol sb denotes the secret bit.
CSSFrameMRSbAction
0110 f 3 , f 8 , f 13 100distill
f 4 , f 12 , f 9 111
1001 f 2 , f 8 , f 14 110distill
f 6 , f 12 , f 10 101
0011 f 1 , f 9 , f 14 100distill
f 5 , f 10 , f 13 111
0000 f 2 , f 6 , f 9 , f 13 000distill
f 3 , f 4 , f 10 , f 14 011
1100 f 1 , f 3 , f 6 110distill
f 2 , f 4 , f 5 101
1010 f 1 , f 3 , f 4 , f 5 00-remove
f 8 , f 12 , f 10 , f 14
0101 f 1 , f 2 , f 5 , f 6 01-remove
f 8 , f 12 , f 9 , f 13
Table 3. Analysis of f 7 frame set. Separate lists of error-detected-null-frames and error-free-null-frames. The symbol ∗ represents an arbitrary NO-QP index.
Table 3. Analysis of f 7 frame set. Separate lists of error-detected-null-frames and error-free-null-frames. The symbol ∗ represents an arbitrary NO-QP index.
Error-DetectedError-Free
CSS ! 0 i 1 i 2 CommentCSS = 0 i 1 i 2 Comment
1010 0000 x 1 x 2 hidden error
1100 x 1 double-error-detection0000 y 1 y 2
1100 x 2 double-error-detection0000
1010 0000
1001 0000
0101 x 1 y 1 first-state-error0000
1010 x 2 y 1 second-state-error0000
Table 4. Analysis of f 11 frame set. Separate lists of error-detected-unitary-frames and error-free-unitary-frames. The symbol ∗ represents an arbitrary NO-QP index.
Table 4. Analysis of f 11 frame set. Separate lists of error-detected-unitary-frames and error-free-unitary-frames. The symbol ∗ represents an arbitrary NO-QP index.
Error-DetectedError-Free
CSS i 1 i 2 CommentCSS i 1 i 2 Comment
1010 0000 x 1 x 2 hidden error
0011 x 1 double-error-detection1100 y 1 y 2
0011 x 2 double-error-detection1100
0101 1100
1001 0000
1010 x 1 y 1 first-state-error0000
1001 x 2 y 1 second-state-error1100
Table 5. Error detection using regular frames.
Table 5. Error detection using regular frames.
CSSFrameMRError Detection
1010 f 2 , f 6 00 1 X , 0 Z
0110 f 2 10 1 X , 0 Z
f 6 11
1001 f 3 11 0 X , 1 Z
f 4 10
0101 f 3 , f 4 01 0 X , 1 Z
1010 f 9 00 0 X , 1 Z
100110
1010 f 13 00 0 X , 1 Z
100111
0101 f 10 01 1 X , 0 Z
100110
0101 f 14 01 1 X , 0 Z
011010
Table 6. Eve is forced to produce a double detection event, then she must guess Bob’s basis which occurs with 0.5 probability, so Eve’s final probability is 0.25 .
Table 6. Eve is forced to produce a double detection event, then she must guess Bob’s basis which occurs with 0.5 probability, so Eve’s final probability is 0.25 .
AliceEveBob
Q ( + , + ) 0.5 DMDE 0.5 X basis
0.5 Z basis
Table 7. Eve is required to produce a double matching detection event as Bob. In addition, Eve must choose the appropriate basis which occurs with 0.5 probability, so Eve’s final probability is 0.25 .
Table 7. Eve is required to produce a double matching detection event as Bob. In addition, Eve must choose the appropriate basis which occurs with 0.5 probability, so Eve’s final probability is 0.25 .
AliceBobEve
Q ( + , + ) 0.5 DMDE 0.5 X basis
0.5 Z basis
Table 8. Eve is required to produce a double matching detection event as Bob with probability 0.56. In addition, Eve must choose the appropriate basis which occurs with probability of 0.5, so Eve’s final probability is 0.28.
Table 8. Eve is required to produce a double matching detection event as Bob with probability 0.56. In addition, Eve must choose the appropriate basis which occurs with probability of 0.5, so Eve’s final probability is 0.28.
AliceBobEve
Q ( + , + ) 0.56 DMDE0.5 X basis
0.5 Z basis
Table 9. Comparison of main reconciliation algorithms based on [24]. Complexity refers to computational or communication complexity. Effectiveness is the corrective percentage efficiency of the protocol. Throughput is the secret key rate measured in bits per second. Runtime is the number of seconds required to execute the algorithm.
Table 9. Comparison of main reconciliation algorithms based on [24]. Complexity refers to computational or communication complexity. Effectiveness is the corrective percentage efficiency of the protocol. Throughput is the secret key rate measured in bits per second. Runtime is the number of seconds required to execute the algorithm.
AlgorithmComplexityEffectivenessThroughputRuntime
CascadeHighMediumLowMedium
WinnowMediumLowHighLow
LDPCHighHighMediumHigh
This workLowHighHighLow
Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

Share and Cite

MDPI and ACS Style

Lizama-Pérez, L.A.; López-Romero, J.M. Perfect Reconciliation in Quantum Key Distribution with Order-Two Frames. Symmetry 2021, 13, 1672. https://doi.org/10.3390/sym13091672

AMA Style

Lizama-Pérez LA, López-Romero JM. Perfect Reconciliation in Quantum Key Distribution with Order-Two Frames. Symmetry. 2021; 13(9):1672. https://doi.org/10.3390/sym13091672

Chicago/Turabian Style

Lizama-Pérez, Luis Adrián, and José Mauricio López-Romero. 2021. "Perfect Reconciliation in Quantum Key Distribution with Order-Two Frames" Symmetry 13, no. 9: 1672. https://doi.org/10.3390/sym13091672

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop