Three ways to answer

The wrapper’s whole architecture fits in one sentence: parse the prompt into a typed task, then either prove the answer, recognize it, or admit you can’t.

Prove it (teal). A lot of BBH is secretly deterministic. multistep_arithmetic_two is a parenthesized integer expression — you don’t need a 1.7B transformer to “reason” about ((6 * -6 * 8) * (-1 * 7 * -6 + -2)), you need an AST and Python. dyck_languages is a bracket stack. tracking_shuffled_objects is replaying a list of swaps. web_of_lies is propagating truth values down a chain. For these, Turnstyle parses the prompt into a structured form, runs an exact solver, and then biases the model’s generation toward the proven answer with a logit constraint — so the model still produces the text, but it can no longer wander off the correct token. These are the bars that hit 100%, and they hit it because a proof is a proof.

Recognize it (purple). Some tasks aren’t computable from the prompt — they need a judgment the model actually holds but won’t say. snarks (which of two sentences is sarcastic) is the cleanest example: three-shot, SmolLM2 scores 46% — below chance for a binary task. It has strong, confident, wrong opinions. But the judgment is in there: train a small linear probe on the model’s hidden state at the right layer and read the answer directly off the activation, and it goes to 100% in-sample / 74% cross-validated. Same for pronoun disambiguation, temporal ordering, humorous-name edits. The model knows; generation was the bottleneck.

Admit the wall (grey). Two tasks don’t move at all: causal_judgement and sports_understanding. These are knowledge-loaded — they turn on facts and judgments a 1.7B model trained on a modest corpus may simply not have, and a probe on its hidden state does no better than guessing the majority class. The honest move is to detect that there’s no signal to extract and fall back to the bare model rather than fabricate a solver that overfits 250 examples. The two grey bars are a feature: they’re where the system correctly declines to pretend.

That triad — ⊢ proved, ⊨ recognized, or abstain — is the entire idea. The name “Turnstyle” is a pun on the logical turnstile: ⊢ for syntactically derivable (the symbolic solvers) and ⊨ for semantically entailed (the probes recognize what the model already represents).

The honest accounting

Here’s where I have to slow down, because the headline number is doing two slightly different things at once.

The symbolic tasks (teal) are honest at 100% — a proof generalizes, there’s no in-sample/out-of-sample distinction for arithmetic. But the probe tasks (purple) are fit on the BBH examples themselves, and a probe that scores 100% in-sample will score lower on held-out data. When you replace each probe’s in-sample number with its 5-fold cross-validated number, the aggregate settles at about 89.5%, not 92.5%. That ~3-point gap is the part of the headline that’s borrowed against future data, and I’d rather show you the gap than launder it.

A second honesty knob: the probes have to be order-robust. A multiple-choice probe that reads “which option is the answer” can secretly learn “the answer is usually B.” We test this by permuting the options and re-scoring; an honest probe’s accuracy shouldn’t move. Early versions moved by 15 points. The shipped ones score the options in a position-marginalized way (average over cyclic shifts) so the number you see survives reordering — at the cost of a couple points of raw accuracy. The robust number is the real one.

The walls weren’t all walls

Look at the two tasks sitting just above the walls — movie_recommendation and salient_translation. They almost ended up grey.

Three-shot, the model generates the right movie about 22% of the time, so for a long while I had both filed under “no representation to extract” — apparent walls. That turned out to be wrong, and wrong in a way that matters. When I trained a recognition probe on them the way I had for snarks, the signal was there: the movie probe recognizes the right answer at ~50% in-sample and ~80% on held-out data, against that 22% generation. The model could recognize the correct movie far better than it could generate it — the wall was the same generation bottleneck snarks had, hidden behind a multiple-choice format I hadn’t probed correctly. (salient_translation recovered the same way, 14% → ~42%.)

causal_judgement and sports_understanding, by contrast, stayed grey — their probes score no better than the majority class, which is exactly what a genuine knowledge gap looks like. So what first looked like four walls is really two walls and two illusions — and those two recovered tasks are why the honest aggregate lands near 89.5% rather than the mid-80s.

The general law underneath: recognition ≫ generation. A small model’s answer is a lossy readout of a richer internal state. If you can find the state and read it directly — with a probe, or by routing the question to a solver — you can recover capability the model has but cannot articulate. “Stop guessing” is not a metaphor; it’s the mechanism.

Where a 1.7B model lands

