Tutorial: Exploración del entrelazamiento cuántico con Q#

En este tutorial, escribirá un Q# programa que prepara dos cúbits en un estado cuántico específico, opera en los cúbits para entrelazarlos entre sí y realiza mediciones para demostrar los efectos de superposición y entrelazamiento. Cree el Q# programa por partes para introducir estados de cúbits, operaciones cuánticas y medidas.

Antes de empezar, revise los siguientes conceptos de computación cuántica:

Los bits clásicos contienen un único valor binario como 0 o 1, pero los cúbits pueden estar en una superposición de los dos estados, 0 y 1. Cada estado de cúbit posible se describe mediante un conjunto de amplitudes de probabilidad.
Al medir el estado de un cúbit, siempre obtendrá 0 o 1. La probabilidad de cada resultado viene determinada por las amplitudes de probabilidad que definen el estado de superposición cuando se realiza una medición.
Se pueden entrelazar varios cúbits de forma que no se puedan describir independientemente entre sí. Al medir un cúbit en un par entrelazado, también obtendrá información sobre el otro cúbit sin medirlo.

En este tutorial, aprenderá a:

Crear operaciones Q# para inicializar un cúbit en un estado deseado.
Coloque un cúbit en un estado de superposición.
Entrelazar un par de cúbits.
Mida un cúbit y observe los resultados.

Sugerencia

Si desea acelerar el recorrido de la computación cuántica, consulte Código con Azure Quantum, una característica única del sitio web de Microsoft Quantum. Aquí puede ejecutar ejemplos integrados Q# o sus propios Q# programas, generar código nuevo Q# a partir de las indicaciones, abrir y ejecutar el código en VS Code para la Web con un solo clic y formular preguntas de Copilot sobre la computación cuántica.

Requisitos previos

Para ejecutar el ejemplo de código con Copilot para Azure Quantum, debe tener una cuenta de correo electrónico de Microsoft (MSA).

Para más información sobre Copilot para Azure Quantum, consulte Exploración de Azure Quantum.

Inicialización de un cúbit en un estado conocido

El primer paso es definir una Q# operación que inicializa un cúbit en un estado clásico deseado, ya sea 0 o 1. Esta operación mide un cúbit en un estado cuántico general, que devuelve un Q#Result valor de tipo de Zero o One. Si el resultado de la medida es diferente del estado deseado, la operación cambia el estado para que la operación devuelva el estado deseado 100% del tiempo.

Abra Copilot para Azure Quantum, borre el código predeterminado y, a continuación, copie el código siguiente en la ventana del editor de código. No puede ejecutar este código por sí mismo porque aún no es un programa completo Q# .

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

En el ejemplo de código se presentan dos operaciones estándar Q# y MX, que transforman el estado de un cúbit.

Esta es una descripción detallada de cómo funciona la SetQubitState operación:

Toma dos parámetros: un Result parámetro de tipo denominado desired que representa el estado deseado para que el cúbit esté en (Zero o One) y un Qubit parámetro de tipo.
Realiza una operación de medición, , Mque mide el estado del cúbit (Zero o One) y compara el resultado con el valor que se pasa para desired.
Si el resultado de la medida no coincide con el valor de desired, se aplica una X operación al cúbit. Esta operación invierte el estado del cúbit para que se invierten las probabilidades de medición de Zero y One .

Escribir una operación de prueba para probar el estado de Bell

Para llamar a la operación SetQubitState en su programa Q#, cree otra operación denominada Main. Esta operación asigna dos cúbits, llama SetQubitState a para establecer el primer cúbit en un estado conocido y, a continuación, mide los cúbits para ver los resultados.

Copie el código siguiente en la ventana del editor de código después de la SetQubitState operación.

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

En el código, las variables count y initial se establecen en 1000 y One respectivamente. El primer cúbit se inicializa en One y cada cúbit se mide 1000 veces.

La Main operación hace lo siguiente:

