Nota

Esta página foi gerada a partir de tutorials/noise/9_entanglement_verification.ipynb.

Execute interativamente no IBM Quantum lab.

Verificação De Entrelaçamento¶

Introdução ao Estado GHZ¶

O estado The Greenberger-Horne-Zeilinger (GHZ) é um entrelaçamento \(n\)-qubit melhor definido pelo seguinte vetor de estado:

\[|{\rm GHZ} \rangle = \frac{|0 \rangle ^{\otimes n} + |1 \rangle ^{\otimes n}}{\sqrt{2}} , n > 2\]

A caracterização do Estado GHZ é muito útil na avaliação de interações entre múltiplos qubits, cuja robustez é fundamental para o desenvolvimento de computadores quânticos de grande escala.

Caracterizando um estado quântico¶

Any mixed quantum state can be identified by a density matrix, defined as \(\rho = \sum_{i} p_i |\psi_{i} \rangle \langle \psi_{i}|\), where \(|\psi_{i} \rangle\) are the pure quantum states forming the mixture and \(0 < p_i \le 1\), \(\sum_{i} p_i = 1\) are the classical probabilities to be in state \(|\psi_{i} \rangle\). We denote the pure density matrix of an ideal GHZ State by \(\rho_{p} \equiv |{\rm GHZ} \rangle \langle {\rm GHZ}|\). We want to see how close this matrix is to the density matrix of a GHZ State as produced in an experiment, \(\rho_{T}\). One method to quantify this similarity is to calculate the fidelity between the states, \(F(\rho_{p},\rho_{T})\)

\[F = \Big[ Tr \sqrt{\sqrt{\rho_{p}}\rho_{T}\sqrt{\rho_{p}}} \Big] ^{2}\]

Este tutorial tem dois objetivos: vamos explorar maneiras em que podemos caracterizar o Estado GHZ, e formas nas quais podemos usar ferramentas de mitigação de erros do Ignis para aumentar a fidelidade de leitura, independentemente do método de caracterização

Antes de irmos mais longe, vamos importar tudo o que precisaremos do Qiskit básico:

[1]:

from qiskit import IBMQ, execute
from qiskit import Aer
from qiskit import QuantumRegister
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.providers.aer import noise
from qiskit import quantum_info
from qiskit import visualization

import numpy as np
import matplotlib.pyplot as plt

%matplotlib inline

As duas próximas funções são do ignis. A primeira é para a técnica geral de mitigação de erros, e a segunda é especificamente para a tomografia quântica

[2]:

from qiskit.ignis.mitigation.measurement import (complete_meas_cal, tensored_meas_cal,
                                                 CompleteMeasFitter, TensoredMeasFitter)
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter

The following import from the entanglement package contains information needed to create, parallelize and analyze GHZ State circuits

[3]:

from qiskit.ignis.verification.entanglement.parallelize import *
from qiskit.ignis.verification.entanglement.linear import *
from qiskit.ignis.verification.entanglement.analysis import Plotter

Preparando um Estado GHZ¶

Vamos primeiro ver como preparar um estado GHZ:

Digamos que temos um sistema de \(n\) qubits, todos preparados no estado \(|0\rangle\):

\[|\psi \rangle = |00...0\rangle\]

Aplicamos uma porta Hadamard ao primeiro qubit: \(|0\rangle \longrightarrow \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)\). Nosso estado agora se parece com:

\[|\psi \rangle = \frac{|00...0\rangle + |10...0\rangle}{\sqrt{2}}\]

Aplicando neste estado uma sequência de \(n-1\) portas CNOT entre os qubits \(n^{th}\) e \((n+1)^{th}\) para \(n = 0 \ldots n-1\) deixa o qubit \(n+1\) em \(|0\rangle\) se o \(n^{th}\) estiver em \(|0\rangle\), e em \(|1\rangle\) se o \(n^{th}\) estiver em \(|1\rangle\), criando assim o Estado GHZ:

