What is meant with "reconciliation" in CV QKD?

Question

I am working on a paper about Continuous Variable QKD. (https://arxiv.org/abs/1711.08500v2)

I read about direct and reverse reconciliation in this paper. I don't understand what exactly Reconciliation is? Reconciliation algorithms, reconciliation protocols and so on.

I am really confused. Can any one explain reconciliation to me?

Answer 1

I assume the paper you are reading is referring to information reconciliation.

Information reconciliation is a vital part of post-processing in QKD, to limit (or erase in the best-case scenario) the amount of errors/differences between the key of Alice and Bob.

In that sense, it is a form of (classical) error-correction, and, broadly speaking, it works like this:

• Alice and Bob run a QKD protocol together and both obtain a raw key $k_{a}$ and $k_{b}$ of whatever length.
• In real world scenarios, $k_{a} \not = k_{b}$ due to measurement errors, imperfect channels etc. Alice and Bob want the exact same key, so they need to fix this.
• However, $k_{a} \simeq k_{b}$; we can write $k_{b} = k_{a} + \epsilon$, where $\epsilon$ is the error/difference between Alice and Bob, and therefore $\epsilon \simeq \overrightarrow{0}$ (i.e. $\epsilon$ is a bitstring with almost all entries equal to $0$ because there are not that many errors).
• Alice and Bob have (in advance) agreed to use a certain error code to perform error correction. This error code is some linear function $f$ that calculates the syndrome $s$ of a key. Note that the error code may or may not be secret to Alice and Bob.
• It is hard to reverse this function in general. $s$ is of considerably shorter length than $k$. So, there are multiple $k$ with the same $s$.
• Alice calculates $s_{a} = f(k_{a})$ and publicly communicates $s_{a}$. Any Eve cannot do anything with this because the function is in general hard to reverse.
• Bob receives $s_{a}$ and calculates $s_{b}$. The function is linear, so $s_{b} = f(k_{b}) = f(k_{a} + \epsilon) = f(k_{a}) + f(\epsilon) = s_{a} + s_{\epsilon}$. Therefore, the 'error syndrome' $s_{\epsilon} = s_{a} - s_{b}$ encodes only information about $\epsilon$.
• Only Bob can calculate $s_{\epsilon}$. Because the code was designed properly (and for this exact function), and because $\epsilon \simeq \overrightarrow{0}$, Bob can decode the error syndrome to estimate $\epsilon$: $\hat{\epsilon} = f^{-1}(s_{\epsilon})$.
• Finally, Bob calculates $\hat{k_{a}} = k_{b} - \hat{\epsilon}$. If the code is any good, $\hat{k_{a}} - k_{a} \rightarrow 0$, i.e. Alices key and Bobs corrected key are very close/almost always the same.

There are a lot of important details I have grossed over, but this is the general idea. For a nice introduction of information reconciliation/error correction in the scope of QKD, check this paper.

Note that the above is error-correction for general QKD, not necessarily only for continuous variable QKD. I suspect that there are small discrepancies between the two, but the main goal should be the same.