Establece variables para el número de tomas (count) y el estado de cúbit inicial (One).
Llama a la instrucción use para inicializar dos cúbits.
Recorre en bucle los tiempos del experimento count .
En el bucle, llama SetQubitState a para establecer el valor especificado initial en el primer cúbit y, a continuación, llama SetQubitState de nuevo para establecer el segundo cúbit en el Zero estado.
En el bucle, aplica la M operación para medir cada cúbit y, a continuación, almacena el número de medidas de cada cúbit que devuelve One.
Una vez completado el bucle, llama SetQubitState de nuevo a para restablecer los cúbits a un estado conocido (Zero). Debe restablecer los cúbits que asigne con la sentencia use.
Llama a la Message función para imprimir los resultados en la ventana de salida.

Ejecución del código en Copilot para Azure Quantum

Antes de escribir código para superposición y entrelazamiento, pruebe el programa actual para ver la inicialización y medición de los cúbits.

Para ejecutar el código como un programa independiente, el Q# compilador de Copilot debe saber dónde iniciar el programa. Dado que no especificó un espacio de nombres, el compilador reconoce el punto de entrada predeterminado como la Main operación. Para obtener más información, vea Proyectos y espacios de nombres implícitos.

El Q# programa ahora tiene el siguiente aspecto:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Copie y pegue el ejemplo de código completo en la ventana Código de Copilot para Azure Quantum , establezca el control deslizante para el número de capturas en "1" y, a continuación, elija Ejecutar. Los resultados se muestran en el histograma y en los campos Resultados .

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

El programa aún no modifica los estados de cúbit, por lo que la medición del primer cúbit siempre devuelve Oney el segundo cúbit siempre devuelve Zero.

Si cambia el valor de initial a Zero y vuelve a ejecutar el programa, entonces el primer cúbit también siempre devuelve Zero.

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Colocar un cúbit en un estado de superposición

Actualmente, los cúbits del programa están en un estado clásico, ya sea 1 o 0, al igual que bits en un equipo normal. Para entrelazar los cúbits, primero debe colocar uno de los cúbits en un estado de superposición igual. La medición de un cúbit en un estado de superposición igual tiene un 50% de probabilidad de dar como resultado Zero y un 50% de probabilidad de dar como resultado One.

Para colocar un cúbit en un estado de superposición, use la operación de Hadamard Q#H. La H operación convierte un cúbit que está en un estado puro Zero o One en un tipo de estado medio entre Zero y One.

Modifique el código de la operación Main. Restablezca el valor inicial en One e inserte una línea para la H operación:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);  // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Vuelva a ejecutar el programa. Dado que el primer cúbit está en una superposición igual al medirlo, se acerca a un resultado de 50/50 para Zero y One. Por ejemplo, la salida tiene un aspecto similar al siguiente:

Q1 - Zeros: 523
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Cada vez que ejecute el programa, los resultados del primer cúbit varían ligeramente, pero están cerca de 50% One y 50% Zero, mientras que los resultados del segundo cúbit siguen siendo siempre Zero.

Inicialice el primer cúbit en Zero en vez de One y ejecute el programa nuevamente. Obtiene resultados similares porque la operación H convierte tanto un estado puro Zero como un estado puro One en un estado de igual superposición.

Nota:

Para ver cómo los resultados de la superposición varían en función de la distribución de las tomas, mueva el control deslizante en Copilot para Azure Quantum y aumente el número de tomas.

Entrelazar dos qubits

Los cúbits entrelazados se correlacionan de modo que no se puedan describir independientemente entre sí. Al medir el estado de un cúbit entrelazado, también conoce el estado del otro cúbit sin medirlo. En este tutorial se usa un ejemplo con dos cúbits entrelazados, pero también puede entrelazar tres o más cúbits.

Para crear un estado entrelazado, use la operación Q#CNOT, o Controlled-NOT. Cuando se aplica CNOT a dos cúbits, un cúbit es el cúbit de control y el otro es el cúbit de destino. Si el estado del cúbit de control es One, la CNOT operación invierte el estado del cúbit de destino. De lo contrario, CNOT no hace nada con los cúbits.

