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.

El QTensor embolcalla un array dens de NumPy o una matriu dispersa de SciPy en una matriu dispersa en format CSR, i pot representar:

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 tensors zero de la dimensió especificada

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 and zero operators
print("Identity (4x4):\n", QTensor.identity(2))
print("Zero (2x2):\n", QTensor.zero(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

Totes les dades s’emmagatzemen de forma dispersa, però podeu recuperar vistes denses o disperses:

.data: obté la matriu dispersa subjacent (format SciPy 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
.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
.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, format='csr')
[[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)