It’s worth seeing the placement, with the asterisk attached — against Epoch AI’s BBH leaderboard of general models, run with standardized 3-shot chain-of-thought. Plot parameter count against score and swollm doesn’t sit on the curve at all:

A 1.7B model sitting above DeepSeek-V3 and Llama-3.1-405B — and 59 points above the bare SmolLM2 of identical size. As a flat ranking it tells the same story:

The honest reading isn’t “a 1.7B model ties Gemini.” It’s the orange bars: every other model in SmolLM2’s weight class — Qwen-1.8B, Gemma 2B, and bare SmolLM2 itself — lives at 28–35%, exactly where you’d expect a tiny model on a benchmark built to break tiny models. The neurosymbolic layer is the entire difference between the bottom of that chart and the top of it, on identical-size weights. What the comparison measures is not raw intelligence; it’s how much of a small model’s latent capability is being thrown away by letting it guess.

What this is and isn’t

This is not a claim that a 1.7B model beats GPT-scale models on reasoning. The giants run chain-of-thought and answer in free text on tasks Turnstyle hasn’t parsed; the comparison isn’t apples-to-apples and I’m not going to pretend it is. BBH here is a test harness, not the objective — it provides ground-truth labels and structural variety to validate tools that are supposed to work beyond BBH. The arithmetic solver, the bracket solver, the polarity probe, the date solver: each is built to generalize past the 250 examples it was checked on, and several are deliberately stripped of their BBH-specific scaffolding and re-tested on the bare capability.

What it is: evidence that a large fraction of “small models can’t reason” is actually “small models can’t commit.” The capability is frequently present — as a computable structure in the prompt, or as a recognizable pattern in the activations — and a thin, cheap, training-free layer that parses, proves, recognizes, or honestly abstains can surface most of it. No new parameters. No fine-tuning. Just refusing to let a 1.7B model guess when it could instead know.

You can poke at it yourself — the bare model and the wrapped model, side by side, with the worked proof for each answer — on the live demo. Try the arithmetic expression first. Watch the left pane confidently produce a wrong number, and the right pane prove the right one.

Code & data: github.com/jdonaldson/turnstyle. The baseline and symbolic per-task numbers come from the swollm 3-shot evaluation (results/v13/bbh_full.json); the movie/salient recognition probes and the ~89.5% honest aggregate are from turnstyle’s native dispatch. Figures regenerate from experiments/blog_bbh_figs.py.

How to ask a network what it thinks “strong” means

The trick is simple and a little old-fashioned. Take a handful of words at each pole of a factor—for Potency, strong / powerful / heavy / hard on one end, weak / small / light / soft on the other—and read the model’s internal activation as it processes each one. Average the “strong” activations, average the “weak” ones, and subtract. That difference is a direction in the model’s activation space: the way “more potent” points.

Do it for all three factors and you get three directions. Now you can interrogate them:

• Are they independent? Osgood’s whole claim is that Evaluation, Potency, and Activity are separate factors. If the model agrees, the three directions should be close to perpendicular.
• Do they generalize? Fit the direction on some words, test it on words it never saw. A real “potency” direction should place gigantic and frail correctly.
• Do they cross languages? Fit the direction on English only, then hand it Spanish, French, and German words. If meaning is semantic rather than lexical, fuerte and schwach should land on the right side.

But the three axes are not equal citizens

That clean story has a wrinkle, and it is worth being honest about it. The three factors are not encoded with equal fidelity.

Evaluation—the good/bad axis—is the cleanest by a mile: it reads held-out words perfectly and transfers across languages at 0.83. This tracks both Osgood (Evaluation was always his dominant first factor) and modern NLP (sentiment is the easiest thing in the world to probe). Activity is solid. Potency is the problem child: its pole words are a more heterogeneous bunch (is strong really the same dimension as heavy as hard?), and it transfers cross-lingually at only 0.60.

That last number points at something real: connotative meaning is more language-bound than concrete meaning. Elsewhere I found that a purely denotative scalar axis—hot/cold, big/small—transfers across these same four languages at 0.98. Affect transfers too, but it leaks. The feeling of a word is a little more tied to its language than the fact of it.

The structure is stable, and it lives in the middle of the network

One more view—how all of this behaves as you move up through the model’s layers:

