Un triple no es un hecho, es una afirmación Image: AI generated

El silencio de Wikidata

Wikidata contiene este triple:

(tomato, instance_of, vegetable) — rank: preferred
(tomato, instance_of, fruit)     — rank: normal

¿Quién decidió preferred? ¿Por qué es preferred? ¿En qué contexto es preferred?

Wikidata guarda silencio ante estas preguntas. Los editores deciden; el sistema solo almacena la decisión.

Pero que el tomate sea verdura o fruta no es una constante física. Si le preguntas a un chef, es verdura. Si le preguntas a un botánico, es fruta. Si le preguntas al Tribunal Supremo de EE.UU., es verdura (1893, Nix v. Hedden). La misma pregunta tiene tres respuestas, y ninguna está equivocada.

Los triples de un grafo de conocimiento no son hechos. Son afirmaciones.

Las afirmaciones necesitan argumentación

Para almacenar afirmaciones se necesita estructura. El modelo de argumentación de Toulmin proporciona esa estructura.

ElementoRolEjemplo del tomate
ClaimAfirmación“El tomate es una verdura”
GroundEvidencia directa“Clasificado como verdura en taxonomías culinarias”
BackingFuente/autoridad“Le Guide Culinaire (1903)”
QualifierAlcance“En contexto culinario” (confianza 0.8)
RebuttalCondición de refutación“En contexto botánico es fruta — estructura del ovario”
WarrantLógica de conexión“La clasificación tradicional de ingredientes se basa en el uso culinario”

En lugar de forzar un único truth value sobre un triple, elevamos el triple a objeto de argumentación. Hay una afirmación, hay evidencia, hay condiciones de refutación, hay fuentes. Y el juicio no ocurre al almacenar, sino al consultar.

Esta idea no es nueva en sí misma. La academia ha explorado la argumentación sobre grafos de conocimiento con el marco de argumentación abstracta de Dung (1995), ASPIC+ (2010), nanopublication, entre otros. La diferencia es una sola: nosotros entregamos código ejecutable, no un paper. Se instala con go install, las reglas se escriben como funciones Go, y se ejecuta ahora mismo.

El contexto determina la verdad

El almacenamiento es estructura argumentativa. El juicio ocurre en tiempo de ejecución.

ctx.Set("domain", "cooking")
results, _ := g.Evaluate(ctx)
// verdict: +0.8 → vegetable

ctx.Set("domain", "botany")
results, _ = g.Evaluate(ctx)
// verdict: -0.9 → not a vegetable (fruit)

El mismo grafo, la misma estructura argumentativa, el mismo código. Solo cambió el contexto. Consultar en contexto culinario da +0.8 (verdura); en contexto botánico da -0.9 (fruta). El veredicto sigue al contexto.

Esta es la diferencia fundamental con el rank estático de Wikidata. No es un editor quien decide preferred, sino el contexto del consultante quien produce el juicio.

¿Es Plutón un planeta?

Triple: (Pluto, instance_of, planet)

Claim:
  Ground: "Solar orbit, spherical, sufficient mass"
  Backing: IAU 1930 classification resolution

Rebuttal:
  Ground: "Orbit-clearing criterion not met"
  Backing: IAU 2006 Resolution 5A

Exception to rebuttal:
  Ground: "Still taught as a planet in education curricula"
  Backing: NASA Education Resources 2024

ctx.Set("domain", "astronomy_formal")
// verdict: -0.8 (not a planet)

ctx.Set("domain", "education")
// verdict: +0.3 (can be treated as planet in context)

Para quien fue a la escuela primaria antes de 2006, Plutón es un planeta. Para la IAU, Plutón es un planeta enano. Ambos tienen evidencia, ambos tienen fuentes. Lo que el sistema debe hacer no es elegir uno, sino almacenar ambos y juzgar según el contexto.

Cuando la fuente es atacada

En debates académicos, es común que la fuente misma sea atacada.

// Claim: Drug X is effective
claim := g.Rule(drugXEffective).
    With(&TripleSpec{
        Ground:  "Significant effect in Phase 3 clinical trial",
        Backing: "Smith et al. (2020), NEJM",
    })

// Rebuttal: Independent replication failed
counter := g.Counter(replicationFailed).
    With(&TripleSpec{
        Ground:  "Effect not confirmed in independent replication",
        Backing: "Jones et al. (2022), Lancet",
    })
counter.Attacks(claim)

// Undercutter: conflict of interest
undercutter := g.Counter(conflictOfInterest).
    With(&TripleSpec{
        Ground:  "Smith's funding came from the pharmaceutical company",
        Backing: "Retraction Watch (2023)",
    })
undercutter.Attacks(claim)

El artículo de Smith se publicó en NEJM. Una fuente con autoridad. Pero cuando se revela el origen de la financiación, toda afirmación basada en ese artículo se debilita. El counter refuta la afirmación frontalmente; el undercutter debilita la evidencia misma. Ambos atacan la afirmación, pero de formas distintas. El h-Categoriser sintetiza la intensidad de estos ataques para calcular el verdict final.

