Proveedor Quantinuum

Quantinuum proporciona acceso a sistemas de iones atrapados con cúbits totalmente conectados de alta fidelidad y la capacidad de tomar medidas en el circuito medio.

• Editor: Quantinuum
• Identificador de proveedor: quantinuum

Targets

Los siguientes targets están disponibles en este proveedor:

Quantinuum targets corresponde a un QIR Adaptive RI perfil. Para más información sobre este target perfil y sus limitaciones, consulte Descripción target de los tipos de perfil en Azure Quantum.

Todos los circuitos híbridos integrados ahora son compatibles con Quantinuum targets . Para obtener más información sobre el envío de trabajos híbridos integrados, consulte Informática híbrida integrada.

Para empezar a usar el proveedor Quantinuum en Azure Quantum, consulte Introducción a Q# y un cuaderno de Azure Quantum.

Correctores sintácticos

Se recomienda que los usuarios validen primero su código con un Corrector sintáctico. Se trata de una herramienta para comprobar que la sintaxis sea correcta, que la compilación finaliza y que la máquina sea compatible. Los comprobadores de sintaxis usan el mismo compilador que el equipo cuántico que target. Por ejemplo, el comprobador de sintaxis H1-1 usa el mismo compilador que H1-1. La pila de compilación completa se ejecuta con la excepción de las operaciones cuánticas reales. Si el código se compila, el comprobador de sintaxis devuelve un success estado y un resultado de todos los 0s. Si el código no se compila, el comprobador de sintaxis devuelve un estado erróneo y proporciona el error devuelto para ayudar a los usuarios a depurar su sintaxis de circuito. Los correctores sintácticos permiten a los desarrolladores validar su código en cualquier momento, incluso cuando las máquinas están desconectadas.

• Tipo de trabajo: Simulation
• Formatos de datos: honeywell.openqasm.v1, honeywell.qir.v1
• Target IDENTIFICACIÓN:
  • Corrector de sintaxis H1-1: quantinuum.sim.h1-1sc
  • Comprobador de sintaxis H2-1: quantinuum.sim.h2-1sc
• Target Perfil de ejecución: QIR Adaptive RI

El uso de los comprobadores de sintaxis se ofrece de forma gratuita.

Emuladores de System Model H1

Después de validar la sintaxis de su código con un Comprobador de sintaxis, los usuarios pueden aprovechar las ventajas de los emuladores del modelo de sistema H1 de Quantinuum, herramientas de emulación que contienen un modelo físico detallado y un modelo de ruido realista del hardware real del modelo de sistema H1. Los modelos de ruido se derivan de una caracterización detallada del hardware. Los emuladores del modelo de sistema H1 usan una API idéntica para el envío de trabajos como hardware del modelo de sistema H1, lo que permite la transición sin problemas de emulación al hardware. Para ayudar a maximizar la productividad y acortar el tiempo de desarrollo, los emuladores del modelo de sistema H1 están disponibles incluso mientras el hardware está sin conexión.

Puede encontrar más información en la hoja de datos del producto del emulador de System Model H1 que se encuentra en la página System Model H1 .

• Tipo de trabajo: Simulation
• Formato de datos: quantinuum.openqasm.v1
• Target IDENTIFICACIÓN:
  • Emulador H1-1: quantinuum.sim.h1-1e
• Target Perfil de ejecución: QIR Adaptive RI

El uso del emulador de System Model H1 se ofrece de forma gratuita con una suscripción de hardware. Para obtener más información, consulte Precios de Azure Storage.

Emulador de la serie H (basado en la nube)

El emulador de la serie H está disponible de forma gratuita en la página Código con Azure Quantum en el sitio web de Azure Quantum , donde puede escribir código de Q# y enviar sus trabajos al emulador de la serie H de Quantinuum sin una cuenta de Azure. El emulador de la serie H es un emulador cuántico basado en estado que usa un modelo de ruido físico realista y parámetros de error generalizados basados en el rendimiento típico de un equipo cuántico del modelo del sistema H1. La simulación cuántica realizada es la misma que el emulador del modelo de sistema H1, pero la rutina de optimización del circuito clásico se reduce para aumentar el rendimiento. La compatibilidad con la informática híbrida integrada está planeada para una fecha futura.

System Model H1

