QTensor

El mòdul qtensor defineix la classe QTensor i funcions auxiliars relacionades per representar i manipular estats quàntics i operadors en forma dispersa.

The QTensor wraps an array, storing it in the optimal storage format based on its shape and sparsity. It supports a variety of quantum objects, including:

Kets (vectors columna de forma (2**N, 1))
Bras (vectors fila de forma (1, 2**N))
Operadors / Matrius de densitat (matrius quadrades de forma (2**N, 2**N))
Escalars (matrius (1, 1))

Exemples de creació de diversos objectes quàntics:

import numpy as np
from qilisdk.core.qtensor import QTensor

# 1‑qubit |0> ket
psi_ket = QTensor(np.array([[1], [0]]))
print("Ket:", psi_ket.dense(), "is_ket?", psi_ket.is_ket())
print("-" * 20)

# 1‑qubit <0| bra
psi_bra = QTensor(np.array([[1, 0]]))
print("Bra:", psi_bra.dense(), "is_bra?", psi_bra.is_bra())
print("-" * 20)

# Density matrix |0><0|
rho = QTensor(np.array([[1, 0], [0, 0]]))
print("Density matrix:\n", rho.dense(), "is_density_matrix?", rho.is_density_matrix())
print("-" * 20)

# Scalar 0.5
scalar = QTensor(np.array([[0.5]]))
print("Scalar:", scalar.dense(), "is_scalar?", scalar.is_scalar())

Sortida

Ket: [[1]
[0]] is_ket? True
--------------------
Bra: [[1 0]] is_bra? True
--------------------
Density matrix:
[[1 0]
[0 0]] is_density_matrix? True
--------------------
Scalar: [[0.5]] is_scalar? True

Constructors auxiliars

També hi ha diversos constructors per a objectes quàntics habituals:

ket() per a kets de la base computacional

bra() per a bras de la base computacional

basis_state() per a estats de base N-dimensionals amb un únic 1 a l’índex especificat

identity() per a operadors identitat de la dimensió especificada

zero() per generar vectors d’estat en l’estat de tot zeros.

one() per generar vectors d’estat en l’estat de tot uns.

ghz() per generar estats GHZ del nombre de qubits especificat

uniform() per generar estats de superposició uniforme del nombre de qubits especificat

from qilisdk.core.qtensor import QTensor

# Single‑qubit
print("ket(0):\n", QTensor.ket(0), "\nis_ket?", QTensor.ket(0).is_ket())
print("bra(1):\n", QTensor.bra(1), "\nis_bra?", QTensor.bra(1).is_bra())

# Fock basis in N=4 Hilbert space
print("basis_state(2,4):\n", QTensor.basis_state(2, 4), "\nshape:", QTensor.basis_state(2, 4).shape)

# GHZ state for 2 qubits
print("GHZ state for 2 qubits:\n", QTensor.ghz(2))

# Identity operators
print("Identity (4x4):\n", QTensor.identity(2))

Sortida

ket(0):
[[1.]
[0.]]
is_ket? True
bra(1):
[[0. 1.]]
is_bra? True
basis_state(2,4):
[[0.]
[0.]
[1.]
[0.]]
shape: (4, 1)

Propietats i operacions d’objectes quàntics

Sigui quin sigui el mètode d’emmagatzematge intern, podeu recuperar vistes denses o disperses:

.data: obté el contingut com una matriu dispersa de SciPy (sempre en format CSR)
.dense(): converteix a un array dens de NumPy (useu amb precaució per a tensors grans)
o accedint directament als elements per valor amb qtensor[i, j]

També estan disponibles les operacions matricials habituals:

.adjoint(): transposada conjugada
.conjugate(): conjugada complexa element a element
.transpose(): transposada de la matriu
.exp(): exponencial matricial
.log(): logaritme matricial
.sqrt(): arrel quadrada matricial
.rank(): calcula el rang de l’operador
.pow(exponent): potència matricial
.norm(order="l2"): norma vectorial o matricial
.normalized(order='l2'): normalitza a norma unitària
.eig(): obté els valors propis i els vectors propis
.trace(): calcula la traça d’un operador
.dot(other): producte intern de Frobenius amb un altre QTensor

Així com algunes transformacions específiques de la mecànica quàntica:

