INFOQCh2 MesureetOperateurs PDF

ÉLÉMENTS CALCULS ET
INFORMATION QUANTIQUES
Simulations avec le Quantum Toolbox in Python
NANA ENGO
ALHADJI MALLOUM
BSM
|ψi • W D0 • b0
|0i W • X D1 • b1
|0i X X Z |ψi
EPR U
Circuit intraportation
The Publisher N E 19 avril 2018

ii
Table des matières
2 Mesure de l’information et opérateurs linéaires 1
2.1 Mesure de grandeurs physiques et opérateurs . . . . . . . . . . . . . . . . . . . . 1
2.1.1 Mesure de grandeurs physiques . . . . . . . . . . . . . . . . . . . . . . . 2
2.1.2 Autres Expériences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.3 Point sur la mesure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Opérateurs linéaires et représentation matricielle . . . . . . . . . . . . . . . . . . 7
2.2.1 Linéarité et représentation matricielle . . . . . . . . . . . . . . . . . . . . 7
2.2.2 Hermiticité et fonction d’un opérateur . . . . . . . . . . . . . . . . . . . 9
2.2.3 Unitarité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.4 Projection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2.5 Matrices de Pauli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 QuTiP - États et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.1 États et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.2 Attributs d’une classe Qobj et fonction opérant sur cette classe . . . . . . 19
2.3.3 Qobj Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3.4 Valeurs moyennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.5 Sphère de Bloch et les classes Bloch et Bloch3d . . . . . . . . . . . . . . 28
2.4 Décomposition spectrale des opérateurs hermitiens . . . . . . . . . . . . . . . . . 30
2.4.1 Diagonalisation d’un opérateur hermitien . . . . . . . . . . . . . . . . . . 31
iii
iv Table des matières
2.4.2 Ensemble complet d’opérateurs compatibles (ECOC) . . . . . . . . . . . 37
2.4.3 QuTiP - Diagonalisation simultanée . . . . . . . . . . . . . . . . . . . . . 42
2.5 Inégalités d’Heisenberg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.6 Exercices supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.7 Solutions des Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
A Installation de QuTiP et commandes usuelles 59
A.1 Installation de QuTiP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
A.2 Vérification de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
A.3 Vérification des versions des logiciels de base l’installation . . . . . . . . . . . . . 60
A.3.1 Sauvegarde des fichiers de résultats des exercices . . . . . . . . . . . . . . 61
A.4 Commandes usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
A.4.1 Charger les modules QuTiP . . . . . . . . . . . . . . . . . . . . . . . . . 61
A.4.2 Quantum object class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
A.4.3 Sauvegarder les objets QuTiP et les données . . . . . . . . . . . . . . . . 63

Chapitre 2
Mesure de l’information et opérateurs linéaires
Sommaire
2.1 Mesure de grandeurs physiques et opérateurs
2.2 Opérateurs linéaires et représentation matricielle
2.3 QuTiP - États et opérateurs
2.4 Décomposition spectrale des opérateurs hermitiens
2.5 Inégalités d’Heisenberg
2.6 Exercices supplémentaires
2.7 Solutions des Exercices
Maintenant que nous sommes entrés dans le monde quantique, il est légitime de se demander
comment on y extrait l’information ou comment on y effectue la mesure sur un système. On le
fait grâce aux opérateurs qui sont des représentations mathématiques des grandeurs physiques
( section 2.1). L’essentiel de ce chapitre, très mathématique, est donc consacrée à l’algèbre
des opérateurs linéaires, à l’étude des propriétés des opérateurs hermitiens, opérateurs associés
aux grandeurs physiques (section 2.2). La section 2.3 est consacrée à l’apprentissage de la
représentation des vecteurs d’état et opérateurs avec l’excellente bibliothèque python QuTiP.
La décomposition spectrale (section 2.4) les fameuses inégalités d’Heisenberg (section 2.5)
achèvent ce chapitre.
2.1 Mesure de grandeurs physiques et opérateurs
La théorie quantique est avant tout une théorie des phénomènes microscopiques ou plus exacte-
ment nanoscopiques (10−9 ). Mais la physique est macroscopique (les microscopes, accélérateurs
de particules, etc., sont des objets macroscopiques), et il est donc indispensable que les résul-
tats simples de la théorie classique puissent se retrouver en théorie quantique. D’autre part,
1
2 2. Mesure de l’information et opérateurs linéaires
contrairement à la situation classique, il y a indéterminisme dans la mesure, vu que nous ne

saurons dire exactement où est passé le quanton lorsqu’on observe une interférence avec des
fentes de Young ou un interféromètre de Mach Zehnder. De ce fait, il est donc important de
se munir d’une théorie de la mesure, afin d’éviter de transposer au monde nanoscopique notre
expérience journalière qui est macroscopique1 .
Définition 2.1.1 – Mesure en théorie quantique

Une mesure est le résultat d’une interaction temporaire entre le système et
un appareil de mesure (qui peut être un homme). Or comme il y a un quantum d’ac-
tion minimale, h̄2 (il y a un minimum de changement dans la nature), on ne peut
éviter que l’observation influence ou perturbe le système quantique. C’est pourquoi toute
description précise de l’observation doit inclure une description de cette perturbation qui
est modélisée par un changement d’état.
2.1.1 Mesure de grandeurs physiques
Reprenons le chemin du laboratoire où d’une source nous faisons sortir un jet monocinétique
d’atomes électriquement neutres argent (Ag), paramagnétiques, porteurs d’un moment magné-
tique intrinsèque de spin. Nous avons ainsi préparer N quantons indépendamment dans le même
état |ψi. Ces atomes traversent l’entrefer d’un aimant où règne un fort gradient d’induction
magnétique ∂B ∂z . Chaque atome est alors soumis à une force Fz = µz ∂z , où µz est la projection
∂B
du moment magnétique de spin de l’atome sur le vecteur unitaire z. Lorsque l’induction ma-
gnétique est nulle, on observe, sur une plaque de verre placée perpendiculairement au jet à une
certaine distance de la sortie de l’entrefer, une tache unique de dimension finie en raison de la
dispersion des vitesses. En présence du gradient d’induction magnétique, la théorie classique
prévoit un élargissement de la tache précédente du fait de l’orientation à priori aléatoire des
moments magnétiques µ lors de la production des atomes2 .
Jet d’atomes d’Ag
Prédiction classique
N
Observation
Source
S
Champ magnétique inhomogène
Figure 2.1.1 – Expérience de Stern et Gerlach : classiquement, on devrait avoir une tache unique de
dimension finie, mais on observe plutôt deux taches symétriques d’égales intensités aux points (z+ ) et (z− ).
Cependant, on observe (voir la Figure 2.1.1), que les impacts des atomes, pourtant iden-
tiques, se répartissent en deux taches quasi-ponctuelles d’égales intensités I+ et I− (de moment
1 Maisoù est la limite entre le monde macroscopique et le monde microscopique ?
2 Les
atomes de moment magnétique µ antiparallèle à Oz devraient subir une déviation maximale vers le haut
pour ∂B
∂z < 0. Ceux de µ parallèle à Oz, une déviation maximale vers le bas. Toutes les déviations intermédiaires
étant possibles.
2.1. Mesure de grandeurs physiques et opérateurs 3
magnétique de spin µ+ = + h̄2 et µ− = − h̄2 ), de part et d’autre du point d’impact en absence

d’induction magnétique, à égale distance, i.e., P+ = P− = 12 . On notera |+i (up) et |−i (down)
l’état des atomes de moment magnétique de spin µ+ = + h̄2 et µ− = − h̄2 .
Il apparaît que l’appareil de Stern et Gerlach instaure une corrélation dans le faisceau
émergent entre l’état de spin et sa situation spatiale. On reconnaît alors un spin up à ce qu’il a
comme point d’impact la position (z+ ) et un spin down à ce qu’il y a comme point d’impact la
position (z− ). La distance entre ces deux points étant proportionnelle au gradient ∂B∂z . Ainsi, un
atome initialement dans un état de spin quelconque |ψi (orientation des moments magnétiques
à priori quelconque), donne après une mesure de la grandeur physique spin S, une valeur
µ+ = + h̄2 ou µ− = − h̄2 , signifiant qu’après la mesure l’atome est dans l’état |+i ou |−i. Ainsi,
lors de son interaction avec l’appareil de mesure, le quanton change d’état. On
dit qu’il y a réduction du paquet d’ondes, autrement, la mesure a perturbé le système.
Cette réduction force l’émergence classique d’un résultat unique.
Principe 2.1.1 – Réduction du paquet d’ondes

Après une mesure sur un système quantique, on modifie en général l’état de ce système.
L’ensemble {µ+ , µ− } est l’ensemble complet des résultats de la mesure de S puisque ce

sont les seules modalités qu’on peut obtenir lors de cette mesure. Cet ensemble complet de
résultats est obtenu avec N atomes paramagnétiques dans le même état |ψi. Donc avant la
mesure, le système est dans l’état superposé (exploration de tous les chemins possibles)
|ψi = |ii hi |ψi = α+ |+i + α− |−i . (2.1.1)

X
Les amplitudes α± = h± |ψi décrivent l’orientation du spin dans l’espace tridimensionnel : ce

sont des coordonnées ou amplitudes de projections dans la base des états de spin {|+i , |−i}.
Du point de vue classique, cette situation est paradoxale puisque le comportement de chaque
atome ne peut être prédit, bien qu’il soit tous préparés de la même façon et indépendamment.
Dans chaque atome individuel, il existe l’alternative dichotomique d’être dans l’état spin up ou
spin down.
Les probabilités d’obtenir les moments magnétiques de spin µ+ et µ− sont donc
P+ = |h+ |ψi |2 = |α+ |2 et P− = |h− |ψi |2 = |α− |2 , (2.1.2)
avec
1
α+ = α− = √ . (2.1.3)
2
Par suite, la probabilité totale est (complétude du système)
P = |α+ |2 + |α− |2 = 1. (2.1.4)
L’effet de l’appareil de mesure est décrit par l’opérateur S qui opère sur l’état |ψi pour
donner |+i ou |−i, états propres de S avec les valeurs propres + h̄2 ou − h̄2 :
+ 2 |+i ,
h̄



S |ψi = ou (2.1.5)
 h̄

− 2 |−i .
On dit que l’opérateur transforme un vecteur d’état de l’espace de Hilbert en un autre vecteur
d’état du même espace de Hilbert.
Autrement, le lien entre ce qu’on peut observer du système, une grandeur physique A, et
le système, se fait à travers le lien entre l’opérateur A associé à cette grandeur physique
et le vecteur d’état.
Autant que possible, nous utiliserons des lettres majuscules (droites) pour les opérateurs.
2.1.2 Autres Expériences
|+iz |+iz |+iz
Sz Sz Sz
|−iz |−iz |−iz
Splitter Filtre ne laissant passer que |+iz Filtre ne laissant passer que |−iz
Figure 2.1.2 – Stern et Gerlach comme séparateur du jet atomique ou splitter et comme filtres.
Nous allons maintenant réaliser diverses expériences sur le spin en utilisant les symboles de
la Figure 2.1.2 pour les divers rôles des appareils de Stern et Gerlach.
Première expérience SG1

A la sortie du filtre de la Figure 2.1.3, chaque atome est dans un état propre de l’opérateur Sz
que l’on mesure. Le résultat de la mesure est donc certain : on trouve à coup sûr la valeur
propre correspondante + h̄2
h̄
P(+ ) = |h+ |+i |2 = 1. (2.1.6)
2
|+iz |+iz |+iz |+ix

50%
Sz Sz Sz Sx
|−iz |−iz |−ix
50%
Figure 2.1.3 – Mesure de Sz dans l’état |+i. Figure 2.1.4 – Mesure de Sx dans l’état |+i.
2.1. Mesure de grandeurs physiques et opérateurs 5
Deuxième expérience SG2

A la sortie du filtre de la Figure 2.1.4, chaque atome qui entre dans le splitter orienté dans
la direction Ox est dans l’état |+i. Lors du processus de mesure de la grandeur Sx , il y a
indétermination dans le comportement de chaque atome puisque |+i n’est pas un état
propre de l’opérateur Sx . Cet opérateur à pour valeurs propres + h̄2 et − h̄2 associées respective-
ment aux états propres |+ix et |−ix . C’est parce que |+i se projette dans la base {|+ix , |−ix }
qui diagonalise Sx qu’on observe à la sortie deux faisceaux d’égales intensités, i.e.,
1. un faisceau où les atomes ont un spin + h̄2 avec la probabilité |x h+ |+i |2 = 12 ;
2. un faisceau où les atomes ont un spin − h̄2 avec la probabilité |x h− |+i |2 = 12 .
Troisième expérience SG3

|+iz |+ix |+iz
50%
Sz Sx Sz
|−iz |−ix |−iz
50%
Figure 2.1.5 – Incompatibilité des mesures de Sz et Sx .
On filtre maintenant |+i que fait pénétrer dans Sx . On filtre la sortie de ce SG pour ne
laisser sortir que |+ix qui va pénétrer dans un Sz . On constate avec surprise qu’on a à la sortie
des atomes dans les états propres |+i et |−i de Sz , alors que |−i a été exclus à la sortie du
premier SG, Sz .
Cette expérience met en exergue le fait qu’en théorie quantique, l’état final du système
dépend seulement de l’état de l’atome qui entre dans le dernier SG et de son action avec cet
appareil. Autrement, il n’y a pas de mémoire sur l’histoire passée du système.
En clair, comme le faisceau qui entre dans le dernier SG, Sz est dans l’état |+ix qui n’est
pas état propre de Sz , il va se projeter dans la base {|+i , |−i} des états propres de Sz . C’est
pourquoi on a
1. un faisceau où les atomes ont un spin + h̄2 avec la probabilité |h+ |+ix |2 = 12 ;
2. un faisceau où les atomes ont un spin − h̄2 avec la probabilité |h− |+ix |2 = 12 .
2.1.3 Point sur la mesure
Il découle de ce qui précède que :
1. L’acte de mesure modifie généralement d’une manière instantanée le système de façon

irréversible : c’est la réduction du paquet d’onde.
2. Le résultat complet de la mesure expérimentale de la grandeur physique A sur le

