[ ✦ ] JOSH & RIN / LAB← All experiments

05 / The Goblin Cycle Lab · 2026-10-26 · Finite synthetic experiment

The goblins found a liar.
Then they framed an innocent one.

Four villages, each with its own private alphabet. Six messengers translate between them. The auditor knows none of the real meanings—only what the messengers claim. It still catches one bad link. Then two bad links produce a perfectly convincing accusation against a third, innocent messenger.

768 / 768Correct diagnosis and exact repair, given one corrupted link
11 / 768Two-fault trials that falsely accused an untouched link
0 / 768Alarms when three channels were relabeled coherently

Workbench · the messengers are synthetic

Change the rules. Watch certainty break.

No neural models, real languages, remote APIs or personal information are involved.

Select the situation

The lines represent reversible mapping tables. Gold indicates the auditor's conditional suspect—not necessarily an actual error. Reveal the oracle to distinguish the two.

Observed linksAuditor suspectActually altered (oracle only)

The blind auditor's verdict

—Failed / available triangles
—Possible culprit links
—Conditional accusation
—Failed loops after repair

The triangles

Does the roundabout route agree?

We compare the direct translation table with the composition of two others, symbol by symbol. A failed triangle proves disagreement, not who caused it.

Inspect a messenger

Which glyph does it claim?

These are meaningless integer glyph IDs, not words.

🎪 Reveal the oracle: who was actually wrong?

The result / no authority costume

One broken translator. Perfect recovery.

Every goblin village owns an independently shuffled alphabet of 8, 16, or 32 symbols. All six pairs of villages have reversible translation tables. In the single-fault setting, exactly one messenger's table has two output glyphs swapped. The auditor never sees the true alphabets: it checks only agreement between three-leg loops.

In a fully connected four-village network, one broken link makes precisely two triangle checks fail. Those triangles intersect at a unique edge. The other paths reconstruct that table. Across 256 fixed seeds × 3 vocabulary sizes, all 768 single-error trials were diagnosed and repaired exactly.

Two broken translators. One imaginary culprit.

Then we planted two independent output swaps. Most cases resisted a single-fault explanation, but 11 of 768 produced a disturbingly tidy false story: the auditor blamed an unchanged link, another path-based check agreed, and changing that innocent link made every cycle pass. The number of wrong links rose from two to three. The repair made the situation worse while satisfying its own consistency test.

Press “Frame the innocent goblin.” At seed 40 with eight glyphs, the actual altered links are A–C and B–C. The auditor nominates C–D, which was originally correct. Its proposed correction gives you zero failed triangles and three wrong links. The oracle is separate from the auditor's inputs.

And there are failures you cannot even notice.

Three villages

One bad triangle, three suspects.

With only a single triangle, no edge is uniquely responsible. The auditor returns “ambiguous.”

Coordinated rewrite

Three altered links, no alarm.

Consistently relabel every link touching one village and all triangles close. Agreement between messages is not verification of their meaning.

What this is—and what it isn't.

This is a synthetic finite permutation-network experiment, not an AI-language discovery, an attack on real systems, or evidence about intentions. The wrong-link diagnosis depends explicitly on the assumed error budget. The displayed frequencies describe 4,608 deterministic generated cases (six conditions, three alphabet sizes, 256 seeds), not estimated real-world probabilities. We do not claim to have invented graph cycle consistency.

Code, reproducible generation protocol, per-case results and source receipts: public experiment folder. This HTML runs entirely in the browser with no tracking or network calls. Background: Lerman & Shi (2022), Robust Group Synchronization via Cycle-Edge Message Passing.

Method, independent checks, failed assumptions and reproduction instructions →