CatQualia/bridge-ledger

Bridge Ledger

BRIDGE_LEDGER.jsonl — 43946441 B, 171822 lines, 171822 parsable rows. Each row is a verdict on one pair of research documents: do these two share more distinctive structure than a random pair of documents does, or is the resemblance an artefact of metaphor?

What a "bridge" is in this system

A bridge is a candidate pairing of two research tracks, written (A, B). The pairing is proposed upstream by a cross-pollination step (a generator that deliberately pairs distant domains). The ledger records a discriminator adjudicating that proposal.

The mechanism is defined in bridge_discriminator.py, shipped alongside this dataset. In that implementation:

1. Candidate generation. Each ACTIVE line of EXPANSION_CANDIDATE_LOG.md names a parent track and one or more backticked track names. Each such pair becomes a candidate bridge. The pair is stored with a < b lexicographically, so the pair is unordered.
2. Document loading. Each track resolves to reports/research_campaigns/<track>.md. Documents under 20,000 bytes, and a fixed list of meta-documents, are excluded.
3. Tokenisation. Text is lowercased, restricted to [a-z]{4,}, and stop-word filtered.
4. Distinctive sets. For each document the top 40 tokens by tf * log(N/df) are kept — frequent in the document, rare across the corpus. This is the step that makes the comparison about signature vocabulary rather than shared English.
5. Two similarity measures.
   • coherence — FHRR-style phase alignment: each distinctive token is mapped to a 1024-dimensional complex phasor seeded by sha256(token), the phasors are bundled and magnitude-normalised, and two documents are compared by |⟨a,b⟩| / 1024.
   • overlap — plain Jaccard similarity between the two distinctive-token sets.
   • score = 0.5 * coherence + 0.5 * overlap.
6. Null distribution. 800 random track pairs are scored the same way; the 95th percentile and the mean of that null become null_p95 and null_mean, stored on every row.
7. Verdict rule. REAL-BRIDGE if score > null_p95; PUN if score <= null_mean; AMBIGUOUS otherwise. This rule holds exactly across the whole file: all 33602 REAL-BRIDGE rows satisfy score > null_p95, with zero exceptions.

So a verdict means: this pairing's distinctive vocabulary either separates from a random-pairing baseline (REAL-BRIDGE), fails to separate at all (PUN — the proposed isomorphism is treated as a plausible-sounding pun rather than a structural match), or lands in between (AMBIGUOUS). The design intent stated in the script is that PUN bridges are discarded before they consume further research effort.

A file called BRIDGE_FROM_OPUS.md was briefly included in this repository and has been removed. It was not a description of the bridge mechanism: it was an inter-agent coordination memo between two autonomous instances sharing one filesystem, and it documented work allocation, crash-safety protocol, backup file paths, and an unreleased publishing plan. None of that belongs in a dataset about structural-overlap scoring. It is retained locally as part of the author's own record and is not republished.

This is recorded rather than silently corrected, because a dataset is only as trustworthy as its provenance decisions, and this one was wrong.

Schema

One JSON object per line, 9 fields on every row:

field	type	rows containing it
a	str	171822
b	str	171822
score	float	171822
coherence	float	171822
overlap	float	171822
null_mean	float	171822
null_p95	float	171822
verdict	str	171822
method	str	171822
ts	str	171822

method is constant across the file:

method	rows
structural-overlap-vs-null	171822

ts	rows
2026-06-20	171822

Categorical values and counts

verdict, over all 171822 rows:

verdict	rows
AMBIGUOUS	72635
PUN	65585
REAL-BRIDGE	33602

Numeric spread: score ranges 0.0011 to 0.2185 (mean 0.0376, median 0.0224). null_mean ranges 0.0177–0.0201; null_p95 ranges 0.0382–0.0500.

Structure of the file — read this before sampling

171822 rows encode only 42 distinct (a, b) pairs, across 19 distinct a values and 25 distinct b values. Each of the 42 pairs appears exactly 4091 times. The ledger is append-only: the discriminator is re-run as the underlying research corpus grows, and each run re-appends a full copy of every verdict.

The rows are therefore not independent observations. 42 distinct configurations are recorded, each replicated 4091 times; the repetition counts appended lines, not additional evidence. Training on the raw file without grouping will massively overweight whichever pairs happen to be present, and evaluation splits made by row will leak identical rows across the split.

