Mes: marzo 2021

Categorías
Quantum

CNOT

Como no he encontrado una imagen interesante para ilustrar una compuerta CNOT, he puesto el yelmo de Knut, que suena parecido. Sí, a veces las neuronas me patinan.

Compuertas condicionales

El siguiente circuito, extremadamente simple, muestra una compuerta CNOT aplicada al primer y segundo qubit del circuito:

CNOT significa «conditional NOT», una negación condicional, y el parentesco con la negación a secas se evidencia en la simbología asociada: la parte inferior del símbolo es la cruz dentro del círculo que se suele usar para la negación. Se trata de una compuerta que trabaja siempre con dos qubits. Todas las transformaciones que hemos visto hasta ahora sobre dos qubits se creaban componiendo transformaciones sobre un qubit. Con esta compuerta, ya saltamos a transformaciones más complejas.

El papel de una compuerta CNOT consiste en invertir el estado de un qubit de acuerdo con el estado de otro qubit de control. Si el qubit de control vale $0$, el otro bit no se modifica. Si el bit de control es $1$, el otro bit se invierte. En el circuito que acabamos de mostrar, el qubit de control es el menos significativo, y esta es la acción de la compuerta sobre la base del estado:
$$\eqalign{
\operatorname{CNOT}\vert00\rangle&\rightarrow\vert00\rangle\cr
\operatorname{CNOT}\vert01\rangle&\rightarrow\vert11\rangle\cr
\operatorname{CNOT}\vert10\rangle&\rightarrow\vert10\rangle\cr
\operatorname{CNOT}\vert11\rangle&\rightarrow\vert01\rangle
}$$¿Recuerda nuestro truco ninja en la entrada anterior, para calcular rápidamente la acción de una matriz sobre vectores de la base? Cuando una matriz actúa sobre un vector de la base, el resultado se obtiene seleccionando una columna. Eso significa que la primera columna de la matriz tiene que ser el resultado de aplicarla al primer vector de la base, y la última, es el resultado sobre el último vector de la base. Pero yo acabo de enumerar lo que ocurre cuando se aplica CNOT a cada uno de los vectores de la base. Podemos entonces dar ya la representación de CNOT como matriz:

$$\operatorname{CNOT_{LS}} = \pmatrix{1&0&0&0\cr 0&0&0&1\cr 0&0&1&0\cr 0&1&0&0
}$$Para evitar confusiones, he usado el sufijo $ls$ para indicar que esta es la matriz cuando el qubit de control es el menos significativo. Si hacemos que el control lo ejerza el bit más significativo, el de la izquierda, la matriz correspondiente sería:
$$\operatorname{CNOT_{MS}} = \pmatrix{1&0&0&0\cr 0&1&0&0\cr 0&0&0&1\cr 0&0&1&0
}$$¡Compruébelo!

En general, si tenemos una compuerta de un qubit y queremos aplicarla condicionalmente sobre el qubit menos significativo, usando el más significativo como control, la matriz que necesitamos sigue este patrón:

$$\operatorname{CondA} = \pmatrix{I & 0 \cr 0 & A
}$$No hay nada mágico en la fórmula anterior. Si se aplica $\operatorname{CondA}$ a los vectores $\vert00\rangle$ o $\vert01\rangle$, obtenemos el vector original, sin cambios, porque el qubit más significativo de estos dos vectores es $0$. Las dos columnas en las que la matriz original $A$ pinta algo son la tercera y la cuarta, que son los estados de la base con el qubit más significativo a $1$.

The twilight zone

Confieso que me preocupa un poco que en la mayoría de los ejemplos estemos usando matrices con ceros y unos en sus celdas. Puede dar la impresión de que estamos usando valores lógicos, y no es así ni remotamente. Donde estamos viendo un cero, podríamos tener un número complejo arbitrario.