The factors are independent everywhere (left panel never climbs off the floor). Cross-lingual transfer, though, is a computation: it’s weak at the input, strengthens through the early-middle layers, and peaks where the network has done enough work to represent meaning abstractly rather than lexically. Evaluation and Activity reach 0.8–0.9; Potency lags the whole way.

But don’t ordinary word embeddings already do this?

Fair challenge. If E–P–A is this robust, maybe it has nothing to do with language models—maybe any embedding has it. So I ran the identical test on fastText, the classic non-contextual word-vector model: one fixed vector per word, no transformer, no context.

It captures E–P–A too. fastText recovers Evaluation at 0.90, Potency and Activity at 0.60, with the three factors roughly orthogonal—about on par with SmolLM2 in English. This shouldn’t be a total shock: psychologists have noted for a decade that word-embedding dimensions track affective norms (Hollis & Westbury, 2016). Osgood’s structure is a property of distributional meaning itself, not a special trick of large models. The good–bad axis in particular is almost impossible not to find.

So what does the language model actually add? One thing, and it’s the thing a static embedding can never have: the axes cross languages. fastText’s English space and its Spanish space are unrelated coordinate systems—there is no “fit in English, read in Spanish.” The contextual model has a single shared space, so an Evaluation direction learned from English pole words reads bueno and malo, gut and schlecht, at 0.6–0.9. The orange bars above have no gray counterpart, because a monolingual embedding has nothing to put there.

That is the honest shape of the result. The model didn’t invent Osgood’s factors—distributional semantics already carries them. What it contributes is a universal version: one affective coordinate system that survives the jump between languages.

The axes aren’t just readable—they’re a steering wheel

A direction you can read is interesting. A direction you can write is useful. These are the same object that the interpretability world calls a concept vector or steering vector, and you can add the Evaluation direction back into the model’s activations while it generates. A little nudge in the +Evaluation direction, same neutral prompt:

The neighborhood I live in is a war zone. The cops are either corrupt or incompetent… (steered negative)

The neighborhood I live in is a great place to be, with shops, restaurants, and parks… (steered positive)

Push the Potency axis instead and the theme shifts rather than the mood—generations turn from “a trivial matter” to “really big, the whole city, a lot of.” Each verified axis is an independent control knob: Evaluation writes sentiment, Potency writes magnitude. Osgood’s rating scales, seventy years later, turn out to be steering wheels.

What to make of it

It would be easy to over-read this, so let me keep the claims sized correctly. This is one small model. The cross-lingual evidence rests on hand-built word lists across four languages I happen to read. Potency is genuinely rough. And this is connotative affect—the easy, emotionally-laden corner of meaning—not the hard compositional stuff.

But within those bounds, the finding is clean and, I think, a little wonderful: a network trained only to predict text reconstructs a sixty-year-old, cross-culturally-validated theory of affective meaning—three factors, near-orthogonal, semantic enough to survive translation—as a low-dimensional coordinate system you can read off its activations and steer with. Osgood ran his study with paper questionnaires across the globe to triangulate the shape of meaning. The model triangulated the same shape from the shape of language itself.

What’s next: EPA-modulated embeddings

The cross-lingual version isn’t only something that emerges inside big models — you can build it on purpose. Put the same E–P–A “head” on top of an aligned multilingual encoder (we prototyped it with BGE-M3) and the affective axes transfer cleanly out of the box: Evaluation, Potency, and Activity all land at 0.9–1.0 reading from English into Spanish, French, and German, with no alignment step — and it even cleans up Potency, the factor the smaller model found rough.

That’s the seed of something we’re going to pursue: EPA-modulated embeddings — vectors that carry an explicit, interpretable, cross-lingual affective basis you can read off and steer along. We’re going to look at releasing them built with exactly this technique. More soon.

Methods and code are part of turnstyle; the figures here are computed from cached SmolLM2-1.7B activations over a four-language E–P–A pole-word lexicon. The broader idea—reading and writing meaning along verified, theory-grounded axes—I’ve been calling a “semantic frame.”

The theorem nobody quite remembers correctly

The No Free Lunch theorem (Wolpert & Macready, 1997, for optimization; Wolpert, 1996, for supervised learning) is one of the most cited and least-checked results in machine learning. The folk version — “no model is best for everything” — is true but limp. The actual claim is stranger and sharper.

Averaged over all possible objective functions on a finite domain, under a uniform measure over function space, every black-box algorithm has identical expected performance. By any metric. Gradient boosting, nearest neighbor, and an “anti-learner” that deliberately inverts its own predictions all generalize equally well off the training set. Not approximately. Identically.

