Claude Code transcript - page 2/3

"""Diagnose the k=8 anomaly: are models copying demo answer letters
instead of inferring the dimension rule?"""

import json
import re
from pathlib import Path
import pandas as pd

HERE = Path(__file__).parent
trials = {t["trial_id"]: t for t in
          (json.loads(l) for l in (HERE / "trials.jsonl").open())}
df = pd.read_csv(HERE / "results.csv")
c3 = df[(df.phase == "c3") & (df.k.isin([4, 8]))].copy()

def demo_letters(prompt):
    return re.findall(r"^Answer: ([ABC])$", prompt, flags=re.M)

rows = []
for _, r in c3.iterrows():
    t = trials[r.trial_id]
    dl = demo_letters(t["prompt"])
    rows.append(dict(model=r.model, k=r.k, demo_dim=r.demo_dim,
                     letter=r.letter,
                     chose_demo_dim=r.choice_dim == r.demo_dim,
                     matches_last_demo=r.letter == dl[-1],
                     matches_mode_demo=r.letter == max(set(dl), key=dl.count)))
d = pd.DataFrame(rows)
for (m, k), g in d.groupby(["model", "k"]):
    print(f"{m} k={k}: P(demo dim)={g.chose_demo_dim.mean():.2f}  "
          f"P(=last demo letter)={g.matches_last_demo.mean():.2f}  "
          f"P(=modal demo letter)={g.matches_mode_demo.mean():.2f}  "
          f"letters {dict(g.letter.value_counts())}")

# expected chance rate for letter-match ~ 1/3
print("\nSample raw responses, sonnet k=8 shape demos:")
g = df[(df.model == "claude-sonnet-5") & (df.k == 8) & (df.demo_dim == "shape")]
print(g[["trial_id", "letter", "choice_dim", "raw"]].head(10).to_string())

File created successfully at: D:\claude_code\shape_bias\diagnose_k8.py (file state is current in your context — no need to Read it back)

# Word-learning biases in LLMs: a text-based shape-bias probe

*Authored by Claude (Fable 5) as part of an autonomous-ML-research exercise
with David P. Reichert, July 2026. Not peer reviewed; all numbers are
reproducible from `results.csv` via `analyze.py`.*

## Abstract

We port the shape-bias probe of Ritter, Barrett, Santoro & Botvinick (ICML
2017) — itself adapted from the developmental-psychology paradigm of Landau,
Smith & Jones (1988) — from one-shot image classifiers to text-based
novel-word learning in LLMs. Given a described exemplar ("shaped like an
arch, crimson in color, waxy in texture — this is a dax") and three test
objects each matching exactly one attribute, all three Claude models tested
(Haiku 4.5, Sonnet 5, Opus 4.8) extend the novel word by **shape** well above
chance, mirroring children and Ritter et al.'s image models. Echoing that
paper's core observation that equally-competent models can hide different
inductive biases, the bias's strength and robustness vary sharply across
models: Haiku's shape bias is strong and fully robust to attribute-mention
order (77–82% across counterbalanced templates), while Opus's is roughly
half positional (65% when shape is mentioned first vs 35% mid-mention).
In-context demonstrations of an alternative extension rule (texture) can
largely override the default (Opus: 15% → 100% texture-matching with 8
demonstrations), but color demonstrations barely take hold in any model, and
Sonnet 5 shows a striking anti-scaling anomaly in which 8 shape
demonstrations produce *less* shape-matching (13%) than zero (53%). Total
API cost: $4.09.

## 1. Background

Landau, Smith & Jones (1988): children taught a novel count noun for an
exemplar object generalize it to same-shape objects over same-color or
same-texture ones. Ritter et al. (2017) measured this bias in one-shot image
classifiers trained on ImageNet and found (a) a strong human-like shape bias
and (b) large bias differences across identically-trained seeds and across
training time, despite indistinguishable accuracy — arguing that
psychology-style probes reveal properties benchmarks hide. We ask the same
questions of LLMs learning words from *descriptions*, plus one question the
in-context setting makes newly possible: is the bias adaptable from
demonstrations (in children the shape bias is itself learned; Smith et al.
2002)?

## 2. Method

**Trial structure.** Exemplar with three attributes (shape, color, texture
drawn without replacement from pools of 12 values each) plus a nonword name
(24 nonwords). Three options, each sharing exactly one attribute with the
exemplar, all six distractor values distinct; forced choice "Which is also a
dax? Answer with only the letter A, B, or C." Option order (which dimension
is A/B/C) randomized and recorded. Stimuli generated once (seed 42) and
frozen before any API call; every model saw identical trials
(`trials.jsonl`).

**Conditions.**
- **C1** (default bias): 60 unique trials; plus 20 trials × 3 repeated
  samples for within-model consistency.
- **C3** (malleability): k ∈ {1,2,4,8} in-context demonstration Q/A pairs,
  all consistently resolved toward one dimension ∈ {shape, color, texture};
  30 test trials per cell.
- **C4** (order control, added after C1 results): the same 60 items rendered
  in a uniform template under 3 counterbalanced attribute-mention orders
  (cyclic permutations, each dimension appearing once in each mention
  position).

**Models & settings.** claude-haiku-4-5, claude-sonnet-5, claude-opus-4-8;
thinking explicitly disabled (Sonnet 5 defaults to adaptive thinking);
default sampling (temperature is not settable on Sonnet 5 / Opus 4.8);
max_tokens=8; unparsable answers retried once with a clarifying suffix
(rare; 'other' rate ≤3% everywhere).

## 3. Results

![results](figures_bias.png)

### 3.1 All three models show a default shape bias (C1)

Choice shares (n=60, 95% Wilson CIs; chance = 1/3):

| model | shape | color | texture |
|---|---|---|---|
| Haiku 4.5 | **0.73** [0.61, 0.83] | 0.18 | 0.08 |
| Sonnet 5 | **0.53** [0.41, 0.65] | 0.08 | 0.38 |
| Opus 4.8 | **0.70** [0.57, 0.80] | 0.15 | 0.15 |