La verdad desaparece a la velocidad de la luz; solo quedan las afirmaciones. El sistema gestiona afirmaciones, no declara verdades.

¿Todo triple necesita argumentación?

No.

(water, chemical_formula, H2O)   — Settled. No argumentation needed.
(tomato, instance_of, ?)         — Contested. Attach argumentation.
(Pluto, instance_of, ?)          — Contested. Attach argumentation.
(Jerusalem, capital_of, ?)       — Contested. Attach argumentation.

El criterio es simple: si para el mismo subject + predicate existen múltiples objects, o los ranks divergen, o las references se contradicen — es un triple contestado. El resto se deja como triple simple.

Añadir argumentación a la fórmula química del agua es un desperdicio. No añadir argumentación al estatus de capital de Jerusalén es una mentira.

Motor de juicio: h-Categoriser

El juicio del grafo de argumentación lo ejecuta el h-Categoriser de Amgoud. Calcula para cada nodo un grado de aceptabilidad en la escala [-1, +1]: cuanto mayor sea la aceptabilidad del atacante, menor será la del atacado. Se itera recursivamente hasta la convergencia.

Rendimiento: aunque 100.000 triples contestados tengan cada uno su grafo de argumentación, al consultar solo se evalúa el grafo del triple en cuestión. Es independiente del tamaño total del grafo de conocimiento.

Triple lookup:        milliseconds (existing index)
Argumentation eval:   milliseconds (h-Categoriser)
Verdict trace:        milliseconds (graph traversal)

No se escala el modelo; se escala la argumentación.

Correspondencia con el rank de Wikidata

Wikidatatoulmin extension
preferred rankverdict > +0.5 (in current context)
normal rank0 < verdict ≤ +0.5
deprecated rankverdict ≤ 0
referenceBacking
qualifierQualifier + context function conditions

Diferencia: el rank de Wikidata es estático. Lo decide un editor. El verdict de toulmin es dinámico. Lo determinan el contexto y la estructura argumentativa.

El panorama más amplio

Este sistema no está atado a un dominio específico.

AI Prefrontal Cortex (feature selection):
  triple = (feature, should_include_in, app_type)
  context = current project's app tags
  verdict = should this feature be included?

Knowledge graph general:
  triple = (subject, predicate, object)
  context = querier's domain/perspective
  verdict = is this triple true in current context?

El mismo motor. La misma estructura. Diferentes dominios. Las reglas son funciones Go, las excepciones son grafos de defeats, el juicio es h-Categoriser. Sin DSL.

Por qué es necesario

Los LLM disuelven el conocimiento en pesos. Se hace una pregunta y sale una respuesta. Pero no se puede rastrear estructuralmente en qué contexto esa respuesta es verdadera, en qué fuente se basa, si existe refutación. Las alucinaciones nacen de esta ausencia de estructura.

Este sistema no puede prevenir todas las alucinaciones. Los LLM generan salidas abiertas, y no es posible registrar previamente todas las afirmaciones posibles. Pero para afirmaciones ya registradas en el grafo de argumentación, se puede contrastar la respuesta generada por el LLM y evaluar su fiabilidad. “¿Cuál es el Backing de esta afirmación? ¿Existe un Counter que ataque ese Backing? ¿El verdict en el contexto actual es positivo?”

No es un verificador universal de verdad. Es un sistema de evaluación de fiabilidad que opera sobre argumentación acumulada.

No es un sistema que almacena hechos, sino uno que gestiona afirmaciones. No declara verdad, sino que rastrea juicios. Este es el siguiente paso de los grafos de conocimiento.

  • toulmin — Go Rule Engine — Motor de reglas basado en el modelo de argumentación de Toulmin. El motor de juicio detrás de este artículo.
  • Ratchet Pattern — Verificación determinista y bloqueo de trinquete.

Code: github.com/park-jun-woo/toulmin

go install github.com/park-jun-woo/toulmin@latest

The code examples in this article represent a design vision based on the toulmin library’s current API. The knowledge graph extension (TripleSpec, context-based evaluation) is under active development. The core judgment engine (h-Categoriser, defeats graph, Rule/Counter) works today.

References

  • Toulmin, S. (1958). The Uses of Argument. Cambridge University Press.
  • Dung, P.M. (1995). “On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming and n-Person Games.” Artificial Intelligence, 77(2), 321–357.
  • Amgoud, L. & Ben-Naim, J. (2013). “Ranking-based semantics for argumentation frameworks.” SUM 2013, LNCS 8078, 134–147.
  • Modgil, S. & Prakken, H. (2014). “The ASPIC+ framework for structured argumentation: a tutorial.” Argument & Computation, 5(1), 31–62.
  • Groth, P. et al. (2010). “Anatomy of a Nanopublication.” Information Services & Use, 30(1-2), 51–56.
  • Nix v. Hedden, 149 U.S. 304 (1893). United States Supreme Court.