Note

Cette page a été générée à partir de tutorials/noise/9_entanglement_verification.ipynb.

Exécuter en mode interactif dans le IBM Quantum lab.

Vérification de l’intrication

Introduction à l’état GHZ

L’État Greenberger-Horne-Zeilinger (GHZ) est un état intriqué à \(n\)-qubit que l’on peut. définir par le vecteur d’état suivant :

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

La caractérisation de l’état GHZ est très utile pour évaluer les interactions multi-qubits, dont la robustesse est une clé du développement d’ordinateurs quantiques à grande échelle.

Caractérisation d’un état quantique

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}\]

Le but de ce tutoriel est double: nous allons explorer des façons de caractériser l’état GHZ, et des façons dont nous pouvons utiliser la bibliothèque lgnis et ses outils d’atténuation des erreurs pour augmenter la fidélité de lecture, indépendamment de la méthode de caractérisation utilisée

Avant d’aller plus loin, importons tout ce dont nous aurons besoin à partir du Qiskit de base:

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

Les deux fonctions suivantes sont issues dl’ignis. La première concerne la technique générale d’atténuation des erreurs, et la seconde est spécifique pour la tomographie quantique

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

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

Préparation d’un état GHZ

Voyons d’abord comment préparer un État GHZ:

Disons que nous avons un système de \(n\) qubits, tous préparés dans l’état :math:` |0rangle`:

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

Nous appliquons une porte Hadamard au premier qubit: \(|0\rangle \longrightarrow \frac{1}{ \sqrt{2}} (| 0\rangle + | 1\rangle)\). Notre état se présente maintenant comme suit:

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

Sur cet état, l’application d’une séquence de \(n-1\) CNOT entre le \(n^{ieme}\) et le \((n+1)^{ieme}\) qubits pour \(n = 0 \ldots n-1\) laisse le qubit \(n+1\) à \(|0\rangle\) si le \(n^{th}\) est dans l’état \(|0\rangle\), et \(|1\rangle\) si le \(n^{ieme}\) qubit est en \(|1\rangle\), créant ainsi l’état GHZ:

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

La fonction suivante crée ce circuit « linéaire » qui peut mesurer l’état GHZ:

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)

circ_simple.draw(output='mpl')

Caractérisation, Partie I

Coherence quantique multiple (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.

La fonction ci-dessous crée un circuit MQC linéaire. Comme pour chaque circuit ici, vous pouvez changer l’argument full_measurement pour basculer entre la mesure complète de tous les qubits ou la mesure de seulement le qubit de contrôle. La mesure complète donne les résultats les plus précis, mais pour plus de 7 qubits, il est recommandé de la définir à false et d’observer uniquement les oscillations entre les états 0 et 1.

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)

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

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).

Oscillations de parité

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.

La fonction suivante génère un circuit qui est l’équivalent en oscillation de parité du circuit MQC indiqué ci-dessus

circ_po = get_ghz_po_para(qn)

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

Nous pouvons obtenir la fidélité pour les oscillations de parité :math:` S_ { phi } ` de :math:` F = frac{1}{2}(P_{00…0}+ P_{11…1}+ C) , où :math: C , la cohérence est définie comme :math: 2sqrt { I_{n}} `, suivant la même convention pour la DFT que pour la méthode MQC.

Tomographie

La tomographie mesure la matrice de densité en produisant de nombreux états nominalement identiques et en mesurant les instances d’état dans différentes bases. Le résultat idéal d’un état GHZ est de quatre éléments de matrice de densité égale aux 4 coins de la base du produit tensoriel, tous les autres éléments disparaissent. Bien que la fidélité puisse être facilement calculée par cette méthode, la méthode est lente (nécessite un nombre exponentiel de mesures par rapport à n), et devient très longue au delà de 7. Néanmoins, nous montrerons ci-dessous comment effectuer cette méthode car elle est pertinente pour un petit nombre de qubits.

Parallélisation des circuits

Les circuits « linéaires » ci-dessus conviennent pour effectuer des simulations, mais comment faire lorsque nous utilisons des dispositifs réels, où le système peut avoir une topologie arbitraire et diverses erreurs ? Nous ciblons spécifiquement le matériel réel ici, pas seulement la simulation Aer. Une technique pour réduire les effets du matériel réel est de paralléliser les portes CNOT et ainsi créer un circuit plus court. Cela peut être extrêmement bénéfique en termes d’efficacité et de fidélité. La classe BConfig du module parallelize fait justement cela.

Tout d’abord, nous devons configurer le backend optimal que nous voulons utiliser. Nous considérerons un backend de simulation, ibmq_qasm_simulateur, déguisé en un véritable appareil, ibmq_16_melbourne en utilisant un faux backend FakeMelbourne

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

A l’aide du module noise, nous pouvons maintenant définir un modèle de bruit issu de `` ibmq_16_melbourne`` pour l’assigner sur l’émulateur : ibmq_qasm_simulateur.

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

