Personalización de los target parámetros del estimador de recursos

  • Artículo

En este artículo se muestra cómo personalizar los target parámetros del estimador de recursos de Azure Quantum para que coincidan con las características de la máquina que está targetrealizando. El estimador de recursos usa estos parámetros para calcular los recursos necesarios para ejecutar un algoritmo cuántico en un equipo cuántico.

Nota

Si tiene algún problema mientras trabaja con el Estimador de recursos, consulte la página Solución de problemas.

Requisitos previos

Parámetros de destino

El estimador de recursos calcula la estimación de recursos, como el número de cúbits y el tiempo de ejecución, que sería necesario para implementar un algoritmo cuántico determinado mediante una tecnología de cúbit determinada y con un conjunto fijo de opciones arquitectónicas.

Por lo tanto, el estimador de recursos toma un conjunto de entradas, con valores predefinidos para empezar fácilmente:

Parámetros de cúbit físicos

Cuando el estimador de recursos modela las suposiciones de cúbit físico, usa dos conjuntos de instrucciones físicas diferentes para operar los cúbits. El conjunto de instrucciones físicas puede ser basado en puertas o de Majorana. Un conjunto de instrucciones basado en puertas proporciona una medida de un solo cúbit, puertas de un solo cúbit (por ejemplo, puertas T) y puertas de dos cúbits. Un conjunto de instrucciones de Majorana proporciona una puerta T física, una medida de un solo cúbit y operaciones de medida conjunta de dos cúbits.

Puede elegir entre seis parámetros de cúbit predefinidos, cuatro de los cuales tienen conjuntos de instrucciones basados en puertas y dos tienen un conjunto de instrucciones de Majorana. Estos modelos de cúbits abarcan una gama de tiempos de operación y tasas de error, lo que permite una exploración suficiente de los costos de recursos necesarios para lograr aplicaciones cuánticas prácticas.

Parámetro de cúbit Clase de API de Python Descripción
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Los tiempos de operación y las fidelidades pueden corresponder a versiones futuras de cúbits transmon superconductores, o cúbits de número, que normalmente tienen tiempos de funcionamiento en el régimen nanosegundo. Para estos cúbits, se supone que las operaciones de puerta y medición toman 50 ns y 100 n, respectivamente. Se supone que las tasas de error de un solo cúbit y de dos cúbits son $10^{-3}$ como realistas targety $10^{-4}$ como optimista target para un sistema de escalado vertical.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Los tiempos de operación y las fidelidades pueden corresponder a versiones futuras de cúbits basados en iones, que normalmente tienen tiempos de operaciones en el régimen microsegundo. En función de las suposiciones típicas para cúbits de ion, se supone que las operaciones de puerta y medición toman 100 μs. La tasa de errores para las puertas clifford de un solo cúbit es de $10^{-3}$ como realista target y $10^$ como optimistatarget, mientras que la tasa de errores para las puertas no clifford (puerta T) de un solo cúbit es $10^{-4}{-6}$. Para las puertas de dos cúbits, la tasa de errores es $10^{-3}$ como realista target y $10^{-4}$ como optimista target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Los tiempos de operación y las fidelidades pueden corresponder a versiones mejoradas futuras de cúbits de Majorana. Para estos cúbits, se supone que las operaciones de medición y puerta toman 100 ns. Para tener en cuenta la protección topológica en el hardware, se supone que las tasas de error de medición conjunta de un solo cúbit y dos cúbits (velocidades de error clifford) son $10^{-4}$ como realista targety $10^{-6}$ como optimista target. Las operaciones que no son clifford en esta arquitectura no tienen protección topológica, la tasa de errores de las puertas T físicas que no son Clifford es del 5 %.

Nota

A menos que se especifique otro valor, el valor predeterminado para el modelo de cúbits es "qubit_gate_ns_e3".

Como referencia, los parámetros de cúbit predefinidos completos son los siguientes:

{
    "qubitParams": {
        "name": "qubit_gate_ns_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-3
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_ns_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-4
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e4",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "twoQubitJointMeasurementErrorRate": 1e-4,
        "tGateErrorRate": 0.05
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e6",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-6,
        "twoQubitJointMeasurementErrorRate": 1e-6,
        "tGateErrorRate": 0.01
    }
}

Pasar parámetros de cúbit predefinidos

Hay dos maneras de especificar mediante programación parámetros de cúbit predefinidos. Puede seleccionar el nombre del modelo de cúbit para la qubitParams clase al ejecutar qsharp.estimate. Por ejemplo, para seleccionar "qubit_maj_ns_e6" el parámetro de cúbit, escriba:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e6"
                    },
                })

También puede pasar los parámetros de cúbit a la EstimatorParams clase mediante QubitParams. Por ejemplo, para seleccionar MAJ_NS_E6 el parámetro de cúbit, escriba:

from qsharp.estimator import EstimatorParams, QubitParams

params = EstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E6 # qubit_maj_ns_e6 qubit parameter

qsharp.estimate("RunProgram()", params=params)

Personalización de parámetros de cúbit predefinidos

Puede personalizar los parámetros de cúbit predefinidos especificando el nombre y actualizando cualquiera de los demás valores. Por ejemplo, para reducir la tasa de errores de la medida conjunta de dos cúbits en "qubit_maj_ns_e4", escriba:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e4",
                        "twoQubitJointMeasurementErrorRate": 1e-5,
                    },
                })

O bien, puede pasar las instrucciones en forma de una lista.

from qsharp.estimator import EstimatorParams, QubitParams

params = MicrosoftEstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Parámetros de cúbit para cúbits basados en puertas

Identificador de Python Tipo de datos Descripción
name string Nombre del modelo de cúbits
instruction_set "gate_based" Tecnología de cúbit subyacente
one_qubit_measurement_time cadena de tiempo Tiempo de operación para la medición de un solo cúbit ($t_{\rm meas}$) en ns
one_qubit_gate_time cadena de tiempo Tiempo de operación para la puerta de un solo cúbit ($t_{\rm gate}$) en ns
two_qubit_gate_time cadena de tiempo Tiempo de operación para la puerta de dos cúbits en ns
t_gate_time cadena de tiempo Tiempo de operación para la puerta no Clifford de un solo cúbit en ns
one_qubit_measurement_error_rate FLOAT Tasa de errores para la medición de un solo cúbit
one_qubit_gate_error_rate FLOAT Tasa de errores para la puerta clifford de un solo cúbit ($p$)
two_qubit_gate_error_rate FLOAT Tasa de errores para la puerta clifford de dos cúbits
t_gate_error_rate FLOAT Tasa de errores para preparar el estado no Clifford de un solo cúbit ($p_T$)
idle_error_rate FLOAT Tasa de errores correspondiente al idling

En el código siguiente se muestra cómo especificar parámetros de cúbit personalizados para un conjunto de instrucciones basado en puertas:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "gate_based"
params.qubit_params.t_gate_error_rate = 0.03
params.qubit_params.t_gate_time = "10 ns"
params.qubit_params.idle_error_rate = 0.02

Nota

Cuando no se especifica, los valores de two_qubit_gate_time y t_gate_time de forma predeterminada son one_qubit_gate_time, los valores de two_qubit_gate_error_rate y t_gate_error_rate el valor predeterminado one_qubit_gate_error_ratees y el valor predeterminado one_qubit_measurement_error_ratede idle_error_rate para .

Parámetros de cúbit para cúbits de Majorana

