L'algebra lineare è la branca della matematica che si occupa dello studio dei vettori, spazi vettoriali(piano cartesiano), trasformazioni lineari e sistemi di equazioni lineari.

Qui analizziamo quelle che sono le componenti dell'algebra che vengono utilizzate nella quantistica computazionale.


Vector e vector spaces

Indichiamo con il simbolo |v⟩ il vettore composto da ( x y ), compongono il vector spaces che viene rappresentato nel piano cartesiano come nell'immagine sottostante dove vediamo il vector space del vettore v=(1 3)



Linear combination

La linear combination di 2 o più vettori è il vettore che si ottiene dalla somma dei vettori (anche con differenti direzioni) e moltiplicati con uno scalare.

Prendiamo ad esempio 3 vettori V1=(2 3) V2=(1 3) e V3=(-1 2) ed i 3 seguenti scalari C1=2 C2=1 e C3=0 con la formula c1v1 + c2v2 + c3v3 procediamo con i calcoli siostituendo i valori degli scalari ed otteniamo 2v1 + 1v2 + 0v3 ora sostituiamo i valore dei vettori 2(2 3) + 1(1 3) + 0(-1 2) poi moltiplichiamo gli scalari con i valori dei vettori (4 6) + (1 3) + 0 infine essendo 0 eliminiamo il valore del terzo vettore e sottraiamo i valori rimasti dei rimanenti 2 vettori per trovare il valore di x ed y del vettore che si ottiene dalla linear combination (4–1 6–3) il risultato finale è il nuovo vettore con i seguenti valori (3 3)

Nel grafico sottostante vemgono raffigurati nel piano cartesiano i 3 vettori v1,v2,v3 e il vettore creato con la linear combination



Span

Lo span è l'insieme dei vettori che possono essere rappresentati con la linear combination in uno spazio vettoriale e possiamo indicarlo come il prolungamento della linea della rappresentazione del vettore verso l'alto o il basso.



Nel grafico possiamo notare lo span che è nel vettore (1 3) la continuazione della rapprresentazione grafica che continua verso il basso e verso l'alto. Quindi nello span possono essere compresi.

Nella quantistica si parla di state vectors che indica lo space vectors dell’algebra lineare.

Per state vector indichiamo un vector che punta verso uno specifico quantum state.

Nella sfera di Bloch visualizziamo lo state vector e il vettore viene indicato con il termine state space nell'immagine sottostante viene rappresentata la superposition(tra 0 e 1) ed il vector che vediamo può rotare nella sfera ed ogni punto in cui può rotare consiste in un diverso quantunm state.



Matrix

Un vettore è una matrice di una sola colonna e nella quantistica si applica ad ogni state vector per manipolarlo un gate che viene rappresentato da una matrice che viene moltiplicata al vettore (state vector).

Nella quantistica si usano Hermitian matrix ed unitary matrix.

Hermitian matrix

La Hermitian matrix è una matrice che è uguale alla conjugate transpose(U).

U = U-1 e U U = U U = I dove I è la Identity matrix.

Unitary matrix

La Unitary matrix è simile alla Hermitian ed è una matrice dove la matrice inversa è uguale alla conjugate transpose della matrice originale.

Matrice inversa di A-1 A = A A -1 = I dove I è la Identity matrix cioè una matrice che ha tutti 1 nella diagonale da sx a dx e 0 in tutti gli altri elementi.

La unitary matrix è importante perchè applicandola al quantum state non lo modifica.

Linear independing

Un vettore il cui span non rientra nella linear combination degli altri vettori viene indicato come linear independent.

Basis

Il basis è lo span ottenuto da una linear independent.

Perciò il basis di un vector space è il minimo che lo span può avere nell'intero space.

Basis e span nel quantum state sono importanti perchè ci permettono di ridurre verso il basso il vector space.

Conosciamo ogni vector nello space vector perchè sono una linear combination del basis vector.

Nella quantum computation i basis più comuni sono |0⟩ e |1⟩ ma si possono avere altri qubit state come una linear combination di questi basis vectors ad esempio |0⟩+|1⟩/√2 che rappresenta la superposition dove si hanno le stesse probabilità che si abbia |0⟩ o |1⟩.

Hilbert Space

Lo state space è lo spazio che contiene tutti i quantum state vectors. La differenza tra Hilbert state e altri vector space è che il primo ha un inner product, una operazione effettuata tra 2 vettori che restituisce uno scalare.

