SparsePauliOp

Valor predeterminado: 1e-08

Devuelve los coeficientes de Pauli.

Devuelve una tupla (forma_entrada, forma_salida).

Devuelve el número de qubits si es un operador N-qubit o Ninguno en caso contrario.

Devuelve los Parameters libres en los coeficientes.

Devuelva el PauliList.

Devuelve los qargs para el operador.

Valor predeterminado: 1e-05

Devuelve los ajustes.

El número de términos Pauli de Pauli en el operador.

adjoint()

Devuelve el adjunto del Operador.

apply_layout(layout, num_qubits=None)

Aplicar un diseño de transpilador a este SparsePauliOp

Parámetros

• layout (TranspileLayout |list[int] | None) – Puede ser un TranspileLayout, una lista de números enteros o None. Si tanto layout como num_qubits son «none», se devuelve una copia del operador.
• num_qubits (int | None) – El número de qubits a los que expandir el operador. Si no se proporciona, entonces si layout es un TranspileLayout se utilizará por defecto el número de qubits del circuito de salida del transpilador. Si layout es una lista de enteros, la permutación especificada se aplicará sin ninguna expansión. Si layout es None, el operador se expandirá al número de qubits dado.

Devuelve

Un nuevo SparsePauliOp con el diseño proporcionado aplicado

Tipo de retorno

SparsePauliOp

argsort(weight=False)

Devuelve índices para ordenar las filas de la tabla.

Devuelve la composición de permutaciones en el orden de ordenación por coeficiente y ordenación por Pauli. Utilizando el peso kwarg, la salida puede ordenarse adicionalmente por el número de términos no idénticos en el Pauli, donde el conjunto de todos los Pauli de un peso dado siguen ordenados lexicográficamente.

Ejemplo

He aquí un ejemplo de cómo utilizar SparsePauliOp argsort.

import numpy as np
from qiskit.quantum_info import SparsePauliOp

# 2-qubit labels
labels = ["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"]
# coeffs
coeffs = [2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j]

# init
spo = SparsePauliOp(labels, coeffs)
print('Initial Ordering')
print(spo)

# Lexicographic Ordering
srt = spo.argsort()
print('Lexicographically sorted')
print(srt)

# Lexicographic Ordering
srt = spo.argsort(weight=False)
print('Lexicographically sorted')
print(srt)

# Weight Ordering
srt = spo.argsort(weight=True)
print('Weight sorted')
print(srt)

Initial Ordering
SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
              coeffs=[2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j])
Lexicographically sorted
[4 7 0 1 2 6 5 3]
Lexicographically sorted
[4 7 0 1 2 6 5 3]
Weight sorted
[4 7 3 0 1 2 6 5]

Parámetros

• weight (bool) – ordenar opcionalmente por peso si es True (por defecto: False).
• sorted (By using the weight kwarg the output can additionally be)
• Pauli. (by the number of non-identity terms in the)

Devuelve

los índices para ordenar la tabla.

Tipo de retorno

matriz

assign_parameters(parameters, inplace=False)

Vincula los Parameters libres de los coeficientes a los valores proporcionados.

Parámetros

• parameters (Mapping[Parameter, complex |ParameterExpression] | Sequence[complex |ParameterExpression]) – Los valores a los que se vincularán los parámetros.
• inplace (bool) – Si False, se devuelve una copia del operador con los parámetros vinculados. Si True se modifica el propio operador.

Devuelve

Una copia del operador con parámetros vinculados, si inplace es False, en caso contrario None.

Tipo de retorno

SparsePauliOp | Ninguno

chop(tol=1e-14)

Ponga a 0 las partes real e imaginaria de los coeficientes si < tol en magnitud.

Por ejemplo, el operador que representa 1+1e-17j X + 1e-17 Y con una tolerancia mayor que 1e-17 se reducirá a 1 X mientras que SparsePauliOp.simplify() devolvería 1+1e-17j X.