Identificador de Python Tipo de datos Descripción
name string Nombre del modelo de cúbits
instruction_set "majorana" Tecnología de cúbit subyacente
one_qubit_measurement_time cadena de tiempo Tiempo de operación para la medición de un solo cúbit ($t_{\rm meas}$) en ns
two-qubit_joint_measurement_time cadena de tiempo Tiempo de operación para la medición de dos cúbits en ns
t_gate_time cadena de tiempo Tiempo de operación para la puerta no Clifford de un solo cúbit en ns
one_qubit_measurement_error_rate FLOAT Tasa de errores para la medición de un solo cúbit
two_qubit_joint_measurement_error_rate FLOAT Tasa de errores para la medición de dos cúbits
t_gate_error_rate FLOAT Tasa de errores para preparar el estado no Clifford de un solo cúbit ($p_T$)
idle_error_rate FLOAT Tasa de errores correspondiente al idling

Una plantilla mínima para el conjunto de instrucciones basado en Majorana con todos los valores necesarios es:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "majorana"
params.qubit_params.one_qubit_measurement_time = "10 ns"
params.qubit_params.one_qubit_measurement_error_rate = 0.01

Nota

Cuando no se especifica, los valores de two_qubitJointMeasurementTime y t_gate_time el valor predeterminado de one_qubit_measurement_time, los valores de two_qubit_joint_measurement_error_rate y t_gate_error_rate el valor predeterminado one_qubit_measurement_error_ratede y , y el valor de idle_error_rate los valores predeterminados es one_qubit_measurement_error_rate.

Para one_qubit_measurement_error_rate y two_qubit_joint_measurement_error_rate, puede especificar las tasas de error correspondientes a lecturas de medida, readout, y procesamiento de medidas, process. Estos valores pueden ser <double> números o pares de números. Por ejemplo:

params.qubit_params.two_qubit_joint_measurement_error_rate = \
    MeasurementErrorRate(process=0.00005, readout=0.00007)

Nota

Si especifica un único valor numérico para las tasas de error de un solo cúbit y de dos cúbits en la medida de cúbits de Majorana, las tasas de error de lectura y proceso pueden ser iguales.

Importante

Todos los valores que no se especifican tomarán un valor predeterminado, por ejemplo, especificando "qubit": {"oneQubitGateTime":"200 ns"} modelar un cúbit basado en la puerta en el que tanto el tiempo de puerta de dos cúbits como el tiempo de puerta de un cúbit son 200 ns. En el caso de las unidades, debe especificar cadenas de tiempo, que son números de punto flotante de precisión doble, seguidos de un espacio y la unidad de tiempo para dichos valores, siempre que los sufijos de hora posibles sean ns, µs (o us), msy s.

Esquemas de corrección de errores cuánticos

Para ejecutar aplicaciones cuánticas de escala práctica, las operaciones cuánticas deben tener tasas de error bajas. Normalmente, esta tasa targets de errores supera las funcionalidades de cúbits físicos sin procesar. Para superar esta limitación, la corrección cuántica de errores (QEC) y el cálculo tolerante a errores son dos técnicas cruciales que forman los bloques de creación de equipos cuánticos a gran escala. En primer lugar, QEC nos permite componer varios cúbits físicos propensos a errores y crear un cúbit lógico más confiable que conserva la información cuántica mejor que los cúbits físicos subyacentes.

La distancia del código de corrección de errores (o simplemente distancia de código para abreviar) es un parámetro que controla el número de errores que se pueden corregir. Por lo tanto, la tasa de errores de los cúbits lógicos y el número de cúbits físicos necesarios para codificarlos. Tanto la precisión como el número de cúbits físicos aumentan con la distancia del código. El objetivo es encontrar la distancia mínima del código que puede lograr la tasa de errores necesaria establecida para una aplicación determinada.

El estimador de recursos usa la fórmula siguiente para modelar tasas de error lógicas mediante un modelo exponencial,

$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$

donde $d$ es la distancia del código, $p$ es la tasa de errores físicos y $p^*$ es el umbral de corrección de errores cuánticos. La tasa de errores físicos $p$ se extrae de los parámetros de cúbit como la tasa de errores en el peor de los casos, cualquier operación física de Clifford en el dispositivo.

