QubitSparsePauli

class qiskit.quantum_info.QubitSparsePauli(data, /, num_qubits=None)

Bases: object

Un operador de Pauli sin fase almacenado en un formato de qubit disperso.

Representación

Un operador de Pauli es un producto tensorial de operadores de Pauli de un solo qubit de la forma $P = \bigotimes_n A^{(n)}_i$ , para $A^{(n)}_i \in \{I, X, Y, Z\}$ . La representación interna de a QubitSparsePauli almacena sólo los operadores de Pauli de un solo qubit no idénticos.

Internamente, cada operador de Pauli de un solo qubit se almacena con un valor numérico, explícitamente:

Etiqueta	Operador	Valor numérico	`Pauli` atributo
`"I"`	$I$ (identidad)	No guardado.	No guardado.
`"X"`	$X$ (Pauli X)	`0b10` (2)	`X`
`"Y"`	$Y$ (Pauli Y)	`0b11` (3)	`Y`
`"Z"`	$Z$ (Pauli Z)	`0b01` (1)	`Z`

Atributo	Longitud	Descripción
`paulis`	$s$	Cada uno de los operadores de Pauli de un solo qubit sin identidad. Corresponden a los términos sin identidad $A^{(n)}_i$ en la lista, donde las entradas se almacenan en orden creciente $i$ primero, y en orden creciente $n$ dentro de cada término.
`indices`	$s$	El qubit correspondiente ( $n$ ) para cada uno de los operadores en `paulis`. `QubitSparsePauli` requiere que esta lista esté ordenada por términos, y los algoritmos pueden confiar en que esta invariante se mantenga.

El parámetro $s$ es el número total de términos single-qubit no idénticos.

El elemento escalar de la matriz paulis se almacena como un byte numérico. Los valores numéricos están relacionados con la representación Pauli simpléctica que SparsePauliOp utiliza, y son accesibles con acceso nominativo mediante una enumeración:

Pauli

class Pauli

GitHub

En IntEnum que proporciona acceso con nombre a los valores numéricos utilizados para representar cada uno de los términos del alfabeto single-qubit enumerados en Alphabet of single-qubit Pauli operators used in QubitSparsePauliList.

Esta clase se adjunta a QubitSparsePauli. Acceder como QubitSparsePauli.Pauli. Si esto es demasiado teclear, y usted está tratando solamente con QubitSparsePauliList y el nombre Pauli no es ambiguo, puede acortarlo como:

>>> ops = QubitSparsePauli.Pauli
>>> assert ops.X is QubitSparsePauli.Pauli.X

Se puede acceder a todos los valores de la enumeración mediante el acceso a atributos o mediante la indexación por cadena, similar a la de un diccionario:

>>> assert QubitSparsePauli.Pauli.X is QubitSparsePauli.Pauli["X"]

Los bits que representan cada single-qubit Pauli son la representación simpléctica (sin fase) del operador Pauli.

Valores

X

Valor predeterminado: 2

El operador Pauli $X$ . Utiliza la etiqueta de una sola letra "X".

Y

Valor predeterminado: 3

El operador Pauli $Y$ . Utiliza la etiqueta de una sola letra "Y".

Z

Valor predeterminado: 1

El operador Pauli $Z$ . Utiliza la etiqueta de una sola letra "Z".

Cada uno de los atributos tipo array se comporta como una secuencia Python. Puede indexarlas y trocearlas con la semántica list-estándar. El corte de un atributo devuelve un Numpy ndarray que contiene una copia de los datos relevantes con la dirección natural dtype del campo; esto le permite realizar fácilmente operaciones matemáticas con los resultados, como operaciones bit a bit con paulis.

Construcción

QubitSparsePauli define varios constructores. El constructor por defecto intentará delegar en uno de los constructores más específicos, basándose en el tipo de la entrada. Siempre puedes utilizar los constructores específicos para tener más control sobre la construcción.

Método	Resumen
`from_label()`	Convertir una etiqueta de cadena densa en una etiqueta `QubitSparsePauli`.
`from_sparse_label()`	Construye un `QubitSparsePauli` a partir de una tupla de una etiqueta de cadena dispersa y los qubits a los que se aplican.
`from_pauli()`	Elevar una sola `Pauli` en un `QubitSparsePauli`.
`from_raw_parts()`	Construir el operador a partir de las matrices de datos brutos.

new

__new__(data, /, num_qubits=None)

El constructor por defecto de QubitSparsePauli.

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 QubitSparsePauli, en cuyo caso se copia la entrada, o puede ser un formato válido tanto para from_label() o from_sparse_label().
num_qubits (int|None) – Número opcional de qubits para el operador. Para la mayoría de las entradas de datos, esto se puede deducir y no es necesario pasarlo. Sólo es necesario para el formato de etiqueta dispersa. Si se da innecesariamente, debe coincidir con los datos introducidos.