Si tanto la parte real como la imaginaria de un coeficiente son 0 tras el recorte, el Pauli correspondiente se elimina del operador.

Parámetros

tol (float) – La tolerancia absoluta para comprobar si una parte real o imaginaria debe ponerse a 0.

Devuelve

Este operador con coeficientes picados.

Tipo de retorno

SparsePauliOp

compose(other, qargs=None, front=False)

Devuelve la composición del operador con otro SparsePauliOp.

Parámetros

• other (SparsePauliOp) – un objeto SparsePauliOp.
• qargs (list or None) – una lista de posiciones de subsistemas a las que aplicar otras. Si se aplica «None» a todos los subsistemas (valor predeterminado: None).
• front (bool) – Si es True compone usando el operador derecho de multiplicación, en lugar del izquierdo [por defecto: Falso].

Devuelve

El compuesto SparsePauliOp.

Tipo de retorno

SparsePauliOp

Eleva

QiskitError - si otro no puede convertirse en operador o tiene dimensiones incompatibles para los subsistemas especificados.

conjugate()

Devuelve el conjugado de SparsePauliOp.

copy()

Realiza una copia en profundidad del operador actual.

dot(other, qargs=None)

Devuelve el operador multiplicado por la derecha self * other.

Parámetros

• other (Operator) – un objeto operador.
• qargs (list or None) – una lista de posiciones de subsistemas a las que aplicar otras. Si se aplica «None» a todos los subsistemas (valor predeterminado: None).

Devuelve

La matriz derecha multiplicada Operador.

Tipo de retorno

Operador

equiv(other, atol=None)

Comprueba si dos operadores SparsePauliOp son equivalentes.

Parámetros

• other (SparsePauliOp) – un objeto operador.
• atol (float | None) – Tolerancia numérica absoluta para comprobar la equivalencia.

Devuelve

Verdadero si el operador es equivalente a self.

Tipo de retorno

bool

expand(other)

Devuelve el producto tensorial de orden inverso con otro SparsePauliOp.

Parámetros

other (SparsePauliOp) – un objeto SparsePauliOp.

Devuelve

el producto tensorial $b \otimes a$, donde $a$

es el actual SparsePauliOp, y $b$ es el otro SparsePauliOp.

Tipo de retorno

SparsePauliOp

static from_list(obj, dtype=None, *, num_qubits=None)

Construir a partir de una lista de cadenas de Pauli y coeficientes.

Por ejemplo, el Hamiltoniano de 5 qubits

puede construirse como

from qiskit.quantum_info import SparsePauliOp

# via tuples and the full Pauli string
op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])

Parámetros

• obj (Iterable[Tuple[str, complex]]) – La lista de 2-tuplas que especifican los términos de Pauli.
• dtype (type | None) – Tipo de datos de los coeficientes. Si None (por defecto), el tipo de datos se deduce automáticamente.
• num_qubits (int) – El número de qubits del operador (Por defecto: Ninguno).

Devuelve

La representación SparsePauliOp de los términos de Pauli.

Tipo de retorno

SparsePauliOp

Eleva

• QiskitError - Si se pasa una lista vacía y num_qubits es None.
• QiskitError - Si num_qubits y los objetos de la lista de entrada no coinciden.

static from_operator(obj, atol=None, rtol=None)

Crear a partir de un objeto Operator.

Nótese que el coste de esta construcción es exponencial en general porque el número de términos de Pauli posibles en la descomposición es exponencial en el número de qubits.

Internamente se utiliza una implementación de la "descomposición tensorizada de Pauli" presentada en Hantzko, Binkowski y Gupta (2023).

Parámetros

• obj (Operator) – un operador N-qubit.
• atol (float) – Opcional. Tolerancia absoluta para comprobar si los coeficientes son cero (Por defecto: 1e-8 ). Como la comparación es con cero, en efecto la tolerancia utilizada es el máximo de atol y rtol.
• rtol (float) – Opcional. tolerancia relativa para comprobar si los coeficientes son cero (Por defecto: 1e-5 ). Como la comparación es con cero, en efecto la tolerancia utilizada es el máximo de atol y rtol.