En concreto, $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) para parámetros de cúbit con un conjunto de instrucciones basado en puerta y $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) para parámetros de cúbit con un conjunto de instrucciones Majorana. Los esquemas QEC suelen tener un umbral de tasa de errores $p^*$ por debajo del cual la corrección de errores suprime los errores.

Protocolo QEC Clase de API de Python Descripción
"surface_code" SURFACE_CODE El código de superficie basado en puertas se basa en arXiv:1208.0928 y arXiv:1009.3686. El código de superficie majorana se basa en arXiv:1909.03002 y arXiv:2007.00307.
"floquet_code" FLOQUET_CODE Solo para cúbits de Majorana. El código de floquet se basa en arXiv:2202.11829.

Nota

A menos que se especifique otro valor, el valor predeterminado para el esquema QEC es "surface_code".

Los parámetros exactos de cada esquema QEC predefinido (incluido un paso previo $a$, que se puede extraer numéricamente para las simulaciones) son los siguientes.

{
    "qubitParams": {
        "instructionSet": "GateBased",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.03,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.0015,
        "crossingPrefactor": 0.08,
        "logicalCycleTime": "20 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "floquet_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.07,
        "logicalCycleTime": "3 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "4 * codeDistance * codeDistance + 8 * (codeDistance - 1)"
    }
}

Pasar esquemas de QEC predefinidos

Hay dos maneras de especificar esquemas de QEC predefinidos. Puede seleccionar el nombre del modelo QEC para la "qecScheme" clase al ejecutar qsharp.estimate. Por ejemplo, para seleccionar el código de floquet, escriba:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code"
                    }
                })

También puede pasar una lista de parámetros de estimación a la EstimatorParams clase mediante la QECScheme clase . Por ejemplo, para seleccionar el código de floquet, escriba:

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.qec_scheme.name = QECScheme.FLOQUET_CODE # floquet code QEC scheme

qsharp.estimate("RunProgram()", params=params)

Personalización de esquemas de QEC predefinidos

Puede personalizar esquemas de QEC predefinidos especificando el nombre y actualizando cualquiera de los demás valores. Por ejemplo, para aumentar el factor previo del cruce en el código de floquet, escriba:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code",
                        "crossingPrefactor": 0.07,
                    }
                })

Nota

Cuando no se especifica, los valores para "logicalCycleTime" y "physicalQubitsPerLogicalQubit" el valor predeterminado de "oneQubitMeasurementTime", el valor de "errorCorrectionThreshold" los valores predeterminados 0.01es y el valor de "crossingPrefactor" los valores predeterminados en 0.03.

Personalización de los esquemas de QEC

El estimador de recursos puede abstraer un esquema QEC personalizado basado en la fórmula anterior proporcionando valores para el "crossingPrefactor" $a$ y el "errorCorrectionThreshold" $p^*$. Además, debe especificar , "logicalCycleTime"es decir, el tiempo de ejecución de una sola operación lógica, que depende de la distancia del código y de las suposiciones de tiempo de operación física de los cúbits físicos subyacentes. Por último, una segunda fórmula calcula , "physicalQubitsPerLogicalQubit"es decir, el número de cúbits físicos necesarios para codificar un cúbit lógico en función de la distancia del código.

Puede usar el código siguiente como plantilla para esquemas QEC:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "crossingPrefactor": <double>,
                        "errorCorrectionThreshold": <double>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })

Dentro de las fórmulas, puede usar las variables one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timey two_qubit_joint_measurement_time, cuyos valores se toman del campo correspondiente de los parámetros de cúbit físico, así como la variable eccDistance para la distancia de código calculada para el cúbit lógico, en función de las propiedades del cúbit físico, el umbral de corrección de errores y el prefactor de cruce. Las variables de hora y eccDistance se pueden usar para describir la logicalCycleTime fórmula. Para la fórmula physicalQubitsPerLogicalQubit solo eccDistance se puede usar .

Presupuesto de errores

