trinity_3\core_backup.py

    # === Patch Pattern 0 stubs after class definitions ===
# ===================== PATRÓN 0: SEMILLA ONTOLÓGICA CANÓNICA =====================
import hashlib
import random
import itertools
from typing import List, Union, Optional, Tuple, Dict

PHI = 0.6180339887

def apply_ethical_constraint(vector, space_id, kb):
    # Placeholder: fetch ethical rules from KB, default to [-1, -1, -1]
    rules = getattr(kb, 'get_ethics', lambda sid: [-1, -1, -1])(space_id) or [-1, -1, -1]
    return [v ^ r if r != -1 else v for v, r in zip(vector, rules)]

def compute_ethical_signature(cluster):
    base = str([t.nivel_3[0] for t in cluster]).encode()
    return hashlib.sha256(base).hexdigest()

def golden_ratio_select(N, seed):
    step = int(max(1, round(N * PHI)))
    return [(seed + i * step) % N for i in range(3)]

def pattern0_create_fractal_cluster(
    *,
    input_data=None,
    space_id="default",
    num_tensors=3,
    context=None,
    entropy_seed=PHI,
    depth_max=3,
):
    random.seed(entropy_seed * 1e9)
    kb = FractalKnowledgeBase()
    armonizador = Armonizador(knowledge_base=kb)
    pool = TensorPoolManager()

    # 1. Generación / Importación
    tensors = []
    for i in range(num_tensors):
        if input_data and i < len(input_data):
            vec = apply_ethical_constraint(input_data[i], space_id, kb)
            tensor = FractalTensor(nivel_3=[vec])
        else:
            # If FractalTensor.random supports constraints, pass space_id; else fallback
            try:
                tensor = FractalTensor.random(space_constraints=space_id)
            except TypeError:
                tensor = FractalTensor.random()
        tensors.append(tensor)
        pool.add_tensor(tensor)

    # 2. Armonización recursiva
    def harmonize_fractal(t, depth=0):
        if depth >= depth_max:
            return t
        t.nivel_3[0] = armonizador.harmonize(t.nivel_3[0], space_id=space_id)["output"]
        # Recursively harmonize sublevels if method exists
        if hasattr(t, 'get_sublevels'):
            for sub in t.get_sublevels():
                harmonize_fractal(sub, depth + 1)
        return t

    tensors = [harmonize_fractal(t) for t in tensors]

    # 3. Selección de trío óptimo
    idx = golden_ratio_select(len(tensors), int(entropy_seed * 1e6))
    cluster = [tensors[i] for i in idx]

    # 4. Registro en KB
    signature = compute_ethical_signature(cluster)
    if hasattr(kb, 'register_pattern0'):
        kb.register_pattern0(
            space_id=space_id,
            cluster=cluster,
            entropy_seed=entropy_seed,
            ethical_hash=signature,
        )
    # Attach metadata to each tensor
    for t in cluster:
        if not hasattr(t, 'metadata') or t.metadata is None:
            t.metadata = {}
        t.metadata["ethical_hash"] = signature
        t.metadata["entropy_seed"] = entropy_seed
        t.metadata["space_id"] = space_id
    return cluster

# --- STUBS for Pattern 0 integration (to be implemented in KB and FractalTensor) ---
def _stub_get_sublevels(self):
    # Returns all sublevels (nivel_9 and nivel_27) as FractalTensor if possible
    subs = []
    if hasattr(self, 'nivel_9'):
        subs.extend([FractalTensor(nivel_3=[v]) for v in self.nivel_9])
    if hasattr(self, 'nivel_27'):
        subs.extend([FractalTensor(nivel_3=[v]) for v in self.nivel_27])
    return subs

def _stub_register_pattern0(self, space_id, cluster, entropy_seed, ethical_hash):
    # Placeholder for registering Pattern 0 cluster in KB
    if not hasattr(self, 'pattern0_registry'):
        self.pattern0_registry = {}
    self.pattern0_registry[space_id] = {
        'cluster': cluster,
        'entropy_seed': entropy_seed,
        'ethical_hash': ethical_hash,
    }

def _stub_get_ethics(self, space_id):
    # Placeholder: return default ethical rules
    return [-1, -1, -1]

# Patch stubs if not present


