SparseObservable

__new__(data, /, num_qubits=None)

El constructor por defecto de SparseObservable.

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 SparseObservableen cuyo caso se copia la entrada, un Pauli o SparsePauliOpen cuyo caso from_pauli() o from_sparse_pauli_op() según corresponda, 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 operador. 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.

Una lista plana de términos single-qubit. Esto es más naturalmente una lista de listas, pero se almacena plana por razones de uso de memoria y localización, con las sublistas denotadas por límites.

Índices que particionan bit_terms y indices en sublistas para cada término individual de la suma. boundaries[0] : boundaries[1] es el rango de índices en bit_terms y indices que corresponden al primer término de la suma. Todos los índices de qubit no especificados son implícitamente la identidad. Es un elemento más largo que coeffsya que boundaries[0] es siempre un cero explícito (para facilitar el algoritmo).

Los coeficientes de cada término abstracto en en la suma. Tiene tantos elementos como términos tiene la suma.

Una lista plana de los índices de qubits sobre los que actúan las entradas correspondientes en bit_terms actúan. Esta lista debe estar siempre ordenada por términos, donde un término es una sublista denotada por boundaries.

Número de qubits sobre los que actúa el operador.

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 en la suma que este operador está rastreando.

adjoint()

Calcular el adjunto de este observable.

Esto está bien definido en el sentido matemático abstracto. Todos los términos del alfabeto single-qubit son autoadjuntos, por lo que el resultado de esta operación es el mismo observable, excepto que sus coeficientes son todos sus conjugados complejos.

Ejemplos

>>> left = SparseObservable.from_list([("XY+-", 1j)])
>>> right = SparseObservable.from_list([("XY+-", -1j)])
>>> assert left.adjoint() == right

apply_layout(layout, num_qubits=None)

Aplique un diseño de transpilador a esto SparseObservable.

Normalmente habrás definido tu observable en términos de los qubits virtuales de los circuitos que utilizarás para preparar estados. Tras la transpilación, los qubits virtuales se asignan a qubits físicos concretos en un dispositivo, que puede ser más amplio que tu circuito. Esa asignación también puede cambiar a lo largo del circuito. Este método transforma el observable de entrada en qubits virtuales en un observable adecuado para aplicar inmediatamente después del circuito físico totalmente transpilado.

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 da explícitamente None, no se aplica ninguna reasignación (pero puede seguir utilizando num_qubits para ampliar el observable).
• num_qubits (int | None) – El número de qubits al que expandir el observable. 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 SparseObservable con el diseño proporcionado aplicado.

as_paulis()

Expresar el observable sólo en términos de Pauli, escribiendo cada proyector como suma de términos de Pauli.

Nótese que no se garantiza el orden de los términos de Pauli resultantes. Utilice SparseObservable.simplify() además para obtener una representación canónica.

Devuelve

El mismo observable, pero expresado sólo en términos de Pauli.

Ejemplos

Reescribir un observable en términos de proyectores en operadores de Pauli:

>>> obs = SparseObservable("+")
>>> obs.as_paulis()
<SparseObservable with 2 terms on 1 qubit: (0.5+0j)() + (0.5+0j)(X_0)>
>>> direct = SparseObservable.from_list([("I", 0.5), ("Z", 0.5)])
>>> assert direct.simplify() == obs.as_paulis().simplify()

Para operadores pequeños, esto se puede utilizar con simplify() como forma canónica única:

>>> left = SparseObservable.from_list([("+", 0.5), ("-", 0.5)])
>>> right = SparseObservable.from_list([("r", 0.5), ("l", 0.5)])
>>> assert left.as_paulis().simplify() == right.as_paulis().simplify()

clear()

Borra todos los términos de este operador, haciéndolo de nuevo igual al operador cero.

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

Ejemplos

>>> obs = SparseObservable.from_list([("IX+-rl", 2.0), ("01YZII", -1j)])
>>> obs.clear()
>>> assert obs == SparseObservable.zero(obs.py_num_qubits())