Agregue la operación CNOT al programa inmediatamente después de la operación H. El programa completo tiene este aspecto:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
 }

Ejecute el programa y vea la salida. Tus resultados varían ligeramente cada vez que ejecutas el programa.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Las estadísticas del primer cúbit siguen mostrando aproximadamente un 50% de posibilidad de medir ambos One y Zero, pero ahora los resultados de medición del segundo cúbit no siempre son Zero. Cada cúbit tiene el mismo número de Zero resultados y One resultados. El resultado de la medición del segundo cúbit siempre es el mismo que el resultado del primer cúbit porque los dos cúbits están entrelazados. Si el primer cúbit se mide como Zero, el cúbit entrelazado también debe ser Zero. Si el primer cúbit se mide como One, el cúbit entrelazado también debe ser One.

Requisitos previos

Para desarrollar y ejecutar el ejemplo de código en el entorno de desarrollo local, instale las siguientes herramientas:

La versión más reciente de Visual Studio Code (VS Code) o abra VS Code para la Web.
La versión más reciente de la extensión del Kit de desarrollo de Azure Quantum (QDK). Para obtener más información sobre la instalación, consulte Configuración de la extensión QDK.

Crear un nuevo Q# archivo

En VS Code, abra el menú Archivo y elija Nuevo archivo de texto para crear un nuevo archivo.
Guarde el archivo como CreateBellStates.qs. Este archivo es donde se escribe el código para el Q# programa.

Inicialización de un cúbit en un estado conocido

Abra CreateBellStates.qs y copie el código siguiente:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

En el ejemplo de código se presentan dos operaciones estándar Q# y MX, que transforman el estado de un cúbit.

Esta es una descripción detallada de cómo funciona la SetQubitState operación:

Toma dos parámetros: un Result parámetro de tipo denominado desired que representa el estado deseado para que el cúbit esté en (Zero o One) y un Qubit parámetro de tipo.
Realiza una operación de medición, , Mque mide el estado del cúbit (Zero o One) y compara el resultado con el valor que se pasa para desired.
Si el resultado de la medida no coincide con el valor de desired, se aplica una X operación al cúbit. Esta operación invierte el estado del cúbit para que se invierten las probabilidades de medición de Zero y One .

Escribir una operación de prueba para probar el estado de Bell

Agregue la siguiente operación a su archivo CreateBellStates.qs después de la operación SetQubitState:

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

En el código, las variables count y initial se establecen en 1000 y One respectivamente. El primer cúbit se inicializa en One y cada cúbit se mide 1000 veces.

La Main operación hace lo siguiente:

Establece variables para el número de tomas (count) y el estado de cúbit inicial (One).
Llama a la instrucción use para inicializar dos cúbits.
Recorre en bucle los tiempos del experimento count .
En el bucle, llama SetQubitState a para establecer el valor especificado initial en el primer cúbit y, a continuación, llama SetQubitState de nuevo para establecer el segundo cúbit en el Zero estado.
En el bucle, aplica la M operación para medir cada cúbit y, a continuación, almacena el número de medidas de cada cúbit que devuelve One.
Una vez completado el bucle, llama SetQubitState de nuevo a para restablecer los cúbits a un estado conocido (Zero). Debe restablecer los cúbits que asigne con la sentencia use.
Llama a la función Message para imprimir tus resultados en la consola.

Ejecución del código

Antes de escribir código para superposición y entrelazamiento, pruebe el programa actual para ver la inicialización y medición de los cúbits.

Para ejecutar el código como un programa independiente, el Q# compilador debe saber dónde iniciar el programa. Dado que no especificó un espacio de nombres, el compilador reconoce el punto de entrada predeterminado como la Main operación. Para obtener más información, vea Proyectos y espacios de nombres implícitos.

Su CreateBellStates.qs archivo ahora tiene el siguiente aspecto:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Para ejecutar el programa, elija el comando Ejecutar en la lente de código que precede a la Main operación o escriba Ctrl + F5. El programa ejecuta la Main operación en el simulador predeterminado.