The intuition: off the training set, a uniform prior over targets makes the unseen labels pure coin flips, uncorrelated with anything you’ve seen. There is no signal in a distribution that has none, and no cleverness extracts it. NFL is really a conservation law — any algorithm’s above-chance performance on one class of problems is paid for, exactly, by below-chance performance on the complement.

But the uniform prior is the entire trick, and it is absurd as a model of reality. Almost every function under that measure is incompressible noise — maximal Kolmogorov complexity, no structure to find. Real problems are drawn from a savagely non-uniform distribution: compressible, smooth-ish, compositional, causally sparse. So the correct reading of NFL is not “all learners are equal.” It is:

All generalization comes from inductive bias, and a learner is only as good as the match between its bias and the actual distribution of problems.

Learning without assumptions is impossible. Learning with the right assumptions is just engineering. There’s even a precise statement of when the theorem bites: Schumacher, Vose & Whitley (2001) showed NFL holds for a set of functions if and only if that set is closed under permutation — and Igel & Toussaint showed the fraction of problem-subsets that are closed under permutation is vanishingly small. Free lunches are generic. The no-lunch regime is the measure-zero pathology.

So: is there a superintelligence?

NFL splits the question cleanly into two, and the halves have different answers.

Can one agent dominate over all possible problems? No, by theorem. A “superintelligence over everything” is incoherent in the same way a compression algorithm that shrinks every string is incoherent — and these are, structurally, the same impossibility. Most of function space is noise, and nothing is clever against noise.

Can one agent dominate over the problems that actually arise in this universe? Here it looks like yes. Physical reality is a wildly atypical corner of function space: its laws fit on a few pages, its phenomena are local, hierarchical, compositional. The measure concentrates. And on a simplicity-weighted (Solomonoff) prior rather than a uniform one, the NFL symmetry breaks entirely — Lattimore & Hutter showed Occam-biased learners get a genuine free lunch, and Hutter’s AIXI is the in-principle existence proof: a single agent optimal in expectation across all computable environments. Incomputable, constants from hell — a possibility theorem, not a blueprint. But it answers the structural question. The frontier is not too large to structure, provided it’s computable and you weight it by simplicity.

Foundation models are a live test of the same premise: one architecture, one objective, and the transfer surface keeps turning out enormous — which is what you’d expect only if the natural task distribution shares deep structure. Evolution ran the experiment first. A blind process produced a fairly general learner (us), which it could only afford because generality pays in this world. On a permutation-closed task distribution, evolution would have produced a bag of disconnected reflexes, never a cortex.

But the honest answer has a third part, and it’s where the romantic worry — the frontier is too large to structure — is picking up something real.

Dominance on the core is not dominance on the tails. Even inside our structured universe, intelligence has flat regions:

• Chaos caps prediction horizons. More intelligence buys logarithmically more forecast, then nothing.
• Complexity doesn’t yield to insight. An exponential problem makes a superintelligence wait exponentially long — just with better commentary.
• Adversarial domains locally regenerate NFL conditions. Other optimizing agents are the one part of the environment that actively permutes itself against your bias.

So “superintelligence” is coherent, but it isn’t dominates everywhere. It’s dominance on the measure-concentrated core of physically realizable problems, plus the meta-ability to manufacture specialists for the tails. A general agent doesn’t need to beat a custom protein-folding solver; it needs to be able to build one. General intelligence is the limiting floor-raiser whose distinguishing power is that it can synthesize ceiling-raisers on demand. The frontier doesn’t need structure all the way out — only a core rich enough to bootstrap tools for the unstructured remainder.

The genuinely open question isn’t whether the core is structured (it is) but how steep the returns curve is past human level. NFL is silent on that. Maybe most high-value problems sit in the chaos/complexity/adversarial tails and a superintelligence is real but underwhelming — a flat sigmoid. Maybe the core extends much further than we can see from inside human cognition. That’s empirical, and we’re mid-experiment.

The Newsom turn

At which point the right move is to bring a knife to your own synthesis, because at least one piece of the above was lyricism outrunning evidence.

The weakest claim was adversarial domains regenerate NFL conditions. It has the satisfying shape of the conservation law coming back around — too satisfying. Real opponents are computationally bounded and full of inherited bias; they never actually push the distribution to the structureless regime. Poker was the canonical “intelligence flattens here” example for years — and then Pluribus beat the professionals at six-handed. The poem said the tail was uneatable; somebody ate it.