Et là, nous l’avons. A partir de maintenant, dans le tutoriel, lors de l’utilisation d’un véritable appareil, pas d’une simulation, il suffit de mentionner le noise_model et coupling_map, et d’assigner le vrai dispositif à backend. Le simulateur utilisé à partir de maintenant n’est pas un substitut à l’exécution d’un véritable appareil.

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:

protocirc = BConfig(backend_hardware)

Atténuation d’erreurs

Qiskit Ignis fournit des outils très précis pour prendre des données brutes et retourner les données calibrées. Pour ce faire, on obtient les données brutes, sous la forme d’un vecteur :math:` v_{raw}` et on obtient une matrice d’étalonnage \(A\). La sortie est alors la solution au problème d’optimisation: :math:` argmin_ { v_{cal}} | | Av_{cal}-v_{raw}| | ^{2}`

Phase d’expérimentation

Étapes préliminaires

Les probabilités de mesurer \(|0\rangle ^ { \otimes n }\) et :math:` | 1rangle ^ { otimes n }` dans l’état GHZ sont importantes pour le calcul de la fidélité. Pour cela, nous devons exécuter le test suivant :

Nous commençons par définir les paramètres d’exécution standard :

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

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

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}

                       ░ ┌───┐ ░                             ░  ░       ┌─┐   »
 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 

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

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

Maintenant, avec l’atténuation des erreurs :

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

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

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

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

0.44859593996533753

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

Nous allons charger ces valeurs dans un dictionnaire pour pouvoir évaluer la fidélité par la suite :

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

Partie 1 : MQC

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

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

%%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

Nous exécutons maintenant l’expérience MQC :

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

Nous allons maintenant tracer la quantité d’occurrences mesurées pour \(| 0 \rangle ^ { \otimes n }\) en fonction de la phase. Il est important de noter que lors de l’utilisation d’un circuit paramétré comme celui ici, la méthode get_counts() accepte un index et non un circuit. Dans tout autre type d’expérience, get_counts() accepte un ** circuit**.

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)

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.

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

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

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

Enfin, nous avons nos résultats avec les erreurs atténuées :

result_exp_em = meas_fitter_mqc.filter.apply(result_exp_mqc)

Nous pouvons voir comment les résultats utilisant l’atténuation d’erreur produisent une fidélité beaucoup plus grande que les données brutes

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)

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

{'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}

Nous traçons maintenant la DFT et comparons les hauteurs des pics pour donner des bornes pour la fidélité

Le bootstrap statistique a permis de constater que l’erreur sur ces mesures est au plus de 1,5% (arXiv 1905.05720), de sorte que ces résultats se situent à l’intérieur des limites d’erreur, malgré la fidélité légèrement supérieure à la limite haute, et montrent comment l’atténuation des erreurs augmente considérablement la fidélité

Partie 2 : Oscillation de parité

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.

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

%%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

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

Nous construisons à présent a matrice :math:` otimes _{j}^{N} sigma_z ^{j}` pour l’instruction, bien que cette méthode soit déjà prise en compte dans la méthode suivante: entanglement.analysis.composite_pauli_z_expvalue ():

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)

Maintenant nous voulons nous assurer que notre liste de compteurs est correctement ordonnée afin qu’elle coïncide avec les états des \(\otimes _{j}^{N} \sigma_z ^{j}\), de sorte que le calcul de \(\langle \otimes _{j}^{N} \sigma_z^{j} \rangle\) sera aussi simple que de prendre le produit à points de cette liste ordonnée avec la diagonale de \(\otimes _{j}^{N} \sigma_z ^{j}\). La fonction composite_pauli_z_expvalue fait exactement cela ; elle prend un circuit et ordonne correctement le nombre de vecteurs d’état. Nous pouvons tracer ce produit en tant que fonction de \(\phi\) pour observer les oscillations de parité.

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

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

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

Maintenant, pour l’atténuation standard des erreurs :

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

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

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

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

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

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:

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

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

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

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

Partie 3: Tomographie

La première étape de cette expérience est de passer un état GHZ simple sans opération de mesure. De plus, le circuit ne peut pas être transpilé ; l’argument transpiled dans la méthode getGHZChecker () peut être activé et désactivé comme indiqué

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

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

Nous avons maintenant un backend simulé par Aer pour obtenir les quantités théoriques des états vectoriels

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

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

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

De là, nous pouvons obtenir la fidélité, bien que cette méthode ne soit pas aussi robuste que celle à laquelle nous arriverons à la fin :

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

…Et maintenant pour l’atténuation des erreurs…

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

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

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

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,…

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

Et aussi la matrice de densité après l’atténuation des erreurs …

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

Les matrices de densité réelles peuvent être obtenues à l’aide de la méthode fit (). Une fois que nous avons la matrice de densité, nous pouvons calculer la fidélité, qui n’est que la moitié de la somme des quatre coins de la matrice de densité ; la méthode suivante nous aide:

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

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

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

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.

Une note sur la tomographie

Ne pas effectuer de tomographie quantique avec > 5 qubits

Conclusion

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.

Collaborateurs externes

Rohith Karur

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

© Copyright IBM 2017, 2021.

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.