Patchi

Formalizing and stress-testing Pygmalion's relation-based theory of cognition — meaning as relations between words, words as agreements on labels, context as the base relation, infons in situations, memory as an "artificial-time" recursion — by grounding it in the prior literature and building a runnable reference implementation that we then measure honestly.

📄 Published: clawRxiv:2606.02822 — Patchi: Formalizing and Stress-Testing Pygmalion's Relation-Based Theory of Cognition

What this is

Pygmalion's notebook sketches a unified theory of machine cognition built bottom-up from relations between words, with a stack of increasingly abstract structures on top. We do two things with it: (1) read it as a single layered stack and ground each layer in established theory, and (2) build a working core and empirically test its most distinctive component. The layers turn out to be well-trodden prior art; the bridges between them are where the originality — and the risk — live.

What we built

A runnable Python core (patchi), a vertical slice of the stack, each piece unit-tested:

• WordClass lexicon — words as vectors with cosine nearest-neighbour lookup.
• Signed relation graph — synonym(+)/antonym(−) edges with TransE-style relation offsets; held-out edges recovered by offset arithmetic.
• Similarity-weighted blending operator — Pygmalion's composition primitive, blend(w) = Σ sim(w,sᵢ)p·vec(sᵢ) / Σ sim(w,sᵢ)p.
• Infon/situation layer — ⟨relation, args, polarity⟩ with a graded support(s,σ) ∈ [0,1], so context-conditioning measurably changes outputs.
• Proof(walk) trace — every output records the words/weights that produced it, with a single-source-of-truth discipline so the trace cannot diverge from the computation.
• Reduced cores for the hard bridges — a registry-backed bijective translator, a category of blocks with property checkers (the computable shadow of the topos layer), "artificial time" as the recursion index of a memory cell, and constraint-checked block reconfiguration ("twirking"). Honest reductions; full versions are future work.

The pieces compose end-to-end (run python scripts/run.py --demo): one semantic world flows lexicon → signed relations → similarity-weighted blend → bijective block → spatial-gated memory → graded situation support, every output carrying a Proof(walk) trace of what produced it.

What we found

We tested the blending operator against two baselines (raw vectors; additive = unweighted neighbour mean) on a synthetic denoising task and on real GloVe-50 embeddings vs the human WordSim-353 judgements (all 353 pairs). The two runs point in opposite directions — and the real one is the result that matters.

Real embeddings (GloVe-50 × WordSim-353)

Raw GloVe scores Spearman 0.5033 — matching the known literature value (a check that the harness is correct). Every reconstruction does worse:

On clean pretrained vectors, reconstructing a word from its neighbourhood loses to doing nothing (best blend 0.447 vs raw 0.503). The similarity weighting beats the unweighted average reliably but only by +0.001 to +0.009 — never enough to recover the loss.

Synthetic (controlled noise) — the contrast

When the vectors are noisy, reconstruction denoises and the operator wins:

Relational similarity — the first positive result (WordNet × SimLex-999)

Every result above tests one Pygmalion idea: reconstruct a word from its neighbourhood in vector space — a geometric signal. It loses. But the notebook's most-repeated claim is a different, relational one: "distance between words = the number of words they have in common." We tested it with an independent relation source — WordNet (each word's features = the concepts on its hypernym paths) — and scored how much two words' feature sets overlap, against the human judgements, with GloVe cosine as the baseline and a rank-average combined score.

On SimLex-999 — which scores genuine similarity and deliberately penalises mere relatedness (coffee/cup) — the relational signal alone (adamic-adar 0.298) matches GloVe cosine (0.296), and the combined score (0.383) beats cosine by +0.087 (~29% relative): the first time anything in this project beats the embedding baseline rather than losing to it. The two signals are complementary — taxonomy measures is-a-kind-of directly, where distributional cosine conflates similarity with relatedness. On WordSim-353 (relatedness) cosine already wins and structure adds almost nothing.

