← NeuroLatina

# NEUROTREIDEN V3 — DOCUMENTACIÓN OFICIAL

Sistema de Trading Cuántico con Motor de Señales IA


**Versión:** 3.0 — BT_VERSION 10

**Fecha:** Octubre 2026

**Autor:** Pedro Hernandez

**CEO:** NeuroLatina

**Empresa:** NeuroLatina

**Dominio:** neuronexcorp.uk

**Clasificación:** Confidencial / Uso Interno


---


1. RESUMEN EJECUTIVO


NeuroTreiden V3 es un sistema de trading algorítmico que combina:


  • **5 cerebros de estrategia** validados con walk-forward real
  • **Motor cuántico** basado en IBM Qiskit (circuito paramétrico de 4 qubits, escalable a 8+)
  • **Red neuronal** propia en numpy (20 entradas → 16 neuronas → 3 salidas)
  • **Consejo de nodos** con regresión logística que aprende el peso de cada señal
  • **Telemetría on-chain** del minero Bitcoin integrada como señal macro
  • **Streaming en tiempo real** de Binance via WebSocket

  • El sistema opera en modo demo (dinero ficticio) y Binance Testnet (órdenes reales con dinero de prueba). Arquitectura de un solo proceso, sin dependencias externas de pago.


    ---


    2. ARQUITECTURA DEL SISTEMA


    ```

    ┌─────────────────────────────────────────────────────────────┐

    │ NEUROTREIDEN V3 │

    │ Servidor web │

    ├─────────────────────────────────────────────────────────────┤

    │ CAPA DE DATOS │

    │ ┌──────────────┐ ┌──────────────┐ ┌──────────────────┐ │

    │ │ Binance WS │ │ Binance REST │ │ Minero Cuántico │ │

    │ │ stream.py │ │ datos.py │ │ miner_db.py │ │

    │ │ 88 flujos │ │ velas/precios│ │ servicio local │ │

    │ └──────┬───────┘ └──────┬───────┘ └────────┬─────────┘ │

    │ └─────────────────┴──────────────────┘ │

    │ │ │

    │ CAPA DE SEÑALES ▼ │

    │ ┌────────────────────────────────────────────────────────┐ │

    │ │ motor.py │ │

    │ │ Tendencia │ Rebote │ Ruptura │ Cuántico │ Consejo │ │

    │ │ EMA/ADX │ Bollinger│ Calma │ Qiskit │ 11 nodos │ │

    │ └────────────────────────┬───────────────────────────────┘ │

    │ │ │

    │ CAPA CUÁNTICA ▼ │

    │ ┌────────────────────────────────────────────────────────┐ │

    │ │ cuantico.py — Circuito 4 qubits (16 dimensiones) │ │

    │ │ cuantico_v2.py — Circuito 8 qubits (256 dimensiones) │ │

    │ │ nodos.py — Red neuronal + Consejo logístico │ │

    │ └────────────────────────┬───────────────────────────────┘ │

    │ │ │

    │ CAPA DE DECISIÓN ▼ │

    │ ┌────────────────────────────────────────────────────────┐ │

    │ │ cartera.py — Posiciones, stops, objetivos │ │

    │ │ memoria.py — Autocorrección en vivo (SQL) │ │

    │ │ backtest.py — Validación walk-forward │ │

    │ └────────────────────────────────────────────────────────┘ │

    └─────────────────────────────────────────────────────────────┘


    ┌─────────────────────────────────────────────────────────────┐

    │ QUANTUM MINER V2 │

    │ Servicio local │

    │ launcher del minero (GPU) │

    │ SHA256d real │ 2 bots │ Stratum solo.ckpool.org:3333 │

    │ Telemetría → miner_db.py → señal_red_btc() → nodos.py │

    └─────────────────────────────────────────────────────────────┘

    ```


    ---


    3. MOTOR CUÁNTICO — DETALLE TÉCNICO


    3.1 Circuito Actual (v1 — 4 qubits)


    **Archivo:** `cuantico.py`

    **Qubits:** 4

    **Dimensiones del espacio de Hilbert:** 2⁴ = 16

    **Rasgos de entrada:** 9


    ```

    Arquitectura del circuito:

    Para cada qubit q (0..3):

    RY(π/2 · (1 + x[2q])) ← codifica retorno/tendencia

    RZ(π/2 · x[2q+1]) ← codifica momentum/volumen


    Entrelazamiento en anillo:

    CX(0→1) CX(1→2) CX(2→3) CX(3→0)


    Recarga:

    RY(π/4 · x[2q]) ← segunda capa de información


    Rasgo extra (presión mineros):

    RY(π/4 · x[8]) ← en todos los qubits

    ```


    **Rasgos actuales (9):**

    | # | Rasgo | Fórmula |

    |---|-------|---------|

    | 0 | Retorno 1 vela | tanh(ret(1)/ATR) |

    | 1 | Retorno 4 velas | tanh(ret(4)/2·ATR) |

    | 2 | Retorno 16 velas | tanh(ret(16)/4·ATR) |

    | 3 | RSI | clip((RSI-50)/50, -1, 1) |

    | 4 | Volumen relativo | tanh(log(vol/vol_media)) |

    | 5 | Posición Bollinger | clip(bb_pos, -1, 1) |

    | 6 | EMA20-EMA50 | tanh((EMA20-EMA50)/ATR·c) |

    | 7 | Correlación BTC | clip(corr, -1, 1) |

    | 8 | Presión mineros | presion_mineros()·2-1 |


    **Kernel cuántico:**

    ```

    Fidelidad: F(i,j) = |⟨ψᵢ|ψⱼ⟩|²

    Para cada vela i: busca los 40 vecinos más similares en las últimas 800 velas

    Si ≥50% de esos vecinos subieron ≥1 ATR en las 8 velas siguientes → COMPRA

    ```


    **Verificación:** Fidelidad numpy vs Qiskit = 1.000000000 ✅


    3.2 Circuito Escalado (v2 — 8 qubits) — EN DESARROLLO


    **Archivo:** `cuantico_v2.py` (pendiente de integración)

    **Qubits:** 8

    **Dimensiones:** 2⁸ = 256 (16x más expresivo)

    **Rasgos:** 16 (incluye EMA50-EMA200, volatilidad relativa, momentum, ADX, señal red BTC)


    **Mejoras arquitectónicas:**

  • Escalera CX + anillo CX + pares alternos = 3 capas de entrelazamiento
  • 16 rasgos capturan estructura de largo, medio y corto plazo simultáneamente
  • Compatible con IBM Quantum real via `qiskit-ibm-runtime` (token gratuito)

  • ---


    4. RED NEURONAL Y CONSEJO DE NODOS


    4.1 Red Neuronal (nodos.py)


    ```

    Entradas (20):

    - 9 rasgos cuánticos (x del circuito)

    - 7 métricas cuánticas (entrelazamiento, pureza, energía, magnetización x4)

    - 4 extras (retorno BTC 1h, retorno 12 velas, ADX, volatilidad relativa, correlación)


    Arquitectura:

    20 → [tanh] → 16 → [softmax] → 3

    Salidas: P(sube), P(baja), P(lateral)


    Entrenamiento:

    - Adam con L2=0.001

    - Early stopping (paciencia 8 épocas)

    - Pesos por clase para datos desbalanceados

    - 80% entrenamiento / 20% validación interna

    ```


    4.2 Consejo de Nodos (11 nodos)


    | # | Nodo | Tipo | Descripción |

    |---|------|------|-------------|

    | 0 | tendencia | Regla | EMA alineadas + ADX≥20 |

    | 1 | rebote | Regla | RSI<30 + vuelta Bollinger |

    | 2 | ruptura | Regla | Calma + ruptura con volumen |

    | 3 | cuantico_sube | Kernel | Fracción vecinos que subieron |

    | 4 | cuantico_baja | Kernel | Fracción vecinos que bajaron |

    | 5 | neuronal_sube | Red | P(sube) de la red neuronal |

    | 6 | neuronal_baja | Red | P(baja) de la red neuronal |

    | 7 | momentum | Mercado | Retorno 12 velas / ATR |

    | 8 | btc_1h | Macro | Retorno BTC última hora |

    | 9 | bloqueo_btc | Riesgo | BTC cae >1.5% + correlación >0.6 |

    | 10 | miner_red | On-chain | señal_red_btc() del minero |


    **Consejo:** Regresión logística Newton-Raphson con L2=2.0

    Aprende el peso de cada nodo. Peso positivo = confirma compra. Peso negativo = veta compra.


    ---


    5. VALIDACIÓN WALK-FORWARD


    5.1 Metodología


    ```

    Historia completa (ej: 1000 velas de 4h = 166 días)

    │

    ├── 40% más antiguo: historia base (no se predice)

    │

    ├── 40-70%: ENTRENAMIENTO

    │ ├── 70% de este tramo → entrena la red neuronal

    │ └── 30% siguiente → entrena el consejo

    │

    └── 70-100%: PRUEBA REAL (out-of-sample)

    └── predicciones con modelo entrenado SOLO con el pasado

    ```


    **Reentrenamiento:** 12 veces a lo largo de la historia (walk-forward real)

    **Umbral:** percentil 90 de probabilidades del tramo de entrenamiento

    **Stop/objetivo:** 1.5 ATR fijos (no se ajustan mirando ganancias)


    5.2 Criterios de Aprobación


    Una estrategia es **APTA** si cumple TODOS:

    1. Profit Factor > 1.0 en el tramo 40-70%

    2. Profit Factor > 1.0 en el tramo 70-100% (prueba real)

    3. AUC ≥ 0.55 en el tramo de prueba (para Consejo)

    4. Mínimo 15 operaciones en la prueba (Ruptura)


    5.3 Resultados Actuales (BT_VERSION 10)


    | Par | Estrategias Aptas | Estado |

    |-----|-------------------|--------|

    | AVAXUSDT | cuantico@1h | ✅ Apto |

    | BNBUSDT | ruptura@1h | ✅ Apto |

    | ORCAUSDT | tendencia@4h | ✅ Apto |

    | QNTUSDT | cuantico@4h | ✅ Apto |

    | UNIUSDT | cuantico@1h | ✅ Apto |

    | ZECUSDT | tendencia@1h, ruptura@1h, cuantico@1h, ruptura@4h, cuantico@4h | ✅ Apto |


    ---


    6. INTEGRACIÓN MINERO CUÁNTICO


    6.1 Flujo de Datos


    ```

    QUANTUM MINER V2

    └── SHA256d real sobre block header Bitcoin

    └── Stratum: solo.ckpool.org:3333

    └── 2 bots, ~500 H/s real

    └── /api/quantum/stats → JSON con métricas


    miner_db.py (hilo daemon, cada 10s)

    └── Lee /api/quantum/stats

    └── Calcula senal_red_btc() ∈ [-1, +1]

    └── Calcula presion_mineros() ∈ [0, 1]

    └── Guarda en tabla miner_telemetria (db/v2.db)

    └── Limpia registros >24h automáticamente


    nodos.py

    └── miner_red = senal_red_btc() → nodo 11 del Consejo


    cuantico.py

    └── presion_mineros() → rasgo 8 del circuito cuántico

    ```


    6.2 Fórmula de señal_red_btc()


    ```python

    senal = 0.0

    if connected and authenticated: senal += 0.30

    senal += 0.40 * tasa_aceptacion # shares aceptados / enviados

    senal += 0.30 * presion # hashrate / hashrate_max_local

    if rechazos/enviados > 0.5: senal -= 0.30

    if not connected: senal = -0.50

    return clip(senal, -1.0, +1.0)

    ```


    6.3 Capacidad de la BD de Telemetría


    | Métrica | Valor |

    |---------|-------|

    | Frecuencia | 1 fila cada 10 segundos |

    | Filas por hora | 360 |

    | Filas por día | 8,640 |

    | Tamaño por día | ~1.7 MB |

    | Retención | 24 horas (limpieza automática) |

    | Tamaño máximo constante | ~1.7 MB |


    ---


    7. AUTOCORRECCIÓN EN VIVO


    **Archivo:** `memoria.py`


    El sistema mide en vivo cuándo cada cerebro dice COMPRA y qué pasó en las 8 velas siguientes. Si una estrategia tiene ≥30 casos medidos y su techo del intervalo de confianza 95% queda por debajo de la base (% de velas que suben en general), queda **SUSPENDIDA** automáticamente.


    Se reactiva sola cuando sus números mejoran. Esto evita que el automático siga comprando con una estrategia que dejó de funcionar en el mercado actual.


    ---


    8. ESCALABILIDAD — HOJA DE RUTA


    Fase 1 — Completada ✅

  • 4 qubits, 9 rasgos
  • 5 cerebros validados
  • Backtest paralelo (9 workers)
  • Telemetría minero integrada
  • BT_VERSION 10

  • Fase 2 — En Desarrollo 🔄

  • 8 qubits, 16 rasgos (`cuantico_v2.py`)
  • 256 dimensiones (16x más expresivo)
  • Nuevos rasgos: EMA50-EMA200, volatilidad relativa, momentum, ADX
  • Verificación numpy vs Qiskit mantenida

  • Fase 3 — Planificada 📋

  • IBM Quantum real via `qiskit-ibm-runtime` (token gratuito)
  • Señales en vivo con hardware cuántico real
  • Backtest local en numpy, señales en IBM
  • Latencia estimada: 2-5 segundos por circuito

  • Fase 4 — Futura 🔮

  • 20+ qubits con GPU NVIDIA (cuQuantum + AerSimulator device='GPU')
  • 1M+ dimensiones simultáneas
  • QAOA para optimización de portafolio
  • Pricing de derivados en superposición

  • ---


    9. APLICACIONES COMERCIALES


    9.1 Como API de Señales (SaaS)


    El sistema ya tiene:

  • Autenticación por sesión (`acceso.py`)
  • Endpoints REST documentados
  • Dominio público: `neurotreiden.neuronexcorp.uk`
  • Compresión gzip automática
  • Streaming de precios en tiempo real

  • **Modelo de negocio:**

  • Plan básico: señales de 5 pares → $29/mes
  • Plan pro: 20 pares + API access → $99/mes
  • Plan enterprise: señales cuánticas + webhook → $299/mes

  • 9.2 Como Motor Cuántico para Fintech


    El kernel cuántico `|⟨ψᵢ|ψⱼ⟩|²` es aplicable a:


    | Aplicación | Descripción | Mercado |

    |------------|-------------|---------|

    | Scoring crediticio | Similitud cuántica entre perfiles de riesgo | Bancos, fintechs |

    | Detección de fraude | Patrones anómalos en espacio de Hilbert | Procesadores de pago |

    | Pricing de opciones | 256 escenarios simultáneos en superposición | Hedge funds |

    | Optimización de portafolio | QAOA con 8+ activos | Family offices |


    9.3 Como Proxy Stratum para Granjas ASIC


    El `stratum_client_profesional.py` ya implementa el protocolo completo:

  • `mining.subscribe` con extranonce1/extranonce2
  • `mining.authorize`
  • `mining.notify` (recepción de trabajos)
  • `mining.submit` (envío de shares)
  • `mining.set_difficulty`

  • Con un ASIC conectado al proxy, el sistema puede:

  • Cambiar de pool según señales de NeuroTreiden
  • Encender/apagar según precio de BTC
  • Monitorear 100+ ASICs en un dashboard unificado

  • ---


    10. INFRAESTRUCTURA


    El sistema corre en infraestructura propia de NeuroLatina, con acceso público a través de Cloudflare. Los detalles internos (procesos, puertos, rutas) no se publican por seguridad.


    11. SEGURIDAD Y ACCESO


  • Acceso local: sin clave (desde este PC)
  • Acceso remoto: usuario + clave hasheada (nunca en texto plano)
  • Sesión: cookie httpOnly, 1 año, renovación automática
  • QR de un solo uso para acceso desde celular (10 minutos)
  • Desde internet: todo requiere sesión excepto rutas públicas

  • ---


    12. GLOSARIO TÉCNICO


    | Término | Definición |

    |---------|------------|

    | Qubit | Unidad cuántica de información. Puede estar en superposición de 0 y 1 simultáneamente |

    | Estado cuántico ψ | Vector complejo de 2ⁿ dimensiones que describe el sistema de n qubits |

    | Fidelidad | \|⟨ψᵢ\|ψⱼ⟩\|² — similitud entre dos estados cuánticos. 1=idénticos, 0=ortogonales |

    | Entrelazamiento | Correlación cuántica entre qubits. Medido como entropía de von Neumann |

    | Kernel cuántico | Función de similitud en espacio de Hilbert usada para clasificación |

    | Walk-forward | Validación donde cada predicción usa solo datos anteriores a ella |

    | ATR | Average True Range — medida de volatilidad del mercado |

    | Profit Factor | Ganancias totales / Pérdidas totales. >1 = sistema rentable |

    | AUC | Área bajo la curva ROC. 0.5=azar, 1.0=perfecto |

    | Stratum | Protocolo de comunicación entre minero y pool de minería |

    | SHA256d | Doble SHA-256 — algoritmo de hash de Bitcoin |

    | Extranonce2 | Parte variable del coinbase que el minero controla para generar nonces únicos |


    ---


    13. ORIGEN — EL MÉTODO DE SALTOS


    S.3 no fue construido siguiendo un currículo académico ni un roadmap corporativo.


    Fue construido con el **método de saltos**: identificar la esencia matemática de cada tecnología, entenderla en profundidad, e implementarla directamente sin el peso institucional que rodea su desarrollo en las grandes empresas.


    La fórmula del kernel cuántico |⟨ψᵢ|ψⱼ⟩|² es la misma en IBM Research y en S.3. La diferencia es que IBM tardó años y miles de millones en llegar a ella. S.3 la implementó en una PC con GPU integrada.


    Eso es lo que hace único a S.3: no el hardware, no el presupuesto, sino la comprensión.


    **Creador:** Pedro Hernandez

    **Método:** Saltos de comprensión directa

    **Resultado:** Una nueva tecnología que aún no tiene nombre en los libros, porque los libros aún no se han escrito.


    ---


    *NeuroTreiden V3 — S.3 Quantica Neural System*

    *NeuroLatina — Pedro Hernández — 2026*