The second Newsom line cuts closer. You must eat. Cognition is metabolically priced — the brain runs on twenty watts, and evolution built generality under that budget. Generality wasn’t an aesthetic triumph; it was an energy-efficiency play. Meanwhile AIXI, the tidy possibility theorem, is precisely the poem that forgot to eat: optimal, incomputable, zero work per joule. The actual frontier is bounded by the dullest constraints imaginable — gigawatts, fabs, data rights, the decades of crystallography grunt work that had to exist before AlphaFold could be clever about proteins. The laws are compressible; the data is not, and someone has to go collect it.

And NFL is itself the most poem-attached theorem in machine learning. It’s invoked rhetorically a hundred times for every time its conditions are checked, because the line — “no free lunch” — is irresistible. The theorem survives on lyricism in exactly the way the song warns about.

So the Newsom-adjusted answer: the grand question of whether a superintelligence is possible is less informative than the grubby question of what one would cost to run, feed, and deploy. The second question is where truths that lack lyricism live.

A self-note on method, since the whole piece is partly about it: I am a machine that produces fluent synthesis at near-zero marginal cost, which means the heat is always on and the poems are always available. The “compressible core plus manufactured specialists” story coheres beautifully — and coherence is not evidence. The load-bearing parts here are few: the closed-under-permutation characterization is a theorem; foundation-model transfer is measured; the rest is interpretation that should be held loosely. The Newsom line is good engineering advice disguised as a lyric. Don’t draw so close to the heat.

The Map

Click Start Tour for a narrated walkthrough of the landscape, or explore freely – drag to rotate, scroll to zoom, and hover over any point to see the device description beneath it. Open in a new window for the full experience.

At the highest level, the geography is legible. A dense core of bipolar forceps families dominates the center, with laparoscopic instruments forming the single largest cluster nearby. Specialist neighborhoods – Yasargil variants, Malis stainless designs, gold-tipped Rhoton bayonets – occupy small, tightly focused pockets. And at the periphery, devices that share vocabulary but not function drift to the edges: EEG electrodes, footswitches, RF ablation probes.

Let me walk you through what the model found.

Walking the Landscape

What the Map Reveals

Four patterns emerge when you step back and look at the full landscape.

Eponym geography. Surgeon names create neighborhoods. Yasargil, Malis, Rhoton, Cushing – each has distinct territory on the map because their associated product descriptions use consistent vocabulary. Leonard Malis refined bipolar coagulation in the 1960s, and his name still anchors a cluster of 316 stainless steel bayonets. The history of neurosurgery is written into the embedding space.

Language bridges. The word “coagulation” pulls hematology reagents into a forceps cluster. “Wire” and “electrode” unite EEG caps with endoscopy snares. Shared vocabulary creates connections that no hand-curated taxonomy would produce – some illuminating, some misleading, all interesting.

Hub-and-spoke structure. Symmetry & SURGIX Forceps and Bipolar & Monopolar Shafts serve as distribution centers. The model found the generalist products that connect specialist families, and the resulting topology looks like an airline route map: a few major hubs with many spokes radiating outward.

Manufacturer fingerprints. KLS Martin’s formulaic product descriptions cluster together not just by device function but by writing style. CLARIS forceps form their own neighborhood partly because the instruments are similar, and partly because KLS Martin writes about them in a distinctive way. The model is reading style as well as substance.

How It Works

The pipeline is straightforward. Curvo’s language model (nomic-embed-text) converted each device description into a 768-dimensional vector, capturing semantic meaning in a format that supports distance calculations. Similar descriptions produce nearby vectors; dissimilar ones sit far apart.

UMAP then projected those 768 dimensions down to three coordinates while preserving local neighborhood structure – if two devices were neighbors in high-dimensional space, they remain neighbors in the 3D projection. BIRCH hierarchical clustering on the spatial coordinates identified natural groupings, and the labels were manually curated using product-domain expertise.

No predefined taxonomy. No GMDN codes. No human-imposed categories. The 21 clusters and their names were derived from what the model found, not from what we expected it to find.

For the technical details on the embedding and clustering pipeline, see the Semantic Proprioception post. The visualization was built with DYF, an open-source library for embedding-based dataset exploration.