Su salida se muestra en la consola.

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

El programa aún no modifica los estados de cúbit, por lo que la medición del primer cúbit siempre devuelve Oney el segundo cúbit siempre devuelve Zero.

Si cambia el valor de initial a Zero y vuelve a ejecutar el programa, entonces el primer cúbit también siempre devuelve Zero.

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Colocar un cúbit en un estado de superposición

Modifique el código de la operación Main. Restablezca el valor inicial en One e inserte una línea para la H operación:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);  // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Q1 - Zeros: 523
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Entrelazar dos qubits

Agregue la operación CNOT al programa inmediatamente después de la operación H. El programa completo tiene este aspecto:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Ejecute el programa y vea la salida. Los resultados variarán ligeramente cada vez que se ejecuta el programa.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Las estadísticas del primer cúbit siguen mostrando aproximadamente un 50% de probabilidad de medir tanto One como Zero, pero los resultados de medición del segundo cúbit no siempre son Zero ahora. Cada cúbit tiene el mismo número de Zero resultados y One resultados. El resultado de la medición del segundo cúbit siempre es el mismo que el resultado del primer cúbit porque los dos cúbits están entrelazados. Si el primer cúbit se mide como Zero, el cúbit entrelazado también debe ser Zero. Si el primer cúbit se mide como One, el cúbit entrelazado también debe ser One.

Traza el histograma de frecuencia

Para trazar un histograma de frecuencia que muestra la distribución de resultados al ejecutar el programa varias veces, complete los pasos siguientes:

Abra el CreateBellStates.qs archivo en VS Code.
Abra el menú Ver y elija Paleta de comandos.
Escriba histograma para abrir la opción QDK: Ejecutar archivo y mostrar histograma. O bien, elija el comando Histograma de la opción de Code Lens que precede a la operación Main. A continuación, ingrese una cantidad de tomas (por ejemplo, 100). El Q# histograma se abre en una nueva pestaña.

Cada barra del histograma corresponde a un posible resultado cuando el circuito de entrelazamiento se ejecuta 1000 veces. El alto de una barra representa el número de veces que se produce el resultado. Por ejemplo, el histograma siguiente muestra una distribución con 50 resultados únicos. Tenga en cuenta que para cada resultado, los resultados de medición para el primer y el segundo cúbit siempre son los mismos.

Sugerencia

Para acercar el histograma, use la rueda del ratón o un gesto en el panel táctil. Para desplazar el gráfico cuando se acerca, mantenga presionada la tecla Alt mientras se desplaza.
Elija una barra para mostrar el porcentaje de disparos totales que produjeron ese resultado.
Elija el icono de configuración de la parte superior izquierda para mostrar las opciones de visualización.
Vuelva a ejecutar el código, pero esta vez con 1000 ejecuciones. A medida que aumenta el número de tomas, la distribución de los resultados se aproxima a una distribución normal.

Explore otros tutoriales de Q#:

El algoritmo de búsqueda de Grover muestra cómo escribir un Q# programa que usa el algoritmo de búsqueda de Grover.
Quantum Fourier Transform explora cómo escribir un Q# programa que direccione directamente los cúbits específicos.
Quantum Katas son tutoriales autodirigidos y ejercicios de programación que enseñan los elementos de la computación cuántica y Q# programación al mismo tiempo.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-12-03

Compartir a través de

Tutorial: Exploración del entrelazamiento cuántico con Q#

Requisitos previos

Inicialización de un cúbit en un estado conocido

Escribir una operación de prueba para probar el estado de Bell

Ejecución del código en Copilot para Azure Quantum

Colocar un cúbit en un estado de superposición

Entrelazar dos qubits

Requisitos previos

Crear un nuevo Q# archivo

Inicialización de un cúbit en un estado conocido

Escribir una operación de prueba para probar el estado de Bell

Ejecución del código

Colocar un cúbit en un estado de superposición

Entrelazar dos qubits

Traza el histograma de frecuencia

Contenido relacionado

Comentarios

Recursos adicionales