In quantum computing l'inner product ritorna una scalare che identifica la quantità di un vettore che è compreso nell’altro vettore. In differenti quantum state si calcola la probabilità con il totale che deve essere uguale a 1 ma qui non appofondiremo questo aspetto. La Bloch sphere rappresenta un valido Hilbert state ed il radius della Bloch sphere è uguale ad 1.

Unitary matrix

La Unitary matrix è importante in quantum computation perchè preserva l'inner product.

La unitary transformation nella Bloch sphere non è altro che la rotazione dello state vectors in diverse posizioni all’interno della sfera con la lunghezza dello state vector che non cambia.

Eigenvectors and Eigenvalues

Per definire cosa sono gli eigenvectors e eigenvalues partiamo dalla seguente formula:

A|v⟩ = λ|v⟩

dove A è una matrice e λ è un numero

Date alcune matrici A, dobbiamo cercare i vettori |v⟩ ed i numeri λ che soddisfino la relazione.

Questi vettori vengono chiamati eigenvectors ed i relativi numeri moltiplicatori eigenvalues.

Eigenvectors and eigenvalues sono concetti importanti nel contesto della quantistica computazionale.

Quando si deve misurare il valore di un qubit nel Z-basis l'operazione di misurazione fa collassare il qubit state all'interno di uno dei possibili eigenvectors della Z matrix cioè |0⟩ o |1⟩.

L'eigenvectors del Pauli-Z matrix sono i quantum computational basis states |0⟩ e |1⟩.

Ritorneremo sotto a parlare di eigenvectors e eigenvalues.

Orthogonal

2 vettori sono orthogonal se il loro inner product è uguale a zero.

Mentre un vettore è normalizzato se se la sua magnitude è uguale a 1.

Si dice che 2 vettori sono Orthonormal se entrambi sono orthogonal e normalizzati.

In quantum computing si usano gli orthonormal basis vectors |0⟩ e |1⟩ per rappresentare lo stato del qubit.
Ci sono altre basis i più comuni derivano dai vectors |+⟩ e |-⟩ con |+⟩ = 1/√2 (1 1) e |-⟩ = 1/√2 (1 -1)

Ora le riscriviamo con |0⟩ e |1⟩ e vediamo l'inner products ottenuto è uguale :

|+⟩ = 1/√2 (|0⟩+|1⟩) 〈0|0〉= 1 〈0|1〉= 0
|-⟩ = 1/√2 (|0⟩-|1⟩) 〈0|+〉= 1/√2 〈0|-〉= - 1/√2

Inner Product

Moltiplicando bra e ket con la moltiplicazione delle matrici si ottiene uno scalare

Per esempio prendiamo i seguenti bra e ket :

〈a|b〉= (a1 a2 a3) (b1 b2 b3) = a1b1 + a2b2 + a3b3

se |a⟩ e |b⟩ sono orthogonal abbiamo 〈a|b〉= 0 e se |a⟩ è normalizzato〈a|a〉= 1

The Outer Product

Sempre per le regole della moltiplicazione tra matrici vediamo come ottenere l'outer product usando ket e bra:
|a〉〈b| = (a1 a2) (b1 b2) = vettore = (a1b1 a1b2 b1a1 b2a2)

DIRAC NOTATION

Per descrivere il quantum state nello spazio di Hilbert si può usare anche la Dirac Notation o notazione bra-ket che indica il prodotto scalare di 2 stati indicati nella forma 〈a|b〉.

Nell'algebra lineare ci sono vettori di riga e di colonna e nella Dirac notation sono indicati con ⟨Bras| and |Kets⟩.

Vediamo un esempio dove
ket |a⟩ = (a1 a2) vettore colonna
bra vettore riga〈b| = (b1 b2) = |b⟩+ (b1* b2*)
bra-ket = 〈b|a〉 = inner product = a1b1 + a2b2 = 〈a|b〉 * appartiene a complex number
ket-bra = |axb| = vettore (a1b1 a1b2 a2b1 a2b2)
Define state |0⟩ = (1 0) |1⟩ = (0 1) inner product = 〈0|1〉sono ortogonali si calcola (1 0) * (0 1) = 1 0 + 0 1 = 0
In questa immagine vediamo la matrice che contiene il valore del gate x



gli stessi dati possono essere rappresentati con la Dirac Notation |0x1| + |1x0| ora per esempio applichiamo il gate x a |0⟩ ed otteniamo (01 10) (1 0) = (01 + 10 11 + 00) = (0 1) = |1⟩ un altro esempio utile è della seguente matrice (1 0 0 -1) che nella Dirac Notation diviene |0x0| - |1x1|