\[|GHZ \rangle = \frac{|00...0\rangle + |11...1\rangle}{\sqrt{2}} \equiv \frac{|0 \rangle ^{\otimes n} + |1 \rangle ^{\otimes n}}{\sqrt{2}}\]

A função a seguir cria esse circuito “linear” que pode medir o Estado GHZ:

[4]:

qn = 5 #creating a 5 qubit GHZ state
circ_simple = get_ghz_simple(qn,measure=True)

/home/computertreker/git/qiskit/qiskit-tutorial/release/lib/python3.9/site-packages/qiskit/ignis/verification/entanglement/linear.py:84: DeprecationWarning: The QuantumCircuit.__add__() method is being deprecated.Use the compose() method which is more flexible w.r.t circuit register compatibility.
  circ = circ + meas
/home/computertreker/git/qiskit/qiskit-tutorial/release/lib/python3.9/site-packages/qiskit/circuit/quantumcircuit.py:869: DeprecationWarning: The QuantumCircuit.combine() method is being deprecated. Use the compose() method which is more flexible w.r.t circuit register compatibility.
  return self.combine(rhs)

[5]:

circ_simple.draw(output='mpl')

[5]:

../../_images/tutorials_noise_9_entanglement_verification_8_0.png

../../_images/tutorials_noise_9_entanglement_verification_8_1.png

Caracterização, Parte I¶

Coerência Quântica Múltipla (MQC)¶

Multiple Quantum Coherence (MQC) works by taking the preliminary preparation of an \(n\) qubit GHZ State, and rotating each of the qubit states around the z axis by a phase \(\phi\). After that, we apply a X gate, i.e., a \(\pi\) pulse around the x axis. Then, we apply the inverse of the operations we originally applied to get the GHZ state. In an ideal situation the final state is \(|\psi \rangle = \frac{|0 \rangle ^{\otimes n} + e^{i n \phi}|1 \rangle ^{\otimes n}}{\sqrt{2}}\). We can ideally observe the phase collected by projecting \(|\psi \rangle\) onto the state \(|0 \rangle ^{\otimes n}\). This technique is reminiscent of an echo sequence, and has been shown to substantially improve the fidelity during readout.

A função abaixo cria um circuito de MQC linear. Da mesma forma que todos os circuitos daqui em diante, é possível alterar o argumento full_measurement para alternar entre a medição completa de todos os qubits ou a medição apenas do qubit de controle. A medição completa produz resultados mais precisos, mas para mais de 7 qubits, recomenda-se configurá-la como falso, e observar apenas as oscilações entre os estados '0' e '1'.

[6]:

circ_mqc = get_ghz_mqc_para(qn, full_measurement=True)

/home/computertreker/git/qiskit/qiskit-tutorial/release/lib/python3.9/site-packages/qiskit/ignis/verification/entanglement/linear.py:142: DeprecationWarning: The QuantumCircuit.__iadd__() method is being deprecated. Use the compose() (potentially with the inplace=True argument) and tensor() methods which are more flexible w.r.t circuit register compatibility.
  circ += circinv
/home/computertreker/git/qiskit/qiskit-tutorial/release/lib/python3.9/site-packages/qiskit/circuit/quantumcircuit.py:876: DeprecationWarning: The QuantumCircuit.extend() method is being deprecated. Use the compose() (potentially with the inplace=True argument) and tensor() methods which are more flexible w.r.t circuit register compatibility.
  return self.extend(rhs)

[7]:

circ_mqc[0].draw(output='mpl')

[7]:

../../_images/tutorials_noise_9_entanglement_verification_11_0.png

../../_images/tutorials_noise_9_entanglement_verification_11_1.png

After running experiments on this MQC circuit, we can pick a state to observe oscillations as we sweep \(\phi\) from \(0\) to \(2 \pi\). Our signal in theory should follow \(S(\phi) = \frac{1}{2}(1+\cos(n \phi))\). We then perform a Discrete Fourier Transform (DFT: \(I_{v}=(1/N)|\sum_{\phi}e^{iv\phi}S(\phi)\)) to extract the Fidelity of the state, defined by the bounds \(2\sqrt{I_{n}} \leq F \leq \sqrt{I_{0}/2}+ \sqrt{I_{n}}\); if desired, an actual value for the fidelity can be obtained: \(F = \frac{1}{2}(P_{00...0}+P_{11...1})+\sqrt{I_{n}})\) (arXiv:1905.05720).