Devuelve

la representación SparsePauliOp del operador.

Tipo de retorno

SparsePauliOp

Eleva

QiskitError - si el operador de entrada no es un operador N-qubit.

static from_sparse_list(obj, num_qubits, do_checks=True, dtype=None)

Construir a partir de una lista de cadenas locales de Pauli y coeficientes.

Cada elemento de la lista es una 3-tupla de una cadena Pauli local, índices donde aplicarla y un coeficiente.

Por ejemplo, el Hamiltoniano de 5 qubits

puede construirse como

from qiskit.quantum_info import SparsePauliOp

# via triples and local Paulis with indices
op = SparsePauliOp.from_sparse_list([("ZX", [1, 4], 1), ("YY", [0, 3], 2)], num_qubits=5)

# equals the following construction from "dense" Paulis
op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])

Parámetros

• obj (Iterable[tuple[str, list[int], complex]]) – La lista 3-tuplas que especifica los Paulis.
• num_qubits (int) – El número de qubits del operador.
• do_checks (bool) – Si se deben realizar comprobaciones de validez en los índices de entrada.
• dtype (type | None) – Tipo de datos de los coeficientes. Si None (por defecto), el tipo de datos se deduce automáticamente.

Devuelve

La representación SparsePauliOp de los términos de Pauli.

Tipo de retorno

SparsePauliOp

Eleva

• QiskitError - Si el número de qubits es incompatible con los índices de los términos de Pauli.
• QiskitError - Si el qubit designado ya está asignado.

static from_sparse_observable(obs)

Inicializar desde a SparseObservable.

Parámetros

obs (SparseObservable) – La dirección SparseObservable para convertir.

Devuelve

A SparsePauliOp versión del observable.

Tipo de retorno

SparsePauliOp

group_commuting(qubit_wise=False)

Particionar un SparsePauliOp en conjuntos de cadenas Pauli conmutativas.

Parámetros

qubit_wise (bool) –

si la regla de conmutación se aplica a todo el operador o a cada qubit. Por ejemplo:

>>> from qiskit.quantum_info import SparsePauliOp
>>> op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])
>>> op.group_commuting()
[SparsePauliOp(["IZ", "ZZ"], coeffs=[0.+2.j, 0.+1j]),
 SparsePauliOp(["XX", "YY"], coeffs=[2.+0.j, 1.+0.j])]
>>> op.group_commuting(qubit_wise=True)
[SparsePauliOp(['XX'], coeffs=[2.+0.j]),
 SparsePauliOp(['YY'], coeffs=[1.+0.j]),
 SparsePauliOp(['IZ', 'ZZ'], coeffs=[0.+2.j, 0.+1.j])]

Devuelve

Lista de SparsePauliOp donde cada SparsePauliOp contiene

operadores de Pauli conmutativos.

Tipo de retorno

lista [ SparsePauliOp ]

input_dims(qargs=None)

Devuelve tupla de dimensión de entrada para subsistemas especificados.

is_unitary(atol=None, rtol=None)

Devuelve True si el operador es una matriz unitaria.

Este método comprueba si el operador compuesto con su adjunto es igual a la identidad, hasta la tolerancia proporcionada. La tolerancia se utiliza al simplificar el operador compuesto y comprobar si el resultado es la identidad.

Parámetros

• atol (float) – Opcional. Tolerancia absoluta para comprobar si los coeficientes son cero (Por defecto: 1e-8 ).
• rtol (float) – Opcional. Tolerancia relativa para comprobar si los coeficientes son cero (Por defecto: 1e-5 ).

Devuelve

True si el operador es unitario, False en caso contrario.

Tipo de retorno

bool

label_iter()

Devuelve un iterador de representación de etiquetas.

Se trata de un iterador perezoso que convierte cada término de SparsePauliOp en una tupla (etiqueta, coeficiente). Para convertir toda la tabla en etiquetas, utilice el método to_labels() .