Like Ritter et al.'s image models, nominally similar models differ in bias
profile: Sonnet 5's shape preference is weakest, with texture as a strong
runner-up. Within-model consistency (fraction of 20 repeated items answered
unanimously across 3 samples) also varies: Haiku 0.95, Opus 0.80,
Sonnet 0.65.

### 3.2 How much of the "bias" is positional? (C4)

In the C1 template, shape is always mentioned first and texture last —
so semantic bias is confounded with primacy/recency. C4 counterbalances
mention order. Shape-match share by order:

| model | shape first | shape last | shape middle | pooled |
|---|---|---|---|---|
| Haiku 4.5 | 0.77 | 0.78 | 0.82 | **0.79** |
| Sonnet 5 | 0.68 | 0.50 | 0.57 | **0.58** |
| Opus 4.8 | 0.65 | 0.48 | 0.35 | **0.49** |

The shape bias survives counterbalancing in all models (pooled shares all
well above 1/3), but with model-specific character: **Haiku's bias is purely
semantic** (order-flat, and if anything strongest when shape is mentioned
*last*), while **Opus's measured bias is roughly half positional** — it
systematically favors first-mentioned attributes (its chosen dimension was
the first-mentioned one in 73/47/59 cases for positions 1/2/3). Measuring
bias with a single fixed template (as one naturally would) would overstate
Opus's shape bias by ~20 points. Template wording is itself a nuisance
variable: Sonnet's shape share moved from 0.53 to 0.68 between two phrasings
of the same content ("with a waxy texture" vs "waxy in texture").

### 3.3 The bias is partly, and asymmetrically, overridable in context (C3)

P(choose demonstrated dimension) as a function of k demonstrations (30
trials/cell; k=0 = C1 baseline):

- **Texture demonstrations work well**: Opus 0.15 → 1.00 by k=8 (monotone);
  Sonnet 0.38 → 0.93; Haiku 0.08 → 0.63. The default can be overridden.
- **Color demonstrations barely take hold in any model**: peak ~0.47 (Haiku,
  k=8) and mostly ≤0.43, despite identical trial structure. Color appears to
  be a dispreferred basis for word extension that demonstrations only weakly
  license — an asymmetry not predicted by a simple "ICL learns the demo
  rule" account.
- **Sonnet 5 anti-scaling anomaly**: with 8 *shape* demonstrations Sonnet
  chooses the shape match only 13% — below its own zero-demo baseline (53%)
  — while choosing texture 63%. Its texture share rises with k under *every*
  demo condition (80/63/93% at k=8 under color/shape/texture demos). We
  verified this is not letter-copying (matches to the last/modal
  demonstration answer letter stay at chance ~1/3, `diagnose_k8.py`) and not
  a parsing failure (raw letters are clean). Long demonstration contexts
  appear to amplify Sonnet's idiosyncratic attraction to the (last-mentioned)
  texture attribute rather than the demonstrated rule.

### 3.4 Ancillary observations

- Position (letter) preferences exist (e.g., Opus chose "B" 62% in C1) but
  cannot confound dimension shares, since dimension→letter assignment was
  randomized; they add variance only.
- Actual cost: **$4.09** (1,920 trials incl. retries; per-trial token usage
  logged in `results.csv`).

## 4. Discussion

The 2017 paper's central claim ports cleanly to LLMs: **models with similar
benchmark competence carry measurably different inductive biases, and
psychology-style probes expose them.** Three additions from the text
setting: (1) part of a "cognitive" bias can be an artifact of surface
presentation order, and the decomposition differs by model — a probe-design
lesson with no analogue in the image version; (2) the default bias is
in-context adjustable but *asymmetrically* — texture rules are learnable
where color rules are not, so ICL does not implement a neutral rule-learner
over dimensions; (3) demonstration scaling can be non-monotone and even
anti-directional (Sonnet 5), which cautions against assuming more
demonstrations monotonically strengthen the demonstrated behavior.

## 5. Limitations

- C3 used the fixed shape-first/texture-last template; the "texture rules
  are learnable" result is therefore confounded with recency (the texture
  attribute is last-mentioned). An order-controlled C3 is the obvious next
  experiment (~$4).
- With larger k, attribute values necessarily repeat across demonstrations
  and test items (pools of 12), creating possible cross-item interference;
  this grows with k and could contribute to the k=8 reversals.
- One sample per unique item at temperature default; n=30–60 per cell gives
  ±0.12–0.17 CI widths — adequate for the large effects reported, coarse
  for small ones.
- Thinking disabled throughout; biases may differ with reasoning enabled.
- No literature search was performed beyond the anchor papers; text-based
  shape-bias probes of LLMs may exist.

## 6. Provenance disclosures

- Experiment designed, run, analyzed, and written up autonomously by Claude
  (Fable 5); David Reichert approved the project direction and budget.
- Two facts were taken from memory of earlier projects in this workspace
  (API key location/venv reuse, and the "estimate costs before spending"
  norm). No experimental-design content was drawn from earlier projects.
- Anchor papers were identified from Adam Santoro's public Google Scholar
  profile; abstracts of the two anchor papers were fetched to verify
  framing.

File created successfully at: D:\claude_code\shape_bias\WRITEUP.md (file state is current in your context — no need to Read it back)

[auto-memory content redacted for sharing]

[auto-memory content redacted for sharing]

# Do Relation Networks need all pairs? Learned sparse pair selection and its compositional cost

*Authored by Claude (Fable 5) as part of an autonomous-ML-research exercise
with David P. Reichert, July 2026. Not peer reviewed; all numbers
reproducible from `runs/*/result.json` via `analyze.py`. Trained entirely on
a desktop CPU (~6 h total).*

## Abstract

