Introducción al lenguaje de programación cuántica Q#
Q#es un lenguaje de programación de código abierto de alto nivel para desarrollar y ejecutar algoritmos 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 de lenguaje, compilador y tiempo 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.
- Integra la computación cuántica y clásica: la capacidad de realizar cálculos clásicos y cuánticos es esencial en un equipo cuántico universal.
- Respeta las leyes de la física:Q# y los algoritmos cuánticos siguen las reglas de la física cuántica. Por ejemplo, no se puede copiar ni acceder directamente al estado de cúbit en Q#.
Estructura de un Q# programa
Antes de empezar a escribir programas cuánticos, es importante comprender su estructura y componentes. Tenga en cuenta el siguiente Q# programa 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 Superposition 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 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. Cada Q# programa solo puede tener un namespace. Si no se especifica un espacio de nombres, el Q# compilador usa el nombre de archivo como espacio de nombres. Por ejemplo, el Superposition programa podría escribirse 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;
}
La Q# biblioteca estándar tiene espacios de nombres predefinidos que contienen funciones y operaciones que puede usar en programas cuánticos. Para obtener más información, consulte Espacios de nombres integrados.
Puntos de entrada
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.
En el Superposition programa, la operación más descriptiva MeasureOneQubit() es el punto de entrada del programa.
@EntryPoint()
operation MeasureOneQubit() : Result {
...
Sin embargo, el programa también se podría escribir sin el @EntryPoint() atributo cambiando el nombre de la MeasureOneQubit() operación a Main():
// 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
Q#proporciona tipos integrados que son comunes a la mayoría de los lenguajes, incluidos Intlos tipos , DoubleBool, y , y Stringque son 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 uno de dos valores: Zero o One.
En el Superposition programa, la MeasureOneQubit() operación devuelve un Result tipo, que corresponde al tipo de valor devuelto 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);
...
Q# también proporciona tipos que definen intervalos, matrices y tuplas. Podemos definir incluso nuestros propios tipos personalizados.
Asignación de bits cuánticos
En Q#, se asignan cúbits mediante la use palabra clave . Los cúbits siempre se asignan en el $\ket{0}$ estado .
El Superposition programa define un único cúbit:
// 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.
Para obtener más información, vea Use statement( Instrucción Use).
Operaciones cuánticas
Después de asignar un cúbit, puede pasarlo a operaciones y funciones, también conocidos como invocables. Las operaciones son los bloques de creación básicos de un programa de Q#. 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 Superposition programa, la MeasureOneQubit() operación es esencialmente todo el programa. 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 Result tipo de Zero o One.
Para implementar una medida en la base $computacional \lbrace\ket{0},\ket{1}\rbrace$, también puede usar la M operación , que mide un cúbit en la base Z de Pauli. Esto equivale M a Measure([PauliZ], [qubit]).
El Superposition programa 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. Use la Reset operación para restablecer cada cúbit al $\ket{0}$ estado antes de liberarlo 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 integrados
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!");
El Superposition programa 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 Microsoft.Quantum.Measurement espacio de nombres mediante la MResetZ operación para optimizar el Superposition programa. 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);
}
Desarrollo de 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.
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 Q# proyecto con un programa host de Python para llamar Q# a operaciones. También puede integrarse Q# con Python en Jupyter Notebooks. Para obtener más información, consulte Diferentes formas de ejecutar Q# programas.
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 qsharppara habilitar%%qsharp. %%qsharpámbitos de la celda del cuaderno 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
%%qsharpde . - Q# el código siguiente
%%qsharpdebe cumplir la Q# sintaxis. Por ejemplo, use//en lugar de para indicar comentarios y;finalizar líneas de#código.
Nota:
Los cuadernos de Azure en Azure Portal incluyen las versiones más recientes de los qsharp paquetes de Python y azure-quantum , por lo que no es necesario instalar nada. Para más información, consulte Introducción a Q# y cuadernos de Azure Quantum.
Estimación de recursos
Antes de ejecutarse en hardware cuántico real, deberá 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
Puede enviar los Q# programas (también conocidos como trabajos) a Azure Quantum a través de su entorno de desarrollo preferido, tanto local como en línea. Para obtener más información, consulte cómo enviar trabajos de Q#. También puede ejecutar y enviar circuitos cuánticos escritos en los lenguajes Qiskit y Cirq.
Azure Quantum ofrece algunos de los hardware cuánticos más atractivos y diversos disponibles hoy en día desde líderes del sector. Vea Proveedores de computación cuántica para obtener la lista actual de proveedores de hardware compatibles.
Nota:
El destino del emulador de la serie H de Quantinuum basado en la nube está disponible sin una cuenta de Azure. Para enviar un trabajo al resto de 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.
En este diagrama, se muestra el flujo de trabajo básico después de enviar el trabajo:
