Inicio rápido: Creación del primer Q# programa

Aprenda a escribir un programa básico Q# que muestre el entrelazamiento, un concepto clave de la computación cuántica.

Cuando dos o más cúbits están entrelazados , comparten información cuántica, lo que significa que sucede con un cúbit también ocurre con el otro. En este inicio rápido, creará un estado entrelazado de dos cúbits determinado denominado par Bell. En un par bell, si mide un cúbit en el $\ket{0}$ estado, sabe que el otro cúbit también está en el $\ket{0}$ estado sin medirlo. Para más información, consulte Entrelazamiento cuántico.

En esta guía de inicio rápido:

• Cree un archivo Q# .
• Asigne un par de cúbits.
• Entrelazar los cúbits.

Requisitos previos

• Versión más reciente de Visual Studio Code.
• Extensión del Kit de desarrollo de Azure Quantum (QDK). Para obtener más información sobre la instalación, consulte Configuración del kit de desarrollo de Quantum.

Cree un archivo Q# .

1. Abra Visual Studio Code.
2. Seleccione Archivo>nuevo archivo de texto.
3. Guarde el archivo como Main.qs. La extensión .qs denota un Q# programa.

Q# Escribir el código

En el Main.qs archivo, siga estos pasos para entrelazar y medir un par de cúbits.

Importación de una biblioteca cuántica

El QDK incluye la Q# biblioteca estándar con funciones y operaciones predefinidas para los programas cuánticos. Para usarlos, primero debe importar la biblioteca pertinente.

En el programa, use una import instrucción para abrir la Microsoft.Quantum.Diagnostics biblioteca. Esto le proporciona acceso a todas sus funciones y operaciones, incluido DumpMachine(), que posteriormente se usa para mostrar el estado entrelazado.

    import Microsoft.Quantum.Diagnostics.*;

Definición de una operación

Después de importar las bibliotecas pertinentes, defina la operación cuántica y sus valores de entrada y salida. Para este inicio rápido, la operación es Main. Aquí es donde escribirá el código restante Q# para asignar, manipular y medir dos cúbits.

Main no toma parámetros y devuelve dos Result valores, o Zero One, que representan los resultados de las medidas de cúbit:

    operation Main() : (Result, Result) {
        // Your entanglement code goes here.
}

Asignar dos cúbits

La Main operación está vacía actualmente, por lo que el siguiente paso es asignar dos cúbits y q2q1 . En Q#, se asignan cúbits mediante la use palabra clave :

        // Allocate two qubits, q1 and q2, in the 0 state.
        use (q1, q2) = (Qubit(), Qubit());

Nota:

En Q#, los cúbits siempre se asignan en el $\ket{0}$ estado .

Colocar un cúbit en superposición

Los cúbits q1 y q2 están en estado $\ket{0}$ . Para preparar los cúbits para el entrelazamiento, debe colocar uno de ellos en una superposición par, donde tiene una probabilidad del 50 % de medirse como $\ket{0}$ o $\ket{1}$.

Para colocar un cúbit en superposición, aplique hadamard, H, operación:

        // Put q1 into an even superposition.
        H(q1);

El estado resultante de q1 es $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1})$, que es una superposición par de $\ket{0}$ y $\ket{{1}$.

Entrelazar los cúbits

Ya está listo para entrelazar los cúbits mediante la operación controlled-NOT, CNOT, . CNOT es una operación de control que toma dos cúbits, una que actúa como control y la otra como destino.

En este inicio rápido, se establece q1 como cúbit de control y q2 como cúbit de destino. Esto significa CNOT voltear el estado de cuando el estado de q1 q2 es $\ket{1}$.

        // Entangle q1 and q2, making q2 depend on q1.
        CNOT(q1, q2);

El estado resultante de ambos cúbits es el par $\frac{{1}{\sqrt{2}}Bell (\ket{00}+\ket{{11})$.

Sugerencia

Si desea obtener información sobre cómo las operaciones Hadamard y CNOT transforman el estado de los cúbits, consulte Creación de un entrelazamiento con operaciones cuánticas.

Mostrar el estado entrelazado

Antes de medir los cúbits, es importante comprobar que el código anterior los entrelazará correctamente. Puede usar la DumpMachine operación , que forma parte de la Microsoft.Quantum.Diagnostics biblioteca, para generar el estado actual del Q# programa:

        // Show the entangled state of the qubits.
        DumpMachine();

Medición de los cúbits

Ahora que ha comprobado que los cúbits están entrelazados, puede usar la M operación para medirlos. Medir q1 y q2 contraer sus estados cuánticos en Zero o One con probabilidad uniforme.

En Q#, se usa la let palabra clave para declarar una nueva variable. Para almacenar los resultados de medición de q1 y q2, declare las variables m1 y m2, respectivamente:

        // Measure q1 and q2 and store the results in m1 and m2.
        let (m1, m2) = (M(q1), M(q2));

Restablecer los cúbits

Antes de liberarse al final de cada Q# programa, los cúbits deben estar en estado $\ket{0}$ . Para ello, use la Reset operación :

        // Reset q1 and q2 to the 0 state.
        Reset(q1);
        Reset(q2);

Devolver los resultados de la medida

Por último, para completar la Main operación y observar el estado entrelazado, devuelva los resultados de medición de m1 y m2:

        // Return the measurement results.
        return (m1, m2);

Sugerencia

Si desea obtener más información sobre una Q# función o una operación, mantenga el puntero sobre ella.

Ejecución del Q# código

Felicidades. Escribió un Q# programa que entrelaza dos cúbits y crea un par de Campanas.

El programa final Q# debe tener este aspecto:

import Microsoft.Quantum.Diagnostics.*;

operation Main() : (Result, Result) {  
    // Allocate two qubits, q1 and q2, in the 0 state.
    use (q1, q2) = (Qubit(), Qubit());
    
    // Put q1 into an even superposition.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q1);
    
    // Entangle q1 and q2, making q2 depend on q1.
    CNOT(q1, q2);
    
    // Show the entangled state of the qubits.
    DumpMachine();
    
    // Measure q1 and q2 and store the results in m1 and m2.
    let (m1, m2) = (M(q1), M(q2));
    
    // Reset q1 and q2 to the 0 state.
    Reset(q1);
    Reset(q2);
    
    // Return the measurement results.
    return (m1, m2);
}

Para ejecutar el programa y ver el resultado de ambos cúbits, seleccione Ejecutar encima de la Main operación o presione Ctrl+F5.

Puede ejecutar el programa varias veces, cada uno con un resultado diferente en la consola de depuración. Esto muestra la naturaleza probabilística de las medidas cuánticas y el entrelazamiento de los cúbits.

Por ejemplo, si el resultado es Zero, la consola de depuración debe tener este aspecto:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
  |11⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

Result: "(Zero, Zero)"

Paso siguiente

Para más información sobre el entrelazamiento cuántico con Q#, consulte Tutorial: Exploración del entrelazamiento cuántico con Q#. Este tutorial se expande sobre los conceptos descritos en este inicio rápido y le ayuda a escribir un programa de entrelazamiento más avanzado.