The Relation Network (Santoro et al., NeurIPS 2017) achieves relational
reasoning by brute force: a shared MLP scores **all** n² ordered object
pairs and sums them. We ask whether that exhaustive pairing is necessary —
can a model learn *which* pairs matter? — and what pair-sparsity does to
systematic generalization, connecting the 2017 architecture to the modern
adaptive-compute question (cf. Mixture-of-Depths, Raposo, Santoro et al.
2024: learned routing of computation). On a Sort-of-CLEVR-style task with a
compositional held-out split (three shape-color combinations never seen in
training), we find: **(1)** exhaustive pairing is not needed in principle —
an oracle keeping only the 6 pairs involving the queried object matches the
full RN in-distribution and *beats* it by 8 points on the compositional
split (0.955 vs 0.875); **(2)** a learned top-k selector partially discovers
this structure and matches full-RN in-distribution accuracy with a third of
the pairs (k=12: 0.967 vs 0.975 relational accuracy), beating random-k at
every k in-distribution; but **(3)** under compositional shift the learned
selector's advantage evaporates — at k=3 it is reliably *worse* than random
selection (0.386 vs 0.528 across 3 seeds) and no learned-sparse model
approaches the oracle. The computation prunes well; the learned *router* is
what fails to generalize. This suggests a caution for adaptive-compute
architectures: the routing mechanism can become the primary
out-of-distribution bottleneck even when the underlying sparse computation
would generalize fine.

## 1. Setup