El presupuesto total de errores $\epsilon$ establece el error tolerado general para el algoritmo, es decir, la probabilidad de error permitida del algoritmo. Su valor global debe estar comprendido entre 0 y 1 y el valor predeterminado es 0,001, que corresponde al 0,1 %. En otras palabras, el algoritmo puede producir un error máximo de una vez en 1000 ejecuciones. Este parámetro es muy específico de la aplicación.

Por ejemplo, si está ejecutando el algoritmo de Shor para factorizar enteros, se puede tolerar un valor grande para el presupuesto de errores, ya que se puede comprobar que las salidas son realmente los factores primos de la entrada. Por otro lado, es posible que se necesite un presupuesto de errores más pequeño en el caso de un algoritmo que resuelva un problema con una solución, que no se puede comprobar de forma eficaz.

El presupuesto de errores corresponde a la suma de tres partes:

$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$

Si no se especifica más, el presupuesto de errores $\epsilon$ se distribuye uniformemente y se aplica a los errores $\epsilon_{\log}$ para implementar cúbits lógicos, el presupuesto de errores $\epsilon_{\rm dis}$ genera estados T a través de la destilación y un presupuesto de errores $\epsilon_{\rm syn}$ para sintetizar puertas de rotación con ángulos arbitrarios.

Tenga en cuenta que para la destilación y la síntesis de rotación, los presupuestos de error respectivos $\epsilon_{\rm dis}$ y $\epsilon_{\rm syn}$ se distribuyen uniformemente entre todos los estados T necesarios y todas las puertas de rotación necesarias, respectivamente. Si no hay puertas de rotación en el algoritmo de entrada, el presupuesto de errores se distribuye uniformemente a errores lógicos y errores de estado T.

Pasar el presupuesto de errores

Hay dos maneras de especificar el presupuesto de errores estableciendo un número entre 0 y 1. Puede pasar el presupuesto de errores al ejecutar qsharp.estimate. Por ejemplo, para seleccionar un presupuesto de error de 1/3, escriba:

qsharp.estimate("RunProgram()", params=
                {'errorBudget': 0.333
                })

También puede pasar los parámetros de presupuesto de errores a la EstimatorParams clase .

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.error_budget = 0.333 # error budget of 1/3

qsharp.estimate("RunProgram()", params=params)

Además, puede especificar individualmente cada componente del presupuesto de errores. La suma de todos los valores es el presupuesto total de errores y debe estar comprendido entre 0 y 1. Si un algoritmo cuántico no contiene estados T ni rotaciones, los valores de t_states y rotations pueden ser 0 respectivamente.

En el código siguiente se muestra cómo especificar el parámetro de presupuesto de errores con estados T y rotaciones:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()
params.error_budget.logical = 0.01
params.error_budget.t_states = 0.02
params.error_budget.rotations = 0.03

Restricciones

Puede usar la "constraints" clase para aplicar restricciones en el nivel de componente de fábrica de T . Al ajustar las restricciones, puede optimizar las estimaciones para reducir el número de cúbits o para reducir el runtime.

Parámetro Tipo de datos Descripción
logical_depth_factor FLOAT Controlar el tiempo de ejecución. Si tiene un valor mayor que 1, el número inicial de ciclos lógicos, también denominado profundidad lógica, se multiplica por este número. Al reducir logical_depth_factor, puede aumentar el número de invocaciones de la factoría de T en un tiempo determinado, lo que da lugar a menos copias de fábrica de T necesarias para producir el mismo número de estados T. Al reducir el número de copias de fábrica de T, el tiempo de ejecución del algoritmo aumenta en consecuencia. El factor de escala del tiempo de ejecución total puede ser mayor, ya que la tasa de errores lógicas necesaria aumenta debido al número adicional de ciclos.
max_t_factories integer Número máximo de copias de fábrica de T. El estimador de recursos determina los recursos necesarios seleccionando el número óptimo de copias de fábrica de T que minimiza el número de cúbits físicos usados, sin tener en cuenta la sobrecarga de tiempo. El max_t_factories parámetro limita el número máximo de copias y, por tanto, ajusta el número de ciclos lógicos en consecuencia. Para obtener más información, consulte Estimación física de fábrica de T.
max_duration time string Tiempo de ejecución máximo para el algoritmo. El estimador de recursos acepta solo una de max_duration las restricciones o max_physical_qubits en el momento, pero no dos. Si max_duration se especifica , el estimador de recursos intenta encontrar la mejor estimación de max_physical_qubits entre las soluciones restringidas por el número máximo especificado.
max_physical_qubits integer Número máximo de cúbits físicos para el algoritmo. El estimador de recursos acepta solo una de max_duration las restricciones o max_physical_qubits en el momento, pero no dos. Si max_physical_qubits se especifica , el estimador de recursos intenta encontrar la mejor estimación de max_duration entre las soluciones restringidas por el número máximo especificado.