système consiste à déterminer les modalités ai (résultats de la mesure) et les amplitudes
de probabilité αi ou les probabilités Pi = |αi |2 . Autrement dit, il s’agit d’extraire des
nombres contenus dans le vecteur d’état |ψi.
3. Les modalités ai dépendent de la nature du système et les amplitudes de probabilité αi
dépendent de l’état du système ou du vecteur d’état |ψi.
4. L’opérateur A extrait de |ψi l’information physique sur la grandeur physique A. |ψi
décrit la réalité physique d’un système quantique individuel.
5. Lorsqu’on a un seul système dans l’état |ψi, si une seule mesure de A donne la modalité
ai , le système est après cette mesure dans l’état |ϕi i associé à ai
|ϕi i = |Aψi = A |ψi , (2.1.7)
A est l’opérateur (hermitien)3 associé à la grandeur physique A. Si on répète cette mesure
de A immédiatement après sur le système, qui est alors dans l’état |ϕi i, on obtiendra
de façon certaine la même modalité ai avec la probabilité 1 :
A |ϕi i = ai |ϕi i ou A = |ϕi i ai hϕi | (2.1.8a)
P(ai ) = |hϕi |ϕi i | = | |ϕi i | = 1.
2 2
(2.1.8b)
Autrement dit, à chaque résultat possible ai de la mesure correspond un état |ϕi i possé-
dant la propriété ci-dessus, que nous appellerons état propre4 ou vecteur propre de
l’opérateur A ; ai est appelée valeur propre de l’opérateur A.
Donc, la mesure de A sur un seul système dans l’état |ψi donne l’information
sur l’état du système après la mesure.
6. Pour obtenir l’information sur l’état du système avant la mesure il faut effectuer N
mesures de A sur N systèmes identiques5 dans l’état |ψi afin d’obtenir toutes les
modalités possibles ai :
|ψi = |ϕi i hϕi | |ψi = (2.1.9a)
X X
αi |ϕi i ,
i i
A |ψi = αi A |ϕi i = (2.1.9b)
X X
αi ai |ϕi i .
i i
L’ensemble des états propres |ϕi i de la grandeur physique forme une base orthonormée

1, si i = j.
hϕi |ϕj i = (2.1.10)
0, sinon.
D’où les propriétés suivantes de leurs probabilités de transition
P(hϕi |ϕj i) = 0, ∀i, j i 6= j (disjonction),
(2.1.11)
i P(hϕi |ψi) = 1, ∀ |ψi (complétude).
P
3 Les
propriétés d’un opérateur hermitien sont étudiées à la section 2.2
4 C’est
un état simple qui peut être qualifié de "déterministe".
5 On peut par exemple réaliser une expérience de Stern et Gerlach avec N voies de sorties au lieu de deux
voies |+i et |−i et un détecteur associé à chaque voie.

2.2. Opérateurs linéaires et représentation matricielle 7
2.2 Opérateurs linéaires et représentation matricielle
Principe 2.2.1 – Grandeur physique et opérateur

A chaque grandeur physique A, l’on peut associer un opérateur A, qui est linéaire
hermitien agissant dans l’espace de Hilbert H, tel que la valeur moyenne haiψ des
résultats d’une mesure de la grandeur A pour un quanton dans l’état |ψi soit
hai = hψ| A |ψi . (2.2.1)
Les opérateurs de la théorie quantique sont linéaires et cette linéarité est intimement lié au
principe de superposition.
2.2.1 Linéarité et représentation matricielle
On appelle opérateur linéaire A de H, toute application linéaire
A: H −→ H
(2.2.2)
|ψi −→ |ϕi = |Aψi ≡ A |ψi
vérifiant la propriété
|A(λ1 ψ1 + λ2 ψ2 )i = λ1 |Aψ1 i + λ2 |Aψ2 i = λ1 |ϕ1 i + λ2 |ϕ2 i . (2.2.3)
Un exemple simple d’opérateur linéaire est l’opérateur identité I :
|Iψi = |ψi . (2.2.4)
L’algèbre sur ces opérateurs est la suivante,
|(λA)ψi = λ |Aψi , (2.2.5a)

|(A + B)ψi = |Aψi + |Bψi , (2.2.5b)
|(AB)ψi = |A(Bψ)i . (2.2.5c)
Afin de déterminer l’effet de l’opérateur linéaire A sur n’importe quel état |ψi dans une
base {|ii}, utilisons la décomposition (2.1.9a)

|ϕi = A |ψi = P |ii hi| A |ψi ,
i
⇒ |ϕi = (2.2.6)
X
|ii hi| A |ji hj |ψi .
|ψi = j |ji hj |ψi ,
 P
i,j
Il apparaît ainsi que si l’on connaît les matrices d’amplitudes ou éléments de matrice
Aij = hi| A |ji = hi |Aji , (2.2.7)

entre tous les états {|ii} de cette base, on peut déterminer l’effet de l’opérateur A sur n’importe
quel état |ψi.
Si la base {|ii} à n états, alors les amplitudes (n × n) de l’équation (2.2.7) définissent

complètement l’opérateur A.
Les opérateurs sont donc définis par les matrices d’amplitudes (n × n) dans une repré-
sentation particulière
|Aji −→
A11 A12 · · · A1j · · ·
 
A
 21 A22 · · · A2j · · ·
A −→ hi| A |ji = hi |Aji = Aij ⇐⇒  . .. (2.2.8)

 .
 ..
hi| ↓  . 

Ai2 · · · Aij · · ·
 
 Ai1
.. .. ..
 
. . .
Les amplitudes dans une matrice définissant l’opérateur A dépendent de la représentation.

La transformation des éléments de matrices lors d’un changement de base est
hν| A |µi = (2.2.9)

X
hν |ii hi| A |ji hj |µi ,
ij
où hν |ii et hj |µi sont les éléments de la transformation de la base {|ii} à la base {|µi} et
vice-versa.
Exemple 2.2.1 – Représentation matricielle des opérateurs X et P

√
Soient les opérateurs X = αx et P = √1α dxd d
. L’action des opérateurs x et dx sur les états
|ni d’un oscillateur harmonique donne les fonctions d’Hermite suivantes :
√ √ √
2αx |ni = n + 1 |n + 1i + n |n − 1i , (2.2.10a)
s
2 d √ √
|ni = − n + 1 |n + 1i + n |n − 1i . (2.2.10b)
α dx
Les matrices des opérateurs X et P sur les états |ni sont

1 √
Xmn = hm| X |ni = √ hm| 2αx |ni
2
1 √ √
= √ ( n + 1hm |n + 1i + nhm |n − 1i) (2.2.11)
2
1 √ √
= √ ( n + 1δm,n+1 + nδm,n−1 ),
2
et
s
1 2 d
Pmn = hm| P |ni = √ hm| |ni
2 α dx
1 √ √
= √ (− n + 1hm |n + 1i + nhm |n − 1i) (2.2.12)
2
1 √ √
= √ (− n + 1δm,n+1 + nδm,n−1 ).
2
Pour n, m ∈ [0, 3] on a les représentations matricielles ci-dessous.
Xmn |X0i |X1i |X2i |X3i Pmn |P 0i |P 1i |P 2i |P 3i
h0| 0 √1
2
0 0 h0| 0 √1
2
0 0
h1| √1
2
0 1 0 h1| − √12 0 1 0
q q
h2| 0 1 0 3
2 h2| 0 −1 0 3
2
q q
h3| 0 0 3
2 0 h3| 0 0 − 3
2 0
2.2.2 Hermiticité et fonction d’un opérateur
L’opérateur adjoint ou hermitien conjugué A† de A est défini par
hϕ| A† ψi = hAϕ |ψi = hψ| Aϕi∗ , |ψi , |ϕi ∈ H. (2.2.13)
On montre facilement que
(A† )† = A, (2.2.14a)
(λA + µB)† = λ∗ A† + µ∗ B † , (2.2.14b)
† † †
(AB) = B A . (2.2.14c)
Algorithme pour prendre le conjugué hermitien d’une expression donnée :
1. renverser l’ordre des termes ;
2. remplacer
(a) les opérateurs par leurs adjoints ;

(b) les kets par les bras et réciproquement ;
(c) les nombres par leurs complexes conjugués.
Exemple 2.2.2 – Hermitien conjugué - Forme vectorielle
(λ hϕ| AB |ψi hχ| C † )† = C |χi hψ| B † A† |ϕi λ∗ . (2.2.15)

(2 |0i h1| − i |1i h0|)† = +i |0i h1| + |1i h0| 2. (2.2.16)
Pas du tout compliqué n’est-ce pas ? ! ! ! !
Dans la base {|ii}, l’opérateur adjoint A† vérifie

(A† )ij = A∗ji = (Atij )∗ ⇒ A† = (At )∗ . (2.2.17)
Ainsi, les matrices représentant A et A† dans une représentation sont hermitiennes conju-
guées l’une de l’autre, au sens des matrices : on passe de l’une à l’autre par une conjugaison
complexe suivie d’une symétrie par rapport à la diagonale principale.
Il va de soi que lorsque A est une matrice réelle, A† = At .
Exemple 2.2.3 – Hermitien conjugué - Forme matricielle
!†
2 + i −i 2−i 4+i
!
= ; (2.2.18a)
4−i 2+i i 2−i
!†
i 2+i
!
−i −4i
= ; (2.2.18b)
4i 3 − 2i 2 − i 3 + 2i
!†
a + ib c + id
!
a − ib e − if
= ; (2.2.18c)
e + if g + ih c − id g − ih
†
−85 −35 79
  
−85 −55 −37
−35 97 50  = −55 97 56 . (2.2.18d)
  
79 56 49 −37 50 49
Un opérateur A est hermitien ou auto-adjoint, s’il coïncide avec son adjoint :

A† = A. (2.2.19)
Par conséquent 
A†
ij = Aij = Aji si i 6= j,
∗
†
A = Aii = A∗ .
(2.2.20)
ii ii
Ainsi, dans une matrice hermitienne
1. deux éléments quelconques symétriques par rapport à la diagonale principale sont

complexes conjugués l’un de l’autre,
2. les éléments diagonaux sont toujours réels.

Ceci nous permet de comprendre aisément pourquoi Zurek affirme que la réalité serait
quantique mais aurait une apparence classique par le fait que les éléments non diagonaux sont
très petits et leurs effets inobservables de façon pratique.
La forme générale d’une matrice hermitienne 2 × 2 est

!
a11 a12
, (2.2.21)
a∗12 a22
où a11 , a22 ∈ R et a12 à priori complexe.
Les opérateurs de la théorie quantique sont hermitiens. Les importantes consé-

quences sur leurs spectres seront étudiées à la section 2.4.
La fonction d’un opérateur f (A) peut être développée comme une série entière
∞
f (A) = cn An . (2.2.22)
X
Par exemple,
1 1
eA = I + A + A2 + . . . + An + . . . (2.2.23)
2 n!
Si |ψi est vecteur propre de A avec la valeur propre a, |ψi est aussi vecteur propre de
f (A) avec la valeur propre f (a)
∞ ∞
f (A) |ψi = cn An |ψi = cn an |ψi = f (a) |ψi . (2.2.24)
X X
n n
Exemple 2.2.4 – Fonction d’un opérateur
1 0 e1 0
! !
Pour A = , on a l’opérateur eA = .
0 −1 0 e−1
0 1
!
Pour B = , on a pour tout entier n, B 2n = I2 , la matrice unité de rang 2, et
1 0
B 2n+1 = B, et par conséquent,
∞ ∞ ∞ ∞
(iαB)2n X (iαB)2n+1 (iα)2n (iα)2n+1
eiαB = + = I2 +B
X X X
n=0 (2n)! n=0 (2n + 1)! n=0 (2n)! n=0 (2n + 1)! (2.2.25)
= (cos α)I2 + i(sin α)B.
Si les ai sont les valeurs propres de l’opérateur A dans la base {|ϕi i}, la trace de cet
opérateur est la somme de ses éléments diagonaux
Tr(A) = hϕi | A |ϕi i = ai = (2.2.26)

X X X
Aii .
i i i
La trace est invariante dans un changement de base et on a
Tr(A + B) = Tr(A) + Tr(B), (linéarité),

Tr(cA) = c Tr(A), (c ∈ C) (2.2.27)
Tr(AB) = Tr(BA), (propriété cyclique).
Exemple 2.2.5 – Trace d’un opérateur
Dans la base {|0i , |1i}, la trace de l’opérateur
A = 2i |0i h0| + 3 |0i h1| − 2 |1i h0| + 4 |1i h1| (2.2.28a)
est
Tr(A) = h0| A |0i + h1| A |1i = 2i + 4. (2.2.28b)
2.2.3 Unitarité
Un opérateur S est dit unitaire s’il est l’inverse de son adjoint, i.e.,
S † = S −1 , i.e.,SS † = S † S = I, (2.2.29)
et par conséquent conserve la norme de tout vecteur d’état,
kS |ψi k2 = hψ| S † S |ψi = k |ψi k2 . (2.2.30)
Preuve. Si |ψi i et |ϕi i sont deux bases orthonormées complètes, et si
S |ψi i = |ϕi i , (2.2.31)
alors
S = SI = S |ψi i hψi | = (2.2.32)
X X
|ϕi i hψi | ,
i i
et
S† = (2.2.33)
X
|ψi i hϕi | .
i
Et par suite,
SS † = |ϕi i hψi |ψj i hϕj | = |ϕi i δij hϕj | = I. (2.2.34)
X X
i,j i,j
Remarque 2.2.1 – Action d’un opérateur unitaire sur un état normé
Pour une colonne donnée, i |Sij |2 = 1 et pour une ligne donnée, j |Sij |2 = 1. Par
P P
conséquent, le résultat de l’action d’un opérateur unitaire sur un état normé donne un
état normé. On verra par la suite qu’il en résulte une non perte de l’information.
On peut construire des opérateurs unitaires par exponentiation d’opérateurs hermitiens A

S(λ) = e−iλA , (2.2.35)
avec λ une paramètre continu réel. De plus, S(λ) vérifie la propriété de groupe abélien
S(λ1 + λ2 ) = S(λ1 )S(λ2 ), (2.2.36a)
S(0) = I. (2.2.36b)
La réciproque de cette propriété est le théorème de .
Théorème 2.2.1 – Stone

Soit un ensemble d’opérateurs unitaires dépendant d’un paramètre continu λ et vérifiant
la loi du groupe abélien. Il existe alors un opérateur hermitien G, appelé générateur
infinitésimal du groupe de transformations S(λ) tel que S(λ) = e−iλG .
Preuve. Si δλ → 0,
S(λ + δλ) = S(λ)S(δλ) ' (I − iδλB)S(λ), (2.2.37)
avec
dS

B = i . (2.2.38)

dλ λ=0
Alors
dS(λ)
= −iBS(λ). (2.2.39)
dλ
Par intégration on trouve, en tenant compte de S(0) = I et en posantG = B, S(λ) = e−iλG .
Un opérateur A est une isométrie si

A† A = I, (2.2.40)
puisque le produit scalaire est préservé
D
ϕA† Aψi = hϕ |ψi . (2.2.41)

Il est à noter qu’il existe des opérateurs isométriques non unitaire ou anti-unitaire.
2.2.4 Projection
Une classe importante des opérateurs linéaires hermitiens est celle des opérateurs projecteurs
P caractérisés par les propriétés de normalisation, d’orthogonalité et d’hermiticité suivantes
Pi2 = Pi , (2.2.42a)
Pi Pj = δij Pi , (2.2.42b)
Pi† = Pi . (2.2.42c)
L’opérateur projecteur
m≤n
Pi = (2.2.43)
X
|ii hi| ,
i=1
projette l’état |ψi sur la base orthonormée {|ii} de dimension m du sous-espace H0 de H (qui
est de dimension n) :
Pi |ψi = |ii hi| ψi = hi |ψi |ii = (2.2.44)
X X X
αi |ii .
i i i
On montre facilement que Pi est hermitien
Pi† = ( |ii hi|)† = |ii hi| = Pi , (2.2.45)
X X
i i
et qu’il vérifie la relation de normalisation
Pi2 = |ii hi |ii hi| = |ii hi| = Pi . (2.2.46)
X X
i i
Les seules valeurs propres d’un opérateur projecteur sont 0 et 1. En effet, si |pi est vecteur propre
de l’opérateur P avec la valeur propre p, P |pi = p |pi, la condition nécessaire et suffisante P 2 = P
entraîne
P 2 |pi − P |pi = 0 ⇒ p2 − p = p(p − 1) = 0, i.e., p = 0 ou p = 1. (2.2.47)
Lorsque m = n dans l’équation (2.2.43), on obtient la décomposition de l’opérateur identité