Oscilações de Paridade¶

The next method we use to characterize the GHZ state is parity oscillations. After preparing a GHZ state, we apply a combination of rotations about the x and y axes to create various superposition states as a function of \(\phi\): \(U(\phi) = \otimes_{j}^{N} e^{i\frac{\pi}{4}(\cos(\phi)\sigma_{x}^{j}+\sin(\phi)\sigma_{y}^{j})}\). We then measure the expectation value \(\langle \otimes_{j}^{N} \sigma_{z}^{j} \rangle_{\phi}\) as a function of \(\phi\), which in theory should lead to parity oscillations between 1 and -1.

A função a seguir gera um circuito que é o equivalente de Oscilação de Paridade do circuito MQC dado acima

[8]:

circ_po = get_ghz_po_para(qn)

[9]:

circ_po[0].draw(output='mpl')

[9]:

../../_images/tutorials_noise_9_entanglement_verification_15_0.png

../../_images/tutorials_noise_9_entanglement_verification_15_1.png

Podemos obter a fidelidade para oscilações de paridade \(S_{\phi}\) from \(F = \frac{1}{2}(P_{00...0}+P_{11...1}+C)\), na qual \(C\), a coerência é definida como \(2\sqrt{I_{n}}\), seguindo a mesma convenção para o DFT como com o método MQC.

Tomografia¶

A tomografia mede a matriz densidade produzindo muitos estados nominalmente idênticos e medindo as instâncias dos estados em diferentes bases. O resultado ideal de um estado GHZ são quatro elementos da matriz densidade iguais nos 4 cantos da base de produto tensorial, com todos os outros elementos desaparecendo. Embora a fidelidade possa ser prontamente calculada por este método, o método é lento (requer um número exponencial de medições em n), e toma tempos proibitivamente longos se n for maior que 7 ou próximo. Não obstante, mostraremos abaixo como executar este método já que ele é relevante para pequenos números de qubits.

Paralelizando circuitos¶

Os circuitos “lineares” acima são bons para realizar simulações, mas o que fazemos quando utilizamos dispositivos reais, onde o sistema pode ter uma topologia arbitrária e vários erros? Estamos especificamente visando hardware real aqui, não apenas simulações do Aer. Uma técnica para reduzir efeitos reais de hardware é paralelizar as portas CNOT e, assim, criar um circuito de menor profundidade. Isso pode ser enormemente benéfico com relação à eficiência e à fidelidade. A classe BConfig do módulo parallelize faz exatamente isto.

Primeiro devemos configurar o backend ótimo que queremos utilizar. Consideraremos um backend de simulação, 'ibmq_qasm_simulator', disfarçado como um dispositivo real, 'ibmq_16_melbourne', usando um backend falso 'FakeMelbourne'

[10]:

from qiskit.providers.aer import QasmSimulator
from qiskit.test.mock import FakeMelbourne
backend = QasmSimulator()
backend_hardware = FakeMelbourne()

Utilizando o módulo noise, podemos agora definir um modelo de ruído a partir do 'ibmq_16_melbourne' para “atribuir” ao 'ibmq_qasm_simulator'.

[11]:

noise_model = noise.NoiseModel.from_backend(backend_hardware)
coupling_map = backend_hardware._configuration.coupling_map
basis_gates=noise_model.basis_gates

E aqui está. A partir de agora, no tutorial, quando usar um dispositivo real, não uma simulação, basta tirar todas as menções e atribuições de noise_model e coupling_map, e atribuir o dispositivo real a backend. O simulador usado a partir de agora não é nenhum substituto para a execução em um dispositivo real.

BConfig lays the blueprint for creating parallelized circuits. Let us initialize an object taking in the real device we just defined, and name it protocirc. All of our experiments will use it:

[12]:

protocirc = BConfig(backend_hardware)

Mitigação De Erros¶

O Qiskit Ignis fornece ferramentas muito precisas para receber dados brutos e retornar dados calibrados. Isto é feito através da obtenção dos dados brutos, na forma de um vetor \(v_{raw}\) e obtendo uma matriz de calibração \(A\). A saída é, então, a solução para o problema de otimização: \(argmin_{v_{cal}} ||Av_{cal}-v_{raw}||^{2}\)

Hora do experimento¶

Etapas Preliminares¶

As probabilidades de medir \(|0\rangle ^{\otimes n}\) e \(|1\rangle^{\otimes n}\) no estado GHZ são importantes no cálculo da fidelidade. Para isso, precisamos executar o teste a seguir

Começamos definindo parâmetros de execução padrão:

[13]:

shots = 1024 #numbers of shots in a given experiment
max_credits = 3 #number of credits
qn = 5 #number of qubits
zerocode = '0'*qn #will help us easily define the state |00...00>
onecode = '1'*qn #will help us easily define the state |11...11>
sweep = np.arange(0.,np.pi*2,np.pi/16) #standard list of phase values we will sweep

[14]:

circ_simple, qr, initial_layout = protocirc.get_ghz_simple(qn, True)

[15]:

print(initial_layout)
circ_simple.draw()

{Qubit(QuantumRegister(5, 'q'), 0): 1, Qubit(QuantumRegister(5, 'q'), 1): 2, Qubit(QuantumRegister(5, 'q'), 2): 0, Qubit(QuantumRegister(5, 'q'), 3): 3, Qubit(QuantumRegister(5, 'q'), 4): 13}

[15]:

                       ░ ┌───┐ ░                             ░  ░       ┌─┐   »
 q_0: ─────────────────░─┤ X ├─░─────────────────────────────░──░───────┤M├───»
      ┌─────────┐      ░ └─┬─┘ ░ ┌─────────┐┌───┐┌─────────┐ ░  ░ ┌─┐   └╥┘   »
 q_1: ┤ U2(0,π) ├──■───░───■───░─┤ U2(0,π) ├┤ X ├┤ U2(0,π) ├─░──░─┤M├────╫────»
      └─────────┘┌─┴─┐ ░       ░ └─────────┘└─┬─┘└─────────┘ ░  ░ └╥┘┌─┐ ║    »
 q_2: ───────────┤ X ├─░───■───░──────────────┼──────────────░──░──╫─┤M├─╫────»
                 └───┘ ░ ┌─┴─┐ ░              │              ░  ░  ║ └╥┘ ║ ┌─┐»
 q_3: ─────────────────░─┤ X ├─░──────────────┼──────────────░──░──╫──╫──╫─┤M├»
                       ░ └───┘ ░              │              ░  ░  ║  ║  ║ └╥┘»
 q_4: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                                              │                    ║  ║  ║  ║ »
 q_5: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                                              │                    ║  ║  ║  ║ »
 q_6: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                                              │                    ║  ║  ║  ║ »
 q_7: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                                              │                    ║  ║  ║  ║ »
 q_8: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                                              │                    ║  ║  ║  ║ »
 q_9: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                                              │                    ║  ║  ║  ║ »
q_10: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                                              │                    ║  ║  ║  ║ »
q_11: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                                              │                    ║  ║  ║  ║ »
q_12: ────────────────────────────────────────┼────────────────────╫──╫──╫──╫─»
                       ░       ░ ┌─────────┐  │  ┌─────────┐ ░  ░  ║  ║  ║  ║ »
q_13: ─────────────────░───────░─┤ U2(0,π) ├──■──┤ U2(0,π) ├─░──░──╫──╫──╫──╫─»
                       ░       ░ └─────────┘     └─────────┘ ░  ░  ║  ║  ║  ║ »
 c: 5/═════════════════════════════════════════════════════════════╩══╩══╩══╩═»
                                                                   0  1  2  3 »
