# Standing as a dynamical system steered by reality

_donto papers · original research · 2026-06-13 · theory, working draft v1_

**Abstract.** donto attaches to every claim an *epistemic standing* — in v1 the vector ⟨maturity, corroboration, contradiction-pressure, recency⟩, computed live by the `donto_standing` SQL function from tables that already exist (claim flags, `donto_evidence_link`, `donto_paraconsistency_density`, `tx_time`). The prevailing reading treats standing as a *score*: a number you read off a claim. We argue it is better modeled as the **state of a controlled dynamical system** — a vector field over the claim graph that evolves under a closed feedback loop with reality. The controller is `donto_suggest_next_evidence`: at each step it ranks the observation that would most move standing (resolve a contradiction, settle an identity, discharge a proof obligation), an agent acquires it, the new evidence lands as a non-destructive claim, and standing re-ranks. This reframing buys three things a static score cannot: a vocabulary for the **fixed points** of the loop (settled facts — standing stops moving), its **limit cycles** (perennial disputes — standing oscillates as sources rebut each other forever), and **convergence conditions** (when does steering actually terminate). We give the formal model, characterize the three regimes, and state the central conjecture: *steered acquisition strictly shortens time-to-resolution versus passive accumulation on contested subgraphs, and standing-weighting is the missing ingredient that makes the [bitemporal-sheaf](/papers/bitemporal-sheaf) transaction-time convergence conjecture true rather than false-in-general.* The formalization is new; the controller and standing function are deployed and queryable today; the steering experiment that would establish the headline claim is specified but **not yet run** — the live genealogy testbed currently carries only 7 argument edges, so the loop is built and barely exercised. That gap is the experiment.

---

## 1. The static-score reading, and why it is a category error

`donto_standing(statement_id)` returns, per claim, the v1 components plus the v2 extensions migration `0166_standing_v2` wired in (`source_policy`, `identity_stability`, `inference_depth`, `review_state`, `downstream_utility`). Read naively, this is a richer confidence score: a claim with high corroboration, low contradiction-pressure, recent belief, mature flags is "trustworthy," and you sort answers by it.