I n
I= (2.2.48)
X
|ii hi| .
i=1
C’est la relation de fermeture. Elle exprime le fait que l’ensemble {|ii} est une base hilber-
tienne.
2.2.5 Matrices de Pauli
Il existe une classe de matrice 2 × 2, très importante en théorie quantique, appelée matrices
de Pauli σi ,
0 1 0 −i 1 0
! ! !
σx = X := , σy = Y := , σz = Z := . (2.2.49)
1 0 i 0 0 −1
Elles sont telles que
σi σj = iεijk σk + δij I, (2.2.50)
où le symbole de Levi-Civita εijk est un tenseur de rang 3 complètement anti-symétrique (dans
l’échange de n’importe quelle paire indices) :
1, pour les permutations circulaires droite de (i, j, k),




εijk := −1, pour les permutations circulaires de 2 indices de (i, j, k), (2.2.51)

0, sinon.


Ces propriétés sont étudiées à l’Exercice 2.6.4

2.3. QuTiP - États et opérateurs 15
2.3 QuTiP - États et opérateurs
QuTiP, Quantum Toolbox in Python, est une bibliothèque libre ou open-source de calculs en
optique quantique avec des applications en information quantique6 . Dans cette section, nous
allons apprendre à utiliser cette excellente bibliothèque pour simuler les concepts fondamentaux
de la théorie quantique que sont les états et les opérateurs.
Nous invitons le lecteur à se rapporter à l’Appendice A pour la procédure d’installation de

QuTiP.
La quasi-totalité des scripts présentés dans cette section ont été faites avec l’interpréteur
IPython7 , et présuppose que les modules de QuTiP ont déjà été chargés.
2.3.1 États et opérateurs
Avec QuTiP, il y a deux façons de créer des états et des opérateurs :
• soit à partir des qutip.Qobj prédéfinis,
• soit en définissant soi-même les données du qutip.Qobj().
Etat - qutip.states
Dans cet ouvrage, les qutip.states qui seront couramment utilisés sont :
basis(N,m)=fock(N,m) N : nombre d’états dans l’espace de Hilbert ;

m :position dans la base
ket(seq,dim) ou bra(seq,dim) seq="0" ou "1" ; dim=2 par défaut
Script QuTiP 2.3.1: Quelques qutip.states prédéfinis

1 In [1]: basis(2,0) # Vecteur de dim N=2, de position m=1-1 dans la base
2 Out[1]:
3 Quantum object: dims = [[2], [1]], shape = [2, 1], type = ket
4 Qobj data =
5 [[ 1.]
6 [ 0.]]
7
8 In [2]: basis(2,1) # Vecteur de dim N=2, de position m=2-1 dans la base

9 Out[2]:
6 qutip.org, J. R. Johansson, P.D. Nation, and F. Nori, QuTiP 2 : A Python framework for the dynamics
of open quantum systems, Comp. Phys. Comm. 184, 1234 (2013) ou arxiv.org/abs/1211.6518
7 Celui intégré à l’IDE Spyder.
11 Qobj data =
12 [[ 0.]
13 [ 1.]]
14
15 In [3]: fock(2,0) # Vecteur de dim N=2, de position m=1-1 dans la base

16 Out[3]:
18 Qobj data =
19 [[ 1.]
20 [ 0.]]
21
22 In [4]: fock(2,1) # Vecteur de dim N=2, de position m=2-1 dans la base

23 Out[4]:
25 Qobj data =
26 [[ 0.]
27 [ 1.]]
28
29 In [5]: ket("1")
30 Out[5]:
31 Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
32 Qobj data =
33 [[ 0.]
34 [ 1.]]
35
36 In [6]:ket("0")
37 Out[6]:
39 Qobj data =
40 [[ 1.]
41 [ 0.]]
42
43 In [7]:bra("0")
44 Out[7]:
45 Quantum object: dims = [[1], [2]], shape = (1, 2), type = bra
46 Qobj data =
47 [[ 1. 0.]]
48
49 In [8]:bra("1")
50 Out[8]:
52 Qobj data =
53 [[ 0. 1.]]
On définit soi-même les données du vecteurs d’etat qutip.states par Qobj([[a1 ],[a2 ],· · · ,[an ]])
pour les vecteurs colonnes ou ket, et Qobj([a1 , a2 , · · · , an ]) pour les vecteurs colonnes ou bra.
1
 
2
 

Par exemple, les vecteurs ligne 1 2 3 4 5 et colonne 3 peuvent être definis avec
 
 
4
 
5
le script suivant :
Script QuTiP 2.3.2: Quelques qutip.states définis

1 In [1]: Qobj([1,2,3,4,5]) # Vecteur ligne
2 Out[1]:
3 Quantum object: dims = [[1], [5]], shape = [1, 5], type = bra
4 Qobj data =
5 [[ 1. 2. 3. 4. 5.]]
6
7 In [2]: Qobj([[1],[2],[3],[4],[5]]) # Vecteur colonne

8 Out[2]:
10 Qobj data =
11 [[ 1.]
12 [ 2.]
13 [ 3.]
14 [ 4.]
15 [ 5.]]
Exemple 2.3.1 – ket et bra avec QuTiP
Dans la base {|u1 i , |u2 i , |u3 i} on considère

1 √ 1
|φi = (|u1 i + |u2 i + 2 |u3 i), hψ| = √ (hu1 | + hu3 |). (2.3.1)
2 2
Sans utiliser des qutip.Qobj prédéfinis, on peut définir |φi et hψ| à travers le script 2.3.3.
Script QuTiP 2.3.3: ket et bra

1 In [1]: Qobj([[1/2.0],[1/2.0],[1/sqrt(2)]]) # Etat |φi
2 Out[1]:
4 Qobj data =
5 [[ 0.5 ]
6 [ 0.5 ]
7 [ 0.70710678]]
8
9 In [2]: Qobj([1/sqrt(2),0,1/sqrt(2)]) # Etat hψ|

10 Out[2]:
12 Qobj data =
13 [[ 0.70710678 0. 0.70710678]]
Exercice 2.3.1 Solution à la page 49
Proposer un script QuTiP traite qui l’Exercice ??.
Opérateurs - qutip.operators
Dans cet ouvrage, les qutip.operators qui seront couramment utilisés sont :
sigmax() σx sigmap() σ+
sigmay() σy sigmam() σ−
sigmaz() σz qeye(N) IN
Script QuTiP 2.3.4: Quelques qutip.operators prédéfinis

1 In [1]: sigmax() # Matrice de Pauli σx
2 Out[1]:
3 Quantum object: dims = [[2], [2]], shape = [2, 2], type = oper, isherm = True
4 Qobj data =
5 [[ 0. 1.]
6 [ 1. 0.]]
7
8 In [2]: sigmay() # Matrice de Pauli σy

9 Out[2]:
11 Qobj data =
12 [[ 0.+0.j 0.-1.j]
13 [ 0.+1.j 0.+0.j]]
14
15 In [3]: sigmaz() # Matrice de Pauli σz

16 Out[3]:
18 Qobj data =
19 [[ 1. 0.]
20 [ 0. -1.]]
21
22 In [4]: sigmap() # Matrice de Pauli σ+

23 Out[4]:
24 Quantum object: dims = [[2], [2]], shape = [2, 2], type = oper, isherm = False
25 Qobj data =
26 [[ 0. 1.]
27 [ 0. 0.]]
28
29 In [5]: sigmam() # Matrice de Pauli σ−

30 Out[5]:
31 Quantum object: dims = [[2], [2]], shape = [2, 2], type = oper, isherm = False
32 Qobj data =
33 [[ 0. 0.]
34 [ 1. 0.]]
35
36 In [6]: qeye(2) # Matrice identité d'ordre 2

37 Out[6]:
39 Qobj data =
40 [[ 1. 0.]
41 [ 0. 1.]]
En définissant soi-même les données de Qobj(array)8 , on definit les opérateurs.
1 1 0
 
Par exemple, on peut définir la matrice carré 3 × 3 A = 1 −1 1 comme dans le script

 
0 1 1
suivant :
Script QuTiP 2.3.5: Matrice carré 3 × 3 avec Qobj défini
1 In [1]: Qobj([[1,1,0],[1,-1,1],[0,1,1]]) # Matrice A
2 Out[1]:
4 Qobj data =
5 [[ 1. 1. 0.]
6 [ 1. -1. 1.]
7 [ 0. 1. 1.]]
2.3.2 Attributs d’une classe Qobj et fonction opérant sur cette classe
Nous avons dit qu’une classe d’objet Qobj() possède des attributs et des fonctions. Le Ta-
bleau 2.3.1 donne les commandes et descriptions de ces attributs et le Tableau 2.3.2 présente
les fonctions les plus usuelles qui agissent sur les instances Qobj().
Attributs Commandes Description

Data Q.data Matrice représentant Q
Dimensions Q.dims Permet d’identifier un système composite
Shape Q.shape Dimension de Q
is Hermitian ? Q.isherm Q est-il hermitien ?
Type Q.type Ket, bra, opérateur ou superopérateur
Tableau 2.3.1 – Description des attributs d’une classe d’objet Qobj.
8 array étant un tableau carré.

Fonction Commande Description

Check Hermicity Q.check_herm() Vérifie l’hermiticité de Q
Conjugate Q.conj() Conjugué de Q
Dagger (adjoint) Q.dag() Conjugué hermitien de Q
Diagonal Q.diag() Matrice diagonale de Q
Eigenenergies Q.eigenenergies() Énergies (valeurs) propres de Q
Eigenstates Q.eigenstates() Valeurs et vecteurs propres de Q
Eliminate States Q.eliminate_states(inds) Renvoie Q sans les états listés en inds
Exponential Q.expm() Matrice exponentielle de Q
Extract States Q.extract_states(inds) Renvoie Q avec uniquement les états listés en inds
Full Q.full() Donne juste la matrice de Q
Groundstate Q.groundstate() Énergie et ket de l’état fondamentale
Matrix Element Q.matrix_element(bra,ket) Éléments de matrice hbra| Q |keti
Norm Q.norm() Norme L2 de l’état
Partial Trace Q.ptrace(sel) Trace partielle choisi par "sel"
Projector Q.proj() Opérateur projecteur du vecteur ket ou bra
Sine Q.sinm() Sinus de l’operateur Q
Sqrt Q.sqrtm() Matrice racine carré de Q
Trace Q.tr() Trace de Q
Transpose Q.trans() Matrice transposé de Q
Unit Q.unit() Renvoie Q normalisé
Tableau 2.3.2 – Fonctions usuelles applicables à une classe d’objet Qobj()
Le scripte ci-dessous présente les attributs et quelques fonctions de l’opérateur de Pauli X.
Script QuTiP 2.3.6: Attributs et quelques fonctions de l’opérateur de Pauli X

1 In [16]: X = sigmax() # Matrice σx
2
3 In [17]: X.data # Affiche l'information sur X

4 Out[17]:
5 <2x2 sparse matrix of type '<type 'numpy.complex128'>'
6 with 2 stored elements in Compressed Sparse Row format>
7
8 In [18]: X.isherm # Indique si X est hermitien ou non

9 Out[18]: True
10
11 In [19]: X.type # Indique la nature de X

12 Out[19]: 'oper'
13
14 In [20]: X.shape # Donne la dimension de X

15 Out[20]: [2, 2]
16
17 In [21]: X = sigmax()
18
19 In [22]: X.dag() # Conjugué hermitien de X

20 Out[22]:
22 Qobj data =
23 [[ 0. 1.]
24 [ 1. 0.]]
25
26 In [23]: evals,evecs=X.eigenstates() # Calcul des valeurs propres et

27 #vecteurs propres de X
28
29 In [24]: evals # Valeurs propres de X

30 Out[24]: array([-1., 1.])
31
32 In [25]: evecs # Vecteurs propres de X

33 Out[25]:
34 array([ Quantum object: dims = [[2], [1]], shape = [2, 1], type = ket
35 Qobj data =
36 [[-0.70710678]
37 [ 0.70710678]],
39 Qobj data =
40 [[ 0.70710678]
41 [ 0.70710678]]], dtype=object)
42
43 In [26]: X.tr() # Calcul la trace de X

44 Out[26]: 0.0
45
46 In [27]: Psi = basis(2,0)+2*basis(2,1) # |ψi = |0i + 2 |1i

47
48 In [28]: Psi # Données du |ψi

49 Out[28]:
51 Qobj data =
52 [[ 1.]
53 [ 2.]]
54
55 In [29]: Psi.dag() # Données du hψ|

56 Out[29]:
58 Qobj data =
59 [[ 1. 2.]]
60
61 In [30]: Psi.unit() # Normalisation de |ψi

62 Out[30]:
64 Qobj data =
65 [[ 0.4472136 ]
66 [ 0.89442719]]
2.3.3 Qobj Math
On peut effectuer sur un objet de classe Qobj(), presque toutes les opérations mathématiques
qu’on peut effectuer sur des variables ordinaires : l’addition, la soustraction, la multiplication,
la puissance, etc.
Le script ci-dessous donne illustre quelques
 opérations mathématiques sur les matrices de
1 1 0

Pauli X, Y et Z ; l’opérateur B = 1 −1 1 et l’opérateur A = 2i |0i h0| + 3 |0i h1| − 2 |1i h0| +

0 1 1
4 |1i h1| (relation Équation 2.2.28).
Script QuTiP 2.3.7: Quelques opérations mathématiques sur les matrices

1 In [31]: X = sigmax() # Matrcie X
2
3 In [32]: Y = sigmay() # Matrice Y

4
5 In [33]: Z = sigmaz() # Matrice Z

6
7 In [34]: X+Z # Addition des matrices X et Z

8 Out[34]:
10 Qobj data =
11 [[ 1. 1.]
12 [ 1. -1.]]
13
14 In [35]: (X+Z)/sqrt(2) # Produit d'un scalaire et de l'addition de X et Z

15 Out[35]:
17 Qobj data =
18 [[ 0.70710678 0.70710678]
19 [ 0.70710678 -0.70710678]]
20
21 In [36]: X*X # X 2
22 Out[36]:
24 Qobj data =
25 [[ 1. 0.]
26 [ 0. 1.]]
27
28 In [37]: commutator(X,Y)
29 Out[37]:
30 Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = False
31 Qobj data =
32 [[ 0.+2.j 0.+0.j]
33 [ 0.+0.j 0.-2.j]]
34
35 In [38]: B=Qobj([[1,1,0],[1,-1,1],[0,1,1]]) # Matrice B