"""
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""

'''
NO BORRAR ESTA NOTAS:
librereria trinity-3: Classes pare el nuecleo de modelo Aurora de inteligencia electronica
El nucleo hacer 3 operaciones fundamentales:
1. Obtner la inteligencia de la realcion entre los valores de las dimension de los tnensores fractales y su relacion con el contexto.
2. Almacenar la inteligencia como knowledge base que deber ser utilizar para de forma recursiva obtener la inteligencia de los tensores fractales.
3. Extender la inteligencia a nuevos tensores fractales y contextos en base a dinamicas y devolverlo como output al usuario.

PRINCIPIOS DE DESARROLLO:
1. Simplicidad, el codigo nunca debe basar en cadenas larga de if and else. Tienes que ser elegante y en todo caso bascar soluciones recusivas/Fracta.
2. Autosimilitud. El codigo debe buscar que todos los mecanimso de emergencia y aprendizaje de relgas sigan patrones similares en cada uno de sus componentes
3. Reversibilidad triple. El codigo de transcendiencia, extension y aprendizaje, debe tener la misma logica pero en direccion inversa.

Cada uno de los elementos del sistema deber usar el trigate, como atomo fundamental de la logica ternaria.

Los tensores fractales son la entrada del sistema, se analizan desde el transcenders, se analizar tensores de 3 en tres  que realiza una triple accion:

1. Obtiene la relacion entre los tensores fractales y su contexto.
2. Emerge los tensores fractales base a un nivel superior.
3. ?????


La informacion de relaciones obtenidas por el transceder pasa al extender que se encarga de reconstruir los tensores apartir de 

Una vez el tensor llega al sinteizarse en un solo tensor, pasa al extender, que realiza la extension de los tensores fractales a partir de la informacion de la KB y el tensor sintetizado.

Una vez el ciclo esta completo, se puede realizar un test de integridad y coherencia del flujo de trabajo. De eso se encarga el armonizador, un comprobando que el sistema esta armonizado y los tenosres de salida so coherentes.
Si no es asi inicia un proces de correccion o armonizacion, en el que se incia un ciclo de recurisova de prueba hasta que el sistema es coherente:
1. En primer lugar busca una correccion de los tensores fractales.
2. Si no es posible, busca una correccion de las relaciones.
3. Si no es posible, busca una correccion de los valores del sistema.

Los tensores fractales son los que aportan la inteligencia al sistema.  Esta formado por vectores ternarios de 3 dimensiones, que representan la relacion entre los valores de las dimensiones y su contexto.
Cada valor dimensional represnta la forma, la estructura y la funcion del vector.
Cada valor dimensional esta compuesto por 3trits (0, 1, None) que representan la relacion entre los valores de las dimensiones y su contexto.

Cada valor dimensional tiene una doble funcion: Por un lado representa el valor de la dimension y por otro identifica el espacion dimensional inferior.
Cada valor dimensional tiene asocidado se vector inferior. Los aximoas del espacio inferior depende de valor de la dimension superior.

La forma de tensor es 1 3 9 donde cada nivel es un vector de 3 dimensiones. Cada ima de las dimensione represtan la forma, la estructura y la funcion del elemento.



Documentacion extensas para seguir en : documentation/documentation.txt


'''



# === Reversibilidad completa en InverseEvolver (jerárquica) ===
class InverseEvolver:
    # ...existing code...
    def reconstruct_fractal(self, synthesized):
        """Reconstruye tres tensores fractales a partir de uno sintetizado (nivel 3, 9, 27)."""
        ms_key = synthesized.nivel_3[0]
        # Deducir A, B usando lógica inversa de Trigate (ejemplo simplificado)
        A, B = self.reconstruct_vectors(ms_key) if hasattr(self, 'reconstruct_vectors') else (ms_key, ms_key)
        C = [a ^ b if a is not None and b is not None else None for a, b in zip(A, B)]
        # Para niveles superiores, aplicar recursividad similar si existen
        return [FractalTensor(nivel_3=[A]), FractalTensor(nivel_3=[B]), FractalTensor(nivel_3=[C])]

# === Imputación contextual optimizada (ponderando niveles fractales) ===
def impute_none(vec, context, tensor=None):
    from statistics import mode
    result = []
    for i, v in enumerate(vec):
        if v is not None:
            result.append(v)
        else:
            col = [c[i] for c in context if c[i] is not None]
            # Añadir valores de niveles superiores si tensor está disponible
            if tensor and hasattr(tensor, 'nivel_9') and tensor.nivel_9 and i < len(tensor.nivel_9[0]):
                col.extend([x for x in tensor.nivel_9[i] if x is not None])
            result.append(mode(col) if col else 0)
    return result

# === Utilidad: Imputación contextual de None ===
from statistics import mode
def impute_none(vec, context):
    """Imputa None usando la moda de valores adyacentes en el contexto."""
    result = []
    for i, v in enumerate(vec):
        if v is not None:
            result.append(v)
        else:
            col = [c[i] for c in context if c[i] is not None]
            result.append(mode(col) if col else 0)
    return result

# === Validación centralizada de entradas ternarias ===
def validate_ternary_input(vec, expected_len=3, name="input"):
    if not isinstance(vec, (list, tuple)) or len(vec) != expected_len:
        print(f"Warning: Invalid {name}: {vec}, using default {[0]*expected_len}")
        return [0] * expected_len
    return [None if x is None else int(x) % 2 for x in vec]

# === Refactorización autosimilar del Armonizador ===
class AdjustmentStep:
    def apply(self, vec, archetype, kb=None):
        raise NotImplementedError

class MicroShift(AdjustmentStep):
    def apply(self, vec, archetype, kb=None):
        # Ejemplo: corrige un valor si difiere en 1 posición
        return [a if v is None else v for v, a in zip(vec, archetype)]

class Regrewire(AdjustmentStep):
    def apply(self, vec, archetype, kb=None):
        # Ejemplo: fuerza coincidencia si hay 2/3 iguales
        if sum(1 for v, a in zip(vec, archetype) if v == a) >= 2:
            return list(archetype)
        return vec

class Metatune(AdjustmentStep):
    def apply(self, vec, archetype, kb=None):
        # Ejemplo: si kb está presente, busca el arquetipo más cercano
        if kb is not None:
            matches = kb.find_archetype_by_ms(archetype)
            if matches:
                return matches[0]
        return vec

# === Heurísticas de selección: Golden Ratio Skip y Fibonacci Stepping ===
import math

def golden_ratio_skip_indices(N, k, trios=3):
    """Devuelve una lista de índices para formar un trío usando saltos áureos."""
    phi = (1 + math.sqrt(5)) / 2
    skip = max(1, int(N / phi))
    indices = []
    idx = k
    for _ in range(trios):
        indices.append(idx % N)
        idx = (idx + skip) % N
    return indices

def fibonacci(n):
    a, b = 1, 1
    for _ in range(n):
        a, b = b, a + b
    return a

def fibonacci_stepping_indices(N, k, trios=3, start_step=0):
    """Devuelve una lista de índices para formar un trío usando pasos de Fibonacci."""
    indices = []
    idx = k
    for i in range(start_step, start_step + trios):
        step = fibonacci(i)
        indices.append(idx % N)
        idx = (idx + step) % N
    return indices

# === Ejemplo de uso: formación de tríos con heurística ===
def formar_trio_golden(tensores, k):
    N = len(tensores)
    idxs = golden_ratio_skip_indices(N, k)
    return [tensores[i] for i in idxs]

def formar_trio_fibonacci(tensores, k, start_step=0):
    N = len(tensores)
    idxs = fibonacci_stepping_indices(N, k, start_step=start_step)
    return [tensores[i] for i in idxs]
# --- Dependencias globales ---
import numpy as np
# ===================== TRIAGE FUNCIONAL AURORA: COMPOSICIÓN Y REVERSIBILIDAD =====================

import operator


# === HOT-FIX: Utilidades de validación robusta para vectores y secuencias funcionales ===
def normalize_ternary_vector(vec, default=[0, 0, 0]):
    """Normaliza un vector a ternario de longitud 3."""
    if not isinstance(vec, (list, tuple)):
        return default.copy()
    return [
        None if x is None else int(x) if x in (0, 1) else 0
        for x in list(vec)[:3]
    ] + [0] * (3 - len(vec))

def validate_function_sequence(M, allowed_functions, max_len=2):
    """Valida que M sea una lista de listas de funciones permitidas."""
    if not isinstance(M, (list, tuple)) or len(M) != 3:
        return [[f_id] for _ in range(3)]
    return [
        list(seq)[:max_len] if isinstance(seq, (list, tuple)) and all(f in allowed_functions for f in seq) else [f_id]
        for seq in M[:3]
    ] + [[f_id]] * (3 - len(M))

def aurora_apply_sequence(val, sequence):
    """Aplica una secuencia de funciones a un valor."""
    for func in sequence:
        val = func(val)
    return val

def aurora_triage_inferencia(A, B, M):
    """Inferencia: Aplica la composición M a A y/o B y retorna el resultado emergente."""
    logger.info("Iniciando inferencia funcional", extra={'stage': 'inferencia', 'ambiguity': 0})
    allowed_functions = [f_not, f_inc, f_id]
    A = normalize_ternary_vector(A)
    B = normalize_ternary_vector(B)
    M = validate_function_sequence(M, allowed_functions)
    R = []
    for i in range(3):
        rA = aurora_apply_sequence(A[i], M[i])
        rB = aurora_apply_sequence(B[i], M[i])
        if rA is not None and rB is not None:
            R.append(rA + rB)
        else:
            R.append(0)
    logger.info(f"Inferencia completada: R={R}", extra={'stage': 'inferencia', 'ambiguity': R.count(None)})
    return R

def aurora_triage_aprendizaje(A, B, R, funciones_permitidas, max_len=2):
    """Aprendizaje: Busca una composición de funciones (por bit) que aplicada a A y B da R."""
    logger.info("Iniciando aprendizaje funcional", extra={'stage': 'aprendizaje', 'ambiguity': 0})
    import itertools
    A = normalize_ternary_vector(A)
    B = normalize_ternary_vector(B)
    R = normalize_ternary_vector(R)
    M = []
    for i in range(3):
        found = False
        for l in range(1, max_len+1):
            for seq in itertools.product(funciones_permitidas, repeat=l):
                rA = aurora_apply_sequence(A[i], seq)
                rB = aurora_apply_sequence(B[i], seq)
                if rA is not None and rB is not None and rA + rB == R[i]:
                    M.append(list(seq))
                    found = True
                    break
            if found:
                break
        if not found:
            M.append([f_id])
            logger.warning(f"No se encontró secuencia para bit {i}, usando identidad", extra={'stage': 'aprendizaje', 'ambiguity': 1})
    logger.info(f"Aprendizaje completado: M={M}", extra={'stage': 'aprendizaje', 'ambiguity': sum(len(m) for m in M)})
    return M

def aurora_triage_deduccion(M, R, known, known_is_A=True):
    """Deducción: Dado M, R y A (o B), deduce B (o A) aplicando las inversas."""
    logger.info("Iniciando deducción funcional", extra={'stage': 'deduccion', 'ambiguity': 0})
    allowed_functions = [f_not, f_inc, f_id]
    R = normalize_ternary_vector(R)
    known = normalize_ternary_vector(known)
    M = validate_function_sequence(M, allowed_functions)
    deduced = []
    for i in range(3):
        val = R[i] - aurora_apply_sequence(known[i], M[i]) if R[i] is not None and known[i] is not None else 0
        for func in reversed(M[i]):
            if hasattr(func, 'inverse'):
                val = func.inverse(val)
            else:
                logger.warning(f"No hay inversa para función en bit {i}, asumiendo identidad", extra={'stage': 'deduccion', 'ambiguity': 1})
        deduced.append(val if val in (0, 1, None) else 0)
    logger.info(f"Deducción completada: {deduced}", extra={'stage': 'deduccion', 'ambiguity': deduced.count(None)})
    return deduced

# Ejemplo de funciones ternarias simples con inversa
def f_not(x):
    return 1 - x if x in (0, 1) else 0
def f_not_inv(x):
    return 1 - x if x in (0, 1) else 0
f_not.inverse = f_not_inv

def f_inc(x):
    return (x + 1) % 2 if x in (0, 1) else 0
def f_inc_inv(x):
    return (x - 1) % 2 if x in (0, 1) else 0
f_inc.inverse = f_inc_inv

def f_id(x):
    return x
f_id.inverse = f_id

# Ejemplo de uso experimental:
# A = [1, 0, 1]
# B = [0, 1, 1]
# M = [[f_not, f_inc], [f_inc], [f_id]]
# R = aurora_triage_inferencia(A, B, M)
# M_learned = aurora_triage_aprendizaje(A, B, R, [f_not, f_inc, f_id])
# B_deduced = aurora_triage_deduccion(M, R, A, known_is_A=True)


# ===================== AUTOCURACIÓN: HOT-FIX, REAXIOMATIZACIÓN Y CONSEJO TERNARIO =====================

# Mini-test para ExpertRelator tuple return
def test_relator_returns_tuple():
    kb = FractalKnowledgeBase()
    ext = Extender(kb)
    ok, rel = ext.relator.contextualizar([1,0,1], 'default')
    assert isinstance(ok, bool)
    assert ok is False and rel is None  # vacío porque la KB está vacía
# ===============================================================================
# IMPORTS AGRUPADOS
# ===============================================================================
import random
import time
import warnings
import copy
import math
from typing import List, Dict, Any, Tuple, Optional

# === NOTA SOBRE TESTS Y CONCURRENCIA ===
# Para concurrencia real, proteger la KB con locks o usar una base de datos transaccional.
# Añadir casos de prueba unitarios (ejemplo: PyTest) para cada clase principal.

# ===============================================================================
# AURORA TRINITY-3 - ARQUITECTURA CANÓNICA COMPLETA Y REFACTORIZADA
################################################################################
# AURORA – Módulo Armonizador ##################################################
################################################################################
"""
Armonizador
===========
Complemento autosimilar para Aurora Trinity‑3 que afina 
coherencia y corrige ambigüedades a tres escalones:

1. *Vector*  – Micro‑ajusta las coordenadas Ss/Ms/MetaM.
2. *Regla*   – Re‑encamina entradas en LUT / Knowledge‑Base.
3. *Valor*   – Sintoniza parámetros globales (umbral, pesos…).