La generación del modelo de sistema H1 de equipos cuánticos, con tecnología de Honeywell, consta de un dispositivo de carga cuántica (QCCD) con una sección lineal y actualmente incluye una máquina targets: el H1-1. Se recomienda a los usuarios probar la compatibilidad de su código con el H1-1 mediante el envío de trabajos a un comprobador de sintaxis y el emulador del modelo de sistema H1 antes de enviarlos a las target máquinas.

La máquina System Model H1 se actualiza continuamente a lo largo de su ciclo de vida del producto. A los usuarios se les proporciona acceso al hardware más actualizado, avanzado y capaz que haya disponible.

Puede encontrar más información en la hoja de datos del producto System Model H1 que se encuentra en la página System Model H1 .

• Tipo de trabajo: Quantum Program
• Formato de datos: honeywell.openqasm.v1, honeywell.qir.v1
• Target IDENTIFICACIÓN:
  • H1-1: quantinuum.qpu.h1-1
• Target Perfil de ejecución: QIR Adaptive RI

Emulador de System Model H2

Después de validar la sintaxis de su código con el Comprobador de sintaxis H2-1, los usuarios pueden aprovechar el emulador de System Model H2 de Quantinuum, una herramienta de emulación que contiene un modelo físico detallado y un modelo de ruido realista del hardware del modelo del sistema H2 real. Puede encontrar más información sobre el modelo de ruido en la hoja de datos del producto del emulador de System Model H2 que se encuentra en la página System Model H2 . El emulador de System Model H2 usa una API idéntica para el envío de trabajos como hardware system model H2, lo que permite la transición sin problemas de emulación al hardware. Para ayudar a maximizar la productividad y acortar el tiempo de desarrollo, el emulador H2 está disponible incluso mientras el hardware está sin conexión.

• Tipo de trabajo: Simulation
• Formato de datos: quantinuum.openqasm.v1
• Target IDENTIFICACIÓN:
  • Emulador H2-1: quantinuum.sim.h2-1e
• Target Perfil de ejecución: QIR Adaptive RI

El uso del emulador de System Model H2 se ofrece de forma gratuita con una suscripción de hardware. Para obtener más información, consulte Precios de Azure Storage.

Modelo de sistema H2

La generación Quantinuum System Model H2 de equipos cuánticos, con tecnología de Honeywell, está formada por un dispositivo de carga cuántica acoplado (QCCD) con dos secciones lineales conectadas y actualmente tiene 1 máquina, el H2-1. Puede encontrar más información en la hoja de datos del producto System Model H2 que se encuentra en la página System Model H2 . Se recomienda a los usuarios probar la compatibilidad de su código mediante el envío de trabajos a un comprobador de sintaxis y el emulador del modelo de sistema H2 antes de enviarlos a las target máquinas.

Si un usuario envía un trabajo a la máquina H2-1 y la máquina H2-1 no está disponible, el trabajo permanece en la cola de esa máquina hasta que la máquina esté disponible.

El hardware del modelo del sistema H2 se actualiza continuamente a lo largo del ciclo de vida del producto. A los usuarios se les proporciona acceso al hardware más actualizado, avanzado y capaz que haya disponible.

• Tipo de trabajo: Quantum Program
• Formato de datos: quantinuum.openqasm.v1
• Target IDENTIFICACIÓN:
  • H2-1: quantinuum.qpu.h2-1
• Target Perfil de ejecución: QIR Adaptive RI

Especificaciones técnicas del modelo del sistema H1 y H2

Los detalles técnicos de System Model H1 y System Model H2 se pueden encontrar en las hojas de datos de producto de Quantinuum en las páginas System Model H1 y System Model H2 junto con vínculos a la especificación de Quantinuum y repositorios de datos de volumen cuántico y cómo citar el uso de sistemas Quantinuum.

Funcionalidades adicionales

Las funcionalidades adicionales disponibles a través de la API Quantinuum se enumeran aquí.

Los usuarios pueden aprovechar estas funcionalidades adicionales a través de funciones de circuito o parámetros de paso a través en los proveedores de Q# y Qiskit de Azure Quantum.

Medición y restablecimiento del circuito medio