Atributos

indices

Vista de sólo lectura sobre los índices de cada término single-qubit no identitario.

Los índices estarán siempre ordenados.

num_qubits

El número de qubits en los que se define el término.

paulis

Vista de sólo lectura de los términos single-qubit individuales.

Los únicos valores válidos en la matriz son los que tienen un valor Pauli.

Métodos

commutes

commutes(other)

Comprueba si se conmuta con otro qubit sparse pauli.

Parámetros

other (QubitSparsePauli) – el qubit sparse Pauli con el que comprobar la conmutación.

compose

compose(other)

Composición sin fase con otra QubitSparsePauli.

Parámetros

other (QubitSparsePauli) – el qubit sparse Pauli con el que componer.

copy

copy()

Obtenga una copia de este término.

from_label

static from_label(label, /)

Construir a partir de una etiqueta de cadena densa.

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

label (str) – la etiqueta densa.

Ejemplos

>>> QubitSparsePauli.from_label("IIIIXZI")
<QubitSparsePauli on 7 qubits: X_2 Z_1>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert QubitSparsePauli.from_label(label) == QubitSparsePauli.from_pauli(pauli)

from_pauli

static from_pauli(pauli, /)

Construir un QubitSparsePauli a partir de una única Pauli instancia.

Obsérvese que la fase de Pauli se suprime.

Parámetros

pauli (Pauli) – el único Pauli para convertir.

Ejemplos

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> QubitSparsePauli.from_pauli(pauli)
<QubitSparsePauli on 5 qubits: Y_3 X_2 Z_1>
>>> assert QubitSparsePauli.from_label(label) == QubitSparsePauli.from_pauli(pauli)

from_raw_parts

static from_raw_parts(num_qubits, paulis, indices)

Construye un QubitSparsePauli a partir de matrices Numpy sin procesar que coincidan con la representación de datos requerida descrita en la documentación de nivel de clase.

Los datos de cada matriz se copian en asignaciones de espacio Rust nuevas y ampliables.

Parámetros

num_qubits - número de qubits sobre los que actúa el operador.
paulis - lista de los términos single-qubit. Debe ser un array Numpy con dtype uint8 (que es compatible con Pauli).
índices - lista ordenada de los qubits a los que corresponde cada término single-qubit. Debería ser un array Numpy con dtype uint32.

Ejemplos

Construir un operador $Z$ que actúe sobre el qubit 50 de 100 qubits.

>>> num_qubits = 100
>>> terms = np.array([QubitSparsePauli.Pauli.Z], dtype=np.uint8)
>>> indices = np.array([50], dtype=np.uint32)
>>> QubitSparsePauli.from_raw_parts(num_qubits, terms, indices)
<QubitSparsePauli on 100 qubits: Z_50>

from_sparse_label

static from_sparse_label(sparse_label, num_qubits)

Construye un qubit sparse Pauli a partir de una etiqueta sparse, dada como una tupla de una cadena de Paulis, y los índices de los qubits correspondientes.

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

Parámetros

sparse_label (tuple[str, Sequence[int]]) – y los qubits a los que se aplica cada término single-qubit.
num_qubits (int) – el número de qubits sobre los que actúa el operador.

Ejemplos

Construye un Pauli simple:

>>> QubitSparsePauli.from_sparse_label(
...     ("ZX", (1, 4)),
...     num_qubits=5,
... )
<QubitSparsePauli on 5 qubits: X_4 Z_1>

Este método puede replicar el comportamiento de from_label()si el campo qubit-arguments de la tupla se establece en enteros decrecientes:

>>> label = "XYXZ"
>>> from_label = QubitSparsePauli.from_label(label)
>>> from_sparse_label = QubitSparsePauli.from_sparse_label(
...     (label, (3, 2, 1, 0)),
...     num_qubits=4
... )
>>> assert from_label == from_sparse_label

identity

static identity(num_qubits)

Obtiene el operador de identidad para un número dado de qubits.

Ejemplos

Consigue la identidad en 100 qubits:

>>> QubitSparsePauli.identity(100)
<QubitSparsePauli on 100 qubits: >

to_pauli

to_pauli()

Devuelve a Pauli que representa el mismo Pauli sin fase.

to_qubit_sparse_pauli_list

to_qubit_sparse_pauli_list()

Convertir este Pauli en un solo elemento QubitSparsePauliList.

¿Le ha resultado útil esta página?

Informe de un error, de una errata o solicite contenido en GitHub.