Compartir a través de

Introducción al lenguaje de programación cuántica Q#

Q# es un lenguaje de programación de código abierto de alto nivel desarrollado por Microsoft para escribir programas cuánticos. Q# se incluye en el Kit de desarrollo de Quantum (QDK). Para obtener más información, consulte Configuración del kit de desarrollo de Quantum.

Como lenguaje de programación cuántica, Q# cumple los siguientes requisitos para el lenguaje, el compilador y el entorno de ejecución:

  • Independiente del hardware: los cúbits de los algoritmos cuánticos no están vinculados a un diseño o hardware cuántico específico. El Q# compilador y el tiempo de ejecución controlan la asignación de cúbits de programa a cúbits físicos, lo que permite que el mismo código se ejecute en diferentes procesadores cuánticos.
  • Integración de la computación cuántica y clásica:Q# permite la integración de cálculos cuánticos y clásicos, que es esencial para la computación cuántica universal.
  • Administración de cúbits:Q# proporciona operaciones y funciones integradas para administrar cúbits, incluida la creación de estados de superposición, el entrelazamiento de cúbits y la realización de medidas cuánticas.
  • Respetar las leyes de la física:Q# y los algoritmos cuánticos deben seguir las reglas de la física cuántica. Por ejemplo, no se puede copiar ni acceder directamente al estado de cúbit en Q#.

Para obtener más información sobre los orígenes de Q#, consulte la entrada del blog ¿Por qué necesitamos Q#?.

Estructura de un Q# programa

Antes de empezar a escribir Q# programas, es importante comprender su estructura y componentes. Tenga en cuenta el siguiente Q# programa, denominado Superposición, que crea un estado de superposición:

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

En función de los comentarios (//), el Q# programa asigna primero un cúbit, aplica una operación para colocar el cúbit en superposición, mide el estado del cúbit, restablece el cúbit y, por último, devuelve el resultado.

Vamos a dividir este Q# programa en sus componentes.

Espacios de nombres de usuario

Q# Los programas pueden empezar opcionalmente con un espacio de nombres definido por el usuario, como:

namespace Superposition {
    // Your code goes here.
}

Los espacios de nombres pueden ayudarle a organizar la funcionalidad relacionada. Los espacios de nombres son opcionales en Q# programas, lo que significa que puede escribir un programa sin definir un espacio de nombres.

Por ejemplo, el programa Superposición del ejemplo también se podría escribir sin un espacio de nombres como:

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Nota:

Cada Q# programa solo puede tener un namespace. Si no especifica un espacio de nombres, el Q# compilador usa el nombre de archivo como espacio de nombres.

Puntos de entrada

Cada Q# programa debe tener un punto de entrada, que es el punto inicial del programa. De forma predeterminada, el Q# compilador comienza a ejecutar un programa desde la Main() operación, si está disponible, que se puede ubicar en cualquier parte del programa. Opcionalmente, puede usar el @EntryPoint() atributo para especificar cualquier operación en el programa como punto de ejecución.

Por ejemplo, en el programa Superposición , la MeasureOneQubit() operación es el punto de entrada del programa porque tiene el @EntryPoint() atributo antes de la definición de la operación:

@EntryPoint()
operation MeasureOneQubit() : Result {
    ...
}

Sin embargo, el programa también podría escribirse sin el @EntryPoint() atributo cambiando el nombre de la MeasureOneQubit() operación a Main(), como:

// The Q# compiler automatically detects the Main() operation as the entry point. 

operation Main() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Tipos

Los tipos son esenciales en cualquier lenguaje de programación porque definen los datos con los que un programa puede trabajar. Q# proporciona tipos incorporados comunes a la mayoría de los lenguajes, incluidos Int, Double, Bool y String, y tipos que definen intervalos, matrices y tuplas.

Q# también proporciona tipos específicos de la computación cuántica. Por ejemplo, el Result tipo representa el resultado de una medida de cúbit y puede tener dos valores: Zero o One.

En el programa Superposición, la MeasureOneQubit() operación devuelve un tipo Result, que corresponde al tipo de retorno de la M operación. El resultado de la medida se almacena en una nueva variable definida mediante la let instrucción :

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the Z-basis, returning a Result type.
    let result = M(q);
    ...
}

Otro ejemplo de un tipo específico de quantum es el Qubit tipo , que representa un bit cuántico.

Q# también permite definir sus propios tipos personalizados. Para obtener más información, vea Declaraciones de tipo.

Asignación de bits cuánticos

