⬡ QuantRoute

Quantum-Inspired Route Optimization Engine

Resolución de problemas logísticos NP-hard usando heurísticas quantum-inspired
Simulated Annealing · Genetic Algorithm · Ant Colony Optimization

---

Demo en vivo · Instalación · API Docs · Algoritmos · Arquitectura

QuantRoute es un motor de optimización logística que aplica principios de computación cuántica —implementados como heurísticas clásicas avanzadas— para resolver problemas de enrutamiento y asignación de recursos de forma eficiente.

El sistema puede resolver en milisegundos problemas que los métodos tradicionales de fuerza bruta tardarían millones de años en calcular:

• Un problema con 20 nodos tiene 20! ≈ 2.4 × 10¹⁸ rutas posibles
• QuantRoute encuentra soluciones a menos del 5% del óptimo global en < 300ms
• Mejoras típicas de 25–35% sobre soluciones greedy de referencia

Cada algoritmo implementado tiene un análogo directo en computación cuántica:

El criterio de Metropolis permite que el sistema "atraviese" barreras de energía —soluciones peores— con probabilidad decreciente:

P(aceptar movimiento peor) = e^(-ΔE / T)

Esto simula el quantum tunneling: en mecánica cuántica, una partícula puede atravesar una barrera de potencial que clásicamente sería imposible. SA replica este comportamiento para escapar de óptimos locales.

# Criterio de aceptación — núcleo del algoritmo
delta = new_cost - current_cost
if delta < 0 or random() < exp(-delta / temperature):
    current = neighbor
    current_cost = new_cost

Parámetros clave:

• T₀ — Temperatura inicial (exploración máxima)
• α — Factor de enfriamiento (velocidad de convergencia)
• I — Iteraciones totales

Mantiene una población de soluciones simultáneas —análogo a estados cuánticos superpuestos— que colapsan hacia el óptimo via presión selectiva:

# Crossover de orden (OX) — recombinación genética
def ox_crossover(parent1, parent2):
    segment = parent1[a:b]                    # subsecuencia preservada
    fill = [x for x in parent2 if x not in segment]
    return fill[:a] + segment + fill[a:]      # hijo resultante

Operadores genéticos:

• Selección — Torneo entre los mejores k individuos
• Crossover OX — Order Crossover preserva restricciones de permutación
• Mutación — Swap aleatorio con probabilidad p_mut = 0.12

Las hormigas refuerzan caminos probabilísticamente mediante feromonas, análogo a la amplificación de amplitudes en el algoritmo de Grover:

# Probabilidad de transición — quantum walk analog
score(i→j) = pheromone[i][j]^α × (1/distance[i][j])^β

La actualización de feromonas implementa evaporación + depósito:

τ(i,j) ← (1-ρ) × τ(i,j) + Σ Q/L_k    para cada hormiga k que usó arista (i,j)

Resultados en instancias aleatorias uniformes (promedio de 50 ejecuciones):

*Gap estimado usando lower bounds (Held-Karp relaxation)

• Python 3.10+
• pip

# 1. Clonar el repositorio
git clone https://github.com/skila-academy/quantroute.git
cd quantroute

# 2. Instalar dependencias
pip install -r backend/requirements.txt

# 3. Iniciar servidor
uvicorn backend.main:app --reload --port 8000

# El servidor estará disponible en http://localhost:8000
# Documentación interactiva: http://localhost:8000/docs

# Opción 1: Abrir directamente (sin dependencias)
open frontend/index.html

# Opción 2: Servidor local
cd frontend && python -m http.server 3000
# Navegar a http://localhost:3000

Nota: El frontend funciona de forma completamente standalone con un motor JS integrado. El backend es opcional y mejora la precisión para instancias grandes (N > 20).

Endpoint principal. Recibe una instancia del problema y devuelve la solución optimizada.

Request body:

{
  "nodes": [
    { "id": 0, "x": 120.5, "y": 340.2, "demand": 1.0, "label": "Depósito Central" },
    { "id": 1, "x": 280.0, "y": 150.8, "demand": 2.5, "label": "Cliente A" }
  ],
  "depot_id": 0,
  "mode": "tsp",
  "algorithm": "sa",
  "vehicles": 3,
  "capacity": 10.0,
  "temperature": 1000.0,
  "cooling_rate": 0.97,
  "iterations": 5000
}

Response:

{
  "routes": [
    { "tour": [0, 3, 7, 1, 4, 0], "cost": 284.5, "vehicle_id": 0 }
  ],
  "total_cost": 284.5,
  "initial_cost": 412.3,
  "improvement_pct": 31.02,
  "elapsed_ms": 143.7,
  "algorithm": "SA",
  "iterations_run": 5000,
  "convergence": [412.3, 380.1, 340.8, 310.2, 295.6, 284.5],
  "metadata": {
    "nodes": 12,
    "mode": "tsp",
    "vehicles": 1,
    "algorithm_detail": "Simulated Annealing — quantum tunneling analog"
  }
}

Lista todos los algoritmos disponibles con sus parámetros y analogías cuánticas.

Health check del servicio.

quantroute/
│
├── backend/
│   ├── main.py                # FastAPI app + todos los algoritmos
│   └── requirements.txt       # fastapi, uvicorn, numpy, pydantic
│
├── frontend/
│   └── index.html             # SPA standalone (HTML + CSS + JS)
│                              # Motor de optimización JS integrado
│                              # Visualización Canvas 2D
│                              # Comunicación opcional con API
│
└── README.md

Usuario (Frontend)
    │
    ├─ [Sin backend] ──→ Motor JS local (SA/GA/ACO en browser)
    │                        └──→ Canvas 2D render
    │
    └─ [Con backend] ──→ POST /optimize ──→ FastAPI
                                               └──→ Numpy + Python algorithms
                                               └──→ JSON response
                                               └──→ Canvas 2D render

El modo VRP implementa un split heurístico post-optimización. Para mejores resultados con restricciones de capacidad reales:

• Usar capacity acorde a la demanda total de los nodos
• Aumentar vehicles gradualmente hasta que todas las rutas sean factibles

• Integración con Google Maps API para coordenadas reales
• Soporte para ventanas de tiempo (VRPTW)
• Algoritmo QUBO para hardware cuántico real (D-Wave)
• Dashboard de analytics con histórico de optimizaciones
• Docker Compose para despliegue en producción
• Exportación de rutas a formato GPX / GeoJSON

Las contribuciones son bienvenidas. Por favor:

1. Haz fork del repositorio
2. Crea una rama: git checkout -b feature/nueva-funcionalidad
3. Commit con mensajes descriptivos: git commit -m 'feat: agrega soporte VRPTW'
4. Push: git push origin feature/nueva-funcionalidad
5. Abre un Pull Request

MIT License — ver LICENSE para detalles.