Para compensar esta tendencia, vamos a movernos ahora a la zona «crepuscular». Todos comprendemos sin problemas lo que ocurre cuando el qubit de control es cero o uno: nuestra mente está habituada a trabajar en blanco y negro, ¿no? Pero, ¿qué ocurre si el qubit de control es un gato de Schrödinger? Vamos a diseñar un circuito en el que aplicaremos una transformación de Hadamard precisamente a ese qubit:

En notación algebraica, este circuito se puede escribir así:

$$\operatorname{CNOT_{LS}} \times (I \otimes H)$$¡Mucha atención al orden, que es muy importante! En primer lugar, he puesto la matriz de la condicional a la izquierda de la expresión, aunque es la segunda que se aplica en el circuito. ¿Por qué? Pues porque cuando yo escribo $ABx$ estoy pidiendo que primero se aplique la matriz $B$ al vector $x$, y luego al resultado se le aplique la matriz $A$. Es decir, en $ABx$, la matriz de más a la izquierda es la segunda que se aplica, no la primera.

Por otra parte, escribo $I \otimes H$ porque la matriz de la izquierda es la que corresponde al qubit más significativo, como vimos en la entrada anterior. Hadamard se le aplica sólo al qubit menos significativo, y para completar el circuito, aplicamos la matriz identidad al qubit más significativo.

Ahora calculemos la matriz por partes. Primero, la combinación tensorial de la identidad con Hadamard:

$$I\otimes H = \pmatrix{H&0\cr 0&H} = \frac{1}{\sqrt2}\pmatrix{1&1&0&0\cr1&-1&0&0\cr0&0&1&1\cr0&0&1&-1
}$$La matriz $\operatorname{CNOT}$ que utiliza el qubit menos significativo como control ya la hemos presentado antes. Sólo nos queda multiplicar dos matrices:

$$\frac{1}{\sqrt2}\pmatrix{1&0&0&0\cr 0&0&0&1\cr 0&0&1&0\cr 0&1&0&0} \times \pmatrix{1&1&0&0\cr1&-1&0&0\cr0&0&1&1\cr0&0&1&-1}
$$¿Sabe lo que haría un ninja del álgebra ahora? Sólo calcularía la primera columna del resultado, porque es la que nos importa dado el estado cuántico inicial. Pero como soy buena persona, aquí le dejo la matriz completa del circuito (pero no se fíe de mí, y haga el cálculo por su cuenta):

$$\frac{1}{\sqrt2}\pmatrix{1&1&0&0\cr 0&0&1&-1\cr 0&0&1&1\cr 1&-1&0&0}
$$Como ya hemos dicho, esta matriz tiene que transformar un estado cuántico inicial que es el $\vert00\rangle$, o $\pmatrix{1&0&0&0}^T$ en notación matricial (la $T$ significa que hay que transponer para obtener un vector de columna). El resultado es la primera columna de la matriz de transformación:

$$\frac{1}{\sqrt2}\pmatrix{1\cr0\cr0\cr1}
$$Y este, amigos míos, a pesar de su apariencia inocente, es un estado entrelazado. En concreto, es uno de los estados de Bell, el estado $\vert\Phi^{+}\rangle$. Como dicen en inglés, we’ve got a crazy cookie.

Einstein-Podolski-Rosen

¿Qué ocurre cuando se realiza una medición sobre este estado? Si aplicamos la regla de Born, vemos que podemos obtener solamente uno de dos resultados, $00$ o $11$, de los cuatro resultados posibles. Si obtenemos un $1$ en el bit menos significativo, no tenemos que mirar el más significativo para saber que obligatoriamente es otro $1$.

Si en el diseñador de circuitos de Qiskit creamos este circuito y miramos el panel «Measurement probabilities» veremos este gráfico:

Efectivamente, nos advierte que hay dos posibles lecturas, las antes mencionadas, y que cada una se obtiene en un 50% de los casos.

Categorías
Quantum

Cuatro gatos

Vamos a probar fortuna ahora con un circuito mucho más interesante, que a la larga utilizaremos con cierta frecuencia. Este es el circuito:

Las compuertas $H$, naturalmente, corresponden a transformadas de Hadamard aplicadas a qubits individuales.

SuperHadamard