.entropy_von_neumann(): calcula l’entropia de von Neumann d’una matriu de densitat
.entropy_renyi(alpha): calcula l’entropia de Rényi d’una matriu de densitat per a un ordre alpha donat
.magic(alpha): calcula la màgia (no-estabilitzabilitat) d’un estat pur mitjançant l’entropia de Rényi d’estabilitzador
.commutator(other): calcula el commutador amb un altre operador
.anticommutator(other): calcula l’anticommutador amb un altre operador
.fidelity(other): calcula la fidelitat entre dos estats quàntics
.probabilities(): calcula la distribució de probabilitat de cada estat en la base computacional
.sample(nshots): obté mostres de mesura en la base computacional a partir d’un estat o d’una matriu de densitat
.expectation_value(operator): calcula el valor esperat d’un operador en aquest estat
.partial_trace(keep): traça parcial
.reset_qubits(qubits): restableix els qubits especificats a 0
.dagger(): àlies d’adjoint

Exemples:

import numpy as np
from qilisdk.core.qtensor import QTensor

# Adjoint of a non-Hermitian operator
A = QTensor(np.array([[1+1j, 2], [3, 4]]))
A_dag = A.adjoint()
print("A:\n", A.dense())
print("A†:\n", A_dag.dense())

# Matrix exponential of Pauli-X
X = QTensor(np.array([[0, 1], [1, 0]]))
expX = X.exp()
print("exp(X):\n", np.round(expX.dense(), 3))

# Norm of a ket and a density matrix
ket0 = QTensor(np.array([[1], [0]]))
dm = ket0.to_density_matrix()
print("||ket0|| =", ket0.norm())
print("trace norm(dm) =", dm.norm(order='l2'))

# Partial trace of a Bell state
from qilisdk.core.qtensor import ket, tensor_prod
bell = (tensor_prod([ket(0), ket(0)]) + tensor_prod([ket(1), ket(1)])).unit()
rho_bell = bell.to_density_matrix()
print("rho_bell:\n", rho_bell)
rhoA = rho_bell.ptrace([0])
print("rho_A:\n", rhoA.dense())

Sortida

A:
[[1.+1.j 2.+0.j]
[3.+0.j 4.+0.j]]
A†:
[[1.-1.j 3.+0.j]
[2.+0.j 4.+0.j]]
exp(X):
[[1.543 1.175]
[1.175 1.543]]
||ket0|| = 1.0
trace norm(dm) = 1.0
rho_bell:
QTensor(shape=4x4, nnz=4):
[[0.5 0.  0.  0.5]
[0.  0.  0.  0. ]
[0.  0.  0.  0. ]
[0.5 0.  0.  0.5]]
rho_A:
[[0.5 0. ]
[0.  0.5]]

Utilitats addicionals

Producte tensorial amb tensor_prod()
Valor esperat amb expect_val()

from qilisdk.core.qtensor import QTensor, expect_val, ket, tensor_prod
import numpy as np

# Two‑qubit Hadamard tensor
H = QTensor(np.array([[1, 1], [1, -1]]) / np.sqrt(2))
H2 = tensor_prod([H, H])
print("H ⊗ H:\n", np.round(H2.dense(), 3))

# Expectation of Z⊗Z on |00>
Z = QTensor(np.array([[1, 0], [0, -1]]))
zz = tensor_prod([Z, Z])
psi00 = tensor_prod([ket(0), ket(0)])
rho00 = psi00.to_density_matrix()
ev = expect_val(zz, rho00)
print("⟨ZZ⟩ on |00> =", ev)

Sortida

H ⊗ H:
[[ 0.5  0.5  0.5  0.5]
[ 0.5 -0.5  0.5 -0.5]
[ 0.5  0.5 -0.5 -0.5]
[ 0.5 -0.5 -0.5  0.5]]
⟨ZZ⟩ on |00> = 1.0

Visualització d’estats quàntics

També podeu visualitzar estats d’un sol qubit a l’esfera de Bloch mitjançant .draw():

from qilisdk.core import QTensor

state = QTensor.ket(0)
state.draw()

L’aspecte d’aquest gràfic es pot personalitzar amb un objecte QTensorStyle, que permet establir colors, densitat de punts i altres elements visuals:

from qilisdk.core import QTensor
from qilisdk.utils.visualization import QTensorStyle

state = QTensor.ket(0)
style = QTensorStyle(
            sphere_color="blue",
            arrow_color="lightblue",
            draw_center_circle=True,
            sphere_points=100,
            draw_reference_points=True,
        )
state.draw(style=style)