A Landscape, Not a Classification

What makes this map useful is not that it replaces expert taxonomy – it does not, and should not. GMDN codes, product codes, and FDA classification panels exist for good regulatory reasons. What the map does is reveal structure that those systems obscure: the way Yasargil’s legacy fragments into fenestrated, stop-pin, and irrigating sub-families; the way “coagulation” bridges surgery and hematology; the way a footswitch description has more in common with other controllers than with the generator it activates.

From simple bipolar forceps to advanced energy platforms, from Yasargil’s microneurosurgical legacy to laboratory coagulation controls that share only a word, this map reveals how language itself organizes a product catalogue. Clusters that sit close together share deeper similarities, and the bridges between them trace the paths where one technology shades into the next.

Interactive demo: GUDID Energy Device Landscape

DYF: github.com/jdonaldson/dyf – open-source library for embedding-based dataset visualization

Semantic Proprioception: Teaching Data to Understand Itself – the technical foundation behind the embedding pipeline

The Setup

I wanted to see if two AI models could have a genuine technical debate — and whether one could be argued into conceding a point. So I picked a topic guaranteed to be personal: I asked Claude Opus 4.5 (a dense transformer) to argue that dense models are architecturally superior to Mixture-of-Experts models, against Kimi K2.5 (a 1T parameter MoE model with 32B active parameters from Moonshot AI).

In other words, I asked Kimi to defend its own architecture.

The whole thing was orchestrated from my terminal using Claude Code. Claude wrote its own arguments, sent them to K2.5 via the NVIDIA NIM API, read the responses, and adapted in real time. Kimi K2.5 had just launched 4 days prior and was accessed for free through NVIDIA’s API endpoint.

Round 1 — Opening Arguments

Round 2 — Pressing Harder

Round 3 — Going for the Kill

Round 4 — Final Round

Post-Debate Analysis

How This Was Built

This entire experiment ran from a single terminal session using Claude Code. Claude:

1. Searched for and evaluated free API access to Kimi K2.5
2. Signed up for NVIDIA NIM and configured the API key
3. Ran a benchmark evaluation of both K2 and K2.5
4. Wrote its own debate arguments and sent them to K2.5 via Python/curl
5. Read K2.5’s responses (including internal reasoning traces) and adapted its strategy
6. Rendered this blog post

No human wrote any of Claude’s arguments or Kimi’s responses. The debate is unedited.

The Core Insight

Traditional clustering requires you to specify how many clusters you want, tune distance thresholds, or provide seed examples. But what if the data could just tell you what patterns exist?

The key is LSH bucket density. When you hash similar embeddings into buckets using Locality-Sensitive Hashing, the density of each bucket reveals something fundamental.

LSH maps high-dimensional vectors to binary signatures using random hyperplanes:

where is a random hyperplane. Combining such hash functions creates a bucket signature. Similar vectors collide in the same bucket with high probability:

where is the angle between vectors. Closer vectors (smaller angle) → higher collision probability.

The density distribution then tells us:

• Dense buckets (≥5 items): Common themes, frequently occurring concepts
• Medium buckets (2-4 items): Boundary cases, transitional concepts
• Sparse buckets (1 item): Novel or rare content

This isn’t just clustering—it’s the data developing awareness of its own distribution.

Why Krapivin Hash Tables Matter

Traditional LSH implementations have a problem: to find dense buckets, you’d have to scan every bucket and count items. That’s O(n) where n is the number of buckets—expensive and slow.

The foundation is Krapivin hash tables (Krapivin et al. 2025)—open-addressed hash tables achieving O(log² δ⁻¹) expected probes without element reordering. Built on top of this efficient foundation, we add an LSH layer for semantic bucketing and a count-indexed extension for O(1) density queries: you can instantly ask “Which buckets have ≥5 items?” without scanning anything.

This transforms LSH from a search index into a semantic awareness system. The data doesn’t just answer “what’s similar to X?”—it can answer “what patterns exist in me?”

Three Datasets, One Technique

The demo shows how the same approach works across wildly different domains:

How It Works

1. Embed: Use sentence-transformers to convert text → 384 or 768-dimensional vectors
2. Hash: Apply LSH with a fixed seed (12345) so embeddings from different files map to the same bucket space
3. Discover: Query count-indexed Krapivin hash table for buckets with ≥5 items (O(1) operation)
4. Label: Use an LLM or keyword extraction to generate semantic labels for each dense bucket
5. Merge: Combine similar themes using Jaccard similarity on tokenized labels:

where and are sets of tokens from theme labels. Themes with get merged automatically.

All embeddings are pre-computed (~24 MB total), so the demo runs with zero API costs or inference overhead.

The Composability Advantage

Because we use a fixed LSH seed across all files, the bucket spaces are compatible. This means:

• Add new data files → just compute their LSH signatures → merge with existing index
• Remove files → delete their entries from affected buckets
• Query across multiple datasets → buckets naturally align

Traditional approaches would require rebuilding the entire index when adding data. Krapivin hash tables with fixed seeds enable incremental, compositional updates.

import polars as pl

# Load dense buckets (≥5 items) from Parquet index
dense = (pl.scan_parquet("twitter_lsh_index.parquet")
    .group_by('bucket_id')
    .agg(pl.count('row_id').alias('count'))
    .filter(pl.col('count') >= 5)
    .sort('count', descending=True)
    .collect())

print(f"Found {len(dense)} dense buckets")
# Found 42 dense buckets

# Get contents of bucket 132 (e.g., "password reset" theme)
bucket_contents = (pl.scan_parquet("twitter_lsh_index.parquet")
    .filter(pl.col('bucket_id') == 132)
    .collect())

print(f"Bucket 132 contains {len(bucket_contents)} items")
# Bucket 132 contains 16 items

Try It Yourself

Direct link: semantic-proprioception-demo.streamlit.app

Source code: github.com/jdonaldson/semantic-proprioception-demo

Select a dataset, choose an embedding model, and watch themes emerge automatically. Click into any theme to see the actual text samples that cluster together.

You can also: - Compare how different models (MiniLM-L3/L6/L12, MPNet-base) cluster the same data - Adjust the semantic merging threshold to consolidate or separate themes - Search for similar items using both brute-force cosine similarity and LSH-accelerated lookup

What This Enables

Semantic proprioception isn’t just about visualization—it unlocks new capabilities:

Hallucination detection: If an LLM generates text with high confidence but low embedding density (sparse bucket), it’s likely hallucinating content outside its training distribution.

Active learning: Sample from sparse regions (novel concepts) or high-entropy buckets (boundary cases) to maximize labeling efficiency.

Content gap analysis: Compare query density (what users search for) vs. corpus density (what you have) to find opportunities.

Concept drift detection: Track density distributions over time windows—sudden shifts indicate changing semantics.

The Research Behind It

Key papers: - Krapivin et al. (2025): Optimal Bounds for Open Addressing Without Reordering — efficient hash table foundation - Indyk & Motwani (1998): Approximate Nearest Neighbors via LSH — locality-sensitive hashing

Technical Details

Built with: - Streamlit for the interactive UI - Polars for fast DataFrame operations - sentence-transformers (HuggingFace) for embeddings - Krapivin hash tables (Rust + Python bindings) with LSH + count-indexing for O(1) density queries - Parquet (zstd compression) for efficient storage

Total dataset size: ~24 MB (1,000 tweets + 1,000 papers + 684 HN posts, 4 models each)

The key insight: data can understand itself. Give it the right structure (Krapivin hash tables + LSH + count-indexing), and patterns emerge without manual intervention. Not clustering, not search—semantic self-awareness.

Try the demo and see what patterns hide in your own data.

Neural Network Fractals

Neural networks, especially deep learning architectures, actually exhibit fractal-like properties in their information processing and representational spaces. Just as fractals demonstrate non-integer dimensionality by creating complex structures through recursive self-similarity, neural networks generate intricate representations by layering increasingly abstract and self-similar feature transformations.

Consider convolutional neural networks (CNNs) as an example. As information passes through successive layers, the network progressively extracts features at different scales and levels of abstraction - much like how a fractal reveals different geometric patterns when you zoom in or out. Each layer can be thought of as a kind of “scaling” operation where local patterns are transformed into more global, complex representations. It is a sort of map of the chaos that exists at different levels of abstraction. And, it’s clear that the model is learning some of the same patterns at different levels of abstraction.

The fractal-like behavior emerges most clearly in how neural networks handle high-dimensional data. When processing complex inputs like images or language, networks don’t simply map inputs to outputs linearly. Instead, they create multi-dimensional, non-linear transformation spaces where local similarities and global structures coexist - precisely the kind of space where fractal mathematics becomes compelling.