A modo de recordatorio, esta es la definición de la matriz de Hadamard:

$$H = \frac{1}{\sqrt2} \pmatrix{
1&1\cr 1&-1
}$$El coeficiente $\frac{1}{\sqrt2}$ se incluye para que el determinante de la matriz sea la unidad.

Cuando la transformada de Hadamard se aplica a un qubit que está en el estado inicial $\vert0\rangle$, lo lleva al estado $\vert+\rangle$ de la base de Hadamard, que se expresa en la base computacional como $\frac{1}{\sqrt2}(\vert0\rangle + \vert1\rangle)$. Este es un estado superpuesto, un gato de Schrödinger, que cuando se mide, va a alternar entre ceros y unos con la misma probabilidad. Si nos ponemos solemnes, podríamos decir que acabamos de implementar un generador aleatorio de valores binarios.

¿Qué pasa si tengo dos qubits y le aplico Hadamard a cada uno de ellos? Ya sabemos que para tener una respuesta exacta tenemos que multiplicar tensorialmente dos matrices de Hadamard. Este es el cálculo:

$$\eqalign{
H \otimes H &= \frac{1}{2} \pmatrix{1&1\cr 1&-1} \otimes \pmatrix{1&1\cr 1&-1}\cr
&= \frac{1}{2}\pmatrix{1&1&1&1\cr 1&-1&1&-1\cr 1&1&-1&-1\cr 1&-1&-1&1 }
}$$Ahora queremos saber qué pasa si aplicamos esta matriz al estado inicial del circuito, $\vert00\rangle$:

$$(H\otimes H)\vert00\rangle = \frac{1}{2}\pmatrix{1&1&1&1\cr 1&-1&1&-1\cr 1&1&-1&-1\cr 1&-1&-1&1 } \pmatrix{1\cr0\cr0\cr0} = \frac{1}{2} \pmatrix{1\cr1\cr1\cr1}
$$Vamos a entender mejor el resultado si lo representamos en notación de Dirac:
$$\frac{1}{2}\vert0\rangle + \frac{1}{2}\vert1\rangle + \frac{1}{2}\vert2\rangle + \frac{1}{2}\vert3\rangle
$$Esta es una superposición uniforme de los cuatro vectores de la base de dos qubits. Es decir: un gato de Schrödinger simultáneamente en cuatro estados. También podemos interpretarlo como una superposición uniforme de todos los números enteros del cero al tres.

Si aplicamos una medición a este estado, el resultado puede ser cualquiera de los números del cero al tres, con la misma probabilidad para cada uno de ellos (un cuarto). De vuelta a la solemnidad: hemos programado un generador aleatorio que escupe números del $0$ al $3$.

Los goces de la linealidad

Imaginemos que hemos diseñado un circuito multiqubits, que recibe un número entero de entrada y que hace algún cálculo mágico y genera un valor entero muy interesante por el otro extremo. No voy a complicar la fiesta ahora recordando que ese circuito debe implementar una transformación unitaria. Si lo tuviésemos en cuenta, tendríamos que introducir qubits adicionales para mantener la reversibilidad del circuito. Pero vamos a olvidarnos ahora de ese problema, y aceptemos que tenemos un algoritmo mágico que transforma un número en otro número más interesante.

Supongamos ahora que, en vez de pasarle un número al algoritmo, le pasamos de golpe una superposición uniforme de todos los números representables en el número de qubits de los que disponemos. ¿Qué calculará el algoritmo? Como el «algoritmo» es una matriz, es decir, una transformación lineal, lo que obtendremos es una superposición uniforme de todos los resultados. Es como si hubiésemos aplicado el algoritmo en paralelo a todos los números enteros que podemos representar en nuestro ordenador:

$$A\times \sum_i { \alpha_i \hat{e}_i } = \sum_i { \alpha_i (A\times \hat{e}_i) }
$$Esta propiedad se conoce como paralelismo cuántico, y no es tan útil como parece a primera vista. No lo es porque, cuando midamos, colapsaremos el estado en un único vector propio, y perderemos toda esa información. De todos modos, pronto veremos cómo sacar partido de esta situación.

