Q# Standard Libraries "Error Correction"を翻訳する。

$$\newcommand{\bra}[1]{\left\langle #1 \right|}$$$$\newcommand{\ket}[1]{\left|#1 \right\rangle}$$$$\newcommand{\bracket}[2]{\left\langle #1 \middle|#2 \right\rangle}$$
以下のサイトを翻訳してみます。
https://docs.microsoft.com/en-us/quantum/libraries/error-correction?view=qsharp-preview
Introduction
=
In classical computing, if one wants to protect a bit against errors, it can often suffice to represent that bit by a <em>logical bit</em> by repeating the data bit.
For instance, let $\overline{0} = 000$ be the encoding of the data bit 0, where we use the a line above the label 0 to indicate that it is an encoding of a bit in the 0 state.
If we similarly let $\overline{1} = 111$, then we have a simple repetition code that protects against any one bit flip error.
That is, if any of the three bits are flipped, then we can recover the state of the logical bit by taking a majority vote.
Though classical error correction is a much richer subject that this particular example (we recommend <a href="https://www.springer.com/us/book/9783540641339" data-linktype="external">Lint&#39;s introduction to coding theory</a>), the repetition code above already points to a possible problem in protecting quantum information.
Namely, the <a class="xref" href="https://docs.microsoft.com/en-us/quantum/quantum-concepts-7-paulimeasurements?view=qsharp-preview#the-no-cloning-theorem" data-linktype="relative-path">no-cloning theorem</a> implies that if we measure each individual qubit and take a majority vote by analogy to classical code above, then we have lost the precise information that we are trying to protect.

古典的なコンピューティングでは、ビットをエラー(ノイズ)から保護したい場合、データビットを繰り返すことによって、そのビットを”論理ビット”として表します。
たとえば、$\overline{0} = 000$によって、データ”０”ビットをエンコーディングします。ここで、0の上のバーで、0状態のビットのエンコーディングであることを示します。
同様に$\overline{1} = 111$とすると、1ビットフリップエラーから保護できる、単純な繰り返しコードが得られます。
すなわち、3つのビットのいずれかがフリップされた場合、多数決を取って論理ビットの状態を回復することができるというわけです。
ただし、ここで述べたのはほんの一例であり、古典的なコンピューティングの誤り訂正は実際、この特定の例よりもはるかに豊富なテーマを含んでいます（詳しくは<a href="https://www.springer.com/us/book/9783540641339" data-linktype="external"> Lintの符号化理論入門</a>をオススメします）。上記の繰り返しコードはすでに量子情報を保護する上で起こりうる問題を指摘しています。
つまり、<a class="xref" href="https://docs.microsoft.com/en-us/quantum/quantum-concepts-7-paulimeasurements?view=qsharp-preview#the-no-cloning-theorem" data-linktype="relative-path"> 非クローニング定理</a>によって、個々の量子ビットを測定し、上記の古典的な方法と同様に多数決を取ってしまうと、保護しようとしている正確な量子情報を失ってしまうのです。

In the quantum setting, we will see that the measurement is problematic. We can still implement the encoding above.
It is helpful to do so to see how we can generalize error correction to the quantum case.

Thus, let $\ket{\overline{0}} = \ket{000} = \ket{0} \otimes \ket{0} \otimes \ket{0}$, and let $\ket{\overline{1}} = \ket{111}$.
Then, by linearity, we have defined our repetition code for all inputs; for instance, $\ket{\overline{+}} = (\ket{\overline{0}} + \ket{\overline{1}}) / \sqrt{2} = (\ket{000} + \ket{111}) / \sqrt{2}$.
In particular, letting a bit-flip error $X_1$ act on the middle qubit, we see that the correction needed in both branches is precisely $X_1$:
$$
\begin{align}
    X_1 \ket{\overline{+}}  = \frac{1}{\sqrt{2}} \left(X_1\ket{000} + X_1\ket{111}\right)\\ = \frac{1}{\sqrt{2}} \left(\ket{010} + \ket{101}\right).
\end{align}
$$
To see how we can identify that this is the case without measuring the very state we are trying to protect, it is helpful to write down what each different bit flip error does to our logical states:

量子的な設定では、測定に問題があることをこれから見ていきましょう。まず、上記のエンコーディングを（量子的に）実装することは可能です。
量子誤り訂正をどのように一般化できるかを知るために参考にしてください。
$\ket{\overline{0}} = \ket{000} = \ket{0} \otimes \ket{0} \otimes \ket{0}$, and let $\ket{\overline{1}} = \ket{111}$とします。
そして、線形性によって、すべての入力に対して繰り返しコードを定義します。$\ket{\overline{+}} = (\ket{\overline{0}} + \ket{\overline{1}}) / \sqrt{2} = (\ket{000} + \ket{111}) / \sqrt{2}$.
特に、ビットフリップエラー$X_1$をまん中の（2番目の）量子ビットに作用させると、両方のエラーで必要とされる修正が正確に$X_1$であることがわかります。
$$
\begin{align}
    X_1 \ket{\overline{+}}  = \frac{1}{\sqrt{2}} \left(X_1\ket{000} + X_1\ket{111}\right)\\ = \frac{1}{\sqrt{2}} \left(\ket{010} + \ket{101}\right).
\end{align}
$$
保護しようとしている量子状態を測定せずにどのように判断できるかを確認するには、それぞれのビットフリップエラーが論理状態にどのような影響を及ぼすかを書き留めると便利です。

<table>
<thead>
<tr>
<th>Error $E$</th>
<th>$E\ket{\overline{0}}$</th>
<th>$E\ket{\overline{1}}$</th>
</tr>
</thead>
<tbody>
<tr>
<td>$\boldsymbol{1}$</td>
<td>$\ket{000}$</td>
<td>$\ket{111}$</td>
</tr>
<tr>
<td>$X_0$</td>
<td>$\ket{100}$</td>
<td>$\ket{011}$</td>
</tr>
<tr>
<td>$X_1$</td>
<td>$\ket{010}$</td>
<td>$\ket{101}$</td>
</tr>
<tr>
<td>$X_2$</td>
<td>$\ket{001}$</td>
<td>$\ket{110}$</td>
</tr>
</tbody>
</table>
In order to protect the state that we're encoding, we need to be able to distinguish the three errors from each other and from the identity $\boldsymbol{1}$ without distinguishing between $\ket{\overline{0}}$ and $\ket{\overline{1}}$.
For example, if we measure $Z_0$, we get a different result for $\ket{\overline{0}}$ and $\ket{\overline{1}}$ in the no-error case, so that collapses the encoded state.
On the other hand, consider measuring $Z_0 Z_1$, the parity of the first two bits in each computational basis state.
Recall that each measurement of a Pauli operator checks which eigenvalue the state being measured corresponds to, so for each state $\ket{\psi}$ in the table above, we can compute $Z_0 Z_1 \ket{\psi}$ to see if we get $\pm\ket{\psi}$.
Note that $Z_0 Z_1 \ket{000} = \ket{000}$ and that $Z_0 Z_1 \ket{111} = \ket{111}$, so that we conclude that this measurement does the same thing to both encoded states.
On the other hand, $Z_0 Z_1 \ket{100} = - \ket{100}$ and $Z_0 Z_1 \ket{011} = -\ket{011}$, so the result of measuring $Z_0 Z_1$ reveals useful information about which error occured.
To emphasize this, we repeat the table above, but add the results of measuring $Z_0 Z_1$ and $Z_1 Z_2$ on each row.
We denote the results of each measurement by the sign of the eigenvalue that is observed, either $+$ or $-$, corresponding to the Q# <code>Result</code> values of <code>Zero</code> and <code>One</code>, respectively.

私たちがエンコードしている状態を保護するためには、 $\ket{\overline{0}}$と$\ket{\overline{1}}$を"区別せず"に、3つのエラーを互いに識別し、識別$\boldsymbol{1}$と"区別する"必要があります。
たとえば、$ Z_0 $を測定すると、エラーなしの場合、$\ket{\overline{0}}$と$\ket{\overline{1}}$の結果が異なり、これによりエンコードされた量子状態は破壊されてしまいます。
一方、各計算基礎状態の最初の2ビットのパリティである$ Z_0 Z_1 $を測定することを検討してみましょう。
Pauli演算子の各測定は、測定される状態がどの固有値に対応するかを調べるので、もし$ \pm \ket {\psi} $を得るならば、上の表の各状態$ \ket{\ psi} $に対して、$ Z_0 Z_1 \ket {\psi} $を計算して見ることができます。
$ Z_0 Z_1 \ket{000} = \ket{000} $、$ Z_0 Z_1 \ket{111} = \ket{111} $となるので、この測定は両方のエンコードされた状態に対して同じことを行うと結論づけることができます。
一方、$ Z_0 Z_1 \ket{100} = -\ket{100} $、$ Z_0 Z_1 \ket{011} = -\ket{011} $となるので、$ Z_0 Z_1 $を測定した結果、どのエラーが発生したかに関する情報を得ることができます。これを強調するために、上の表を繰り返しますが、各行に$ Z_0 Z_1 $と$ Z_1 Z_2 $を測定した結果を追加します。
各測定の結果は、Q＃の<code>Zero</code>と<code>One</code>の<code>Result</code>の値に対応する$ + $または$ - $の固有値の符号として得られます。
<table><tr><th>Error $E$</th><th>$E\ket{\overline{0}}$</th><th>$E\ket{\overline{1}}$</th><th>Result of $Z_0 Z_1$</th><th>Result of $Z_1 Z_2$</th></tr><tr><td>$\boldsymbol{1}$</td>
<td>$\ket{000}$</td><td>$\ket{111}$</td><td>$+$</td><td>$+$</td></tr><tr><td>$X_0$</td><td>$\ket{100}$</td><td>$\ket{011}$</td><td>$-$</td><td>$+$</td></tr><tr><td>$X_1$</td>
<td>$\ket{010}$</td><td>$\ket{101}$</td><td>$-$</td><td>$-$</td></tr><tr><td>$X_2$</td>
<td>$\ket{001}$</td><td>$\ket{110}$</td><td>$+$</td><td>$-$</td></tr></table>

Thus, the results of the two measurements uniquely determines which bit-flip error occured, but without revealing any information about which state we encoded.
We call these results a <em>syndrome</em>, and refer to the process of mapping a syndrome back to the error that caused it as <em>recovery</em>.
In particular, we emphasize that recovery is a <em>classical</em> inference procedure which takes as its input the syndrome which occured, and returns a prescription for how to fix any errors that may have occured.

したがって、2つの測定の結果は、どのビットフリップエラーが発生したかを一意に決定することができるが、符号化された量子状態に関する情報を明らかにすることはありません。
これらの結果を"シンドローム"と呼び、シンドロームの原因となったエラーを再マッピングするプロセスを”リカバリー”と呼びます。
特に、リカバリーは、発生したシンドロームを入力として受け取り、発生した可能性のあるエラーを修正するための処方箋を返す”古典的”な推論手続きであることを強調します。

Note
=
The bit-flip code above can only correct against single bit-flip errors; that is, an <code>X</code> operation acting on a single qubit.
Applying <code>X</code> to more than one qubit will map $\ket{\overline{0}}$ to $\ket{\overline{1}}$ following recovery.
Similarly, applying a phase flip operation <code>Z</code> will map $\ket{\overline{1}}$ to $-\ket{\overline{1}}$, and hence will map $\ket{\overline{+}}$ to $\ket{\overline{-}}$.
More generally, codes can be created to handle larger number of errors, and to handle $Z$ errors as well as $X$ errors.

上記のビットフリップコードは、単一のビットフリップエラーに対してのみ修正できます。 つまり、単一の量子ビットに対して動作する<code>X</code>操作です。
複数のキュービットに<code>X</code>を適用すると、回復後に$\ket{\overline{0}}$から$\ket{\overline{1}}$にマッピングされてしまいます。
同様に、フェーズ（位相）フリップ操作<code>Z</code>を適用すると、$\ket{\overline{1}} $が$-\ket{\overline{1}}$にマップされ、 $\ket{\overline{+}}$ が $\ket{\overline{-}}$にマップされてしまいます。
より一般的には、より多くのエラーを処理し、$ Z $エラーと$ X $エラーを処理するコードを作成できます。

The insight that we can describe measurements in quantum error correction that act the same way on all code states, is the essense of the <em>stabilizer formalism</em>.
The Q# canon provides a framework for describing encoding into and decoding from stabilizer codes, and for describing how one recovers from errors.
In this section, we describe this framework and its application to a few simple quantum error-correcting codes.

すべてのコード状態で同じように動作する量子誤り訂正の測定値を記述できるという洞察は、"スタビライザ形式"の要点です。
Q＃は、スタビライザコードのエンコーディングとデコーディング、およびエラーからの回復方法を記述するためのフレームワークを提供します。
このセクションでは、このフレームワークと、いくつかの簡単な量子誤り訂正符号への応用について説明します。
Tip
=
A full introduction to the stabilizer formalism is beyond the scope of this section.
We refer readers interested in learning more to <a href="https://arxiv.org/abs/0904.2557" data-linktype="external">Gottesman 2009</a>.
スタビライザー形式の完全な紹介は、このセクションの範囲外です。
もっと学習に興味のある読者は<a href="https://arxiv.org/abs/0904.2557" data-linktype="external"> Gottesman 2009</a>をオススメします。

Representing Error Correcting Codes in Q#
=
To help specify error correcting codes, the Q# canon provides several distinct user-defined types:
エラー訂正コードを指定するのに役立つように、Q＃にはいくつかの異なるユーザー定義型が用意されています。
<ul>
<li><a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.logicalregister" data-linktype="absolute-path">LogicalRegister</a> <code>= Qubit[]</code>: Denotes that a register of qubits should be interpreted as the code block of an error-correcting code.
量子ビットのレジスタは誤り訂正符号のコードブロックとして解釈されます。</li>
<li><a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.syndrome" data-linktype="absolute-path">Syndrome</a> <code>= Result[]</code>: Denotes that an array of measurement results should be interpreted as the syndrome measured on a code block.
測定結果の配列は、コードブロックで測定されたシンドロームとして解釈されます。</li>
<li><a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.recoveryfn" data-linktype="absolute-path">RecoveryFn</a> <code>= (Syndrome -&gt; Pauli[])</code>: Denotes that a <em>classical</em> function should be used to interpret a syndrome and return a correction that should be applied.
シンドロームを解釈し、適用すべき訂正を返すために"古典的な"関数を使用します。</li>
<li><a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.encodeop" data-linktype="absolute-path">EncodeOp</a> <code>= ((Qubit[], Qubit[]) =&gt; LogicalRegister)</code>: Denotes that an operation takes qubits representing data along with fresh ancilla qubits in order to produce a code block of an error-correcting code.
エラー訂正コードのコードブロックを生成するために、演算が新鮮なアンシラ量子ビットと共にデータを表す量子ビットを要します。</li>
<li><a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.decodeop" data-linktype="absolute-path">DecodeOp</a> <code>= (LogicalRegister =&gt; (Qubit[], Qubit[]))</code>: Denotes than an operation decomposes a code block of an error correcting code into the data qubits and the ancilla qubits used to represent syndrome information.
オペレーションは、誤り訂正符号の符号ブロックを、シンドローム情報を表現するために使用されるデータ量子ビットとアンシラ量子ビットに分解します。</li>
<li><a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.syndromemeasop" data-linktype="absolute-path">SyndromeMeasOp</a> <code>= (LogicalRegister =&gt; Syndrome)</code>: Denotes an operation that should be used to extract syndrome information from a code block, without disturbing the state protected by the code.
コードによって保護されている状態を乱すことなく、コードブロックからシンドローム情報を抽出するために使用します。</li>
</ul>
Finally, the canon provides the <a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.qecc" data-linktype="absolute-path">QECC</a> type to collect the other types required to define a quantum error-correcting code. Associated with each stabilizer quantum code is the code length $n$, the number $k$ of logical qubits, and the minimum distance $d$, often conveniently grouped together in the notation ⟦$n$, $k$, $d$⟧. For example, the <a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.bitflipcode" data-linktype="absolute-path">BitFlipCode</a> function defines the ⟦3, 1, 1⟧ bit flip code:

最後に、Q#は <a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.qecc" data-linktype="absolute-path">QECC</a>タイプを提供して、量子誤り訂正符号を定義するのに必要な他のタイプを収集します。 各スタビライザ量子コードには、コード長$ n $、論理量子ビット数$ k $、最小距離$ d $があり、これらは便宜上、⟦$ n $,$ k $,$ d $⟧とします。 たとえば、BitFlipCode関数を⟦3,1,1⟧<a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.bitflipcode" data-linktype="absolute-path">BitFlipCode</a>のように定義します。

<pre><code class="lang-qsharp">let encodeOp = EncodeOp(BitFlipEncoder);
let decodeOp = DecodeOp(BitFlipDecoder);
let syndMeasOp = SyndromeMeasOp(MeasureStabilizerGenerators([
    [PauliZ; PauliZ; PauliI];
    [PauliI; PauliZ; PauliZ]
], _, MeasureWithScratch));
let code = QECC(encodeOp, decodeOp, syndMeasOp);
</code></pre>

Notice that the <code>QECC</code> type does <em>not</em> include a recovery function.
This allows us to change the recovery function that is used in correcting errors without changing the definition of the code itself; this ability is in particular useful when incorporating feedback from characterization measurements into the model assumed by recovery.

<code>QECC</code>タイプでは、リカバリー機能は含まれて"いません"。
これにより、コード自体の定義を変更することなくエラーを修正するために使用されるリカバリー機能を変更することができます。 この機能は、リカバリーによって想定されるモデルの特性評価測定値からのフィードバックを組み込む場合に特に役立ちます。

Once a code is defined in this way, we can use the <a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.recover" data-linktype="absolute-path">Recover</a> operation to recover from errors:
このようにしてコードを定義すると、エラーを回復する<a class="xref" href="https://docs.microsoft.com/en-us/qsharp/api/canon/microsoft.quantum.canon.recover" data-linktype="absolute-path">Recover</a>操作を使うことが出来るようになります：

<pre><code class="lang-qsharp">let code = BitFlipCode();
let fn = BitFlipRecoveryFn();
let X0 = ApplyPauli([PauliX; PauliI; PauliI], _);
using (scratch = Qubit[nScratch]) {
    let logicalRegister = encode(data, scratch);
    // Cause an error.
    X0(logicalRegister);
    Recover(code, fn, logicalRegister);
    let (decodedData, decodedScratch) = decode(logicalRegister);
    ApplyToEach(Reset, decodedScratch);
}
</code></pre>

We explore this in more detail in the bit flip code sample</a>.
これについては、bit flip code sample</a>で詳しく説明しています（する予定？）。

Aside from the bit-flip code, the Q# canon is provided with implementations of the <a href="https://arxiv.org/abs/1305.08" data-linktype="external">five-qubit perfect code</a>, and the <a href="https://arxiv.org/abs/quant-ph/9705052" data-linktype="external">seven-qubit code</a>, both of which can correct an arbitrary single-qubit error.

ビットフリップコードとは別に、Q＃には、<a href="https://arxiv.org/abs/1305.08" data-linktype="external">5キュビットの完璧なコード</a>および<a href="https://arxiv.org/abs/quant-ph/9705052" data-linktype="external">7キュビットコード</a>がの実装が提供されています。どちらも単一量子ビットの任意のエラーを修正することができます。

以上。