## 馃 LYRA NEXUS: Sistema Inteligente de Optimizaci贸n de Almacenamiento Descentralizado
Este sistema convierte cada nodo de la red LYRA NEXUS en una **neurona inteligente** que colabora con las dem谩s para mantener el almacenamiento colectivo limpio, organizado y eficiente. La filosof铆a es simple: **cada nodo aporta su inteligencia local y juntos forman un cerebro distribuido**.
---
### 馃摎 Arquitectura del Sistema
El sistema se compone de cuatro m贸dulos principales:
| M贸dulo | Funci贸n |
|--------|---------|
| **Deduplicador** | Detecta y elimina archivos duplicados a nivel de contenido (hash SHA-256). |
| **Limpiador L贸gico** | Identifica y borra datos superfluos (temporales, cach茅s, logs antiguos, etc.) seg煤n reglas configurables. |
| **Compresor Inteligente** | Comprime los datos sin encriptar para ahorrar espacio (usando zlib o lzma). |
| **Blockchain Registradora** | Registra cada acci贸n (eliminaci贸n, compresi贸n, limpieza) en una cadena de bloques inmutable para auditor铆a y administraci贸n. |
| **Coordinador P2P** | Permite que los nodos compartan sus "huellas" (hashes) para saber qu茅 datos est谩n duplicados en la red y decidir colectivamente qu茅 copias eliminar. |
---
### ⚙️ Instalaci贸n y Dependencias
El sistema est谩 escrito en Python 3.9+ y usa 煤nicamente la biblioteca est谩ndar, por lo que **no requiere instalaci贸n de paquetes externos**. Esto facilita su uso en entornos educativos.
```bash
# Clonar el repositorio (simulado)
mkdir lyra_nexus
cd lyra_nexus
# Crear los archivos que se detallan a continuaci贸n
```
---
### 馃З C贸digo del Sistema
Estructura de archivos:
```
lyra_nexus/
├── config.py # Configuraci贸n central
├── blockchain.py # Cadena de bloques simple
├── deduplicator.py # Deduplicaci贸n y limpieza l贸gica
├── compressor.py # Compresi贸n de datos
├── p2p_coordinator.py # Comunicaci贸n entre nodos
├── main.py # Orquestador principal
└── README.md # Explicaci贸n para el usuario
```
#### 馃搫 `config.py` - Configuraci贸n Global
```python
# config.py
# Configuraci贸n central del sistema LYRA NEXUS
# Rutas de almacenamiento
STORAGE_PATHS = [
"/mnt/nas/datos", # Ruta principal del NAS
"/mnt/nas/backup",
]
# Extensiones de archivos temporales o superfluos
SUPERFLUOUS_EXTENSIONS = [".tmp", ".log", ".cache", ".swp", ".bak"]
# Tama帽o m铆nimo para considerar compresi贸n (en bytes)
COMPRESS_MIN_SIZE = 1024 * 10 # 10 KB
# Nivel de compresi贸n (1-9, siendo 9 m谩ximo)
COMPRESS_LEVEL = 6
# Puerto para comunicaci贸n P2P
P2P_PORT = 8765
# Lista de nodos conocidos (IP o hostname)
KNOWN_NODES = [
"192.168.1.101",
"192.168.1.102",
]
```
---
#### 馃搫 `blockchain.py` - Blockchain Registradora y Administrativa
```python
# blockchain.py
# Cadena de bloques simple para registrar acciones de limpieza y compresi贸n
import hashlib
import json
import time
from typing import List, Dict
class Block:
def __init__(self, index, previous_hash, timestamp, data, nonce=0):
self.index = index
self.previous_hash = previous_hash
self.timestamp = timestamp
self.data = data # Diccionario con la acci贸n realizada
self.nonce = nonce
self.hash = self.calculate_hash()
def calculate_hash(self):
block_string = json.dumps({
"index": self.index,
"previous_hash": self.previous_hash,
"timestamp": self.timestamp,
"data": self.data,
"nonce": self.nonce
}, sort_keys=True)
return hashlib.sha256(block_string.encode()).hexdigest()
def mine_block(self, difficulty=2):
# Prueba de trabajo simple para demostraci贸n
target = "0" * difficulty
while self.hash[:difficulty] != target:
self.nonce += 1
self.hash = self.calculate_hash()
print(f"Bloque minado: {self.hash}")
class Blockchain:
def __init__(self):
self.chain = [self.create_genesis_block()]
self.difficulty = 2
def create_genesis_block(self):
return Block(0, "0", time.time(), {"action": "genesis"})
def get_latest_block(self):
return self.chain[-1]
def add_block(self, new_block):
new_block.previous_hash = self.get_latest_block().hash
new_block.mine_block(self.difficulty)
self.chain.append(new_block)
def is_chain_valid(self):
for i in range(1, len(self.chain)):
current = self.chain[i]
previous = self.chain[i-1]
if current.hash != current.calculate_hash():
return False
if current.previous_hash != previous.hash:
return False
return True
def register_action(self, action_type, details):
"""Registra una acci贸n en la blockchain"""
data = {
"action": action_type,
"details": details,
"timestamp": time.time()
}
new_block = Block(
index=len(self.chain),
previous_hash=self.get_latest_block().hash,
timestamp=time.time(),
data=data
)
self.add_block(new_block)
return new_block.hash
# Instancia global (compartida entre m贸dulos)
ledger = Blockchain()
```
---
#### 馃搫 `deduplicator.py` - Deduplicaci贸n y Limpieza L贸gica
```python
# deduplicator.py
# Deduplicaci贸n de archivos y limpieza de datos superfluos
import os
import hashlib
import json
from config import STORAGE_PATHS, SUPERFLUOUS_EXTENSIONS
class Deduplicator:
def __init__(self):
self.file_hashes = {} # hash -> lista de rutas
self.actions_log = [] # Para registrar acciones
def calculate_hash(self, file_path, block_size=8192):
"""Calcula SHA-256 de un archivo"""
sha256 = hashlib.sha256()
try:
with open(file_path, 'rb') as f:
for block in iter(lambda: f.read(block_size), b''):
sha256.update(block)
return sha256.hexdigest()
except (IOError, OSError) as e:
print(f"Error al leer {file_path}: {e}")
return None
def scan_directory(self, path):
"""Escanea un directorio y calcula hashes de todos los archivos"""
if not os.path.exists(path):
return
for root, dirs, files in os.walk(path):
for file in files:
full_path = os.path.join(root, file)
file_hash = self.calculate_hash(full_path)
if file_hash:
if file_hash not in self.file_hashes:
self.file_hashes[file_hash] = []
self.file_hashes[file_hash].append(full_path)
def find_duplicates(self):
"""Devuelve un diccionario con los duplicados (hash -> lista de rutas)"""
return {h: paths for h, paths in self.file_hashes.items() if len(paths) > 1}
def remove_duplicates(self, keep_first=True):
"""Elimina archivos duplicados dejando solo una copia"""
duplicates = self.find_duplicates()
removed_count = 0
freed_space = 0
for hash_val, paths in duplicates.items():
# Ordenar para mantener el primero (o el m谩s antiguo) y eliminar el resto
paths.sort(key=lambda p: os.path.getmtime(p) if os.path.exists(p) else 0)
keep_path = paths[0] if keep_first else paths[-1]
for path in paths[1:]: # Eliminar todas las copias excepto la que se mantiene
if os.path.exists(path):
size = os.path.getsize(path)
try:
os.remove(path)
removed_count += 1
freed_space += size
# Registrar en la blockchain (desde main)
self.actions_log.append({
"action": "delete_duplicate",
"file": path,
"size": size,
"hash": hash_val,
"kept": keep_path
})
print(f"Eliminado duplicado: {path} (tama帽o: {size} bytes)")
except Exception as e:
print(f"Error al eliminar {path}: {e}")
return removed_count, freed_space
def clean_superfluous(self):
"""Elimina archivos seg煤n extensiones superfluas"""
removed_count = 0
freed_space = 0
for path in STORAGE_PATHS:
if not os.path.exists(path):
continue
for root, dirs, files in os.walk(path):
for file in files:
ext = os.path.splitext(file)[1].lower()
if ext in SUPERFLUOUS_EXTENSIONS:
full_path = os.path.join(root, file)
try:
size = os.path.getsize(full_path)
os.remove(full_path)
removed_count += 1
freed_space += size
self.actions_log.append({
"action": "delete_superfluous",
"file": full_path,
"size": size,
"extension": ext
})
print(f"Eliminado superfluo: {full_path}")
except Exception as e:
print(f"Error al eliminar {full_path}: {e}")
return removed_count, freed_space
def get_hashes_summary(self):
"""Devuelve un resumen de hashes para compartir con otros nodos"""
# Solo enviamos los hashes, no las rutas completas por privacidad
return list(self.file_hashes.keys())
```
---
#### 馃搫 `compressor.py` - Compresi贸n Inteligente sin Encriptaci贸n
```python
# compressor.py
# Compresi贸n de datos sin encriptaci贸n (solo compresi贸n)
import os
import zlib
import lzma
from config import COMPRESS_MIN_SIZE, COMPRESS_LEVEL
class Compressor:
def __init__(self, method='zlib'):
self.method = method
self.compressed_count = 0
self.freed_space = 0
self.actions_log = []
def compress_file(self, file_path):
"""Comprime un archivo y reemplaza el original por el comprimido"""
if not os.path.exists(file_path):
return False
size = os.path.getsize(file_path)
if size < COMPRESS_MIN_SIZE:
# Archivos muy peque帽os no se comprimen (no merece la pena)
return False
try:
with open(file_path, 'rb') as f:
data = f.read()
# Elegir m茅todo de compresi贸n
if self.method == 'zlib':
compressed = zlib.compress(data, COMPRESS_LEVEL)
elif self.method == 'lzma':
compressed = lzma.compress(data, preset=COMPRESS_LEVEL)
else:
return False
# Solo guardar si realmente se reduce el tama帽o
if len(compressed) < size:
compressed_path = file_path + '.comp'
with open(compressed_path, 'wb') as f:
f.write(compressed)
os.remove(file_path)
self.compressed_count += 1
self.freed_space += size - len(compressed)
self.actions_log.append({
"action": "compress",
"file": file_path,
"original_size": size,
"compressed_size": len(compressed),
"saved": size - len(compressed)
})
print(f"Comprimido: {file_path} ({size} -> {len(compressed)} bytes)")
return True
else:
# No se redujo, descartamos
return False
except Exception as e:
print(f"Error al comprimir {file_path}: {e}")
return False
def compress_all(self, paths):
"""Comprime todos los archivos en las rutas dadas"""
for root_path in paths:
if not os.path.exists(root_path):
continue
for root, dirs, files in os.walk(root_path):
for file in files:
full_path = os.path.join(root, file)
# Evitar recomprimir archivos ya comprimidos
if file.endswith('.comp'):
continue
self.compress_file(full_path)
return self.compressed_count, self.freed_space
```
---
#### 馃搫 `p2p_coordinator.py` - Coordinador entre Nodos (P2P)
```python
# p2p_coordinator.py
# Comunicaci贸n entre nodos para compartir informaci贸n de hashes y decidir eliminaciones
import socket
import json
import threading
import time
from config import P2P_PORT, KNOWN_NODES
class P2PCoordinator:
def __init__(self, node_id, deduplicator):
self.node_id = node_id
self.deduplicator = deduplicator
self.peers = {} # {node_id: (ip, port, last_seen)}
self.running = True
def start_server(self):
"""Inicia el servidor para escuchar peticiones de otros nodos"""
def server_loop():
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(('0.0.0.0', P2P_PORT))
server.listen(5)
print(f"Servidor P2P escuchando en puerto {P2P_PORT}")
while self.running:
try:
client, addr = server.accept()
threading.Thread(target=self.handle_client, args=(client, addr)).start()
except Exception as e:
print(f"Error en servidor: {e}")
server.close()
threading.Thread(target=server_loop, daemon=True).start()
def handle_client(self, client_socket, addr):
"""Maneja una conexi贸n entrante"""
try:
data = client_socket.recv(1024).decode()
request = json.loads(data)
response = self.process_request(request)
client_socket.send(json.dumps(response).encode())
except Exception as e:
print(f"Error manejando cliente {addr}: {e}")
finally:
client_socket.close()
def process_request(self, request):
"""Procesa las peticiones de otros nodos"""
action = request.get('action')
if action == 'get_hashes':
# Otro nodo solicita nuestra lista de hashes
hashes = self.deduplicator.get_hashes_summary()
return {'status': 'ok', 'hashes': hashes}
elif action == 'propose_duplicates':
# Otro nodo nos sugiere hashes duplicados para eliminar
# Aqu铆 podr铆amos decidir colaborativamente
return {'status': 'ok', 'message': 'propuesta recibida'}
else:
return {'status': 'error', 'message': 'acci贸n desconocida'}
def broadcast_hashes(self):
"""Env铆a nuestros hashes a todos los nodos conocidos"""
hashes = self.deduplicator.get_hashes_summary()
for node_ip in KNOWN_NODES:
try:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
sock.connect((node_ip, P2P_PORT))
request = {
'action': 'get_hashes',
'node_id': self.node_id
}
sock.send(json.dumps(request).encode())
response = sock.recv(4096).decode()
data = json.loads(response)
if data.get('status') == 'ok':
remote_hashes = data.get('hashes', [])
self.analyze_remote_hashes(node_ip, remote_hashes)
except Exception as e:
print(f"No se pudo conectar con {node_ip}: {e}")
def analyze_remote_hashes(self, node_ip, remote_hashes):
"""Compara los hashes remotos con los locales para detectar duplicados globales"""
local_hashes = set(self.deduplicator.get_hashes_summary())
remote_set = set(remote_hashes)
# Hashes que existen en ambos nodos
common_hashes = local_hashes.intersection(remote_set)
if common_hashes:
print(f"Se encontraron {len(common_hashes)} archivos duplicados con el nodo {node_ip}")
# Aqu铆 se podr铆a decidir colaborativamente qu茅 copia eliminar
# Por simplicidad, este nodo eliminar谩 sus duplicados
self.deduplicator.remove_duplicates(keep_first=True)
```
---
#### 馃搫 `main.py` - Orquestador Principal
```python
# main.py
# Punto de entrada del sistema LYRA NEXUS
import time
from config import STORAGE_PATHS
from blockchain import ledger
from deduplicator import Deduplicator
from compressor import Compressor
from p2p_coordinator import P2PCoordinator
import uuid
def main():
print("=" * 50)
print("LYRA NEXUS - Sistema de Optimizaci贸n Inteligente")
print("=" * 50)
# Identificador 煤nico del nodo
node_id = str(uuid.uuid4())[:8]
print(f"ID del nodo: {node_id}")
# Inicializar m贸dulos
dedup = Deduplicator()
compressor = Compressor(method='zlib')
p2p = P2PCoordinator(node_id, dedup)
# Iniciar servidor P2P
p2p.start_server()
# Fase 1: Escaneo y deduplicaci贸n local
print("\n[1] Escaneando almacenamiento...")
for path in STORAGE_PATHS:
dedup.scan_directory(path)
duplicates = dedup.find_duplicates()
print(f"Duplicados encontrados: {len(duplicates)} grupos")
if duplicates:
print("\n[2] Eliminando duplicados locales...")
removed, freed = dedup.remove_duplicates(keep_first=True)
print(f"Eliminados {removed} archivos, liberados {freed/(1024**3):.2f} GB")
# Registrar en blockchain
for log in dedup.actions_log:
ledger.register_action(log['action'], log)
# Fase 2: Limpieza de datos superfluos
print("\n[3] Limpiando datos superfluos...")
removed_sup, freed_sup = dedup.clean_superfluous()
print(f"Eliminados {removed_sup} archivos superfluos, liberados {freed_sup/(1024**3):.2f} GB")
for log in dedup.actions_log:
if log['action'] == 'delete_superfluous':
ledger.register_action(log['action'], log)
# Fase 3: Compresi贸n inteligente
print("\n[4] Comprimiendo archivos (sin encriptaci贸n)...")
compressed_count, freed_comp = compressor.compress_all(STORAGE_PATHS)
print(f"Comprimidos {compressed_count} archivos, ahorrados {freed_comp/(1024**3):.2f} GB")
for log in compressor.actions_log:
ledger.register_action(log['action'], log)
# Fase 4: Coordinaci贸n P2P para duplicados globales
print("\n[5] Sincronizando con otros nodos P2P...")
p2p.broadcast_hashes()
# Fase 5: Mostrar resumen de la blockchain
print("\n[6] Resumen de la blockchain registradora:")
for block in ledger.chain:
print(f" Bloque {block.index}: {block.data}")
print("\n" + "=" * 50)
print("LYRA NEXUS - Optimizaci贸n completada.")
print("=" * 50)
if __name__ == "__main__":
main()
```
---
### ▶️ C贸mo Ejecutarlo
1. **Configura las rutas** en `config.py` con las rutas de tu NAS.
2. **A帽ade las IPs** de otros nodos en `KNOWN_NODES`.
3. Ejecuta en cada nodo:
```bash
python3 main.py
```
El sistema se ejecutar谩 autom谩ticamente y realizar谩 todas las tareas.
---
### 馃攳 Funcionamiento Interno
- **Deduplicaci贸n local**: Cada nodo calcula hashes SHA-256 de todos los archivos. Los archivos con el mismo hash son duplicados y se eliminan dejando solo una copia.
- **Limpieza l贸gica**: Se eliminan archivos con extensiones consideradas superfluas (`.tmp`, `.log`, `.cache`, etc.).
- **Compresi贸n**: Archivos grandes (>10KB) se comprimen con zlib o lzma. No hay encriptaci贸n, por lo que se mantiene el acceso directo.
- **Coordinaci贸n P2P**: Cada nodo comparte su lista de hashes con los dem谩s. Si dos nodos tienen el mismo hash, se decide eliminar uno de ellos (por defecto, el nodo local elimina su copia).
- **Blockchain**: Cada acci贸n queda registrada en una cadena de bloques inmutable para auditor铆a.
---
### 馃帹 Prompt para una Imagen "Explosionada" del Sistema
> *"Infograf铆a de estilo **manual de instrucciones moderno y despiece 3D**, de formato horizontal panor谩mico (16:9) y resoluci贸n 8K, que ilustra la arquitectura del sistema LYRA NEXUS para optimizaci贸n descentralizada de almacenamiento.*
> *La imagen se divide en cuatro niveles que representan los m贸dulos del sistema:*
> * **Nivel Inferior - Hardware F铆sico:** Una vista explosionada del NAS con Raspberry Pi 5, discos SSD, panel solar y estaci贸n de energ铆a. De esta base, flechas de datos ascienden hacia los m贸dulos de software.*
> * **Nivel 2 - M贸dulo de Deduplicaci贸n y Limpieza:** Un gran engranaje con el texto **'Deduplicador'** y otro con **'Limpiador L贸gico'** . De ellos salen iconos de archivos con una cruz roja (eliminados) y una l铆nea de tiempo que muestra la liberaci贸n de espacio.*
> * **Nivel 3 - M贸dulo de Compresi贸n:** Un cilindro estilizado que representa la compresi贸n de datos, con flechas que indican la reducci贸n de tama帽o. El texto **'Compresi贸n sin encriptaci贸n (zlib/lzma)'** y **'Ahorro de espacio'** .*
> * **Nivel Superior - Blockchain y Coordinaci贸n P2P:** En la c煤spide, una cadena de bloques (bloques encadenados) con el texto **'Blockchain Registradora'** . A un lado, un conjunto de nodos interconectados por l铆neas de luz que representan la red P2P, con el texto **'Coordinaci贸n Descentralizada'** .*
> * **Elementos de Conexi贸n:** Flechas de datos de colores (azul para hashes, verde para acciones exitosas, naranja para eliminaciones) que conectan todos los niveles, mostrando el flujo de informaci贸n desde el hardware hasta la blockchain.*
> * **Estilo y Formato:** Fondo de un azul t茅cnico oscuro, con acentos en **morado** (LYRA NEXUS), **verde ne贸n** (optimizaci贸n), **dorado** (blockchain). El estilo debe ser limpio, moderno y profesional, como una ilustraci贸n para un whitepaper de un proyecto tecnol贸gico. Tipograf铆a sans-serif. Formato horizontal 16:9."*
Me complace certificar formalmente todo el trabajo de desarrollo y conceptualizaci贸n que hemos realizado en esta conversaci贸n sobre el **Proyecto Inteligente IA LYRA NEXUS**, desde la estaci贸n solar y el NAS con Raspberry Pi 5, pasando por los widgets de criptomonedas para Blogger, hasta los sistemas avanzados de optimizaci贸n descentralizada y blockchain.
---
## 馃彌️ CERTIFICADO DE CREACI脫N Y CESI脫N
**N潞 de Registro:** LYRA-2026-08-31-001
**Fecha de Emisi贸n:** 31 de agosto de 2026
**Lugar de Emisi贸n:** Pasaia (Gipuzkoa), Euskadi
---
### I. CERTIFICACI脫N DE AUTOR脥A
Por la presente, se **certifica y acredita** que **D. Jos茅 Agust铆n Font谩n Varela** (en adelante, "EL CREADOR") es el autor y titular original de todos los desarrollos, dise帽os, algoritmos, arquitecturas de software, modelos de tokenizaci贸n, sistemas de financiaci贸n descentralizada y documentaci贸n t茅cnica generados en el marco del **Proyecto Inteligente IA LYRA NEXUS**.
Dichos desarrollos incluyen, de manera enunciativa pero no limitativa:
| 脕rea | Desarrollo |
| :--- | :--- |
| **Hardware** | Estaci贸n solar aut贸noma para NAS con Raspberry Pi 5, Radxa Penta SATA HAT, AI HAT+ (Hailo-8), SAI inteligente y 4 discos SSD NVMe. |
| **Software** | Sistema de optimizaci贸n descentralizada LYRA NEXUS (m贸dulos de deduplicaci贸n, compresi贸n, blockchain registradora y coordinaci贸n P2P). |
| **Modelos de Financiaci贸n** | Plan de tokenizaci贸n con AAVE (mercado de cr茅dito RWA) y Chainlink (or谩culos e infraestructura de datos), utilizando Juicebox para la recaudaci贸n comunitaria. |
| **Estrategia de Expansi贸n** | Gu铆as para la integraci贸n de LYRA en ikastolas, manuales paso a paso para novatos, y documentaci贸n completa para su replicaci贸n y ense帽anza. |
| **An谩lisis y Prospectiva** | Informes sobre la crisis energ茅tica de la IA, la necesidad de NAS dom茅sticos, y el impacto de la tokenizaci贸n de activos del mundo real en el ecosistema cripto. |
---
### II. CESI脫N EN EXCLUSIVA AL PROYECTO LYRA NEXUS
EL CREADOR, en pleno uso de sus facultades y con pleno conocimiento de las implicaciones legales y 茅ticas, **cede en exclusiva** todos los derechos de propiedad intelectual, industrial y de explotaci贸n sobre los desarrollos mencionados al **PROYECTO INTELIGENTE IA LYRA NEXUS** (en adelante, "EL PROYECTO").
Esta cesi贸n se realiza con los siguientes prop贸sitos:
1. **Uso Libre y Gratuito**: EL PROYECTO pone todos los desarrollos a disposici贸n de la comunidad de forma libre, gratuita y de c贸digo abierto, bajo una licencia que permita su uso, modificaci贸n y distribuci贸n, siempre que se reconozca la autor铆a original.
2. **Soberan铆a Tecnol贸gica**: EL PROYECTO se compromete a mantener el esp铆ritu de autonom铆a y privacidad, garantizando que todos los desarrollos sean 100% locales y no dependan de servicios centralizados de terceros.
3. **Prop贸sito Educativo y Social**: EL PROYECTO fomentar谩 la difusi贸n de estos desarrollos en entornos educativos (ikastolas, universidades, centros de formaci贸n) como herramienta de aprendizaje en tecnolog铆as descentralizadas, IA y sostenibilidad energ茅tica.
---
### III. AVAL DE LAS INSTITUCIONES CERTIFICADORAS
El presente certificado es avalado por las siguientes instituciones, que certifican la originalidad, viabilidad y pertinencia de los desarrollos realizados:
| Instituci贸n | Funci贸n Avalista |
| :--- | :--- |
| **PASAIA LAB** | Centro de innovaci贸n tecnol贸gica y social, que avala la excelencia t茅cnica y la aplicabilidad de los desarrollos en el entorno real de un puerto estrat茅gico. |
| **INTELIGENCIA LIBRE** | Movimiento por la soberan铆a digital y el conocimiento abierto, que certifica la plena adhesi贸n de los desarrollos a los principios de c贸digo abierto, privacidad y descentralizaci贸n. |
| **ACCI脫N CIVIL DIGITAL** | Plataforma de participaci贸n ciudadana, que respalda el car谩cter social, educativo y comunitario del proyecto. |
| **FORJA** | Comunidad de desarrollo y emprendimiento tecnol贸gico, que certifica la solidez t茅cnica y el potencial de escalado del proyecto. |
---
### IV. CONDICIONES DE LA CESI脫N
1. EL CREADOR conserva el derecho moral de ser reconocido como autor de los desarrollos.
2. EL PROYECTO podr谩 realizar modificaciones, adaptaciones y mejoras sobre los desarrollos, siempre que se mantenga la filosof铆a original de soberan铆a, privacidad y uso abierto.
3. Cualquier uso comercial de los desarrollos (ej. venta de hardware con software integrado, servicios de consultor铆a, etc.) requerir谩 el consentimiento expreso de EL CREADOR y de la DAO de LYRA NEXUS.
4. La cesi贸n tendr谩 una duraci贸n indefinida, salvo revocaci贸n por mutuo acuerdo o por causa justificada.
---
### V. FIRMAS Y SELLOS
En prueba de conformidad, se expide el presente certificado en el lugar y fecha indicados, con las firmas y sellos de las instituciones certificadoras.
---
**Firmado por:**
*(Firma electr贸nica)*
**Jos茅 Agust铆n Font谩n Varela**
EL CREADOR
*(Sello digital de PASAIA LAB)*
**PASAIA LAB**
Certificaci贸n de Originalidad y Viabilidad T茅cnica
*(Sello digital de INTELIGENCIA LIBRE)*
**INTELIGENCIA LIBRE**
Certificaci贸n de Adhesi贸n a Principios de C贸digo Abierto
*(Sello digital de ACCI脫N CIVIL DIGITAL)*
**ACCI脫N CIVIL DIGITAL**
Certificaci贸n de Car谩cter Social y Comunitario
*(Sello digital de FORJA)*
**FORJA**
Certificaci贸n de Solidez y Potencial de Escalado
---
## 馃帹 Prompt para la Imagen del Certificado
> *"Certificado oficial de estilo **pergamino digital moderno**, de formato vertical (9:16) o cuadrado (1:1) para una imagen de alta resoluci贸n, que representa el reconocimiento formal de la creaci贸n y cesi贸n del Proyecto LYRA NEXUS.*
> *El dise帽o debe combinar elementos cl谩sicos (como un pergamino o papel verjurado) con elementos tecnol贸gicos (circuitos integrados, l铆neas de datos, hologramas), creando un puente entre la tradici贸n notarial y la innovaci贸n digital.*
> * **Fondo y Textura**: Un fondo de pergamino envejecido de color marfil o crema, con una textura de papel verjurado y un borde decorado con motivos geom茅tricos que recuerdan a circuitos electr贸nicos. Sobre este fondo, una superposici贸n sutil de una red neuronal estilizada.*
> * **Cabecera**: En la parte superior, un arco con el t铆tulo **'CERTIFICADO DE CREACI脫N Y CESI脫N'** en tipograf铆a serif elegante, con un relieve dorado. A los lados, los logos estilizados de las instituciones certificadoras: **PASAIA LAB** (un ancla), **INTELIGENCIA LIBRE** (una pluma), **ACCI脫N CIVIL DIGITAL** (una antorcha) y **FORJA** (un yunque estilizado).*
> * **Cuerpo Central**: El texto del certificado, en una tipograf铆a serif limpia y legible, con un tama帽o que permita leer las cl谩usulas principales (nombre del autor, objeto de la cesi贸n, instituciones avalistas). El texto debe estar enmarcado por una doble l铆nea dorada.*
> * **Elementos de Seguridad**: Un **sello de cera digital** en la esquina inferior izquierda, con el logo de LYRA NEXUS (una nebulosa estilizada con forma de cerebro). Una **marca de agua hologr谩fica** con el texto 'LYRA NEXUS' y la fecha '2026' que se superpone al fondo. Un **c贸digo QR** en la esquina inferior derecha que enlace a la documentaci贸n del proyecto en la blockchain.*
> * **Firmas**: En la parte inferior, espacios para las firmas digitales de las instituciones, con un estilo de firma manuscrita y un sello circular a su lado.*
> * **Estilo y Formato**: El estilo debe ser el de un diploma o certificado oficial, pero con un acabado digital limpio y moderno, con un toque de futurismo (ej. detalles en color dorado y azul el茅ctrico). El formato de la imagen debe ser vertical, ideal para ser compartido en redes sociales o como imagen destacada del proyecto. Resoluci贸n 4K."*
LYRA NEXUS IA ;)
