一般の建設

最もよく知られているもつれ状態の2つはGHZ状態です$|\psi\rangle = 1/\sqrt{2}\left( |0\rangle^{\otimes n} + |1\rangle^{\otimes n}\right)$と$W_n$と-state、$W_3 = 1/\sqrt{3}\left(|100\rangle + |010\rangle + |001\rangle\right)$。

GHZ状態の構築は、任意の$n$簡単です。ただし、$W_n$実装はより困難です。以下のため$n=2$、それは簡単で、かつのため$n=4$、我々が使用することができます

H q[0,3]
X q[0,3]
Toffoli q[0],q[3],q[1]
X q[0,3]
Toffoli q[0],q[3],q[2]
CNOT q[2],q[0]
CNOT q[2],q[3]

$n=3$でも実装があります。たとえば、この回答を参照してください。しかし、$n$与えられた場合、$W_n$を構築するための回路を出力するアルゴリズムは見つかりませんでした。

シングルおよび2キュービットゲートで定義されたこのようなアルゴリズムは存在しますか？もしそうなら、それは何ですか？

はい、スーパーポジション量子カタにこのアルゴリズムの実装がいくつかあります（タスク14および15）：

• 以下のため$n = 2^k$、あなたは再帰的なアルゴリズムを使用することができます。最初にW状態を作り出す$2^{k-1}$量子ビットを、割り当てancilla量子ビットで$|+\rangle$状態、制御されたSWAPを実行して2番目の$2^{k-1}$量子ビットの状態を設定し、制御されたNOTを実行して、アンシラを$|0\rangle$にリセットします。0 ⟩（WState_PowerOfTwo_Reference操作）。
• 任意の$n$、DaftWullie（WState_Arbitrary_Referenceoperation）で説明されている再帰アルゴリズムを使用できます。
• 最初の再帰アルゴリズムを使用して任意のnの$W_n$状態を作成するために使用できる巧妙なトリックもあります。与えられたnを2 kにパディングするために追加のキュービットを割り当て、それらに状態W 2 kを作成し、追加のキュービットを測定します。すべてのキュービットが0である場合、元のキュービットの状態はW nです。それ以外の場合、リセットしてプロセス（操作）を繰り返します。$n$$n$$2^k$$W_{2^k}$$W_n$WState_Arbitrary_Postselect

これは非常に多くの異なるアプローチを可能にするため、そのカタの私のお気に入りのタスクです。

The conceptually simplest way to produce a W state is somewhat analogous to classical reservoir sampling, in that it involves a series of local operations that ultimately create a uniform effect.

Basically, you look at each qubit in turn and consider "how much amplitude do I have left in the all-0s state, and how much do I want to transfer into the just-this-qubit-is-ON state?". It turns out that the family of rotations you need is what I'll call the "odds gates" which have the following matrix:

$$M(p:q) = \sqrt{\frac{1}{p+q}} \begin{bmatrix} \sqrt{p} & \sqrt{q} \\ -\sqrt{q} & \sqrt{p} \end{bmatrix}$$

Using these gates, you can get a W state with a sequence of increasingly-controlled operations:

This circuit is somewhat inefficient. It has cost $O(N^2 + N \lg(1/\epsilon))$ where $N$ is the number of qubits and $\epsilon$ is the desired absolute precision (since, in an error corrected context, the odds gates are not native and must be approximated).

We can improve the efficiency by switching from a "transfer out of what was left behind" strategy to a "transfer out of what is traveling along" strategy. This adds a fixup sweep at the end, but only requires single controls on each operation. This reduces the cost to $O(N \lg(1/\epsilon))$:

It is still possible to do better, but it starts to get complicated. Basically, you can use a single partial Grover step to get $N$ amplitudes equal to $\sqrt{1/N}$ but they will be encoded into a binary register (we want a one-hot register with a single bit set). Fixing this requires a binary-to-unary conversion circuit. The tools needed to do this are covered in "Encoding Electronic Spectra in Quantum Circuits with Linear T Complexity"). Here are the relevant figures.

The partial grover step:

How to perform an indexed operation (well... sort of. the closest figure had an accumulator which is not quite right for this case):

Using this more complicated approach reduces the cost from $O(N \lg(1/\epsilon))$ to $O(N + \lg(1/\epsilon))$.

You can define the sequence recursively. Conceptually, what you want to do is:

• Create the initial state $|0\rangle^{\otimes N}$

• On qubit 1, apply the gate

  $$\frac{1}{\sqrt{N}}\left(\begin{array}{cc} 1 & \sqrt{N-1} \\ \sqrt{N-1} & -1 \end{array}\right)$$

• Controlled off qubit 1, apply "make $|W_{N-1}\rangle$" on qubits 2 to $N$ (i.e. on do this if qubit 1 is in the $|1\rangle$ state, otherwise do nothing)

• Apply a bit-flip gate on qubit 1.

This algorithm, as expressed, is not made up of only one- and two-qubit gates, but it can certainly be broken down as such by standard universality constructions.

Also, this may not be the most efficient algorithm you could come up with. For example, if $N=2^n$, you could use just $n$ layers of square-root of swap gates to produce what you want -- start with a $|1\rangle$ on a single qubit. Root-swap with a second qubit, and you've got the $|W_2\rangle$ (up to phases that you'll need to take care of). Put an ancilla next to both of these, and do root swaps between W-ancilla pairs, and you've got $|W_4\rangle$, repeat and you've got $|W_8\rangle$, and so on. I believe this is basically what they do experimentally here. You should be able to incorporate this algorithm into the first one to make it more efficient ($O(\log N)$) for any arbitrary size, but I've never stopped to work out the details with any great care.