commutes(other, tol=1e-12)

Comprueba si el observable conmuta con otro.

Parámetros

• other (SparseObservable) – El otro observable con el que comprobar la conmutación.
• tol (float) – Si los coeficientes en el producto de uno mismo y otro están por debajo de la tolerancia (en magnitud), los términos se ignoran.

Devuelve

True si los términos conmutan, hasta la tolerancia, False de lo contrario.

Aumentos

TypeError – Si no other pudiera ser coaccionado para SparseObservable.

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

Componga otro SparseObservable sobre éste.

En términos de álgebras de operadores, la composición corresponde a la multiplicación por la izquierda: c = a.compose(b) corresponde a $C = B A$. En otras palabras, a.compose(b) devuelve un operador que "realiza a, y luego realiza b sobre el resultado". En cambio, el argumento front=True lo convierte en una multiplicación por la derecha.

self y other deben tener el mismo tamaño, a menos que se indique qargs , en cuyo caso other puede ser menor que self, siempre que el número de qubits de other y la longitud de qargs coincidan. qargs nunca puede contener duplicados o índices de qubits que no existan en self.

Tenga en cuenta que esta función puede provocar una explosión exponencial del uso de memoria del observable, ya que el alfabeto de SparseObservable no es cerrado bajo composición; la composición de dos términos de un solo bit puede ser una suma, que multiplica el número total de términos. Este uso de memoria no es necesariamente inherente al observable resultante, pero encontrar una refactorización eficiente de la suma suele ser igualmente difícil desde el punto de vista computacional. Es mejor utilizar el conocimiento del dominio de tus observables para minimizar el número de términos que existen, en lugar de intentar simplificarlos a posteriori.

Parámetros

• other - el observable utilizado para multiplicar por la izquierda self.

• qargs -

  si se indica, los qubits de self que deben asociarse a los qubits de other. Dicho de otro modo: si esto se da, es similar a una implementación más eficiente de:

  self.compose(other.apply_layout(qargs, self.num_qubits))

  ya que no se crea ningún observable temporal para almacenar la forma de disposición aplicada de other.

• front - si True, entonces se multiplica a la derecha por other en lugar de a la izquierda (por defecto False). Los qargs se siguen aplicando a other. Esto es muy útil cuando qargs está establecido, o other puede ser un objeto que debe ser coaccionado a SparseObservable.

conjugate()

Calcular la conjugación compleja de este observable.

Esta operación se define en términos de las convenciones estándar de la matriz de Qiskit, en que la forma de la matriz se toma para estar en la base computacional $Z$. Los términos del alfabeto relacionados con $X$- y $Z$ no se ven afectados por la conjugación compleja, pero los términos relacionados con $Y$ modifican sus términos del alfabeto. Precisamente:

• $Y$ se conjuga con $-Y$
• $\lvert r\rangle\langle r\rvert$ conjugados con $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ conjugados con $\lvert r\rangle\langle r\rvert$

Además, todos los coeficientes están conjugados.

Ejemplos

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.conjugate() == SparseObservable([("III", -1j), ("Ylr", -0.5)])

copy()

Obtener una copia de este observable.

Ejemplos

>>> obs = SparseObservable.from_list([("IXZ+lr01", 2.5), ("ZXI-rl10", 0.5j)])
>>> assert obs == obs.copy()
>>> assert obs is not obs.copy()

evolve(other, /, qargs=None)

Desarrolla este observable mediante un término de Pauli.

Una evolución de la observable $O$ mediante un $P$ de Pauli corresponde a $P^\dagger O P$.

A diferencia de una implementación literal mediante dos composiciones completas, este método realiza la conjugación directamente a nivel de un solo qubit utilizando una tabla de consulta fija. De este modo se evita materializar cualquier término intermedio SparseObservable y se calcula la observable evolucionada en una sola pasada por los términos. self y other debe tener el mismo número de qubits, a menos que qargs se especifique, en cuyo caso other puede ser menor que self, siempre que el número de qubits en other y la longitud de qargs coincidan. qargs especifica qué qubits de self son evolucionados por other.