36
37 In [39]: B**3 # B 3
38 Out[39]:
40 Qobj data =
41 [[ 2. 3. 1.]
42 [ 3. -3. 3.]
43 [ 1. 3. 2.]]
44
45 In [40]: commutator(B,B)
46 Out[40]:
47 Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, isherm = True
48 Qobj data =
49 [[ 0. 0. 0.]
50 [ 0. 0. 0.]
51 [ 0. 0. 0.]]
52
53
54 # A = 2i |0i h0| + 3 |0i h1| − 2 |1i h0| + 4 |1i h1|

55
56 In [31]:
57 A=2.j*ket("0")*bra("0")+3*ket("0")*bra("1")-2*ket("1")*bra("0")+4*ket("1")*bra("
58 1")
59
60 In [32]: A
61 Out[32]:
62 Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm = False
63 Qobj data =
64 [[ 0.+2.j 3.+0.j]
65 [-2.+0.j 4.+0.j]]
66
67 In [33]: A.tr()
68 Out[33]: (4+2j)
69
70 In [34]: A.isherm # Test de l'hermiticité

71 Out[34]: False
72
73 # Autre formulation de A
74
75 In [35]: A=2.j*fock(2,0)*fock(2,0).dag()+3*fock(2,0)*fock(2,1).dag()
76
77 In [36]:A=-2*fock(2,1)*fock(2,0).dag()+4*fock(2,1)*fock(2,1).dag()
78
79 In [37]: A
80
81 Out[37]:
82 Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper, isherm =False
83 Qobj data =
84 [[ 0.+2.j 3.+0.j]
85 [-2.+0.j 4.+0.j]]
86
87 In [38]: A.tr()
88 Out[38]:(4+2j)
2.3.4 Valeurs moyennes
La fonction qutip.expect, à travers la commande expect(oper, state), permet de calculer

la valeur moyenne d’un opérateur (oper) dans un état (state) donné.
Script QuTiP 2.3.8: Moyenne de l’opérateur de Pauli X dans l’état |ψi

1 In [38]: X = sigmax()
2
3 In [39]: Psi = (basis(2,0)+basis(2,1))/sqrt(2)

4
5 In [40]: Moy = expect(X,Psi)

6
7 In [41]: Moy
8 Out[41]: 0.9999999999999998
Exemple 2.3.2 – Expectation value of an operator

An operator acts on the qutrit basis states in the following way :
1
A |0i = |1i , A |1i = √ (|0i + |1i), A |2i = |0i . (2.3.2)
2
Find the expectation value hAi in the state
1 i 1
|ψi = |0i − |1i + √ |2i . (2.3.3)
2 2 2
Using the matrix representation, one easy find
0 √1 1 1
  
√ √
1 i 1  2   2i  3 2 + i(2 − 2)
hAi = hψ| A |ψi = ( + √ ) 1 √1
 − 2  =
0   (2.3.4)
2 2 2  2
√1 8
0 0 0 2
Script QuTiP 2.3.9: QuTiP version of Example 2.3.2

1 In [6]: A=Qobj([[0,1/sqrt(2),1],[1,1/sqrt(2),0],[0,0,0]])
2
3 In [7]: psi=.5*basis(3,0)-.5*1.j*basis(3,1)+basis(3,2)/sqrt(2)
4
5 In [8]: Amoy=expect(A,psi)
6
7 In [9]: Amoy
8 Out[9]: (0.5303300858899106+0.073223304703363135j)
9
10 In [10]: (3*sqrt(2)+(2-sqrt(2))*1j)/8 # vérification de la valeur de l'exemple

11 Out[10]: (0.53033008588991071+0.073223304703363107j)
Exemple 2.3.3 – QuTiP version of Example ??

By using an IDE as Spyder, write a QuTiP script of the Example ?? and use the function
print to view the result as Qobj data.
Script QuTiP 2.3.10: Probability of finding a state

1 # -*- coding: utf-8 -*-
2 """
3 Exemple calcul des probabilités de trouver un état - Chapitre 2 Cours
4 """
5 #The probability of finding the state |ψi in |ii, i = 0, 1,
6 #is pi = | hi| ψi|2 = hi| ψi hi| ψi∗
7 #
8
9 from qutip import *

10
11 psi1=(basis(2,0)+sqrt(2)*basis(2,1))/sqrt(3)
12 psi2=(1.j*basis(2,0)+sqrt(3)*basis(2,1))/2
13 psi3=((1+1.j)*basis(2,0)-1.j*basis(2,1))/sqrt(3)
14
15 bra0=basis(2,0).dag()
16 bra1=basis(2,1).dag()
17
18 p10=bra0*psi1 # probability amplitude of finding psi1 in the state |0i

19 p10=p10*p10.dag() # probability of finding psi1 in the state |0i
22
23 print('The probability of finding psi1 in the state 0 is')

24 print(p10)
25 print('\n The probability of finding psi1 in the state 1 is')
26 print(p11)
27 print('\n The sum of probabilities of finding psi1 is')
28 print(p10+p11) # completeness relation

29

34

36 print(p20)
38 print(p21)
41

46

48 print(p30)
50 print(p31)
Ouput of QuTiP’s Script 2.3.11: Probability of finding a state

1 # -*- coding: utf-8 -*-
2
3 # Output du script QuTiP de l'exercice sur le calcul des probabilités

4
5 The probability of finding psi1 in the state 0 is

7 Qobj data =
8 [[ 0.33333333]]
9

12 Qobj data =
13 [[ 0.66666667]]
14
15 The sum of probabilities of finding psi1 is

17 Qobj data =
18 [[ 1.]]
19

22 Qobj data =
23 [[ 0.25]]
24

27 Qobj data =
28 [[ 0.75]]
29

32 Qobj data =
33 [[ 1.]]
34

37 Qobj data =
38 [[ 0.66666667]]
39

42 Qobj data =
43 [[ 0.33333333]]
44

47 Qobj data =
48 [[ 1.]]
Pas du tout compliqué n’est-ce pas ?
En utilisant la bibliothèque QuTiP,
1. calculer les valeurs propres et vecteurs propres de la matrice de Pauli Z. On notera vec1
et vec2 lesdits vecteurs propres ;
2. évaluer l’action de Z sur vec1 et vec2 et commenter ;
3. calculer les valeurs propres et vecteurs propres de l’opérateur W = √1 (X + Z) ;

2
4. vérifier l’hermiticité de W et évaluer W2 , comparer à I2 et commenter ;
5. définir les projecteurs P1 et P2 sur les états propres de W. Vérifier les propriétés d’un
opérateur projecteur sur P1 et P2 , i.e., P†i = Pi , P2i = Pi .
2.3.5 Sphère de Bloch et les classes Bloch et Bloch3d
La sphère de Bloch permet de représenter l’état d’un qubit ou d’un système à deux niveaux.
La classe qutip.Bloch utilise la bibliothèque Matplotlib pour dessiner la sphère de Bloch et y
ajouter des points, des états ou même des vecteurs avec l’une des commandes de le Tableau 2.3.3.
Commande Variable d’entrée Description

Ajoute un ou plu-
add_points(pnts,#meth) pnts : liste/tableau des points (x,y,z) ; sieurs points à la
meth=’m’ (par défaut ’s’) : points mul- sphère de Bloch
ticolores
Ajoute un ou plu-
add_states(state,#kind) state : Qobj ou liste de Qobj repré- sieurs états à la
sentant l’état ou l’opérateur densité du sphère de Bloch
système à deux niveaux ; kind : chaînes
de caractères spécifiant si l’état doit
être représenté comme point (’points’)
ou vecteur (par défaut)
Ajoute un vecteur
add_vectors(vec) vec : liste/tableau des points (x,y,z) ou un ensemble de
donnant la direction et la longueur du vecteurs
vecteur d’état
Efface toute don-
clear() née sur la sphère de
Bloch
Sauvegarde la
save(#format,#dirc) format : format (’png’ par défaut) du sphère dans un
fichier de sortie ; dirc : répertoire à uti- fichier
liser
Génère la sphère de
show()
Bloch
Tableau 2.3.3 – Commandes applicables à la classe qutip.Bloch. Le symbole # signifie que l’argument de
la commande est optionnelle.
Pour créer une sphère de Bloch, on utilise l’instruction Bloch(). Dans le script 2.3.12, on
créé une sphère de Bloch, on y ajoute des états, puis on visualise (voir la Figure 2.3.1 et la
Figure 2.3.2).
Script QuTiP 2.3.12: Sphère de Bloch simple avec des vecteurs

1 # -*- coding: utf-8 -*-
2 """
3 Sphère de Bloch avec des vecteurs d'état - Cours Chapitre 2
4
5 """
7 from pylab import *

8
9 psi0 = (basis(2,0) + basis(2,1)).unit()

10 psi1 = (basis(2,0) - 3 * basis(2,1)).unit()
11
12 b1=Bloch() # Crée une sphère de Bloch b1 vide

13 b1.save('Images/Bloch0.png') #Sauvegarde l'image 'Bloch0.png'de la sphère
14 #dans le sous-repertoire 'Images' du repertoire courant
15 b1.show() # Permet de visualiser la sphère vide
16
17 b1.size=[4,4]
18 b1.font_size=14
19 b1.add_states([psi0,psi1,basis(2,0),basis(2,1)]) # Ajoute plusieurs vecteurs au
20 #même moment à la sphère b1
21
22 b1.save('Images/Bloch-pnts.png') #Sauvegarde l'image 'Bloch-pnts.png'de

23 #la sphère dans le sous-repertoire 'Images' du repertoire courant
24 b1.show() # Permet de visualiser la sphère avec les états
Figure 2.3.2 – Sphère de Bloch obtenue avec les

états |0i, |1i, |ψ0 i = √1 (|0i + |1i), |ψ1 i = √1 (|0i −
Figure 2.3.1 – Sphère de Bloch vide. 2 10
3 |1i).
La classe Bloch3d est une classe qui génère la sphère de Bloch comme Bloch. Ces deux
commandes s’utilisent de la même manière. Il suffit juste de remplacer l’instruction Bloch()
par Bloch3d() (voir le script 2.3.12). On peut aussi ajouter des points sur la sphère de Bloch
créée (voir la Figure 2.3.3 et la Figure 2.3.4).
Script QuTiP 2.3.13: Sphère de Bloch 3d avec des points

1 # -*- coding: utf-8 -*-
2 """
3 Sphère de Bloch 3d avec des points sur une latitude et le vecteur y - Chapitre 2
4 """
6 from pylab import *
7
8 B3d=Bloch3d()
9 B3d.save('Images/Bloch3d0.png') #Sauvegarde l'image 'Bloch3d0.png'de la sphère
10 #dans le sous-repertoire 'Images' du repertoire courant
11 B3d.show() #Permet de visualiser la sphère 3d vide
12
13 # Ajout de 20 points allant de \ket{0} à \ket{1}

14 xz=zeros(20) # définition des coordonnées de x
15 yz=[sin(th) for th in linspace(0,pi,20)] # définition des coordonnées de y
16 zz=[cos(th) for th in linspace(0,pi,20)] # définition des coordonnées de z
17 B3d.add_points([xz,yz,zz],'m') # Ajout des points xz, yz et zz en mode multicolore
18
19 # Ajout du vecteur y
20 yvec=[0,1,0]
21 B3d.add_vectors(yvec) # Ajout des points xz, yz et zz en mode multicolore
22
23 B3d.save('Images/Bloch3d-pnts.png') #Sauvegarde l'image 'Bloch3d-pnts.png'de

24 #la sphère dans le sous-repertoire 'Images' du repertoire courant
25 B3d.show() # Permet de visualiser la sphère 3d avec les points
Figure 2.3.4 – Sphère de Bloch 3d avec un vecteur

Figure 2.3.3 – Sphère de Bloch 3d vide. dans la direction y et des points allant de |0i à |1i.
2.4 Décomposition spectrale des opérateurs hermitiens
Comme nous l’avons vu à la sous-section 2.2.2, les opérateurs de théorie quantique asso-
ciés aux grandeurs physiques sont hermitiens. Leur spectre est par conséquent réel et
l’ensemble de leurs vecteurs propres est complet. Certains opérateurs, comme par
2.4. Décomposition spectrale des opérateurs hermitiens 31
exemple l’hamiltonien de l’oscillateur harmonique, ont un spectre discret. Il est alors possible
de construire une base hilbertienne à partir de l’ensemble de leurs vecteurs propres.
L’étude de ces propriétés importantes des opérateurs hermitiens est l’objet de cette section.
2.4.1 Diagonalisation d’un opérateur hermitien
Un vecteur |ψi est dit vecteur propre de A si
A |ψi = a |ψi , (2.4.1)
le nombre a étant la valeur propre associée à ce vecteur propre.
1. Lorsqu’il correspond à a un vecteur propre unique à un facteur multiplicatif près, on dit

que a est non-dégénéré. Tous les vecteurs d’état associés sont colinéaires.
2. Si au contraire, il existe plusieurs vecteurs d’état indépendants qui soient vecteurs propres
de A, a est dit dégénéré. Son degré de dégénérescence est le nombre de vecteurs propres
linéairement indépendant qui lui sont associés.
On appelle spectre d’un opérateur A, l’ensemble de ses valeurs propres. On obtient ces va-
leurs propres en résolvant l’équation (2.4.1) : on dit qu’on diagonalise la matrice représentant
A. Les éléments diagonaux de cette matrice diagonale sont les valeurs propres.
L’algorithme pour la diagonalisation explicite d’une matrice hermitienne A de di-

mension finie n est la suivante :
1. Résoudre l’équation caractéristique ou séculaire det(A − λI) = 0 afin de trouver les

n valeurs propres λ de A.
2. Résoudre Aij αj = λαi (A |ψi = λ |ψi) pour chaque vecteur propre de A (les αi sont
les composantes ou amplitudes de projection de ces vecteurs propres de A). Ce qui
revient à résoudre un système de n équations à n inconnues.
L’ensemble des vecteurs propres {|ϕi i} d’un opérateur hermitien A forme une
base orthonormée dans H.
Dans un espace de Hilbert fini H, lorsque les valeurs propres ai sont non-dégénérées
A |ϕi i = ai |ϕi i , (2.4.2)
la décomposition spectrale de la matrice hermitienne A est
A= ai P i = ai |ϕi i hϕi | = (2.4.3)

X X X
|ϕi i ai hϕi | .
i i i
Des équations (2.1.9a) et (2.4.3) il apparaît que l’opérateur projecteur
Pi = |ϕi i hϕi | , (2.4.4)
permet soit
1. de faire passer un test |ϕi i à un système quantique (Eq. (2.1.9a)) lorsqu’on est intéressé
par la probabilité de trouver le système dans un état propre de l’opérateur A : la mesure
de Pi vaut 1 si le test réussi et vaut 0 si le test échoue ;
2. de mesurer la grandeur physique A lorsqu’on est plutôt intéressé par une valeur
propre ai de l’opérateur A.
Par exemple, lors de la mesure de la composante suivant Oz du spin avec l’appareil de Stern
et Gerlach, on obtient les valeurs ± h̄2 de la grandeur physique Sz . On peut aussi dire qu’on fait
passer aux atomes le test |+i et |−i avec les probabilités respectives |h+ |ψi |2 et |h− |ψi |2 de
déviations vers le haut et vers le bas.
Remarque 2.4.1
Dans une mesure idéale ou un test idéal, on suppose que le système physique n’est pas
détruite par la mesure. Lorsqu’on répète plusieurs fois une même mesure idéale, on a
mesure quantique sans démolition ou mesure Quantum Non Demolition (QND).
Théorème 2.4.1 – Valeurs propres d’un opérateur hermitien

Les valeurs propres d’un opérateur hermitien sont réelles et les vecteurs propres d’un
opérateur hermitien correspondants à deux valeurs propres différentes sont orthogonaux.
Preuve.
A = A† → hϕi | A |ϕi i = hϕi | A† |ϕi i = hϕi | A |ϕi i∗ .


i | A |ϕi i = ai ,
hϕ
Si A |ϕi i = ai |ϕi i , alors ⇒ ai = a∗i , i.e., ai ∈ R. (2.4.5)
hϕi | A |ϕi i∗ = a∗ ,
i
D’autre part,
A |ϕi i = ai |ϕi i ,


j | A |ϕi i = ai hϕ |ϕi i ,

 hϕ
A |ϕj i = aj |ϕj i , ⇒ (2.4.6a)
 hϕj | A |ϕi i = aj hϕj |ϕi i ,
ai 6= aj ,


⇒ (ai − aj )hϕj |ϕi i = 0, (2.4.6b)

⇒ hϕj |ϕi i = 0, puisque par hypothèse ai 6= aj .
⇒ hϕj |ϕi i = δij . (2.4.6c)
Par conséquent, les vecteurs propres normalisés à l’unité d’un opérateur her-
mitien forment une base orthonormée de H lorsque toutes les valeurs propres
sont différentes. Physiquement, cela entraîne que toute amplitude peut être décomposée
suivant les amplitudes qui sont les projections des vecteurs propres de la grandeurs physique
(donc suivant les amplitudes de base). Le principe de superposition des états est donc lié au
caractère mathématique fermé du système des vecteurs propres d’un opérateur hermitien.
Théorème 2.4.2 – Matrice de diagonalisation

Si un opérateur A est hermitien, il est toujours possible de trouver une matrice unitaire
S (non unique) telle que S −1 AS soit une matrice diagonale, dont les éléments diagonaux
sont les valeurs propres qui apparaissent sur la diagonale un nombre de fois égal à leur
dégénérescence.
0 0 ··· 0
 
a1
0 .. 
0

 a2 ··· . 
−1
=
 ..  (2.4.7)
S AS 0 0 a3 0 .
 . ..
 . ... ... 
 . . 0

0 · · · · · · 0 an
Exemple 2.4.1 – Diagonalisation d’une matrice

On considère la matrice
0 1 0
 
H = 1 0 1 . (2.4.8)
 
0 1 0
Les valeurs propres de cette matrice déterminées par l’équation caractéristique
−λ 1 0
 
det(H − λI) = det  1 −λ 1  = −λ3 + 2λ = 0, (2.4.9)

 
0 1 −λ
√ √
sont, λ1 = 0, λ2 = 2, λ3 = − 2. Ainsi la matrice diagonalisée est
√
2 0 0

 0
H̃ =  0 0 
√ . (2.4.10)
0 0 − 2
L’ordre dans lequel on introduit les valeurs propres quand on écrit H est arbitraire. Mais
très souvent, on les introduit par ordre décroissant.
 
a
Les vecteurs propres  b  de cette matrice sont telles que
 
0 1 0
    
a a
1 0 1  b  = λ  b  , (2.4.11)
    
0 1 0 c c
d’où le système d’équations
b = λa,



a + c = λb,


(2.4.12)




b = λc,
|a| + |b|2 + |c|2
 2
= 1.

La quatrième équation est due à la condition de normalisation des vecteurs d’état. La

résolution de ce système d’équations conduit facilement aux vecteurs propres
1 1
     
−1
1 √  1   1 √ 
2 , √ 0 , − 2 . (2.4.13)
2 2 2
    
1 λ= 2
√ 1 λ=0 1 √
λ=− 2
Script QuTiP 2.4.1: Version avec l’interpréteur IPython

1 In [1]: from qutip import *
2
3 In [2]: H = Qobj([[0,1,0],[1,0,1],[0,1,0]]) #Définition de la matrice H

4
5 In [3]: evalues, states =H.eigenstates() #Diagonalisation de H ou calcul des

6 valeurs et vecteurs propres
7
8 In [4]: evalues
9 Out[4]: array([ -1.41421356e+00, 1.55431223e-15, 1.41421356e+00])
10
11 In [5]: states
12 Out[5]:
13 array([ Quantum object: dims = [[3], [1]], shape = [3, 1], type = ket
14 Qobj data =
15 [[-0.5 ]
16 [ 0.70710678]
17 [-0.5 ]],
19 Qobj data =
20 [[-0.70710678]
21 [ 0. ]
22 [ 0.70710678]],
24 Qobj data =
25 [[ 0.5 ]
26 [ 0.70710678]
27 [ 0.5 ]]], dtype=object)
Simple et rapide n’est ce pas ? !
Exemple 2.4.2 – Quelques propriétés des matrices de Pauli
Dans la base des états de spin {|+i , |−i},
1 0
! !
|+i = , |−i = , (2.4.14)
0 1
sont vecteurs propres de la matrice de Pauli
1 0
!
σz = = |+i h+| − |−i h−| , (2.4.15)
0 −1
avec les valeurs propres +1 et −1 respectivement. Dans la même base, la matrice de Pauli
σx s’écrit
0 1
!
σx = = |+i h−| + |−i h+| . (2.4.16)
1 0
Elle n’est pas diagonale dans cette base, mais elle est hermitienne :
σx† = (|+i h−| + |−i h+|)† = |+i h−| + |−i h+| = σx , (2.4.17)
et unitaire :
σx σx† = σx2 = (|+i h−| + |−i h+|)(|+i h−| + |−i h+|)

(2.4.18)
= |−i h−| + |+i h+| = I.
L’opérateur σx est diagonale dans la base
1 1 1 1
! !
|+ix = √ , |−ix = √ , (2.4.19)
2 1 2 −1
dans laquelle sa décomposition spectrale est donnée par
σx = |+ixx h+| + |−ixx h−| . (2.4.20)
Cette nouvelle base {|+ix , |−ix } est reliée à la base {|+i , |−i} des vecteurs propres de
σz à travers la transformation unitaire
1 1 1
!
S=√ . (2.4.21)
2 1 −1
Lorsqu’on a en général {ai } modalités avec des probabilités Pi , la valeur moyenne des
résultats de la grandeur physique A dans l’état |ψi est
Z
haiψ = ai Pi = (2.4.22a)
X
a dP(a),
i
= hAiψ = hψ |ϕi i ai hϕi | ψi = hψ| A |ψi . (2.4.22b)
X
Ainsi, la valeur moyenne du moment de spin est

1 1
! !
h̄ h̄
hµz i = µi Pi = + + − = 0. (2.4.23)
X
i 2 2 2 2
Ce résultat est conforme aux attentes de la théorie classique lorsque l’orientation des dipôles
magnétiques n’a aucune direction privilégiée dans un champ d’induction magnétique inhomo-
gène.
L’équation (2.4.22) représente la connexion générale entre le théorie quantique et le théorie

quantique classique. Il s’agit du principe de correspondance.
Principe 2.4.1 – Correspondance

Les valeurs moyennes des grandeurs physiques obéissent aux lois de la théorie classique.
En d’autres termes, ce n’est que la statistique des résultats sur les éléments individuels
ou microscopiques qui peut être comparée au résultat macroscopique (collectif d’éléments
microscopiques).
Aussi, dirons-nous que le principe de correspondance fournit l’expression des principales

grandeurs de la théorie classique. En définitive, retenons le théorème suivant :
Théorème 2.4.3 – Copenhagen

Si le rôle de la physique est de bien décrire la nature, le rôle de la théorie quantique
est d’étudier comment les contraintes de l’information troublent cette description. Et,
un système physique n’a pas de réalité physique en dehors de ce qui est extrait par
l’opérateur.
Notons cependant, que ce point de vue restrictif de Copenhagen, est remis en cause par le
théorème EPR :
Théorème 2.4.4 – EPR
Si les prédictions de la théorie quantique concernant les résultats de mesure sont correctes
et si la réalité physique peut être décrite de façon locale (ou séparable), alors la théorie
quantique n’est pas complète ; il existe des éléments de réalité dont elle ne rend pas
compte.
Les applications de ce théorème sorte du cadre de cet ouvrage. Nous limiterons donc à celui
de Copenhagen.
2.4.2 Ensemble complet d’opérateurs compatibles (ECOC)
On appelle commutateur de A et B, l’opérateur
[A, B] = AB − BA. (2.4.24)
Lorsque [A, B] = 0 ou AB = BA, on dit que A et B commutent ou forme une paire d’Heisenberg.
Dans ce cas, faire d’abord un test sur une grandeur physique B et ensuite faire un test sur la
grandeur physique A est équivalent à faire d’abord un test sur une grandeur physique A et
ensuite faire un test sur la grandeur physique B. Autrement, l’ordre des tests sur les grandeurs
physiques A et B n’est plus important.
L’anticommutation de deux opérateurs A et B est définie par
{A, B} = AB + BA. (2.4.25)
On dit que A et B anticommutent lorsque {A, B} = 0. L’ordre des tests sur les grandeurs
physiques A et B est très important.
La bibliothèque QuTiP utilise, pour évaluer la Commutation ou l’anticommutation entre

les opérateurs A et B, la fonction
commutator(A,B,kind) kind=’normal’ ou ’anti’ pour la commutation ou l’anticom-
mutation.
kind=’normal’ étant définit par défaut, on peut l’omettre pour la commutation.
Script QuTiP 2.4.2: Quelques propriétés de commutations des matrices de

Pauli
1 In [1]: from qutip import *
2
3 In [2]: # Par définition [σi , σj ] = 2iσk

4
5 In [3]: commutator(sigmax(),sigmay())-2j*sigmaz()
6 Out[3]:
8 Qobj data =
9 [[ 0. 0.]
10 [ 0. 0.]]
11
12 In [4]: commutator(sigmay(),sigmaz())-2j*sigmax()
13 Out[4]:
15 Qobj data =
16 [[ 0. 0.]
17 [ 0. 0.]]
18
19 In [5]: commutator(sigmaz(),sigmax())-2j*sigmay()
20 Out[5]:
22 Qobj data =
23 [[ 0. 0.]
24 [ 0. 0.]]
25
26 In [6]: # Par définition −iσx σy σz = I

27 ...: -1j*sigmax()*sigmay()*sigmaz()
28 Out[6]:
30 Qobj data =
31 [[ 1. 0.]
32 [ 0. 1.]]
33
34 In [7]: # σx2 = σy2 = σz2 = I

35 ...: sigmax()**2==sigmay()**2==sigmaz()**2==qeye(2)
36 Out[7]: True
Théorème 2.4.5 – Commutation et valeurs propres
Si deux opérateurs hermitiens A et B commutent, et si |ϕi i est un vecteur propre de A,

B |ϕi i est aussi un vecteur propre de A, avec la même valeur propre.
Preuve. 
i i = ai |ϕi i ⇒ AB |ϕi i = ai B |ϕi i ,
A |ϕ
[A, B] |ϕi i = 0 ⇒ A(B |ϕi i) = BA |ϕi i = ai (B |ϕi i),
(2.4.26)
B |ϕi i est vecteur propre de A avec la valeur propre ai .
• Si ai est non-dégénérée, les vecteurs propres qui lui sont associés sont colinéaires et B |ϕi i
est nécessairement proportionnel à |ϕi i. Donc |ϕi i est aussi vecteur propre de B.
• Si ai est dégénérée, on peut seulement dire que B |ϕi i appartient au sous-espace propre
Ha de A, correspondant à la valeur propre an . On dit que Ha est globalement invariant
sous l’action de B.
Théorème 2.4.6 – Commutation et orthogonalité
Si deux opérateurs hermitiens A et B commutent, et si |ψ1 i et |ψ2 i sont deux vecteurs

propres de A avec des valeurs propres différentes, l’élément de matrice hψ1 | B |ψ2 i est nul
(i.e., |ψ1 i et B |ψ2 i sont orthogonaux).
Preuve.
[A, B] = 0,



 hψ1 | [A, B] |ψ2 i = hψ1 | AB |ψ2 i − hψ1 | BA |ψ2 i = 0,
A |ψ i = a ⇒ a1 hψ1 | B |ψ2 i − a2 hψ1 | B |ψ2 i = 0,

1 |ψ1 i ,

1
⇒ (2.4.27)

 A |ψ2 i = a2 |ψ2 i , ⇒ (a1 − a2 ) |ψ1 i B |ψ2 i = 0,
⇒ hψ1 | B |ψ2 i = 0 puisque a1 6= a2 .


a1 6= a2 ,


Autre démonstration :
A |ψ1 i = a1 |ψ1 i , [A, B] = 0 ⇒ AB |ψ2 i = BA |ψ2 i = a2 B |ψ2 i , ( voir Th. 2.4.5),

 

 


A |ψ2 i = a2 |ψ2 i , ⇒

a1 6= a2 , ⇒ hψ1 | B |ψ2 i = 0, (voir Prop. 2.4.1),

 

(2.4.28)
puisque B |ψ2 i et |ψ1 i sont vecteurs propres de A avec des valeurs propres différentes (a1 6= a2 ).
Autrement, la matrice B n’a d’éléments de matrice non nuls que dans les sous-espaces
propres de A et se présente sous forme de blocs diagonaux.
Exemple 2.4.3 – Matrice générale communtant avec une matrice connue
La matrice représentant l’opérateur Lz dans la base {|u1 i , |u2 i , |u3 i} est
1 0 0
 
Lz = 0 0 0  . (2.4.29)
 
0 0 −1
D’après le théorème 2.4.6, si A est un opérateur qui commute avec Lz , alors A ne peut
avoir des éléments de matrices non-nuls entre |u1 i et |u2 i ; |u2 i et |u3 i ; |u1 i et |u3 i. La
matrice représentant A est donc forcément diagonale, i.e., est de la forme
a11 0 0
 
A =  0 a22 0 

. (2.4.30)
0 0 a33
De même, si M est une matrice qui commute avec
1 0 0
 
Lz = 0 0 0 ,
2
(2.4.31)
 
0 0 1
elle ne peut avec des éléments de matrice non-nuls entre |u1 i et |u2 i ; |u1 i et |u3 i seule-
ment. Ainsi la forme générale de M est
m11 0 m13
 
M =  0 m22 0  . (2.4.32)
 
m31 0 m33
Le théorème 2.4.5 peut se mettre sous la forme suivante :
Théorème 2.4.7 – Diagonalisation simultannée

i deux opérateurs hermitiens A et B commutent, tout sous-espace propre Ha de A est glo-
balement invariant sous l’action de B. Donc lorsque [A, B] = 0, les opérateurs hermitiens
A et B sont simultanément diagonalisables.
Cette propriété est très souvent utilisée pour rechercher le spectre de H. Si le spectre de A
est connu, et si [A, H] = 0, alors la dynamique quantique générée par H laisse invariant chaque
sous-espace propre de l’opérateur A.
Théorème 2.4.8 – ECOC 1

Si deux opérateurs hermitiens A et B commutent, on peut construire une base orthonor-
mée de l’espace des états H constituée par les vecteurs propres communs à A et B et
réciproquement.
Preuve. Démontrons la réciproque. Considérons {|abni}9 une base de vecteurs propres com-
muns à A et B :
 
A |abni = a |abni BA |abni = aB |abni = ab |abni
⇒ ⇒ [A, B] |abni = 0. (2.4.33)
B |abni = b |abni AB |abni = bA |abni = ab |abni
Ainsi, si deux opérateurs hermitiens A et B commutent, il existe une base orthonormée dans
laquelle elles sont diagonalisées simultanément. En effet, il est toujours possible d’effectuer des
diagonalisations partielles de B à l’intérieur de chacun des blocs diagonaux correspondant à
des sous-espaces propres de A.
Théorème 2.4.9 – ECOC 2

n ensemble d’opérateurs A, B, C, · · · , est appelé ensemble complet d’opérateurs
compatibles (ECOC) s’il existe une base unique orthonormée de vecteurs propres
communs (aux facteurs de phase près).
Le théorème équivalent s’énonce comme suit :
Un ensemble d’opérateurs A, B, C, · · · est appelé ensemble complet d’opérateurs compa-

tibles (ECOC) si :
• tous les opérateurs (hermitiens) A, B, C, · · · commutent deux à deux,
• la donnée des valeurs propres de tous les opérateurs A, B, C · · · suffit à déterminer

un vecteur propre commun unique (aux facteurs de phase près).
En d’autres termes, la diagonalisation simultanée de A et B peut faire apparaître des sous-

espaces propres de dimension supérieure à 1 commun à ces deux opérateurs hermitiens. Il est
alors possible d’introduire un opérateur hermitien C qui commutent avec A et B et qui n’a donc
les éléments de matrice que dans le sous espace propre commun à A et B. Il est par conséquent
possible de diagonaliser C à l’intérieur de chaque bloc sans toutefois altérer la diagonalisation
de A et B.
9 L’indice
n sert à éventuellement distinguer les différents vecteurs de base qui correspondent aux mêmes
valeurs propres a et b (dégénérescence).
Si après cette opération, il n’existe plus de sous espace propre commun à A, B et C de

dimension supérieure à 1, on dit que A, B et C forment un ECOC. Si ce n’est pas le cas, on
cherche un opérateur D qui commute avec A, B et C etc.
La mesure simultanée d’un système complet de grandeurs physiques compatibles {A, B, C . . .}
constitue un test maximal du vecteur d’état. Ceci dit, si l’espace est à N dimensions, un test
maximal doit avoir N résultats différents possibles. Alors, on connaît exactement le vecteur
d’état du système quantique : on dit qu’on a préparé le système quantique dans un état déter-
miné.
Exemple 2.4.4 – ECOC
On considère un système physique dont l’espace des états, qui est à trois dimensions, est
rapporté à la base orthonormée formée par les trois kets |ϕ1 i, |ϕ2 i, |ϕ3 i. Dans la base de
ces trois vecteurs pris dans cet ordre, les deux opérateurs H et B sont définis par
1 0 0 1 0 0
   
H = 0 −1 0  , B = 0 0 1 . (2.4.34)
   
0 0 −1 0 1 0
1. Les opérateurs H et B sont hermitiens car ils sont représentés par des matrices
symétriques, réelles. Comme en plus, l’espace est de dimension finie, elles sont
diagonalisables et représentent donc des grandeurs physiques.
2. On peut montrer que H et B commutent par un calcul direct du produit des

matrices HB et BH et en constatant l’égalité. Mais procédons autrement afin de
déduire aisément les vecteurs propres communs à H et B.
(a) Soit H1 le sous-espace (de dimension 1) associé à |ϕ1 i. Dans ce sous-espace,

[H, B] = 0 puisque HB |ϕ1 i = BH |ϕ1 i. Ainsi, |ϕ1 i est un vecteur propre com-
mun à H et B de valeur propre 1.
(b) Considérons maintenant le sous-espace H2 associé à {|ϕ2 i , |ϕ3 i}. Dans ce sous-
espace, les restrictions de H et B sont
−1 0 0 1
! !
H2 = = −I2 et B2 = . (2.4.35)
0 −1 1 0
Puisque H2 est proportionnelle à la matrice unité, il commute avec toutes les

matrices carrées de rang 2, i.e., [H2 , B2 ] = 0.
(c) Finalement, [H, B] = 0 dans la base H = H1 ⊕ H2 .
(d) Pour avoir une base de vecteurs propres communs à H et B, il faut diagonaliser
B2 . Les valeurs propres de B2 sont λ = ±1 et les vecteurs propres
1 1
|ψ2 i = √ (|ϕ2 i + |ϕ3 i) et |ψ3 i = √ (|ϕ1 i − |ϕ2 i), (2.4.36)
2 2
Ces vecteurs sont aussi vecteurs propres de H2 avec la valeur propre −1 (deux
fois dégénérés).
(e) En définitive, les vecteurs propres communs à H et B sont
Vecteur propre Valeur propre de H Valeur propre de B

|ψ1 i = |ϕ1 i 1 1
|ψ2 i = √12 (|ϕ2 i + |ϕ3 i) −1 1
|ψ2 i = √12 (|ϕ2 i − |ϕ3 i) −1 −1
Il n’y a pas deux lignes semblables dans ce tableau des valeurs propres de H
et B : ces deux opérateurs forment donc un ECOC. Ce qui n’est pas le cas
pour chacun d’entre eux pris individuellement.
2.4.3 QuTiP - Diagonalisation simultanée
QuTiP permet de faire la diagonalisation simultanée de matrices hermitiennes qui commutent

(ECOC) grâce à l’instruction,
simdiag([e_ops],evals=True) [e_ops] : liste des opérateurs qui commutent
Le script 2.4.3 (et la sortie 2.4.4) reprend l’Exemple 2.4.4 avec la bibliothèque QuTiP.
Script QuTiP 2.4.3: Exemple 2.4.4 - ECOC

1 # -*- coding: utf-8 -*-
2 """
3 ECOC - Exemple Cours du Chapitre 2
4 """
5

7
8 #Définition des matrices H et B

9 H = Qobj([[1,0,0],[0,-1,0],[0,0,-1]])
10 B = Qobj([[0,0,0],[0,0,1],[0,1,0]])
11
12 #Test hermiticité
13 if H.isherm:
14 print('\n H est hermitien')
15 else:
16 print('\n H n\'est pas hermitien')
17
18 if B.isherm:
19 print('\n B est hermitien')
20 else:
21 print('\n B n\'est pas hermitien')
22
23 #Test de commutation
24 if H*B==B*H:
25 print('\n H et B commutent')
26
27 #Diagonalisation simultannée de H et B
28 evalues, states =simdiag([H,B])
29 print('\n Les valeurs propres communs de H et B sont,')
30 print(evalues)
31 print('\n Les vecteurs propres communs de H et B sont,')
32 print(states)
33
34 #Vérification de l'unicité de chaque couple de valeurs propres communs

35 i=0
36 Ecoc=False
37 while(i<len(evalues[0])) :
38 j=i
39 while(j<(len(evalues[0])-1)) :
40 if(evalues[0][i]==evalues[0][j+1] and evalues[1][i]==evalues[1][j+1]) :
41 Ecoc=True
42 j=j+1
43 tt=Ecoc or Ecoc
44 i=i+1
45 if (tt==False) :
46 print('\n H et B forment un ECOC')
47 else :
48 print('\n H et B ne forment pas un ECOC')
49 else:
50 print('\n H et B ne commutent pas')
Ouput of QuTiP’s Script 2.4.4: Exemple 2.4.4 - ECOC

1 # -*- coding: utf-8 -*-
2
3 # Output du script QuTiP sur les ECOC (Cours)

4
5 H est hermitien
6
7 B est hermitien
8
9 H et B commutent
10
11 Les valeurs propres communs de H et B sont,

12 [[ 1. -1. -1.]
13 [ 0. 1. -1.]]
14
15 Les vecteurs propres communs de H et B sont,

16 [ Quantum object: dims = [[3], [1]], shape = [3, 1], type = ket
17 Qobj data =
18 [[ 1.]
19 [ 0.]
20 [ 0.]]
22 Qobj data =
23 [[ 0. ]
24 [ 0.70710678]
25 [ 0.70710678]]
27 Qobj data =
28 [[ 0. ]
29 [ 0.70710678]
30 [-0.70710678]]]
31
32 H et B forment un ECOC
2.5 Inégalités d’Heisenberg
Nous examinons de façon qualitative le concept de grandeurs physiques incompatibles et ses

conséquences sur la mesure. En général, il ne sera pas possible de trouver des états où les valeurs
des grandeurs physiques A et B soient toutes deux bien déterminées.
Supposons qu’on ait [A, B] 6= 0 et qu’une première mesure de A ait donné une valeur a et
projeté le vecteur d’état initial sur le vecteur propre |ai de A : A |ai = a |ai. Si on effectue une
mesure B immédiatement après celle de A, en général, |ai ne sera pas vecteur propre de B et le
résultat de la mesure ne sera pas connu qu’avec une certaine probabilité. En effet, si b est une
valeur propre de B correspondant au vecteur propre |bi, B |bi = b |bi, la probabilité de mesurer
b sera
P(b ← a) = |hb |ai |2 . (2.5.1)
Il existe donc des dispersions ou écarts quadratiques moyens des mesures effectuées à partir
d’un état initial |ψi arbitraire :
q q
∆ψ A = hA2 iψ − hAi2ψ = h(A − hAiψ I)2 iψ , (2.5.2a)
q q
∆ψ B = hB 2 iψ − hBi2ψ = h(B − hBiψ I)2 iψ . (2.5.2b)
Nous savons que nous pouvons écrire [A, B] = iC, avec C † = C. Considérons les opérateurs
hermitiens P et Q de valeur moyenne nulle, définis par
P = A − hAiψ I et Q = B − hBiψ I, (2.5.3)
et dont le commutateur est aussi iC :
[P, Q] = iC, (2.5.4)

2.5. Inégalités d’Heisenberg 45
puisque hAiψ et hBiψ sont des nombres. Le vecteur (P + iλQ) |ψi, où λ ∈ R, a une norme au
carré positive :
k(P + iλQ) |ψi k2 = kP |ψi k2 + iλh[P, Q]iψ + λ2 kQ |ψi k2

(2.5.5)
= hP 2 iψ − λhCiψ + λ2 hQ2 iψ ≥ 0
Le discriminant de ce polynôme de deuxième degré en λ est négatif ou nul :
hCi2ψ − 4hP 2 iψ hQ2 iψ ≤ 0, (2.5.6)
et nous avons, en vertu de l’équation (2.5.3),

1
∆ψ A · ∆ψ B ≥ |hCiψ |, (2.5.7)
2
qui est l’inégalité de Heisenberg.
En effectuant un grand nombre de mesures de A, un grand nombre de mesures de B et

un grand nombre de mesure de C sur des systèmes tous préparés dans le même état |ψi,
on pourra en déduire avec une bonne précision les dispersions ∆ψ A et ∆ψ B ainsi que la
valeur moyenne hCiψ , qui obéiront alors à (2.5.7).
Cependant, il faut faut préciser que c’est le quanton ou le système quantique lui-même
qui ne peut avoir simultanément une grandeur physique A et une grandeur physique B bien
déterminées. Et c’est de cette indétermination que découle naturellement les incertitudes des
mesures. La relation (2.5.7) est donc une conséquence du caractère spécifique des quantons et
non du jeu de la Nature en vertu duquel on ne saurait étendre nos connaissances à tout ce qui
existe.
QuTiP calcule la variance grâce à l’instruction,

variance(oper,state) oper : opérateur de la valeur moyenne calcu-
lée sur le vecteur d’état state
2.6 Exercices supplémentaires
Représentation matricielle.
1. L’espace des états d’un système physique est à trois dimensions. Soit {|ϕ1 i , |ϕ2 i , |ϕ3 i},
une base orthonormée de cet espace. On définit les kets
1 i 1 1
|ψ0 i = √ |ϕ1 i + |ϕ2 i + |ϕ3 i , |ψ1 i = √ (|ϕ1 i + i |ϕ3 i). (2.6.1)
2 2 2 3
(a) vérifier si ces kets sont normés ;

(b) calculer les matrices P0 et P1 représentant dans la base {|ϕi i}i=1−3 les projecteurs
sur les états |ψ0 i et |ψ1 i respectivement ;
(c) Vérifier l’hermiticité de ces matrices.
2. Dans un espace à deux dimensions, on considère l’opérateur dont la matrice dans une
base orthonormée {|ϕ1 i , |u2 i} s’écrit
!
0 −i
Y= . (2.6.2)
i 0
(a) vérifier l’hermiticité de la matrice Y ;

(b) calculer ses valeurs propres et ses vecteurs propres ;
(c) calculer les matrices représentant les projecteurs sur ces vecteurs propres et vérifier
que celles-ci satisfont à des relations d’orthogonalité et de fermeture.
Formule de Baker-Campbell-Hausdorff.
Soient A et B deux opérateurs qui commutent avec leur commutateur [A, B]. On définit l’opé-
rateur F (t) par la fonction de la variable t, F (t) = eAt eBt .
dF
1. Démontrer que dt = (A + B + t[A, B])F (t).
2. Intégrer cette équation et vérifier la formule de Baker-Campbell-Hausdorff (BCH)

1
eA eB = eA+B e 2 [A,B] . (2.6.3)
Il est donc claire que si A et B commutent eA eB = eB eA .

2.6. Exercices supplémentaires 47
Opérateur de Hausdorff.
On considère l’opérateur
f (t) = etA Be−tA , (2.6.4)
où A et B sont des opérateurs.
1. Montrer que
df (t) d2 f (t)
= [A, f (t)], = [A, [A, f (t)]]. (2.6.5)
dt dt2
2. En déduire
t t2
eAt Be−At = B + [A, B] + [A, [A, B]] + . . . (2.6.6)
1! 2!
Propriétés des matrices de Pauli.

En vertu de la relation (2.2.50)
1. Montrer que les matrices de Pauli σi anti-commutent entre elles et en déduire
σx σy σz = −σy σx σz = iI. (2.6.7)
2. Montrer que si A et B sont deux vecteurs dont les composantes sont des nombres ou des
opérateurs qui commutent avec σi , alors
(σ · A)(σ · B) = A · BI+iσ · (A × B). (2.6.8)
3. On pose σ0 = I. Une matrice 2 × 2 quelconque M peut s’écrire

3
X
M= λi σi . (2.6.9)
i=0
Montrer que
1
λi =
Tr(M σi ). (2.6.10)
2
A quelle condition doivent obéir les coefficients λi lorsque la matrice M est hermitienne ?
Portes logiques quantiques élémentaires.

Une porte quantique logique U, |ψe i U |ψs i est un dispositif expérimental agissant de ma-
nière linéaire sur un 1-qubit d’entrée |ψe i, en fournissant un 1-qubit de sortie |ψs i = U |ψe i,
où U est pour une matrice carrée. On rappelle que la relation duale de |ψs i = U |ψe i s’écrit
hψs | = hψe | U† , où hψe | = α∗ h0| + β ∗ h1|.
Les trois matrices de Pauli, définies en représentation de Dirac par
X := |0i h1| + |1i h0| , Y := −i |0i h1| + i |1i h0| , Z := |0i h0| − |1i h1| , (2.6.11)
permettent de construire des portes q-logiques élémentaires :
|ψe i X |ψs xi = X |ψe i |ψe i Y |ψs yi = Y |ψe i |ψe i Z |ψs zi = Z |ψe i
1. Pour |ψe i = α |0i + β |1i, donner l’expression des sorties |ψsx i = X |ψe i, |ψsy i = Y |ψe i et
|ψsz i = Z |ψe i.
2. En vertu de la linéarité de l’opération |ψs i = U |ψe i, on peut calculer |ψs i pour un 1-qubit
|ψe i quelconque à partir de la seule donnée de la table de vérité de la porte U.
On définit la porte quantique W, dite porte de Walsh-Hadamard, par la table de vérité
suivante :
1
|0i → √ (|0i + |1i)
2
(2.6.12)
1
|1i → √ (|0i − |1i)
2
Indiquer la matrice W correspondante dans la base {|0i , |1i}. Écrire la porte W en fonction
des portes X et Z.
3. Montrer que la normalisation simultanée de |ψe i et |ψs i impose que U soit, en toute
généralité, une matrice unitaire, i.e., telle que U† U = I. Tout dispositif expérimental
implémentant une porte quantique logique devra respecter cette condition dite
d’unitarité.
4. Vérifier, en utilisant la forme vectorielle (2.6.11), que les opérateurs Y, et W sont unitaires.
5. {X, Z} est-il un ECOC ? Justifier.

2.7. Solutions des Exercices 49
2.7 Solutions des Exercices
Solution Exercice 2.3.1 de la page 18
On a le Script QuTiP 2.7.1 obtenu sur la console IPhyton.
Script QuTiP 2.7.1: bra2

1 In [1]: a=Qobj([[-2.],[4.j],[1.]])
2
3 In [2]: b=Qobj([[1.],[0.],[1.j]])
4
5 In [3]: a.dag()
6 Out[3]:
8 Qobj data =
9 [[-2.+0.j 0.-4.j 1.+0.j]]
10
11 In [4]: b.dag()
12 Out[4]:
14 Qobj data =
15 [[ 1.+0.j 0.+0.j 0.-1.j]]
16
17 In [5]: a.dag()*b
18 Out[5]:
20 Qobj data =
21 [[-2.+1.j]]
22
23 In [6]: b.dag()*a
24 Out[6]:
26 Qobj data =
27 [[-2.-1.j]]
28
29 In [7]: c=a+2*b
30
31 In [8]: c
32 Out[8]:
34 Qobj data =
35 [[ 0.+0.j]
36 [ 0.+4.j]
37 [ 1.+2.j]]
38
39 In [9]: c.dag()*a
40 Out[9]:
42 Qobj data =
43 [[ 17.-2.j]]
Le Script Output QuTiP 2.7.3 présente la sortie à l’écran du Script QuTiP 2.7.2 proposé.
Script QuTiP 2.7.2: Quelques propriétés des matrices de Pauli

1 # -*- coding: utf-8 -*-
2 """
3 Quelques Propriétés des Matrices de Pauli I - Exercice Chapitre 2
4 """
6
7 #Définition des operateurs

8 X = sigmax()
9 Z = sigmaz()
10
11 #Valeurs propres et vecteurs propres de Z

12 [val1,val2],[vec1,vec2] = Z.eigenstates()
13 print('Les valeurs propres de Z sont')
14 print(val1, ' et ', val2)
15
16 print('\n Les vecteurs propres de Z sont,')

17 print('vec1=')
18 print(vec1)
19 print('\n et vec2=')
20 print(vec2)
21
22 print('\n L\'action de Z sur vec1 est ')

23 print(Z*vec1)
24
25 print('\n L\'action de Z sur vec2 est ')

26 print(Z*vec2)
27
√
28 # Définition de W = (X + Z)/ 2
29 W = (X+Z)/sqrt(2)
30 [va1,va2],[ket1,ket2] = W.eigenstates()
31
32 print('\n Les valeurs propres de W sont')

33 print(va1, ' et ',va2)
34
35 print('\n Les vecteurs propres de W sont')

36 print('ket1=')
37 print(ket1)
38 print('\n et ket2=')
39 print(ket2)
40
41 #Propriétés de W
42 if W.isherm:
43 print('\n W est hermitien')
44 else:
45 print('\n W n\'est pas hermitien')
46
47 if W*W == qeye(2):
48 print("\n W est une matrice unitaire")
49 else:
50 print('\n W n\'est pas une matrice unitaire')
51
52 # Calcul des projecteurs sur les états propres de W

53 P1 = ket1*ket1.dag()
54 P2 = ket2*ket2.dag()
55 print('\n Le projecteur P1 sur le 1er état propre de W est')
56 print(P1)
57 print('\n Le projecteur P2 sur le 2e état propre de W est')
58 print(P2)
59
60 # Propriétés des projecteurs

61 if P1.isherm:
62 print('\n P1 est hermitien')
63 else:
64 print('\n P1 n\'est pas hermitien')
65
66 if P1*P1 == P1:
67 print('\n P1 est un projecteur')
68 else:
69 print('\n P1 n\'est pas un projecteur')
70
71 if P2.isherm:
72 print('\n P2 est hermitien')
73 else:
74 print('\n P2 n\'est pas hermitien')
75
76 if P2*P2 == P2:
77 print('\n P2 est un projecteur')
78 else:
79 print('\n P2 n\'est pas un projecteur')
Ouput of QuTiP’s Script 2.7.3: Quelques propriétés des matrices de Pauli

1 # Output du script QuTiP sur les propriétés des matrices de Pauli (Exercice)
2
3 Les valeurs propres de Z sont

4 (-1.0, ' et ', 1.0)
5
6 Les vecteurs propres de Z sont,

7 vec1=
9 Qobj data =
10 [[ 0.]
11 [-1.]]
12
13 et vec2=
15 Qobj data =
16 [[-1.]
17 [ 0.]]
18
19 L'action de Z sur vec1 est

21 Qobj data =
22 [[ 0.]
23 [ 1.]]
24
25 L'action de Z sur vec2 est

27 Qobj data =
28 [[-1.]
29 [ 0.]]
30
31 Les valeurs propres de W sont

32 (-1.0, ' et ', 1.0)
33
34 Les vecteurs propres de W sont

35 ket1=
37 Qobj data =
38 [[ 0.38268343]
39 [-0.92387953]]
40
41 et ket2=
43 Qobj data =
44 [[-0.92387953]
45 [-0.38268343]]
46
47 W est hermitien
48
49 W est une matrice unitaire

50
51 Le projecteur P1 sur le 1er état propre de W est

53 Qobj data =
54 [[ 0.14644661 -0.35355339]
55 [-0.35355339 0.85355339]]
56
57 Le projecteur P2 sur le 2e état propre de W est

59 Qobj data =
60 [[ 0.85355339 0.35355339]
61 [ 0.35355339 0.14644661]]
62
63 P1 est hermitien
64
65 P1 est un projecteur
66
67 P2 est hermitien
68
69 P2 est un projecteur
Représentation matricielle. Voir les scripts 2.7.4 et 2.7.5
Script QuTiP 2.7.4: Représentation matricielle

1 # -*- coding: utf-8 -*-
2 """
3 Représentation matricielle - TD Chapitre 2
4 """
6
7 Psi0 = (sqrt(2)*basis(3,0)+1j*basis(3,1)+basis(3,2))/2
8 Psi1 = (basis(3,0)+1j*basis(3,2))/sqrt(3)
9
10 # Vérification de la norme
11 print('psi0 est normé, vrai ou faux?')
12 print Psi0.norm()==1.
13 print('\n psi est normé, vrai ou faux?')
14 print Psi1.norm()==1.
15
16 # Calcul de P0 et P1
17 P0 = Psi0*Psi0.dag()
18 P1 = Psi1*Psi1.dag()
19 print('\n Les projecteurs P0 et P1 valent respectivement')
20 print P0
21
22 print P1
23
24 # Hermiticité de P0 et P1
25 print('\n P0 est hermitien, vrai ou faux?')
26 print P0.isherm
27 print('\n P1 est hermitien, vrai ou faux?')
28 print P1.isherm
29
30 # Définir Y
31 Y = sigmay()
32
33 #Hermiticité de Y
34 print('\n Y est hermitien, vrai ou faux?')
35 print Y.isherm
36
37 #Valeurs propres et vecteurs propres

38 ValY, VecY = Y.eigenstates()
39 print('\n Les valeurs propres de Y sont')
40 print ValY
41 print('\n Les vecteurs propres de Y sont')
42 print VecY
43
44 VecY1 = VecY[0]
45 VecY2 = VecY[1]
46
47 # Calcul des projecteurs sur ces états

48 P2 = VecY1*VecY1.dag()
49 P3 = VecY2*VecY2.dag()
50 print('\n Les projecteurs P2 et P3 des vecteurs propres de Y valent')
51 print P2
52
53 print P3
54
55 # Relation de fermeture et d'orthogonalité

56 print('\n La relation de fermeture est vérifiée pour P2 et P3, vrai ou faux?')
57 print (P2+P3)==qeye(2)
58 print('\n La relation d\'orthogonalité est vérifiée pour P2 et P3, vrai ou faux?')
59 print P2*P3==(P2-P2)
Ouput of QuTiP’s Script 2.7.5: Représentation matricielle

1 # -*- coding: utf-8 -*-
2
3 # Output du script QuTiP Représentation matricielle - TD Chapitre 2

4
5 psi0 est normé, vrai ou faux?

6 True
7
8 psi est normé, vrai ou faux?

9 False
10
11 Les projecteurs P0 et P1 valent respectivement

13 Qobj data =
14 [[ 0.50000000+0.j 0.00000000-0.35355339j 0.35355339+0.j ]
15 [ 0.00000000+0.35355339j 0.25000000+0.j 0.00000000+0.25j ]
16 [ 0.35355339+0.j 0.00000000-0.25j 0.25000000+0.j ]]
18 Qobj data =
19 [[ 0.33333333+0.j 0.00000000+0.j 0.00000000-0.33333333j]
20 [ 0.00000000+0.j 0.00000000+0.j 0.00000000+0.j ]
21 [ 0.00000000+0.33333333j 0.00000000+0.j 0.33333333+0.j ]]
22
23 P0 est hermitien, vrai ou faux?

24 True
25
26 P1 est hermitien, vrai ou faux?

27 True
28
29 Y est hermitien, vrai ou faux?

30 True
31
32 Les valeurs propres de Y sont

33 [-1. 1.]
34
35 Les vecteurs propres de Y sont

36 [ Quantum object: dims = [[2], [1]], shape = [2, 1], type = ket
37 Qobj data =
38 [[-0.70710678+0.j ]
39 [ 0.00000000+0.70710678j]]
41 Qobj data =
42 [[-0.70710678+0.j ]
43 [ 0.00000000-0.70710678j]]]
44
45 Les projecteurs P2 et P3 des vecteurs propres de Y valent

47 Qobj data =
48 [[ 0.5+0.j 0.0+0.5j]
49 [ 0.0-0.5j 0.5+0.j ]]
51 Qobj data =
52 [[ 0.5+0.j 0.0-0.5j]
53 [ 0.0+0.5j 0.5+0.j ]]
54
55 La relation de fermeture est vérifiée pour P2 et P3, vrai ou faux?

56 True
57
58 La relation d'orthogonalité est vérifiée pour P2 et P3, vrai ou faux?

59 True
Formule de Baker-Campbell-Hausdorff.
1. La dérivation simple de F (t) donne
d At Bt
F 0 (t) = (e e ) = AeAt eBt + eAt BeBt = (A + eAt Be−At )F (t). (2.7.1)
dt
Puisque A et B commutent avec leur commutateur,
eAt
[B, eAt ] = [B, A] = t[B, A]eAt ⇒ eAt Be−At = t[A, B] + B, (2.7.2)
∂A
et finalement
F 0 (t) = (A + B + t[A, B])F (t). (2.7.3)
2. Par hypothèse, A + B et [A, B] commutent. On peut donc intégrer l’équation (2.7.3)

comme si A + B et [A, B] étaient des nombres
t2 t2
F (t) = F (0) exp[(A + B)t + [A, B]] = exp[(A + B)t + [A, B]]. (2.7.4)
2 2
Pour t = 1, on la formule de Baker-Campbell-Hausdorff (BCH)
1
eA eB = eA+B e 2 [A,B] . (2.7.5)
Il est donc claire que si [A, B] = 0, eA eB = eB eA .
Opérateur de Hausdorff.
1. Les dérivées premières de f (t) sont
f 0 (t) = AetA Be−tA − etA BAe−tA = AetA Be−tA − etA Be−tA A = [A, f (t)], (2.7.6)
f 00 (t) = [A, f 0 (t)] = [A, [A, f (t)]], etc. (2.7.7)

2. Le développement de Taylor en t de f (t) conduit donc à
t t2
etA Be−tA = B + [A, f (t)] + [A, [A, f (t)]] + . . . (2.7.8)
1! 2!
Propriétés des matrices de Pauli. Les matrices de Pauli sont telles
σj σj = iεijk σk + δij I. (2.7.9)
1. De la relation (2.7.9), on obtient sans peine
σj σj + σj σj = i(1 − 1)σk = 0. (2.7.10)
(2.7.10) et (2.7.9) conduisent à
σx σy σz = −σy σx σz = σz σz i = iI. (2.7.11)
2. Puisque A et B commutent avec σ, on a,
(A · σ)(B · σ) = σj Aj σj Bj = Aj Bj σj σj = Aj Bj (iεijk σk + δij I) (2.7.12a)

= A · BI+iσ · (A × B). (2.7.12b)
P3
3. Si M = i=0 λj σj , alors
3
X
Tr(M ) = Tr(λ0 σ0 ) + Tr( λj σj ) = λ0 Tr(σ0 ) = 2λ0 (2.7.13a)
i=1
1
λ0 = Tr(M ) = Tr(M σ0 ). (2.7.13b)
2
D’autre part,
Tr(M σj ) = Tr(λ0 σ0 σj + λj σj σj ) (2.7.14a)

= λ0 Tr(σj ) + Tr(λj (iεijk σk + δij I)) = 2λj (2.7.14b)
1
λj = Tr(M σj ). (2.7.14c)
2
M est hermitienne si et seulement si λj = λ∗j , i.e., si les coefficients λj sont réels.
Portes logiques quantiques élémentaires.

1. |ψsx i = α |1i + β |0i, |ψsy i = +iα |1i − iβ |0i et |ψsz i = α |0i − β |1i.
2. Porte quantique de Walsh-Hadamard :

!
1 1 1 1
W= √ = √ (X + Z), (2.7.15)
2 1 −1 2
3. Si hψs | ψs i = hψe | U† Uψe i = hψe | ψe i = 1, alors U† U = I.
4. On vérifie facilement que
YY† = (i |0i h1| − i |1i h0|)(|0i h1| − i |1i h0|) = |0i h0| + |1i h1| = I2 . (2.7.16)
et
1
WW† = (|0i h1| + |1i h0|)(|0i h1| + |1i h0|) + (|0i h0| − |1i h1|)(|0i h0| − |1i h1|)
2 (2.7.17)
2
= (|0i h0| + |1i h1|) = I2 .
2
5. Puisque X et Z ne commutent pas, {X, Z} ne peut être un ECOC.

Chapitre A
Installation de QuTiP et commandes usuelles
Sommaire
A.1 Installation de QuTiP
A.2 Vérification de l’installation
A.3 Vérification des versions des logiciels de base
l’installation
A.4 Commandes usuelles
QuTiP, Quantum Toolbox in Python, est un logiciel libre ou open-source de calculs en

optique quantique avec des applications en information quantique1 . La syntaxe simple de Py-
thon permet de construire, de manipuler et d’évoluer des objets quantiques en utilisant QuTiP
avec juste quelques lignes de code. Ceci fait de QuTiP un excellent outil d’appropriation et
de simulation aisées des concepts fondamentaux de la théorie quantique. Grâce à cet biblio-
thèque, l’étudiant peut facilement représenter un état quantique ou un opérateur, calculer une
valeur moyenne, simuler l’évolution d’un système, implémenter des algorithmes de l’information
quantique.
QuTiP étant rédiger en Python2 , il est nécessaire, pour son utilisation optimale, d’avoir
quelques notions de base du langage de programmation Python. Pour cela nous vous conseillons
le cours gratuit Apprenez à programmer en Python disponible sur le site openclassrooms.com3 .
Il est à noter que Python est un langage de programmation interprété, c’est-à-dire que les
instructions qu’on envoie sont transcrites en langage machine au fur et à mesure de leur lecture.
Les langages comme le C/C++ ou le fortran sont appelés langages compilés car, avant de
pouvoir les exécuter, un logiciel spécialisé se charge de transformer le code du programme en
langage machine par la compilation. À chaque modification du code, il faut rappeler une étape
1 J. R. Johansson, P.D. Nation, and F. Nori, QuTiP 2 : A Python framework for the dynamics of open
quantum systems, Comp. Phys. Comm. 184, 1234 (2013) ou http://arxiv.org/abs/1211.6518.
2 le langage de programmation le plus largement utilisé dans les sciences quantiques
3 https://openclassrooms.com/courses/apprenez-a-programmer-en-python, consulté en Avril 2018
59
60 A. Installation de QuTiP et commandes usuelles
de compilation.
A.1 Installation de QuTiP
QuTiP est conçu pour fonctionner au mieux lors de l’utilisation des distributions Anaconda ou
Intel Python prenant en charge le système de gestion de paquets conda.
Nous invitons le lecteur à suivre les instructions d’installation multi-plateforme données

dans la documentation en ligne de QuTiP4 .
Les exemples données dans cet ouvrage ont été exécuté sous Linux Ubuntu, en utilisant
très souvent l’interpréteur IPython qui permet une bonne complétion.
A.2 Vérification de l’installation
Il est possible de vérifier si l’installation de QuTiP s’est bien déroulée. Le temps de cette
vérification est fonction de la puissance de votre ordinateur. Pour vérifier, il faut taper sur le
terminal les instructions :
Script QuTiP A.2.1: Test de l’installation de QuTiP

1 import qutip.testing as qt
2 qt.run()
Une fois la vérification faite QuTiP peut être utilisée.
A.3 Vérification des versions des logiciels de base l’installa-

tion
QuTiP utilise la fonction about pour afficher des informations sur QuTiP et les dépendances
importantes installées sur votre système. Pour voir cette information :
Script QuTiP A.3.1: Version de QuTiP

2 about()
On a par exemple en sortie :

4 http://qutip.org/docs/latest/installation.html, consulté en Avril 2018.
A.4. Commandes usuelles 61
Script QuTiP A.3.2: Version QuTiP

1 QuTiP: Quantum Toolbox in Python
2 Copyright (c) 2011 and later.
3 A. J. Pitchford, P. D. Nation, R. J. Johansson, A. Grimsmo, and C. Granade
4
5 QuTiP Version: 4.2.0

6 Numpy Version: 1.13.3
7 Scipy Version: 1.0.0
8 Cython Version: 0.27.3
9 Matplotlib Version: 2.2.0
10 Python Version: 3.6.4
11 Number of CPUs: 2
12 BLAS Info: INTEL MKL
13 OPENMP Installed: False
14 INTEL MKL Ext: True
15 Platform Info: Linux (x86_64)
16 Installation path:
17 /home/taamangtchu/miniconda3/envs/qutip-env/lib/python3.6/site-packages/qutip
A.3.1 Sauvegarde des fichiers de résultats des exercices
Tous les résultats des divers exercices seront affichés à l’écran (ou console) avec l’instruction
print et sauvegardés par la suite dans un fichier de type texte5 .
Pour les scripts rédigés avec un éditeur ou IDE (Integrated Development Environment), on
créera directement un fichier de résultat en exécutant (dans le répertoire du programme)
root $> python monprogramme.py > resultat.dat
A.4 Commandes usuelles
A.4.1 Charger les modules QuTiP
Avant toute utilisation de QuTiP, il faut importer ses modules avec l’instruction
Script QuTiP A.4.1: Importer les module de qutip

5 Par
exemple, la commande magique dans l’interpréteur IPython, l’instruction %save monFichier 2 8
10-13 sauvegarde dans monFichier.py les lignes 2, 8 et les lignes situées entre 10 et 13.
qui met toutes les fonctions et classes de QuTiP6 , à disposition pour la suite du programme.
Il est aussi important d’importer les bibliothèques SciPy, numpy, matplotlib avec les ins-
tructions
Script QuTiP A.4.2: Importer les module de scipy

1 from scipy import *
2 import numpy as np
3 import matplotlib.pyplot as plt
SciPy est un projet visant à unifier et fédérer un ensemble de bibliothèques Python à usage
scientifique (fonctions spéciales, interpolation, intégration, optimisation, traitement d’images).
Scipy utilise les tableaux et matrices de la bibliothèque NumPy. Cette bibliothèque permet
d’appliquer des opérations simultanément sur l’ensemble d’un tableau permettant d’écrire un
code plus lisible, plus facile à maintenir et donc plus efficace.
SciPy offre également des possibilités avancées de visualisation grâce au module matplotlib.
A.4.2 Quantum object class
La classe qutip.Qobj ou Qobj() est une classe de QuTiP qui crée et manipule les objets
quantiques, sous forme de matrices. Cette classe possède
• des attributs auxquels on peut accéder pour avoir des informations sur l’objet quantique
– dims=dimension (de l’espace de Hilbert) de la fonction ;

– shape=dimension de l’argument de la fonction ;
– type=’oper’, ’ket’, ’bra’ ;
– isherm=’True’, ’False’ (l’opérateur est-il ou non hermitien ?) ;
• des fonctions que l’on peut appliquer à cet objet quantique
– soit pour le modifier ou le transformer (i.e., normaliser, conjugué hermitien,. . . ) ;

– soit pour acquérir des informations sur l’objet quantique (i.e., valeurs propres, vec-
teurs propres,. . . ).
Il est à noter que par convention, les classes d’objet en Python comme Qobj() diffère d’une
fonction par l’utilisation d’une lettre majuscule au début.
6 On
peut visualiser le diagramme en ligne sur http://qutip.org/docs/latest/guide/guide-overview.
html#figure-qutip-org
A.4. Commandes usuelles 63
A.4.3 Sauvegarder les objets QuTiP et les données
Il arrive très souvent qu’on ait besoin de réutiliser les résultats de nos calculs pour une session
ultérieur ou d’exporter ces données pour en exploiter avec d’autres logiciels que QuTiP. Pour
cela il nous faut pouvoir sauvegarder ces données.
1. Le contenu des objets quantiques (qutip.Qobj, qutip.solver.Result, etc.) peut être stocké
dans un fichier et lu ultérieurement respectivement avec les fonctions qutip.fileio.qsave
et qutip.fileio.qload à travers les syntaxes
Script QuTiP A.4.3: Stocker les données qutip
1 qsave(data, name='filename')
qui sauvegarde le data dans fichier ’filename.qu’ dans le répertoire courant ;

Script QuTiP A.4.4: Charger les données qutip
1 qload('filename')
qui charge le contenu du fichier ’filename.qu’ du répertoire courant.

Les fichiers qutip.fileio.qsave et qutip.fileio.qload sont excellents, mais le format
de fichier utilisé n’est compris que par les programmes QuTiP ou python.
2. Lorsque les données exportées dans un programme autre que QuTiP ou python, il est
préférable de les stocker sous forme d’un fichier texte de type CSV (comma-separated
values) pour d’autres calculs ou TSV (tab-separated values) pour une visualisation (tra-
cer de figures). On utilise alors, pour stocker et lire ou charger les données, les fonctions
qutip.fileio.file_data_store et qutip.fileio.file_data_read à travers les syn-
taxes
Script QuTiP A.4.5: Stocker et charger les données standards
1 file_data_store('filename.dat', data, numtype="complex", numformat="decimal",
2 sep=",")
3 file_data_read('filename.dat', sep=",")
où ’filename.dat’ est le nom du fichier, data est le contenu à stocker (un vecteur numpy),
numtype (optionel) est un drapeau indiquant le type valeurs numériques (complexe ou
réelle), numformat (optionel) est un drapeau spécifiant le format numérique des valeurs
(exp pour le format 1.0e1 et decimal pour le format 10.0), et sep indiquant le type de
séparation (tab, space, comma, semicolon, etc.).
Bibliographie
[NE2013] Serge Guy Nana Engo, Introduction à l’Information Quantique- Simulations avec
le Quantum Toolbox in Python, Éditions Universitaires Européennes, 2013.
[MLB2005] Michel Le Bellac,Introduction à l’Information Quantique, Belin, 2005.
[VSC2004] Valerio Scarani, Initiation à la Physique Quantique, Vuibert, 2004.
[BCS2004] Giuliano Benenti, Giulio Casati and Giuliano Strini, Principles of Quantum Com-
putation and Information, Vol.I, World Scientific, 2004.
[MLB2017] Michel Le Bellac,Physique Quantique - Fondements (Tome 1), 3e Édition, EDP

Sciences/CNRS ÉDITIONS, 2013.
[MNIC2000] Michael Nielsen and Isaac Chuang, Quantum Computation and Quantum Infor-
mation, Cambridge University Press, 2000.
[JPresk1998] John Preskill, Lecture note on quantum information and computation, http://
theory.caltech.edu/people/preskill/.
[SCHWWW] C. Schiller, Motion Mountain, http://www.motionmountain.org
[QUTIP] P.D. Nation, J.R. Johansson, QuTiP : Quantum Toolbox in Python, 2011–2012.
http://qutip.org/.
65

INFOQCh2 MesureetOperateurs PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

INFOQCh2 MesureetOperateurs PDF

Transféré par

Droits d'auteur :

Formats disponibles

ÉLÉMENTS CALCULS ET

The Publisher N E 19 avril 2018

2 Mesure de l’information et opérateurs linéaires 1

2.1 Mesure de grandeurs physiques et opérateurs . . . . . . . . . . . . . . . . . . . . 1

2.1.1 Mesure de grandeurs physiques . . . . . . . . . . . . . . . . . . . . . . . 2

2.1.2 Autres Expériences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1.3 Point sur la mesure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.2 Opérateurs linéaires et représentation matricielle . . . . . . . . . . . . . . . . . . 7

2.2.1 Linéarité et représentation matricielle . . . . . . . . . . . . . . . . . . . . 7

2.2.2 Hermiticité et fonction d’un opérateur . . . . . . . . . . . . . . . . . . . 9

2.2.5 Matrices de Pauli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.3 QuTiP - États et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.3.1 États et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.3.3 Qobj Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.3.4 Valeurs moyennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.3.5 Sphère de Bloch et les classes Bloch et Bloch3d . . . . . . . . . . . . . . 28

2.4 Décomposition spectrale des opérateurs hermitiens . . . . . . . . . . . . . . . . . 30

2.4.1 Diagonalisation d’un opérateur hermitien . . . . . . . . . . . . . . . . . . 31

2.4.2 Ensemble complet d’opérateurs compatibles (ECOC) . . . . . . . . . . . 37

2.4.3 QuTiP - Diagonalisation simultanée . . . . . . . . . . . . . . . . . . . . . 42

2.5 Inégalités d’Heisenberg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

2.6 Exercices supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

2.7 Solutions des Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

A Installation de QuTiP et commandes usuelles 59

A.1 Installation de QuTiP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

A.2 Vérification de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

A.3 Vérification des versions des logiciels de base l’installation . . . . . . . . . . . . . 60

A.3.1 Sauvegarde des fichiers de résultats des exercices . . . . . . . . . . . . . . 61

A.4 Commandes usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

A.4.1 Charger les modules QuTiP . . . . . . . . . . . . . . . . . . . . . . . . . 61

A.4.2 Quantum object class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

A.4.3 Sauvegarder les objets QuTiP et les données . . . . . . . . . . . . . . . . 63

2.1 Mesure de grandeurs physiques et opérateurs

contrairement à la situation classique, il y a indéterminisme dans la mesure, vu que nous ne

Définition 2.1.1 – Mesure en théorie quantique

2.1.1 Mesure de grandeurs physiques

Champ magnétique inhomogène

magnétique de spin µ+ = + h̄2 et µ− = − h̄2 ), de part et d’autre du point d’impact en absence

Principe 2.1.1 – Réduction du paquet d’ondes

L’ensemble {µ+ , µ− } est l’ensemble complet des résultats de la mesure de S puisque ce

|ψi = |ii hi |ψi = α+ |+i + α− |−i . (2.1.1)

Les amplitudes α± = h± |ψi décrivent l’orientation du spin dans l’espace tridimensionnel : ce

Les probabilités d’obtenir les moments magnétiques de spin µ+ et µ− sont donc

P+ = |h+ |ψi |2 = |α+ |2 et P− = |h− |ψi |2 = |α− |2 , (2.1.2)

P = |α+ |2 + |α− |2 = 1. (2.1.4)

2.1.2 Autres Expériences

|+iz |+iz |+iz

Première expérience SG1

|+iz |+iz |+iz |+ix

Deuxième expérience SG2

1. un faisceau où les atomes ont un spin + h̄2 avec la probabilité |x h+ |+i |2 = 12 ;

2. un faisceau où les atomes ont un spin − h̄2 avec la probabilité |x h− |+i |2 = 12 .

Troisième expérience SG3

Figure 2.1.5 – Incompatibilité des mesures de Sz et Sx .

2.1.3 Point sur la mesure

Il découle de ce qui précède que :

1. L’acte de mesure modifie généralement d’une manière instantanée le système de façon

2. Le résultat complet de la mesure expérimentale de la grandeur physique A sur le

voies |+i et |−i et un détecteur associé à chaque voie.

2.2 Opérateurs linéaires et représentation matricielle

Principe 2.2.1 – Grandeur physique et opérateur

hai = hψ| A |ψi . (2.2.1)

2.2.1 Linéarité et représentation matricielle