From Claims to a Graph of Accepted Facts

From Claims to a Graph of Accepted Facts Image: generated with Google Gemini

Reality is an open system. Records arrive late. Witnesses recant. Sensors are recalibrated. Policies change. At no point can we say that every relevant observation has arrived, because we do not even know what remains undiscovered.

Action is different. Charging, paying, granting access, raising an alarm: each demands a closed answer. A decision must end even when reality does not. Between an open world and a finite action lies a structural gap. More model confidence, a longer chain of thought, or another layer of agents cannot close it.

The first question is therefore not, “What is true?” It is:

In a world of claims with no known end, who may fix the premises for this decision, under what rules?

What enters a system is not the event itself. It is a contract, payment record, sensor log, video, testimony, or message: a fragment produced by an observer, at a time, through a transformation, within a scope, with failure modes. The system must receive these as Claims, not facts.

But preserving Claims is not enough to act. Claims can conflict. A missing record may mean that an event never happened, or merely that collection failed. Several Claims may have to be combined to derive one premise. If an open Claim ledger goes directly into a judgment engine, collection, fact-finding, and rule application collapse back into one opaque act.

What we need is an explicit procedure that constructs the factual state permitted for a particular decision. I call that procedure Projection, and its result a Graph of Accepted Facts, or GAF.

Open Claims
    │
    ▼
Projection
    │  evaluation · conflict resolution · derivation · absence policy
    ▼
Graph of Accepted Facts (GAF)
    │
    ▼
Closure
    │  GAF · scope · policy · rules · runtime frozen
    ▼
Deterministic Verdict
    │
    ▼
Authorized Action
    │
    └── new evidence · policy change · appeal · defect
                                  │
                                  ▼
                           Reopen / Re-projection

The point is not to collect more facts. It is to separate constructing the premises of judgment from computing upon those premises.

A finite input is not yet a closed world

A finite Claim set does not make a closed world. If a payment does not appear in a database, we cannot immediately conclude that no payment occurred. The record may be missing, delayed, misrouted, or held by another institution.

Projection must therefore fix the meaning of absence, not merely the input list:

Which source is considered complete for this subject, predicate, range, and period?
Where may a closed-world assumption be applied?
Does a missing record mean false or unknown?
How is explicit negation distinguished from missing data?
What must the system return when the evidence is insufficient?

Raymond Reiter’s foundational paper On Closed World Data Bases formalized the crucial move: under a closed-world assumption, failure to prove a positive ground literal may license its negation. That move is useful precisely because it is not universally safe. It requires a declared boundary.

Suppose a bank supplies a finalized transaction ledger for one account and one period, and the Projection policy accepts that ledger as complete within that scope. Absence may then count as evidence that no matching transaction exists there. The absence of a payment reference in a tenant’s message archive proves no such thing. One source is closed for a declared query; the other remains open.

Closure is not the statement “we read this far.” It is a contract defining where absence itself becomes computable information.

Projection is not a button that promotes a Claim into fact

Projection cannot be reduced to attaching accepted, rejected, or held to an entire Claim. Real Claims are rarely that clean.

“I sent the rent on the fifth” may have a verified date but an unverified purpose.
Two independent records may be required to establish one payment.
One Claim may support one proposition and rebut another.
A fact may be derived even though no source states it verbatim.
A reliable source may still be unresolved as to which event its record describes.

Evaluation is relational, not a flag on a whole Claim. It connects one or more Claims, an atomic Proposition, and a particular Projection. A Derivation then combines Evaluations, previously accepted premises, and explicit rules to produce an Accepted Fact.

Claims ───────┐
Proposition ──┼── Evaluation ── accepted / rejected / unknown
Projection ───┘                     │
                                   ▼
                       Derivation ── Claims · Facts · Rules
                                   │
                                   ▼
                            Accepted Fact

