Upload 2 files

# Análisis de Características del Sistema
Ambos archivos, enhanced_ml_features.ts y time_dependent_lindblad.py, son representaciones de sistemas físicos complejos que buscan modelar o predecir su comportamiento. Aunque están en lenguajes de programación diferentes (TypeScript y Python) y se aplican a dominios distintos (procesamiento de audio/señales y física cuántica), comparten la misma lógica de ingeniería: la extracción y preparación de características para una tarea de aprendizaje automático [cite: 2025-06-18].

enhanced_ml_features.ts se centra en la extracción de 32 características distintas de una señal de audio (amplitudes de onda de presión). Esto incluye medidas espectrales (centroide, contraste, energía por banda) y temporales (tasa de cruces por cero, RMS). El objetivo es transformar una señal de audio cruda en un vector de características numéricas que pueda ser fácilmente procesado por un modelo de ML para tareas como clasificación de sonido, reconocimiento de voz o detección de anomalías.

time_dependent_lindblad.py describe un sistema cuántico abierto que evoluciona con el tiempo. El estado del sistema se representa por una matriz de densidad, y su evolución se rige por la ecuación de Lindblad. Las "características" en este caso no se extraen directamente de datos, sino que son parámetros de entrada que describen el sistema, como el Hamiltoniano (H(t)) y los operadores de decoherencia (L
k
​
(t)), que a su vez dependen de parámetros físicos como la frecuencia de un pulso de láser o la tasa de decaimiento. Los "observables" (población, coherencia) son el resultado de la simulación, y son el tipo de datos que un modelo de ML podría usar para predecir o clasificar el comportamiento del sistema.

enhanced_ml_features.ts