Con la normalizzazione abbiamo〈ψ|ψ〉= 1 quindi abbiamo come e.g. |ψ⟩ = 1/√2(|0⟩ + |1⟩) = (1/√2 1/√2)

MEASUREMENTS

La fase di misurazione del qubit fa collassare verso il basis |0⟩ o |1⟩ quindi collassa nello stato 0 o 1.

Questo avviene perchè queste sono gli eigenstates del σz operator.

Nella quantistica sono presenti 3 Pauli matrix che si identificano con i simboli σx σy σz.

La σz chiamata anche z-measurement viene utilizzata per misurare se il qubit è nella posizione |0⟩ o |1⟩.

Naturalmente non ci sono solo le basis 0 e 1 e le più comuni basis sono:

|+⟩ = 1/√2 (|0⟩ + |1⟩)
|-⟩ = 1/√2 (|0⟩ - |1⟩)

per interferenze e differente amplitude ci sono altre 2 orthagonal states ed altre comuni basis utili che sono:

|+i⟩ = 1/√2 (|0⟩ + i|1⟩)
|-i⟩ = 1/√2 (|0⟩ - i|1⟩)
sono orthagonal con numeri immaginari
questi ultimi corrispondono a eigenstates σx e σy e si usano per measure x e y.

Born Rule

La born rule restituisce la probabilità che una misurazione su un sistema quantistico produrrà un dato risultato.

Quindi possiamo calcolare la probabilità che |ψ⟩ collassi nel basis
{ |x⟩, |x+⟩} nello state |x⟩ sono P(x) = |〈x|ψ〉|² se normalizzato ∑i P(xi) = 1
vediamo un esempio:

|ψ⟩ = 1/√3 (|0⟩ + √2i |1⟩ ) misurato in basis {|0⟩, |1⟩}
P(0) = inner product P(0) = |〈0| 1/√3 (|0⟩ + √2|1⟩) |² = | 1/√3 〈0|0〉 + √2/3 〈0|1〉|² = | 1/√3 1 + √2/3 0 |² = 1/3
quindi P(1)= 2/3

altro esempio :

|ψ⟩ = 1/√2 (|0⟩ - |1⟩) misurato in basis {|+⟩,|-⟩}
P(+) = |〈+|ψ〉|² = | 1/√2 (〈0| +〈1|) 1/√2 (|0⟩ - |1⟩) |² = 1/4 |〈0|0〉- 〈0|1〉+〈1|0〉-〈1|1〉|² = | 1 - 1 | = 0

atteso come 〈+|ψ〉 = 〈+|-〉 = 0

BLOCH SPHERE

Per descrivere il quantum state normalizzato detto pure state si utilizza la Bloch Sphere che è una rappresentazione geometrica dello spazio di Hilbert di raggio 1 dove trova una corretta identificazione un qubit.



Nell'immagine sopra che descrive la sfera possiamo vedere gli assi x, y e z, lo stato |0⟩ e |1⟩, i parametri θ e φ.

Con la formula seguente indichiamo uno stato che può così essere rappresentato nella Bloch sphere e possiamo calcolare la probabilità che abbia un valore.

Vediamo la formula e come calcolare la probabilità.

|ψ⟩ = (cos (θ/2)|0⟩ + e sin (θ/2)|1⟩ ) con φ ∈ { 0, 2π } che descrive la fase e θ ∈ { 0, π } determina la probabilità P di misurare |0⟩ o |1⟩.

P(0) = cos² θ/2 e P(1) = sin² θ/2

Nella Bloch sphere viene illustrata con sfera radius = 1 e con coordinate calcolate con il seguente Bloch vector
(sinθ cosθ
sinθ sinφ
cosθ)
i valori calcolati nel Bloch vector identificano le coordinate x,y e z.

Vediamo un esempio di come calcolare le coordinate per diversi stati ad iniziare da
|0⟩ con θ = 0 , φ valore arbitrario
sin(0)=0 cos(0)=1 quindi x = 0
sin(0)=0 sin(1)=0,8415 quindi y = 0
cos(0)=1 quindi z = 1
per cui le coordinate nella Bloch Sphere sono ( 0,0,1 )
con qiskit se inseriamo il comando sottostante otteniamo la relativa Bloch Sphere.
plot_bloch_vector([0,0,1], title="Bloch Sphere")