A Claim preserves who asserted or observed what. A Proposition is the smallest statement being evaluated. An Evaluation records how the Claims bear upon that Proposition under one Projection. A Derivation is the proof object that shows how the result was produced. An Accepted Fact is the premise the procedure permits this judgment to use.

The same Claim may therefore yield a different Accepted Fact—or none at all—under another purpose, cutoff time, burden of proof, or authority. An Accepted Fact is not absolute truth about all reality. It is a premise admitted for use within a declared decision boundary.

Why the result is a graph

The premises of a judgment are not isolated sentences. Who paid whom, when, how much, under which contract, toward which obligation, and while that contract was in force are connected statements.

A Graph of Accepted Facts contains those premises and their semantic relations, together with the derivation and provenance that produced them:

entities, actions, times, quantities, and states;
Claims that support or rebut each Proposition;
original sources and responsible actors;
Evaluations and derivation rules;
rejected or unresolved alternatives;
temporal, logical, and supersession relations.

The point of the graph is not decorative explanation. It is machine-traceable dependency.

Starting from a Verdict, an auditor must be able to descend through the GAF and its rules to the original Claims. Starting from an invalidated Claim or source, the system must be able to find every Accepted Fact, Closure, Verdict, and Action that may require review.

Provenance alone is insufficient. Complete impact analysis also needs derivation dependencies, negative dependencies, aggregate conditions, and policy scope. A conclusion may depend not on a Claim that exists, but on the declared absence of any qualifying Claim. The PROV-O: The PROV Ontology standardizes interoperable provenance around entities, activities, agents, and qualified relations; GAF’s additional burden is to preserve the decision-specific acceptance and negative dependencies needed to reopen judgments.

This is a logical data model, not a graph-database mandate. A relational database, content-addressed object store, append-only event log, or graph database may implement it. The physical store is valid if it preserves the nodes, typed relations, lineage, and dependency queries without semantic loss.

Closure is larger than GAF

GAF preserves Accepted Facts and their Derivation and Provenance. Closure is larger than GAF: it freezes exactly which GAF was used, for which question, under which conditions. It is the replay contract for the decision.

A Closure must contain at least:

the question and purpose of the judgment;
the event, subject, and temporal scope;
the exact GAF snapshot and its integrity identifier;
completeness declarations and the treatment of absence, negation, and unknowns;
the Projection policy and implementation version;
the Verdict rules and engine version;
runtime conditions such as numeric precision, ordering, and tie-breaking;
canonicalization rules required to identify the same graph again.

If the same Closure executed in the same runtime yields a different Verdict, the computation layer is defective. If the Closures differ, the disagreement can be localized to inputs, Projection policy, Accepted Facts, rules, or runtime.

Determinism does not mean knowing reality perfectly. It means that the same closed world must compute the same way.

Follow one case all the way through

A landlord asserts that the July rent is unpaid. A tenant asserts that the rent was transferred on the fifth. The finalized bank ledger shows that the landlord received one thousand dollars that day, but the transfer memo is empty. The contract requires one thousand dollars by the fifth of each month.

The Open Claim Ledger preserves all four records without letting one overwrite another.

Claim	Content	Source status
Claim A	July rent is unpaid	landlord assertion
Claim B	rent was transferred on the fifth	tenant assertion
Claim C	the landlord’s account received one thousand dollars on the fifth	finalized bank ledger
Claim D	monthly rent is one thousand dollars, due by the fifth	valid contract

The Projection narrows the question to: “Has July rent delinquency been established?” It accepts the bank ledger as complete for the account and period. It also applies a policy that does not infer allocation to a particular debt without a memo or separate agreement.

Claim C and Claim D support accepted Propositions. Claim B’s date and amount are supported by Claim C, but its allocation to July rent remains unknown. Claim A is a party’s assertion of the desired conclusion, not independent evidence of nonpayment, so it does not become an Accepted Fact by repetition.

The GAF records:

The contract required monthly payment by the fifth.       [accepted]
The landlord received the contractual amount that day.    [accepted]
Allocation of that payment to the July debt is unresolved.[unknown]
July rent delinquency has not been established.            [not derived]

The Closure binds this GAF to the Projection policy, the ledger’s completeness scope, the cutoff time, and the Verdict engine. The Verdict is not delinquent; it is undetermined. The Authorized Action is therefore not a demand letter, but a request to establish allocation.

Later, an original transfer receipt bearing the memo “July rent” arrives as a new Claim. The old Closure is preserved. A Reopen event starts a new Projection. If the memo is admitted, a new GAF accepts the allocation, and a new Closure produces paid as the Verdict.

Projection in this example is not a vote over which person sounds more credible. It fixes the question, completeness boundary, atomic Propositions, meaning of missing data, and derivation rules required to construct a decidable factual state.

Preserve the decision as a contract

The example still contains a bottleneck. If every payment without a memo requires the landlord to confirm allocation, uncertainty has not been eliminated; it has merely been moved into a human approval queue.

The first confirmation should resolve the case. A repeated pattern should do more: preserve the decision as a contract that can become future Projection input.

Suppose the landlord confirms the payment and both parties approve this rule:

A payment is allocated to the current month’s rent when it arrives from the tenant’s registered account by the due date, equals the contractual amount, and no other debt is outstanding. A case that violates any condition requires review.

That produces four distinct records:

Case Decision    ── this payment satisfied the July rent
Policy Candidate ── matching future payments may satisfy monthly rent
Ratified Contract── authorized conditions, exceptions, effective date, version
Policy Exception ── ambiguity outside the contract returns to human review

The next Closure references the ratified policy version. Matching Claims can then be projected without asking the landlord the same question again; only a new exception consumes human judgment. The human decision is used once, while its authorized structure continues to work.

But one decision is not yet a policy. A system must not silently turn one confirmation into precedent. The person with authority must ratify the rule’s scope, exceptions, effective date, and whether it applies retroactively. Until then, the case record is only a Policy Candidate. If a new contract is not explicitly retroactive, it governs later Closures and does not rewrite earlier ones.

This adds a second preservation loop to GAF. Claims preserve what entered from the world. GAF and Closure preserve what a particular judgment accepted. A ratified policy preserves how an authorized human resolved a recurring ambiguity, so the next Projection begins with a stronger contract instead of the same bottleneck.

Different errors require different repairs

Once Projection, Verdict, and Action are separated, one “wrong result” decomposes into different failures:

missing a relevant Claim is a collection error;
evaluating a source or Proposition incorrectly is a Projection error;
applying the wrong rule to correct Accepted Facts is a computation error;
rendering a correct Verdict inaccurately is a communication error;
executing a correct Verdict against the wrong target, limit, or authority is an Action error.

This taxonomy does not abolish error. It tells us what to reopen.

A collection error requires another Claim. A Projection error requires review of Evaluation and Derivation. A computation error can preserve the Closure while correcting and comparing the engine. An Action error should not rewrite the facts; it requires cancellation, correction, or compensation in the external world.

Calling all of these “the model was wrong” destroys the distinction. Once the cause is lost, the system cannot prove what changed after the repair.

Accepted Fact is not authority to act

An Accepted Fact does not confer power. “The rent is delinquent” and “this system may send a demand letter” are different Propositions.

The Verdict engine consumes a Closure and emits a judgment with a computation trace. An Authorized Action must separately check:

who authorized the effect;
which subject and object it targets;
applicable amount and frequency limits;
whether retries are idempotent;
what receipt proves execution;
how a mistaken effect can be cancelled or compensated.

Fact production, judgment, and execution are separate because each exercises a different kind of authority.

A closed world must remain reopenable

A Closure must be immutable without pretending to be eternal truth. Evidence may arrive late. A source may prove fraudulent. A policy defect may be discovered. An affected party may appeal.

Overwriting the old result would destroy the explanation for the action taken at that time. Reopen is therefore a new event, not an edit to the old Closure.