Algebra lineal, nivel Dios

Termino esta entrada con una nota técnica sobre álgebra lineal, que nos va a ser muy útil para obtener el grado de ninja. A todos nos han contado, en un momento u otro de nuestras vidas, que el mundo está lleno de vectores que pastan por los prados y de matrices cuya obsesión en la vida es transformar cada vector que se le ponga a tiro:

$$Ax$$Vamos a plantearnos esta relación desde otro punto de vista. ¿Y si realmente es el vector quien está actuando sobre la matriz para generar otro vector? Podemos hacerlo, siempre que consideremos que una matriz es una colección de columnas, en vez de una colección de filas, que es la forma más habitual de verlas. Observe cómo un vector parasita a una matriz y genera un vector combinando linealmente las columnas de la misma:

$$\pmatrix{a_1&b_1&c_1\cr a_2&b_2&c_2\cr a_3&b_3&c_3} \pmatrix{x_1\cr x_2\cr x_3} = x_1\pmatrix{a_1\cr a_2\cr a_3} + x_2\pmatrix{b_1\cr b_2\cr b_3} + x_3\pmatrix{c_1\cr c_2\cr c_3}
$$Esta intuición nos sirve, si estamos implementando una librería de matrices con aceleración por hardware, para representar las matrices como vectores de columnas. Lo he probado en C++, usando funciones intrínsecas y, efectivamente, es más eficiente implementar la multiplicación de matrices por vectores usando SIMD como una combinación lineal de las columnas de la matriz. De hecho, el convenio de FORTRAN siempre ha sido almacenar las matrices por columnas, no por filas.

Pero no es esto lo que quiero mostrarle exactamente. Imaginemos que el vector $x$ pertenece a la base. En ese caso, uno de sus componentes será un $1$, y el resto, $0$. Veamos cómo transformaría nuestra matriz de Hadamard de $4\times4$ el estado $\vert10\rangle$:

$$(H\otimes H)\vert10\rangle = \frac{1}{2}\pmatrix{1&1&1&1\cr 1&-1&1&-1\cr 1&1&-1&-1\cr 1&-1&-1&1 } \pmatrix{0\cr0\cr1\cr0} = \frac{1}{2} \pmatrix{1\cr1\cr-1\cr-1}
$$Si observamos bien, vemos que lo que ha hecho el vector es seleccionar directamente la tercera columna de la matriz. ¿Por qué? Pues porque $\vert10\rangle$ es el tercer vector de la base: dos ceros, un uno y otro cero. Una combinación lineal de las columnas, en este caso, va directamente a por la tercera columna.

Esto tiene una segunda consecuencia: ya hemos visto que en un ordenador cuántico, el vector de estado siempre se inicializa con ceros: $\vert000\cdots0\rangle$. Este es el primer vector de la base computacional: un $1$ en el primer componente, seguido de un montón de ceros. ¿Qué le va a hacer este astuto vector a una inocente matriz? ¡Pues seleccionar la primera columna!

Esto es un truco muy útil. Si tenemos una matriz de $2^N\times2^N$ que representa a todo un circuito, en realidad sólo necesitamos las $2^N$ celdas de la primera columna, porque sabemos a ciencia cierta cómo funciona la inicialización del ordenador cuántico.

Categorías
Quantum

Compuertas y circuitos

Tras presentar el estado cuántico de un qubit, vimos las transformaciones unitarias que actuaban sobre dicho estado. Ahora, que ya hemos presentado el estado de un grupo de qubits, tenemos que ver las transformaciones unitarias que nos permitirán manejar su estado.

Compuertas

Cuando se trata de operaciones sobre qubits individuales, no es mayor problema utilizar directamente las matrices en notación de componentes. El vector de estado de un qubit se representa con dos componentes complejos, por lo que las matriz son «simples» matrices complejas de $2\times2$. En cambio, es más pesado tener que listar los componentes de matrices con más dimensiones.

