A classe Operator

Versões dos pacotes

O código desta página foi desenvolvido usando os seguintes requisitos. Recomendamos usar estas versões ou mais recentes.

qiskit[all]~=2.3.0

Esta página mostra como usar a classe Operator. Para uma visão geral de alto nível das representações de operadores no Qiskit, incluindo a classe Operator e outras, consulte Visão geral das classes de operadores.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

import numpy as np
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import CXGate, RXGate, XGate
from qiskit.quantum_info import Operator, Pauli, process_fidelity

Converter classes em Operators

Várias outras classes no Qiskit podem ser convertidas diretamente em um objeto Operator usando o método de inicialização do operador. Por exemplo:

• Objetos Pauli
• Objetos Gate e Instruction
• Objetos QuantumCircuit

Note que o último ponto significa que você pode usar a classe Operator como um simulador unitário para calcular a matriz unitária final de um Circuit quântico, sem precisar chamar um Backend simulador. Se o Circuit contiver operações não suportadas, uma exceção será levantada. As operações não suportadas são: measure, reset, operações condicionais, ou um Gate que não possui uma definição de matriz ou decomposição em termos de gates com definições de matriz.

# Create an Operator from a Pauli object

pauliXX = Pauli("XX")
Operator(pauliXX)

Operator([[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
          [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
          [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
          [1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

# Create an Operator for a Gate object
Operator(CXGate())

Operator([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
          [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
          [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

# Create an operator from a parameterized Gate object
Operator(RXGate(np.pi / 2))

Operator([[0.70710678+0.j        , 0.        -0.70710678j],
          [0.        -0.70710678j, 0.70710678+0.j        ]],
         input_dims=(2,), output_dims=(2,))

# Create an operator from a QuantumCircuit object
circ = QuantumCircuit(10)
circ.h(0)
for j in range(1, 10):
    circ.cx(j - 1, j)

# Convert circuit to an operator by implicit unitary simulation
Operator(circ)

Operator([[ 0.70710678+0.j,  0.70710678+0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          ...,
          [ 0.        +0.j,  0.        +0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.70710678+0.j, -0.70710678+0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j]],
         input_dims=(2, 2, 2, 2, 2, 2, 2, 2, 2, 2), output_dims=(2, 2, 2, 2, 2, 2, 2, 2, 2, 2))

Usar Operators em Circuits

Operators unitários podem ser inseridos diretamente em um QuantumCircuit usando o método QuantumCircuit.append. Isso converte o Operator em um objeto UnitaryGate, que é adicionado ao Circuit.

Se o operador não for unitário, uma exceção será levantada. Isso pode ser verificado usando a função Operator.is_unitary(), que retorna True se o operador for unitário e False caso contrário.

# Create an operator
XX = Operator(Pauli("XX"))

# Add to a circuit
circ = QuantumCircuit(2, 2)
circ.append(XX, [0, 1])
circ.measure([0, 1], [0, 1])
circ.draw("mpl")

Note que no exemplo acima o operador é inicializado a partir de um objeto Pauli. Porém, o objeto Pauli também pode ser inserido diretamente no próprio Circuit e será convertido em uma sequência de gates de Pauli de um único Qubit:

# Add to a circuit
circ2 = QuantumCircuit(2, 2)
circ2.append(Pauli("XX"), [0, 1])
circ2.measure([0, 1], [0, 1])
circ2.draw()

┌────────────┐┌─┐
q_0: ┤0           ├┤M├───
     │  Pauli(XX) │└╥┘┌─┐
q_1: ┤1           ├─╫─┤M├
     └────────────┘ ║ └╥┘
c: 2/═══════════════╩══╩═
                    0  1

Combinar Operators

Os operadores podem ser combinados usando vários métodos.

Produto tensorial

Dois operadores $A$ e $B$ podem ser combinados em um operador produto tensorial $A\otimes B$ usando a função Operator.tensor. Note que se tanto $A$ quanto $B$ forem operadores de um único Qubit, então A.tensor(B) = $A\otimes B$ terá os subsistemas indexados como a matriz $B$ no subsistema 0, e a matriz $A$ no subsistema 1.

A = Operator(Pauli("X"))
B = Operator(Pauli("Z"))
A.tensor(B)

Operator([[ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
          [ 0.+0.j, -0.+0.j,  0.+0.j, -1.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
          [ 0.+0.j, -1.+0.j,  0.+0.j, -0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

Expansão tensorial

Uma operação intimamente relacionada é Operator.expand, que age como um produto tensorial, mas na ordem inversa. Portanto, para dois operadores $A$ e $B$ você tem A.expand(B) = $B\otimes A$, onde os subsistemas são indexados como a matriz $A$ no subsistema 0, e a matriz $B$ no subsistema 1.

A = Operator(Pauli("X"))
B = Operator(Pauli("Z"))
A.expand(B)

Operator([[ 0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
          [ 0.+0.j,  0.+0.j, -0.+0.j, -1.+0.j],
          [ 0.+0.j,  0.+0.j, -1.+0.j, -0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

Composição

Você também pode compor dois operadores $A$ e $B$ para realizar multiplicação de matrizes usando o método Operator.compose. A.compose(B) retorna o operador com a matriz $B.A$:

A = Operator(Pauli("X"))
B = Operator(Pauli("Z"))
A.compose(B)

Operator([[ 0.+0.j,  1.+0.j],
          [-1.+0.j,  0.+0.j]],
         input_dims=(2,), output_dims=(2,))

Você também pode compor na ordem inversa aplicando $B$ antes de $A$ usando o argumento front do compose: A.compose(B, front=True) = $A.B$:

A = Operator(Pauli("X"))
B = Operator(Pauli("Z"))
A.compose(B, front=True)

Operator([[ 0.+0.j, -1.+0.j],
          [ 1.+0.j,  0.+0.j]],
         input_dims=(2,), output_dims=(2,))

Composição de subsistemas

Note que a composição anterior requer que a dimensão de saída total do primeiro operador $A$ seja igual à dimensão de entrada total do operador composto $B$ (e, de forma análoga, a dimensão de saída de $B$ deve ser igual à dimensão de entrada de $A$ quando se compõe com front=True).

Você também pode compor um operador menor com uma seleção de subsistemas de um operador maior usando o argumento qargs do compose, com ou sem front=True. Neste caso, as dimensões de entrada e saída relevantes dos subsistemas sendo compostos devem coincidir. Note que o operador menor deve ser sempre o argumento do método compose.

Por exemplo, para compor um Gate de dois Qubits com um operador de três Qubits:

# Compose XZ with a 3-qubit identity operator
op = Operator(np.eye(2**3))
XZ = Operator(Pauli("XZ"))
op.compose(XZ, qargs=[0, 2])

Operator([[ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
           -1.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j, -1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j]],
         input_dims=(2, 2, 2), output_dims=(2, 2, 2))

# Compose YX in front of the previous operator
op = Operator(np.eye(2**3))
YX = Operator(Pauli("YX"))
op.compose(YX, qargs=[0, 2], front=True)

Operator([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j, 0.+0.j],
          [0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+1.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2, 2), output_dims=(2, 2, 2))

Combinações lineares

Os operadores também podem ser combinados usando operadores lineares padrão para adição, subtração e multiplicação escalar por números complexos.

XX = Operator(Pauli("XX"))
YY = Operator(Pauli("YY"))
ZZ = Operator(Pauli("ZZ"))

op = 0.5 * (XX + YY - 3 * ZZ)
op

Operator([[-1.5+0.j,  0. +0.j,  0. +0.j,  0. +0.j],
          [ 0. +0.j,  1.5+0.j,  1. +0.j,  0. +0.j],
          [ 0. +0.j,  1. +0.j,  1.5+0.j,  0. +0.j],
          [ 0. +0.j,  0. +0.j,  0. +0.j, -1.5+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

Um ponto importante é que, enquanto tensor, expand e compose preservam a unitaridade de operadores unitários, as combinações lineares não preservam; portanto, adicionar dois operadores unitários resultará, em geral, em um operador não unitário:

op.is_unitary()

False

Conversão implícita para Operators

Note que para todos os métodos a seguir, se o segundo objeto ainda não for um objeto Operator, ele será implicitamente convertido em um pelo método. Isso significa que matrizes podem ser passadas diretamente sem serem explicitamente convertidas para um Operator antes. Se a conversão não for possível, uma exceção é levantada.

# Compose with a matrix passed as a list
Operator(np.eye(2)).compose([[0, 1], [1, 0]])

Operator([[0.+0.j, 1.+0.j],
          [1.+0.j, 0.+0.j]],
         input_dims=(2,), output_dims=(2,))

Comparar Operators

Os operadores implementam um método de igualdade que pode ser usado para verificar se dois operadores são aproximadamente iguais.

Operator(Pauli("X")) == Operator(XGate())

True

Note que isso verifica se cada elemento de matriz dos operadores é aproximadamente igual; dois unitários que diferem por uma fase global não são considerados iguais:

Operator(XGate()) == np.exp(1j * 0.5) * Operator(XGate())

False

Fidelidade de processo

Você também pode comparar operadores usando a função process_fidelity do módulo de Informação Quântica. Esta é uma quantidade teórica da informação que mede quão próximos dois canais quânticos estão um do outro, e no caso de operadores unitários ela não depende da fase global.

# Two operators which differ only by phase
op_a = Operator(XGate())
op_b = np.exp(1j * 0.5) * Operator(XGate())

# Compute process fidelity
F = process_fidelity(op_a, op_b)
print("Process fidelity =", F)

Process fidelity = 1.0

Note que a fidelidade de processo é geralmente apenas uma medida válida de proximidade se os operadores de entrada forem unitários (ou CP no caso de canais quânticos), e uma exceção é levantada se as entradas não forem CP.

Próximos passos

Recomendações

• Explore a referência da API do Operator.