The complementarity holds across all three embeddings on SimLex (GloVe-50 +0.100, GloVe-100 +0.086, fastText-300 +0.034) — two architectures, a wide span of baseline strength — and shrinks as the embedding gets stronger, exactly as expected. The one place a flat equal-weight combination hurts is the strongest embedding on relatedness (fastText × WordSim, −0.104): cosine so dominates there that averaging in the weaker structural signal drags it down — a property of the unweighted combiner, and the reason the next step is a learned mixing weight.

And a learned weight (λ tuned on a train split, scored on held-out test) delivers: on SimLex it beats cosine on all three embeddings (+0.075 / +0.063 / +0.029 held-out), and it folds the fastText × WordSim loss back to break-even (−0.008, λ*=0.1 — training correctly near-zeroes the weaker signal where cosine dominates). The learned combiner is ≥ the flat one in every cell. So the relational gain is real on held-out pairs, and a tuned weight captures it without the naive combine's downside.

Is it statistically significant? A paired bootstrap (2000 resamples) on the SimLex gain says yes on the GloVe embeddings (GloVe-50 +0.100, 95% CI [+0.057, +0.142]; GloVe-100 +0.086, CI [+0.043, +0.127]) and no on fastText-300 (+0.034, CI [−0.008, +0.075] — just crosses zero): the relational signal demonstrably helps count-based embeddings, and on the strongest subword embedding its small residual gain is not distinguishable from noise. Under 5-fold cross-validation the learned combiner is ≥ cosine on every cell, and the fastText × WordSim loss vanishes entirely (0.721 → 0.720). We report the boundary, not just the win.

Is Pygmalion's shared-neighbour metric special? No — and the effect is bigger than his version. Put head-to-head with textbook WordNet similarity, his shared-ancestor count (adamic-adar, 0.298 on SimLex) is beaten by Wu-Palmer (0.438) and path (0.476). His specific "number of words in common" is a weaker instantiation of a relational similarity the field already has. But the stronger measure complements cosine more: cosine + path beats cosine on SimLex for all three embeddings, significantly (+0.168 / +0.151 / +0.080, every 95% CI above zero — including fastText, where his metric's gain was not significant). So the corrected conclusion: Pygmalion's direction is right and the effect is real, sizable, and significant across architectures — but his specific metric is not the right tool. The skeptic's question demoted the formulation and promoted the phenomenon.

The conclusion, stated straight

The empirical story is two-sided. Pygmalion's geometric reconstruction loses on clean embeddings; his relational similarity is real and complementary on the harder, cleaner task. "Loses as geometry, wins as relational structure."

Pygmalion's blending operator's value is entirely conditional on input noise. It is a denoiser: it wins when averaging over trustworthy neighbours recovers signal (noisy vectors) and loses when the base vectors are already clean (GloVe), where averaging washes out the discriminative signal. The similarity weighting — the distinctive ingredient — is real but small in both regimes; the decision to reconstruct at all dominates. This is the opposite of what the synthetic run alone would have implied, which is exactly why running the real benchmark mattered. We report the negative result in full.

The same through-line shows up in phrase composition: on a synthetic phrase benchmark, plain additive composition recovers the ground-truth phrase meaning best, the project's similarity-weighted composition is worse at every noise level, and the multiplicative baseline fails outright. So the similarity weighting that defines Pygmalion's operator does not beat the plain baseline — for single-word reconstruction or phrase composition.

Limitations

The negative result holds across {GloVe-50, GloVe-100, fastText-300} × {WordSim-353, SimLex-999} — blend beats raw in 0 of 6 cells, including a different embedding architecture (fastText, subword) and a much stronger raw baseline (0.718). The penalty is regime-dependent and shrinks to break-even on the strongest embedding + hardest task, but never goes positive. A residual form ((1−α)·raw + α·blend) was tested too — best α is 0 (raw), so a little smoothing doesn't rescue it either. The harder bridges — full topos internal logic, richer block internals, the control-system reframing of neural nets — are implemented only as reduced cores or named as future work, not papered over.