Devuelve

objeto iterador de etiquetas para el SparsePauliOp.

Tipo de retorno

LabelIterator

matrix_iter(sparse=False)

Devuelve un iterador de representación matricial.

Se trata de un iterador perezoso que convierte cada término de SparsePauliOp en una matriz a medida que se utiliza. Para convertir a una matriz única utilice el método to_matrix() método.

Parámetros

sparse (bool) – opcionalmente, devuelve matrices CSR dispersas si se establece en True; de lo contrario, devuelve matrices de tipo Numpy (por defecto: False)

Devuelve

objeto iterador de matriz para el PauliList.

Tipo de retorno

MatrixIterator

noncommutation_graph(qubit_wise)

Crea el gráfico de no conmutación de este SparsePauliOp.

Esto transforma el problema de agrupación de operadores de medición en un problema de coloreado de grafos. El grafo construido contiene un nodo por cada Pauli. Los nodos se conectarán para dos términos de Pauli cualesquiera que no conmuten.

Parámetros

qubit_wise (bool) – si la regla de conmutación se aplica a todo el operador o a cada qubit.

Devuelve

el grafo de no conmutación con nodos para cada Pauli y aristas

que indica una relación de no conmutación. Cada nodo contendrá el índice del término de Pauli al que corresponde en sus datos. Las aristas del gráfico no contienen datos.

Tipo de retorno

rustworkx.PyGraph

output_dims(qargs=None)

Devuelve tupla de dimensión de salida para subsistemas especificados.

power(n)

Devuelve la composición de un operador consigo mismo n veces.

Parámetros

n (int) – el número de veces que se compone con uno mismo ( n>0 ).

Devuelve

el operador compuesto n veces.

Tipo de retorno

Clifford

Eleva

QiskitError - si las dimensiones de entrada y salida del operador no son iguales, o la potencia no es un entero positivo.

reshape(input_dims=None, output_dims=None, num_qubits=None)

Devuelve una copia superficial con las dimensiones de los subsistemas de entrada y salida remodeladas.

Parámetros

• input_dims (None or tuple) – nuevas dimensiones de entrada del subsistema. Si es Ninguno, se conservarán las atenuaciones de entrada originales [Por defecto: Ninguno].
• output_dims (None or tuple) – nuevas dimensiones de salida del subsistema. Si es Ninguno, se conservarán las atenuaciones de salida originales. [Predeterminado: Ninguno].
• num_qubits (None or int) – remodelar a un operador N-qubit [Por defecto: Ninguno].

Devuelve

devuelve self con las dimensiones de entrada y salida reformadas.

Tipo de retorno

BaseOperator

Eleva

QiskitError - si el tamaño combinado de todas las dimensiones de entrada del subsistema o las dimensiones de salida del subsistema no es constante.

simplify(atol=None, rtol=None)

Simplifique PauliList combinando duplicados y eliminando ceros.

Parámetros

• atol (float) – Opcional. Tolerancia absoluta para comprobar si los coeficientes son cero (Por defecto: 1e-8 ).
• rtol (float) – Opcional. tolerancia relativa para comprobar si los coeficientes son cero (Por defecto: 1e-5 ).

Devuelve

el operador simplificado SparsePauliOp.

Tipo de retorno

SparsePauliOp

sort(weight=False)

Ordena las filas de la tabla.

Después de ordenar los coeficientes usando argsort de numpy, ordena por Pauli. La clasificación de Pauli tiene preferencia. Si Pauli es el mismo, se ordenará por coeficiente. Utilizando el peso kwarg, la salida puede ordenarse adicionalmente por el número de términos no idénticos en el Pauli, donde el conjunto de todos los Pauli de un peso dado siguen ordenados lexicográficamente.

Ejemplo

He aquí un ejemplo de cómo utilizar SparsePauliOp sort.

import numpy as np
from qiskit.quantum_info import SparsePauliOp