En el código siguiente se muestra cómo especificar las restricciones de un algoritmo cuántico:

from qsharp.estimator import EstimatorParams

params = EstimatorParams()

params.constraints.max_duration = "1 s"
params.constraints.logical_depth_factor = 1.5
params.constraints.max_t_factories = 10

Nota

Si el valor proporcionado a max_duration o max_physical_qubits es demasiado pequeño para encontrar una solución factible, el estimador de recursos devuelve un error. Si no se especifican ni max_durationmax_physical_qubits restricciones, el estimador de recursos pretende encontrar una solución con el menor tiempo.

Sugerencia

Puede usar max_duration e max_physical_qubits influir en el espacio de la solución, posiblemente encontrar soluciones con un tiempo de ejecución más largo, pero un número menor de cúbits en comparación con las soluciones sin estas restricciones. Existe un equilibrio entre el tiempo de ejecución y el número de cúbits, y esta compensación puede administrarse eficazmente para algunos algoritmos, con efectos variables en distintos algoritmos. La tabla IV de [arXiv:2211.07629] ilustra el uso eficaz del equilibrio entre el número de cúbits y el tiempo de ejecución para los algoritmos de dinámica cuántica. Para obtener más información, consulte Estimación de recursos cuánticos con el tiempo o el número de restricciones de cúbits de ejemplo.

Unidades de destilación

Puede proporcionar especificaciones para algoritmos de destilación de fábricas de T con la DistillationUnitSpecification clase . La especificación puede ser predefinida o personalizada. Para especificar una especificación predefinida, seleccione el nombre de la unidad de destilación: 15-1 RM o 15-1 space-efficient.

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.name = "15-1 RM" # predefined distillation unit

params.distillation_unit_specifications.append(unit)

En ambos casos, la notación 15-1 significa 15 estados de entrada T y 1 estado de salida T. La unidad de destilación 15-1 space-efficient usa menos cúbits que 15-1 RM, pero requiere más runtime. Para obtener más información, consulte Tabla VI.

Sugerencia

El uso de unidades de destilación predefinidas proporciona un mejor rendimiento en comparación con los personalizados.

Personalización de las unidades de destilación

Puede personalizar sus propias unidades de destilación. Los parámetros exactos de las unidades de destilación son los siguientes.

qsharp.estimate("RunProgram()", params=
                    {"distillationUnitSpecifications": {
                        "displayName": <string>, 
                        "numInputTs": <int>,
                        "numOutputTs": <int>,
                        "failureProbabilityFormula": <string>,
                        "outputErrorRateFormula": <string>,
                        "physicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecificationFirstRoundOverride": <protocol specific parameters>, # Only if "logicalQubitSpecification"
                        }
                })

Se espera que todos los parámetros numéricos sean positivos. displayName especifica cómo se mostrará la unidad de destilación en los resultados de salida.