|1⟩ con θ = π, φ valore arbitrario in questo esempio 1
sin(π)=0 cos(π)=-1 quindi x = 0
sin(π)=0 sin(1)=0,8415 quindi y = 0
cos(π)=-1 quindi z = -1
per cui le coordinate nella Bloch Sphere sono ( 0,0,-1 )
con qiskit se inseriamo il comando sottostante otteniamo la relativa Bloch Sphere.
plot_bloch_vector([0,0,1], title="Bloch Sphere")


|+⟩ con θ = π/2, φ = 0 otteniamo il Bloch vector ( 1 0 0 )
e se con qiskit inseriamo il comando sottostante otteniamo la relativa Bloch Sphere.
plot_bloch_vector([1,0,0], title="Bloch Sphere")


|-⟩ con θ = π/2, φ = π otteniamo il Bloch vector ( -1 0 0 )
e se con qiskit inseriamo il comando sottostante otteniamo la relativa Bloch Sphere.
plot_bloch_vector([-1,0,0], title="Bloch Sphere")


|+i⟩ con θ = π/2, φ = π/2 otteniamo il Bloch vector ( 0 1 0 )
e se con qiskit inseriamo il comando sottostante otteniamo la relativa Bloch Sphere.
plot_bloch_vector([0,1,0], title="Bloch Sphere")


|-i⟩ con θ = π/2, φ = 3 π/2 otteniamo il Bloch vector ( 0 -1 0 )
e se con qiskit inseriamo il comando sottostante otteniamo la relativa Bloch Sphere.
plot_bloch_vector([0,-1,0], title="Bloch Sphere")


Nella Bloch Sphere |0⟩ e |1⟩ sono ortagonali e θ è l'angolo della Bloch sphere mentre θ/2 è l'angolo dell'Hilbert space.

Ora che abbiamo visto nella Bloch sphere le assi x, y e z possiamo ritornare alla fase di misurazione indicando che queste sono delle proiezioni sul relativo asse per cui
z-measurement è la proiezione sull'asse delle z (|0⟩ o |1⟩)
x-measurement è la proiezione sull'asse delle x (|+⟩ o |-⟩)
y-measurement è la proiezione sull'asse delle y (|+i⟩ o |-i⟩)
inoltre si possono creare quante si vogliono assi nella Bloch sphere e misurare le relative proiezioni.

Bell State