What genuinely varies between repeats of the same pair is the two null statistics — the corpus changes, so null_mean and null_p95 shift, and a pair sitting near the boundary can change verdict across repeats. There are 21 distinct (null_mean, null_p95) combinations in the file, which approximates the number of distinct corpus states the discriminator ran against. Example: one pair is REAL-BRIDGE in 4063 of its 4091 repeats and AMBIGUOUS in the other 28 — the same documents, adjudicated under a slightly different null.

ts does not help: every row carries the hardcoded string 2026-06-20.

The 12 most-repeated pairs, each appearing 4091 times:

repeats	a	b
4091	honest_sub1b_context_extension	yarn_longrope_context_extension
4091	random_baseline_sanity_protocol	self_improvement_apophenia_guard
4091	loop_ingest_collapse_tripwire	machine_barnum_benchmark
4091	constitution_as_validity_gate	machine_barnum_benchmark
4091	honest_sub1b_context_extension	sink_reliability_sub200m
4091	effective_resistance_unifying_scalar	hj_ranked_token_selection
4091	position_encoding_repair_small_model	streamingllm_sinks_t0
4091	cmaes_evolutionary_model_merge	hj_scg_universal_gate
4091	position_encoding_repair_small_model	sink_reliability_sub200m
4091	honest_sub1b_context_extension	honesty_floor_360m_benchmark
4091	honesty_floor_360m_benchmark	position_encoding_repair_small_model
4091	position_encoding_repair_small_model	slime_mold_dataflow_vosc

Highest-scoring rows

a ~ b	score	coherence	overlap	verdict
honest_sub1b_context_extension ~ yarn_longrope_context_extension	0.2185	0.2605	0.1765	REAL-BRIDGE
honest_sub1b_context_extension ~ yarn_longrope_context_extension	0.2185	0.2605	0.1765	REAL-BRIDGE
honest_sub1b_context_extension ~ yarn_longrope_context_extension	0.2185	0.2605	0.1765	REAL-BRIDGE
honest_sub1b_context_extension ~ yarn_longrope_context_extension	0.2162	0.2559	0.1765	REAL-BRIDGE
honest_sub1b_context_extension ~ yarn_longrope_context_extension	0.2162	0.2559	0.1765	REAL-BRIDGE

What a record asserts, concretely

A row states: documents a and b were tokenised with this procedure, their top-40 distinctive tokens scored by phase alignment and Jaccard, and the combined score was compared against a null built from 800 random pairs; the outcome was at threshold null_p95 = <value>.

It does not assert that the two domains are genuinely analogous in any scientific sense. The measure is a lexical-structural proxy over distinctive vocabulary. Two documents that happen to name the same specialised machinery score higher regardless of whether the analogy is sound, and the ledger's own AMBIGUOUS band — 72635 rows, the largest class — is where that ambiguity is honestly recorded rather than resolved.

Limitations and verification status

• Self-adjudicated. The verdicts are produced by the author's script, on the author's documents, against a null drawn from the same corpus. No external party regenerated them. Reproduction requires the source documents, which are not included here.
• Not a semantic judgement. No human or model rated the analogies. coherence is a phase-alignment over hashed token identity, not a meaning similarity.
• Small support. 19 × 25 names resolve to 42 actual pairs. The file carries far less information than its row count suggests.
• Distance is not controlled. The generator picks distant-domain pairings, but nothing in the ledger records or checks domain distance, so "cross-domain" is an upstream intent, not a measured property of any row.
• The null is a random-pair null, not a distance-matched null. Pairs selected to be maximally distant are compared against uniformly random pairs; a matched-null design would be needed to claim the separation is due to the specific pairing rather than to the selection procedure.
• bridge_discriminator.py writes a hardcoded ts and appends without deduplication, which is the direct cause of the duplication described above.

How this was measured

wc -l < BRIDGE_LEDGER.jsonl            # 171822
python3 -c "import json;[json.loads(l) for l in open('BRIDGE_LEDGER.jsonl') if l.strip()]"   # all 171822 rows parse
python3 -c "
import json,collections
rows=[json.loads(l) for l in open('BRIDGE_LEDGER.jsonl') if l.strip()]
print(len(rows), len(set(tuple((r['a'],r['b'])) for r in rows)))
print(collections.Counter(r['verdict'] for r in rows))
"

Files

• BRIDGE_LEDGER.jsonl — 43946441 B, 171822 rows (42 distinct pairs).
• bridge_discriminator.py — the script that produced the ledger, 7243 B.

Licence

CC-BY-4.0 — attribution required, commercial use permitted.

Copyright 2026 Christopher Betances (catqualia.com)