Actualmente, este método solo admite la evolución mediante un operador de un solo término, lo que significa que other debe ser un operador de Pauli representado por Pauli.

Parámetros

• otro : el operador de Pauli, que se utiliza para conjugar self.
• qargs : si se proporciona, los qubits de self que se van a evolucionar mediante other. La longitud debe coincidir con el número de qubits en other.

Devuelve

Una nueva versión mejorada SparseObservable con conjugaciones aplicadas.

Aumentos

• TypeError – si no other es de tipo Pauli.
• ValueError – si self y other tienen un número diferente de qubits (y no qargs se especifica).
• ValueError – si qargs la longitud no coincide con other el número de qubits.
• ValueError – si qargs contiene duplicados o índices fuera de rango.
• ValueError – si other contiene más de un término.

expand(other, /)

Producto tensorial de orden inverso.

Esto es equivalente a other.tensor(self), excepto que other será primero convertido a SparseObservable si no lo es ya (llamando al constructor por defecto).

Parámetros

otro - el observable a poner en el lado izquierdo del producto tensorial.

Ejemplos

Esto equivale a tensor() con el orden de los argumentos invertido:

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == right.expand(left)

static from_label(label, /)

Construir un observable de un solo término a partir de una etiqueta de cadena densa.

El operador resultante tendrá un coeficiente de 1. La etiqueta debe ser una secuencia del alfabeto 'IXYZ+-rl01'. 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

>>> SparseObservable.from_label("IIII+ZI")
<SparseObservable with 1 term on 7 qubits: (1+0j)(+_2 Z_1)>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

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

Construir un observable a partir de una lista de etiquetas densas y coeficientes.

Es análogo a SparsePauliOp.from_list()salvo que utiliza el alfabeto ampliado de SparseObservable. En este formulario denso, debe suministrar todas las identidades explícitamente en cada etiqueta.

La etiqueta debe ser una secuencia del alfabeto 'IXYZ+-rl01'. 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, complex]]) – Pares de etiquetas y sus coeficientes asociados para sumar. Las etiquetas se interpretan del mismo modo que en from_label().
• num_qubits (int | None) – No es necesario especificarlo si 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 para cuántos qubits es el observable. Si se indica y iter no está vacío, el valor debe coincidir con la longitud de las etiquetas.

Ejemplos

Construir un observable a partir de una lista de etiquetas de la misma longitud:

>>> SparseObservable.from_list([
...     ("III++", 1.0),
...     ("II--I", 1.0j),
...     ("I++II", -0.5),
...     ("--III", -0.25j),
... ])
<SparseObservable with 4 terms on 5 qubits:
    (1+0j)(+_1 +_0) + (0+1j)(-_2 -_1) + (-0.5+0j)(+_3 +_2) + (-0-0.25j)(-_4 -_3)>

Utilice num_qubits para desambiguar entradas potencialmente vacías:

>>> SparseObservable.from_list([], num_qubits=10)
<SparseObservable 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 = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_pauli(pauli, /)

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

El observable de salida tendrá un único término, con un coeficiente unitario dependiente de la fase.

Parámetros

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

Ejemplos

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> SparseObservable.from_pauli(pauli)
<SparseObservable with 1 term on 5 qubits: (1+0j)(Y_3 X_2 Z_1)>
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

static from_raw_parts(num_qubits, coeffs, bit_terms, indices, boundaries, check=True)

Construye un SparseObservable 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 en el observable.

• coeffs - coeficientes complejos de cada término del observable. Debería ser un array Numpy con dtype complex128.

• bit_terms - lista aplanada de los términos single-qubit que comprende todos los términos completos. Debe ser un array Numpy con dtype uint8 (que es compatible con BitTerm).