Il Bell State è la base dell'entanglement e matematicamente lo possiamo rappresentare come segue:
00⟩ = 1/√2 (|00⟩ + |11⟩
01⟩ = 1/√2 (|01⟩ + |10⟩
10⟩ = 1/√2 (|00⟩ + |11⟩
11⟩ = 1/√2 (|01⟩ + |10⟩

in generale |ψij⟩ = (I ⊗ σjx σiz) |ψ00⟩ dove I è la Identity matrix

Operazioni tra vettori e matrici

Vediamo ora come eseguire le moltiplicazione tra vettori o tra matrici e vettori che sono la base per eseguire le operazioni per i tensor oppure per operazioni nei circuiti quantistici.

Sotto vediamo 2 diversi esempi, il primo di moltiplicazione tra vettori ed il secondo di moltiplicazione tra matrice e vettore.



Nella parte finale una moltiplicazione binaria come si hanno nella computazione quantistica per determinare i valori dei qubit.



Ora nell'immagine sottostante passiamo ad analizzare un esempio di calcolo di un Tensor.


Mentre l'immagine seguente mostra come calcolare il valore dei qubit, 2 nel primo caso e 3 qubit nel secondo caso.



Applicazione Gates

Vediamo come vengono applicati i gates nei qubit sia nel procedimento che a livelli di calcoli algebrici.

Se su di un qubit dobbiamo applicare più gates prima moltiplichiamo i loro valori algebrici tra loro ed il risultato viene poi moltiplicato per il valore del qubit.

In questo esempio applichiamo al qubit |0⟩ il gate X ed Y.

Nella figura 1 di sx vengono indicati i relativi valori del gate X ed Y.

Mentre nella figura 2 a dx viene calcolato il valore della moltiplicazione dei 2 gates che poi si applichera al qubit.


Figura 1


Figura 2


Infine nella figura 3 sottostante vediamo il risultato finale dell'operazione eseguita sul qubit |0⟩.

Figura 3

Qui vediamo un esempio di risoluzione di equazioni lineari con le matrici e presentato nel piano cartesiano.
Date le seguenti 2 equazioni lineari:
3x - 2y = 1
-x + 4y = 3

Traduciamo le equazioni in una matrice come nell'immagine sottostante:

Il vettore (1,3) è il risultato, come vediamo anche nel piano cartesiano dell'immagine a lato(figura 1), l'obiettivo è trovare i valori del vettore (x,y) che generano il risultato (1,3).
Sfruttando la proprietà delle matrici quadrate e moltiplicando la matrice inversa per il vettore del risultato (1,3) otteniamo il vettore v = (1,1) che sono i valori x, y.
Utilizzando la Markov matrices possiamo risolvere delle equazioni lineari per determinare i valori di 2 incognite in una sequenza temporale continua.
Su di un campione di 1000 elettori in un sistema bipartitico seguiamo il trend dei flussi elettorali settimanali dove il 10% degli elettori di sx passano a dx ed il 5% passano da dx a sx.
Costruiamo le equazioni lineari partendo da 2 campioni di 500 elettori per ogni schieramento

sx .9x + .05y = 500
dx .1x + .95y = 500

Costruiamo la matrice iniziale con x = 500 e y = 500 da notare che la caratteristica della matrice di Markov è che la somma dei coefficienti sia di x che di y è uguale a 1.
Quindi abbiamo

.9(500) + .05(500) = 475
.1(500) + .95(500) = 525

possiamo rappresentare le 2 equazioni nel piano cartesiano con il vettore EIGENVECTOR con il relativo EIGENVALUE.
Sostituendo la x con 475 e la y con 525 otteniamo i nuovi valori :

.9(475) + .05(525) = 453.75
.1(475) + .95(525) = 546.25

e cosi per ogni nuova sequenza(figura 2). Proseguendo nelle iterazioni si arriverà al punto in cui cambiando i valori di x ed y i risultati non cambiano ciò significa che abbiamo raggiunto l'Eigenvector.
Nella Linear transformation la i hat e j hat di tutti i vettori ruotano ed escono dal proprio span solo il vettore EIGENVECTOR non si sposta e rimane nella stessa posizione e lo scalare EIGENVALUE è il valore di stretched durante la trasformazione.


Ora facciamo un esempio per trovare un eigenvector ed il relativo eigenvalue tramite l'algoritmo HHL di Quantum computing su Qiskit prima con la simulazione e poi su di un computer quantistico reale. Per prima cosa definisco le 3 equazioni lineari dalle quali poi estraiamo la matrice ed il valore.
Quindi dalle 3 seguenti equazioni :

-x + 3y + z = 3.54515
2x + 3y + z = 5.59135
3x + 2y + z = 5.19768

le scomponiamo in una matrice e 2 vettori.

estraiamo la matrice M
vettore v (incognite da ricercare)
ed il vettore b (risultato equazioni)

tale che Mv = b

Programma per calcolare Eigenvector con algoritmo HHL computer quantistico - simulazione

import qiskit
from qiskit.aqua import run_algorithm
#from qiskit.aqua import LinearSystemInput
from qiskit.quantum_info import state_fidelity
from qiskit.aqua.algorithms import ExactLSsolver
import numpy as np
parametri= {
'problem': {
'name': 'linear_system'
},
'algorithm': {
'name': 'HHL'
},
'eigs': {
'expansion_mode': 'suzuki',
'expansion_order': 1,
'name': 'EigsQPE',
'num_ancillae': 3,
'num_time_slices': 1
},
'reciprocal': {
'name': 'Lookup'
},
'backend': {
'provider': 'qiskit.BasicAer',
'name': 'statevector_simulator'
}
}

def fidelity(hhl, ref):
solutionHHL = hhl / np.linalg.norm(hhl)
solutionCl = ref / np.linalg.norm(ref)
fidelity = state_fidelity(solutionHHL, solutionCl)
print("fidelity %f" % fidelity)

#parametri input
matrix = [[-1, 3,1], [2,3, 1],[3,2,1]]
vector = [3.54, 5.59,5.20]
parametri['input'] = {
'name': 'LinearSystemInput',
'matrix': matrix,
'vector': vector
}

result = run_algorithm(params)
print("soluzione circuito algoritmo HHL :", np.round(result['solution'], 2))
resultCl = ExactLSsolver(matrix, vector).run()
print("Soluzione classica :", np.round(resultCl['solution'], 2))
fidelity(result['solution'], resultCl['solution'])


Soluzione circuito algoritmo HHL : [0.81-0.j 0.9 -0.j 1.25-0.j]
Soluzione classica : [0.68 1.07 1. ]
fidelity : 0.967365

ed il relativo eigenvalue è 5,19768 tale che Mv = λb
Il circuito ha impiegato 9 qubits, 156 gates di cui 82 CNOT gates.