That reading misses what standing is *for*. The canon (`DONTO-CANON.md` §3) frames donto as three compounding loops — **HOLD** (extract/anchor/contest), **JUDGE** (align/identify/review/**stand**), **STEER** (rank what would disambiguate → act → measure → re-rank). Standing is the output of JUDGE and the *input* of STEER. It is not a verdict to be displayed; it is a **set-point the system actively drives toward** by choosing what to observe next. A score is a noun. Standing, used as the canon intends, is the state variable of a verb.

The consequence: the right questions about standing are not "is this score calibrated?" but the questions you ask of any controlled system — **where are its fixed points, does the loop converge, and when does it get stuck in a cycle?** Those questions are unanswerable about a number. They are answerable about a vector field with a controller, which is what the deployed pieces already are.

---

## 2. The model

### 2.1 State

Let `C` be the set of currently-believed claims (`donto_statement` rows with `upper(tx_time) IS NULL`). For a claim `c`, write its standing vector as it stands at transaction-time `τ`:

```
σ(c, τ) = ⟨ m(c,τ),  k(c,τ),  p(c,τ),  r(c,τ) ⟩   ∈  ℕ × ℕ × ℝ≥0 × ℝ≥0
```

with components exactly as `donto_standing` computes them at time `τ`:

| symbol | component | source (verified) |
|---|---|---|
| `m` | maturity | `donto_maturity(flags)` — the E-level (E0…E2 cap) |
| `k` | corroboration | `count(distinct document_id)` over `donto_evidence_link` for the claim's content-hash |
| `p` | contradiction-pressure | `conflict_score` from `donto_paraconsistency_density` for the claim's ⟨subject, predicate⟩ |
| `r` | recency | `(now() − lower(tx_time)) / 86400` days |

Because donto never deletes (invariant **I3** — supersede, never overwrite), `σ(c, τ)` is well-defined at *every* past `τ`, reconstructable from stored rows. This is the property that makes "standing over time" a real trajectory and not a fiction — the same I3 property the [bitemporal sheaf](/papers/bitemporal-sheaf) leans on for its time-indexed stalks. A mutable store could report standing *now*; only a bitemporal, non-destructive store can replay the *trajectory*.

Over a contested subgraph `S ⊆ C` (the claims about one disputed subject — e.g. every attestation of one person's birthplace), the state is the field `Σ_S(τ) = { σ(c,τ) : c ∈ S }`. This is the vector field the title refers to: a standing vector pinned to each node, the whole thing indexed by transaction-time.

### 2.2 The controller (deployed)

The dynamics are not autonomous diffusion — they are *driven by acquisition*. The controller is `donto_suggest_next_evidence(scope, lens, limit)`, deployed and queryable today. It enumerates three kinds of action over the scoped subgraph and ranks them by an explicit priority heuristic (read directly off migration `0156_suggest_next_evidence`):

```
contradiction action:  p·100  +  ln(reach+1)·5  +  fetchability_bonus  +  unreviewed_bonus
obligation action:     priority·20  +  ln(reach+1)·5  +  p·50
identity action:       (1 − |conf − 0.5|·2)·80  +  entity_count·5  +  missing_anchor_bonus
```

Two things matter for the dynamical reading. First, **every term is a function of current standing or its inputs**: contradiction-pressure `p`, subject reach (a proxy for how much the subject's standing matters), identity uncertainty (`1 − |conf − 0.5|·2`, maximized at `conf = 0.5` — the controller seeks the *most uncertain* identity, the textbook active-learning objective). Second, the function already emits an `expected_standing_shift` per action — it is *designed* as a controller that predicts the move it makes to the state field, not merely a to-do list.

### 2.3 The loop

One STEER step is the map `Σ_S(τ) → Σ_S(τ')`:

```
1. RANK    a* = argmax_a  priority(a | Σ_S(τ))          ← suggest_next_evidence
2. ACT     fetch the source a* points at                ← agent / human
3. INGEST  land it as a non-destructive claim + evidence_link + (maybe) argument edge   ← I3-safe
4. MEASURE re-evaluate donto_standing over S            ← Σ_S(τ')
```

Step 3 only ever *adds* rows (new statement, new evidence link, a `rebuts`/`supports` `donto_argument` edge, a `review_decision`). It can lower contradiction-pressure (corroboration arrives, `donto_paraconsistency_density.conflict_score` drops on recompute) or raise it (a fresh dissenting source), and it can raise corroboration and maturity. But it never deletes a prior attestation — so the **trajectory of `Σ_S` is monotone in information even when it is non-monotone in any single component.** That asymmetry is the whole reason convergence is subtle, and §4 turns on it.

---

## 3. The three regimes

A controlled system is characterized by its long-run behavior. Standing-as-dynamics has exactly three, and each names a thing genealogists and the canon already talk about informally.

### 3.1 Fixed points — settled facts

`Σ_S(τ)` is a **fixed point** when `suggest_next_evidence` over `S` returns no action whose `expected_standing_shift` is non-trivial: corroboration is saturated, contradiction-pressure is ~0, no open `donto_proof_obligation`, no candidate `donto_identity_proposal`. The controller has nothing it would acquire because nothing would move standing. *This is what "settled" means, made operational:* not "we are certain" but "no available observation would change our standing." The subject "Caroline Rose Davis's mother is Kitty" approaches this once the parish-baptism corroboration is in and the alternative readings are explicitly ruled out — standing stops moving because the controller stops proposing.

Crucially, a fixed point is **not** zero contradiction-pressure in the *valid-time* sense. Two sources may have disagreed historically; that residue is permanent (I3, and the valid-time `H¹` of the sheaf paper). The fixed point is in *transaction-time*: our **belief** stops moving. This is precisely the sheaf paper's distinction between valid-`H¹` (permanent) and transaction-`H¹` (convergent), read through the standing lens — and the link is not incidental, see §5.

### 3.2 Limit cycles — perennial disputes

A **limit cycle** is a subgraph where standing never settles: each acquired source rebuts the last, contradiction-pressure oscillates, and `suggest_next_evidence` keeps proposing the same contradiction action because every new source raises a new conflict instead of resolving one. The signature in the tables: a ⟨subject, predicate⟩ whose `donto_paraconsistency_density.distinct_polarities ≥ 2` *persists* across recomputes while corroboration on no single polarity ever dominates — and a `donto_argument` neighborhood dense in `rebuts` with no `supersedes` ever firing. (Live, `rebuts` is by far the dominant relation: 2,282 of 2,525 argument edges. *Caveat:* that ratio is dominated by one synthetic context — `ctx:epistemic-sweep` alone holds 2,150 edges — so it is a statement about how the substrate is *structured to hold* conflict, not a measurement of organic dispute. Either way, the machinery to represent a limit cycle exists; whether real corpora exhibit one is §6's experiment.)

The honest point: **a paraconsistent substrate does not promise convergence.** It promises to *hold* the dispute. Whether steering converges or cycles is a property of the *evidence available in the world*, not of donto. Some lineages are genuinely undecidable from surviving records; the loop should *detect* the cycle and report "perennial: bounded evidence, sources disagree, no acquisition would settle it" rather than thrash. Detecting the limit cycle is itself a deliverable — and one only a store that keeps the whole rebuttal history can compute.

### 3.3 Convergence to a fixed point — steering's payoff

The interesting regime: the subgraph *can* be settled by some sequence of acquisitions, and the question is whether the controller reaches the fixed point **faster** than passively ingesting whatever shows up. This is the headline claim, and §4 states it precisely.

---

## 4. Convergence conditions and the central claim

### 4.1 Why steering should beat passive accumulation

Passive accumulation ingests sources in arrival order; steered acquisition ingests them in `suggest_next_evidence` priority order. Both reach the same fixed point *if the decisive source is eventually acquired* — the difference is **time-to-resolution**: the number of acquisitions until `Σ_S` first reaches the fixed point.

The intuition is active-learning's: the controller's identity term `(1 − |conf − 0.5|·2)·80` and contradiction term `p·100` both target *maximum-uncertainty* observations, which are the ones that most reduce standing variance per acquisition. Under the natural assumption that the decisive source (a marriage certificate naming both spouses' parents — "anchors ~3 generations") exists in the fetch frontier, prioritizing high-contradiction-pressure / maximum-identity-uncertainty actions front-loads the decisive acquisition.

> **Conjecture (steering speedup).** On a contested subgraph that is *resolvable* (a fixed point is reachable), expected time-to-resolution under `suggest_next_evidence`-ordered acquisition is strictly less than under arrival-ordered acquisition, with the gap growing in the subgraph's contradiction density `p` and its identity uncertainty.
>
> **Failure mode (named).** The conjecture is *false* when the controller's priority is anti-correlated with which acquisition is actually decisive — e.g. if high contradiction-pressure is generated by an adversarial source flooding low-value rebuttals (the `donto_argument` `rebuts` bias becomes an attack surface), the controller chases noise and steering can be *slower* than passive. This is the standing analogue of the sheaf paper's deceptive-source failure, and it is why §4.2 needs a trust model.

### 4.2 The condition that rules out the failure: standing-weighting

The failure mode above is exactly an *unweighted* controller treating every rebuttal as equally informative. The fix is the component v1 deliberately ships and v2 extends: weight contradiction-pressure and corroboration by **source standing**, so a rebuttal from a low-corroboration, low-maturity, unreviewed source moves the controller less than one from a corroborated, reviewed source. `donto_standing` already exposes the inputs (`corroboration`, `review_state`, `downstream_utility`); the controller's heuristic does **not** yet consume source standing — its terms are raw `conflict_score` and `priority`. Closing that gap is the concrete next build.

This is the same condition the bitemporal-sheaf paper arrived at from the other side. That paper conjectured transaction-time `H¹` is non-increasing under monotone evidence accrual, and flagged that it is *false in general without a trust model on sources* — "you cannot converge on truth without weighting sources." Standing **is** that trust model. So:

> **Bridge conjecture.** Standing-weighting of the STEER controller is the *necessary condition* that makes the bitemporal-sheaf transaction-`H¹` convergence conjecture hold: with source-standing weights, monotone evidence accrual drives transaction-`H¹` down (belief converges); without them, an adversarial source can raise it without bound. The two papers' open conjectures are the same conjecture viewed as a flow (sheaf) and as a controller (standing).

If true, this unifies the two theory papers under one mechanism and tells the build order: ship standing-weighting in the controller *before* trusting either convergence claim.

---

## 5. Why only donto can pose this

The model needs four things at once, and donto is where they co-exist:

| requirement | donto provides it | verified |
|---|---|---|
| standing as a live, multi-component, replayable state | `donto_standing` fn (migrations `0151_standing_v1`, `0166_standing_v2`) | function deployed in `donto-pg` |
| a controller that ranks the next observation by expected standing shift | `donto_suggest_next_evidence` fn (migration `0156`) | function deployed; emits `expected_standing_shift` |
| a contradiction-pressure signal to drive the loop | `donto_paraconsistency_density.conflict_score` | 235,032 rows, all with `distinct_polarities ≥ 2`, `max conflict_score = 1.00` |
| non-destructive ingest so the trajectory is real, not overwritten | invariant I3; supersede-not-delete | every component computable at any past `tx_time` |

No collapse-on-conflict store can pose the *cycle* question (it deleted the losing claim, so there is no oscillation to observe) or the *trajectory* question (it overwrote the past states). A vector DB has no contradiction-pressure to drive a controller. donto has all four as deployed tables and functions — which is why this is donto's paper to write, and why the experiment is *runnable on the live box*, not a simulation.

---

## 6. The experiment that would establish the headline claim

The genealogy program is the canon's designated testbed: every research loop already ends with a hand-written "decisive next action" list (order this certificate, open that register, test this filiation). That hand-ranking is `suggest_next_evidence` done by an agent ad hoc. The experiment formalizes it and measures the speedup.

**Design.** Take three real contested subjects the program already works: the Kitty disambiguation (at least 16 distinct women named some variant of "Kitty" catalogued in `genes/native-title/eky-apicals-resources/kittys-disambiguation.md`, with explicit anti-merge/merge findings — a textbook identity-resolution loop); Val's Mauritius apex couple (Poitevin × Collinson, `research/val-poitevin-collinson-mauritius/`); and the Coen-vs-McIvor birthplace contradiction (the canonical worked dispute, also Example B of the [bitemporal sheaf](/papers/bitemporal-sheaf) paper). For each:

1. **Build the contested subgraph in the substrate** — land every attestation as a claim with evidence links, add the `rebuts`/`supports` `donto_argument` edges, recompute `donto_paraconsistency_density`. (This is the prerequisite that is *missing today*: genealogy contexts carry only **7** `donto_argument` edges total — the disputes live in prose, not yet as substrate state. Loading them is step 0.)
2. **Two arms, same fetch frontier.** *Steered:* acquire sources in `suggest_next_evidence` priority order. *Passive:* acquire in arrival/chronological order. Both draw from the identical set of fetchable sources.
3. **Measure time-to-resolution** = acquisitions until `Σ_S` reaches a fixed point (controller proposes no non-trivial action), and **show the standing shift with receipts** — before/after `donto_standing` per claim, exactly the canon's "show the standing shift" demo.

**What each outcome means.**
- Steered < passive on resolvable subjects → the speedup conjecture holds; report the gap vs contradiction density.
- Steered ≈ passive → steering is *not* paying off on this corpus; an honest negative — likely the frontier is too small for ordering to matter, or the controller needs standing-weighting (§4.2).
- A subject where neither arm settles → a detected **limit cycle**; report it as "perennial: bounded evidence" — itself a result (the substrate correctly recognizes an undecidable lineage instead of forcing a winner).

A sharp negative here (steering doesn't help) is worth more than a vague positive: it would say the controller's *ordering* is not the bottleneck — *acquisition* is — which redirects the whole STEER program.

---

## 7. Status: proven / conjectured / speculative

- **Deployed / measured (solid).** `donto_standing` and `donto_suggest_next_evidence` are live functions in `donto-pg`; standing v1 = ⟨maturity, corroboration, contradiction-pressure, recency⟩ is computable per claim from existing tables; the controller's priority heuristic and `expected_standing_shift` output are as quoted from migration `0156`. Live substrate state (queried 2026-06-13): 2,525 `donto_argument` edges (2,282 `rebuts`, but 2,150 of all edges sit in the synthetic `ctx:epistemic-sweep`), 235,032 `donto_paraconsistency_density` rows (all `distinct_polarities ≥ 2`, `max conflict_score = 1.00`), ~2.8M `donto_evidence_link`, 1,240 `donto_proof_obligation`, 169 `donto_identity_edge`.
- **Conjectured (open, failure mode named).** The steering-speedup conjecture (§4.1) and the bridge conjecture that standing-weighting is the necessary condition for transaction-`H¹` convergence (§4.2). The named failure mode is an adversarial `rebuts` flood against an *unweighted* controller — and the controller is unweighted today (its terms use raw `conflict_score`/`priority`, not source standing), so closing that gap is a prerequisite to even testing the conjecture honestly.
- **Defined, not yet run (the experiment).** The §6 three-subject steered-vs-passive trial. The blocker is concrete and small: genealogy contexts hold only **7** argument edges — the disputes are in prose, not substrate state — so step 0 is loading them. Until then the loop is *built and barely exercised*; this paper is the spec for exercising it.
- **Speculative (flagged).** That the fixed-point / limit-cycle classification of a corpus is itself a *historiographic* instrument — that the set of subjects which provably limit-cycle (bounded evidence, persistent `distinct_polarities ≥ 2`) is a map of what the surviving record can and cannot decide. Worth measuring once the subgraphs exist; no claim yet.

---

_See also: the convergence flow this controls, [The Bitemporal Sheaf](/papers/bitemporal-sheaf) (the bridge conjecture says these two are one mechanism); the empirical lever standing feeds, [Answer-Shaping](/papers/answer-shaping) (contradiction-pressure is a shape-routing signal); the full program in the [donto research agenda](/papers/research-agenda)._