Cycle contradictions: the conflicts pairwise edges cannot see

donto papers · original research · 2026-06-13 · theory + census, working draft v1

Abstract. Contradiction in a knowledge base is almost always modeled as a binary relation: claim A rebuts claim B, stored as one edge. donto stores exactly this — donto_argument holds 2,525 such edges, 2,282 of them rebuts (2,150 concentrated in ctx:epistemic-sweep/contradictions). But many of the contested-knowledge errors that matter in our corpus are not two claims that explicitly negate. They are cycles of individually-defensible claims whose composition around a loop is impossible — a person recorded as both the daughter of and the spouse of the same generational position, where no single claim is wrong and no single pair contradicts, yet the loop cannot close. A pairwise edge model is structurally blind to these: there is no privileged source→target pair to attach a rebuts edge to, so none is ever written, so the conflict is invisible to every consumer that reads donto_argument. We make the claim precise, prove why the blindness is structural (a product of positive scalar maps around any loop is a positive scalar — a d=1 scalar restriction map cannot carry a non-trivial 1-cocycle, ever), and show that cellular-sheaf cohomology with d≥2 sign-carrying maps detects and localizes the loop as a non-zero holonomy ‖H_cyc − I‖_F. The detector math is built and unit-tested (packages/donto-sheaf, Case-A/Case-B fixtures green, no DB). What is not done — and is the honest center of this paper — is the census: how many real cycle-contradictions live in the genealogy corpus that no pairwise method flags. We give the worked Kitty example from live ex:kitty rows, the exact census procedure, the lift metric that makes a result honest, and a negative we already expect (most of the live conflict frontier is single-(subject,predicate) polarity clashes that pairwise methods do catch — the cohomological upgrade pays off precisely on the long tail it adds, and the paper's job is to measure how long that tail is).

1. The shape of the error pairwise edges miss

A pairwise contradiction edge encodes "these two claims cannot both hold." It is the right tool for a polarity clash: bornAt Coen vs bornAt McIvor, same subject, same predicate, two incompatible objects. donto already detects these — donto_paraconsistency_density materializes 235,032 (subject, predicate) rows with distinct_polarities ≥ 2, and the rebuts edges in donto_argument are the explicit pairwise record of that family.

But consider three claims, each individually attested and individually fine (all are live ex:kitty rows):

No two of these contradict. There is no (subject, predicate) polarity clash — each predicate is distinct. There is no pair to which a rebuts edge attaches. Yet add the generational and kinship constraints the predicates carry — a daughter is one generation below her father; a mother is one above her child; a spouse is the same generation — plus a loop-closing chord from a second source (Caroline's father is the same Mick that Kitty married, or the Duke-of-York father line and another attested father line resolve to one person), and the loop closes into an impossibility: Kitty would sit in two incompatible generational positions at once. This is the real disambiguation problem behind the live ex:kitty junk-drawer URI, which holds — simultaneously, all as live upper(tx_time) IS NULL rows — isMotherOf ex:caroline-rose-davis (×7), is1907WifeOf ex:mick (×2), daughterOf ex:duke-of-york, and two distinct fathers, hasFather ex:bobbie and hasFather ex:buiku-buiku: a single symbol that cannot be one person.

The error is a cycle, not an edge. It lives in the composition of typed relations around a loop, not in any pair. That is the conflict class this paper is about.

The claim. A material share of high-value contested-knowledge errors in a contradiction-preserving store are cycle-inconsistencies of individually-fine claims, not pairwise negations. Pairwise donto_argument cannot represent them (a cycle has no privileged source→target pair); the sheaf 1-cocycle (H¹ around the loop) detects and localizes them. The value of the upgrade is exactly the count of such loops a pairwise method misses — the census this paper specifies and has not yet run.

2. Why the blindness is structural, not an implementation gap

It is tempting to think a smarter pairwise pass — transitive closure over rebuts, or a rule deriving an edge from daughterOf + spouse — would catch the loop. It would not, for two distinct reasons.

2.1 There is no edge to write. donto_argument is binary by constraint: CHECK (source_statement_id <> target_statement_id), open-uniqueness on (source, target, relation, context). A cycle conflict over {A, B, C} has no privileged ordered pair — picking any one (say A→B) is arbitrary and lossy: it asserts "A rebuts B," which is false (A and B are individually compatible; only the loop is bad). A faithful pairwise encoding therefore does not exist. The N-ary conflict's only honest home is a cluster record — exactly the donto_sheaf_cocycle + donto_sheaf_cocycle_member tables in migration 0179, with an optional, off-by-default, explicitly-lossy cycle_inconsistent star shadow (migration 0180) for consumers that can only read pairwise. That shadow is intentionally invisible: every live pressure consumer filters relation IN ('rebuts','undercuts'), so cycle_inconsistent never leaks into a binary-shaped reader.

2.2 The one hard correctness fact: d=1 maps cannot carry a cocycle. Even if you tried to detect the loop by propagating a value around it (a transport/holonomy view), a scalar model is provably blind. Model each typed relation as a restriction map between the two claims' stalks. If the stalks are one-dimensional (d=1) and the maps are positive scalars σ_e > 0, the holonomy around any cycle is

H_cyc = σ_{e_k} · … · σ_{e_2} · σ_{e_1}   ∈  ℝ_{>0}

— a product of positive scalars is a positive scalar, conjugate to the identity in the scaling group: there is no non-trivial 1-cocycle, ever, regardless of the loop. A d=1 detector reports H¹ = 0 on the Kitty loop. This is not a tuning failure; it is the algebra. To make a loop's holonomy able to be non-identity you need (i) d ≥ 2 stalks so the maps live in a non-abelian group, and (ii) sign- or orientation-carrying maps, so a disjointness relation (daughterOf ⊥ spouseOf) contributes a reflection/sign-flip that does not cancel around the loop.

This is why donto's Stage-0 sheaf math (packages/donto-sheaf/src/lib.rs) ships RestrictionMap::identity(d, w) as the default d≥2 path and RestrictionMap::scalar_fallback(w) as a never-flagged d=1 fallback whose doc comment states the reason verbatim: "By construction its loop holonomy is a positive scalar ⇒ never a cocycle." The crate's Case-B test asserts both directions on the same loop — the signed d=2 path gives residual_norm > 1e-3, the d=1 scalar path gives obstruction 0. A Stage-0 that shipped d=1 as primary would not recover the very Kitty cycle it claims as its headline. The blind spot is in the representation, and only a d≥2 sign-carrying representation removes it.

3. The detector, concretely

The mechanism (specified in the sheaf build spec, Stage-0; implemented in packages/donto-sheaf):

1. Scope a bounded subgraph (≤ ~500 statement-nodes) around a contested entity or the high-conflict frontier. Never the global graph (donto_statement ≈ 42,018,816 rows — sheaf Laplacians are heavier than graph Laplacians; the global sheaf is an open problem, not attempted here).
2. Assign d=2 value-indexed stalks: distinct attested object values index orthogonal basis axes (the report's Coen=(1,0), McIvor=(0,1) construction), polarity-signed.
3. Build restriction maps from learned signals only — donto_predicate_closure.confidence, donto_argument.strength, donto_identity_edge.confidence. The relation value only caps magnitude and assigns the orientation sign (a disjointness/inverse relation contributes the flip). No hand-maintained predicate→weight table, no synonym list, no if/elif over predicate names — that would be exactly the brittle logic the canon forbids.
4. Spanning-forest cycle basis. Each non-tree edge closes one fundamental cycle; there are |E| − |V| + #components of them — a minimal independent generating set of H¹. We never enumerate all simple cycles (exponential). For each, compose the signed maps around the loop and measure ‖H_cyc − I‖_F (holonomy_frobenius in the crate). Non-zero ⇒ a localized 1-cocycle; the member set is the loop's statements — the localization the pairwise layer cannot give.
5. Filter before flagging: stalk_dim ≥ 2 (never flag the d=1 fallback), obstruction above an empirical floor (a fixed cold-start until enough prior runs calibrate it), a max_cycle_len cap, and — critically for the census — skip any loop already covered by a single pairwise rebuts/undercuts edge among its members, because that conflict is already visible to the pairwise layer. The sheaf's contribution is exactly the loops that survive this filter.

That last filter is the empirical question of this paper made operational: a cycle-contradiction "counts" toward the cohomological upgrade only if no pairwise edge already fires inside it.

4. The census: the to-be-done part (stated honestly)

The detector math exists; the census does not. The Stage-0 migrations are written and committed — 0178_sheaf_pressure.sql, 0179_sheaf_cocycle.sql, 0180_sheaf_argument_relation.sql, 0181_standing_sheaf_pressure.sql, all under packages/sql/migrations/ — but not yet applied to live donto-pg: SELECT tablename FROM pg_tables WHERE tablename LIKE 'donto_sheaf%' returns zero rows today, and the analyzer driver (donto analyze sheaf-h1, analyzer_sheaf) is still in build. So everything in this section is a specified experiment, not a result. We refuse to report a census number we have not measured (cf. the answer-shaping note on measuring the plumbing before the hypothesis).

4.1 The procedure

1. Apply migrations 0178–0181 — the pressure table, the cocycle cluster + member tables (with the donto_assert_sheaf_cocycle function), the optional cycle_inconsistent relation, and the dark-by-construction donto_standing re-point (sheaf-first contradiction pressure with the live paraconsistency value as COALESCE fallback, so it is inert while the sheaf table is empty).
2. Run donto analyze sheaf-h1 over a battery of scopes: each contested-entity neighbourhood in the genealogy corpus (Kitty, Caroline, the EKY apical set), plus the HighConflictFrontier seed.
3. For every flagged cocycle, record (member statement_ids, residual_norm, member_count) and the boolean pairwise_visible = "does any rebuts/undercuts/supersedes edge in donto_argument connect two members?"
4. The census number is |{ cocycles : pairwise_visible = false }| — cycle-contradictions that no pairwise method flags — with the residual-norm distribution and the per-entity breakdown.

4.2 What a result would establish — and the metric that makes it honest

The headline metric is the cohomological lift ratio:

lift = (# cycle-conflicts with pairwise_visible = false)
       ─────────────────────────────────────────────────
       (# pairwise contradiction edges, donto_argument rebuts/undercuts)

A lift materially above 0 quantifies the upgrade: that fraction of real conflict is only visible cohomologically. A lift ≈ 0 would be an honest negative — the corpus's contestation is overwhelmingly pairwise-shaped and the sheaf buys little on this corpus (while remaining the only correct representation for whatever loops do exist). Either way the number is the contribution.

4.3 The negative we already expect

We will not pretend the census will be flattering everywhere. The live high-conflict frontier is dominated by single-(subject,predicate) polarity clashes — the 235,032 donto_paraconsistency_density rows with distinct_polarities ≥ 2 are pairwise-shaped by construction, and the skip-if-pairwise-rebutted filter will correctly discard them. So the census's real yield should be the genealogy junk-drawer entities — the ex:kitty-class symbols that have accreted dozens of incompatible kinship roles (isMotherOf ×7, is1907WifeOf ×2, daughterOf, two distinct hasFather) and carry no rebuts edge anywhere. The honest prediction: cycle-conflicts will be rare relative to polarity clashes, but concentrated exactly where pairwise methods are blind and disambiguation matters most — the contested-identity entities the genealogy consumer exists to resolve. Measuring that concentration, not maximizing a count, is the point.

4.4 A second honest risk

There is a real chance the diagonal d=2 maps do not fire on the live corpus even though the fixture passes, if the daughter-of⊥spouse-of disjointness is fundamentally off-diagonal (a permutation / O(d) structure the diagonal family cannot express). The crate's Case-B fixture proves the math on a constructed loop; the real-corpus run is the true gate, and if diagonal fails we promote orthogonal/connection maps before claiming recovery. We do not ship the claim on the fixture alone.

5. Worked example: the Kitty loop, end to end

Using live ex:kitty rows:

• A = ex:kitty isMotherOf ex:caroline-rose-davis — implies Kitty is generation g, Caroline g+1.
• B = ex:kitty daughterOf ex:duke-of-york — implies Kitty is g, her father g−1.
• C = ex:kitty is1907WifeOf ex:mick — implies Kitty same generation as Mick.
• Closing chord (supplied by a second source or an identity hypothesis): ex:caroline-rose-davis hasFather ex:mick, placing Mick simultaneously at g (Kitty's spouse) and at Caroline's-father position — which, folded against the daughter/mother chain, forces Kitty into two incompatible generational slots at once.

Pairwise view: zero rebuts edges among {A, B, C, chord}. Each is individually attested and individually consistent. donto_argument is silent. donto_paraconsistency_density shows no (subject,predicate) clash because every predicate differs. The error is invisible.

Sheaf view: with d=2 stalks (generation axes) and signed restriction maps (the spouse/daughter/mother relations carry the generational offset; the disjointness daughterOf ⊥ spouseOf carries the sign flip), the composed holonomy around A→B→C→chord→A is not the identity: ‖H_cyc − I‖_F > floor. The detector returns one Cocycle whose member set localizes the conflict to exactly {A, B, C, chord}, and donto_assert_sheaf_cocycle records it as an N-ary cluster — never a fake pairwise edge. This is the crate's Case-B fixture; running it on these real rows is the corpus gate of §4.4, not yet done.

The payoff is operational: the genealogy researcher gets "these four claims cannot all describe one person — here are the four" automatically, where today that loop is hand-detected (the live notes already flag ex:kitty as a junk-drawer URI that may split into two people). The sheaf turns hand-detection into a localizable computation.

6. Why only donto can run this census

The census needs three things at once — donto's three foundational invariants:

A collapse-on-conflict KB cannot run this census at all: it would have deduped or winner-picked the incompatible kinship roles at ingest, deleting the very loop the census counts. donto holds all of them — ex:kitty carries seven isMotherOf and two is1907WifeOf rows at once — which is precisely what makes the cycle detectable later. The census is a measurement only a paraconsistent, non-deleting, abundance-native store can produce.

And the comparison is fair and adversarial: donto runs the pairwise detector and the cohomological detector over the same scoped subgraph, and reports the loops the pairwise one missed. It is donto demonstrating its own blind spot and then closing it — the honest way to quantify an upgrade.

7. Status: proven / conjectured / speculative

• Proven (built + tested, no DB). The d=1-cannot-carry-a-cocycle correctness fact (§2.2) and its consequence that d≥2 sign-carrying maps are mandatory; the holonomy detector and fundamental-cycle localization (packages/donto-sheaf, holonomy_frobenius + analyze); the Case-A (H¹ norm √2) and Case-B (Kitty loop residual_norm > 1e-3, localized; d=1 scalar path → 0) fixtures pass as pure unit tests independent of Postgres. The structural argument that a cycle conflict has no faithful pairwise encoding (§2.1) follows from the donto_argument binary constraint. The cluster tables and assert function exist as committed migrations 0178–0181 (written, not yet applied to live).
• Conjectured (open, failure mode named). That cycle-contradictions are a material fraction of real contested-knowledge error in the genealogy corpus. Failure mode: the census returns lift ≈ 0 because contestation is overwhelmingly single-(subject,predicate) polarity clashes that pairwise methods already catch (§4.3) — an honest negative we'd report as "the sheaf is the correct representation but the corpus rarely needs it." Resolving the conjecture requires the deployed run; we will not assert a census number before measuring it.
• Speculative (flagged). That diagonal d=2 maps suffice on the live corpus (§4.4); the disjointness structure may demand orthogonal maps — fixture-pass does not imply corpus-pass. Also speculative: that the per-entity cocycle count is itself a useful disambiguation signal (an entity whose neighbourhood carries many independent cocycles is a candidate to split into multiple people — the ex:kitty→two-people hypothesis as a query, not a hand-judgment). Worth measuring once the census exists; no claim yet.

The detector is Stage-0 of the sheaf program. The census is the paper — and it is the part still to do.

See also: the theory companion The Bitemporal Sheaf (the cohomology, generalized over both time axes); the build spec and literature grounding in sheaf neural networks for donto; the empirical sibling Answer-Shaping on measuring before claiming; Standing dynamics (which consumes the contradiction pressure this detector feeds); the full program in the donto research agenda.