«
« q_0: ───
«
« q_1: ───
«
« q_2: ───
«
« q_3: ───
«
« q_4: ───
«
« q_5: ───
«
« q_6: ───
«
« q_7: ───
«
« q_8: ───
«
« q_9: ───
«
«q_10: ───
«
«q_11: ───
«
«q_12: ───
«      ┌─┐
«q_13: ┤M├
«      └╥┘
« c: 5/═╩═
«       4

[16]:

job_simple = execute(circ_simple, backend, shots=shots, max_credits=max_credits,noise_model=noise_model)
# job_simple = execute(circ_simple, backend, shots=shots, max_credits=max_credits,noise_model=noise_model, coupling_map=coupling_map, basis_gates=basis_gates)

job_monitor(job_simple)
result_simple = job_simple.result()

Job Status: job has successfully run

[17]:

P0 = (1/shots)*result_simple.get_counts()[zerocode]
P1 = (1/shots)*result_simple.get_counts()[onecode]
print('P(|00...0>) = ',P0)
print('P(|11...1>) = ',P1)

P(|00...0>) =  0.4140625
P(|11...1>) =  0.341796875

Agora com a mitigação de erros:

[18]:

qr = QuantumRegister(qn)
qubit_list = range(qn)
meas_calibs_simple, state_labels_simple = complete_meas_cal(qubit_list=qubit_list, qr=qr, circlabel='mcal')

[19]:

job_simple_em = execute(meas_calibs_simple, backend=backend,
                     noise_model=noise_model)
job_monitor(job_simple_em)
meas_result = job_simple_em.result()

Job Status: job has successfully run

[20]:

meas_fitter = CompleteMeasFitter(meas_result,state_labels_simple,circlabel='mcal')
result_simple_em = meas_fitter.filter.apply(result_simple)

[21]:

result_simple_em.get_counts()[zerocode]*1/shots

[21]:

0.44859593996533753

[22]:

P0_m = (1/shots)*result_simple_em.get_counts()[zerocode]
P1_m = (1/shots)*result_simple_em.get_counts()[onecode]
print('P(|00...0>) error mitigated = ',P0_m)
print('P(|11...1>) error mitigated = ',P1_m)

P(|00...0>) error mitigated =  0.44859593996533753
P(|11...1>) error mitigated =  0.4868663698086132

Vamos carregar esses valores em um dicionário para avaliar a fidelidade posteriormente em:

[23]:

p_dict = {'P0': P0, 'P1': P1, 'P0_m': P0_m, 'P1_m':P1_m}

Parte 1: MQC¶

We now retrieve a parallelized MQC circuit for the n qubit device

[24]:

shots = 1024 #numbers of shots in a given experiment
max_credits = 3 #number of credits
qn = 5 #number of qubits
zerocode = '0'*qn #will help us easily define the state |00...00>
sweep = np.arange(0.,np.pi*2,np.pi/16) #standard list of phase values we will sweep

[25]:

%%time
circ, theta,initial_layout = protocirc.get_ghz_mqc_para(qn)
circ_total_mqc = [circ.bind_parameters({theta:t}) for t in sweep]

CPU times: user 1.87 s, sys: 16.3 ms, total: 1.89 s
Wall time: 1.89 s

Agora executamos o experimento MQC:

[26]:

job_exp_mqc = execute(circ_total_mqc, backend, shots=shots, max_credits=max_credits,
                      noise_model=noise_model,coupling_map=coupling_map,basis_gates=basis_gates)
job_monitor(job_exp_mqc)
result_exp_mqc = job_exp_mqc.result()

Job Status: job has successfully run