En Q#, se asignan qubits mediante la palabra clave use y el tipo Qubit. Los cúbits siempre se asignan en el estado $\ket{0}$.

Por ejemplo, el programa Superposición define un único cúbit y lo almacena en la variable q:

// Allocate a qubit.
use q = Qubit();

También puede asignar varios cúbits y acceder a cada uno a través de su índice:

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Operaciones cuánticas

Después de asignar un cúbit, puede pasarlo a operaciones y funciones. Un programa Q# tiene como bloques de creación básicos las operaciones. Una Q# operación es una subrutina cuántica o una rutina invocable que contiene operaciones cuánticas que cambian el estado del registro de cúbits.

Para definir una Q# operación, especifique un nombre para la operación, sus entradas y su salida. En el programa Superposición , la MeasureOneQubit() operación no toma parámetros y devuelve un Result tipo:

operation MeasureOneQubit() : Result {
    ...
}

Este es un ejemplo básico que no toma parámetros y espera ningún valor devuelto. El Unit valor es equivalente a NULL en otros idiomas:

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

La Q# biblioteca estándar también proporciona operaciones que puede usar en programas cuánticos, como la operación Hadamard, H, en el Superposition programa. Dado un cúbit en la base Z, H coloca el cúbit en una superposición par, donde tiene una probabilidad del 50 % de medirse como Zero o One.

Medición de cúbits

Aunque hay muchos tipos de mediciones cuánticas, Q# se centra en las mediciones projectivas en cúbits individuales, también conocidos como mediciones de Pauli.

En Q#, la Measure operación mide uno o varios cúbits en la base de Pauli especificada, que puede ser PauliX, PauliYo PauliZ. Measure devuelve un tipo Result, ya sea Zero o One.

Para implementar una medición en la base computacional $\lbrace\ket{0},\ket{1}\rbrace$, puede usar también la operación M, que mide un qubit en la base Z de Pauli. Esto equivale M a Measure([PauliZ], [qubit]).

Por ejemplo, el programa Superposición usa la M operación :

// Measure the qubit in the Z-basis.
let result = M(q);

Restablecer cúbits

En Q#, los cúbits deben estar en el $\ket{0}$ estado cuando se liberan para evitar errores en el hardware cuántico. Puede restablecer un cúbit al $\ket{0}$ estado mediante la Reset operación al final del programa. Si no se restablece un cúbit, se produce un error en tiempo de ejecución.

// Reset a qubit.
Reset(q);

Espacios de nombres de biblioteca estándar

La Q# biblioteca estándar tiene espacios de nombres integrados que contienen funciones y operaciones que puede usar en programas cuánticos. Por ejemplo, el Microsoft.Quantum.Intrinsic espacio de nombres contiene operaciones y funciones usadas habitualmente, como M para medir los resultados y Message mostrar mensajes de usuario en cualquier parte del programa.

Para llamar a una función o operación, puede especificar el espacio de nombres completo o usar una import instrucción , que hace que todas las funciones y operaciones de ese espacio de nombres estén disponibles y haga que el código sea más legible. En los ejemplos siguientes se llama a la misma operación:

Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

// imports all functions and operations from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.*;
Message("Hello quantum world!");

// imports just the `Message` function from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.Message;
Message("Hello quantum world!");

// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`. 
import Std.Intrinsic.*;
Message("Hello quantum world!");

Nota:

El programa Superposición no tiene instrucciones import ni llamadas con espacios de nombres completos. Esto se debe a que el Q# entorno de desarrollo carga automáticamente dos espacios de nombres: Microsoft.Quantum.Core y Microsoft.Quantum.Intrinsic, que contienen funciones y operaciones usadas habitualmente.

Puede aprovechar el espacio de nombres Microsoft.Quantum.Measurement usando la operación MResetZ para optimizar el programa de Superposición . MResetZ combina las operaciones de medición y restablecimiento en un paso, como en el ejemplo siguiente:

// Import the namespace for the MResetZ operation.
import Microsoft.Quantum.Measurement.*;

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.      
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1. 
    H(q);   
    // Measure and reset the qubit, and then return the result value.
    return MResetZ(q);
}

Aprenda a desarrollar programas cuánticos con Q# y Azure Quantum

Q# y Azure Quantum son una combinación eficaz para desarrollar y ejecutar programas cuánticos. Con Q# y Azure Quantum, puede escribir programas cuánticos, simular su comportamiento, calcular los requisitos de recursos y ejecutarlos en hardware cuántico real. Esta integración le permite explorar el potencial de la computación cuántica y desarrollar soluciones innovadoras para problemas complejos. Tanto si es principiante como un desarrollador cuántico experimentado, Q# y Azure Quantum proporciona las herramientas y los recursos que necesita para desbloquear la eficacia de la computación cuántica.

