Hamiltonià

La classe Hamiltonian representa un Hamiltonià simbòlic com una suma d’operadors de Pauli ponderats. Podeu crear Hamiltonians fent servir els operadors de Pauli integrats i combinar-los amb operacions aritmètiques estàndard.

Construcció

Per construir un Hamiltonià amb un sol Pauli, podeu fer servir els constructors X(i), Y(i), Z(i), I(i). A partir d’aquests operadors d’un sol qubit, podeu construir Hamiltonians de múltiples qubits mitjançant operacions aritmètiques. Les operacions segueixen la sintaxi de Python; per exemple: 2 * Z(0) + Z(1) i Z(0) * Z(1) construeixen Hamiltonians de múltiples qubits.

Hamiltonians habituals

De manera alternativa, per als models més habituals hi ha constructors amb nom propi:

Constructor	Hamiltonià
transverse_field()	\(\sum_i h_x X_i\)
longitudinal_field()	\(\sum_i h_z Z_i\)
ising()	\(\sum_{i<j} J Z_i Z_j + \sum_i h_z Z_i\)
ising_chain()	\(\sum_i J Z_i Z_{i+1} + \sum_i h_z Z_i\)
ising_grid()	\(\sum_{\langle i, j \rangle} J Z_i Z_j + \sum_i h_z Z_i\) en una xarxa quadrada
transverse_field_ising()	\(\sum_{i<j} J Z_i Z_j + \sum_i h_x X_i + \sum_i h_z Z_i\)
heisenberg()	\(\sum_{i<j} \left( J_x X_i X_j + J_y Y_i Y_j + J_z Z_i Z_j \right) + \sum_i h_z Z_i\)

from qilisdk.analog import Hamiltonian

H = Hamiltonian.transverse_field_ising(nqubits=2, x_coefficient=1.3, zz_coefficient=-2)
print(H)

Sortida:

1.3 X(0) + 1.3 X(1) - 2 Z(0) Z(1)

Tots els arguments de coeficient accepten tant un únic valor, compartit per tots els termes als quals dóna pes, com una llista amb un valor per terme, de manera que qualsevol dels constructors anteriors pot construir un model no uniforme simplement passant una llista en lloc d’un número. Els valors es prenen en l’ordre en què es generen els termes, que cada constructor documenta.

from qilisdk.analog import Hamiltonian

H = Hamiltonian.transverse_field_ising(nqubits=2, x_coefficient=[1.3, -0.7], zz_coefficient=[-2])
print(H)

Sortida:

1.3 X(0) - 0.7 X(1) - 2 Z(0) Z(1)

Llista d’operacions

Operacions aritmètiques:

• Suma: H1 + H2

• Multiplicació escalar: 5 * H

• Multiplicació: H0 * H1

• Resta: H1 - H2

• Divisió per escalar: H / 5

• Negació: -H

Operadors simbòlics addicionals:

• commutador: H1.commutator(H2)

• anticommutador: H1.anticommutator(H2)

• norma_vectorial: H.vector_norm()

• norma_frobenius: H.frobenius_norm()

• traça: H.trace()

Exportació de Hamiltonians:

• a matriu: H.to_matrix(nqubits)

• a qtensor: H.to_qtensor(nqubits)

Importació de Hamiltonians:

• des de qtensor: Hamiltonian.from_qtensor(qtensor)

• des de cadena: Hamiltonian.parse(hamiltonian_string)

Hamiltonians habituals:

• camp transversal: Hamiltonian.transverse_field(nqubits)

• camp longitudinal: Hamiltonian.longitudinal_field(nqubits)

• Ising: Hamiltonian.ising(nqubits)

• cadena d’Ising: Hamiltonian.ising_chain(nqubits)

• xarxa d’Ising: Hamiltonian.ising_grid(rows, columns)

• Ising amb camp transversal: Hamiltonian.transverse_field_ising(nqubits)

• Heisenberg: Hamiltonian.heisenberg(nqubits)

Exemple: Hamiltonià d’Ising

Per definir un Hamiltonià d’Ising de la forma:

\[H_{\text{Ising}} = - \sum_{\langle i, j \rangle} J_{ij} \sigma^Z_i \sigma^Z_j - \sum_j h_j \sigma^Z_j\]

podeu fer servir els operadors de Pauli Z de la biblioteca:

from qilisdk.analog import Z

nqubits = 3
J = {(0, 1): 1, (0, 2): 2, (1, 2): 4}
h = {0: 1, 1: 2, 2: 3}

coupling = sum(weight * Z(i) * Z(j) for (i, j), weight in J.items())
fields = sum(weight * Z(i) for i, weight in h.items())

H = -(coupling + fields)
print(H)

Sortida:

- Z(0) Z(1) - 2 Z(0) Z(2) - 4 Z(1) Z(2) - Z(0) - 2 Z(1) - 3 Z(2)

Visualització

H.draw() dibuixa un Hamiltonià com un graf d’interaccions:

• Cada qubit és un node, el disc del qual es divideix en un sector per cada camp local que hi actua, etiquetat amb el seu tipus de Pauli.

• Cada terme de dos qubits és una aresta entre els qubits que acobla, dibuixada amb un estil de línia per cada tipus d’acoblament (vegeu la llegenda).

• Cada terme que actua sobre tres o més qubits és una hiperaresta en forma d’estrella unida al centroide dels qubits implicats.

• Els colors dels sectors i de les arestes codifiquen el coeficient del terme corresponent, tal com descriu la barra de color.

• Un terme constant (identitat) s’anota sota el graf com un desplaçament d’energia.

from qilisdk.analog import X, Z

nqubits = 3
J = {(0, 1): 1, (0, 2): 2, (1, 2): 4}

H = sum(weight * Z(i) * Z(j) for (i, j), weight in J.items()) + sum(X(i) for i in range(nqubits))
H.draw()

L’aparença es controla amb HamiltonianStyle, que comparteix els temes dels renderitzadors de circuits i d’esquemes. Selecciona la disposició de rustworkx emprada per col·locar els qubits ("spring", "circular", "shell", "spiral" o "random", o positions explícites), si els camps locals i els acoblaments comparteixen una única escala de color, i quines anotacions es dibuixen:

from qilisdk.analog import X, Z
from qilisdk.utils.visualization.style import HamiltonianStyle
from qilisdk.utils.visualization.themes import dark

H = 5 * X(0) - 3 * Z(0) + X(1) + 0.1 * Z(0) * Z(1) + 0.05 * X(0) * X(1)

H.draw(
    HamiltonianStyle(
        theme=dark,
        layout="circular",
        title="My Hamiltonian",
        # Local fields and couplings live on very different scales here, so give each its own colour bar.
        separate_color_scales=True,
    )
)

Per desar la figura en lloc de mostrar-la, passeu un filepath (el format es dedueix de l’extensió):

from qilisdk.analog import X, Z

H = X(0) + Z(0) * Z(1)
H.draw(filepath="hamiltonian.png")