J'ai abordé divers sujets sous le titre de "Bases de la théorie de l'information quantique", mais pour exprimer l'état quantique, "Opérateur de densité" est toujours apparu. Surtout lorsque je considère un système quantique mixte, c'est un outil théorique très pratique que je dois utiliser, donc je ne peux plus m'en passer. C'est tellement pratique que lorsque vous avez un système physique inconnu, vous serez tenté de demander: "Par quel opérateur de densité cet état quantique peut-il être représenté?" En fait, elle peut être estimée à l'aide d'une technique appelée "tomographie à état quantique". Dans cet article, je vais d'abord expliquer la méthode, puis utiliser le simulateur de calcul quantique qlazy pour estimer l'opérateur de densité pour tout état quantique. Je vais.
Les documents suivants ont été utilisés comme références.
Avant d'estimer l'opérateur de densité, examinons un peu comment les états mixtes apparaissent. Il s'agit de comprendre quand cette méthode d'estimation est utile. Je pense qu'il y a deux modèles comme indiqué ci-dessous.
[1] est un état mixte qui apparaît lorsque, par exemple, Alice a un périphérique qui peut déclencher plusieurs modèles à l'état pur, et l'utilise pour sélectionner de manière probabiliste l'état pur et se déclencher l'un après l'autre. Imaginez un lanceur de photons qui peut régler l'angle de polarisation à votre guise. Ou, si vous mesurez un état pur et oubliez le résultat de la mesure, vous obtiendrez un état mixte de ce modèle [^ 1].
Exprimant un ensemble probabiliste d'états purs comme $ \ {p_i, \ ket {\ psi_i} \} $, l'opérateur de densité $ \ rho $
[^ 1]: Par ailleurs, une telle mesure est appelée "mesure non sélective". Quand je lis un manuel sur l'information quantique, je rencontre souvent les mots «oublier» et «perdre les résultats de mesure». Je ne pense pas qu'il y ait un expérimentateur aussi stupide, mais pensons-y comme Aya des mots (quand j'étais étudiant, je faisais parfois des mesures non sélectives, mais je transpirais). Au contraire, la mesure qui mémorise fermement le résultat de la mesure est appelée "mesure sélective". Dans ce cas, l'état du système sera pur.
\rho = \sum_{i} p_i \ket{\psi_i} \bra{\psi_i} \tag{1}
Peut être exprimé comme.
[2] est un état mixte qui apparaît en faisant attention au système partiel S du système fermé (= état pur) dans son ensemble [^ 2]. Le système partiel S est généralement considéré comme interagissant avec le reste des autres systèmes (système environnemental E), il devient donc un système ouvert (= état mixte). Ou, lors de l'exécution d'un circuit quantique sur un ordinateur quantique, si vous regardez certains des bits quantiques, ils sont généralement dans un état mixte [^ 3].
[^ 2]: C'est une partie intéressante de l'état quantique. Lorsque tout le système de l'état pur dont l'état est fixé est divisé, l '«enchevêtrement» est déroulé et il devient un état mixte. En d'autres termes, diviser simplement un système avec une entropie nulle provoque une entropie dans le système partiel pour une raison quelconque!
[^ 3]: Le calcul quantique est une transformation unitaire vers l'état pur dans son ensemble, donc quand vous regardez l'état quantique entier, il garde toujours l'état pur, mais si vous faites attention à certains bits quantiques, C'est dans un état mixte. Cependant, si le bit quantique partiel d'intérêt est dans un état indépendant = untangled = produit avec d'autres bits quantiques, il est dans un état pur.
Lorsque tout le système est $ \ ket {\ Psi} $, si vous écrivez l'attention sur le système partiel avec une formule,
\rho = Tr_E (\ket{\Psi} \bra{\Psi}) \tag{2}
Ce sera.
Maintenant que nous avons brièvement passé en revue l'apparence spécifique de l'état mixte, expliquons comment estimer l'opérateur de densité à ce moment-là. Mais voici une hypothèse. Malheureusement, si la condition $ \ rho $ n'apparaît qu'une seule fois et que vous n'avez qu'une seule chance de la mesurer, il est impossible de l'estimer. Bien que le nombre obtenu par mesure soit un, il existe de nombreux nombres pour décrire l'opérateur de densité, donc cela devient un mauvais problème de réglage et ne peut pas être estimé. Par conséquent, on suppose que l'état de $ \ rho $ peut être généré à plusieurs reprises et peut être mesuré à chaque fois. L'idée de base est d'estimer l'opérateur densité en collectant un grand nombre de résultats de mesure et en les intégrant.
Considérons d'abord l'opérateur de densité pour un état quantique.
Seulement dans le cas d'un quantum, l'opérateur de densité pourrait être exprimé comme la somme linéaire de l'opérateur de Pauli [^ 4]. Cette expression servira de base pour expliquer la méthode d'estimation, regardons donc de plus près comment elle a été dérivée.
[^ 4]: Dans l 'article précédent qui couvrait les "canaux quantiques", j'ai expliqué l'affichage bloch de l'opérateur de densité.
L'opérateur Pauli a été défini comme une matrice comme celle-ci:
\sigma_0 = I =
\begin{pmatrix}
1 & 0 \\
0 & 1
\end{pmatrix}, \space
\sigma_1 =
\begin{pmatrix}
0 & 1 \\
1 & 0
\end{pmatrix}, \space
\sigma_2 =
\begin{pmatrix}
0 & -i \\
i & 0
\end{pmatrix}, \space
\sigma_3 =
\begin{pmatrix}
1 & 0 \\
0 & -1
\end{pmatrix} \tag{3}
Comme il ressort clairement de cette définition, l'opérateur Pauli est l'opérateur Hermeet. Et,
\frac{1}{2} Tr(\sigma_i \sigma_j) = \delta_{ij} \tag{4}
Il a la propriété de. Au fait, $ Tr (AB) $ qui apparaît ici est une sorte de produit interne lorsque les matrices $ A et B $ sont considérées comme des vecteurs, et est parfois appelé "produit interne de Hilbert-Schmidt" (mentionné plus tard). Veuillez vous en souvenir car il viendra).
En notant cette propriété de l'opérateur Pauli, tout opérateur Elmeet $ A $ défini dans l'espace de Hilbert bidimensionnel est $ \ {u_i \} \ space (i = 0,1,2,3) Vous pouvez voir que $ peut être exprimé comme un nombre réel arbitraire par la somme linéaire suivante.
A = u_0 \sigma_0 + u_1 \sigma_1 + u_2 \sigma_2 + u_3 \sigma_3 = \sum_{i=0}^{3} u_i \sigma_i \tag{5}
C'est facile, alors prouvons-le un peu.
[Preuve]
Premièrement, si le côté droit de l'équation (3) est Elmeat.
\begin{align}
A &=
u_0
\begin{pmatrix}
1 & 0 \\
0 & 1
\end{pmatrix} +
u_1
\begin{pmatrix}
0 & 1 \\
1 & 0
\end{pmatrix} +
u_2
\begin{pmatrix}
0 & -i \\
i & 0
\end{pmatrix} +
u_3
\begin{pmatrix}
1 & 0 \\
0 & -1
\end{pmatrix} \\
&=
\begin{pmatrix}
u_0 & 0 \\
0 & u_0
\end{pmatrix} +
\begin{pmatrix}
0 & u_1 \\
u_1 & 0
\end{pmatrix} +
\begin{pmatrix}
0 & -i u_2 \\
i u_2 & 0
\end{pmatrix} +
\begin{pmatrix}
u_3 & 0 \\
0 & -u_3
\end{pmatrix} \\
&=
\begin{pmatrix}
u_0 + u_3 & u_1 - iu_2 \\
u_1 + iu_2 & u_0 - u_3
\end{pmatrix} \tag{6}
\end{align}
Et évidemment $ A ^ {\ dagger} = A $, donc $ A $ est Elmeat.
Vient ensuite la preuve opposée. Autrement dit, si un opérateur Elmeat peut être exprimé comme dans l'équation (5).
En supposant que $ A $ est Elmeat, en utilisant n'importe quel nombre réel $ a, b, c, d $,
A =
\begin{pmatrix}
a & b-ic \\
b+ic & d
\end{pmatrix} \tag{7}
Cela peut être exprimé par. Peu importe ce que $ a, b, c, d $ vous apportez ici
\begin{align}
a &= u_0 + u_3 \\
b &= u_1 \\
c &= u_2 \\
d &= u_0 - u_3 \tag{8}
\end{align}
Puisqu'il y a toujours des valeurs réelles $ u_0, u_1, u_2, u_3 $ qui satisfont, Eq. (7)
\begin{align}
A &=
\begin{pmatrix}
u_0 + u_3 & u_1 - iu_2 \\
u_1 + iu_2 & u_0 - u_3
\end{pmatrix} \\
&=
u_0
\begin{pmatrix}
1 & 0 \\
0 & 1
\end{pmatrix} +
u_1
\begin{pmatrix}
0 & 1 \\
1 & 0
\end{pmatrix} +
u_2
\begin{pmatrix}
0 & -i \\
i & 0
\end{pmatrix} +
u_3
\begin{pmatrix}
1 & 0 \\
0 & -1
\end{pmatrix} \\
&= u_0 \sigma_0 + u_1 \sigma_1 + u_2 \sigma_2 + u_3 \sigma_3 \\
&= \sum_{i=0}^{3} u_i \sigma_i \tag{9}
\end{align}
Ensuite, l'équation (5) a été prouvée.
(Fin de la certification)
Maintenant, disons quelque chose d'un peu différemment sur la signification de l'équation (5). Autrement dit, l'opérateur Elmeet défini dans l'espace de Hilbert bidimensionnel peut être considéré comme un vecteur dans l'espace linéaire étiré par les quatre opérateurs de Pauli lorsqu'ils sont des bases orthogonales au sens du produit interne de Hilbert-Schmidt. Tu peux dire ça.
Hmm? Que signifie «vecteur» lorsque vous dites «opérateur (= matrice)»? ?? Vous pouvez entendre la question, mais adoucissez votre tête et suivez. En gros, pensons que tout peut être appelé un "vecteur" si le produit intérieur peut être défini, il y a une base orthogonale, et il y a quelque chose qui peut être représenté par la somme linéaire.
Ainsi, l'opérateur de densité à une quantité $ \ rho $ était exactement l'opérateur Elmeet dans l'espace de Hilbert bidimensionnel, il peut donc être développé comme l'équation (5) vient de le prouver.
\rho = u_0 \sigma_0 + u_1 \sigma_1 + u_2 \sigma_2 + u_3 \sigma_3 = \sum_{i=0}^{3} u_i \sigma_i \tag{10}
Cependant, l'opérateur de densité a une contrainte de $ Tr (\ rho) = 1 $, et $ Tr (\ sigma_1) = Tr (\ sigma_2) = Tr (\ sigma_3) = 0 $, donc $ u_0 = Tr (\ rho) = 1 $. Autrement dit, une variable est réduite,
\rho = I + u_1 \sigma_1 + u_2 \sigma_2 + u_3 \sigma_3 = I + \sum_{i=1}^{3} u_i \sigma_i \tag{11}
Peut être écrit. Ici, en faisant attention à la nature de l'opérateur de Pauli dans l'équation (4),
u_i = \frac{1}{2} Tr(\sigma_i \rho) \tag{12}
Par conséquent, l'équation (11) est, après tout,
\begin{align}
\rho &= \frac{1}{2} (Tr(\rho) I + Tr(\sigma_1 \rho) \sigma_1 + Tr(\sigma_2 \rho) \sigma_2+ Tr(\sigma_3 \rho) \sigma_3) \\
&= \frac{1}{2} \sum_{i=0}^{3} Tr(\sigma_i \rho) \sigma_i \tag{13}
\end{align}
Ce sera.
Il est maintenant temps de parler de la façon d'estimer l'opérateur de densité.
Examinez de plus près l'équation (13). $ Tr (\ sigma_i \ rho) $ for $ i = 1,2,3 $ était la valeur attendue lorsque la bulle d'observation $ \ sigma_i $ a été mesurée. $ \ Sigma_1, \ sigma_2, \ sigma_3 $ sont comme des spins dans les axes X, Y et Z, respectivement. Par conséquent, pour le quantum volant, la mesure dans la direction de l'axe X est effectuée plusieurs fois, la valeur mesurée (+1, -1) est enregistrée pour obtenir la valeur attendue, puis la mesure dans la direction de l'axe Y est effectuée. Est exécutée plusieurs fois pour obtenir la valeur attendue de la même manière, puis la mesure dans la direction de l'axe Z est exécutée plusieurs fois pour obtenir la valeur attendue, qui est substituée dans l'équation (13). $ Tr (\ sigma_0 \ rho) $ $ \ sigma_0 $ est une matrice unitaire, et la trace de $ \ rho $ est 1, donc peu importe qu'elle existe ou non, ce terme doit être mis à 1. Ainsi, l'équation (13) peut être calculée parfaitement.
Maintenant, j'ai expliqué en imaginant l'état quantique émis physiquement par Alice, mais comme autre exemple, vous voudrez peut-être estimer l'opérateur de densité pour un bit quantique d'un ordinateur quantique. C'est fondamentalement la même chose, mais vous devez faire attention uniquement lorsque vous changez la direction de mesure du bit quantique à chaque fois. Si vous utilisez un simulateur ou un service cloud qui ne prend en charge que les mesures dans la direction Z, vous devez mordre une porte quantique qui change la direction de la mesure avant les mesures dans la direction Z.
Mesure dans la direction X
--H--M--
Mesure dans la direction Y
--S+--H--M--
Mesure de la direction Z
--M--
Je peux y aller. Si vous imaginez une sphère Bloch, vous pouvez voir qu'elle tourne simplement l'axe.
La discussion jusqu'à présent peut être étendue à l'opérateur de densité des deux états quantiques.
J'ai expliqué que l'opérateur de densité dans le cas d'un quantum peut être considéré comme un vecteur dans un espace linéaire basé sur les quatre opérateurs de Pauli. Dans le cas d'un état à deux quantiques, vous pouvez apporter un autre espace linéaire pour créer un espace produit direct et définir un vecteur dessus. La base de cet espace produit direct est définie par le produit tensoriel des quatre opérateurs de Pauli. En d'autres termes
\{\sigma_i \otimes \sigma_j \} \space (i,j = 0,1,2,3) \tag{14}
16 matrices 4X4 sont à la base de cet espace produit direct. Comme vous pouvez le voir, cette base est
\frac{1}{2^2} Tr[(\sigma_i \otimes \sigma_j)(\sigma_k \otimes \sigma_l)] = \delta_{ik} \delta_{jl} \tag{15}
Puisque la condition orthogonale est satisfaite, l'opérateur de densité de cet état à deux quantiques est le même que précédemment.
\rho = \sum_{i}^{3} \sum_{j}^{3} u_{ij} \sigma_i \otimes \sigma_j \tag{16}
Il peut être étendu avec une base en utilisant l'opérateur Pauli comme dans. Notez que l'équation (15), ce $ u_ {ij} $ est
u_{ij} = \frac{1}{2^2} Tr[(\sigma_i \otimes \sigma_j) \rho] \tag{17}
Puisqu'elle peut être calculée comme suit, l'équation (16) est
\rho = \frac{1}{2^2} \sum_{i=0}^{3} \sum_{j=0}^{3} Tr[(\sigma_i \otimes \sigma_j) \rho] \cdot \sigma_i \otimes \sigma_j \tag{18}
Ce sera.
Pour estimer l'opérateur de densité, il est nécessaire d'effectuer des mesures à deux quantités tout en basculant entre les directions. Il existe 4X4 = 16 combinaisons d'opérateurs Pauli, alors trouvez la valeur attendue pour chaque cas. Plus précisément, tout d'abord, pour une combinaison d'opérateurs Pauli, obtenez les valeurs mesurées (+1, -1) de chacun des deux quanta volants. Enregistrez le produit comme la valeur mesurée de la totalité du quantum 2. Répétez cette opération plusieurs fois pour obtenir la valeur attendue. Maintenant que nous avons la valeur attendue pour une combinaison d'opérateurs Pauli, nous allons le faire pour toutes les combinaisons d'opérateurs Pauli (16 modèles). Puisque 16 valeurs attendues sont obtenues, l'estimation de l'opérateur de densité est complétée en les substituant dans l'équation (17). Cependant, il existe un cas où tous les opérateurs Pauli sont des opérateurs d'unité, il n'est donc pas nécessaire de calculer la valeur attendue. Laissez-le à 1 sans dire s'il est présent ou non. c'est tout.
De plus, la même discussion est correcte pour l'opérateur de densité de l'état quantique n. L'opérateur de densité est
\rho = \frac{1}{2^n} \sum_{\mu_1=0}^{3} \sum_{\mu_2=0}^{3} \cdots \sum_{\mu_{n}=0}^{3} Tr[(\sigma_{\mu_1} \otimes \sigma_{\mu_2} \otimes \cdots \otimes \sigma_{\mu_{n}})\rho] \cdot \sigma_{\mu_1} \otimes \sigma_{\mu_2} \otimes \cdots \otimes \sigma_{\mu_{n}} \tag{19}
Peut être exprimé comme Cela semble un peu compliqué, mais si vous regardez de près, vous le comprendrez.
La méthode d'estimation de l'opérateur densité est
Tr[(\sigma_{\mu_1} \otimes \sigma_{\mu_2} \otimes \cdots \otimes \sigma_{\mu_{n}})\rho] \tag{20}
Il vous suffit de trouver la valeur attendue. Puisqu'il s'agit de n quantique, la combinaison des opérateurs de Pauli est de 4 à la nième puissance. Pour chaque combinaison, la direction correspondant à l'opérateur de Pauli attribué à chaque bit quantique est mesurée, la valeur mesurée de n quantum (le produit de la valeur mesurée de chaque quantum) est obtenue, et la valeur attendue est obtenue. Est bon.
La méthode d'estimation telle que décrite ci-dessus est la "tomographie d'état quantique".
Maintenant, je voudrais créer un ensemble d'états quantiques arbitraires et estimer l'opérateur de densité par tomographie d'état quantique [^ 5]. Même si vous ne faites pas une chose aussi délicate, le simulateur de calcul quantique qlazy a une fonction qui vous permet d'obtenir directement l'opérateur de densité de l'ensemble d'états quantiques par calcul matriciel. Ça a été. Cependant, cette fois, j'étudie la tomographie d'état quantique, donc je vais l'oublier et estimer l'opérateur de densité uniquement en mesurant l'ensemble d'état quantique. Utilisez l'opérateur de densité calculé par qlazy comme valeur de référence (valeur vraie) pour mesurer la précision de l'estimation. J'évaluerai la précision par fidélité (la fidélité est également installée en fonction de qlazy).
[^ 5]: Dans cette simulation, nous avons estimé l'état mixte qui apparaît à partir de l'ensemble d'états quantiques. Cependant, je pense que l'estimation de l'état mixte qui apparaît en se concentrant sur le sous-système à l'état pur peut également se faire en modifiant légèrement le programme (?).
Regardons maintenant tout le code Python.
import random
import math
import numpy as np
from scipy.stats import unitary_group
from qlazypy import QState,DensOp
def random_qstate_ensemble(qubit_num, mimxed_num):
qstate = []
dim = 2**qubit_num
for _ in range(mixed_num):
vec_ini = np.zeros(dim)
vec_ini[0] = 1.0
mat = unitary_group.rvs(dim)
vec = np.dot(mat, vec_ini)
qstate.append(QState(vector=vec))
prob = [random.random() for _ in range(mixed_num)]
total = sum(prob)
prob = [p/total for p in prob]
return (qstate,prob)
def get_pauli_index(index, total):
# ex) index = 9 = 1001 -> [10,01] -> [2,1] --reverse-> [1,2] = pauli_index
# '1' means X for 0th-qubit, '2' means Y for 1st-qubit
pauli_index = [0]*int(math.log2(total)/2)
count = 0
while index > 0:
pauli_index[count] = index%4
index = index // 4
count += 1
pauli_index.reverse()
return pauli_index
def make_pauli_product(index, total, pauli_mat):
pauli_index = get_pauli_index(index, total)
pauli_prod_dim = 2**len(pauli_index)
pauli_prod = np.array([1.0])
for pid in pauli_index:
pauli_prod = np.kron(pauli_prod, pauli_mat[pid])
return pauli_prod
def make_densop(expect, qubit_num, pauli_mat):
dim = 2**qubit_num
measure_num = len(expect)
matrix = np.zeros((dim,dim))
for i in range(measure_num):
pauli_prod = make_pauli_product(i,measure_num,pauli_mat)
matrix = matrix + expect[i] * pauli_prod
matrix = matrix / (2.0**qubit_num)
return DensOp(matrix=matrix)
def calc_expect(prb):
N = len(prb)
val = np.zeros(N)
for index in range(N):
bin_list = [int(s) for s in list(format(index, 'b'))]
val[index] = (-1)**sum(bin_list) # odd -> -1, even -> +1
return np.dot(prb, val)
def estimate_densop(prob,qstate,shots):
pauli_mat = [np.eye(2), # = I
np.array([[0,1],[1,0]]), # = X
np.array([[0,-1j],[1j,0]]), # = Y
np.array([[1,0],[0,-1]])] # = Z
mixed_num = len(prob)
qubit_num = qstate[0].qubit_num
measure_num = 4**qubit_num
for i in range(mixed_num):
expect = {}
for index in range(measure_num):
pauli_index = get_pauli_index(index,measure_num)
if index == 0:
expect[index] = 1.0
continue
qs = qstate[i].clone()
for qid in range(len(pauli_index)):
if pauli_index[qid] == 0:
continue
elif pauli_index[qid] == 1:
qs.h(qid)
elif pauli_index[qid] == 2:
qs.s_dg(qid).h(qid)
else:
pass
frq = qs.m(shots=shots).frq
prb = np.array([f/shots for f in frq])
expect[index] = calc_expect(prb)
qs.free()
de_tmp = make_densop(expect, qubit_num, pauli_mat)
if i == 0:
de_tmp.mul(prob[i])
densop_est = de_tmp.clone()
else:
de_tmp.mul(prob[i])
densop_est.add(de_tmp)
de_tmp.free()
return densop_est
if __name__ == '__main__':
# settings
qubit_num = 2
mixed_num = 4
shots = 100
# quantum state ensemble (original)
qstate, prob = random_qstate_ensemble(qubit_num, mixed_num)
# density operator (original)
densop_ori = DensOp(qstate=qstate, prob=prob)
# density operator estimation only from quantum state ensemble
# (quantum state tomography)
densop_est = estimate_densop(prob,qstate,shots)
print("** density operator (original)")
densop_ori.show()
print("** density operator (estimated)")
densop_est.show()
print("** fidelity =",densop_ori.fidelity(densop_est))
for q in qstate:
q.free()
densop_ori.free()
densop_est.free()
Je vais vous expliquer ce que vous faites. Regardez la section de traitement principale.
# settings
qubit_num = 2
mixed_num = 4
shots = 1000
C'est la valeur de réglage pour la simulation. qubit_num est le nombre de quantum supposé, mixed_num est le nombre d'états purs à mélanger et coups est le nombre de mesures.
# quantum state ensemble (original)
qstate, prob = random_qstate_ensemble(qubit_num, mixed_num)
Ici, nous créons au hasard un ensemble d'états quantiques. qstate est une liste de quatre états quantiques. prob est une liste de probabilités qui déterminent la proportion des quatre états purs à mélanger. L'état pur et la probabilité sont tous deux déterminés au hasard. Voir la définition de la fonction pour plus de détails.
# density operator (original)
densop_ori = DensOp(qstate=qstate, prob=prob)
C'est là que qlazy est utilisé pour calculer la vraie valeur de l'opérateur de densité auquel nous pensons. Enfin, il est utilisé comme valeur de référence pour l'évaluation de la précision.
# density operator estimation only from quantum state ensemble
# (quantum state tomography)
densop_est = estimate_densop(prob,qstate,shots)
C'est la partie de l'estimation de l'opérateur de densité qui est la clé de ce temps, je vais donc l'expliquer un peu plus en détail. Regardez le contenu de la fonction estimation_densop.
def estimate_densop(prob,qstate,shots):
pauli_mat = [np.eye(2), # = I
np.array([[0,1],[1,0]]), # = X
np.array([[0,-1j],[1j,0]]), # = Y
np.array([[1,0],[0,-1]])] # = Z
mixed_num = len(prob)
qubit_num = qstate[0].qubit_num
measure_num = 4**qubit_num
...
Le premier pauli_mat définit la matrice de Pauli. mixed_num et qubit_num sont calculés à nouveau à partir des arguments. A partir de qubit_num, le nombre de combinaisons d'opérateurs Pauli peut être obtenu par 4 ** qubit_num (il est stocké dans la variable mesure_num).
La prochaine boucle for est
for i in range(mixed_num):
expect = {}
for index in range(measure_num):
pauli_index = get_pauli_index(index,measure_num)
...
Il est doublé comme. La boucle for externe sert à estimer l'opérateur de densité pour chaque état pur mélangé. Plus tard, nous pondérerons les probabilités et les additionnerons pour créer l'opérateur de densité final [^ 5].
[^ 5]: Si vous voulez vous rapprocher d'une expérience plus réaliste, il aurait été préférable d'implémenter cette partie pour qu'un des états purs puisse voler et mesurer une fois, et ainsi de suite. Cependant, je pensais que le code serait long et difficile à comprendre, j'ai donc sauté un peu l'implémentation.
La boucle for interne sert à calculer la valeur attendue pour le nombre de fois où l'opérateur Pauli peut être combiné. Tout d'abord, initialisez le dictionnaire attendu pour stocker les valeurs attendues correspondant à chaque combinaison sous forme de dictionnaire vide. Répétez pour le nombre de mesure_num ci-dessus, mais le numéro de combinaison sera dans l'index de la variable. Puisqu'il ne s'agit que d'une valeur entière, il est difficile de contrôler la direction de mesure de chaque bit quantique. Ainsi, la fonction get_pauli_index le convertit en une liste de numéros d'opérateurs Pauli. Convertissez la valeur entière en quaternaire et renvoyez chaque chiffre sous forme de liste. Voir la définition de la fonction pour plus de détails.
Vient ensuite le contenu de cette boucle for.
if index == 0:
expect[index] = 1.0
continue
qs = qstate[i].clone()
for qid in range(len(pauli_index)):
if pauli_index[qid] == 0:
continue
elif pauli_index[qid] == 1:
qs.h(qid)
elif pauli_index[qid] == 2:
qs.s_dg(qid).h(qid)
else:
pass
frq = qs.m(shots=shots).frq
prb = np.array([f/shots for f in frq])
expect[index] = calc_expect(prb)
qs.free()
Si index = 0, la valeur attendue est définie sur 1 quelle que soit la présence ou l'absence. Si non,
qs = qstate[i].clone()
Donc, copiez le i-ème état pur et stockez-le dans qs comme temporaire [^ 6].
[^ 6]: Puisqu'il s'agit d'un simulateur, je le copie facilement, mais lorsque je le fais dans une expérience réelle ou un véritable ordinateur quantique, cette partie génère plusieurs fois la même chose à partir du générateur quantique, ou du même circuit quantique Il est nécessaire d'effectuer l'opération consistant à faire passer l'état plusieurs fois.
Ensuite, la boucle for est sortie à nouveau.
for qid in range(len(pauli_index)):
...
C'est pour la porte quantique à appliquer avant la mesure car chaque bit quantique est mesuré dans l'ordre dans la direction de mesure correspondant au numéro d'opérateur Pauli. Le contenu est comme vous pouvez le voir ci-dessus. Quand la boucle est terminée
frq = qs.m(shots=shots).frq
prb = np.array([f/shots for f in frq])
expect[index] = calc_expect(prb)
qs.free()
C'est dit. Vous effectuez maintenant la mesure réelle. Puisque la photo était de 1000, je mesurerai 1000 fois [^ 7]. En conséquence, une liste de fréquences est obtenue, donc normalisez-la de sorte que la somme soit 1 pour la probabilité. Passez-le à la fonction calc_expect pour calculer la valeur attendue. Puisque nous supposons maintenant 2 états quantiques, la probabilité est de 4. Chacun d'eux représente un ensemble particulier d'opérateurs Pauli. Pour un ensemble particulier d'opérateurs de Pauli, les mesures à deux quantiques peuvent être calculées comme le produit de chacune (qui peut être +1 ou -1). Une fois les quatre probabilités et les quatre valeurs mesurées déterminées, la valeur attendue peut être calculée. La fonction calc_expect fait cela. Voir la définition de la fonction pour plus de détails. Après avoir utilisé qs, libérez la mémoire avec qs.free () [^ 8].
[^ 7]: Là encore, l'implémentation est ignorée par le traitement propre au simulateur. Dans une expérience réaliste, qs doit vraiment être généré et mesuré plusieurs fois.
[^ 8]: Ce processus est important lorsque vous utilisez plusieurs fois le même état quantique dans une boucle. qlazy utilise la bibliothèque de langage C à l'intérieur, et alloue également de la mémoire dans le monde C. Par conséquent, la spécification est que la mémoire doit être explicitement libérée pour l'état quantique et l'opérateur de densité. Je l'ai laissé à \ _ \ _ del \ _ \ _ de Python et j'ai essayé une spécification qui ne la publie pas explicitement, mais je ne sais pas quand la mémoire sera libérée du côté Python, donc je suis suspect. Puisqu'il y avait des cas où cela a été fait, nous avons fait cette spécification.
de_tmp = make_densop(expect, qubit_num, pauli_mat)
if i == 0:
de_tmp.mul(prob[i])
densop_est = de_tmp.clone()
else:
de_tmp.mul(prob[i])
densop_est.add(de_tmp)
Une fois les quatre valeurs attendues trouvées, la fonction make_densop calcule une fois l'opérateur de densité pour cet état pur (voir la définition de la fonction pour plus de détails sur make_densop). Additionnez les poids des probabilités par le nombre de nombres mixtes (4). L'instruction if est ce processus. Après avoir quitté la boucle externe, nous avons le dernier densop_est, donc nous le retournerons.
Revenir à la section principale de traitement
print("** density operator (original)")
densop_ori.show()
print("** density operator (estimated)")
densop_est.show()
print("** fidelity =",densop_ori.fidelity(densop_est))
Maintenant, les éléments de l'opérateur de densité réelle (densop_ori) et les éléments de l'opérateur de densité estimée (densop_est) sont affichés dans l'ordre, et enfin la fidélité des deux est calculée et affichée.
Le résultat de la simulation s'affiche.
Le programme ci-dessus était pour estimer 2 états quantiques, mais tout d'abord, il est pour estimer 1 état quantique. Les paramètres sont
qubit_num = 1
mixed_num = 2
shots = 100
C'était fabriqué. Quand je l'ai couru
** density operator (original)
elm[0][0] = +0.3270-0.0000*i : 0.1069 |++
elm[0][1] = +0.1508-0.2138*i : 0.0684 |++
elm[1][0] = +0.1508+0.2138*i : 0.0684 |++
elm[1][1] = +0.6730+0.0000*i : 0.4530 |++++++
** density operator (estimated)
elm[0][0] = +0.3224+0.0000*i : 0.1040 |++
elm[0][1] = +0.1584-0.1887*i : 0.0607 |++
elm[1][0] = +0.1584+0.1887*i : 0.0607 |++
elm[1][1] = +0.6776+0.0000*i : 0.4591 |++++++
** fidelity = 0.9996155234243419
est devenu. Puisque la fidélité est de 0,9996 ..., je pense avoir pu l'estimer avec une précision considérable.
Vient ensuite l'estimation de l'état à deux quantités. Les paramètres sont
qubit_num = 2
mixed_num = 4
shots = 1000
Je l'ai essayé. Puisque l'élément de l'opérateur de densité devient long, si seule la fidélité est affichée,
** fidelity = 0.9814099144563044
Et la précision a un peu baissé. Cependant, pour le moment, je pense avoir atteint l'objectif d'étudier la tomographie d'état quantique, donc je vais laisser ça aussi bon ici [^ 9].
[^ 9]: Quantum Information Engineering a la description suivante. «Dans le cas d'un bit quantique, c'est relativement facile comme ça, mais pour déterminer l'état de plusieurs bits quantiques, il est nécessaire de déterminer la composante de l'opérateur de densité qui augmente dans l'ordre du carré du nombre de bits quantiques. Par conséquent, il est nécessaire. De plus, si l'état se trouve être un état pur, le rang de la matrice de densité sera 1 (un élément diagonal sera laissé et tous les autres éléments seront 0), ce qui n'est pas nécessaire. Il semble qu'il soit assez difficile d'estimer les paramètres. " Lorsque vous le simulez réellement, vous pouvez réaliser ce genre de difficulté.
Cette fois, nous avons repris la "tomographie d'état quantique" pour estimer l'état, mais il existe également une méthode appelée "tomographie de processus quantique" qui estime le "processus" plutôt que "l'état". C'est une méthode d'estimation de l'opérateur de Klaus qui représente les changements dans le système physique, et semble fondamentalement être une méthode d'utilisation répétée de cette tomographie «d'état». Cependant, je n'ai pas encore étudié, alors saisissez à nouveau cette occasion.
La prochaine fois, je pense à des sujets liés à la communication quantique. Je voudrais aborder la "compression de données", qui est une méthode de communication en mettant l'état quantique lui-même sur le canal de communication quantique au lieu des informations classiques (bien que le calendrier soit indécis).
c'est tout
Recommended Posts