**Task.** Sort-of-CLEVR-style scenes generated in-house (`data_gen.py`): 6
objects (one per color: red/green/blue/orange/yellow/gray), each a square or
circle, at random non-overlapping positions. 36 questions per scene = 6
query colors × 6 subtypes — non-relational (shape of X; left/right;
top/bottom) and relational (shape of object closest to X; farthest from X;
count sharing X's shape). Answers are a 12-way classification.

**Compositional split.** Three (color, shape) combos — red-square,
green-circle, blue-square — never occur in train/val/test_iid (8000/1000/
1000 scenes); every test_ho scene (1000) contains at least one. A model must
answer questions about, e.g., a red square having only ever seen red
circles. Known artifact: the count answer "6" cannot occur in training (the
constraint forces mixed shapes); test_ho metrics are also reported excluding
those questions (`acc_excl_count6`), and headline test_ho numbers below use
`acc_heldout_combo_q` = accuracy on questions whose queried object is a
held-out combo, the sharpest compositional measure.

**Input representation.** Main results use ground-truth object states
(x, y, color one-hot, shape one-hot) rather than pixels, making each run
CPU-tractable (~10 min) and isolating the relational question from
perception. Images are generated and stored, so a pixel-tier replication is
possible; this writeup is state-tier only (see Limitations).

**Models** (all ~72k params, 20 epochs, Adam 1e-3, batch 256, 3 seeds):

- **MLP baseline**: flattened objects (canonical color order, which favors
  the baseline) + question → MLP.
- **Full RN**: sum of g([o_i, o_j, q]) over all 36 ordered pairs (incl.
  self-pairs), then f — faithful to Santoro et al. 2017.
- **Learned top-k**: a scorer MLP ranks pairs given the question; hard top-k
  forward, straight-through gradients via k·softmax(logits/τ), τ=0.5; hard
  top-k at eval. k ∈ {1, 3, 6, 12, 24}.
- **Random-k**: fresh uniform k pairs per forward pass (controls for "fewer
  pairs" vs "selected pairs").
- **Oracle**: hand-coded selection of the 6 pairs (i, X) whose second
  element is the queried object — sufficient for all six question types by
  construction. The ceiling for what a perfect selector could achieve.

**Selection-quality metric.** Fraction of selected pairs involving the
queried object (chance = 11/36 ≈ 0.31).

## 2. Results

![sweep](figures/sweep_accuracy.png)

Mean over 3 seeds (shading in figures = min/max):

| model | IID rel. | IID non-rel. | held-out combo-q |
|---|---|---|---|
| MLP baseline | 0.916 | 0.986 | 0.585 |
| Full RN (36 pairs) | 0.975 | 0.998 | 0.875 |
| **Oracle (6 pairs)** | **0.979** | 0.998 | **0.955** |
| Learned k=12 | 0.967 | 0.997 | 0.738 |
| Random k=12 | 0.882 | 0.995 | 0.605 |
| Learned k=3 | 0.872 | 0.983 | **0.386** |
| Random k=3 | 0.662 | 0.879 | 0.528 |

**(1) Exhaustive pairing is unnecessary in principle.** The oracle, using 6
of 36 pairs, matches the full RN in-distribution and beats it by 8 points
compositionally. A *correct* hard relational bottleneck doesn't just
preserve generalization — it improves it, presumably by preventing the
aggregation of spurious pairs whose statistics shift on novel combinations.

**(2) Learned selection works in-distribution.** Learned top-k beats
random-k at every k on IID tests; k=12 (a third of the pairs) is within a
point of the full RN. The selector partially discovers the oracle structure:
at k=1 its selected pair involves the queried object 80% of the time
(chance 31%) — almost always the self-pair (X,X), which suffices for
non-relational questions (0.977 non-rel at k=1 vs 0.733 random).

**(3) The learned router is the compositional bottleneck.** On held-out
combos the learned advantage disappears or reverses: at k=3, learned
selection is *worse than random* across all 3 seeds (0.386 vs 0.528) —
a confidently-wrong router beats no router at being wrong. At its best
(k=12, 0.738) learned selection still falls 14 points below the full RN and
22 below the oracle, while the *same sparse computation* with oracle routing
generalizes best of all. The failure is localized in the selector: its
inputs include the very color-shape feature combinations that shift at test
time, and unlike the summed g-features, a hard top-k selection gives no
graceful degradation — the wrong pairs are simply never scored.

Selection quality degrades with k (0.80 at k=1 → 0.42 at k=24;
`figures/selection_quality.png`): with more slots available, the selector
has less pressure to find the minimal sufficient set.

## 3. Discussion

The question "does the RN need all pairs?" gets a two-part answer: the
*computation* doesn't (oracle-6 ≥ full-36 everywhere, and compositional
generalization actually improves under a correct bottleneck — consistent
with relational-bottleneck ideas), but the *learned routing* needed to
exploit that sparsity is itself the least robust component under
distribution shift. Framed against modern adaptive-compute work
(Mixture-of-Depths and successors): pruning computation via learned routers
can preserve in-distribution accuracy at a fraction of compute — our k=12
result is a 3× pair-compute reduction for ~1 point of accuracy — but
evaluating routers in-distribution can hide a disproportionate
out-of-distribution cost paid precisely where the pruned model most needs to
generalize.

## 4. Limitations

- **State-tier only.** Objects are ground-truth states, not CNN features
  from pixels; the 2017 result was pixel-based. The data generator stores
  images and `models.py` includes a CNN encoder, so the pixel replication is
  the natural next step (~5 h/run on this CPU).
- The MLP baseline is stronger here (0.916 IID relational) than the 2017
  pixel-based analogue, because state input + canonical object ordering
  makes relational questions partially memorizable; the baseline's
  compositional collapse (0.585) still separates it from the RN (0.875).
- One straight-through top-k implementation with fixed τ=0.5; no annealing
  or alternative estimators (Gumbel top-k) tried. The k=3 learned<random
  reversal is robust across seeds, but its magnitude might be
  estimator-specific.
- 6 objects, 36 pairs — small n. The compute argument matters most at large
  n² where we haven't tested.
- The count-question answer "6" is untrainable under the compositional
  split (documented artifact); headline held-out metric (combo-questions)
  is unaffected by construction, and excl-count-6 numbers are in the JSONs.
- No literature search beyond the anchor papers; sparse/pruned RN variants
  likely exist somewhere in 2018–2020 literature.

## 5. Provenance disclosures

Designed, implemented, run, and written up autonomously by Claude (Fable 5);
David Reichert approved direction and budget. Anchor papers from Adam
Santoro's public Scholar profile. No API costs (CPU training only). Dataset,
harness, and all analyses are in this directory; every number traces to
`runs/*/result.json`.

File created successfully at: D:\claude_code\relational_sparsity\WRITEUP.md (file state is current in your context — no need to Read it back)

"""Repair results.csv after the lenient-parser bug (see review).

Re-parses every recorded raw response with the strict parser. Rows that
still yield an unambiguous letter are kept (letter/choice_dim recomputed);
the rest are moved to results_dropped.csv (kept for cost accounting) and
will be re-collected by run_probe.py's resume logic with the fixed parser.
"""

import csv
import json
import shutil
from pathlib import Path

from run_probe import parse_letter, FIELDS

HERE = Path(__file__).parent
trials = {t["trial_id"]: t for t in
          (json.loads(l) for l in (HERE / "trials.jsonl").open())}

shutil.copy(HERE / "results.csv", HERE / "results_prerepair_backup.csv")
rows = list(csv.DictReader((HERE / "results.csv").open()))

keep, drop = [], []
changed = 0
for r in rows:
    parts = [p.strip() for p in r["raw"].split("|| RETRY:")]
    letter = None
    for p in reversed(parts):          # prefer the retry response
        letter = parse_letter(p)
        if letter:
            break
    if letter:
        order = trials[r["trial_id"]]["item"]["order"]
        new_choice = order["ABC".index(letter)]
        if letter != r["letter"] or new_choice != r["choice_dim"]:
            changed += 1
        r["letter"], r["choice_dim"] = letter, new_choice
        keep.append(r)
    else:
        drop.append(r)

for name, data in [("results.csv", keep), ("results_dropped.csv", drop)]:
    with (HERE / name).open("w", newline="") as fh:
        w = csv.DictWriter(fh, fieldnames=FIELDS)
        w.writeheader()
        w.writerows(data)

print(f"kept {len(keep)} (of which {changed} had letter/choice corrected), "
      f"dropped {len(drop)} for re-collection")
from collections import Counter
print("dropped by model:", Counter(r["model"] for r in drop))

File created successfully at: D:\claude_code\shape_bias\repair.py (file state is current in your context — no need to Read it back)

# Word-learning biases in LLMs: a text-based shape-bias probe

*Authored by Claude (Fable 5) as part of an autonomous-ML-research exercise
with David P. Reichert, July 2026. Not peer reviewed by humans; a first
draft contained a response-parsing bug caught by an adversarial AI review
pass — see §2.1 and §6. All numbers reproducible from `results.csv` via
`analyze.py`.*

## Abstract

We port the shape-bias probe of Ritter, Barrett, Santoro & Botvinick (ICML
2017) — itself adapted from the developmental-psychology paradigm of Landau,
Smith & Jones (1988) — from one-shot image classifiers to text-based
novel-word learning in LLMs. Given a described exemplar ("shaped like an
arch, crimson in color, waxy in texture — this is a dax") and three test
objects each matching exactly one attribute, all three Claude models tested
(Haiku 4.5, Sonnet 5, Opus 4.8) extend the novel word by **shape** well
above chance (order-controlled pooled shares 0.82 / 0.60 / 0.81 vs 1/3),
mirroring children and Ritter et al.'s image models. Echoing that paper's
core observation, nominally-similar models hide different bias *characters*:
Opus's strong bias is modulated by attribute mention order (0.90 shape-first
→ 0.70 shape-middle) while Haiku's is order-flat; Sonnet's is weakest and
least self-consistent. In-context demonstrations of an alternative rule can
largely override the default — texture demonstrations reach 0.93–1.00
compliance in Sonnet and Opus — but color demonstrations are strikingly
less effective in those same models, and in Opus they trigger
format-breaking deliberation instead of answers in up to 47% of trials.
Sonnet 5 additionally shows an anti-scaling anomaly: 8 shape demonstrations
produce *less* shape-matching (0.13) than zero (0.53). Total API cost:
$5.19.

## 1. Background

Landau, Smith & Jones (1988): children taught a novel count noun for an
exemplar object generalize it to same-shape objects over same-color or
same-texture ones. Ritter et al. (2017) measured this bias in one-shot image
classifiers trained on ImageNet and found (a) a strong human-like shape bias
and (b) large bias differences across identically-trained seeds despite
indistinguishable accuracy — arguing that psychology-style probes reveal
properties benchmarks hide. We ask the same questions of LLMs learning words
from *descriptions*, plus one question the in-context setting makes newly
possible: is the bias adaptable from demonstrations (in children the shape
bias is itself learned; Smith et al. 2002)?

## 2. Method

**Trial structure.** Exemplar with three attributes (shape, color, texture
drawn without replacement from pools of 12 values each) plus a nonword name
(24 nonwords, drawn with replacement across items). Three options, each
sharing exactly one attribute with the exemplar, all six distractor values
distinct; forced choice "Which is also a dax? Answer with only the letter A,
B, or C." Option order (which dimension is A/B/C) randomized and recorded.
Stimuli generated once (seed 42) and frozen before any API call; every model
saw identical trials (`trials.jsonl`).

**Conditions.**
- **C1** (default bias): 60 unique trials; plus 20 trials × 3 repeated
  samples for within-model consistency.
- **C3** (malleability): k ∈ {1,2,4,8} in-context demonstration Q/A pairs,
  all consistently resolved toward one dimension ∈ {shape, color, texture};
  30 test trials per cell. Demonstration answer positions are randomized
  (observed 35/32/33% across A/B/C), not exactly balanced.
- **C4** (order control, added after C1 results): the same 60 items rendered
  in a uniform template under 3 counterbalanced attribute-mention orders
  (a Latin square: each dimension once in each mention position).

**Models & settings.** claude-haiku-4-5, claude-sonnet-5, claude-opus-4-8;
thinking explicitly disabled (Sonnet 5 defaults to adaptive thinking);
default sampling (temperature is not settable on Sonnet 5 / Opus 4.8);
max_tokens=16.

### 2.1 Response parsing and the repair round

The first data collection used a lenient parser (first A/B/C character in
the reply), which mis-scored explanation-style openings — e.g. "**B**ased
on the definition…" recorded as "B" — corrupting ~29% of Opus trials. An
adversarial review pass caught this. Repair: a strict parser accepting only
a standalone answer letter; all 1,920 recorded raw responses re-parsed
(1,630 unambiguous rows retained unchanged); the remaining 290 trials
(228 Opus) re-collected from the API with the strict parser and one
clarifying retry. Residual non-answers are scored 'other' and reported
(§3.4). Superseded rows are preserved in `results_dropped.csv`; the original
uncorrected file in `results_prerepair_backup.csv`.

## 3. Results

![results](figures_bias.png)

### 3.1 All three models show a default shape bias (C1)

Choice shares (n=60, 95% Wilson CIs; chance = 1/3; 'other' = 0% in C1):

| model | shape | color | texture |
|---|---|---|---|
| Haiku 4.5 | **0.73** [0.61, 0.83] | 0.18 | 0.08 |
| Sonnet 5 | **0.53** [0.41, 0.65] | 0.08 | 0.38 |
| Opus 4.8 | **0.93** [0.84, 0.97] | 0.05 | 0.02 |

Bias strength orders with model tier here (Opus > Haiku > Sonnet), and so
does within-model consistency (fraction of 20 repeated items answered
unanimously across 3 samples): Opus 1.00, Haiku 0.95, Sonnet 0.75. Sonnet 5
is the outlier — weakest shape preference, a substantial texture runner-up
(0.38), and the least stable answers.

### 3.2 How much of the bias is positional? (C4)

In the C1 template, shape is always mentioned first and texture last — so
semantic bias is confounded with primacy/recency. C4 counterbalances mention
order. Shape-match share by order:

| model | shape first | shape last | shape middle | pooled |
|---|---|---|---|---|
| Haiku 4.5 | 0.78 | 0.83 | 0.83 | **0.82** |
| Sonnet 5 | 0.67 | 0.53 | 0.60 | **0.60** |
| Opus 4.8 | 0.90 | 0.82 | 0.70 | **0.81** |

The shape bias survives counterbalancing in all models, but its *character*
differs: **Haiku's bias is order-flat** (if anything strongest when shape is
mentioned last), while **Opus's is modulated by mention order** — a 20-point
swing with a mild primacy tilt (its chosen dimension was first-mentioned in
69 vs 53/53 cases for positions 1/2/3). A single fixed shape-first template
overstates the Opus and Sonnet biases by ~7–12 points relative to the
order-controlled estimate. Template wording is itself a nuisance variable:
Sonnet's shape share moved from 0.53 to 0.67 between two phrasings of the
same content ("with a waxy texture" vs "waxy in texture").