La alternativa, que todo el mundo sigue, es representar las transformaciones mediante compuertas cuánticas y combinar estas compuertas en circuitos. Por supuesto, detrás de todo circuito hay, simple y llanamente, una matriz probablemente enorme que es la que realiza la transformación necesaria antes de la medición. A mí, personalmente, me resulta muchísimo más fácil entender el funcionamiento de un algoritmo calculando las matrices asociadas pero, eso espero, con el tiempo uno llega a familiarizarse con la notación de circuitos y desarrollar la intuición necesaria para ahorrarse unos cuantos pasos. En cualquier caso, intentaré dar las herramientas para pasar de compuertas a matrices y, en el caso de circuitos correspondientes a algoritmos sencillos, del circuito completo a la matriz resultante.

Para el diseño de circuitos y algoritmos, mi recomendación es utilizar Qiskit, de IBM. Qiskit te permite crear una cuenta gratuita, y te da acceso a dos herramientas muy útiles para crear y evaluar circuitos: mediante software gráfico y a través de Python. No soy un entusiasta de Python, pero para este tipo de tareas no duele mucho usarlo. La siguiente imagen muestra parte de la barra de herramientas del editor gráfico, y un circuito muy sencillo con dos qubits, a los cuales se le está aplicando una inversión (la compuerta que parece una cruz) y una medición (la línea inferior representa la salida de bits clásicos del algoritmo):

El objetivo de esta entrada no es ponernos ya a diseñar circuitos: cuando llegue el momento, es preferible mostrar el código en Python. Ahora nos interesa la parte matemática, sobre cómo definir transformaciones que afecten a más de un qubit. Utilizo Qiskit para no tener que dibujar los circuitos a mano.

Hay alternativas a Qiskit. Las principales que conozco son Q#, una iniciativa de Microsoft, e incluso librerías de Matlab. Q# es interesante, pero en estos momentos es una pequeña tragedia hacer que funcione a la primera en Visual Studio. Y Matlab es de pago.

Cómo combinar matrices

Volvamos al circuito que he mostrado antes:
Este circuito muestra dos qubits, $q_0$ y $q_1$. A cada uno de ellos se le aplica una negación: la matriz $X$ que ya hemos visto, que convierte ceros en unos y viceversa, y que Qiskit representa como un círculo con una cruz dentro. Luego se realizan las mediciones. El resultado es muy tonto: obtenemos un $11$ clásico:

  1. Asumimos que cada qubit se inicializa en el estado $\vert0\rangle$. Es decir, el sistema de dos qubits se inicializa en el estado conjunto $\vert00\rangle$.
  2. Cada inversión convierte su qubit al estado $\vert1\rangle$. El sistema queda en un estado puro $\vert11\rangle$.
  3. Por supuesto, al medir obtendremos ese estado, sin ningún tipo de incertidumbre.

Sabemos que la matriz o compuerta $X$ tiene la siguiente representación en notación de componentes:
$$\pmatrix{0&1\cr1&0}
$$La pregunta nuestra es: ¿cómo representamos la matriz que aplica una negación por separado a cada uno de los qubits? En este caso, la intuición podría ayudarnos a determinar el contenido de la matriz, pero vamos a aprovechar que es un ejercicio sencillo para poner a punto la herramienta matemática que necesitaremos para casos más complicados. Esa herramienta es la multiplicación tensorial de matrices (previsible, ¿no?).