En el diagrama siguiente se muestran las fases a las que pasa un programa cuántico al desarrollarlo con Q# y Azure Quantum. El programa comienza con el entorno de desarrollo y termina con el envío del trabajo al hardware cuántico real.

Diagrama que muestra el flujo de trabajo del desarrollo de programación cuántica.

Vamos a desglosar los pasos del diagrama.

Elección del entorno de desarrollo

Ejecute los programas cuánticos en su entorno de desarrollo preferido. Puede usar el editor de código en línea en el sitio web de Azure Quantum, los cuadernos de Jupyter Notebook hospedados en el área de trabajo de Azure Quantum en Azure Portal o un entorno de desarrollo local con Visual Studio Code. Para obtener más información, consulte Diferentes formas de ejecutar Q# programas.

Escritura del programa cuántico

Puede escribir programas cuánticos en Q# mediante el Kit de desarrollo de Quantum (QDK). Para empezar, consulte Inicio rápido: Creación del primer Q# programa.

Q#Además de , el QDK ofrece compatibilidad con otros lenguajes para la computación cuántica, como Qiskit y Cirq.

Integración con Python

Puede usarse Q# por sí mismo o junto con Python en varios IDE. Por ejemplo, puede usar un proyecto Q# con un programa host de Python para llamar a operaciones Q# o integrar Q# con Python en Jupyter Notebooks. Para obtener más información, consulte Integración de Q# y Python.

Comando %%qsharp

De forma predeterminada, los Q# programas de Jupyter Notebook usan el ipykernel paquete de Python. Para agregar Q# código a una celda del cuaderno, use el %%qsharp comando , que está habilitado con el qsharp paquete de Python, seguido del Q# código.

Al usar %%qsharp, tenga en cuenta lo siguiente:

  • Primero debe ejecutar import qsharp para habilitar %%qsharp.
  • %%qsharp se refiere a la celda del notebook en la que aparece y cambia el tipo de celda de Python a Q#.
  • No se puede colocar una instrucción de Python antes o después de %%qsharp.
  • Q# el código siguiente %%qsharp debe cumplir la Q# sintaxis. Por ejemplo, use // en lugar de # para indicar comentarios y ; para finalizar líneas de código.

Estimación de recursos

Antes de ejecutarse en hardware cuántico real, debe averiguar si el programa se puede ejecutar en hardware existente y cuántos recursos consumirá.

El estimador de recursos de Azure Quantum permite evaluar decisiones arquitectónicas, comparar tecnologías de cúbits y determinar los recursos necesarios para ejecutar un algoritmo cuántico determinado. Puede elegir entre protocolos predefinidos de tolerancia a errores y especificar suposiciones del modelo de cúbit físico subyacente.

Para más información, consulte Ejecución de la primera estimación de recursos.

Nota:

El estimador de recursos de Azure Quantum es gratuito y no requiere una cuenta de Azure.

Ejecución del programa en simulación

Al compilar y ejecutar un programa cuántico, el QDK crea una instancia del simulador cuántico y pasa el Q# código a él. El simulador utiliza el código de Q# para crear cúbits (simulaciones de partículas cuánticas) y aplicar transformaciones para modificar su estado. Después, los resultados de las operaciones cuánticas del simulador se devuelven al programa. Al aislar el código de Q# en el simulador, se garantiza que los algoritmos sigan las leyes de la física cuántica y que se puedan ejecutar correctamente en los equipos cuánticos.

Envío del programa al hardware cuántico real

Una vez que haya probado el programa en la simulación, puede ejecutarlo en hardware cuántico real. Al ejecutar un programa cuántico en Azure Quantum, creas y ejecutas una tarea. Para enviar un trabajo a los proveedores de Azure Quantum, necesita una cuenta de Azure y un área de trabajo cuántica. Si no tiene un área de trabajo cuántica, consulte Creación de un área de trabajo de Azure Quantum.

Azure Quantum ofrece algunos de los hardware cuánticos más atractivos y diversos. Vea Proveedores de computación cuántica para obtener la lista actual de proveedores de hardware compatibles.

Una vez enviado el trabajo, Azure Quantum administra el ciclo de vida del trabajo, incluida la programación, la ejecución y la supervisión del trabajo. Puede realizar un seguimiento del estado del trabajo y ver los resultados en el portal de Azure Quantum.

Contenido relacionado