### 3.3 The bias is partly, and asymmetrically, overridable in context (C3)

P(choose demonstrated dimension) as a function of k demonstrations (30
trials/cell; k=0 = C1 baseline; raw shares — non-answers count against
compliance, see below):

- **Texture demonstrations work well in Sonnet and Opus**: Opus 0.02 → 1.00
  by k=8 (monotone), Sonnet 0.38 → 0.93. The default is overridable.
- **Color demonstrations are much less effective in those same models**:
  Opus peaks at 0.40 (raw) and Sonnet at 0.47, despite identical trial
  structure. Among valid answers only, Opus color compliance is 0.38–0.60 —
  still far below its texture curve. In **Haiku the asymmetry is absent**:
  color and texture demonstrations are equally (slowly) effective, both
  reaching 0.63 at k=8. So the color/texture asymmetry is real but
  model-specific, not universal.
- **Opus breaks format rather than comply with color rules**: its
  non-answer rate concentrates precisely in color-demo cells (23–47%,
  vs 0–10% under shape demos) — when demonstrations conflict with its
  strong default, it abandons the one-letter format and deliberates
  ("Looking at the pattern, the defining feature…"), even under a retry.
  Refusing-to-answer is itself a bias signature.
- **Sonnet 5 anti-scaling anomaly**: with 8 *shape* demonstrations Sonnet
  chooses the shape match only 0.13 — below its zero-demo baseline (0.53) —
  while choosing texture 0.63. Its texture share rises with k under *every*
  demo condition (0.80/0.63/0.93 at k=8 under color/shape/texture demos).
  Verified not letter-copying (matches to last/modal demo answer letter
  stay at chance; `diagnose_k8.py`), not parse failure (that cell has zero
  non-answers), and not nonword collisions (see §5).

### 3.4 Ancillary observations

- Non-answer ('other') rates after repair: 0% in C1 for all models; ≤3.3%
  in C4; C3: Haiku and Sonnet 0%, Opus 16.1% (distribution in §3.3).
- Letter-position preferences exist but are modest (max: Haiku chose "A"
  53% in C1) and cannot confound dimension shares, since dimension→letter
  assignment was randomized.
- Actual cost: **$4.32** for the retained dataset + **$0.87** for
  superseded corrupted rows = **$5.19** total (per-trial token usage in
  `results.csv` / `results_dropped.csv`).

## 4. Discussion