Supongamos que tenemos dos matrices $A$ y $B$, y que queremos calcular el producto tensorial de las dos:
$$\pmatrix{a_{11}&a_{12}\cr a_{21}&a_{22}}\otimes\pmatrix{b_{11}&b_{12}\cr b_{21}&b_{22}}
$$La definición de producto tensorial de matrices es un poco engorrosa, pero no es complicada:
$$\pmatrix{
a_{11}\times\pmatrix{b_{11}&b_{12}\cr b_{21}&b_{22}}&
a_{12}\times\pmatrix{b_{11}&b_{12}\cr b_{21}&b_{22}}\cr
a_{21}\times\pmatrix{b_{11}&b_{12}\cr b_{21}&b_{22}}&
a_{22}\times\pmatrix{b_{11}&b_{12}\cr b_{21}&b_{22}}
}$$Simplificando, nos queda esto:
$$\pmatrix{
a_{11}b_{11}&a_{11}b_{12}&a_{12}b_{11}&a_{12}b_{12}\cr
a_{11}b_{21}&a_{11}b_{22}&a_{12}b_{21}&a_{12}b_{22}\cr
a_{21}b_{11}&a_{21}b_{12}&a_{22}b_{11}&a_{22}b_{12}\cr
a_{21}b_{21}&a_{21}b_{22}&a_{22}b_{21}&a_{22}b_{22}
}$$Es muy importante dominar esta técnica. Asegúrese de que comprende de dónde sale cada celda del resultado antes de seguir adelante.

En nuestro ejemplo, queríamos combinar dos matrices $X$:
$$\pmatrix{0&1\cr1&0}\otimes\pmatrix{0&1\cr1&0}
$$En el paso intermedio, obtenemos esto:
$$\pmatrix{
0\times\pmatrix{0&1\cr1&0}&
1\times\pmatrix{0&1\cr1&0}\cr
1\times\pmatrix{0&1\cr1&0}&
0\times\pmatrix{0&1\cr1&0}
}$$Simplificando:
$$\pmatrix{
0&0&0&1\cr
0&0&1&0\cr
0&1&0&0\cr
1&0&0&0
}$$Intuitivamente, el resultado tiene buen aspecto: la matriz $X$ de dos dimensiones parece una matriz con la diagonal invertida, y esta matriz resultado tiene la misma forma. ¿Cómo comprobamos que es correcta? Muy sencillo. La base para dos qubits tiene cuatro vectores, que son $\vert00\rangle,\vert01\rangle,\vert10\rangle,\vert11\rangle$. Estos cuatro vectores, sin embargo, tienen una representación en componentes que puede resultar confusa si no la domina todavía. Vamos a hacer los cálculos y las representaciones explícitos. Para el primer vector de la base:
$$(X\otimes X)\vert00\rangle = \pmatrix{
0&0&0&1\cr
0&0&1&0\cr
0&1&0&0\cr
1&0&0&0
} \times \pmatrix {1\cr0\cr0\cr0} = \pmatrix {0\cr0\cr0\cr1} = \vert11\rangle
$$Para el segundo vector:
$$(X\otimes X)\vert01\rangle = \pmatrix{
0&0&0&1\cr
0&0&1&0\cr
0&1&0&0\cr
1&0&0&0
} \times \pmatrix {0\cr1\cr0\cr0} = \pmatrix {0\cr0\cr1\cr0} = \vert10\rangle
$$Tercer vector:
$$(X\otimes X)\vert10\rangle = \pmatrix{
0&0&0&1\cr
0&0&1&0\cr
0&1&0&0\cr
1&0&0&0
} \times \pmatrix {0\cr0\cr1\cr0} = \pmatrix {0\cr1\cr0\cr0} = \vert01\rangle
$$Y el cuarto vector:
$$(X\otimes X)\vert11\rangle = \pmatrix{
0&1&0&0\cr
1&0&0&0\cr
0&1&0&0\cr
1&0&0&0
} \times \pmatrix {0\cr0\cr0\cr1} = \pmatrix {1\cr0\cr0\cr0} = \vert00\rangle
$$Perdone que haya sido tan pedante y haya escrito explícitamente todos los detalles. La programación, en general, es el reino de los detalles. En este caso, hemos podido comprobar que la matriz combinada invierte los ceros y unos en el estado cuántico combinado.

El orden de los factores

Sin embargo, me he dejado un detalle importante en el tintero: el orden de los qubits. En un estado como $\vert01\rangle$, ¿cuál es el qubit más significativo? ¿Es el $0$ o el $1$? Todo depende del convenio, pero una vez elegido uno, hay que atenerse estrictamente a él. Nuestro convenio será que en $\vert01\rangle$ el bit más significativo es el de la izquierda, es decir, el $0$, y el menos significativo es el de la derecha, el $1$.

