En este avanzado Qutip Tutorial, exploramos la rica dinámica de los sistemas cuánticos utilizando Python y el marco Qutip. Comenzaremos preparando estados fundamentales de un solo y dos quits, incluidos los pares de campanas, y luego pasaremos a implementar operaciones cuánticas clave como las matrices Pauli, las puertas de Hadamard y la CNOT. A partir de ahí, simularemos oscilaciones Rabi en un sistema de dos niveles impulsado, investigaremos la evolución del estado coherente en un oscilador armónico cuántico y la decoherencia del modelo en los sistemas abiertos. Visualizaremos las trayectorias del espacio de fase a través de funciones Wigner y cuantificaremos la generación de enredos entre qubits acoplados. Al final de este tutorial, habrá construido un flujo de trabajo completo para la preparación del estado, la evolución del tiempo, la dinámica del sistema abierto y el análisis de enredos, todo dentro de un entorno de Colab. Mira el Códigos completos aquí.
!pip install qutip matplotlib numpy
import numpy as np
import matplotlib.pyplot as plt
from qutip import *
print("🔬 Advanced QuTip Tutorial: Quantum Dynamics & Entanglement")
print("=" * 60)En la fase de configuración, instalamos Qutip junto con Numpy y Matplotlib para garantizar que nuestro entorno Colab tenga todas las bibliotecas necesarias para las simulaciones cuánticas. Este paso establece las bases para las importaciones posteriores y garantiza la reproducibilidad de nuestros resultados. Mira el Códigos completos aquí.
print("\n1. Creating Quantum States")
ground = basis(2, 0)
excited = basis(2, 1)
plus = (ground + excited).unit()
minus = (ground - excited).unit()
print(f"Ground state |0⟩: {ground.dag()}")
print(f"Superposition |+⟩: {plus.dag()}")
bell_phi_plus = (tensor(ground, ground) + tensor(excited, excited)).unit()
bell_psi_minus = (tensor(ground, excited) - tensor(excited, ground)).unit()
print(f"\nBell state |Φ+⟩ = (|00⟩ + |11⟩)/√2")
rho_bell = bell_phi_plus * bell_phi_plus.dag()
print(f"Entanglement measure: {concurrence(rho_bell):.3f}")Comenzamos definiendo los estados de base computacional | 0⟩ y | 1⟩ y construyendo sus superposiciones |+⟩ y | –⟩ para ilustrar manipulaciones básicas de qubit. Luego creamos estados de campana para demostrar un enredo máximo, calculando su concurrencia para cuantificar el enredo. Mira el Códigos completos aquí.
print("\n2. Quantum Gates and Operations")
sx, sy, sz = sigmax(), sigmay(), sigmaz()
print(f"Pauli-X matrix:\n{sx}")
hadamard = (sx + sz) / np.sqrt(2)
cnot = tensor(fock_dm(2, 0), qeye(2)) + tensor(fock_dm(2, 1), sx)
h_ground = hadamard * ground
print(f"\nH|0⟩ = {h_ground.dag()}")Exploramos los operadores Pauli σₓ, σᵧ y σ_Z como los bloques de construcción fundamentales de las rotaciones y reflexiones de qubit. Usando estos, construimos la puerta Hadamard para la generación de superposiciones y la puerta CNOT para operaciones enredadas, aplicándolas a nuestros estados preparados. Mira el Códigos completos aquí.
print("\n3. Quantum Dynamics: Rabi Oscillations")
omega_0 = 1.0
omega_r = 0.5
H = 0.5 * omega_0 * sz + 0.5 * omega_r * sx
t_list = np.linspace(0, 4*np.pi/omega_r, 100)
psi0 = ground
result = mesolve(H, psi0, t_list, [], [])
excited_pop = [expect(fock_dm(2, 1), state) for state in result.states]
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(t_list, excited_pop, 'b-', linewidth=2)
plt.xlabel('Time (ℏ/ω)')
plt.ylabel('Excited State Population')
plt.title('Rabi Oscillations')
plt.grid(True, alpha=0.3)Modelamos un sistema de dos niveles impulsado con un hamiltoniano que combina los términos σ_Z y σₓ para simular las oscilaciones de Rabi. Al evolucionar en el tiempo el estado fundamental bajo este hamiltoniano, rastreamos las oscilaciones de población de estado excitado y las visualizamos durante un ciclo de Rabi completo. Mira el Códigos completos aquí.
print("\n4. Quantum Harmonic Oscillator")
N = 20
a = destroy(N)
H_ho = a.dag() * a + 0.5
alpha = 2.0
psi0_coh = coherent(N, alpha)
t_list_ho = np.linspace(0, 2*np.pi, 50)
result_ho = mesolve(H_ho, psi0_coh, t_list_ho, [], [])
x_op = (a + a.dag()) / np.sqrt(2)
p_op = 1j * (a.dag() - a) / np.sqrt(2)
x_expect = [expect(x_op, state) for state in result_ho.states]
p_expect = [expect(p_op, state) for state in result_ho.states]
plt.subplot(1, 2, 2)
plt.plot(x_expect, p_expect, 'r-', linewidth=2)
plt.plot(x_expect[0], p_expect[0], 'go', markersize=8, label="Start")
plt.plot(x_expect[-1], p_expect[-1], 'ro', markersize=8, label="End")
plt.xlabel('⟨x⟩')
plt.ylabel('⟨p⟩')
plt.title('Coherent State Phase Space')
plt.legend()
plt.grid(True, alpha=0.3)
plt.axis('equal')
plt.tight_layout()
plt.show()Extendemos nuestro estudio a un oscilador armónico de nivel N, inicializando un estado coherente y evolucionando bajo el hamiltoniano estándar. Calculamos y trazamos la trayectoria del espacio de fase ⟨x⟩ vs. ⟨p⟩ para observar el movimiento clásico en el régimen cuántico. Mira el Códigos completos aquí.
print("\n5. Quantum Decoherence and Open Systems")
gamma = 0.2
n_th = 0.1
c_ops = [np.sqrt(gamma * (1 + n_th)) * a, np.sqrt(gamma * n_th) * a.dag()]
psi0_sq = squeeze(N, 0.5) * basis(N, 0)
t_list_damp = np.linspace(0, 10, 100)
result_damp = mesolve(H_ho, psi0_sq, t_list_damp, c_ops, [])
n_expect = [expect(a.dag() * a, state) for state in result_damp.states]
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.plot(t_list_damp, n_expect, 'g-', linewidth=2)
plt.xlabel('Time')
plt.ylabel('⟨n⟩')
plt.title('Photon Number Decay')
plt.grid(True, alpha=0.3)Introducimos la disipación a través de operadores de colapso para un oscilador armónico amortiguado, simulando la interacción con un entorno térmico. Luego evolucionamos un estado exprimido inicial y monitoreamos la descomposición del número de fotones ⟨n⟩ para ilustrar los efectos de decoherencia. Mira el Códigos completos aquí.
print("\n6. Wigner Function Visualization")
final_state = result_damp.states[-1]
xvec = np.linspace(-4, 4, 50)
W_final = wigner(final_state, xvec, xvec)
plt.subplot(1, 2, 2)
plt.contourf(xvec, xvec, W_final, 20, cmap='RdBu')
plt.colorbar(label="W(x,p)")
plt.xlabel('x')
plt.ylabel('p')
plt.title('Wigner Function (Final State)')
plt.tight_layout()
plt.show()Calculamos la distribución de cuasi de cuasi de Wigner del estado amortiguado final en una cuadrícula en el espacio de fase. Mediante la planificación de contorno W (X, P), obtenemos una visión intuitiva de las características no clásicas y el efecto de la decoherencia en la coherencia del estado. Mira el Códigos completos aquí.
print("\n7. Entanglement Dynamics")
omega1, omega2 = 1.0, 1.1
g = 0.1
H_coupled = (omega1/2 * tensor(sz, qeye(2)) +
omega2/2 * tensor(qeye(2), sz) +
g * tensor(sx, sx))
psi0_prod = tensor(plus, ground)
t_list_ent = np.linspace(0, 20, 200)
result_ent = mesolve(H_coupled, psi0_prod, t_list_ent, [], [])
entanglement = [concurrence(state * state.dag()) for state in result_ent.states]
plt.figure(figsize=(8, 5))
plt.plot(t_list_ent, entanglement, 'purple', linewidth=2)
plt.xlabel('Time')
plt.ylabel('Concurrence')
plt.title('Entanglement Generation in Coupled Qubits')
plt.grid(True, alpha=0.3)
plt.ylim(0, 1)
plt.show()Combinamos dos qubits con una interacción σₓ⊗σₓ y evolucionamos un estado de producto inicial, midiendo la concurrencia en cada paso de tiempo. Esto nos permite observar la acumulación y la descomposición del enredo en tiempo real en función de la fuerza de acoplamiento y la desunión. Mira el Códigos completos aquí.
print("\n8. Summary of Advanced Features Demonstrated:")
print("✓ Quantum state preparation and manipulation")
print("✓ Time evolution with mesolve()")
print("✓ Rabi oscillations in two-level systems")
print("✓ Coherent states and harmonic oscillators")
print("✓ Open quantum systems with decoherence")
print("✓ Wigner function visualization")
print("✓ Entanglement quantification and dynamics")
print(f"\n🎯 Tutorial complete! Explored {len(t_list_ent)} time steps")
print("Try modifying parameters to explore different quantum phenomena!")
print("\n💡 Advanced Exercises:")
print("1. Implement quantum error correction codes")
print("2. Simulate quantum algorithms (Grover, Shor)")
print("3. Explore cavity QED with Jaynes-Cummings model")
print("4. Study quantum phase transitions")
print("5. Implement quantum feedback control")Recapitulamos las demostraciones clave, la preparación de estado, las operaciones de la puerta, la evolución del tiempo, el modelado de decoherencia, la visualización de espacios de fase y la cuantificación del enredo, y destacamos cómo las funciones Mesolve () y incorporadas de Qutip agilizan estos flujos de trabajo. Concluimos con sugerencias de ejercicios avanzados para profundizar nuestra exploración de los fenómenos cuánticos.
En conclusión, hemos pasado por los fenómenos de piedra angular de la mecánica cuántica, desde la superposición y el enredo hasta la decoherencia y la visualización del espacio de fase, utilizando la API intuitiva de Qutip. En el camino, preparamos los estados cuánticos, las puertas aplicadas, la dinámica dependiente del tiempo resolvimos con Mesolve () y enredos cuantificados con concurrencia. Nuestros ejemplos de estado de estado coherente y asociado amortiguado revelaron análogos clásicos en el espacio de fase cuántica, mientras que la simulación de quits acopladas mostró un crecimiento enredos en tiempo real. Le recomendamos que modifique los parámetros, como las fortalezas de acoplamiento, las tasas de amortiguación y los estados iniciales, para profundizar su comprensión.
Mira el Códigos completos aquí. No dude en ver nuestro Página de Github para tutoriales, códigos y cuadernos. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro Subreddit de 100k+ ml y suscribirse a Nuestro boletín.
Sana Hassan, una pasante de consultoría en MarktechPost y estudiante de doble grado en IIT Madras, le apasiona aplicar tecnología e IA para abordar los desafíos del mundo real. Con un gran interés en resolver problemas prácticos, aporta una nueva perspectiva a la intersección de la IA y las soluciones de la vida real.