• índices - lista ordenada por términos de los qubits a los que corresponde cada término de un qubit. Debería ser un array Numpy con dtype uint32.

• límites : los índices que dividen bit_terms y indices en términos. Debería ser un array Numpy con dtype uintp.

• comprobar -

  si True (por defecto), valida que los datos satisfacen todas las garantías de coherencia. Si False, no se realiza ninguna comprobación.

  Aviso

  Si check=False, los bit_terms deben ser absolutamente todos valores válidos de SparseObservable.BitTerm. Si no lo son, puede producirse un comportamiento indefinido en el espacio Rust, invalidando por completo la ejecución del programa.

Ejemplos

Construye una suma de $Z$ en cada qubit individual:

>>> num_qubits = 100
>>> terms = np.full((num_qubits,), SparseObservable.BitTerm.Z, dtype=np.uint8)
>>> indices = np.arange(num_qubits, dtype=np.uint32)
>>> coeffs = np.ones((num_qubits,), dtype=complex)
>>> boundaries = np.arange(num_qubits + 1, dtype=np.uintp)
>>> SparseObservable.from_raw_parts(num_qubits, coeffs, terms, indices, boundaries)
<SparseObservable with 100 terms on 100 qubits: (1+0j)(Z_0) + ... + (1+0j)(Z_99)>

static from_sparse_list(iter, /, num_qubits)

Construye un observable a partir de una lista de etiquetas, los qubits a los que se aplica cada elemento y el coeficiente del término completo.

Es análogo a SparsePauliOp.from_sparse_list()salvo que utiliza el alfabeto ampliado de SparseObservable.

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], complex]]) – triples de etiquetas, los qubits a los que se aplica cada término single-qubit y el coeficiente del término completo.
• num_qubits (int) – el número de qubits del operador.

Ejemplos

Construye un operador simple:

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

Construir el observable de identidad (aunque en realidad, basta con utilizar identity()):

