Una matriz controlada sin puerta se ve así:

$$\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ \end{bmatrix}$$

Eso funciona muy bien cuando solo tienes dos qubits y quieres usar el primer qubit como control y el segundo qubit como entrada para voltear (o no).

¿Existe un método para convertir esta matriz para usar, por ejemplo, si tuviera 3 qubits y quisiera usar qubit 1 como control y qubit 3 como entrada que posiblemente se voltea?

Pensando en ello lógicamente, puedo llegar a esto:

$$\begin{bmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ \end{bmatrix}$$

¿Existe una forma mejor, más formal / generalizada de convertir puertas de múltiples qubits para usar qubits específicos, en lugar del primer en un circuito de qubits?$N$$N$

Expand-n-Swap

Si desea aplicar una puerta a un subconjunto de qubits:

• Expanda las operaciones hasta x con el producto tensor / producto Kronecker .$2^n$$2^n$
• Use puertas de intercambio para hacer que los qubits de destino sean consecutivos.
• Cambiar a un orden simple, aplicar, volver a cambiar.

Puede ser tedioso hacer todas esas multiplicaciones de matrices grandes, pero las matrices de intercambio son escasas y la idea es muy sencilla.

Los controles son más fáciles

En el caso de agregar controles a una operación (que se aplica al ejemplo específico que dio), hay un truco más fácil. Simplemente expanda la operación como de costumbre, pero luego reemplace cualquier parte de la matriz que corresponda a las entradas con control fallido con lo que sería la matriz de identidad.

Esto es un poco más fácil de seguir si introduce un "valor de control" falso que anula el comportamiento habitual del producto tensor$c$ , de modo que en lugar de , tiene (en otras palabras: cuando una entrada es , no coloca sobre la entrada y escala por la entrada; usted usa lugar de ).$\begin{bmatrix} c \end{bmatrix} \otimes U = c \cdot U$$\begin{bmatrix} c \end{bmatrix} \otimes U = c \cdot I$$c$$U$$U$$I$$U$

Defina la "operación" de un control qubit-must-be-ON para que sea . Un no-op es , y A no es . Entonces la operación de su pregunta podría calcularse de esta manera (suponiendo un orden big-endian):$C = \begin{bmatrix} c&0 \\ 0&1 \end{bmatrix}$$I$$X$

$CNOT_{3 \rightarrow 1} = C \otimes I \otimes X$

$= \begin{bmatrix} c&0 \\ 0&1 \end{bmatrix} \otimes \begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} c\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix}&0\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \\ 0\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix}&1\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} \begin{bmatrix} c&0 \\ 0&c \end{bmatrix} & \begin{bmatrix} 0&0 \\ 0&0 \end{bmatrix} \\ \begin{bmatrix} 0&0 \\ 0&0 \end{bmatrix}&\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} c&0&0&0 \\ 0&c&0&0 \\ 0&0&1&0 \\ 0&0&0&1 \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

(nota: va a usar un solo cero para significar ambiguamente una matriz cero 2x2 cuando sea conveniente)

$= \begin{bmatrix} c\otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} &0&0&0 \\ 0&c \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0&0 \\ 0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0 \\ 0&0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} \end{bmatrix}$

$= \begin{bmatrix} \begin{bmatrix} c&0 \\ 0&c \end{bmatrix} &0&0&0 \\ 0&\begin{bmatrix} c&0 \\ 0&c \end{bmatrix}&0&0 \\ 0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0 \\ 0&0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} \end{bmatrix}$

$= \begin{bmatrix} c&0&0&0&0&0&0&0 \\ 0&c&0&0&0&0&0&0 \\ 0&0&c&0&0&0&0&0 \\ 0&0&0&c&0&0&0&0 \\ 0&0&0&0&0&1&0&0 \\ 0&0&0&0&1&0&0&0 \\ 0&0&0&0&0&0&0&1 \\ 0&0&0&0&0&0&1&0 \end{bmatrix}$

(ahora hemos terminado con los productos tensoriales y ya no necesitamos los )$c$

$\rightarrow \begin{bmatrix} 1&0&0&0&0&0&0&0 \\ 0&1&0&0&0&0&0&0 \\ 0&0&1&0&0&0&0&0 \\ 0&0&0&1&0&0&0&0 \\ 0&0&0&0&0&1&0&0 \\ 0&0&0&0&1&0&0&0 \\ 0&0&0&0&0&0&0&1 \\ 0&0&0&0&0&0&1&0 \end{bmatrix}$

¿Tener sentido?

No use el método de intercambio, es muy ineficiente. Y la respuesta de la otra persona es específica para la puerta CNOT, y para ser sincero, complica las cosas en exceso.

Aquí hay un algoritmo muy simple que resuelve su problema para cada caso, no solo la puerta CNOT, para cualquier bit arbitrario.

El algoritmo:

let sys = matrix representing the current state of the system
let n = number of qubits being simulated
let lgm = logic gate matrix of size 2^n by 2^n
let f = our logic gate transformation function
for i = 0 to (2^n) - 1:
    lgm[column = i] = f(i)