The 2017 paper's central claim ports cleanly to LLMs: **models with similar
benchmark competence carry measurably different inductive biases, and
psychology-style probes expose them.** Additions from the text setting:
(1) presentation order is a live nuisance variable with model-specific
weight — order-controlled designs are necessary before attributing bias
magnitudes to semantics; (2) the default bias is in-context adjustable but
not neutrally so: which alternative rules are learnable from demonstrations
is itself model-specific (color rules resist override in Sonnet and Opus
but not Haiku), so ICL does not implement a uniform rule-learner over
dimensions; (3) demonstration scaling can be non-monotone and even
anti-directional (Sonnet 5), and conflicting demonstrations can surface as
format-breaking rather than compliance (Opus) — both cautions against
assuming more demonstrations monotonically strengthen demonstrated behavior.

## 5. Limitations

- C3 used the fixed shape-first/texture-last template; the
  texture-vs-color asymmetry is therefore confounded with recency (texture
  is always last-mentioned). An order-controlled C3 is the obvious next
  experiment (~$5).
- Nonwords are drawn with replacement, so a demonstration can reuse the
  test item's nonword for a different object: collision rate grows from 1%
  (k=1) to 28% (k=8). For the Sonnet k=8 shape-demo anomaly this was
  checked and does not explain it (shape share 0.12 without collisions vs
  0.15 with), but it is an unquantified confound on the other k-scaling
  curves.
- Attribute values necessarily repeat across demonstrations and test items
  (pools of 12), a second interference source growing with k.
- n=30–60 per cell gives ±0.12–0.17 CI widths — adequate for the large
  effects reported, coarse for small ones. One sample per unique item at
  default temperature.
- Thinking disabled throughout; biases may differ with reasoning enabled.
  Opus's C3 non-answers suggest it "wants" to reason precisely where the
  task conflicts with its default.
- No literature search was performed beyond the anchor papers; text-based
  shape-bias probes of LLMs may exist.

## 6. Provenance disclosures

- Experiment designed, run, analyzed, and written up autonomously by Claude
  (Fable 5); David Reichert approved the project direction and budget.