Mid-circuit Measurement and Reset (MCMR) permite a los usuarios medir cúbits en medio de un circuito y restablecerlos. Esto permite la funcionalidad para la corrección de errores cuánticos, así como la capacidad de reutilizar cúbits dentro del circuito.

Debido a la estructura de nivel interno de cúbits de iones atrapados, una medida de circuito medio puede dejar el cúbit en un estado no computacional. Todas las medidas del circuito medio deben ir seguidas de un restablecimiento si el cúbit se va a usar de nuevo en ese circuito. Los ejemplos de código siguientes muestran esto.

Cuando se mide un subconjunto de cúbits en medio del circuito, la información clásica de estas mediciones se puede usar para acondicionar elementos futuros del circuito. Los ejemplos también resaltan este uso.

Para obtener información sobre MCMR en los sistemas Quantinuum, consulte las hojas de datos del producto de la serie H en las páginas System Model H1 y System Model H2 .

%%qsharp
import Std.Measurement.*;

operation ContinueComputationAfterReset() : Result[] {
    // Set up circuit with 2 qubits
    use qubits = Qubit[2];

    // Perform Bell Test
    H(qubits[0]);
    CNOT(qubits[0], qubits[1]);

    // Measure Qubit 1 and reset it
    let res1 = MResetZ(qubits[1]);

    // Continue additional computation, conditioned on qubits[1] measurement outcome
    if res1 == One {
         X(qubits[0]);
    }
    CNOT(qubits[0], qubits[1]);

    // Measure qubits and return results
    let res2 = Measure([PauliZ, PauliZ], qubits);
    return [res1, res2];
}

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

# Set up quantum circuit
q = QuantumRegister(2)
c = ClassicalRegister(2)
circuit = QuantumCircuit(q, c)
circuit.name = "MCMR Example with Conditional Logic"

# Perform Bell Test
circuit.h(q[0])
circuit.cx(q[0], q[1])

# Measure and reset Qubit 1
circuit.measure(q[1], c[1])
circuit.reset(q[1])

# Continue additional computation, conditioned on Qubit 1's measurement outcome
circuit.x(q[0]).c_if(c, 1)
circuit.cx(q[0], q[1])

# Measure all qubits
circuit.measure(q, c)

# Print out the circuit
circuit.draw()

Puertas ZZ angulares arbitrarias

El conjunto de puertas nativas de Quantinuum incluye puertas ZZ angulares arbitrarias. Esto es beneficioso para reducir el número de puertas de 2 cúbits para muchos algoritmos cuánticos y secuencias de puertas. Para obtener información sobre las puertas ZZ angulares arbitrarias en los sistemas Quantinuum, consulte las hojas de datos del producto de la serie H en las páginas System Model H1 y System Model H2 .

%%qsharp
import Std.Intrinsic.*;
import Std.Measurement.*;
import Std.Arrays.*;

operation ArbitraryAngleZZExample(theta : Double) : Result[] {
    
    // Set up circuit with 2 qubits
    use qubits = Qubit[2];

    // Create array for measurement results
    mutable resultArray = [Zero, size = 2];

    H(qubits[0]);
    Rz(theta, qubits[0]);
    Rz(theta, qubits[1]);
    X(qubits[1]);

    // Add Arbitrary Angle ZZ gate
    Rzz(theta, qubits[0], qubits[1]);  

    // Measure qubits and return results
    for i in IndexRange(qubits) {
        set resultArray w/= i <- M(qubits[i]);  
    }
    
    return resultArray;
}

from qiskit import QuantumCircuit

theta = 0.25

# Set up quantum circuit
circuit = QuantumCircuit(2, 2)
circuit.name = "Arbitrary Angle ZZ Gate Example"

circuit.h(0)
circuit.rz(theta, 0)
circuit.rz(theta, 1)
circuit.x(1)

# Add arbitrary angle ZZ gate
circuit.rzz(theta, 0, 1)

circuit.measure_all()

Su general (4) Puerta de entrelazamiento

El conjunto de puertas nativas de Quantinuum incluye una puerta su(4) de entrelazamiento general. Tenga en cuenta que los circuitos cuánticos enviados al hardware se vuelven a base a la puerta ZZ totalmente entrelazada y la puerta RZZ angular arbitraria. Los circuitos solo se vuelven a base de la puerta de entrelazamiento general SU(4) si los usuarios lo participarán. Para obtener información sobre el entrelazador general SU(4) en los sistemas Quantinuum, consulte las hojas de datos del producto de la serie H en las páginas System Model H1 y System Model H2 .