Recuerde, además, que $\vert01\rangle$ es realmente $\vert0\rangle\otimes\vert1\rangle$, esto es, un producto tensorial. Esto es muy importante también para combinar correctamente matrices. Nuestro primer ejemplo de producto tensorial fue muy sencillo porque las dos matrices eran idénticas, y no tuvimos que preocuparnos por su orden relativo. Vamos a suponer que nuestro circuito tiene esta otra forma:

Esta vez queremos invertir solamente el qubit menos significativo. Aparentemente, además, sólo tenemos una matriz, pero eso no es del todo cierto. Lo que queremos calcular ahora es la matriz combinada $I\otimes X$, donde $I$ es la matriz identidad.

Observe el orden: primero va la matriz identidad $I$… ¡porque cuando representamos el sistema de dos qubits, hemos elegido que el más significativo sea el de la izquierda! Y la matriz $X$ es entonces el segundo operando. Queremos entonces calcular esto:

$$\pmatrix{1&0\cr0&1}\otimes\pmatrix{0&1\cr1&0}
$$Expandiendo, según la definición de producto tensorial:
$$\pmatrix{
1\times\pmatrix{0&1\cr1&0}&
0\times\pmatrix{0&1\cr1&0}\cr
0\times\pmatrix{0&1\cr1&0}&
1\times\pmatrix{0&1\cr1&0}
}$$Y si simplificamos:
$$\pmatrix{
0&1&0&0\cr
1&0&0&0\cr
0&0&0&1\cr
0&0&1&0
}$$Esto, así de repente, es chino mandarín, y la única manera sensata de comprobar que no nos hemos equivocado es comprobar directamente las transformaciones.
$$(I\otimes X)\vert00\rangle = \pmatrix{
0&1&0&0\cr
1&0&0&0\cr
0&0&0&1\cr
0&0&1&0
} \times \pmatrix {1\cr0\cr0\cr0} = \pmatrix {0\cr1\cr0\cr0} = \vert01\rangle
$$
$$(I\otimes X)\vert01\rangle = \pmatrix{
0&1&0&0\cr
1&0&0&0\cr
0&0&0&1\cr
0&0&1&0
} \times \pmatrix {0\cr1\cr0\cr0} = \pmatrix {1\cr0\cr0\cr0} = \vert00\rangle
$$
$$(I\otimes X)\vert10\rangle = \pmatrix{
0&1&0&0\cr
1&0&0&0\cr
0&0&0&1\cr
0&0&1&0
} \times \pmatrix {0\cr0\cr1\cr0} = \pmatrix {0\cr0\cr0\cr1} = \vert11\rangle
$$
$$(I\otimes X)\vert11\rangle = \pmatrix{
0&1&0&0\cr
1&0&0&0\cr
0&0&0&1\cr
0&0&1&0
} \times \pmatrix {0\cr0\cr0\cr1} = \pmatrix {0\cr0\cr1\cr0} = \vert10\rangle
$$Nuestra matriz, por lo tanto, transforma $00\rightarrow01$, $01\rightarrow00$, $10\rightarrow11$ y $11\rightarrow11$. Esto es, lo que hace es cambiar el estado del bit menos significativo… que era lo que estábamos buscando. Como ejercicio, puede calcular cuál sería la representación en componentes de la matriz $X\otimes I$, que debe invertir el estado del qubit más significativo. Y si quiere adelantarse a la siguiente entrada, pruebe fortuna con $H\otimes H$, donde $H$ es la transformación de Hadamard que ya hemos visto.

Advertencia

Todas las matrices y estados que hemos visto tienen componentes que son o $0$ o $1$. Esto puede llevar a confusión: ese cero es realmente un cero «complejo», y lo mismo se aplica al uno. No pierda de vista, aunque en estos primeros ejemplos no importe mucho, que en vez de ceros y unos, nuestras matrices y vectores pueden contener, y contendrán, números complejos.