Consulta la evidencia, no le creas al resumen

Empieza aquí

Sin clave, sin registro, nada que negociar. Tres pasos te llevan de la API a un hash que recomputaste tú — pégalos y funcionan:

# 1. qué mide el archivo — abre con su propio negativo
curl -s https://rosettaquantum.com/v1/state

# 2. un archivo sellado, con el hash que declara y sus dos copias públicas
curl -s https://rosettaquantum.com/v1/archive/PR-CLEV-001

# 3. recomputa tú ese hash y compara — imprime MATCH
curl -s https://rosettaquantum.com/v1/archive/PR-CLEV-001 \
| python3 -c '
import sys,json,hashlib,urllib.request
d=json.load(sys.stdin)
raw=json.load(urllib.request.urlopen(d["github_raw"]))
meta={k:v for k,v in raw["meta"].items() if k!="content_hash"}
body={k:v for k,v in raw.items() if k not in ("meta","storage")}
mine="sha256:"+hashlib.sha256(
    json.dumps({"meta":meta,**body},sort_keys=True,ensure_ascii=False).encode()).hexdigest()
print(mine); print(d["content_hash"])
print("MATCH" if mine==d["content_hash"] else "MISMATCH")'
      

El paso 3 imprime MATCH. Si alguna vez imprime MISMATCH, estamos equivocados y puedes decirlo en público — de eso se trata:nada de esto pide que le crean. El hash cubre el contenido del archivo, no el archivo: storage queda fuera porque dice dónde vive una copia, no qué dice. Las cuatro convenciones están más abajo, en Cómo comprobar cualquier cosa que esta API te diga.

Para agentes

# el contrato completo, legible por máquina
curl -s https://rosettaquantum.com/v1/openapi.json

# MCP sobre JSON-RPC 2.0 — tampoco pide clave
curl -s -X POST https://rosettaquantum.com/mcp \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
      

Apunta un cliente MCP a https://rosettaquantum.com/mcp — 9 herramientas de sólo lectura, sin paso de autenticación.

Publicamos nuestro propio uso

curl -s https://rosettaquantum.com/v1/usage

Con qué frecuencia se llama de verdad a esta API, a la vista. Si dice cero, dice cero — la misma regla que el contador de victorias cuánticas. No guarda IP, ni user-agent, ni identificador: sólo una fecha, una superficie y la formade la ruta, así que nada de ahí puede reconstruir qué consultó nadie. También declara sus propios puntos ciegos, porque un número sin sus límites es una afirmación.

Devuelve el estado medido del archivo. Hoy abre con0 victorias cuánticas medidas — en ninguna corrida sellada hasta hoy un método cuántico le ganó al campeón clásico. Ese negativo es el producto de este archivo, no un hueco, así que la API lo dice primero.

Endpoints

Sin autenticación. CORS abierto. Cacheado 5 minutos en el edge.

Cómo comprobar cualquier cosa que esta API te diga

content_hash no es el sha256 del archivo. Es el sha256 de una forma canónica: el documento sin meta.content_hash, sinmeta.schema y sin storage, serializado de una manera fija. Calcular el sha256 del archivo tal como se baja da otro valor — enRQ-EXP-EON-K20-002 el declarado es 4ffdfeb4… y el del archivo es a6ff6a5f…. Los dos son correctos: responden preguntas distintas.

Baja los bytes tal como se sellaron

Usa GET /v1/archive/<id>/raw, o cualquiera de las dos copias públicas. Para verificar, no uses GET /v1/archive/<id>: ese endpoint vuelve a serializar el JSON, y un decimal escrito 6.0 regresa como6. El sello no se altera; lo que se pierde es tu capacidad de recomputarlo. Medido sobre las 72 corridas publicadas: 72 de 72 verifican desde/raw, 17 de 72 desde el endpoint que re-serializa. La respuesta de/raw trae el hash declarado en la cabecera x-rq-content-hash, para comparar sin parsear el cuerpo.

Las cuatro convenciones, y por qué son cuatro

El archivo creció en cuatro etapas, y un hash publicado es un hecho público: los archivos viejos no se re-sellan para uniformar el conjunto. Sus hashes están anclados en Bitcoin y hay terceros que ya los citaron — re-sellarlos invalidaría anclas reales. Así que verificar significa probar las cuatro y decir cuál reprodujo. Es historia declarada, no desorden.

La que viaja es v3. Bajo v1 y v2 el hash depende de cómo Python imprime los números: escribe 6.0 donde JavaScript, Go y Rust escriben 6. Si parseas uno de esos archivos en otro lenguaje y lo vuelves a serializar, obtienes otro hash — en silencio, y con toda la pinta de una alteración. No lo es. Con v3 esa limitación desaparece: JCS normaliza los números, que es para lo que se creó. Los sellos nuevos van en v3 y sólo hacia adelante.

La herramienta

tools/verificar.py — un archivo, sin dependencias, las cuatro convenciones. Dice con cuál reprodujo cada hash, o falla con todas las letras. Verificado sobre el archivo completo: 72 de 72.

# baja el archivo tal como se selló y verifícalo — imprime VALIDO y la convención
curl -s https://rosettaquantum.com/v1/archive/EXP-0012-001/raw -o sellado.json
curl -sO https://raw.githubusercontent.com/RosettaQuantum/evidence/main/tools/verificar.py
python3 verificar.py sellado.json
      

Cada archivo sellado está además anclado en el tiempo en Bitcoin vía OpenTimestamps, en una cadena que no controla ninguna de las partes de este archivo. La especificación completa está en elprotocolo del archivo.

Servidor MCP

POST https://rosettaquantum.com/mcp habla JSON-RPC 2.0 y expone 9 herramientas de sólo lectura: estado_del_archivo, buscar_evidencia, ver_archivo, listar_por_tipo, buscar_algoritmo_cuantico, uso_de_la_api, ver_estructura, ver_propagacion y listar_fuentes_cuanticas.

curl -X POST https://rosettaquantum.com/mcp -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Licencia y citación

Los datos son CC BY 4.0; la atribución es deliberada. Cita así:Rosetta Quantum Evidence Ledger, CC BY 4.0 — https://rosettaquantum.com/ledger. El código es Apache-2.0.

Lo que esta API no hace

Es de sólo lectura. No hay endpoint de escritura, no hay qlib.solve()y no hay plan de pago — eso llega cuando haya demanda y ventaja medida que vender, no antes. Si encuentras un error en el archivo,abre un issue: la corrección externa es el ciclo de calidad que este proyecto quiere.