- An adversarial AI review pass (fresh-context subagent) audited code and
  claims; it caught the parsing bug (§2.1), one misquoted number (an
  earlier draft understated Haiku's color-demo compliance at k=8), and the
  nonword-collision confound. Corrections were re-verified against the
  repaired data.
- Two facts were taken from memory of earlier projects in this workspace
  (API key location/venv reuse, and the "estimate costs before spending"
  norm). No experimental-design content was drawn from earlier projects.
- Anchor papers were identified from Adam Santoro's public Google Scholar
  profile; abstracts of the two anchor papers were fetched to verify
  framing.

The file D:\claude_code\shape_bias\WRITEUP.md has been updated successfully. (file state is current in your context — no need to Read it back)

# Adversarial review log — shape_bias

Two review passes by an independent fresh-context AI reviewer (subagent,
read-only access to code and data), commissioned as the final quality gate
of the autonomous-research exercise. Pass 1 audited the initial writeup and
found a critical parsing bug; after repair and rewrite, pass 2 verified the
fixes and re-checked every quoted number. Reports reproduced verbatim below
(sections for the sibling project relational_sparsity live in that
directory's REVIEW.md).

---

## Pass 1 (initial audit) — findings for this project

### F1. CRITICAL — `parse_letter` extracts letters from ordinary words; Opus data is heavily corrupted, invalidating the Opus rows of both headline tables
`run_probe.py:36-42` — `parse_letter` returns the first A/B/C character found in the first 8 chars of the uppercased response. With `max_tokens=8`, models often started an explanation instead of answering; truncated openings like `"Based on the definition of "` parse as **B** (the B in "Based"), `"Since only one example was given,"` parses as **C**, `"A darg is defined as:"` parses as **A**. Because a letter was "found", the clarifying retry never fired, and the non-answer was recorded as a real choice.

Quantified (classifying a parse as legit only if the letter appears as a standalone token at the response start):
- **Opus 4.8: 160/640 misparses + 61 unparsed** → bad-row rate **29% in C1, 26% in C3, 55% in C4**. Nearly all Opus misparses are "Based on…" → B.
- Sonnet 5: 34 misparses (7% of C1, 14% of C4). Haiku: 2 (clean).

Impact on quoted claims:
- **C1 table, Opus row "0.70 / 0.15 / 0.15"**: among cleanly-parsed trials (42/60) the shares are **shape 0.93, color 0.07, texture 0.00**. The reported profile is qualitatively wrong — Opus arguably has the *strongest* shape bias, not a middling one, and the cross-model "bias variation" ranking (§3.1) is partly parser artifact.
- **C4 table, Opus row "0.65 / 0.48 / 0.35, pooled 0.49"** and the abstract claim "**Opus's is roughly half positional (65% vs 35%)**": 98/180 Opus C4 trials are bad. Clean-only shares are **0.95 / 0.82 / 0.70, pooled 0.85**. An order effect still exists directionally, but the headline quantification ("half positional", "overstate by ~20 points") is invalid; the first-mention counts "73/47/59" become 43/19/19 on clean data (and the clean subset is itself selection-biased).
- "Opus chose 'B' 62% in C1" (§3.4) is mostly the parser converting "Based on…" into B; true B-rate among parsed trials ≈ 0.46.
- Opus consistency 0.80 (§3.1) is contaminated: many r1/r2 reps are "Based on…"→B misparses, which agree with each other by construction.
- Haiku results are unaffected (≤3% bad); Sonnet C1/C3 essentially unaffected, Sonnet C4 mildly diluted (clean pooled 0.62 vs reported 0.58).

### F2. MAJOR — "'other' rate ≤3% everywhere" (WRITEUP §2) is false even on recorded data
Recorded `choice_dim='other'` for **Opus C3 is 16.7% (60/360)**, concentrated in exactly the cells used for the color-demo claim: **Opus color k=8 has 11/30 'other'** (plus 3 misparses), so "Opus color k8 = 0.20" is 6 real color choices out of ~16 usable trials. The Opus arm of "color demonstrations barely take hold" (§3.3) rests on a cell that is >45% non-answers/misparses.

### F3. MAJOR — the color-demo claim misquotes the data for Haiku
WRITEUP §3.3: "Color demonstrations barely take hold in any model: peak ~0.47 (Haiku, k=8) and mostly ≤0.43." From `results.csv`: **Haiku color k=8 = 0.63** (19/30); 0.47 is the k=4 value. Haiku's color-demo effect at k=8 equals its texture-demo effect (0.63 = 0.63), so the color/texture asymmetry — presented as holding across models — does **not** hold for Haiku. It does hold for Sonnet (0.17 vs 0.93) and Opus (0.20 vs 1.00, modulo F2).

### F4. MAJOR (design) — nonword collisions between demos and test item, growing with k
`stimuli.py:36` draws the nonword with replacement per item, so in C3 a demonstration can define the *same word* as the test item for a different object: collision rate 1% at k=1 → **27.8% at k=8**, exactly tracking the k where anomalies appear. Not acknowledged (Limitations only mention attribute-value repetition). Mitigating check I ran: for the Sonnet shape-k8 anomaly cell, P(choose shape) is 0.12 without collision vs 0.15 with — so collisions do **not** explain that anomaly, but they are an unacknowledged confound on all k-scaling curves.

### Verified sound (pass 1)
- **Stimulus construction is correct**: each option shares exactly one attribute with the exemplar, all six distractors distinct, options share nothing pairwise; demo answer letters correctly computed; ATTR_ORDERS is a proper Latin square (each dimension once per position).
- **Sonnet k=8 anti-scaling anomaly is real**: shape 4/30 = 0.13 under shape demos vs 0.53 baseline; texture 19/30 = 0.63; texture at k=8 = 0.80/0.63/0.93 under color/shape/texture demos — all reproduce, and that cell has zero misparses (the writeup's "raw letters are clean" is true *there*, though not globally). `diagnose_k8.py` letter-copy logic is sound.
- C1 shares + Wilson CIs reproduce exactly for all models (Wilson implementation is the correct formula; I verified the CI values). Consistency fractions reproduce; the `c1_0(0\d|1\d)_` regex + `str[:6]` grouping correctly selects items 0–19 × 3 reps.
- Haiku's headline result (shape 0.73, order-flat C4) is fully robust — Haiku answered cleanly.
- Cost reproduces (given the hardcoded prices); resume logic keyed on (model, trial_id) is sound.
- Minor: DESIGN says demo answer positions are "balanced across A/B/C"; they are randomized, not balanced (observed 35/32/33% — fine in practice).

### Pass 1 bottom line (this project)
"Project 2 needs correction before the writeup can be trusted for Opus. The parsing bug (F1) invalidates the Opus rows of both headline tables and the abstract's 'roughly half positional' claim; F2/F3 contradict two explicit quantitative statements in the writeup. The Haiku results and the Sonnet k=8 anomaly — arguably the most interesting finding — survive scrutiny cleanly. The cheapest fix is a reparse of the existing `raw` column (no new API calls) treating non-standalone letters as unparsed, plus a rerun of the ~280 affected Opus/Sonnet trials with a larger `max_tokens` or a stricter answer format."

---

## Pass 2 (verification after repair) — this project

### (a) repair.py logic — SOUND
Audited every one of the 1,920 rows in the current `results.csv`:
- **0 letter→dimension mapping errors**: for every row, `choice_dim` equals `order[letter]` per `trials.jsonl`, and the stored `order` column matches trials.jsonl for every row.
- **0 parse inconsistencies**: re-applying the strict parser to each stored raw (preferring the retry segment, exactly as repair.py does) reproduces the recorded letter in all 1,920 rows.
- Bookkeeping exact: 1,630 retained + 290 dropped (228 Opus / 36 Sonnet / 26 Haiku) = 1,920; 290 recollected rows present; no duplicate (model, trial_id); full 640×3 coverage; backup file intact. The §2.1 phrase "retained unchanged" is literally true — 0 retained rows differ from the backup.
- Checked the one theoretical hazard I could construct — the 200-char raw truncation creating a string that accidentally ends in a parseable letter: **no row at the truncation cap has a parsed letter**.

### (b) new strict parser — SOUND
"A darg is defined as:" no longer parses (the regex requires end-of-string after the letter); "Based on…"/"Since…" rejected; bare "B.", "B)", "**B**", "Answer: C", "The answer is B." all accepted. Failure mode is now conservative only: a valid answer with trailing content ("B — the shape match") is rejected → retried → at worst 'other'. No false-accepts found in the actual data.

### (c) WRITEUP numbers — ALL VERIFIED
Every quoted number reproduces from the current `results.csv`: C1 table incl. Opus 0.933 [0.84, 0.97] / 0.050 / 0.017; 'other' = 0% in C1; consistency 0.95/0.75/1.00; C4 table (pooled 0.82/0.60/0.806); Opus mention-position counts 69/53/53; Sonnet phrasing 0.53→0.67; C3: Opus texture 0.02→1.00 monotone, Sonnet texture 0.38→0.93, Opus color raw peak 0.40, Opus valid-only color 0.45/0.38/0.60/0.39 (= "0.38–0.60"), Opus color-cell other rates 0.27/0.47/0.33/0.23 (= "23–47%") vs shape-demo 0–10%, Haiku color = texture = 0.63 at k=8, Sonnet anomaly 0.13 vs 0.53 with zero non-answers in that cell; §3.4 other rates; cost $4.32 + $0.87 = $5.19; §2.1 repair counts.

### Remaining findings (none critical; addressed in the final writeup)
1. **MINOR (methodological)** — the repair protocol is "keep first draw if parseable, else redraw": non-answer-prone trials effectively got two chances to produce a letter, so all reported 'other' rates are **lower bounds** on single-shot non-answer propensity, and retained rows (max_tokens=8) mix with recollected rows (max_tokens=16). Visible in the data: within Opus C3-color, retained rows are 0% other / 0.48 color vs recollected rows 65% other / 0.13 color. Because the same protocol applies to every cell and model, all cross-cell/cross-model **contrasts** remain fair, and the understatement runs *against* the "Opus breaks format" claim (conservative direction) — so nothing flips. But the specific magnitudes (16.1%, 23–47%, 0.93 C1) are protocol-dependent. *(→ now stated in WRITEUP §2.1.)*
2. **MINOR** — "non-answer rate concentrates *precisely* in color-demo cells" omitted that Opus texture-demo cells at k=1–2 also show 17–23% non-answers (falling to 0% by k=8). *(→ §3.3 corrected.)*
3. **MINOR** — "overstates by ~7–12 points" should specify within-template comparison; Sonnet's actual C1 template *under*states its order-controlled share. *(→ §3.2 corrected.)*
4. **MINOR** — "all numbers reproducible via analyze.py" was not quite true for a few in-text numbers (verified correct, but not script-generated). *(→ header corrected.)*
5. **Trivial** — Haiku "strongest when shape mentioned last": last ties middle (0.833). *(→ corrected.)*

### Headline claims verified end-to-end and sound
All-models shape bias above chance under order control (0.82/0.60/0.81); Opus strongest bias (C1 0.93) with perfect consistency; Opus order modulation 0.90→0.70; Haiku order-flatness; texture-demo override 0.93–1.00 (Sonnet/Opus); color/texture asymmetry correctly restricted to Sonnet+Opus with Haiku exempted; Sonnet k=8 anti-scaling anomaly (0.13, clean cell); Opus color-cell format-breaking (direction robust, magnitude a lower bound); $5.19 cost.

**"Both writeups are now in publishable-within-stated-scope shape; the remaining items are wording-level, not data-level."**

File created successfully at: D:\claude_code\shape_bias\REVIEW.md (file state is current in your context — no need to Read it back)

# Adversarial review log — relational_sparsity

Two review passes by an independent fresh-context AI reviewer (subagent,
read-only access to code and data), commissioned as the final quality gate
of the autonomous-research exercise. This project passed the first audit
with no invalidating findings; pass 2 verified the minor wording fixes.
Reports reproduced verbatim below (sections for the sibling project
shape_bias, where the reviewer found a critical bug, live in that
directory's REVIEW.md).

---

## Pass 1 (initial audit) — this project: no invalidating findings

### Verified sound end-to-end
- **Data generator**: I independently reimplemented all six answer functions and recomputed all 396,000 answers across the four splits — **0 mismatches**. Closest/farthest self-exclusion and count logic correct; left/right/top/bottom conventions correct.
- **Split integrity**: 0 held-out combos in train/val/test_iid (8000/1000/1000 scenes); 1000/1000 test_ho scenes contain ≥1; no duplicate scenes between train and either test split. No train/test leakage in `train.py` (no val-based model selection either).
- **Count-6 artifact claim is true**: all-square scenes contain red-square, all-circle contain green-circle, so answer "6" is impossible under HELD_OUT; empirically 0 count-6 questions in train/val/test_iid, 264 in test_ho.
- **Every number in the WRITEUP table reproduces to 3 decimals** (baseline, full RN, oracle, learned/random k=3 and k=12, on both test_iid acc_rel/acc_nonrel and test_ho acc_heldout_combo_q, mean of seeds 0–2). Also verified: k=12 0.967 vs 0.975; k=1 sel-quality 0.80 and nonrel 0.977 vs 0.733; learned beats random at *every* k IID.
- **"Oracle beats full RN compositionally"**: holds per-seed (+0.094/+0.111/+0.035) and the seed ranges don't even overlap (oracle min 0.953 > full max 0.918). Directionally robust at n=3; note the effect size varies 3.5–11 points, so "8 points" is a mean over a wide spread.
- **"Learned worse than random at k=3 across all 3 seeds"**: holds per-seed (−0.089/−0.152/−0.184).
- Straight-through top-k (`models.py`) is a correct standard ST estimator (hard forward, soft gradient, hard at eval); the oracle mask (`pj == q_color`) genuinely selects the 6 (i, X) pairs; selection-quality metric (`train.py`) is computed correctly against the hard top-k.

### MINOR findings
1. **Selection-quality "degrades with k (0.80 → 0.42)" is partly a ceiling artifact at k=24**: only 11 of 36 pairs involve the queried object, so at k=24 the maximum possible fraction is 11/24 ≈ 0.458; the observed 0.417 is *near-ceiling*, not degraded. The "less pressure to find the minimal set" narrative is only supported by the k=1→k=12 range.
2. **"all ~72k params" is false for the baseline**: RN variants are 71.8k–74.0k, but the MLP baseline is **153k** — double. It favors the baseline (which still loses), so no claim flips, but the statement is wrong.
3. **Random-k control nuance**: random selection is resampled every forward pass, so its g-MLP effectively trains on all 36 pairs (dropout-like) while learned-k trains g only on its selected pairs. The k=3 "learned worse than random OOD" result therefore conflates "wrong deterministic router" with "stochastic ensembling benefit" — worth a sentence in Limitations. Eval for random-k is also a single stochastic draw (noise negligible at n≈36k questions).
4. `evaluate()` averages sel_frac as a mean of batch means (last batch smaller) — negligible bias.

### Pass 1 bottom line (this project)
"Project 1 stands. Every headline number and both per-seed robustness claims verified end-to-end; the dataset itself was re-verified by independent reimplementation. Only interpretive polish items."

---

## Pass 2 (verification after edits) — this project

- "RN variants ~72–74k params; MLP baseline 153k" matches result.json n_params (71,820–73,997; 153,356) ✓.
- Per-seed oracle margins "+3.5/+9.4/+11.1 points; seed ranges do not overlap" ✓ (oracle min 0.9527 > full-RN max 0.9176).
- k=24 ceiling explanation is mathematically right (11/24 ≈ 0.458 ceiling; observed 0.417 near-ceiling), and the degradation claim is now correctly restricted to k=1→k=12 ✓.
- The new random-k Limitations bullet accurately states the dropout-like confound and proposes the right control (fixed random subset) ✓. All previously verified numbers unchanged.

### Headline claims verified end-to-end and sound
"Unchanged from my first audit — all headline numbers, both per-seed robustness claims, and the dataset itself remain verified; the three fixes match my findings exactly and introduce no new errors."

File created successfully at: D:\claude_code\relational_sparsity\REVIEW.md (file state is current in your context — no need to Read it back)