New evidence, a policy change, an appeal, or a defect report is recorded. The dependency graph identifies possibly affected Closures. If an authorized procedure permits reopening, a new Projection produces a new GAF, Closure, and Verdict. The new result states what it supersedes without overwriting history.

If an Action has already changed the world, recomputation cannot reverse it. Cancellation, correction notices, refunds, and compensation are themselves new Actions with their own authorization and receipts.

Reopenability does not weaken closure. Closure becomes legitimate precisely when the system preserves what was fixed and permits replacement only through a declared procedure.

LLMs cannot substitute for the boundary

Most end-to-end LLM applications mix question interpretation, retrieval, source selection, fact-finding, rule application, and expression in one generation. If adopted and rejected Claims are not externalized, the same answer does not prove the same grounds. A changed answer does not reveal whether the input boundary or the computation changed.

A long explanation or generated reasoning trace does not solve this. A post-hoc explanation is not an execution record of the inputs, rules, and authority actually used.

LLMs remain useful around the boundary. They can extract Claim candidates from unstructured sources, propose atomic Propositions, explain conflicts and unknowns, draft Projection policies, and translate a fixed Verdict into human language.

But a proposal is not an adoption. An LLM-generated Claim, mapping, Evaluation, or rule must become a versioned input with provenance and pass an authorized procedure. The final authority for high-consequence action cannot remain hidden inside natural-language generation.

The contribution is the chain

The components are not all new. Closed-world reasoning, provenance, truth-maintenance systems, event sourcing, rule engines, legal fact-finding, and appeals have long histories. On Closed World Data Bases established the open/closed-world distinction, while PROV-O: The PROV Ontology standardized a graph model for tracing entities through activities and responsible agents.

The contribution is the chain, assembled as one responsibility protocol:

Claims → Projection → GAF → Closure → Verdict → Action → Reopen

Every arrow is a boundary of authority and error, not merely a data transformation. The actor preserving Claims, the authority admitting premises, the engine computing a Verdict, and the gateway changing the world operate under different contracts. Their records connect, but no stage silently inherits the authority of another.

GAF is not the invention of another database. It is the proposal to make the entire passage from open claims to actionable facts auditable, reproducible, and appealable.

The goal is controlled closure, not perfect truth

We cannot build a system that knows the whole open world. We can build one that states which information it accepted as a premise, and why.

Open Claims preserve disagreement and uncertainty. Projection fixes purpose, scope, burden, and the meaning of absence. GAF connects admitted premises to their relations and lineage. Closure freezes the conditions for replay. Verdict computes over the closed input. Action changes reality under separate authority. Reopen revisits the boundary without erasing history.

With this cycle, error no longer remains one opaque hallucination. We can distinguish what the system missed, what it accepted wrongly, what it computed wrongly from accepted premises, and what it executed wrongly after a correct judgment.

Projecting Claims into a GAF is not a way to make machines infallible. It fixes what the machine judged upon so that the judgment can be reproduced, challenged, and corrected.

The aphorism “mathematics is true because it computes inside a closed system” points to a narrower, defensible fact. Once axioms, definitions, and inference rules are fixed, a derivation inside that formal boundary can be checked and replayed (Formalism in the Philosophy of Mathematics). This does not make every mathematical truth computable, every proposition decidable, or every axiomatic system complete. Closure guarantees the reproducibility of an admitted derivation, not omniscience.

Real-world judgment needs the same discipline before computation. GAF is not truth itself. It is the closed world that fixes which premises were accepted from open reality, so that a verdict can be reproduced—and contested—within it.

Truth Is Not Discovered — the physical, mathematical, and legal argument for why truth appears only after a world is closed
Triples Are Claims, Not Facts — why a knowledge graph should preserve competing claims before computing contextual judgment
toulmin — A Rule Engine That Computes Contracts — one example of separating accepted premises from deterministic rule computation