# 2-qubit labels
labels = ["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"]
# coeffs
coeffs = [2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j]

# init
spo = SparsePauliOp(labels, coeffs)
print('Initial Ordering')
print(spo)

# Lexicographic Ordering
srt = spo.sort()
print('Lexicographically sorted')
print(srt)

# Lexicographic Ordering
srt = spo.sort(weight=False)
print('Lexicographically sorted')
print(srt)

# Weight Ordering
srt = spo.sort(weight=True)
print('Weight sorted')
print(srt)

Initial Ordering
SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
              coeffs=[2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j])
Lexicographically sorted
SparsePauliOp(['II', 'XI', 'XX', 'XX', 'XX', 'XY', 'XZ', 'YI'],
              coeffs=[4.+0.j, 7.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j, 3.+0.j])
Lexicographically sorted
SparsePauliOp(['II', 'XI', 'XX', 'XX', 'XX', 'XY', 'XZ', 'YI'],
              coeffs=[4.+0.j, 7.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j, 3.+0.j])
Weight sorted
SparsePauliOp(['II', 'XI', 'YI', 'XX', 'XX', 'XX', 'XY', 'XZ'],
              coeffs=[4.+0.j, 7.+0.j, 3.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j])

Parámetros

• weight (bool) – ordenar opcionalmente por peso si es True (por defecto: False).
• sorted (By using the weight kwarg the output can additionally be)
• Pauli. (by the number of non-identity terms in the)

Devuelve

una copia ordenada de la tabla original.

Tipo de retorno

SparsePauliOp

static sum(ops)

Suma de SparsePauliOps.

Se trata de una versión especializada de la función incorporada sum para SparsePauliOp con una sobrecarga menor.

Parámetros

ops (list[SparsePauliOp]) – una lista de SparsePauliOps.

Devuelve

el SparsePauliOp que representa la suma de la lista de entrada.

Tipo de retorno

SparsePauliOp

Eleva

• QiskitError - si la lista de entrada está vacía.
• QiskitError - si la lista de entrada incluye un objeto que no es SparsePauliOp.
• QiskitError - si los números de qubits de los objetos de la lista de entrada no coinciden.

tensor(other)

Devuelve el producto tensorial con otro SparsePauliOp.

Parámetros

other (SparsePauliOp) – un objeto SparsePauliOp.

Devuelve

el producto tensorial $a \otimes b$, donde $a$

es el actual SparsePauliOp, y $b$ es el otro SparsePauliOp.

Tipo de retorno

SparsePauliOp

to_list(array=False)

Convertir en una lista las etiquetas y coeficientes de las cadenas de Pauli.

Para operadores con muchos términos, la conversión utilizando array=True kwarg será más eficiente, ya que asigna memoria para la matriz Numpy completa de etiquetas por adelantado.

Parámetros

array (bool) – devuelve un array Numpy si es True, en caso contrario devuelve una lista (Por defecto: False).

Devuelve

Lista de pares (label, coeff) para las filas de PauliList.

Tipo de retorno

lista o matriz

to_matrix(sparse=False, force_serial=False)

Convertir a una matriz densa o dispersa.

Parámetros

• sparse (bool) – si True devuelve una matriz CSR dispersa, en caso contrario devuelve una matriz Numpy densa (por defecto).
• force_serial (bool) – si True, utiliza una implementación sin hilos, independientemente del estado de las variables de entorno de control de hilos de Qiskit. Por defecto, se utilizará el paralelismo de hilos sobre las CPUs disponibles.

Devuelve

Una matriz densa si sparse=False. csr_matrix: Una matriz dispersa en formato CSR si sparse=True.

Tipo de retorno

matriz

to_operator()

Convertir en un objeto Operador matricial

Tipo de retorno

Operador

to_sparse_list()

Convertir a un formato de lista Pauli dispersa con elementos (pauli, qubits, coeficiente).

transpose()

Devuelve la transposición de SparsePauliOp.