@@ -0,0 +1,405 @@
+// Extractor mejorado de 32 características de amplitudes de onda de presión
+export const FEATURE_VECTOR_SIZE = 32;
+
+interface AdvancedFeatures {
+  spectralCentroid: number;
+  spectralRolloff: number;
+  spectralFlux: number;
+  zeroCrossingRate: number;
+  rms: number;
+  peak: number;
+  crest: number;
+  spectralSpread: number;
+  spectralFlatness: number;
+  spectralSlope: number;
+  harmonicRatio: number;
+  noiseRatio: number;
+  tonalPower: number;
+  spectralContrast: number[];  // 7 valores
+  spectralBandEnergy: number[]; // 8 valores
+  temporalFeatures: number[];   // 4 valores
+}
+
+// Función principal mejorada para extraer características ML
+export const extractMLFeatures = (
+  magnitudes: number[], 
+  rawData: Uint8Array, 
+  previousAmplitudes: number[], 
+  sampleRate: number
+): number[] => {
+  const features: number[] = new Array(FEATURE_VECTOR_SIZE).fill(0);
+  
+  try {
+    // Convertir datos raw a amplitudes normalizadas
+    const amplitudes = convertRawToAmplitudes(rawData);
+    
+    // Extraer características avanzadas
+    const advancedFeatures = extractAdvancedFeatures(magnitudes, amplitudes, previousAmplitudes, sampleRate);
+    
+    // Mapear a vector de 32 características
+    const featureVector = mapToFeatureVector(advancedFeatures);
+    
+    // Copiar al array de salida
+    for (let i = 0; i < Math.min(FEATURE_VECTOR_SIZE, featureVector.length); i++) {
+      features[i] = featureVector[i];
+    }
+    
+    return features;
+  } catch (error) {
+    console.warn('Error extracting ML features:', error);
+    // Fallback a extracción básica
+    return extractBasicFeatures(magnitudes, rawData, sampleRate);
+  }
+};
+
+// Convertir datos raw a amplitudes normalizadas
+function convertRawToAmplitudes(rawData: Uint8Array): number[] {
+  const amplitudes: number[] = [];
+  
+  // Convertir de Uint8 a valores signed y normalizar
+  for (let i = 0; i < rawData.length - 1; i += 2) {
+    // Combinar bytes para 16-bit sample
+    const sample = (rawData[i + 1] << 8) | rawData[i];
+    const signed = sample > 32767 ? sample - 65536 : sample;
+    amplitudes.push(signed / 32768.0); // Normalizar a [-1, 1]
+  }
+  
+  return amplitudes;
+}
+
+// Extractor de características avanzadas
+function extractAdvancedFeatures(
+  magnitudes: number[], 
+  amplitudes: number[], 
+  previousAmplitudes: number[], 
+  sampleRate: number
+): AdvancedFeatures {
+  
+  const N = magnitudes.length;
+  const nyquist = sampleRate / 2;
+  
+  // 1. Centroide espectral
+  const spectralCentroid = calculateSpectralCentroid(magnitudes, nyquist);
+  
+  // 2. Rolloff espectral (85% de energía)
+  const spectralRolloff = calculateSpectralRolloff(magnitudes, nyquist, 0.85);
+  
+  // 3. Flujo espectral
+  const spectralFlux = calculateSpectralFlux(magnitudes, previousAmplitudes);
+  
+  // 4. Tasa de cruces por cero
+  const zeroCrossingRate = calculateZeroCrossingRate(amplitudes);
+  
+  // 5. RMS (Root Mean Square)
+  const rms = calculateRMS(amplitudes);
+  
+  // 6. Valor pico
+  const peak = Math.max(...amplitudes.map(Math.abs));
+  
+  // 7. Factor de cresta
+  const crest = rms > 0 ? peak / rms : 0;
+  
+  // 8. Dispersión espectral
+  const spectralSpread = calculateSpectralSpread(magnitudes, spectralCentroid, nyquist);
+  
+  // 9. Planitud espectral
+  const spectralFlatness = calculateSpectralFlatness(magnitudes);
+  
+  // 10. Pendiente espectral
+  const spectralSlope = calculateSpectralSlope(magnitudes, nyquist);
+  
+  // 11-12. Ratio armónico y de ruido
+  const { harmonicRatio, noiseRatio } = calculateHarmonicNoiseRatio(magnitudes);
+  
+  // 13. Potencia tonal
+  const tonalPower = calculateTonalPower(magnitudes);
+  
+  // 14-20. Contraste espectral (7 bandas)
+  const spectralContrast = calculateSpectralContrast(magnitudes, 7);
+  
+  // 21-28. Energía por bandas de frecuencia (8 bandas)
+  const spectralBandEnergy = calculateBandEnergy(magnitudes, 8);
+  
+  // 29-32. Características temporales
+  const temporalFeatures = calculateTemporalFeatures(amplitudes, previousAmplitudes);
+  
+  return {
+    spectralCentroid,
+    spectralRolloff,
+    spectralFlux,
+    zeroCrossingRate,
+    rms,
+    peak,
+    crest,
+    spectralSpread,
+    spectralFlatness,
+    spectralSlope,
+    harmonicRatio,
+    noiseRatio,
+    tonalPower,
+    spectralContrast,
+    spectralBandEnergy,
+    temporalFeatures
+  };
+}
+
+// Mapear características avanzadas a vector de 32 elementos
+function mapToFeatureVector(features: AdvancedFeatures): number[] {
+  const vector: number[] = [];
+  
+  // Características espectrales básicas (13 elementos)
+  vector.push(
+    features.spectralCentroid,
+    features.spectralRolloff,
+    features.spectralFlux,
+    features.zeroCrossingRate,
+    features.rms,
+    features.peak,
+    features.crest,
+    features.spectralSpread,
+    features.spectralFlatness,
+    features.spectralSlope,
+    features.harmonicRatio,
+    features.noiseRatio,
+    features.tonalPower
+  );
+  
+  // Contraste espectral (7 elementos)
+  vector.push(...features.spectralContrast);
+  
+  // Energía por bandas (8 elementos)
+  vector.push(...features.spectralBandEnergy);
+  
+  // Características temporales (4 elementos)
+  vector.push(...features.temporalFeatures);
+  
+  return vector.slice(0, 32); // Asegurar exactamente 32 elementos
+}
+
+// Funciones de cálculo específicas
+
+function calculateSpectralCentroid(magnitudes: number[], nyquist: number): number {
+  let weightedSum = 0;
+  let magnitudeSum = 0;
+  
+  for (let i = 0; i < magnitudes.length; i++) {
+    const freq = (i * nyquist) / magnitudes.length;
+    weightedSum += freq * magnitudes[i];
+    magnitudeSum += magnitudes[i];
+  }
+  
+  return magnitudeSum > 0 ? weightedSum / magnitudeSum : 0;
+}
+
+function calculateSpectralRolloff(magnitudes: number[], nyquist: number, threshold: number): number {
+  const totalEnergy = magnitudes.reduce((sum, mag) => sum + mag * mag, 0);
+  const targetEnergy = totalEnergy * threshold;
+  
+  let cumulativeEnergy = 0;
+  for (let i = 0; i < magnitudes.length; i++) {
+    cumulativeEnergy += magnitudes[i] * magnitudes[i];
+    if (cumulativeEnergy >= targetEnergy) {
+      return (i * nyquist) / magnitudes.length;
+    }
+  }
+  
+  return nyquist;
+}
+
+function calculateSpectralFlux(current: number[], previous: number[]): number {
+  if (previous.length === 0) return 0;
+  
+  let flux = 0;
+  const minLength = Math.min(current.length, previous.length);
+  
+  for (let i = 0; i < minLength; i++) {
+    const diff = current[i] - previous[i];
+    if (diff > 0) flux += diff * diff;
+  }
+  
+  return Math.sqrt(flux / minLength);
+}
+
+function calculateZeroCrossingRate(amplitudes: number[]): number {
+  let crossings = 0;
+  
+  for (let i = 1; i < amplitudes.length; i++) {
+    if ((amplitudes[i] >= 0) !== (amplitudes[i-1] >= 0)) {
+      crossings++;
+    }
+  }
+  
+  return crossings / (amplitudes.length - 1);
+}
+
+function calculateRMS(amplitudes: number[]): number {
+  const sumSquares = amplitudes.reduce((sum, amp) => sum + amp * amp, 0);
+  return Math.sqrt(sumSquares / amplitudes.length);
+}
+
+function calculateSpectralSpread(magnitudes: number[], centroid: number, nyquist: number): number {
+  let weightedVariance = 0;
+  let magnitudeSum = 0;
+  
+  for (let i = 0; i < magnitudes.length; i++) {
+    const freq = (i * nyquist) / magnitudes.length;
+    const deviation = freq - centroid;
+    weightedVariance += deviation * deviation * magnitudes[i];
+    magnitudeSum += magnitudes[i];
+  }
+  
+  return magnitudeSum > 0 ? Math.sqrt(weightedVariance / magnitudeSum) : 0;
+}
+
+function calculateSpectralFlatness(magnitudes: number[]): number {
+  let geometricMean = 1;
+  let arithmeticMean = 0;
+  let count = 0;
+  
+  for (const mag of magnitudes) {
+    if (mag > 0) {
+      geometricMean *= Math.pow(mag, 1 / magnitudes.length);
+      arithmeticMean += mag;
+      count++;
+    }
+  }
+  
+  arithmeticMean /= count;
+  return arithmeticMean > 0 ? geometricMean / arithmeticMean : 0;
+}
+
+function calculateSpectralSlope(magnitudes: number[], nyquist: number): number {
+  let sumXY = 0, sumX = 0, sumY = 0, sumX2 = 0;
+  const n = magnitudes.length;
+  
+  for (let i = 0; i < n; i++) {
+    const x = (i * nyquist) / n; // frecuencia
+    const y = magnitudes[i];     // magnitud
+    
+    sumXY += x * y;
+    sumX += x;
+    sumY += y;
+    sumX2 += x * x;
+  }
+  
+  const denominator = n * sumX2 - sumX * sumX;
+  return denominator !== 0 ? (n * sumXY - sumX * sumY) / denominator : 0;
+}
+
+function calculateHarmonicNoiseRatio(magnitudes: number[]): { harmonicRatio: number, noiseRatio: number } {
+  // Simplificación: basado en picos vs valle promedio
+  const sortedMags = [...magnitudes].sort((a, b) => b - a);
+  const peakEnergy = sortedMags.slice(0, Math.floor(sortedMags.length * 0.1)).reduce((a, b) => a + b, 0);
+  const totalEnergy = magnitudes.reduce((a, b) => a + b, 0);
+  
+  const harmonicRatio = totalEnergy > 0 ? peakEnergy / totalEnergy : 0;
+  const noiseRatio = 1 - harmonicRatio;
+  
+  return { harmonicRatio, noiseRatio };
+}
+
+function calculateTonalPower(magnitudes: number[]): number {
+  // Potencia de componentes tonales vs total
+  let tonalPower = 0;
+  const threshold = Math.max(...magnitudes) * 0.1;
+  
+  for (const mag of magnitudes) {
+    if (mag > threshold) {
+      tonalPower += mag * mag;
+    }
+  }
+  
+  const totalPower = magnitudes.reduce((sum, mag) => sum + mag * mag, 0);
+  return totalPower > 0 ? tonalPower / totalPower : 0;
+}
+
+function calculateSpectralContrast(magnitudes: number[], numBands: number): number[] {
+  const bandSize = Math.floor(magnitudes.length / numBands);
+  const contrasts: number[] = [];
+  
+  for (let band = 0; band < numBands; band++) {
+    const start = band * bandSize;
+    const end = Math.min(start + bandSize, magnitudes.length);
+    const bandMags = magnitudes.slice(start, end);
+    
+    if (bandMags.length > 0) {
+      const sortedBand = [...bandMags].sort((a, b) => b - a);
+      const peakMean = sortedBand.slice(0, Math.max(1, Math.floor(sortedBand.length * 0.2)))
+                                 .reduce((a, b) => a + b, 0) / Math.max(1, Math.floor(sortedBand.length * 0.2));
+      const valleyMean = sortedBand.slice(Math.floor(sortedBand.length * 0.8))
+                                   .reduce((a, b) => a + b, 0) / Math.max(1, sortedBand.length - Math.floor(sortedBand.length * 0.8));
+      
+      contrasts.push(valleyMean > 0 ? Math.log(peakMean / valleyMean) : 0);
+    } else {
+      contrasts.push(0);
+    }
+  }
+  
+  return contrasts;
+}
+
+function calculateBandEnergy(magnitudes: number[], numBands: number): number[] {
+  const bandSize = Math.floor(magnitudes.length / numBands);
+  const energies: number[] = [];
+  
+  for (let band = 0; band < numBands; band++) {
+    const start = band * bandSize;
+    const end = Math.min(start + bandSize, magnitudes.length);
+    
+    let energy = 0;
+    for (let i = start; i < end; i++) {
+      energy += magnitudes[i] * magnitudes[i];
+    }
+    
+    energies.push(energy / (end - start));
+  }
+  
+  return energies;
+}
+
+function calculateTemporalFeatures(current: number[], previous: number[]): number[] {
+  const features: number[] = [];
+  
+  // 1. Cambio de energía
+  const currentEnergy = current.reduce((sum, amp) => sum + amp * amp, 0);
+  const previousEnergy = previous.length > 0 ? previous.reduce((sum, amp) => sum + amp * amp, 0) : currentEnergy;
+  const energyChange = previousEnergy > 0 ? (currentEnergy - previousEnergy) / previousEnergy : 0;
+  features.push(energyChange);
+  
+  // 2. Autocorrelación en lag=1
+  let autocorr = 0;
+  if (current.length > 1) {
+    for (let i = 1; i < current.length; i++) {
+      autocorr += current[i] * current[i-1];
+    }
+    autocorr /= (current.length - 1);
+  }
+  features.push(autocorr);
+  
+  // 3. Varianza de amplitudes
+  const mean = current.reduce((a, b) => a + b, 0) / current.length;
+  const variance = current.reduce((sum, amp) => sum + (amp - mean) * (amp - mean), 0) / current.length;
+  features.push(variance);
+  
+  // 4. Asimetría (skewness)
+  const std = Math.sqrt(variance);
+  let skewness = 0;
+  if (std > 0) {
+    skewness = current.reduce((sum, amp) => sum + Math.pow((amp - mean) / std, 3), 0) / current.length;
+  }
+  features.push(skewness);
+  
+  return features;
+}
+
+// Función de fallback para extracción básica
+function extractBasicFeatures(magnitudes: number[], rawData: Uint8Array, sampleRate: number): number[] {
+  const features: number[] = new Array(FEATURE_VECTOR_SIZE).fill(0);
+  
+  // Usar magnitudes FFT básicas y rellenar
+  for (let i = 0; i < Math.min(FEATURE_VECTOR_SIZE, magnitudes.length); i++) {
+    features[i] = magnitudes[i];
+  }
+  
+  return features;
+}