>>> SparseObservable.from_sparse_list([("", (), 1.0)], num_qubits=100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

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

>>> labels = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_sparse_pauli_op(op, /)

Construir un SparseObservable a partir de una SparsePauliOp instancia.

Esta será una traducción en gran medida directa del SparsePauliOpen particular, no hay ninguna suma sobre la marcha de términos similares, ni ningún intento de refactorizar sumas de términos de Pauli en operadores de proyección equivalentes.

Parámetros

op (SparsePauliOp) – el operador a convertir.

Ejemplos

>>> spo = SparsePauliOp.from_list([("III", 1.0), ("IIZ", 0.5), ("IZI", 0.5)])
>>> SparseObservable.from_sparse_pauli_op(spo)
<SparseObservable with 3 terms on 3 qubits: (1+0j)() + (0.5+0j)(Z_0) + (0.5+0j)(Z_1)>

static from_terms(obj, /, num_qubits=None)

Construya un SparseObservable 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 observable.

Parámetros

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

Devuelve

El observable correspondiente.

static identity(num_qubits)

Obtiene el operador de identidad sobre el número dado de qubits.

Ejemplos

Obtén el operador de identidad para 100 qubits:

>>> SparseObservable.identity(100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

pauli_bases()

Obtener un PauliList que representa la base de medida necesaria para cada término (en orden) en este observable.

Por ejemplo, el proyector 0l+ devolverá un Pauli ZXY. El resultado Pauli es denso, en el sentido de que se almacenan identidades explícitas. Una identidad en la salida de Pauli no requiere una medida concreta.

Esto devolverá una entrada en la lista Pauli para cada término de la suma.

Devuelve

la lista de operadores de Pauli que representa las bases de medida necesarias.

Tipo de retorno

PauliList

simplify(tol=1e-08)

Suma todos los términos semejantes en este operador, eliminándolos si el coeficiente complejo resultante tiene un valor absoluto dentro de la tolerancia de cero.

Como efecto secundario, esto ordena el operador en orden canónico.

Parámetros

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

Ejemplos

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

>>> base = SparseObservable.from_sparse_list([
...     ("XZ", (2, 1), 1e-10),  # value too small
...     ("+-", (3, 1), 2j),
...     ("+-", (3, 1), 2j),     # can be combined with the above
...     ("01", (3, 1), 0.5),    # out of order compared to `expected`
... ], num_qubits=5)
>>> expected = SparseObservable.from_list([("I0I1I", 0.5), ("I+I-I", 4j)])
>>> 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 = SparseObservable.from_list([("XYZ", 1.0/3.0)] * 3)   # sums to 1.0
>>> right = SparseObservable.from_list([("XYZ", 1.0/7.0)] * 7)  # doesn't sum to 1.0
>>> assert left.simplify() != right.simplify()
>>> assert (left - right).simplify() == SparseObservable.zero(left.num_qubits)

tensor(other, /)

Producto tensorial de dos observables.

La ordenación de bits se define de tal manera que los índices de qubits del argumento seguirán siendo los mismos, y los índices de self se desplazarán por el número de qubits en other. Esta es la misma convención utilizada por el resto de los operadores de Qiskit quantum_info de Qiskit.

Esta función se utiliza para el operador infijo ^ . Si utiliza este operador, tenga en cuenta que las reglas de precedencia de operadores de Python pueden hacer que el orden de evaluación sea diferente al esperado. En concreto, el operador + se une más estrechamente que ^, al igual que * se une más estrechamente que +. Utilice paréntesis para fijar el orden de evaluación, si es necesario.

El argumento se convertirá en SparseObservable utilizando su constructor por defecto, si no está ya en la forma correcta.

Parámetros

otro - el observable que hay que poner en el lado derecho del producto tensorial.

Ejemplos

El orden de bits es tal que el producto tensorial de dos observables hechos a partir de una sola etiqueta "se parece" a un observable hecho concatenando las dos cadenas:

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == SparseObservable.from_label("XYZ+-IIrl")

También se puede utilizar el operador infijo ^ para productos tensoriales, que de forma similar lanzará el lado derecho de la operación si no es ya un SparseObservable:

>>> assert SparseObservable("rl") ^ Pauli("XYZ") == SparseObservable("rlXYZ")

to_sparse_list()

Expresar el observable en términos de un formato de lista dispersa.

Esto puede verse como una contraoperación de SparseObservable.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

>>> obs = SparseObservable.from_list([("IIXIZ", 2j), ("IIZIX", 2j)])
>>> reconstructed = SparseObservable.from_sparse_list(obs.to_sparse_list(), obs.num_qubits)

transpose()

Calcular la transposición matricial de este observable.

Esta operación se define en términos de las convenciones estándar de la matriz de Qiskit, en que la forma de la matriz se toma para estar en la base computacional $Z$. Los términos del alfabeto relacionados con $X$- y $Z$ no se ven afectados por la transposición, pero los términos relacionados con $Y$ modifican sus términos del alfabeto. Precisamente:

• $Y$ se transpone a $-Y$
• $\lvert r\rangle\langle r\rvert$ se transpone a $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ se transpone a $\lvert r\rangle\langle r\rvert$

Ejemplos

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.transpose() == SparseObservable([("III", 1j), ("Ylr", -0.5)])

static zero(num_qubits)

Obtiene el operador cero sobre el número dado de qubits.

El operador cero es el operador cuyo valor de expectativa es cero para todos los estados cuánticos. No tiene condiciones. Es el elemento de identidad para la suma de dos SparseObservable instancias; cualquier cosa añadida al operador cero es igual a sí misma.

Si desea que el proyector en el estado de todos los ceros, utilice:

>>> num_qubits = 10
>>> all_zeros = SparseObservable.from_label("0" * num_qubits)

Ejemplos

Obtén el operador cero para 100 qubits:

>>> SparseObservable.zero(100)
<SparseObservable with 0 terms on 100 qubits: 0.0>