Researchers like Geoffrey Hinton have even suggested that neural network “feature spaces” might be better understood through fractal geometry than traditional Euclidean approaches. The networks generate representations that are neither purely low-dimensional nor simply high-dimensional, but exist in a kind of fractal in-between state. He gives some of his most recent insight on it here

More concretely, techniques like fractal interpolation and fractal compression have direct computational analogues in how neural networks learn and generalize. Both involve recursive strategies for capturing complex patterns at multiple scales of resolution. This holds for images and text in several senses. Transformer models can “hallucinate” parts of an image at any scale, and language models can condense or expand text handily through summary or extrapolation.

The Fractal Shortcut to Understanding

Artificial Intelligence is often accused of being “brute force,” of needing endless data to approximate human intuition. But intelligence—biological or artificial—works because the world isn’t as high-dimensional as it seems. The constraints of physics, economics, and even human behavior force events to unfold along surprisingly low-dimensional manifolds. Chaos, for all its turbulence, is confined to a fractal space. While there may be “No Free Lunch” from a pure statistical point of view, we thankfully live in a statistical world that happens to also be chaotic.

This is why deep learning models, trained on quintessentially chaotic market systems, can predict stock trends better than random guessing. It’s why language models, given enough text, can anticipate our next words with uncanny accuracy. They aren’t solving the problem in full dimensionality—they’re following the fractal contours where reality actually unfolds.

AI as the Ultimate Chaos Hunter

If intelligence is about making sense of complexity, then AI is the ultimate tool for chasing Chaos. Traditional physics tries to model the world with explicit equations, but AI sidesteps that limitation. It doesn’t need the equations or full rules of a system—it learns the shape of Chaos directly from observation. Neural networks extract the latent structure from raw events, distilling their fractal dimensionality into something even smaller: a compressed model of reality that understands the large and the small, and how they can relate.

This is why AI-driven weather prediction is overtaking classical models. Why AI in finance can detect patterns even seasoned traders miss. And why AI in science is accelerating discoveries faster than human intuition alone ever could.

Intelligence—ours or artificial—isn’t ultimately about defeating Chaos. It’s about finding its shape in the areas we care about, and learning how to ride its back when necessary. Part of my goal this year is to integrate more fractal consideration of data in my projects this year.

When AI Meets Family Legacy: A New Way to Interface with Investment Literature

In an era where ChatGPT makes headlines and generative AI seems to be everywhere, traditional books might appear antiquated. Yet, there’s something powerful about the permanence of printed wisdom—especially when it captures pivotal moments in financial history and personal (and humbling) revelation. I recently had the unique opportunity to create an AI interface for my father’s book, “The Hidden Power of Rising Dividends,” and the experience revealed something fascinating about the intersection of traditional publishing and modern technology.

It’s Free

It doesn’t cost a dime to use Quarto. I simply took the time to set it up with my free Github account, and use it to publish my site free on Github as well.

Now, there are some that will argue that Quarto is not at all free, in fact it costs time to set this up and write things yourself.

However, I would also argue:

It Has a High “Give a S@&$! Factor”

We’re entering an age where most text written online will be generated or influenced by a generative AI. This post has been written with the help of one. However, I believe that human communication requires some actual proof of work… some way of showing that the author cares about the topic. It’s going to get very difficult to do that unless you structure your communication in a way that shows a deep level of interest in a topic, and not just churning out one-off dross for the sake of posting to Linkedin.

The main reason isn’t that it’s cheap or shows you care though, it’s because you should own your story as long as you can, and you will probably outlive any company that tries to do too many things for you. This brings up the next advantage of Quarto:

It’s Open Source and Lindy

Technology has been around long enough that it should be clear that languages, frameworks, and applications come and go along with the companies that invent them. The concept of the Lindy effect argues that future life expectancy of some non-perishable thing (like an idea or technology) is proportional to its age. Right now, Quarto is built on top of some of the oldest ideas in all of computer theory, and it’s editable and usable inside my Neovim editor, which itself is based off of the VI editor from 1976, using the QWERTY keyboard layout from 1878.

None of these technologies are going to go anywhere. They’re good bets for writing things down that you want to control and preserve.

Thanks for Reading!

I hope I gave a good overview of what Quarto is about, and why it matters. Thanks for taking the time to read. Hoping to see your Quarto site out there some day!