time_dependent_lindblad.py

@@ -0,0 +1,472 @@
+# -*- coding: utf-8 -*-
+"""
+Extensión del simulador Lindblad para manejar Hamiltonianos dependientes del tiempo.
+Combina evolución coherente (Schrödinger) con procesos disipativos (Lindblad).
+
+Estrategias implementadas:
+1. Hamiltoniano parametrizado H(t, params)
+2. Operadores de Lindblad también dependientes del tiempo L_k(t)
+3. Integración adaptativa con dependencia temporal explícita
+4. Ejemplos: pulsos láser, campos oscilantes, rampas adiabáticas
+
+Autor: Extension del código base de Jacobo Tlacaelel Mina Rodriguez
+"""
+
+import numpy as np
+from scipy.integrate import solve_ivp
+import matplotlib.pyplot as plt
+from typing import Callable, List, Optional, Dict, Any
+from dataclasses import dataclass
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class TimeDependentSystemParameters:
+    """Parámetros para sistemas con dependencia temporal."""
+    name: str
+    dimension: int
+    H_func: Callable[[float, Dict], np.ndarray]  # H(t, params)
+    L_func: Callable[[float, Dict], List[np.ndarray]]  # L_operators(t, params)
+    rho_0: np.ndarray
+    t_span: tuple
+    time_params: Dict[str, Any]  # Parámetros para funciones temporales
+    observables: Dict[str, np.ndarray]
+
+class TimeDependentLindladSimulator:
+    """Simulador Lindblad con Hamiltoniano dependiente del tiempo."""
+    
+    def __init__(self, config=None):
+        self.config = config
+        self.results = {}
+    
+    def lindblad_rhs_time_dependent(self, t: float, rho_vec: np.ndarray,
+                                  H_func: Callable, L_func: Callable, 
+                                  params: Dict) -> np.ndarray:
+        """
+        Ecuación de Lindblad con dependencia temporal explícita.
+        
+        drho/dt = -i[H(t), rho] + Σ_k (L_k(t) rho L_k†(t) - 1/2 {L_k†(t)L_k(t), rho})
+        """
+        try:
+            n = int(np.sqrt(len(rho_vec)))
+            rho = rho_vec.reshape((n, n))
+            
+            # Hamiltoniano en el tiempo t
+            H_t = H_func(t, params)
+            
+            # Operadores de Lindblad en el tiempo t
+            L_operators_t = L_func(t, params)
+            
+            # Término coherente: -i[H(t), rho]
+            drho_dt = -1j * (H_t @ rho - rho @ H_t)
+            
+            # Términos disipativos
+            for L_t in L_operators_t:
+                L_dagger_t = L_t.conj().T
+                drho_dt += (L_t @ rho @ L_dagger_t - 
+                           0.5 * (L_dagger_t @ L_t @ rho + rho @ L_dagger_t @ L_t))
+            
+            return drho_dt.flatten()
+            
+        except Exception as e:
+            logger.error(f"Error en lindblad_rhs_time_dependent en t={t}: {e}")
+            raise
+    
+    def simulate(self, params: TimeDependentSystemParameters, 
+                t_eval: Optional[np.ndarray] = None) -> Dict:
+        """Simula sistema con dependencia temporal."""
+        
+        if t_eval is None:
+            t_eval = np.linspace(params.t_span[0], params.t_span[1], 200)
+        
+        try:
+            sol = solve_ivp(
+                fun=self.lindblad_rhs_time_dependent,
+                t_span=params.t_span,
+                y0=params.rho_0.flatten(),
+                args=(params.H_func, params.L_func, params.time_params),
+                t_eval=t_eval,
+                rtol=1e-8,
+                atol=1e-10,
+                method='RK45'
+            )
+            
+            if not sol.success:
+                raise RuntimeError(f"Integración falló: {sol.message}")
+            
+            # Procesar resultados
+            rho_t = np.array([s.reshape((params.dimension, params.dimension)) 
+                            for s in sol.y.T])
+            
+            # Calcular observables
+            observables = {}
+            for obs_name, obs_op in params.observables.items():
+                observables[obs_name] = [np.trace(rho @ obs_op) for rho in rho_t]
+            
+            # Métricas
+            traces = [np.trace(rho).real for rho in rho_t]
+            purities = [np.trace(rho @ rho).real for rho in rho_t]
+            
+            results = {
+                'success': True,
+                'name': params.name,
+                'time': sol.t,
+                'rho_t': rho_t,
+                'observables': observables,
+                'traces': traces,
+                'purities': purities,
+                'H_evolution': [params.H_func(t, params.time_params) for t in sol.t],
+                'L_evolution': [params.L_func(t, params.time_params) for t in sol.t]
+            }
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"Error en simulación: {e}")
+            return {'success': False, 'error': str(e)}
+
+# ============================================================================
+# EJEMPLOS DE SISTEMAS CON DEPENDENCIA TEMPORAL
+# ============================================================================
+
+def create_driven_qubit_system():
+    """
+    Qubit controlado por pulsos láser + decoherencia.
+    
+    H(t) = ω₀/2 σz + Ω(t)/2 σx    # Campo de control
+    L(t) = √γ(t) σ₋               # Decaimiento variable
+    """
+    
+    # Operadores base
+    sigma_z = np.array([[1, 0], [0, -1]], dtype=complex)
+    sigma_x = np.array([[0, 1], [1, 0]], dtype=complex)
+    sigma_minus = np.array([[0, 0], [1, 0]], dtype=complex)
+    
+    def H_driven_qubit(t, params):
+        """Hamiltoniano con pulso Gaussiano."""
+        omega_0 = params['omega_0']
+        omega_drive = params['omega_drive']
+        pulse_duration = params['pulse_duration']
+        pulse_center = params['pulse_center']
+        
+        # Pulso Gaussiano
+        pulse_envelope = np.exp(-((t - pulse_center)/pulse_duration)**2)
+        Omega_t = omega_drive * pulse_envelope
+        
+        return 0.5 * omega_0 * sigma_z + 0.5 * Omega_t * sigma_x
+    
+    def L_driven_qubit(t, params):
+        """Operadores de Lindblad con decay modulado."""
+        gamma_base = params['gamma_base']
+        
+        # Ejemplo: decaimiento que aumenta durante el pulso
+        pulse_center = params['pulse_center']
+        pulse_duration = params['pulse_duration']
+        pulse_factor = 1 + 0.5 * np.exp(-((t - pulse_center)/pulse_duration)**2)
+        
+        gamma_t = gamma_base * pulse_factor
+        return [np.sqrt(gamma_t) * sigma_minus]
+    
+    # Parámetros temporales
+    time_params = {
+        'omega_0': 1.0,
+        'omega_drive': 2.0,
+        'pulse_duration': 1.0,
+        'pulse_center': 5.0,
+        'gamma_base': 0.1
+    }
+    
+    # Estado inicial (ground state)
+    rho_0 = np.array([[1, 0], [0, 0]], dtype=complex)
+    
+    # Observables
+    observables = {
+        'sigma_z': sigma_z,
+        'sigma_x': sigma_x,
+        'population_excited': np.array([[0, 0], [0, 1]], dtype=complex)
+    }
+    
+    return TimeDependentSystemParameters(
+        name="driven_qubit",
+        dimension=2,
+        H_func=H_driven_qubit,
+        L_func=L_driven_qubit,
+        rho_0=rho_0,
+        t_span=(0, 10),
+        time_params=time_params,
+        observables=observables
+    )
+
+def create_adiabatic_passage_system():
+    """
+    Transferencia adiabática poblacional estimulada (STIRAP).
+    Sistema de 3 niveles con dos campos láser contrapropagantes.
+    
+    |1⟩ ←→ |2⟩ ←→ |3⟩
+       Ω₁(t)   Ω₂(t)
+    """
+    
+    # Operadores de transición
+    sigma_12 = np.array([[0, 1, 0], [0, 0, 0], [0, 0, 0]], dtype=complex)
+    sigma_23 = np.array([[0, 0, 0], [0, 0, 1], [0, 0, 0]], dtype=complex)
+    sigma_13 = np.array([[0, 0, 1], [0, 0, 0], [0, 0, 0]], dtype=complex)
+    
+    # Proyectores
+    P1 = np.array([[1, 0, 0], [0, 0, 0], [0, 0, 0]], dtype=complex)
+    P2 = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype=complex)
+    P3 = np.array([[0, 0, 0], [0, 0, 0], [0, 0, 1]], dtype=complex)
+    
+    def H_stirap(t, params):
+        """Hamiltoniano STIRAP con pulsos contrapropagantes."""
+        delta = params['detuning']
+        Omega_max = params['Omega_max']
+        T_pulse = params['T_pulse']
+        t_delay = params['t_delay']
+        
+        # Pulsos Gaussianos con retraso
+        Omega1_t = Omega_max * np.exp(-((t - T_pulse)/T_pulse * 2)**2)
+        Omega2_t = Omega_max * np.exp(-((t - T_pulse - t_delay)/T_pulse * 2)**2)
+        
+        H = delta * P2  # Desintonía del nivel intermedio
+        H += 0.5 * Omega1_t * (sigma_12 + sigma_12.conj().T)  # Acoplamiento 1↔2
+        H += 0.5 * Omega2_t * (sigma_23 + sigma_23.conj().T)  # Acoplamiento 2↔3
+        
+        return H
+    
+    def L_stirap(t, params):
+        """Decaimiento espontáneo desde el nivel excitado."""
+        gamma2 = params['gamma2']
+        
+        # Solo el nivel 2 decae
+        L1 = np.sqrt(gamma2) * (sigma_12.conj().T)  # 2 → 1
+        L3 = np.sqrt(gamma2) * (sigma_23.conj().T)  # 2 → 3
+        
+        return [L1, L3]
+    
+    time_params = {
+        'detuning': 0.0,      # Resonancia
+        'Omega_max': 1.0,     # Frecuencia de Rabi máxima
+        'T_pulse': 2.0,       # Duración del pulso
+        't_delay': 1.0,       # Retraso entre pulsos (crucial para STIRAP)
+        'gamma2': 0.05        # Decaimiento del nivel intermedio
+    }
+    
+    # Estado inicial: |1⟩
+    rho_0 = P1.copy()
+    
+    observables = {
+        'Population_1': P1,
+        'Population_2': P2, 
+        'Population_3': P3,
+        'Coherence_13': sigma_13 + sigma_13.conj().T
+    }
+    
+    return TimeDependentSystemParameters(
+        name="STIRAP_3level",
+        dimension=3,
+        H_func=H_stirap,
+        L_func=L_stirap,
+        rho_0=rho_0,
+        t_span=(0, 8),
+        time_params=time_params,
+        observables=observables
+    )
+
+def create_parametric_oscillator():
+    """
+    Oscilador paramétrico con bomba modulada + decoherencia.
+    
+    H(t) = ω a†a + f(t)(a² + a†²)    # Bomba paramétrica
+    L = √κ a + √γφ (a + a†)          # Pérdidas + dephasing de fase
+    """
+    N = 6  # Dimensión del espacio de Fock
+    
+    # Operadores
+    a = np.diag(np.sqrt(np.arange(1, N)), k=1).astype(complex)
+    adagger = a.conj().T
+    n_op = adagger @ a
+    
+    # Operadores cuadráticos
+    a_squared = a @ a
+    adagger_squared = adagger @ adagger
+    
+    def H_parametric(t, params):
+        """Hamiltoniano con bomba paramétrica modulada."""
+        omega = params['omega']
+        f_max = params['f_max']
+        f_freq = params['f_freq']
+        
+        # Modulación sinusoidal de la bomba
+        f_t = f_max * np.sin(f_freq * t)
+        
+        H = omega * n_op + f_t * (a_squared + adagger_squared)
+        return H
+    
+    def L_parametric(t, params):
+        """Pérdidas de cavidad + dephasing de fase."""
+        kappa = params['kappa']
+        gamma_phi = params['gamma_phi']
+        
+        L_loss = np.sqrt(kappa) * a
+        L_dephase = np.sqrt(gamma_phi) * (a + adagger)  # Dephasing de cuadratura
+        
+        return [L_loss, L_dephase]
+    
+    time_params = {
+        'omega': 1.0,
+        'f_max': 0.5,         # Amplitud de bomba paramétrica
+        'f_freq': 2.0,        # Frecuencia de modulación
+        'kappa': 0.1,         # Pérdidas de cavidad
+        'gamma_phi': 0.05     # Dephasing de fase
+    }
+    
+    # Estado inicial: vacío
+    rho_0 = np.zeros((N, N), dtype=complex)
+    rho_0[0, 0] = 1.0
+    
+    # Observables
+    x_op = (a + adagger) / np.sqrt(2)      # Posición
+    p_op = -1j * (a - adagger) / np.sqrt(2) # Momento
+    
+    observables = {
+        'photon_number': n_op,
+        'position': x_op,
+        'momentum': p_op,
+        'squeezing_x': x_op @ x_op,
+        'squeezing_p': p_op @ p_op
+    }
+    
+    return TimeDependentSystemParameters(
+        name="parametric_oscillator",
+        dimension=N,
+        H_func=H_parametric,
+        L_func=L_parametric,
+        rho_0=rho_0,
+        t_span=(0, 20),
+        time_params=time_params,
+        observables=observables
+    )
+
+def plot_time_dependent_results(results: Dict, save_path: Optional[str] = None):
+    """Visualización especializada para sistemas con dependencia temporal."""
+    
+    if not results.get('success', False):
+        print("No se pueden graficar resultados fallidos")
+        return
+    
+    time = results['time']
+    observables = results['observables']
+    
+    fig = plt.figure(figsize=(15, 10))
+    
+    # Layout de subplots
+    gs = fig.add_gridspec(3, 3, hspace=0.3, wspace=0.3)
+    
+    # 1. Evolución de observables principales
+    ax1 = fig.add_subplot(gs[0, :2])
+    for obs_name, obs_vals in observables.items():
+        if 'Population' in obs_name or 'population' in obs_name:
+            ax1.plot(time, np.real(obs_vals), 'o-', label=obs_name, markersize=3)
+    ax1.set_xlabel('Tiempo')
+    ax1.set_ylabel('Población')
+    ax1.set_title('Evolución de Poblaciones')
+    ax1.legend()
+    ax1.grid(True)
+    
+    # 2. Conservación de traza y pureza
+    ax2 = fig.add_subplot(gs[0, 2])
+    ax2.plot(time, results['traces'], 'b-', label='Traza')
+    ax2.plot(time, results['purities'], 'r--', label='Pureza')
+    ax2.set_xlabel('Tiempo')
+    ax2.set_title('Conservación')
+    ax2.legend()
+    ax2.grid(True)
+    
+    # 3. Hamiltoniano dependiente del tiempo (elementos seleccionados)
+    ax3 = fig.add_subplot(gs[1, :])
+    H_evolution = results['H_evolution']
+    H_diagonal = [np.real(np.diag(H)) for H in H_evolution]
+    H_diagonal = np.array(H_diagonal).T
+    
+    for i in range(min(3, H_diagonal.shape[0])):  # Máximo 3 elementos diagonales
+        ax3.plot(time, H_diagonal[i], label=f'H_{{{i},{i}}}')
+    
+    # También graficar algunos elementos off-diagonal si existen
+    if H_evolution[0].shape[0] > 1:
+        H_offdiag = [np.real(H[0, 1]) for H in H_evolution]
+        ax3.plot(time, H_offdiag, '--', label='Re(H_{0,1})', alpha=0.7)
+    
+    ax3.set_xlabel('Tiempo')
+    ax3.set_ylabel('H(t) [elementos]')
+    ax3.set_title('Evolución del Hamiltoniano')
+    ax3.legend()
+    ax3.grid(True)
+    
+    # 4. Otros observables (coherencias, etc.)
+    ax4 = fig.add_subplot(gs[2, :2])
+    for obs_name, obs_vals in observables.items():
+        if 'Coherence' in obs_name or 'sigma' in obs_name:
+            ax4.plot(time, np.real(obs_vals), label=f'Re({obs_name})')
+            ax4.plot(time, np.imag(obs_vals), '--', label=f'Im({obs_name})', alpha=0.7)
+    ax4.set_xlabel('Tiempo')
+    ax4.set_ylabel('Coherencias')
+    ax4.set_title('Evolución de Coherencias')
+    ax4.legend()
+    ax4.grid(True)
+    
+    # 5. Matriz de densidad final (representación)
+    ax5 = fig.add_subplot(gs[2, 2])
+    rho_final = results['rho_t'][-1]
+    im = ax5.imshow(np.abs(rho_final), cmap='viridis', interpolation='nearest')
+    ax5.set_title('|ρ(t_final)|')
+    ax5.set_xlabel('j')
+    ax5.set_ylabel('i')
+    plt.colorbar(im, ax=ax5)
+    
+    plt.suptitle(f'Resultados: {results["name"]} (Dependencia Temporal)', fontsize=14)
+    
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        logger.info(f"Figura guardada en {save_path}")
+    
+    plt.show()
+
+def demonstrate_time_dependent_systems():
+    """Función de demostración para sistemas con dependencia temporal."""
+    
+    print("\n" + "="*70)
+    print("SIMULACIÓN DE SISTEMAS CON DEPENDENCIA TEMPORAL")
+    print("="*70)
+    
+    simulator = TimeDependentLindladSimulator()
+    
+    # Ejemplo 1: Qubit controlado
+    print("\n1. Simulando qubit con pulso láser...")
+    driven_qubit = create_driven_qubit_system()
+    results_qubit = simulator.simulate(driven_qubit)
+    
+    if results_qubit['success']:
+        print("   ✓ Simulación exitosa")
+        plot_time_dependent_results(results_qubit)
+    
+    # Ejemplo 2: STIRAP
+    print("\n2. Simulando transferencia adiabática (STIRAP)...")
+    stirap_system = create_adiabatic_passage_system()
+    results_stirap = simulator.simulate(stirap_system)
+    
+    if results_stirap['success']:
+        print("   ✓ Simulación exitosa")
+        plot_time_dependent_results(results_stirap)
+    
+    # Ejemplo 3: Oscilador paramétrico
+    print("\n3. Simulando oscilador paramétrico...")
+    param_osc = create_parametric_oscillator()
+    results_osc = simulator.simulate(param_osc)
+    
+    if results_osc['success']:
+        print("   ✓ Simulación exitosa")
+        plot_time_dependent_results(results_osc)
+
+if __name__ == "__main__":
+    demonstrate_time_dependent_systems()