En el código siguiente se muestra cómo especificar los parámetros de unidad de destilación para un algoritmo cuántico mediante la DistillationUnitSpecification clase y la ProtocolSpecificDistillationUnitSpecification clase .

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification, ProtocolSpecificDistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.display_name = "T"
unit.failure_probability_formula = "c"
unit.output_error_rate_formula = "r"
unit.num_input_ts = 1
unit.num_output_ts = 2

physical_qubit_specification = ProtocolSpecificDistillationUnitSpecification()
physical_qubit_specification.num_unit_qubits = 1
physical_qubit_specification.duration_in_qubit_cycle_time = 2
unit.physical_qubit_specification = physical_qubit_specification

Las fórmulas de failure_probability_formula y output_error_rate_formula son fórmulas personalizadas con operaciones aritméticas básicas, constantes y solo tres parámetros:

  • clifford_error_rate, también se indica como c.
  • readout_error_rate, también se indica como r.
  • input_error_rate, también se indica como z.

Consulte los ejemplos siguientes de fórmulas personalizadas con notación larga y corta. En estos ejemplos se muestran las fórmulas que se usan de forma predeterminada en la implementación estándar.

Parámetro Fórmula larga Fórmula corta
failure_probability_formula "15.0 * input_error_rate + 356.0 * clifford_error_rate" "15.0 * z + 356.0 * c"
output_error_rate_formula "35.0 * input_error_rate ^ 3 + 7.1 * clifford_error_rate" "35.0 * z ^ 3 + 7.1 * c"

Se debe proporcionar al menos uno de los parámetros physical_qubit_specification o logical_qubit_specification . Si solo se proporciona el anterior, la unidad de destilación se puede aplicar a cúbits físicos. Si solo se proporciona este último, la unidad de destilación se puede aplicar a cúbits lógicos. Si se proporcionan ambos, la unidad de destilación se puede aplicar a ambos tipos de cúbits.

El parámetro logical_qubit_specification_first_round_override solo se puede proporcionar si logical_qubit_specification se especifica . Si es así, invalida los valores de logical_qubit_specification en caso de aplicarse en la primera ronda de destilación. El valor <protocol specific parameters> necesario para logical_qubit_specification_first_round_override debe seguir el esquema:

{
    "numUnitQubits": <int>,
    "durationInQubitCycleTime": <double>
}

Estimación de Pareto Frontier

Al calcular los recursos de un algoritmo, es importante tener en cuenta el equilibrio entre el número de cúbits físicos y el tiempo de ejecución del algoritmo. Podría considerar la asignación de tantos cúbits físicos como sea posible para reducir el tiempo de ejecución del algoritmo. Sin embargo, el número de cúbits físicos está limitado por el número de cúbits físicos disponibles en el hardware cuántico. Comprender el equilibrio entre el entorno de ejecución y la escala del sistema es uno de los aspectos más importantes de la estimación de recursos.

La estimación de la frontera de Pareto proporciona varias estimaciones para el mismo algoritmo, cada una de las cuales muestra inconvenientes entre el número de cúbits y el tiempo de ejecución.

Nota

Si ejecuta el estimador de recursos en Visual Studio Code mediante la Q#opción : Calcular estimaciones de recursos, la estimación de frontera de Pareto está habilitada de forma predeterminada.

Si ejecuta el estimador de recursos en Python, debe especificar el "estimateType" parámetro como "frontier".

result = qsharp.estimate("RunProgram()", params=
                    {"qubitParams": { "name": "qubit_maj_ns_e4" },
                    "qecScheme": { "name": "surface_code" },
                    "estimateType": "frontier", # Pareto frontier estimation
                    }
                )

Si desea visualizar los resultados de la estimación de Pareto Frontier, puede usar la EstimatesOverview función . Esta función muestra los resultados de la estimación de frontera en la tabla y un diagrama de tiempo espaciador. Para obtener más información, vea Diagrama de tiempo espaciador.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Nota

Si tiene algún problema al trabajar con el estimador de recursos, consulte la página Solución de problemas o póngase en contacto con AzureQuantumInfo@microsoft.com.

Pasos siguientes