PauliLindbladMap

__new__(data, /, num_qubits=None)

El constructor por defecto de PauliLindbladMap.

Esto delega en uno de los métodos constructores de conversión explícitos, basándose en el tipo del argumento data . Si se suministra num_qubits y el constructor implicado por el tipo de data no acepta un número, el entero dado debe coincidir con la entrada.

Parámetros

• data - Tipo de datos de la entrada. Puede ser otro PauliLindbladMapen cuyo caso se copia la entrada, o puede ser una lista en un formato válido para from_list() o from_sparse_list().
• num_qubits (int|None) – Número opcional de qubits para el mapa. Para la mayoría de las entradas de datos, esto se puede deducir y no es necesario pasarlo. Sólo es necesario para las listas vacías o el formato sparse-list. Si se da innecesariamente, debe coincidir con los datos introducidos.

El número de qubits sobre los que actúa el mapa.

Esto no puede deducirse de ninguna otra forma o valor, ya que las identidades no se almacenan explícitamente.

El número de términos generadores en el exponente para este mapa.

Las tarifas del mapa.

apply_layout(layout, num_qubits=None)

Aplique un diseño de transpilador a este mapa Pauli Lindblad.

Esto permite reasignar los índices de los qubits, por ejemplo, si el mapa se define en términos de etiquetas de qubits virtuales.

Parámetros

• layout (TranspileLayout |list[int] | None) – La disposición a aplicar. La mayoría de los usos de esta función deben pasar el QuantumCircuit.layout campo de un circuito transpilado para hardware. Además, puede pasar una lista de nuevos índices de qubits. Si se indica explícitamente None, no se aplica ninguna reasignación (pero puede seguir utilizando num_qubits para ampliar el mapa).
• num_qubits (int | None) – El número de qubits al que expandir el mapa. Si no se proporciona, la salida será tan ancha como la entrada TranspileLayouto la misma anchura que la entrada si layout se proporciona de otra forma.

Devuelve

Un nuevo PauliLindbladMap con el diseño proporcionado aplicado.

clear()

Borra todos los términos generadores de este mapa, haciéndolo igual al mapa de identidad de nuevo.

Esto no modifica la capacidad de las asignaciones internas, por lo que es posible que las operaciones posteriores de suma o resta derivadas de la composición no requieran una reasignación.

Ejemplos

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IXXXYY", 2.0), ("ZZYZII", -1)])
>>> pauli_lindblad_map.clear()
>>> assert pauli_lindblad_map == PauliLindbladMap.identity(pauli_lindblad_map.py_num_qubits())

compose(other)

Componer con otro PauliLindbladMap.

Esto añade las matrices internas de self y other, y por lo tanto resulta en un mapa cuyos términos enumerados son los de self seguidos por los de other.

Parámetros

other (PauliLindbladMap) – el mapa Pauli Lindblad para componer.

copy()

Consigue una copia de este mapa de Pauli Lindblad.

Ejemplos

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IXZXYYZZ", 2.5), ("ZXIXYYZZ", 0.5)])
>>> assert pauli_lindblad_map == pauli_lindblad_map.copy()
>>> assert pauli_lindblad_map is not pauli_lindblad_map.copy()

drop_paulis(indices)

Deja a Paulis fuera de este mapa Pauli Lindblad.

Elimina todos los Pauli de los índices dados, sustituyéndolos por una identidad.

El mapa resultante puede contener duplicados, que pueden eliminarse con el método PauliLindbladMap.simplify() método.

Parámetros

indices (Sequence[int]) – Los índices por los que Paulis debe ser descartado.

Devuelve

Un nuevo mapa Pauli Lindblad en el que se han eliminado todos los Pauli de los índices dados.

Ejemplos

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

drop_qubits(indices)

Saca qubits de este mapa Pauli Lindblad, realizando una operación de trazado.

El mapa resultante puede contener duplicados, que pueden eliminarse con el método PauliLindbladMap.simplify() método.

Parámetros

indices (Sequence[int]) – Los índices de los qubits a trazar.

Devuelve

Un nuevo mapa Pauli Lindblad en el que se ha trazado cada Pauli en los índices dados.