Agora vamos representar a quantidade de contagens medidas para \(|0 \rangle ^{\otimes n}\) em função da fase. É importante notar que ao usar um circuito parametrizado como esse, o método get_counts() aceita um índice e não um circuito. Em qualquer outro tipo de experimento, get_counts()` aceita um circuito.

[27]:

zeros = [(1/shots)*result_exp_mqc.get_counts(a)[zerocode] if
          zerocode in result_exp_mqc.get_counts(a) else 0 for a in range(len(sweep)) ] #notice the important difference with proto2; takes only the index, not the actual circuit
Plotter('mqc').sin_plotter(sweep,zeros)

../../_images/tutorials_noise_9_entanglement_verification_47_0.png

Now we get started on error mitigation. We create an identical quantum register and use complete_meas_cal from Ignis, to create circuits for calibrated measurements to be executed, and a calibration matrix.

[28]:

qr = QuantumRegister(qn)
qubit_list = range(qn)
meas_calibs_mqc, state_labels_mqc = complete_meas_cal(qubit_list=qubit_list, qr=qr, circlabel='mcal') #from Ignis

[29]:

job_cal_mqc = execute(meas_calibs_mqc, backend=backend,
                     noise_model=noise_model,coupling_map=coupling_map,basis_gates=basis_gates)
job_monitor(job_cal_mqc)
meas_result_mqc = job_cal_mqc.result()

Job Status: job has successfully run

[30]:

meas_fitter_mqc = CompleteMeasFitter(meas_result_mqc,state_labels_mqc,circlabel='mcal')
# print(meas_fitter.cal_matrix) #uncomment this to see how close the calibration matrix is to the calibration matrix

Por fim, temos nossos resultados com mitigação de erro:

[31]:

result_exp_em = meas_fitter_mqc.filter.apply(result_exp_mqc)

Podemos ver como os resultados com mitigação de erro produzem uma fidelidade muito maior do que os dados brutos

[32]:

zeros_m = [(1/shots)*result_exp_em.get_counts(a)[zerocode] if
          zerocode in result_exp_em.get_counts(a) else 0 for a in range(len(sweep)) ]

Plotter('mqc').sin_plotter(sweep,zeros,zeros_m)

../../_images/tutorials_noise_9_entanglement_verification_55_0.png

[33]:

Plotter('mqc').get_fourier_info(qn,sweep,zeros,zeros_m,p_dict)

Upper/Lower raw fidelity bounds =  0.857  +/-  0.009  ||  0.803  +/- 0.008
Upper/Lower error mitigated fidelity bounds =  0.886  +/-  0.009  ||  0.852  +/-  0.009
Raw fidelity =  0.869  +/-  0.009
Mitigated fidelity =  0.894  +/-  0.009

[33]:

{'I0': (0.41552734375+0j),
 'In': (0.16123040795800753+7.8682083452691e-05j),
 'I0_m': (0.42314560290747766+0j),
 'In_m': (0.18167459335619435+6.189882002559724e-05j),
 'LB': 0.8030701766516697,
 'UB': 0.857346092882548,
 'LB_m': 0.8524660788583848,
 'UB_m': 0.8862034748418814,
 'F': 0.8692662432128102,
 'F_m': 0.8939641943161678}

../../_images/tutorials_noise_9_entanglement_verification_56_2.png

Nós agora plotamos o DFT e comparamos as alturas dos picos para definir limites para a fidelidade

O bootstrapping estatístico descobriu que o erro nessas medições é no máximo 1.5% (arXiv 1905.05720), portanto, esses resultados caem dentro de limites de erro, apesar da fidelidade ser um pouco maior do que o limite superior, e mostram como a mitigação de erros aumenta drasticamente a fidelidade

Parte 2: Oscilação de Paridade¶

We now retrieve a parallelized Parity Oscillation circuit for the n qubit device, and run experiments in the same fashion as we did in MQC.

[34]:

shots = 1024
max_credits = 3
qn = 5
zerocode = '0'*qn
sweep = np.arange(0,np.pi*2,np.pi/16)

[35]:

%%time
circ, [theta,thetaneg] , initial_layout = protocirc.get_ghz_po_para(qn)

circ_total = [circ.bind_parameters({theta:t, thetaneg:-t}) for t in sweep]

CPU times: user 2.06 s, sys: 10.5 ms, total: 2.07 s
Wall time: 2.07 s

[36]:

job_exp = execute(circ_total, backend, shots=shots, max_credits=max_credits,
                  noise_model=noise_model, coupling_map=coupling_map, basis_gates=basis_gates)
job_monitor(job_exp)
result_exp = job_exp.result()

Job Status: job has successfully run

Agora nós construímos a matriz \(\otimes _{j}^{N} \sigma_z^{j}\) para instrução, embora isso já seja levado em conta no método a seguir, entanglement.analysis.composite_pauli_z_expvalue():

[37]:

composite_sigma_z = sigma_z = np.array([[1, 0],[0, -1]])
for a in range(1,qn):
    composite_sigma_z = np.kron(composite_sigma_z,sigma_z)

Agora queremos ter certeza de que nossa lista de contagens está corretamente ordenada para que ela coincida com os estados do \(\otimes _{j}^{N} \sigma_z^{j}\), de modo que calcular \(\langle \otimes _{j}^{N} \sigma_z^{j} \rangle\) será tão simples quanto tomar o produto escalar desta lista ordenada com a diagonal de \(\otimes _{j}^{N} \sigma_z^{j}\). A função composite_pauli_z_expvalue faz exatamente isso; ela recebe um circuito e ordena apropriadamente as contagens do vetor de estados. Podemos representar esse produto escalar como uma função de \(\phi\) para observar oscilações de paridade.

[38]:

from qiskit.ignis.verification.entanglement.analysis import composite_pauli_z_expvalue

[39]:

y = [ (1/shots)*composite_pauli_z_expvalue(result_exp.get_counts(i),qn) for i in range(len(sweep))]

[40]:

plt.plot(sweep,y)
Plotter('po').sin_plotter(sweep,y)

../../_images/tutorials_noise_9_entanglement_verification_68_0.png

Agora para mitigação de erro padrão:

[41]:

qr = QuantumRegister(qn)
qubit_list = range(qn)
meas_calibs, state_labels = complete_meas_cal(qubit_list=qubit_list, qr=qr, circlabel='mcal')

[42]:

job_cal = execute(meas_calibs, backend=backend,
                  noise_model=noise_model, coupling_map=coupling_map, basis_gates=basis_gates)
job_monitor(job_cal)
meas_result = job_cal.result()

Job Status: job has successfully run

[43]:

meas_fitter = CompleteMeasFitter(meas_result,state_labels,circlabel='mcal')
result_exp_em = meas_fitter.filter.apply(result_exp)

[44]:

y_m = [ (1/shots)*composite_pauli_z_expvalue(result_exp_em.get_counts(i),qn) for i in range(len(sweep))]

[45]:

Plotter('po').sin_plotter(sweep,y,y_m)

../../_images/tutorials_noise_9_entanglement_verification_74_0.png

We can see how error mitigation dramatically improves our measurement (much more so in PO than in MQC). Let us quantify this using the same DFT method we used in MQC, and calculating the actual fidelities:

[46]:

Plotter('po').get_fourier_info(qn,sweep,y,y_m,p_dict)

Raw fidelity =  0.641  +/-  0.006
Mitigated fidelity =  0.878  +/-  0.009

[46]:

{'In': (-0.26317275322394224-0.0069647879792624975j),
 'In_m': (-0.4101495965078221-0.009319374887961387j),
 'F': 0.6411945851051803,
 'F_m': 0.8779866146481243}

../../_images/tutorials_noise_9_entanglement_verification_76_2.png

As we see, the raw fidelity is much lower than what is achieved with MQC, but the error mitigated result is about the same.

Parte 3: Tomografia¶

O primeiro passo neste experimento é apenas passar um simples estado GHZ sem medições. Também, o circuito não pode ser transpilado; o argumento transpiled, no método getGHZChecker() pode ser ligado e desligado como é mostrado

[47]:

shots = 1024
max_credits = 3
qn = 5
zerocode = '0'*qn
q = QuantumRegister(qn, 'q')

[48]:

circ_total, initial_layout = protocirc.get_ghz_layout(qn,transpiled=False)

Passamos agora um backend simulado do Aer para obter contagens do vetor de estados teórico

[49]:

job_exp = execute(circ_total, Aer.get_backend('statevector_simulator'), shots=shots, max_credits=max_credits)
job_monitor(job_exp)
result_exp = job_exp.result()
psi_exp = result_exp.get_statevector(circ_total)

Job Status: job has successfully run

This following code runs tomography experiments on the circuit we defined first, which is then compared to the theoretical statevector to generate a density matrix

[50]:

qst = state_tomography_circuits(circ_total,q)
job = execute(qst, backend, shots=shots, initial_layout=initial_layout,noise_model=noise_model, coupling_map=coupling_map, basis_gates=basis_gates)
job_monitor(job)

Job Status: job has successfully run

[51]:

tomo = StateTomographyFitter(job.result(), qst)

A partir daqui podemos obter a fidelidade, embora este método não seja tão infalível como ao que vamos chegar a eventualmente:

[52]:

F = quantum_info.state_fidelity(psi_exp,tomo.fit(), validate=False)

…E agora para a mitigação de erros…

[53]:

qr = QuantumRegister(qn)
qubit_list = range(qn)
meas_calibs, state_labels = complete_meas_cal(qubit_list=qubit_list, qr=qr, circlabel='mcal')

[54]:

job_c = execute(meas_calibs, backend=backend,
                  noise_model=noise_model, coupling_map=coupling_map, basis_gates=basis_gates)
job_monitor(job_c)
meas_result = job_c.result()

Job Status: job has successfully run

[55]:

meas_fitter = CompleteMeasFitter(meas_result,state_labels,circlabel='mcal')
result_em = meas_fitter.filter.apply(job.result())

[56]:

result_em = meas_fitter.filter.apply(job.result())
tomo_em = StateTomographyFitter(result_em, qst)

Now, using qiskit.visualization, we can plot the raw density matrix, real, and imaginary parts being on separate plots,…

[57]:

visualization.plot_state_city(tomo.fit(),"city")

[57]:

../../_images/tutorials_noise_9_entanglement_verification_94_0.png

../../_images/tutorials_noise_9_entanglement_verification_94_1.png

E também a matriz densidade com erros mitigados,…

[58]:

visualization.plot_state_city(tomo_em.fit(),"city")

[58]:

../../_images/tutorials_noise_9_entanglement_verification_96_0.png

../../_images/tutorials_noise_9_entanglement_verification_96_1.png

As matrizes densidade reais podem ser obtidas utilizando o método fit(). Uma vez que temos a matriz de densidade, podemos computar a fidelidade, que é simplesmente a metade da soma dos quatro cantos da matriz densidade; o método a seguir nos ajuda:

[59]:

from qiskit.ignis.verification.entanglement.analysis import rho_to_fidelity

[60]:

rho, rho_em = tomo.fit() , tomo_em.fit()

[61]:

F = rho_to_fidelity(rho)
F_em = rho_to_fidelity(rho_em)

[62]:

print("Raw fidelity: ",F)
print("Error mitigated fidelity: ",F_em)

Raw fidelity:  0.6368794947513089
Error mitigated fidelity:  0.8897132713838496

As we see, the raw fidelity is much lower than what is achieved with either MQC or Parity Oscillations, but the error mitigated result is about the same.

Uma nota sobre a tomografia

Não realize tomografia quântica com > 5 qubits

Conclusão¶

In conclusion, we see that without error mitigation, MQC is the superior method for characterizing the GHZ state. However, with error mitigation, all methods can, at least for a small number of qubits, achieve a much greater fidelity, and all near the same value. To get more accurate results, aside from using a real device, it is worth increasing the number of shots four to eight-fold. It may be worth comparing how the parallelized circuits used in this notebook perform fidelity-wise versus linearized circuits.

Colaboradores externos¶

Rohith Karur

[63]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.26.0
Terra	0.17.3
Aer	0.8.2
Ignis	0.6.0
Aqua	0.9.1
IBM Q Provider	0.13.1
System information
Python	3.9.4 (default, Apr 20 2021, 15:51:38) [GCC 10.2.0]
OS	Linux
CPUs	32
Memory (Gb)	125.71707916259766
Wed May 12 06:38:49 2021 EDT

This code is a part of Qiskit

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.