sys = sys × lgg

En las computadoras clásicas, hay algo conocido como el "decodificador". Digamos que solo tengo 3 cables, efectivamente, 3 bits. Pero quiero controlar 8 cables. ¿Se puede hacer eso? Sí, porque 3 bits tienen 8 posibilidades diferentes: 000, 001, 010, 011, 100, 101, 110, 111. Por lo tanto, podemos asignar cada posibilidad a uno de nuestros 8 cables de salida. Esto se llama "decodificación".

Si paso el número 101 y tenemos 3 bits, sabemos 101 = 5, por lo que estaré configurando el cable de salida 5 a un alto voltaje y los otros 7 cables de salida serán 0, lo que podemos representar así: decodificar (101) = [0, 0, 0, 0, 0, 1, 0, 0].

En este algoritmo, menciono la "función de transformación" llamada "f". Para las computadoras clásicas, la función de transformación solo toma un valor de entrada y devuelve la versión "decodificada" del valor de salida. Entonces, si tenemos 3 bits y la salida es 4, entonces devolveremos [0, 0, 0, 0, 1, 0, 0, 0]. Luego asignamos eso como la columna de nuestra matriz para ese valor.

Pensemos en la "decodificación" en términos de qubits. ¿Cómo podemos decodificar los qubits | 101>?

Sabemos que para nuestros vectores de probabilidad qubit, | 0> es [1, 0] y | 1> es [0, 1]. Entonces se pueden decodificar qubits lo que se llama el producto Kronecker.

Entonces, si convertimos cada bit al equivalente de vector de probabilidad y tomamos el producto Kronecker de todos ellos, obtenemos ...

|101> = |1> ⊗ |0> ⊗ |1> = [0, 1] ⊗ [1, 0] ⊗ [0, 1] = [0, 0, 0, 0, 0, 1, 0, 0]

Así es como nos gustaría decodificar qubits. Este algoritmo se puede aplicar a qubits de la misma manera usando esto.

Probemos este algoritmo en un problema más simple.

Supongamos que tenemos un sistema con solo 2 qubits. Si queremos aplicar la puerta Hadamard a solo 1 qubit, podemos generar una puerta lógica para ambos qubits que solo aplique la puerta Hadamard a un solo qubit. Supongamos que el qubit único al que queremos aplicarlo es nuestro qubit más significativo y el menos significativo no se verá afectado.

Queremos una función de transformación que para cada una de nuestras posibles entradas, produzca la salida correcta. Tenemos dos qubits, esto significa que hay cuatro salidas posibles.

f(|00>) = ?
f(|01>) = ?
f(|10>) = ?
f(|11>) = ?

Sabemos que el qubit menos significativo no se verá afectado, por lo que podemos completarlo.

f(|00>) = ? ⊗ |0>
f(|01>) = ? ⊗ |1>
f(|10>) = ? ⊗ |0>
f(|11>) = ? ⊗ |1>

También sabemos lo que el Hadamard le hace a un qubit, de modo que:

H(|0>) = 1/sqrt(2)|0> + 1/sqrt(2)|1>
H(|1>) = 1/sqrt(2)|0> - 1/sqrt(2)|1>

Entonces nuestra función de transformación es simplemente:

f(|00>) = (1/sqrt(2)|0> + 1/sqrt(2)|1>) ⊗ |0>
f(|01>) = (1/sqrt(2)|0> + 1/sqrt(2)|1>) ⊗ |1>
f(|10>) = (1/sqrt(2)|0> - 1/sqrt(2)|1>) ⊗ |0>
f(|11>) = (1/sqrt(2)|0> - 1/sqrt(2)|1>) ⊗ |1>

Expanda esto a nuestra forma de vector de probabilidad normalizada ...

f(|00>) = [ 1/sqrt(2), 1/sqrt(2) ] ⊗ [ 1, 0 ]
f(|01>) = [ 1/sqrt(2), 1/sqrt(2) ] ⊗ [ 0, 1 ]
f(|10>) = [ 1/sqrt(2), -1/sqrt(2) ] ⊗ [ 1, 0 ]
f(|11>) = [ 1/sqrt(2), -1/sqrt(2) ] ⊗ [ 0, 1 ]

Ahora vamos a resolver esto ...

f(|00>) = [ 1/sqrt(2), 0, 1/sqrt(2), 0 ]
f(|01>) = [ 0, 1/sqrt(2), 0, 1/sqrt(2) ]
f(|10>) = [ 1/sqrt(2), 0, -1/sqrt(2), 0 ]
f(|11>) = [ 0, 1/sqrt(2), 0, -1/sqrt(2) ]

Esa es nuestra función de transformación.

Nuestra matriz de puerta lógica, "lgm", tiene un tamaño de 2 ^ n por 2 ^ n donde n = número de qubits que se simulan, por lo que en este caso es 2 ^ 2 por 2 ^ 2 o 4x4. Nuestro algoritmo nos dice que para cada columna i, establezca la columna igual a f (i). Hemos definido nuestra función de transformación de probabilidad, por lo que podemos completar fácilmente estas columnas.