Ejemplos

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.drop_qubits([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

static from_components(rates, qubit_sparse_pauli_list)

static from_list(iter, /, *, num_qubits=None)

Construir un mapa Pauli Lindblad a partir de una lista de etiquetas generadoras densas y tasas.

Esto es análogo a SparsePauliOp.from_list(). En este formulario denso, debe suministrar todas las identidades explícitamente en cada etiqueta.

La etiqueta debe ser una secuencia del alfabeto 'IXYZ'. La etiqueta se interpreta de forma análoga a una cadena de bits. En otras palabras, la letra más a la derecha está asociada al qubit 0, y así sucesivamente. Esto es lo mismo que las etiquetas para Pauli y SparsePauliOp.

Parámetros

• iter (list[tuple[str, float]]) – Pares de etiquetas y sus índices asociados en la suma del generador.
• num_qubits (int | None) – No es necesario especificarlo si se está seguro de que iter no es una secuencia vacía, ya que puede deducirse de las longitudes de las etiquetas. Si iter puede estar vacío, debe especificar este argumento para desambiguar sobre cuántos qubits actúa el mapa. Si se indica y iter no está vacío, el valor debe coincidir con la longitud de las etiquetas.

Ejemplos

Construir un mapa de Pauli Lindblad a partir de una lista de etiquetas:

>>> PauliLindbladMap.from_list([
...     ("IIIXX", 1.0),
...     ("IIYYI", 1.0),
...     ("IXXII", -0.5),
...     ("ZZIII", -0.25),
... ])
<PauliLindbladMap with 4 terms on 5 qubits:
    (1)L(X_1 X_0) + (1)L(Y_2 Y_1) + (-0.5)L(X_3 X_2) + (-0.25)L(Z_4 Z_3)>

Utilice num_qubits para desambiguar entradas potencialmente vacías:

>>> PauliLindbladMap.from_list([], num_qubits=10)
<PauliLindbladMap with 0 terms on 10 qubits: 0.0>

Este método es equivalente a las llamadas a from_sparse_list() con el campo explícito qubit-arguments establecido en enteros decrecientes:

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

static from_sparse_list(iter, /, num_qubits)

Construye un mapa Pauli Lindblad a partir de una lista de etiquetas, los qubits a los que se aplica cada elemento y la tasa del término completo.

Esto es análogo a SparsePauliOp.from_sparse_list().

Los campos "labels" e "indices" de las triplas se asocian comprimiéndolos. Por ejemplo, esto significa que una llamada a from_list() puede convertirse a la forma utilizada por este método estableciendo el campo "índices" de cada triple en (num_qubits-1, ..., 1, 0).

Parámetros

• iter (list[tuple[str, Sequence[int], float]]) – triples de etiquetas, los qubits a los que se aplica cada término single-qubit y la tasa del término completo.
• num_qubits (int) – el número de qubits sobre los que actúa el mapa.

Ejemplos

Construye un mapa sencillo:

>>> PauliLindbladMap.from_sparse_list(
...     [("ZX", (1, 4), 1.0), ("YY", (0, 3), 2)],
...     num_qubits=5,
... )
<PauliLindbladMap with 2 terms on 5 qubits: (1)L(X_4 Z_1) + (2)L(Y_3 Y_0)>

Este método puede reproducir el comportamiento de from_list()si el campo qubit-arguments de la tripleta se establece en enteros decrecientes:

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

static from_terms(obj, /, num_qubits=None)

Construya un PauliLindbladMap a partir de términos individuales.

Todos los términos deben tener el mismo número de qubits. Si se proporciona, el argumento num_qubits debe coincidir con los términos.

No se realiza ninguna simplificación como parte de la creación del mapa.

Parámetros

• obj (Iterable[Term]) – Iterable de términos individuales a partir de los cuales se construye el generador de mapas.
• num_qubits (int | None) – El número de qubits sobre los que debe actuar el mapa. Normalmente se deduce de la entrada, pero puede indicarse explícitamente para manejar el caso de un iterable vacío.

Devuelve

El mapa correspondiente.

gamma()

Calcule la dirección $\gamma$ para el mapa.

generators()

Obtén los generadores del mapa.

Se trata de un alias de get_qubit_sparse_pauli_list_copy(), que ofrece un nombre más práctico y acorde con las convenciones de nomenclatura utilizadas en Aer y Runtime para clases similares.

Devuelve

Una copia de las condiciones de uso del generador de mapas.

Tipo de retorno

QubitSparsePauliList

get_qubit_sparse_pauli_list_copy()

Obtener una copia de la lista de qubit sparse pauli del mapa.

static identity(num_qubits)

Obtener el mapa de identidad en el número dado de qubits.

El mapa de identidad no contiene términos generadores y es el elemento de identidad para la composición de dos instancias PauliLindbladMap cualquier cosa compuesta con el mapa de identidad es igual a sí misma.

Ejemplos

Obtén el mapa de identidad en 100 qubits:

>>> PauliLindbladMap.identity(100)
<PauliLindbladMap with 0 terms on 100 qubits: 0.0>

inverse()

Devuelve un nuevo PauliLindbladMap que es el inverso matemático de self.

keep_paulis(indices)

Mantenga cada Pauli en los índices dados y deje todos los demás.

Esto equivale a utilizar PauliLindbladMap.drop_paulis() en el conjunto de índices del complemento.

Parámetros

indices (Sequence[int]) – Los índices para los que deben conservarse los Paulis.

Devuelve

Un nuevo mapa Pauli Lindblad en el que se han mantenido todos los Pauli de los índices dados y se han eliminado todos los demás Pauli.

Ejemplos

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

keep_qubits(indices)

Mantén cada qubit en los índices dados y rastrea todos los demás qubits.

Esto equivale a utilizar PauliLindbladMap.drop_qubits() en el conjunto complementario de índices.

Parámetros

indices (Sequence[int]) – Los índices para los que deben conservarse los qubits.

Devuelve

Un nuevo mapa Pauli Lindblad en el que se han conservado todos los qubits de los índices dados y se han trazado todos los demás qubits.

Ejemplos

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_qubits([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

parity_sample(num_samples, seed=None, scale=None, local_scale=None)

Muestra pares de signos y operadores Pauli del mapa.

Cada signo está representado por un valor booleano, donde True representa -1y False representa +1.

Dada la representación cuasi-probabilística que figura en la documentación a nivel de clase, cada muestra se extrae mediante el siguiente proceso:

• Inicializa el booleano signo, y una QubitSparsePauli al operador de identidad.
• Iterar a través de cada Pauli en el mapa. Utilizando la pseudoprobabilidad asociada a cada operador, elige aleatoriamente entre aplicar el operador o no.
• Si se aplica el operador, actualiza el :class`QubitSparsePauli` multiplicándolo por el Pauli. Si la tasa asociada al Pauli es negativa, invierte el signo booleano.

Los resultados se devuelven como una matriz 1d de booleanos, y el correspondiente qubit muestreado sparse Paulis en forma de un QubitSparsePauliList.

Los argumentos scale y local_scale pueden utilizarse para cambiar las tasas subyacentes utilizadas en el proceso de muestreo sin modificar la instancia actual ni requerir la creación de una nueva. El scale argumento escala todas las tasas mediante un flotante fijo y local_scale escala las tasas término por término.

Parámetros

• num_samples (int) – Número de muestras a extraer.
• seed (int) – Semilla aleatoria.
• scale (float) – Escala que se aplica a todas las tarifas.
• local_scale (list[float]) – Escala local que se aplicará trimestre a trimestre.

Devuelve

La matriz booleana de signos y la lista de qubit sparse paulis.

Tipo de retorno

signos, qubit_sparse_pauli_list

pauli_fidelity(qubit_sparse_pauli)

Calcular la fidelidad Pauli de este mapa para un qubit sparse Pauli.

Para un mapa de Pauli $Q$, la fidelidad con respecto al mapa de Pauli Lindblad $\Lambda$ es el número real $f(Q)$ para el cual $\Lambda(Q) = f(Q) Q$. I.e. cada Pauli es un vector propio del mapa lineal $\Lambda$, y la fidelidad es el valor propio correspondiente. Para un mapa Pauli Lindblad con el conjunto generador $K$ y la función de tasa $\lambda : K \rightarrow \mathbb{R}$, la fidelidad pauli es matemáticamente

donde $\langle P, Q\rangle_{sp}$ es $0$ si $P$ y $Q$ conmutan, y $1$ si no conmutan.

Args: qubit_sparse_pauli ( QubitSparsePauli ): el qubit sparse Pauli para calcular el Pauli

fidelidad de.

probabilities()

Calcula las probabilidades $p_P$ para el mapa. Estas pueden interpretarse como las probabilidades de que cada generador no se aplique, y se definen como independientes del signo de cada tasa de Lindblad.

sample(num_samples, seed=None)

Para PauliLindbladMap casos con tasas puramente no negativas, muestree operadores de Pauli del mapa. Si el mapa tiene tasas negativas, utilice PauliLindbladMap.parity_sample().

Dada la representación cuasi-probabilística que figura en la documentación a nivel de clase, cada muestra se extrae mediante el siguiente proceso:

• Inicializa una instancia de :class`~.QubitSparsePauli` con el operador de identidad.
• Iterar a través de cada Pauli en el mapa. Utilizando la pseudoprobabilidad asociada a cada operador, elige aleatoriamente entre aplicar el operador o no.
• Si se aplica el operador, actualiza el :class`QubitSparsePauli` multiplicándolo por el Pauli.

Los qubit sparse Paulis muestreados se devuelven en forma de a QubitSparsePauliList.

Parámetros

• num_samples (int) – Número de muestras a extraer.
• seed (int) – Semilla aleatoria. El valor predeterminado es None.

Devuelve

La lista de qubit sparse paulis.

Tipo de retorno

qubit_sparse_pauli_list

Eleva

ValueError - Si alguno de los índices del mapa es negativo.

scale_rates(scale_factor)

Devuelve un nuevo PauliLindbladMap con tasas escaladas por factor_escala.

Parámetros

scale_factor (float) – el coeficiente de escala.

signed_sample(num_samples, seed=None)

Pares de signos y operadores de Pauli de muestra del mapa. Tenga en cuenta que la convención de signos booleanos en este método no es estándar. El método preferido para este tipo de muestreo es PauliLindbladMap.parity_sample(), que también ofrece más funciones.

Cada signo está representado por un booleano, con True representando +1, y False representando -1.

Dada la representación cuasi-probabilística que figura en la documentación a nivel de clase, cada muestra se extrae mediante el siguiente proceso:

• Inicializa el booleano signo, y una QubitSparsePauli al operador de identidad.
• Iterar a través de cada Pauli en el mapa. Utilizando la pseudoprobabilidad asociada a cada operador, elige aleatoriamente entre aplicar el operador o no.
• Si se aplica el operador, actualiza el :class`QubitSparsePauli` multiplicándolo por el Pauli. Si la tasa asociada al Pauli es negativa, invierte el signo booleano.

Los resultados se devuelven como una matriz 1d de booleanos, y el correspondiente qubit muestreado sparse Paulis en forma de un QubitSparsePauliList.

Parámetros

• num_samples (int) – Número de muestras a extraer.
• seed (int) – Semilla aleatoria.

Devuelve

La matriz booleana de signos y la lista de qubit sparse paulis.

Tipo de retorno

signos, qubit_sparse_pauli_list

simplify(tol=1e-08)

Suma los términos similares del generador y elimínalos si la tasa resultante tiene un valor absoluto dentro del margen de tolerancia de cero. Esto también elimina los términos cuyo operador de Pauli es proporcional a la identidad, ya que el generador correspondiente es, de hecho, el mapa nulo.

Como efecto secundario, esto ordena los generadores en un orden canónico fijo.

Parámetros

tol (float) – después de sumar términos similares, cualquier tasa cuyo valor absoluto sea inferior a la tolerancia absoluta dada se suprimirá de la salida.

Ejemplos

Utilizando simplify() para comparar dos operadores que representan el mismo mapa, pero que se compararían de forma desigual debido a las pruebas estructurales por defecto:

>>> base = PauliLindbladMap.from_sparse_list([
...     ("XZ", (2, 1), 1e-10),  # value too small
...     ("XX", (3, 1), 2),
...     ("XX", (3, 1), 2),      # can be combined with the above
...     ("ZZ", (3, 1), 0.5),    # out of order compared to `expected`
... ], num_qubits=5)
>>> expected = PauliLindbladMap.from_list([("IZIZI", 0.5), ("IXIXI", 4)])
>>> assert base != expected  # non-canonical comparison
>>> assert base.simplify() == expected.simplify()

Tenga en cuenta que en el ejemplo anterior, los coeficientes se eligen de tal manera que todos los cálculos de punto flotante son exactos, y no hay redondeo intermedio o problemas de asociatividad. Si no se puede garantizar que sea así, la forma más segura es:

>>> left = PauliLindbladMap.from_list([("XYZ", 1.0/3.0)] * 3)   # sums to 1.0
>>> right = PauliLindbladMap.from_list([("XYZ", 1.0/7.0)] * 7)  # doesn't sum to 1.0
>>> assert left.simplify() != right.simplify()
>>> assert left.compose(right.inverse()).simplify() == PauliLindbladMap.identity(left.num_qubits)

to_sparse_list()

Expresa el mapa en términos de un formato de lista dispersa.

Esto puede verse como una contraoperación de PauliLindbladMap.from_sparse_list()sin embargo, no se garantiza que el orden de los términos sea el mismo después de un viaje de ida y vuelta a una lista dispersa.

Ejemplos

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IIXIZ", 2), ("IIZIX", 3)])
>>> reconstructed = PauliLindbladMap.from_sparse_list(pauli_lindblad_map.to_sparse_list(), pauli_lindblad_map.num_qubits)