%%qsharp
import Std.Math.*;

operation __quantum__qis__rxxyyzz__body(a1 : Double, a2 : Double, a3 : Double, q1 : Qubit, q2 : Qubit) : Unit {
    body intrinsic;
}

operation SU4Example() : Result[] {
    use qs = Qubit[2];
    
    // Add SU(4) gate
    __quantum__qis__rxxyyzz__body(PI(), PI(), PI(), qs[0], qs[1]);
    
    MResetEachZ(qs)
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")

# Update TKET optimization level desired
option_params = {
    "nativetq": `Rxxyyzz`,
    "noreduce": True
}

job = MyTarget.submit(MyProgram, "Submit a program with SU(4) gate", shots = 10, input_params = option_params)
job.get_results()

Parámetros de ruido del emulador

Los usuarios tienen la opción de experimentar con los parámetros de ruido de los emuladores de Quantinuum. Aquí solo se resaltan algunos de los parámetros de ruido disponibles que muestran cómo pasar por los parámetros de los proveedores de Azure Quantum.

Para obtener más información sobre el conjunto completo de parámetros de ruido disponibles, consulte las hojas de datos del producto del emulador de la serie H en las páginas System Model H1 y System Model H2 .

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the System Model H1 Emulator Product Data Sheet
option_params = {
    "error-params": {
        "p1": 4e-5,
        "p2": 3e-3,
        "p_meas": [3e-3, 3e-3],
        "p_init": 4e-5,
        "p_crosstalk_meas": 1e-5,
        "p_crosstalk_init": 3e-5,
        "p1_emission_ratio": 6e-6,
        "p2_emission_ratio": 2e-4
    }
}

job = MyTarget.submit(MyProgram, "Experiment with Emulator Noise Parameters", 
                      shots = 10, 
                      input_params = option_params)
job.get_results()

option_params = {
    "error-model": False 
}

option_params = {
    "simulator": "stabilizer" 
}

# Specify the emulator backend target to submit to
backend = provider.get_backend("quantinuum.sim.1e")

# Update the parameter names desired
# Note: This is not the full set of options available. 
# For the full set, see the System Model H1 Emulator Product Data Sheet
option_params = {
    "error-params": {
        "p1": 4e-5,
        "p2": 3e-3,
        "p_meas": [3e-3, 3e-3],
        "p_init": 4e-5,
        "p_crosstalk_meas": 1e-5,
        "p_crosstalk_init": 3e-5,
        "p1_emission_ratio": 6e-6,
        "p2_emission_ratio": 2e-4
    }
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

option_params = {
    "error-model": False 
}

option_params = {
    "simulator": "stabilizer" 
}

Compilación de TKET en la pila de la serie H

Los circuitos enviados a los sistemas de la serie H quantinuum, excepto los envíos híbridos integrados, se ejecutan automáticamente a través de pasos de compilación TKET para hardware de la serie H. Esto permite optimizar automáticamente los circuitos para sistemas de la serie H y ejecutarse de forma más eficaz.

Puede encontrar más información sobre los pasos de compilación específicos aplicados en la documentación, específicamente en la pytket-quantinuum pytket-quantinuum sección Pasos de compilación.

En la pila de software de la serie H, el nivel de optimización aplicado se establece con el tket-opt-level parámetro . La configuración de compilación predeterminada para todos los circuitos enviados a los sistemas de la serie H es el nivel de optimización 2.

Los usuarios que quieran experimentar con la compilación de TKET pasan y ver qué optimizaciones se aplicarían a sus circuitos antes de enviar cualquier trabajo pueden ver el cuaderno Quantinuum_compile_without_api.ipynb en la pytket-quantinuum carpeta Ejemplos.

Para desactivar la compilación de TKET en la pila, se puede establecer una opción diferente, no-opt, en True dentro option_paramsde . Por ejemplo, "no-opt": True.

Para obtener más información sobre pytket, consulte los vínculos siguientes:

• pytket
• pytket Manual de usuario

import qsharp
import azure.quantum
qsharp.init(target_profile=qsharp.TargetProfile.Base)

%%qsharp
import Std.Measurement.*;
import Std.Arrays.*;
import Std.Convert.*;

operation GenerateRandomBit() : Result {
    use target = Qubit();

    // Apply an H-gate and measure.
    H(target);
    return M(target);
}

MyProgram = qsharp.compile("GenerateRandomBit()")

MyWorkspace = azure.quantum.Workspace(
    resource_id = "",
    location = ""
)

MyTarget = MyWorkspace.get_targets("quantinuum.sim.h1-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}

job = MyTarget.submit(MyProgram, "Experiment with TKET Compilation", shots = 10, input_params = option_params)
job.get_results()

# Specify the backend target to submit to
backend = provider.get_backend("quantinuum.sim.h1-1e")

# Update TKET optimization level desired
option_params = {
    "tket-opt-level": 1
}
backend.options.update_options(**option_params)

# Submit the job
job = backend.run(circuit, shots=100)
print("Job id:", job.id())

Especificaciones técnicas

Los detalles técnicos de system model H1 y H2 y System Model H1 y H2 Emulators se pueden encontrar en las hojas de datos de producto de Quantinuum en la página System Model H1 y System Model H2 junto con vínculos a la especificación de Quantinuum y repositorios de datos de volumen cuántico y cómo citar el uso de sistemas Quantinuum.

Target Disponibilidad

Los equipos cuánticos de la serie H de Quantinuum están diseñados para actualizarse continuamente, lo que permite a los clientes tener acceso a las funcionalidades de hardware más recientes, ya que Quantinuum mejora continuamente las fidelidades de las puertas, los errores de memoria y la velocidad del sistema.

El hardware de Quantinuum recorre cíclicamente los períodos comerciales y los períodos de desarrollo. En los períodos comerciales, el hardware está disponible para procesar los trabajos a través de un sistema de cola. En los períodos de desarrollo, el hardware está sin conexión mientras se aplican las actualizaciones.

Todos los meses se envía un calendario a los usuarios de Quantinuum con información sobre los períodos comerciales y de desarrollo. Si no lo ha recibido, envíe un correo electrónico a QCsupport@quantinuum.com.

El estado de un targetindica su capacidad actual de procesar trabajos. Entre los posibles estados de un target elemento se incluyen:

• Disponible: target está en línea, procesa los trabajos enviados y acepta los nuevos.
• Degradado: target acepta trabajos, pero no los procesa actualmente.
• No disponible: target está sin conexión y no acepta nuevos envíos de trabajo.

Para el equipo targetscuántico Quantinuum , Disponible y Degradado corresponden a períodos comerciales, mientras que No disponible corresponde a los períodos de desarrollo en los que la máquina está sin conexión para las actualizaciones.

La información del estado actual se puede obtener en la pestaña Proveedores de un área de trabajo en Azure Portal.

Precios

Para ver los planes de facturación de Quantinuum, consulte Precios de Azure Quantum.

Límites y cuotas

Se realiza un seguimiento de las cuotas de Quantinuum en función de la unidad de crédito de uso de QPU, crédito cuántico del sistema H (HQC), para trabajos enviados a equipos cuánticos de Quantinuum y HQCs del emulador (eHQCs) para trabajos enviados a emuladores.

Los HQC y los eHQC se usan para calcular el costo de ejecutar un trabajo y se calculan en función de la fórmula siguiente:

$$ HQC = 5 + C(N_{1q} + 10 N_{2q} + 5 N_m)/5000 $$

donde:

• $N_{1q}$ es el número de operaciones de un cúbit en un circuito.
• $N_{2q}$ es el número de operaciones nativas de dos cúbits en un circuito. La puerta nativa equivale a CNOT de hasta varias puertas de un cúbit.
• $N_{m}$ es el número de operaciones de preparación y medida del estado (SPAM) en un circuito, incluida la preparación del estado implícito inicial, las medidas intermedias y finales, y los restablecimientos de estado.
• $C$ es el número de disparos.

Las cuotas se basan en la selección del plan y se pueden aumentar con una incidencia de soporte técnico. Para ver los límites y cuotas actuales, vaya a la hoja Créditos y cuotas y seleccione la pestaña Cuotas del área de trabajo en Azure Portal. Para más información, consulte Cuotas de Azure Quantum.