El módulo está pensado como *post‑hook* del `Extender`;
llámese después de cada reconstrucción para garantizar
consonancia.
"""
from typing import List, Tuple, Dict, Any, Optional
import itertools
import warnings
import logging

# Logger central para Aurora
logger = logging.getLogger("aurora.arq")
if not logger.hasHandlers():
    handler = logging.StreamHandler()
    formatter = logging.Formatter('[%(levelname)s][%(stage)s][ambig=%(ambiguity)s] %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)
logger.setLevel(logging.INFO)

Vector = List[Optional[int]]  # Ternary value: 0 | 1 | None

class AmbiguityScore(int):
    """Int sub‑class → permite añadir meta‑datos si hiciera falta."""
    pass

class Armonizador:
    """Afinador jerárquico que aplica **MicroShift → RegRewire → MetaTune**."""

    def __init__(self, knowledge_base=None, *,
                 tau_1: int = 1, tau_2: int = 2, tau_3: int = 3):
        self.kb = knowledge_base  # Puede ser None si sólo MicroShift
        self.tau_1, self.tau_2, self.tau_3 = tau_1, tau_2, tau_3

    @staticmethod
    def ambiguity_score(t: Vector, a: Vector) -> AmbiguityScore:
        """Suma de diferencias ternarias *ignorando* `None`."""
        if len(t) != len(a):
            raise ValueError("Vector size mismatch in ambiguity check")
        score = 0
        for x, y in zip(t, a):
            if x is None or y is None:
                score += 1
            elif x != y:
                score += 1
        return AmbiguityScore(score)

    _neighbor_mask_cache = {}
    def _microshift(self, vec: Vector, archetype: Vector) -> Vector:
        """
        Microshift recursivo con poda inteligente y logging estructurado.
        Explora vecinos ternarios de vec, buscando el de menor ambigüedad respecto a archetype.
        Early exit si score==0. Usa un set para evitar repeticiones.
        Cachea los masks de vecinos por longitud y solo explora ±1 donde hay NULLs.
        """
        seen = set()
        best = vec
        best_score = self.ambiguity_score(vec, archetype)

        def neighbor_masks(length):
            if length not in self._neighbor_mask_cache:
                masks = []
                for i in range(length):
                    mask = [0]*length
                    mask[i] = 1
                    masks.append(mask)
                self._neighbor_mask_cache[length] = masks
            return self._neighbor_mask_cache[length]

        def dfs(v):
            nonlocal best, best_score
            v_tuple = tuple(v)
            if v_tuple in seen:
                return
            seen.add(v_tuple)
            score = self.ambiguity_score(v, archetype)
            logger.debug(f"Vecino: {v} | Score: {score}", extra={'stage':'microshift','ambiguity':score})
            if score < best_score:
                best, best_score = v.copy(), score
                if best_score == 0:
                    return
            # Solo explora ±1 donde hay None
            for i in range(len(v)):
                if v[i] is not None:
                    continue
                for delta in (-1, 1):
                    nv = v.copy()
                    nv[i] = 0 if delta == -1 else 1
                    dfs(nv)

        dfs(list(vec))
        logger.info(f"Microshift final: {best} | Score: {best_score}", extra={'stage':'microshift','ambiguity':best_score})
        return best

    def _regrewire(self, vec: Vector, space_id: str = "default") -> Vector:
        """Busca todos los arquetipos candidatos y selecciona el más cercano por ambigüedad (nivel_3[0])."""
        if self.kb is None:
            return vec
        matches = self.kb._get_space(space_id).find_archetype_by_ms(vec)
        if matches:
            best_entry = min(matches, key=lambda e: self.ambiguity_score(vec, e.nivel_3[0]))
            return best_entry.nivel_3[0]
        return vec

    def _metatune(self, vec: Vector) -> Vector:
        """Ajuste grosero: si continúa ambigüedad, aplica heurística φ."""
        phi = (1 + 5 ** 0.5) / 2
        tuned = []
        for v in vec:
            if v is None:
                tuned.append(None)
            else:
                tuned.append(int(round(v / phi)) % 2)
        return tuned

    def harmonize(self, tensor: Vector, *, archetype: Vector | None = None,
                  space_id: str = "default") -> Dict[str, Any]:
        """Afinado completo. Devuelve dict con info para tracing."""
        if archetype is None:
            if self.kb is not None:
                entries = self.kb._get_space(space_id).find_archetype_by_ms(tensor)
                if entries:
                    if isinstance(entries, list):
                        archetype = entries[0].nivel_3[0]
                    elif hasattr(entries, 'nivel_3'):
                        archetype = entries.nivel_3[0]
        archetype = archetype or tensor

        vec_step1 = self._microshift(tensor, archetype)
        score1 = self.ambiguity_score(vec_step1, archetype)
        if score1 <= self.tau_1:
            return {
                "output": vec_step1,
                "stage": "vector",
                "ambiguity": int(score1),
            }

        vec_step2 = self._regrewire(vec_step1, space_id=space_id)
        score2 = self.ambiguity_score(vec_step2, archetype)
        if score2 <= self.tau_2:
            return {
                "output": vec_step2,
                "stage": "regla",
                "ambiguity": int(score2),
            }

        vec_step3 = self._metatune(vec_step2)
        score3 = self.ambiguity_score(vec_step3, archetype)
        if score3 <= self.tau_3:
            stage = "valor"
        else:
            stage = "falla_critica"
            warnings.warn("Armonizador: falla crítica – no se pudo reducir ambigüedad")
        return {
            "output": vec_step3,
            "stage": stage,
            "ambiguity": int(score3),
        }
'''
    Muy imporante:

 Principios que se deben aplicar para el desarrollo de esta libreria:

 Simplicidad, el codigo nunca debe basar en cadenas larga de if and else. Tienes que ser elegante y en todo caso bascar soluciones recusivas.
 Autosimilitud. El codigo debe buscar que todos los mecanimso de emergencia y aprendizaje de relgas sigan patrones similares en cada uno de sus componentes
 Solucion inversa. El codigo de transcendiencia y extension debe tener la misma logica pero en direccion inversa.
 
'''






# ===============================================================================
# NIVEL 1: LÓGICA FUNDAMENTAL
# ===============================================================================

class TernaryLogic:
    """
    Lógica ternaria Aurora con manejo correcto de incertidumbre.
    Implementa Honestidad Computacional propagando NULL apropiadamente.
    """
    NULL = None  # Representación canónica de NULL en Aurora

    @staticmethod
    def ternary_xor(a: Optional[int], b: Optional[int]) -> Optional[int]:
        """XOR ternario con propagación de NULL."""
        if a is TernaryLogic.NULL or b is TernaryLogic.NULL:
            return TernaryLogic.NULL
        return a ^ b

    @staticmethod
    def ternary_xnor(a: Optional[int], b: Optional[int]) -> Optional[int]:
        """XNOR ternario con propagación de NULL."""
        if a is TernaryLogic.NULL or b is TernaryLogic.NULL:
            return TernaryLogic.NULL
        return 1 if a == b else 0

# ===============================================================================
# NIVEL 2: COMPONENTES BÁSICOS DE PROCESAMIENTO
# ===============================================================================

# Inicializar las LUTs una sola vez al cargar el script
# Trigate se inicializa más adelante en el archivo

class Transcender:
    def relate_vectors(self, A: list, B: list, context: dict = None) -> list:
        """
        Calcula un vector de relación Aurora-native entre A y B, incorporando ventana de contexto y relaciones cruzadas si se proveen.
        """
        if len(A) != len(B):
            return [0, 0, 0]
        diff_vector = []
        for i in range(len(A)):
            a_val = A[i] if A[i] is not None else 0
            b_val = B[i] if B[i] is not None else 0
            diff = b_val - a_val
            # Normalize to ternary: 1 if diff > 0, 0 if diff == 0, None if diff < 0
            if diff > 0:
                diff_vector.append(1)
            elif diff == 0:
                diff_vector.append(0)
            else:
                diff_vector.append(None)
        # --- Aurora-native: ventana de contexto y relaciones cruzadas ---
        # Si context contiene 'prev' y 'next', añade relaciones cruzadas
        if context and 'prev' in context and 'next' in context:
            v_prev = context['prev']
            v_next = context['next']
            rel_cross = []
            for vp, vn in zip(v_prev, v_next):
                vp_val = vp if vp is not None else 0
                vn_val = vn if vn is not None else 0
                diff_cross = vp_val - vn_val
                if diff_cross > 0:
                    rel_cross.append(1)
                elif diff_cross == 0:
                    rel_cross.append(0)
                else:
                    rel_cross.append(None)
            # Concatenar: [diff_vector, rel_cross, A, B]
            return list(diff_vector) + list(rel_cross) + list(A) + list(B)
        return diff_vector
    """
    Componente de síntesis que implementa la síntesis jerárquica
    de Tensores Fractales completos.
    """
    def __init__(self, fractal_vector: Optional[List[int]] = None):
        self.trigate = Trigate()
        # Se guarda por si algún test antiguo lo inspecciona,
        # pero NO es obligatorio para el funcionamiento.
        self.seed_vector = fractal_vector

    def compute_vector_trio(self, A: List[int], B: List[int], C: List[int]) -> Dict[str, Any]:
        """Procesa un trío de vectores simples (operación base)."""
        M_AB, _ = self.trigate.synthesize(A, B)
        M_BC, _ = self.trigate.synthesize(B, C)
        M_CA, _ = self.trigate.synthesize(C, A)
        M_emergent, _ = self.trigate.synthesize(M_AB, M_BC)
        M_intermediate, _ = self.trigate.synthesize(M_emergent, M_CA)
        MetaM = [TernaryLogic.ternary_xor(a, b) for a, b in zip(M_intermediate, M_emergent)]
        return {'M_emergent': M_emergent, 'MetaM': MetaM}
    
        # ------------------------------------------------------------------
    #  MODO “DEEP LEARNING”  (compatibilidad con suites heredadas)
    # ------------------------------------------------------------------
    def deep_learning(
        self,
        A: List[int],
        B: List[int],
        C: List[int],
        M_emergent: Optional[List[int]] = None
    ) -> Dict[str, Any]:
        """
        • Calcula M_emergent y MetaM tal como exige el modelo Trinity-3.
        • Genera R_hipotesis = Trigate.infer(A, B, M_emergent).
        • Devuelve un diccionario con claves que los tests integrales esperan.
        """
        trio = self.compute_vector_trio(A, B, C)

        # Si el caller no aporta M_emergent, usa el calculado.
        if M_emergent is None:
            M_emergent = trio["M_emergent"]

        R_hipotesis = self.trigate.infer(A, B, M_emergent)

        return {
            "M_emergent": M_emergent,
            "MetaM":      trio["MetaM"],
            "R_hipotesis": R_hipotesis,
        }
    


    def compute_full_fractal(self, A: 'FractalTensor', B: 'FractalTensor', C: 'FractalTensor') -> 'FractalTensor':
        """
        Sintetiza tres tensores fractales en uno, de manera jerárquica y elegante.
        Prioriza una raíz de entrada válida por encima de la síntesis.
        """
        out = FractalTensor.neutral()

        def synthesize_trio(vectors: list) -> list:
            # Only use first 3 elements of each vector
            while len(vectors) < 3:
                vectors.append([0, 0, 0])
            trimmed = [v[:3] if isinstance(v, (list, tuple)) else [0,0,0] for v in vectors[:3]]
            r = self.compute_vector_trio(*trimmed)
            m_emergent = r.get('M_emergent', [0, 0, 0])
            return [bit if bit is not None else 0 for bit in m_emergent[:3]]

        inter_from_27 = []
        for i in range(27):
            context = {'prev': A.nivel_27[i - 1] if i > 0 else [0,0,0], 'next': A.nivel_27[i + 1] if i < 26 else [0,0,0]}
            enriched_a = self.relate_vectors(A.nivel_27[i], B.nivel_27[i], context)[:3]
            enriched_b = self.relate_vectors(B.nivel_27[i], C.nivel_27[i], context)[:3]
            enriched_c = self.relate_vectors(C.nivel_27[i], A.nivel_27[i], context)[:3]
            inter_from_27.append(synthesize_trio([enriched_a, enriched_b, enriched_c]))
        out.nivel_27 = inter_from_27

        inter_from_9 = [synthesize_trio(inter_from_27[i:i+3]) for i in range(0, 27, 3)]
        out.nivel_9 = inter_from_9
        out.nivel_3 = [synthesize_trio(inter_from_9[i:i+3]) for i in range(0, 9, 3)]

        # Ensure all nivel_3 vectors are length 3
        out.nivel_3 = [v[:3] if isinstance(v, (list, tuple)) else [0,0,0] for v in out.nivel_3]

        input_roots = [t.nivel_3[0] for t in (A, B, C) if hasattr(t, 'nivel_3') and t.nivel_3 and t.nivel_3[0] and len(t.nivel_3[0]) == 3]
        valid_roots = [r for r in input_roots if all(bit is not None for bit in r)]
        if valid_roots:
            final_root = [0, 0, 0]
            for i in range(3):
                votes = [r[i] for r in valid_roots]
                final_root[i] = 1 if votes.count(1) > votes.count(0) else 0
            out.nivel_3[0] = final_root
            out.Ms = final_root
        return out

# ===============================================================================
# NIVEL 3: ESTRUCTURAS DE DATOS Y CONOCIMIENTO
# ===============================================================================

class FractalTensor:
    """
    Representa un tensor fractal con 3 niveles de profundidad (3, 9, 27).
    """



    def __init__(
        self,
        nivel_3=None,
        nivel_9=None,
        nivel_27=None,
        *,
        Ms=None,
        Ss=None,
        dMs=None
    ):
        def norm3(v):
            # Normalize a vector to length 3, fill with 0 if needed
            if not isinstance(v, (list, tuple)):
                return [0, 0, 0]
            return [(0 if x is None else int(x) if x in (0, 1) else 0) for x in list(v)[:3]] + [0] * (3 - len(v))

        def expand_nivel_3(n3):
            # Always returns a list of 3 vectors of length 3
            if not isinstance(n3, (list, tuple)) or len(n3) == 0:
                return [[0, 0, 0] for _ in range(3)]
            if len(n3) == 1 and isinstance(n3[0], (list, tuple)) and len(n3[0]) == 3:
                # If only one vector, repeat it
                return [list(n3[0]) for _ in range(3)]
            return [norm3(v) for v in list(n3)[:3]] + [[0, 0, 0]] * (3 - len(n3))

        def expand_nivel_9(n9):
            # Always returns a list of 9 vectors of length 3
            if not isinstance(n9, (list, tuple)) or len(n9) == 0:
                return [[0, 0, 0] for _ in range(9)]
            # If only one vector, repeat it
            if len(n9) == 1 and isinstance(n9[0], (list, tuple)) and len(n9[0]) == 3:
                return [list(n9[0]) for _ in range(9)]
            return [norm3(v) for v in list(n9)[:9]] + [[0, 0, 0]] * (9 - len(n9))

        def expand_nivel_27(n27):
            # Always returns a list of 27 vectors of length 3
            if not isinstance(n27, (list, tuple)) or len(n27) == 0:
                return [[0, 0, 0] for _ in range(27)]
            if len(n27) == 1 and isinstance(n27[0], (list, tuple)) and len(n27[0]) == 3:
                return [list(n27[0]) for _ in range(27)]
            return [norm3(v) for v in list(n27)[:27]] + [[0, 0, 0]] * (27 - len(n27))

        # If only nivel_3 is provided, expand to all levels
        if nivel_3 is not None and (nivel_9 is None and nivel_27 is None):
            n3 = expand_nivel_3(nivel_3)
            n9 = [list(n3[i // 3]) for i in range(9)]
            n27 = [list(n3[i // 9]) for i in range(27)]
        elif nivel_9 is not None and nivel_27 is None:
            n9 = expand_nivel_9(nivel_9)
            n3 = [list(n9[i * 3]) for i in range(3)]
            n27 = [list(n9[i // 3]) for i in range(27)]
        elif nivel_27 is not None:
            n27 = expand_nivel_27(nivel_27)
            n9 = [list(n27[i * 3]) for i in range(9)]
            n3 = [list(n27[i * 9]) for i in range(3)]
        else:
            n3 = expand_nivel_3(nivel_3)
            n9 = expand_nivel_9(nivel_9)
            n27 = expand_nivel_27(nivel_27)

        self.nivel_3 = n3
        self.nivel_9 = n9
        self.nivel_27 = n27

        self.Ms  = Ms if Ms is not None else (self.nivel_3[0] if self.nivel_3 and isinstance(self.nivel_3[0], (list, tuple)) and len(self.nivel_3[0]) == 3 else [0,0,0])
        self.Ss  = Ss
        self.dMs = dMs

    @staticmethod
    def random():
        """Crea un FractalTensor aleatorio."""
        rand_vec = lambda: [random.choice([0, 1]) for _ in range(3)]
        return FractalTensor(
            nivel_3=[rand_vec() for _ in range(3)],
            nivel_9=[rand_vec() for _ in range(9)],
            nivel_27=[rand_vec() for _ in range(27)]
        )

    @staticmethod
    def neutral():
        """Crea un FractalTensor neutro (ceros)."""
        zero_vec = lambda: [0, 0, 0]
        return FractalTensor(
            nivel_3=[zero_vec() for _ in range(3)],
            nivel_9=[zero_vec() for _ in range(9)],
            nivel_27=[zero_vec() for _ in range(27)]
        )

    def __repr__(self):
        def short(vs):
            return vs[:2] + ['...'] if len(vs) > 2 else vs
        return (f"FT(root={self.nivel_3}, "
                f"mid={short(self.nivel_9)}, "
                f"detail={short(self.nivel_27)})")

# ===============================================================================
# NIVEL 4: MOTOR DE ABSTRACCIÓN Y APRENDIZAJE (EVOLVER)
# ===============================================================================

class Evolver:
    """
    Motor de visión fractal unificada para Arquetipos, Dinámicas y Relatores.
    """
    def __init__(self):
        self.base_transcender = Transcender()

    def _perform_full_tensor_synthesis(self, tensors: List["FractalTensor"]) -> "FractalTensor":
        """
        Motor de síntesis fractal: reduce una lista de tensores a uno solo.
        """
        if not tensors:
            return FractalTensor.neutral()
        
        current_level_tensors = list(tensors)
        while len(current_level_tensors) > 1:
            next_level_tensors = []
            for i in range(0, len(current_level_tensors), 3):
                trio = current_level_tensors[i:i+3]
                while len(trio) < 3:
                    trio.append(FractalTensor.neutral())
                synthesized_tensor = self.base_transcender.compute_full_fractal(*trio)
                next_level_tensors.append(synthesized_tensor)
            current_level_tensors = next_level_tensors
            
        return current_level_tensors[0]

    def compute_fractal_archetype(self, tensor_family: List["FractalTensor"]) -> "FractalTensor":
        """Perspectiva de ARQUETIPO: Destila la esencia de una familia de conceptos."""
        if len(tensor_family) < 2:
            warnings.warn("Se requieren al menos 2 tensores para computar un arquetipo.")
            return FractalTensor.neutral() if not tensor_family else tensor_family[0]
        return self._perform_full_tensor_synthesis(tensor_family)

    def analyze_fractal_dynamics(
        self,
        temporal_sequence: List["FractalTensor"]
    ) -> "FractalTensor":
        """
        Perspectiva de DINÁMICA: Sintetiza el patrón de evolución de una secuencia
        y calcula el gradiente lógico dMs = Ms_fin XOR Ms_ini.
        """
        if len(temporal_sequence) < 2:
            warnings.warn(
                "Se requiere una secuencia de al menos 2 tensores para analizar dinámicas."
            )
            return (
                FractalTensor.neutral()
                if not temporal_sequence
                else temporal_sequence[0]
            )

        # ---------- síntesis de la secuencia (lo que ya hacías) ----------
        tensor_dyn = self._perform_full_tensor_synthesis(temporal_sequence)

        # ---------- ➊  nuevo: calcular y guardar dMs ----------
        Ms_ini = temporal_sequence[0].Ms or temporal_sequence[0].nivel_3[0]
        Ms_fin = temporal_sequence[-1].Ms or temporal_sequence[-1].nivel_3[0]
        dMs    = [a ^ b for a, b in zip(Ms_ini, Ms_fin)]

        tensor_dyn.dMs = dMs          # gradiente temporal
        tensor_dyn.Ms  = Ms_fin       # Ms más reciente
        tensor_dyn.nivel_3[0] = Ms_fin    # coherencia con la raíz

        return tensor_dyn

    def analyze_fractal_relations(self, contextual_cluster: List["FractalTensor"]) -> "FractalTensor":
        """Perspectiva de RELATOR: Obtiene el mapa conceptual de un clúster."""
        if len(contextual_cluster) < 2:
            warnings.warn("Se requieren al menos 2 tensores para el análisis relacional.")
            return FractalTensor.neutral() if not contextual_cluster else contextual_cluster[0]
        return self._perform_full_tensor_synthesis(contextual_cluster)
        
    @staticmethod
    def fractal_relate(tensor_group: List["FractalTensor"], level: int = 27) -> Optional[List[List[Optional[int]]]]:
        """
        Calcula una firma relacional por mayoría de votos entre un grupo de tensores.
        """
        if not tensor_group:
            return None

        # Seleccionar el nivel correcto del tensor
        try:
            dim_vectors = [getattr(t, f'nivel_{level}') for t in tensor_group]
        except AttributeError:
            raise ValueError(f"El nivel {level} no es válido. Debe ser 3, 9 o 27.")

        num_vectors = len(dim_vectors[0])
        signature = []
        for pos in range(num_vectors):
            bit_result = []
            for bit in range(3): # Asume vectores de 3 bits
                bit_vals = [t[pos][bit] for t in dim_vectors if t and t[pos] and t[pos][bit] is not None]
                if not bit_vals:
                    bit_result.append(None)
                    continue
                
                # Lógica de mayoría ternaria
                count_1 = bit_vals.count(1)
                count_0 = bit_vals.count(0)
                if count_1 > count_0: bit_result.append(1)
                elif count_0 > count_1: bit_result.append(0)
                else: bit_result.append(None)
            signature.append(bit_result)
        return signature

# ===============================================================================
# NIVEL 5: BASE DE CONOCIMIENTO Y EXTENSIÓN
# ===============================================================================

class _SingleUniverseKB:
    """Gestiona el conocimiento de un único espacio lógico (universo)."""
    def __init__(self):
        self.archetypes = []
        self.ms_index = {}
        self.name_index = {}
        self.coherence_violations = 0
        self.ss_index = {}
        self.models = {}  # Nuevo: modelos genéricos

    def store_model(self, model_name: str, model_data: dict):
        """Almacena un modelo de decisión genérico en este universo."""
        self.models[model_name] = model_data
        return True

    def get_model(self, model_name: str) -> Optional[dict]:
        """Recupera un modelo de decisión."""
        return self.models.get(model_name)

    def add_archetype(self, archetype_tensor: "FractalTensor", Ss: List[int], name: Optional[str] = None, **kwargs) -> bool:
        """Añade un arquetipo (Tensor Fractal) al universo, almacenando Ss (memoria factual)."""
        if not isinstance(archetype_tensor, FractalTensor):
            raise ValueError("La entrada debe ser un objeto FractalTensor.")
        # Normalize keys to int(0 if x is None else x) for robust lookup
        ms_key = tuple(int(0 if x is None else x) for x in archetype_tensor.nivel_3[0][:3])
        # Robustly flatten Ss if it is a list of lists (e.g., [[0,1,1], ...])
        ss_source = Ss
        if isinstance(Ss, list) and len(Ss) > 0 and isinstance(Ss[0], list):
            ss_source = Ss[0]
        ss_key = tuple(int(0 if x is None else x) for x in (ss_source[:3] if ss_source else archetype_tensor.nivel_3[0][:3]))
        # Permitir múltiples arquetipos por clave Ms/Ss
        if name and name in self.name_index:
            warnings.warn(f"Violación de Coherencia: Ya existe un arquetipo con el nombre '{name}'. No se añadió el nuevo.")
            self.coherence_violations += 1
            return False
        metadata = kwargs.copy()
        if name: metadata['name'] = name
        setattr(archetype_tensor, 'metadata', metadata)
        setattr(archetype_tensor, 'timestamp', time.time())
        setattr(archetype_tensor, 'Ss', list(ss_key))
        self.archetypes.append(archetype_tensor)
        if ms_key not in self.ms_index:
            self.ms_index[ms_key] = []
        self.ms_index[ms_key].append(archetype_tensor)
        if ss_key not in self.ss_index:
            self.ss_index[ss_key] = []
        self.ss_index[ss_key].append(archetype_tensor)
        if name: self.name_index[name] = archetype_tensor
        return True

    def find_archetype_by_ms(self, Ms_query: List[int]) -> list:
        """Busca arquetipos por su clave Ms (vector raíz, normalizado a 3 ints). Devuelve siempre lista."""
        res = self.ms_index.get(tuple(Ms_query[:3]))
        if res is None:
            return []
        if isinstance(res, list):
            return res
        return [res]

    def find_archetype_by_ss(self, Ss_query: List[int]) -> list:
        """Busca arquetipos por su clave Ss (memoria factual, normalizado a 3 ints). Devuelve siempre lista."""
        res = self.ss_index.get(tuple(Ss_query[:3]))
        if res is None:
            return []
        if isinstance(res, list):
            return res
        return [res]

    def find_archetype_by_name(self, name: str) -> Optional["FractalTensor"]:
        """Busca un arquetipo por su nombre asignado."""
        return self.name_index.get(name)

    def register_patch(self, ms_key, ttl=10_000):
        """Registra un parche temporal para un vector raíz con TTL."""
        if not hasattr(self, '_patches'):
            self._patches = {}
        self._patches[tuple(ms_key)] = {'ttl': ttl, 'timestamp': time.time()}

    def supersede_axiom(self, ms_key, new_axiom):
        """Reemplaza el axioma raíz y versiona el anterior."""
        if not hasattr(self, '_axiom_versions'):
            self._axiom_versions = {}
        old = self.ms_index.get(tuple(ms_key))
        if old:
            self._axiom_versions[tuple(ms_key)] = old
        self.ms_index[tuple(ms_key)] = new_axiom
        # También actualizar en archetypes si está
        for i, t in enumerate(self.archetypes):
            if t.nivel_3[0] == list(ms_key):
                self.archetypes[i] = new_axiom
                break

class FractalKnowledgeBase:
    def add_archetype(self, space_id: str, name: str, archetype_tensor: "FractalTensor", Ss: list, **kwargs) -> bool:
        """Delegado: añade un arquetipo fractal al universo correcto."""
        return self._get_space(space_id).add_archetype(archetype_tensor, Ss, name=name, **kwargs)
    
    def get_archetype(self, space_id: str, name: str) -> Optional["FractalTensor"]:
        """Obtiene un arquetipo por space_id y nombre."""
        return self._get_space(space_id).find_archetype_by_name(name)
    
    def store_model(self, space_id: str, model_name: str, model_data: dict):
        return self._get_space(space_id).store_model(model_name, model_data)

    def get_model(self, space_id: str, model_name: str):
        return self._get_space(space_id).get_model(model_name)
    """Gestor de múltiples universos de conocimiento fractal."""


    def __init__(self):
        self.universes = {}

    def _get_space(self, space_id: str = 'default'):
        if space_id not in self.universes:
            self.universes[space_id] = _SingleUniverseKB()
        return self.universes[space_id]

    


 # ===================== MÓDULO DE EVOLVER INVERSO =====================
class InverseEvolver:
    def __init__(self):
        self.trigate = Trigate()

    def infer_inputs_from_meta(self, Ms: list, MetaM: list) -> list:
        """
        Dado Ms (emergente) y MetaM, deduce M_AB, M_BC, M_CA compatibles.
        """
        M_intermediate = [TernaryLogic.ternary_xor(m, mm) for m, mm in zip(Ms, MetaM)]
        # Heurística simple: replicamos M_AB = M_BC = M_CA = M_intermediate
        return [M_intermediate, M_intermediate, M_intermediate]

    def reconstruct_vectors(self, Ms: list) -> tuple:
        """
        Deduce todas las combinaciones posibles de A y B que generan Ms usando lógica inversa del Trigate.
        Selecciona la combinación con menor cantidad de valores None.
        """
        import itertools, warnings
        if not isinstance(Ms, list) or len(Ms) != 3:
            Ms = [0, 0, 0]  # Normalizar entrada inválida
        possible_pairs = []
        states = [0, 1, None]
        # Explorar todas las combinaciones de A y B
        for a in itertools.product(states, repeat=3):
            a = list(a)
            # Deducir B desde A y Ms usando LUT
            b = [self.trigate._LUT_DEDUCE_B.get((a_i, 1, m), None) for a_i, m in zip(a, Ms)]
            if all(x is not None for x in b):  # Solo aceptar si B es válido
                none_count = a.count(None) + b.count(None)
                possible_pairs.append((a, b, none_count))
        if not possible_pairs:
            warnings.warn("No se encontraron combinaciones válidas para Ms. Devolviendo valores neutros.")
            return [0, 0, 0], [0, 0, 0]
        # Seleccionar la pareja con menor cantidad de None (criterio de simplicidad)
        best_pair = min(possible_pairs, key=lambda x: x[2])
        return list(best_pair[0]), list(best_pair[1])

# ===================== NUEVO EXTENDER: CONSEJO DE EXPERTOS =====================

class Extender:
    """
    Orquestador Aurora refactorizado con expertos como métodos internos para
    simplificar el alcance y la gestión de estado.

    Opera como de forma inversa a Evolver, extendiendo el conocimiento fractal
    a partir de consultas simples y contexto, utilizando expertos para validar, 
    utiliza trigate de form inversa al transcender.
    """
    def __init__(self, knowledge_base: "FractalKnowledgeBase"):
        self.kb = knowledge_base
        self.transcender = Transcender()  # El relator necesita un transcender
        self._lut_tables = {}
        self.armonizador = Armonizador(knowledge_base=self.kb)

    # --- Experto Arquetipo como método ---
    def _validate_archetype(self, ss_query: list, space_id: str) -> Tuple[bool, Optional['FractalTensor']]:
        universe = self.kb._get_space(space_id)
        ss_key = tuple(int(x) if x in (0, 1) else 0 for x in ss_query[:3])
        print(f"DEBUG: Looking up archetype with ss_key={ss_key} in space={space_id}")
        # Buscar por Ss
        archi_ss = universe.find_archetype_by_ss(list(ss_key))
        if archi_ss:
            print(f"DEBUG: Found archetype by Ss: {archi_ss}")
            return True, archi_ss
        # Buscar por Ms
        archi_ms = universe.find_archetype_by_ms(list(ss_key))
        if archi_ms:
            print(f"DEBUG: Found archetype by Ms: {archi_ms}")
            return True, archi_ms
        print("DEBUG: No archetype found")
        return False, None

    # --- Experto Dinámica como método ---
    def _project_dynamics(self, ss_query: list, space_id: str) -> Tuple[bool, Optional['FractalTensor']]:
        universe = self.kb._get_space(space_id)
        best, best_sim = None, -1.0
        for archetype in universe.archetypes:
            dMs = getattr(archetype, 'dMs', None)
            if dMs and getattr(archetype, 'Ss', None):
                sim = sum(1 for a, b in zip(archetype.Ss, ss_query) if a == b) / len(ss_query)
                if sim > best_sim:
                    best_sim, best = sim, archetype
        if best and best_sim > 0.7:
            return True, best
        return False, None

    # --- Experto Relator como método ---
    def _contextualize_relations(self, ss_query: list, space_id: str) -> Tuple[bool, Optional['FractalTensor']]:
        universe = self.kb._get_space(space_id)
        if not universe.archetypes:
            print("DEBUG: No archetypes in universe")
            return False, None
        best, best_score = None, float('-inf')
        for archetype in universe.archetypes:
            if not getattr(archetype, 'Ss', None):
                continue
            rel = self.transcender.relate_vectors(ss_query, archetype.Ss)
            score = sum(1 for bit in rel if bit == 0)
            if score > best_score:
                best_score, best = score, archetype
        if best:
            # Create a deep copy to avoid modifying the original
            result = copy.deepcopy(best)
            result.nivel_3[0] = list(ss_query[:3])  # Explicitly preserve root
            print(f"DEBUG: Contextualized with score={best_score}, root preserved={result.nivel_3[0]}")
            return True, result
        print("DEBUG: No relational match found")
        return False, None

    # --- Orquestador Principal ---
    def extend_fractal(self, input_ss, contexto: dict) -> dict:
        log = [f"Extensión Aurora: espacio '{contexto.get('space_id', 'default')}'"]
        # Validación y normalización de ss_query
        if isinstance(input_ss, FractalTensor):
            ss_query = getattr(input_ss, 'Ss', input_ss.nivel_3[0])
        else:
            ss_query = input_ss
        # Normalizar a un vector ternario de longitud 3
        if not isinstance(ss_query, (list, tuple, np.ndarray)):
            log.append("⚠️ Entrada inválida, usando vector neutro [0,0,0]")
            ss_query = [0, 0, 0]
        else:
            ss_query = [
                None if x is None else int(x) if x in (0, 1) else 0
                for x in list(ss_query)[:3]
            ] + [0] * (3 - len(ss_query))
        space_id = contexto.get('space_id', 'default')
        STEPS = [
            lambda q, s: (self.lookup_lut(s, q) is not None, self.lookup_lut(s, q)),
            self._validate_archetype,
            self._project_dynamics,
            self._contextualize_relations
        ]
        METHODS = [
            "reconstrucción por LUT",
            "reconstrucción por arquetipo (axioma)",
            "proyección por dinámica (raíz preservada)",
            "contextualización por relator (raíz preservada)"
        ]
        for step, method in zip(STEPS, METHODS):
            ok, tensor = step(ss_query, space_id)
            if ok and tensor is not None:
                log.append(f"✅ {method}.")
                # Si tensor es lista, seleccionar el más cercano
                if isinstance(tensor, list):
                    armonizador = self.armonizador
                    tensor = min(tensor, key=lambda t: armonizador.ambiguity_score(ss_query, t.nivel_3[0]))
                # For dynamic/relator, preserve root
                if method.startswith("proyección") or method.startswith("contextualización"):
                    result = copy.deepcopy(tensor)
                    result.nivel_3[0] = ss_query
                    root_vector = result.nivel_3[0]
                    harm = self.armonizador.harmonize(root_vector, archetype=root_vector, space_id=space_id)
                    result.nivel_3[0] = harm["output"]
                    return {
                        "reconstructed_tensor": result,
                        "reconstruction_method": method + " + armonizador",
                        "log": log
                    }
                tensor_c = copy.deepcopy(tensor)
                root_vector = tensor_c.nivel_3[0]
                harm = self.armonizador.harmonize(root_vector, archetype=root_vector, space_id=space_id)
                tensor_c.nivel_3[0] = harm["output"]
                return {
                    "reconstructed_tensor": tensor_c,
                    "reconstruction_method": method + " + armonizador",
                    "log": log
                }
        # Fallback
        log.append("🤷 No se encontraron coincidencias. Devolviendo tensor neutro.")
        tensor_n = FractalTensor.neutral()
        root_vector = tensor_n.nivel_3[0]
        harm = self.armonizador.harmonize(root_vector, archetype=root_vector, space_id=space_id)
        tensor_n.nivel_3[0] = harm["output"]
        return {
            "reconstructed_tensor": tensor_n,
            "reconstruction_method": "tensor neutro (sin coincidencias) + armonizador",
            "log": log
        }

    # --- LUT methods moved into Extender as proper methods ---
    def lookup_lut(self, space_id: str, ss_query: list):
        """
        Consulta la LUT para el espacio dado y la firma ss_query.
        """
        lut = getattr(self, '_lut_tables', {}).get(space_id, None)
        if lut is None:
            return None
        key = tuple(ss_query)
        return lut.get(key, None)

    def learn_lut_from_data(self, space_id: str, data: list):
        """
        Aprende una LUT auto-didacta a partir de datos [(ss_query, tensor_result)].
        Si hay conflicto, usa voto por mayoría.
        """
        lut = {}
        votes = {}
        for ss_query, tensor_result in data:
            # Ensure key is always a tuple of ints (flatten if needed)
            if isinstance(ss_query, list) and len(ss_query) > 0 and isinstance(ss_query[0], list):
                key = tuple(ss_query[0])
            else:
                key = tuple(ss_query)
            if key not in votes:
                votes[key] = []
            votes[key].append(tensor_result)
        # Votar por mayoría (por nivel_3[0])
        for key, tensors in votes.items():
            # Si solo hay uno, usarlo
            if len(tensors) == 1:
                lut[key] = tensors[0]
            else:
                # Votar por mayoría en nivel_3[0]
                root_votes = [t.nivel_3[0] if hasattr(t, 'nivel_3') else t for t in tensors]
                # Simple: moda por componente
                majority = []
                for i in range(3):
                    vals = [rv[i] for rv in root_votes if rv and len(rv) > i]
                    if vals:
                        count_1 = vals.count(1)
                        count_0 = vals.count(0)
                        if count_1 > count_0:
                            majority.append(1)
                        elif count_0 > count_1:
                            majority.append(0)
                        else:
                            majority.append(None)
                    else:
                        majority.append(None)
                # Crear tensor neutro y ponerle la raíz votada
                tensor_majority = FractalTensor.neutral()
                tensor_majority.nivel_3[0] = majority
                lut[key] = tensor_majority
        self.patch_lut(space_id, lut)
        return lut

    def patch_lut(self, space_id, lut):
        """Actualiza o crea la LUT para el espacio dado."""
        if not hasattr(self, '_lut_tables') or self._lut_tables is None:
            self._lut_tables = {}
        self._lut_tables[space_id] = lut

    def vote_candidates(self, candidates: list):
        """
        Vota entre varios tensores candidatos y devuelve el tensor con mayoría en la raíz.
        """
        if not candidates:
            return FractalTensor.neutral()
        root_votes = [c.nivel_3[0] if hasattr(c, 'nivel_3') else c for c in candidates]
        majority = []
        for i in range(3):
            vals = [rv[i] for rv in root_votes if rv and len(rv) > i]
            if vals:
                count_1 = vals.count(1)
                count_0 = vals.count(0)
                if count_1 > count_0:
                    majority.append(1)
                elif count_0 > count_1:
                    majority.append(0)
                else:
                    majority.append(None)
            else:
                majority.append(None)
        tensor_majority = FractalTensor.neutral()
        tensor_majority.nivel_3[0] = majority
        return tensor_majority

# Move these expert classes to top-level scope
class ExpertArquetipo:
    def __init__(self, kb):
        self.kb = kb
    def validar_axioma(self, ss_query, space_id):
        """
        Valida si existe un axioma. Es más robusto:
        1. Busca por Ss (memoria factual) en ss_index.
        2. Si falla, busca por Ms (raíz) en ms_index.
        """
        universe = self.kb._get_space(space_id)
        # --- FIX: Normalización de tipo reforzada con int() ---
        ss_query_fixed = tuple(int(0 if x is None else x) for x in ss_query[:3])
        # Búsqueda primaria por Ss/Ms en el índice (ahora ambos usan la misma clave)
        exact_match_list = universe.ss_index.get(ss_query_fixed)
        if exact_match_list:
            return True, exact_match_list[0]
        # Búsqueda de respaldo (aunque debería ser redundante si el índice es el mismo)
        exact_by_ms = universe.find_archetype_by_ms(list(ss_query_fixed))
        if exact_by_ms:
            return True, exact_by_ms
        return False, None

class ExpertDinamica:
    def __init__(self, kb):
        self.kb = kb
    def proyectar_dinamica(self, ss_query, space_id):
        # Busca tensor con dMs compatible o genera proyección neutra
        universe = self.kb._get_space(space_id)
        best, best_sim = None, 0.0
        for archetype in universe.archetypes:
            dMs = getattr(archetype, 'dMs', None)
            if dMs:
                sim = sum(1 for a, b in zip(getattr(archetype, 'Ss', []), ss_query) if a == b) / len(ss_query)
                if sim > best_sim:
                    best_sim, best = sim, archetype
        if best and best_sim > 0.7:
            return True, best
        return False, None

class ExpertRelator:
    def __init__(self, kb):
        self.kb = kb
        self.transcender = Transcender()
    def contextualizar(self, ss_query, space_id):
        # Busca relaciones semánticas entre ss_query y todos los arquetipos
        universe = self.kb._get_space(space_id)
        best, best_score = None, float('-inf')
        for archetype in universe.archetypes:
            rel = self.transcender.relate_vectors(ss_query, getattr(archetype, 'Ss', [0,0,0]))
            score = -sum(abs(x) if x is not None else 0 for x in rel)
            if score > best_score:
                best_score, best = score, archetype
        if best:
            return True, best
        return False, None


# ===================== MÓDULO DE ROTACIÓN DE TENSORES (ARC - Aurean Rotation Cycle)
# ===============================================================================
PHI = (1 + 5**0.5) / 2
PHI_INVERSE = 1 / PHI

class TensorRotor:
    """Genera secuencias de índices para la selección de tensores."""
    def __init__(self, N: int, mode: str = "hybrid", start_k: int = 0):
        self.N = max(1, N)
        self.k = start_k % self.N
        self.i = 0
        self.mode = mode
        self.phi_step = max(1, round(PHI_INVERSE * self.N))
        self.fib_cache = {n: self._fib(n) for n in range(16)}

    def _fib(self, n: int) -> int:
        if n <= 1: return 1
        a, b = 1, 1
        for _ in range(2, n + 1): a, b = b, a + b
        return b

    def next(self) -> int:
        """Calcula el siguiente índice según la estrategia de rotación."""
        if self.mode == "phi":
            self.k = (self.k + self.phi_step) % self.N
        elif self.mode == "fibonacci":
            fib_step = self.fib_cache[self.i % 16]
            self.k = (self.k + fib_step) % self.N
        else: # hybrid
            if self.i % 2 == 0:
                self.k = (self.k + self.phi_step) % self.N
            else:
                fib_step = self.fib_cache[(self.i // 2) % 16]
                self.k = (self.k + fib_step) % self.N
        self.i += 1
        return self.k

class TensorPoolManager:
    """Gestor de pools de tensores con rotación estratificada."""
    def __init__(self):
        self.pools: Dict[str, List['FractalTensor']] = {
            'deep27': [], 'mid9': [], 'shallow3': [], 'mixed': []
        }
        self.rotors: Dict[str, TensorRotor] = {
            'deep27': TensorRotor(0, mode="fibonacci"),
            'mid9': TensorRotor(0, mode="hybrid"),
            'shallow3': TensorRotor(0, mode="phi"),
            'mixed': TensorRotor(0, mode="hybrid")
        }

    def add_tensor(self, tensor: 'FractalTensor'):
        """Añade un tensor al pool apropiado según su profundidad."""
        # Un tensor se considera "profundo" si tiene datos en el nivel 27
        if any(any(bit is not None for bit in vec) for vec in tensor.nivel_27):
            pool_name = 'deep27'
        elif any(any(bit is not None for bit in vec) for vec in tensor.nivel_9):
            pool_name = 'mid9'
        else:
            pool_name = 'shallow3'

        self.pools[pool_name].append(tensor)
        self.pools['mixed'].append(tensor)
        self.rotors[pool_name].N = len(self.pools[pool_name])
        self.rotors['mixed'].N = len(self.pools['mixed'])

    def get_tensor_trio(self, task_type: str = "arquetipo") -> List['FractalTensor']:
        """Obtiene un trío de tensores optimizado para una tarea específica."""
        task_to_pool = {
            'arquetipo': 'mixed', 'dinamica': 'shallow3',
            'relator': 'mid9', 'axioma': 'deep27'
        }
        pool_name = task_to_pool.get(task_type, 'mixed')
        
        # Fallback inteligente si el pool preferido no tiene suficientes tensores
        if len(self.pools[pool_name]) < 3:
            fallback_order = ['mixed', 'shallow3', 'mid9', 'deep27']
            for fb_pool_name in fallback_order:
                if len(self.pools[fb_pool_name]) >= 3:
                    pool_name = fb_pool_name
                    break
        
        pool = self.pools[pool_name]
        rotor = self.rotors[pool_name]

        if len(pool) < 3:
            trio = list(pool)
            while len(trio) < 3: trio.append(FractalTensor.neutral())
            return trio
        
        indices = [rotor.next() for _ in range(3)]
        return [pool[i] for i in indices]


KnowledgeBase = FractalKnowledgeBase


# ===============================================================================
# DEMOSTRACIÓN FRACTAL COMPLETA
# ===============================================================================

if __name__ == "__main__":
    print("🌌 DEMOSTRACIÓN FRACTAL AURORA: Arquetipos, Dinámicas y Relatores 🌌")
    print("=" * 80)
    print("Análisis de conocimiento desde tres perspectivas con datos coherentes.")
    print("=" * 80)

    # === INICIALIZACIÓN DEL ECOSISTEMA AURORA ===
    kb = FractalKnowledgeBase()
    evolver = Evolver()
    extender = Extender(kb)
    pool_manager = TensorPoolManager()

    # === FASE 1: ANÁLISIS DE ARQUETIPOS ===
    print("\n🏛️ FASE 1: ANÁLISIS DE ARQUETIPOS")
    print("-" * 50)
    familia_movimiento = [
        FractalTensor(nivel_3=[[1,0,1]], nivel_9=[[1,0,0]]*9, nivel_27=[[0,0,1]]*27),
        FractalTensor(nivel_3=[[1,0,1]], nivel_9=[[1,1,0]]*9, nivel_27=[[0,1,0]]*27),
        FractalTensor(nivel_3=[[1,0,1]], nivel_9=[[0,1,1]]*9, nivel_27=[[1,1,1]]*27)
    ]
    for t in familia_movimiento: pool_manager.add_tensor(t)
    
    trio_para_arquetipo = pool_manager.get_tensor_trio('arquetipo')
    arquetipo_movimiento = evolver.compute_fractal_archetype(trio_para_arquetipo)
    print(f"• Analizando {len(trio_para_arquetipo)} conceptos de 'movimiento'...")
    print(f"• ARQUETIPO resultante: {arquetipo_movimiento}")
    # Extraer Ss del tensor raíz del arquetipo (ejemplo: primer vector de nivel_3)
    Ss_movimiento = arquetipo_movimiento.nivel_3[0] if hasattr(arquetipo_movimiento, 'nivel_3') else [0,0,0]
    kb.add_archetype('fisica_conceptual', 'movimiento_universal', arquetipo_movimiento, Ss=Ss_movimiento)
    print("  └─ Arquetipo almacenado en el espacio 'fisica_conceptual'.")
    # Initialize LUT for archetype
    extender.learn_lut_from_data('fisica_conceptual', [([1, 0, 1], arquetipo_movimiento)])
    # Print KB indices for debug
    print("DEBUG: ss_index:", kb._get_space('fisica_conceptual').ss_index)
    print("DEBUG: ms_index:", kb._get_space('fisica_conceptual').ms_index)

    # === FASE 2: ANÁLISIS DE DINÁMICAS ===
    print("\n⚡ FASE 2: ANÁLISIS DE DINÁMICAS")
    print("-" * 50)
    
    estado_t0 = FractalTensor.random()
    estado_t1 = evolver.base_transcender.compute_full_fractal(estado_t0, estado_t0, FractalTensor.neutral())
    estado_t2 = evolver.base_transcender.compute_full_fractal(estado_t1, estado_t1, FractalTensor.neutral())
    secuencia_temporal_logica = [estado_t0, estado_t1, estado_t2]
    
    print(f"• Analizando secuencia temporal de {len(secuencia_temporal_logica)} estados.")
    firma_dinamica = evolver.analyze_fractal_dynamics(secuencia_temporal_logica)
    print(f"• DINÁMICA resultante: {firma_dinamica}")
    Ss_dinamica = firma_dinamica.nivel_3[0] if hasattr(firma_dinamica, 'nivel_3') else [0,0,0]
    kb.add_archetype('dinamicas_sistemas', 'evolucion_sistema_X', firma_dinamica, Ss=Ss_dinamica)
    print("  └─ Dinámica almacenada en 'dinamicas_sistemas'.")

    # === FASE 3: ANÁLISIS DE RELATORES ===
    print("\n🔗 FASE 3: ANÁLISIS DE RELATORES")
    print("-" * 50)
    
    concepto_base = FractalTensor.random()
    concepto_fuerza = evolver.base_transcender.compute_full_fractal(concepto_base, FractalTensor.random(), FractalTensor.neutral())
    concepto_energia = evolver.base_transcender.compute_full_fractal(concepto_base, concepto_fuerza, FractalTensor.neutral())
    cluster_contextual = [concepto_base, concepto_fuerza, concepto_energia]
    
    print(f"• Analizando clúster de {len(cluster_contextual)} conceptos relacionados.")
    firma_relacional = evolver.analyze_fractal_relations(cluster_contextual)
    print(f"• RELATOR resultante: {firma_relacional}")
    Ss_relator = firma_relacional.nivel_3[0] if hasattr(firma_relacional, 'nivel_3') else [0,0,0]
    kb.add_archetype('mapas_conceptuales', 'mecanica_basica', firma_relacional, Ss=Ss_relator)
    print("  └─ Relator almacenado en 'mapas_conceptuales'.")


    # === FASE 4: EXTENSIÓN BASADA EN CONOCIMIENTO ===
    print("\n🧩 FASE 4: EXTENSIÓN POR ARQUETIPO")
    print("-" * 50)

    # Usar directamente el vector raíz del arquetipo como consulta
    query_vector = arquetipo_movimiento.nivel_3[0][:3]
    print(f"• Vector a extender (solo con raíz): {query_vector}")

    # Extensión robusta: la función copiará todos los niveles del arquetipo encontrado
    resultado_extension = extender.extend_fractal(
        query_vector,
        contexto={'space_id': 'fisica_conceptual'}
    )

    tensor_reconstruido = resultado_extension['reconstructed_tensor']
    print(f"• Método de reconstrucción: {resultado_extension['reconstruction_method']}")
    print(f"• Tensor reconstruido: {tensor_reconstruido}")
    print("  └─ Los niveles 3, 9 y 27 se han rellenado desde la KB.")

    print("\n" + "=" * 80)
    print("🎯 DEMOSTRACIÓN FINALIZADA.")
    print("=" * 80)

################################################################################################
# ===================== INTEGRACIÓN DE REVERSIBILIDAD Y AUTOSIMILARIDAD ========================
################################################################################################

# --- UTILIDADES DE IMPUTACIÓN Y VALIDACIÓN ---
from statistics import mode
def impute_none(vec, context, tensor=None):
    """Imputa valores None usando contexto y niveles superiores del tensor."""
    result = []
    for i, v in enumerate(vec):
        if v is not None:
            result.append(v)
            continue
        col = [c[i] for c in context if i < len(c) and c[i] is not None]
        if tensor:
            if hasattr(tensor, 'nivel_9') and i < len(tensor.nivel_9):
                col.extend([x for x in tensor.nivel_9[i] if x is not None])
            if hasattr(tensor, 'nivel_3') and i < len(tensor.nivel_3[0]):
                col.append(tensor.nivel_3[0][i % 3])
        result.append(mode(col) if col else 0)
    return result

def validate_ternary_input(vec, expected_len=3, name="input"):
    """Valida y normaliza entradas ternarias."""
    if not isinstance(vec, (list, tuple)) or len(vec) != expected_len:
        print(f"Warning: Invalid {name}: {vec}, using default {[0]*expected_len}")
        return [0] * expected_len
    return [None if x is None else int(x) % 2 for x in vec]

# --- ESTRATEGIAS DE SELECCIÓN AUTOSIMILARES ---
def golden_ratio_skip_indices(N, k, trios=3):
    """Devuelve una lista de índices para formar un trío usando saltos áureos."""
    phi = (1 + math.sqrt(5)) / 2
    skip = max(1, int(N / phi))
    indices = []
    idx = k
    for _ in range(trios):
        indices.append(idx % N)
        idx = (idx + skip) % N
    return indices

def fibonacci(n):
    a, b = 1, 1
    for _ in range(n):
        a, b = b, a + b
    return a

def fibonacci_stepping_indices(N, k, trios=3, start_step=0):
    """Devuelve una lista de índices para formar un trío usando pasos de Fibonacci."""
    indices = []
    idx = k
    for i in range(start_step, start_step + trios):
        step = fibonacci(i)
        indices.append(idx % N)
        idx = (idx + step) % N
    return indices

# --- AJUSTE AUTOSIMILAR (OPCIONAL, SI SE DESEA USAR EN ARMONIZADOR) ---
class AdjustmentStep:
    def apply(self, vec, archetype, kb=None):
        raise NotImplementedError

class MicroShift(AdjustmentStep):
    def apply(self, vec, archetype, kb=None):
        return [a if v is None else v for v, a in zip(vec, archetype)]

class Regrewire(AdjustmentStep):
    def apply(self, vec, archetype, kb=None):
        if sum(1 for v, a in zip(vec, archetype) if v == a) >= 2:
            return list(archetype)
        return vec

class Metatune(AdjustmentStep):
    def apply(self, vec, archetype, kb=None):
        if kb is not None:
            matches = kb.find_archetype_by_ms(archetype)
            if matches:
                return matches[0]
        return vec

# --- TRIAGE FUNCIONAL UNIFICADO (INFERENCIA, APRENDIZAJE, DEDUCCIÓN) ---
def f_not(x):
    return 1 - x if x in (0, 1) else 0
def f_not_inv(x):
    return 1 - x if x in (0, 1) else 0
f_not.inverse = f_not_inv

def f_inc(x):
    return (x + 1) % 2 if x in (0, 1) else 0
def f_inc_inv(x):
    return (x - 1) % 2 if x in (0, 1) else 0
f_inc.inverse = f_inc_inv

def f_id(x):
    return x
f_id.inverse = f_id

def aurora_apply_sequence(val, sequence):
    for func in sequence:
        val = func(val)
    return val

def aurora_triage_inferencia(A, B, M):
    allowed_functions = [f_not, f_inc, f_id]
    def normalize_ternary_vector(vec, default=[0,0,0]):
        if not isinstance(vec, (list, tuple)):
            return default.copy()
        return [None if x is None else int(x) if x in (0,1) else 0 for x in list(vec)[:3]] + [0]*(3-len(vec))
    def validate_function_sequence(M, allowed_functions, max_len=2):
        if not isinstance(M, (list, tuple)) or len(M) != 3:
            return [[f_id] for _ in range(3)]
        return [list(seq)[:max_len] if isinstance(seq, (list, tuple)) and all(f in allowed_functions for f in seq) else [f_id] for seq in M[:3]] + [[f_id]]*(3-len(M))
    A = normalize_ternary_vector(A)
    B = normalize_ternary_vector(B)
    M = validate_function_sequence(M, allowed_functions)
    R = []
    for i in range(3):
        rA = aurora_apply_sequence(A[i], M[i])
        rB = aurora_apply_sequence(B[i], M[i])
        if rA is not None and rB is not None:
            R.append(rA + rB)
        else:
            R.append(0)
    return R

def aurora_triage_aprendizaje(A, B, R, funciones_permitidas, max_len=2):
    import itertools
    def normalize_ternary_vector(vec, default=[0,0,0]):
        if not isinstance(vec, (list, tuple)):
            return default.copy()
        return [None if x is None else int(x) if x in (0,1) else 0 for x in list(vec)[:3]] + [0]*(3-len(vec))
    A = normalize_ternary_vector(A)
    B = normalize_ternary_vector(B)
    R = normalize_ternary_vector(R)
    M = []
    for i in range(3):
        found = False
        for l in range(1, max_len+1):
            for seq in itertools.product(funciones_permitidas, repeat=l):
                rA = aurora_apply_sequence(A[i], seq)
                rB = aurora_apply_sequence(B[i], seq)
                if rA is not None and rB is not None and rA + rB == R[i]:
                    M.append(list(seq))
                    found = True
                    break
            if found:
                break
        if not found:
            M.append([f_id])
    return M

def aurora_triage_deduccion(M, R, known, known_is_A=True):
    allowed_functions = [f_not, f_inc, f_id]
    def normalize_ternary_vector(vec, default=[0,0,0]):
        if not isinstance(vec, (list, tuple)):
            return default.copy()
        return [None if x is None else int(x) if x in (0,1) else 0 for x in list(vec)[:3]] + [0]*(3-len(vec))
    def validate_function_sequence(M, allowed_functions, max_len=2):
        if not isinstance(M, (list, tuple)) or len(M) != 3:
            return [[f_id] for _ in range(3)]
        return [list(seq)[:max_len] if isinstance(seq, (list, tuple)) and all(f in allowed_functions for f in seq) else [f_id] for seq in M[:3]] + [[f_id]]*(3-len(M))
    R = normalize_ternary_vector(R)
    known = normalize_ternary_vector(known)
    M = validate_function_sequence(M, allowed_functions)
    deduced = []
    for i in range(3):
        val = R[i] - aurora_apply_sequence(known[i], M[i]) if R[i] is not None and known[i] is not None else 0
        for func in reversed(M[i]):
            if hasattr(func, 'inverse'):
                val = func.inverse(val)
        deduced.append(val if val in (0,1,None) else 0)
    return deduced

# --- INVERSE EVOLVER: REVERSIBILIDAD FRACTAL ---
class InverseEvolver:
    """Reconstruye tensores originales desde sintetizados usando lógica inversa."""
    def __init__(self, knowledge_base=None):
        self.kb = knowledge_base
        self.trigate = Trigate()
        self.armonizador = Armonizador(knowledge_base=knowledge_base) if knowledge_base else None

    def reconstruct_vectors(self, Ms):
        """Deduce A y B desde Ms usando lógica inversa del Trigate."""
        A, B = [], []
        for m in Ms:
            if m == 0:
                A.append(0)
                B.append(0)
            elif m == 1:
                A.append(1)
                B.append(0)
            else:
                A.append(None)
                B.append(None)
        return A, B

    def reconstruct_fractal(self, synthesized):
        """Reconstruye tres tensores fractales desde uno sintetizado (niveles 3, 9, 27)."""
        ms_key = synthesized.nivel_3[0]
        A_l3, B_l3 = self.reconstruct_vectors(ms_key)
        C_l3 = [TernaryLogic.ternary_xor(a, b) for a, b in zip(A_l3, B_l3)]

        def reconstruct_level(level_vectors):
            A_vectors, B_vectors, C_vectors = [], [], []
            for vec in level_vectors:
                a, b = self.reconstruct_vectors(vec)
                c = [TernaryLogic.ternary_xor(x, y) for x, y in zip(a, b)]
                A_vectors.append(a)
                B_vectors.append(b)
                C_vectors.append(c)
            return A_vectors, B_vectors, C_vectors

        A_l9, B_l9, C_l9 = reconstruct_level(synthesized.nivel_9)
        A_l27, B_l27, C_l27 = reconstruct_level(synthesized.nivel_27)

        def create_tensor(n3, n9, n27, ss):
            tensor = FractalTensor(nivel_3=n3, nivel_9=n9, nivel_27=n27)
            if self.armonizador:
                harm = self.armonizador.harmonize(
                    tensor.nivel_3[0],
                    archetype=tensor.nivel_3[0],
                    space_id="inverse"
                )
                tensor.nivel_3[0] = harm["output"]
            tensor.Ss = ss
            return tensor

        return [
            create_tensor([A_l3], A_l9, A_l27, ss="A"),
            create_tensor([B_l3], B_l9, B_l27, ss="B"),
            create_tensor([C_l3], C_l9, C_l27, ss="C")
        ]


# ===================== TRIGATE IMPLEMENTATION =====================

# Ternary values
NULL = None
TERNARY_VALUES = [0, 1, NULL]


class Trigate:
    """
    Fundamental Aurora logic module implementing ternary operations.
    
    Supports three operational modes:
    1. Inference: A + B + M -> R (given inputs and control, compute result)
    2. Learning: A + B + R -> M (given inputs and result, learn control)
    3. Deduction: M + R + A -> B (given control, result, and one input, deduce other)
    
    All operations are O(1) using precomputed lookup tables (LUTs).
    """
    
    # Class-level LUTs (computed once at module load)
    _LUT_INFER: Dict[Tuple, int] = {}
    _LUT_LEARN: Dict[Tuple, int] = {}
    _LUT_DEDUCE_A: Dict[Tuple, int] = {}
    _LUT_DEDUCE_B: Dict[Tuple, int] = {}
    _initialized = False
    
    def __init__(self):
        """Initialize Trigate and ensure LUTs are computed."""
        if not Trigate._initialized:
            Trigate._initialize_luts()
    
    @classmethod
    def _initialize_luts(cls):
        """
        Initialize all lookup tables for O(1) operations.
        
        Based on extended XOR logic with NULL propagation:
        - 0 XOR 0 = 0, 0 XOR 1 = 1, 1 XOR 0 = 1, 1 XOR 1 = 0
        - Any operation with NULL propagates NULL
        - Control bit M determines XOR (1) or XNOR (0)
        """
        print("Initializing Trigate LUTs...")
        
        # Generate all possible combinations for ternary logic
        for a, b, m, r in itertools.product(TERNARY_VALUES, repeat=4):
            
            # INFERENCE LUT: (a, b, m) -> r
            computed_r = cls._compute_inference(a, b, m)
            cls._LUT_INFER[(a, b, m)] = computed_r
            
            # LEARNING LUT: (a, b, r) -> m
            # Find control M that produces R given A, B
            learned_m = cls._compute_learning(a, b, r)
            cls._LUT_LEARN[(a, b, r)] = learned_m
            
            # DEDUCTION LUTS: (m, r, a) -> b and (m, r, b) -> a
            deduced_b = cls._compute_deduction_b(m, r, a)
            deduced_a = cls._compute_deduction_a(m, r, b)
            
            cls._LUT_DEDUCE_B[(m, r, a)] = deduced_b
            cls._LUT_DEDUCE_A[(m, r, b)] = deduced_a
        
        cls._initialized = True
        print(f"Trigate LUTs initialized: {len(cls._LUT_INFER)} entries each")
    
    @staticmethod
    def _compute_inference(a: Union[int, None], b: Union[int, None], m: Union[int, None]) -> Union[int, None]:
        """
        Compute R given A, B, M using ternary logic.
        
        Logic:
        - If any input is NULL, result is NULL
        - If M is 1: R = A XOR B
        - If M is 0: R = A XNOR B (NOT(A XOR B))
        """
        if a is NULL or b is NULL or m is NULL:
            return NULL
        
        if m == 1:  # XOR mode
            return a ^ b
        else:  # XNOR mode (m == 0)
            return 1 - (a ^ b)
    
    @staticmethod
    def _compute_learning(a: Union[int, None], b: Union[int, None], r: Union[int, None]) -> Union[int, None]:
        """
        Learn control M given A, B, R.
        
        Logic:
        - If any input is NULL, cannot learn -> NULL
        - If A XOR B == R, then M = 1 (XOR)
        - If A XOR B != R, then M = 0 (XNOR)
        """
        if a is NULL or b is NULL or r is NULL:
            return NULL
        
        xor_result = a ^ b
        if xor_result == r:
            return 1  # XOR mode produces correct result
        else:
            return 0  # XNOR mode produces correct result
    
    @staticmethod
    def _compute_deduction_a(m: Union[int, None], r: Union[int, None], b: Union[int, None]) -> Union[int, None]:
        """
        Deduce A given M, R, B.
        
        Logic:
        - If any input is NULL, cannot deduce -> NULL
        - If M is 1: A = R XOR B (since R = A XOR B)
        - If M is 0: A = NOT(R) XOR B (since R = NOT(A XOR B))
        """
        if m is NULL or r is NULL or b is NULL:
            return NULL
        
        if m == 1:  # XOR mode: A XOR B = R -> A = R XOR B
            return r ^ b
        else:  # XNOR mode: NOT(A XOR B) = R -> A XOR B = NOT(R) -> A = NOT(R) XOR B
            return (1 - r) ^ b
    
    @staticmethod
    def _compute_deduction_b(m: Union[int, None], r: Union[int, None], a: Union[int, None]) -> Union[int, None]:
        """
        Deduce B given M, R, A.
        
        Logic: Same as deduce_a but solving for B instead of A.
        """
        if m is NULL or r is NULL or a is NULL:
            return NULL
        
        if m == 1:  # XOR mode: A XOR B = R -> B = R XOR A
            return r ^ a
        else:  # XNOR mode: NOT(A XOR B) = R -> A XOR B = NOT(R) -> B = NOT(R) XOR A
            return (1 - r) ^ a
    
    def infer(self, A: List[Union[int, None]], B: List[Union[int, None]], M: List[Union[int, None]]) -> List[Union[int, None]]:
        """
        Inference mode: Compute R given A, B, M.
        
        Args:
            A: First input vector (3 bits)
            B: Second input vector (3 bits)
            M: Control vector (3 bits)
            
        Returns:
            R: Result vector (3 bits)
        """
        if not (len(A) == len(B) == len(M) == 3):
            raise ValueError("All vectors must have exactly 3 elements")
        
        return [self._LUT_INFER[(a, b, m)] for a, b, m in zip(A, B, M)]
    
    def learn(self, A: List[Union[int, None]], B: List[Union[int, None]], R: List[Union[int, None]]) -> List[Union[int, None]]:
        """
        Learning mode: Learn control M given A, B, R.
        
        Args:
            A: First input vector (3 bits)
            B: Second input vector (3 bits)
            R: Target result vector (3 bits)
            
        Returns:
            M: Learned control vector (3 bits)
        """
        if not (len(A) == len(B) == len(R) == 3):
            raise ValueError("All vectors must have exactly 3 elements")
        
        return [self._LUT_LEARN[(a, b, r)] for a, b, r in zip(A, B, R)]
    
    def deduce_a(self, M: List[Union[int, None]], R: List[Union[int, None]], B: List[Union[int, None]]) -> List[Union[int, None]]:
        """
        Deduction mode: Deduce A given M, R, B.
        
        Args:
            M: Control vector (3 bits)
            R: Result vector (3 bits)
            B: Known input vector (3 bits)
            
        Returns:
            A: Deduced input vector (3 bits)
        """
        if not (len(M) == len(R) == len(B) == 3):
            raise ValueError("All vectors must have exactly 3 elements")
        
        return [self._LUT_DEDUCE_A[(m, r, b)] for m, r, b in zip(M, R, B)]
    
    def deduce_b(self, M: List[Union[int, None]], R: List[Union[int, None]], A: List[Union[int, None]]) -> List[Union[int, None]]:
        """
        Deduction mode: Deduce B given M, R, A.
        
        Args:
            M: Control vector (3 bits)
            R: Result vector (3 bits)
            A: Known input vector (3 bits)
            
        Returns:
            B: Deduced input vector (3 bits)
        """
        if not (len(M) == len(R) == len(A) == 3):
            raise ValueError("All vectors must have exactly 3 elements")
        
        return [self._LUT_DEDUCE_B[(m, r, a)] for m, r, a in zip(M, R, A)]
    
    def validate_triangle_closure(self, A: List[Union[int, None]], B: List[Union[int, None]], 
                                  M: List[Union[int, None]], R: List[Union[int, None]]) -> bool:
        """
        Validate that A, B, M, R form a valid logical triangle.
        
        This ensures geometric coherence: the triangle "closes" properly.
        
        Args:
            A, B, M, R: The four vectors forming the logical triangle
            
        Returns:
            True if triangle is valid, False otherwise
        """
        # Compute expected R from A, B, M
        expected_R = self.infer(A, B, M)
        
        # Check if computed R matches provided R
        for expected, actual in zip(expected_R, R):
            if expected != actual:
                return False
        
        return True
    
    def get_truth_table(self, operation: str = "infer") -> str:
        """
        Generate human-readable truth table for debugging.
        
        Args:
            operation: "infer", "learn", "deduce_a", or "deduce_b"
            
        Returns:
            Formatted truth table string
        """
        if operation == "infer":
            lut = self._LUT_INFER
            header = "A | B | M | R"
        elif operation == "learn":
            lut = self._LUT_LEARN
            header = "A | B | R | M"
        elif operation == "deduce_a":
            lut = self._LUT_DEDUCE_A
            header = "M | R | B | A"
        elif operation == "deduce_b":
            lut = self._LUT_DEDUCE_B
            header = "M | R | A | B"
        else:
            raise ValueError(f"Unknown operation: {operation}")
        
        def format_val(v):
            return "N" if v is NULL else str(v)
        
        lines = [header, "-" * len(header)]
        
        for key, value in sorted(lut.items()):
            key_str = " | ".join(format_val(k) for k in key)
            val_str = format_val(value)
            lines.append(f"{key_str} | {val_str}")
        
        return "\n".join(lines)
    
    def synthesize(self, A: List[int], B: List[int]) -> Tuple[List[Optional[int]], List[Optional[int]]]:
        """Síntesis Aurora: genera M (lógica) y S (forma) desde A y B."""
        M = [TernaryLogic.ternary_xor(a, b) for a, b in zip(A, B)]
        S = [TernaryLogic.ternary_xnor(a, b) for a, b in zip(A, B)]
        return M, S

    def recursive_synthesis(
        self,
        vectors: List[List[int]]
    ) -> Tuple[List[Optional[int]], List[List[Optional[int]]]]:
        """
        Reduce secuencialmente una lista ≥2 de vectores ternarios.

        Devuelve:
          • resultado_final – vector M después de la última combinación
          • history – lista de cada resultado intermedio (M-k) para depuración
        """
        if len(vectors) < 2:
            raise ValueError("Se necesitan al menos 2 vectores")

        history: List[List[Optional[int]]] = []
        current = vectors[0]

        for nxt in vectors[1:]:
            current, _ = self.synthesize(current, nxt)
            history.append(current)

        return current, history
    
    def __repr__(self) -> str:
        return f"Trigate(initialized={self._initialized}, lut_size={len(self._LUT_INFER)})"