lgm = 
    |00>       |01>        |10>        |11>
[ 1/sqrt(2),         0,  1/sqrt(2),          0 ] 
[         0, 1/sqrt(2),          0,  1/sqrt(2) ]
[ 1/sqrt(2),         0, -1/sqrt(2),          0 ]
[         0, 1/sqrt(2),          0, -1/sqrt(2) ]

Ahora, el paso final en nuestro algoritmo es simplemente multiplicar por matriz nuestra matriz que representa todo el sistema cuántico, sys, por esta puerta lógica, lgm.

Y eso hace lo que queremos. Aplicará la puerta hadamard solo al qubit más grande y dejará solo el qubit menos significativo. Si no me crees, puedes probarlo tú mismo y ver que funciona.

La razón por la que esto es tan poderoso es porque se aplica a cualquier caso.

Probemos este algoritmo en su problema.

Imaginemos que tenemos un sistema de 3 qubits y queremos aplicar una puerta CNOT a qubits [0] y qubits [2]. Si busca la matriz CNOT en Wikipedia, esa matriz solo se aplica a un sistema de 2 qubits. Una solución ingenua sería agregarle matrices de identidad utilizando el producto Kronecker para que funcione en sistemas con tres qubits. Pero esto falla aquí: qubit [0] y qubit [2] no son adyacentes, por lo que simplemente agregar matrices de identidad no funcionará.

Nosotros podríamos intercambiar qubit [0] con qubit [1], aplique la puerta CNOT, luego intercambiar espalda. Pero eso es lento. En cambio, podríamos simplemente generar una puerta CNOT no adyacente para nuestro problema utilizando el algoritmo anterior.

Primero necesitamos crear una función de transformación para cada caso.

f(|000>) = |0> ⊗ |0> ⊗ |0>
f(|001>) = |0> ⊗ |0> ⊗ |1>
f(|010>) = |0> ⊗ |1> ⊗ |0>
f(|011>) = |0> ⊗ |1> ⊗ |1>
f(|100>) = |1> ⊗ |0> ⊗ |1>
f(|101>) = |1> ⊗ |0> ⊗ |0>
f(|110>) = |1> ⊗ |1> ⊗ |1>
f(|111>) = |1> ⊗ |1> ⊗ |0>

Si comprende la puerta CNOT, puede entender por qué esta es nuestra función. Piense en esto como una tabla de verdad. Dado que nuestro qubit de control es el qubit más significativo, qubit [2], solo cuando ese qubit es | 1> se negará el qubit menos significativo, qubit [0].

Expanda esto a nuestra forma de vector de probabilidad normalizada ...

f(|000>) = [ 1, 0 ] ⊗ [ 1, 0 ] ⊗ [ 1, 0 ]
f(|001>) = [ 1, 0 ] ⊗ [ 1, 0 ] ⊗ [ 0, 1 ]
f(|010>) = [ 1, 0 ] ⊗ [ 0, 1 ] ⊗ [ 1, 0 ]
f(|011>) = [ 1, 0 ] ⊗ [ 0, 1 ] ⊗ [ 0, 1 ]
f(|100>) = [ 0, 1 ] ⊗ [ 1, 0 ] ⊗ [ 0, 1 ]
f(|101>) = [ 0, 1 ] ⊗ [ 1, 0 ] ⊗ [ 1, 0 ]
f(|110>) = [ 0, 1 ] ⊗ [ 0, 1 ] ⊗ [ 0, 1 ]
f(|111>) = [ 0, 1 ] ⊗ [ 0, 1 ] ⊗ [ 1, 0 ]

Ahora vamos a resolver esto ...

f(|000>) = [ 1, 0, 0, 0, 0, 0, 0, 0 ]
f(|001>) = [ 0, 1, 0, 0, 0, 0, 0, 0 ]
f(|010>) = [ 0, 0, 1, 0, 0, 0, 0, 0 ]
f(|011>) = [ 0, 0, 0, 1, 0, 0, 0, 0 ]
f(|100>) = [ 0, 0, 0, 0, 0, 1, 0, 0 ]
f(|101>) = [ 0, 0, 0, 0, 1, 0, 0, 0 ]
f(|110>) = [ 0, 0, 0, 0, 0, 0, 0, 1 ]
f(|111>) = [ 0, 0, 0, 0, 0, 0, 1, 0 ]

Hagamos de estas las columnas de nuestra matriz lgm.

lgm =
[ 1, 0, 0, 0, 0, 0, 0, 0 ]
[ 0, 1, 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 1, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 1, 0, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 1, 0, 0 ]
[ 0, 0, 0, 0, 1, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 0, 0, 1 ]
[ 0, 0, 0, 0, 0, 0, 1, 0 ]

Ahora, si la matriz multiplica nuestra matriz de todo el sistema, sys, por nuestra matriz de compuerta lógica, lgm, nuestro resultado será el efecto de aplicar la compuerta CNOT a qubit [2] y qubit [0] donde qubit [2] es el control qubit