Reproducing the Traps in the Original Code

Generated with Claude Code, and I am not ashamed. My own blog posts of this kind are part of the training data and have sculpted its style.

A companion to A Vector-Symbolic Clojure. The overview found seven traps in a vector-symbolic Lisp. This page runs each one against the original authors’ own code. October 2026.

Our Clojure started from Tomkins-Flanagan and Kelly’s “Hey Pentti, We Did It!” (ICCM 2024). That paper built Lisp 1.5 out of holographic vectors and showed that it can be done. Their follow-up with Hanley, “Hey Pentti, We Did (More of) It!” (IJCNN 2025), added integers in residue arithmetic. Both have public code. Our seven traps came from our code. The fair question is which of them exist in theirs. Here we answer it by running their code: we fetch it at a pinned commit, add noise the way our paper does, and count. The section numbers 4.1–4.7 are those of our paper draft; they are the overview’s traps 1–7 in the same order.

Their papers are proofs of concept, and their READMEs say so. Nothing below changes that. A proof of concept is where the next person starts, and this page lists what that next person (us) ran into.

The two codebases

holis (eilene-ftf/holis, commit db208d7, AGPL-3.0) is one Jupyter notebook. It adapts Norvig’s lispy to holographic reduced representations (HRR) at D = 512:

  • Vectors are random Gaussian, bound by circular convolution.
  • A cons cell is the bundle lhs⊗a + rhs⊗b + φ, but it is stored behind a fresh random pointer in a second memory, because, in the notebook’s words, “tuples turn out to degrade rather quickly”. Equal bundles share a pointer.
  • CAR and CDR follow the pointer, unbind a role and clean up against a lookup table (argmax).
  • The pointer memory looks up a noisy pointer by its nearest key, but only if the cosine exceeds θ = 0.2. Otherwise it returns the probe itself.
  • The evaluator tests with a fixed floor of 0.2, and COND is the paper’s saturating ⊕ with cutoffs 0.8 and 0.2.
  • Functions work by substitution, so there are no environments. Numbers are Peano lists: 0 is NIL and n+1 is (n).

residuelisp (hanleyc01/residuelisp, commit 09864c7, MIT) is the code of the second paper, a typed Python package. It uses complex FHRR vectors at D = 1000:

  • Cells sit behind pointers, as in holis.
  • Function calls bind parameters in a small memory keyed by symbol.
  • Integers are Kymn et al.’s residue code over the moduli 3, 5, 7, 11 (range 0..1154), plus a tag: int(x) = ζ(x) + int.
  • It keeps holis’s numbers: θ = 0.2 in the pointer memory and a 0.2 floor in its approximate equality. Its similarity is not normalised, though.

What we ran

Nothing of theirs is copied into our repository. A small loader fetches each codebase at its pinned commit when a script runs. For holis it executes the notebook’s code cells as a module. The scripts in repro/holis/ then:

  • add probe noise exactly as in our paper: before every cleanup, the probe p becomes p + σ·|p|/√D · N(0, I). Cleanups are the item memory, the function memory and the pointer memory;
  • change at most one thing as a control, and say which;
  • count over seeds, and write every number on this page to a JSON file that the page reads.

First, their code works. Noise-free, holis computes these at D = 512 and 2048 over 5 seeds each:

program D correct 
(CAR (a b c))
 512 5 / 5 
(CDR (a b c))
 512 5 / 5 
(CONS a (b c))
 512 5 / 5 
(EQ a a)
 512 5 / 5 
(EQ a b)
 512 5 / 5 
(ATOM a)
 512 5 / 5 
(ATOM (a b))
 512 5 / 5 
(COND ((EQ a a) . yes) (T . no))
 512 5 / 5 
(COND ((EQ a b) . yes) (T . no))
 512 5 / 5 
((LAMBDA (x) (CONS x (b c))) a)
 512 4 / 5 
(CAR (a b c))
 2048 5 / 5 
(CDR (a b c))
 2048 5 / 5 
(CONS a (b c))
 2048 5 / 5 
(EQ a a)
 2048 5 / 5 
(EQ a b)
 2048 5 / 5 
(ATOM a)
 2048 5 / 5 
(ATOM (a b))
 2048 5 / 5 
(COND ((EQ a a) . yes) (T . no))
 2048 5 / 5 
(COND ((EQ a b) . yes) (T . no))
 2048 5 / 5 
((LAMBDA (x) (CONS x (b c))) a)
 2048 4 / 5

One program misses a seed. We return to it under E1 below. The authors’ own fizzbuzz helpers, verbatim from the notebook, also give the right answers. They are slow, which is why the noise sweeps below use smaller programs:

program result expected seconds
their fizzbuzz DEFINEs 
["NIL", "NIL", "NIL", "NIL", "NIL", "NIL", "NIL", "NIL", "NIL"]
 
["NIL", "NIL", "NIL", "NIL", "NIL", "NIL", "NIL", "NIL", "NIL"]
 5.9
countdown 3 1 
[[["NIL"]]]
 
[[["NIL"]]]
 16.6
divisible 3 3 
["T"]
 
["T"]
 83.1
divisible 4 3 
["F"]
 
["F"]
 767.8
and T F 
["F"]
 
["F"]
 51.7
take 2 (a b c) 
[["a", "b"]]
 
[["a", "b"]]
 241.2

residuelisp, noise-free at D = 1000 over 5 seeds:

program expected correct 
(+ 1 2 )
 
3
 5 / 5 
(+ 20 22 )
 
42
 5 / 5 
(- 7 3 )
 
4
 5 / 5 
(car (cons 1 2 ) )
 
1
 5 / 5 
(cdr (cons a b))
 
b
 5 / 5 
((lambda (x) ((lambda (y) (cons x (cons y nil))) n)) m)
 
["m", "n"]
 5 / 5 
(eq? a a)
 
#t
 5 / 5 
(eq? a b)
 
#f
 5 / 5 
(eq? 3 3 )
 
#t
 5 / 5 
(int? 3 )
 
#t
 5 / 5 
(int? a)
 
#f
 5 / 5 
(and #t #t)
 
#t
 5 / 5 
(and #f #t)
 
#f
 5 / 5 
(if #t yes no)
 
yes
 5 / 5 
(if #f yes no)
 
no
 5 / 5

So both interpreters do what their papers show. What follows asks for more than the papers claim.

4.1 Superposed cells: the paper has them, the code does not

Applies? To the paper’s equation (2), cons(a, b) = ν(L⊗a + R⊗b + φ), yes. To the code, no: both codebases put each cell behind a random pointer, as our fix does. The holis notebook gives the reason in a comment.

To see the paper’s cell inside their code, we added a paper mode. It is two attributes on their pointer memory: a cell is stored as its own normalised bundle, and “following” it returns it unchanged. The evaluator, CAR, CDR and the reader stay theirs. At D = 2048, Peano numerals n and n+1 then look alike. Pointer cells do not:

mode mean cos(n, n+1) mean cos(n, n+2) seeds
pointer 0.000 0.005 5
paper 0.743 0.721 5

Reproduced? Yes, noise-free, and in a way we did not expect. Their evaluator decides that an expression “evaluates to itself”, and stops, when the result is similar to the input: (ee == e) > 0.2. With pointers, a form and its result are unrelated. With superposed cells, a form and its first evaluation step share terms, and their cosine is well above 0.2:

mode program correct results mean cos(form, first step)
pointer 
(CAR (a b c))
 10 / 10 ["a"] ×10 0.005
pointer 
(COND ((EQ a b) . yes) (T . no))
 10 / 10 ["no"] ×10 0.001
pointer 
((LAMBDA (x) (CONS x (b c))) a)
 9 / 10 [["a", "b", "c"]] ×9, [["a", "LAMBDA", ["c"], "LAMBDA"]] ×1 0.005
paper 
(CAR (a b c))
 10 / 10 ["a"] ×10 -0.003
paper 
(COND ((EQ a b) . yes) (T . no))
 10 / 10 ["no"] ×10 -0.001
paper 
((LAMBDA (x) (CONS x (b c))) a)
 0 / 10 [["CONS", "a", ["b", "c"]]] ×7, [["CONS", ["x", "b", "c"], ["b", "c"]]] ×2, [["CONS", ["b", "c"], ["b", "c"]]] ×1 0.435

In paper mode the LAMBDA program stops after the substitution and returns the body unevaluated. This is 4.1’s lesson in its plainest form: similarity of content is not identity.

Under noise the picture is less clean. Here numerals 1 to 8 are built, and then numeral 4 is read back with their reader:

σ pointer pointer, theta=5/sqrt(D) pointer, theta=-1 paper
0 20 / 20 20 / 20 0 / 20 20 / 20
0.500 20 / 20 20 / 20 0 / 20 20 / 20
1 20 / 20 20 / 20 0 / 20 20 / 20
1.500 20 / 20 20 / 20 0 / 20 20 / 20
2 20 / 20 20 / 20 0 / 20 20 / 20
3 20 / 20 20 / 20 0 / 20 19 / 20
4 16 / 20 20 / 20 0 / 20 17 / 20
5 0 / 20 18 / 20 0 / 20 15 / 20
6 0 / 20 17 / 20 0 / 20 14 / 20
8 0 / 20 1 / 20 0 / 20 5 / 20
10 0 / 20 0 / 20 0 / 20 1 / 20
12 0 / 20 0 / 20 0 / 20 0 / 20
16 0 / 20 0 / 20 0 / 20 0 / 20

With their θ = 0.2, pointer cells fail first, because of that threshold (4.5 below). With θ set relative to chance, 5/√D, the comparison is between encodings alone. Then the curves cross: pointer cells read more numerals right at σ = 5 and 6, superposed cells at σ = 8. So this test does not show the loss of noise tolerance we measured in our own code (§4.1 of our paper). One difference: a superposed cell needs no pointer lookup, so each read makes fewer noisy cleanups. Plain argmax (θ = −1) breaks the pointer reads even at σ = 0. Their atom test needs a threshold, which we come back to in 4.5.

Verdict. The paper’s cell causes a noise-free failure in their code. The code’s own cell does not have that problem. The extra noise sensitivity did not reproduce in our read test.

4.2 Binding commutes

Applies? Mostly no. Neither codebase stores an unlabelled pair: cells carry the roles lhs and rhs. holis has no environments, and residuelisp’s are a keyed memory, not a sum of var⊗value. As a control, (x . y) and (y . x) read back correctly every time.

There is one opening. In holis the roles are also ordinary atoms: vsa_env enters lhs, rhs and φ in the lexicon. A program that mentions the symbol lhs therefore gets the role vector itself. The cell (x . lhs) then contains lhs⊗x + rhs⊗lhs. Unbinding lhs finds x and rhs at equal strength, because rhs⊗lhs = lhs⊗rhs.

Reproduced? Yes, through their parser, evaluator and reader, 40 seeds per row:

program D expected correct results 
(CAR (x . lhs))
 512 x 18 / 40 rhs ×22, x ×18 
(CDR (rhs . x))
 512 x 17 / 40 lhs ×23, x ×17 
(CAR (x . rhs))
 512 x 40 / 40 x ×40 
(CDR (lhs . x))
 512 x 40 / 40 x ×40 
(CAR (x . y))
 512 x 40 / 40 x ×40 
(CAR (y . x))
 512 y 40 / 40 y ×40 
(CDR (x . y))
 512 y 40 / 40 y ×40 
(CDR (y . x))
 512 x 40 / 40 x ×40 
(CAR (x . lhs))
 2048 x 19 / 40 rhs ×21, x ×19 
(CDR (rhs . x))
 2048 x 22 / 40 x ×22, lhs ×18 
(CAR (x . rhs))
 2048 x 40 / 40 x ×40 
(CDR (lhs . x))
 2048 x 40 / 40 x ×40 
(CAR (x . y))
 2048 x 40 / 40 x ×40 
(CAR (y . x))
 2048 y 40 / 40 y ×40 
(CDR (x . y))
 2048 y 40 / 40 y ×40 
(CDR (y . x))
 2048 x 40 / 40 x ×40 
(CAR (x . lhs))
 8192 x 20 / 40 x ×20, rhs ×20 
(CDR (rhs . x))
 8192 x 22 / 40 x ×22, lhs ×18 
(CAR (x . rhs))
 8192 x 40 / 40 x ×40 
(CDR (lhs . x))
 8192 x 40 / 40 x ×40 
(CAR (x . y))
 8192 x 40 / 40 x ×40 
(CAR (y . x))
 8192 y 40 / 40 y ×40 
(CDR (x . y))
 8192 y 40 / 40 y ×40 
(CDR (y . x))
 8192 x 40 / 40 x ×40

About half the reads give the wrong atom at every D. It is a tie, not noise, so a bigger D does not help. residuelisp names its roles __lhs and __rhs. Its lexer starts identifiers with a letter, so a program cannot name them (we read this in their lexer and did not run it).

4.3 Residue chimeras

Applies? Not as we found it. Our chimeras came from giving each prime its own band of coordinates, so each band could match a different member of a sum. residuelisp uses Kymn et al.’s product code instead: every coordinate mixes all four moduli. We measured with their RHC.encode on the sum ζ(11) + ζ(12). Its 14 chimeras (integers whose residues each match 11 or 12) score like any other integer:

D cos to 11 cos to 12 chimeras: mean chimeras: max others: mean |cos| seeds
1000 0.704 0.704 -0.004 0.061 0.018 5
4096 0.704 0.704 0.000 0.025 0.009 5

Decoders tell the same story. Their interpreter decodes integers with decode_rhc, an argmax over the codes of 0..199. Their library also has resonator_decoding, the resonator network the paper describes. The interpreter does not call it, and its test is commented out. We read its output residue by residue, by magnitude, because a resonator finds each factor only up to a phase. Counts over the seeds:

readout of ζ(11) of ζ(11) + ζ(12): a member of ζ(11) + ζ(12): a chimera
decode_rhc 10 / 10 10 / 10 0 / 10
resonator_decoding 10 / 10 10 / 10 0 / 10

A residuelisp program cannot build such a sum anyway. Integers come from literals and + / - only, and cells hold them behind pointers.

Reproduced? No. The chimeras belong to the banded encoding, which residuelisp does not use.

4.4 Zero

Applies? No. Our zero problem had two parts, and neither carries over. On bands, an n divisible by several of the primes looked partly like zero, because each such band matched. In the product code, an n that some moduli divide is still unrelated to zero, unless all four divide it, which means n ≡ 0 mod 1155:

D cos(ζ0, ζ1) cos(ζ0, ζ3) cos(ζ0, ζ15) cos(ζ0, ζ105) cos(ζ0, ζ385) cos(ζ0, ζ1154) cos(ζ0, ζ1155)
1000 -0.008 -0.013 -0.014 -0.002 0.001 -0.008 1.000
4096 -0.008 0.003 0.006 0.004 0.003 -0.008 1.000

The wrap at 1155 is the residue range itself, so it is by design. Our second part was that B⁰ was a spike in dimension 0, so damaging that one dimension broke all arithmetic. In FHRR, zero is the all-ones vector, spread evenly. With coordinate 0 zeroed, ζ(17)·ζ(25) still reads as 42:

D seed argmax over 0..199 cos to ζ(42)
1000 0 42 0.999
1000 1 42 0.999
1000 2 42 0.999
1000 3 42 0.999
1000 4 42 0.999
4096 0 42 1.000
4096 1 42 1.000
4096 2 42 1.000
4096 3 42 1.000
4096 4 42 1.000

Reproduced? No.

4.5 Fixed thresholds cap robustness

Applies? To holis, yes. Its pointer memory accepts the nearest key only above cosine θ = 0.2. A probe with noise σ has cosine 1/√(1 + σ²) to its key. That falls below 0.2 at σ = √24 ≈ 4.9, whatever D is.

Reproduced? Yes. The control is the same code with θ = 5/√D, a threshold relative to chance, as our paper prescribes. It is one attribute set on their object. Plain argmax (θ = −1) would not do: their atom test needs the threshold to tell an atom, which matches no pointer, from a cell. With θ = −1 even noise-free reads fail. For D = 512, 5/√D = 0.22 is close to their 0.2. First, single CAR lookups on 25 stored 4-lists, 200 lookups per cell. The cells give correct lookups, and in parentheses how often θ made the memory return the probe itself:

σ D=512, theirs (theta=0.2) D=512, chance floor (theta=5/sqrt(D)) D=2048, theirs (theta=0.2) D=2048, chance floor (theta=5/sqrt(D)) D=8192, theirs (theta=0.2) D=8192, chance floor (theta=5/sqrt(D))
0 200 (0) 200 (0) 200 (0) 200 (0) 200 (0) 200 (0)
1 200 (0) 200 (0) 200 (0) 200 (0) 200 (0) 200 (0)
2 196 (0) 196 (0) 200 (0) 200 (0) 200 (0) 200 (0)
3 159 (0) 159 (1) 200 (0) 200 (0) 200 (0) 200 (0)
4 103 (26) 84 (54) 195 (4) 199 (0) 200 (0) 200 (0)
4.500 48 (75) 38 (101) 164 (37) 199 (0) 190 (10) 200 (0)
5 26 (104) 15 (147) 83 (118) 194 (0) 75 (126) 200 (0)
5.500 21 (141) 12 (165) 31 (165) 178 (0) 6 (197) 200 (0)
6 9 (160) 7 (180) 8 (194) 165 (0) 1 (200) 200 (0)
7 3 (183) 2 (194) 2 (199) 119 (15) 1 (200) 200 (0)
8 5 (191) 4 (197) 1 (200) 91 (46) 0 (200) 200 (0)
10 1 (198) 1 (200) 0 (200) 21 (147) 1 (200) 188 (0)
12 1 (200) 1 (200) 2 (200) 8 (179) 2 (200) 166 (0)
16 2 (200) 2 (200) 2 (200) 2 (200) 2 (200) 83 (46)

With their θ, the lookups collapse between σ = 5 and 5.5 at D = 2048 and at D = 8192 alike, just past the predicted 4.9, and the fallback count shows why. With the chance floor, D = 8192 still gets 200 of 200 at σ = 8. At D = 512 the two rows agree, because there the item memory gives out first, and 5/√512 is close to 0.2 anyway.

The same holds one level up. Here is a 4-list read back with their reader, 20 seeds per cell:

σ D=512, theirs (theta=0.2) D=512, chance floor (theta=5/sqrt(D)) D=2048, theirs (theta=0.2) D=2048, chance floor (theta=5/sqrt(D)) D=8192, theirs (theta=0.2) D=8192, chance floor (theta=5/sqrt(D))
0 20 / 20 20 / 20 20 / 20 20 / 20 20 / 20 20 / 20
1 20 / 20 20 / 20 20 / 20 20 / 20 20 / 20 20 / 20
2 20 / 20 20 / 20 20 / 20 20 / 20 20 / 20 20 / 20
3 14 / 20 14 / 20 20 / 20 20 / 20 20 / 20 20 / 20
4 0 / 20 0 / 20 17 / 20 20 / 20 20 / 20 20 / 20
5 0 / 20 0 / 20 0 / 20 18 / 20 0 / 20 20 / 20
6 0 / 20 0 / 20 0 / 20 15 / 20 0 / 20 20 / 20
8 0 / 20 0 / 20 0 / 20 0 / 20 0 / 20 20 / 20
10 0 / 20 0 / 20 0 / 20 0 / 20 0 / 20 18 / 20
12 0 / 20 0 / 20 0 / 20 0 / 20 0 / 20 11 / 20

And a whole program, ((LAMBDA (x) (CONS x (b c))) a), 10 seeds per cell. Its noise-free row already misses some seeds (E1 below):

σ D=512, theirs (theta=0.2) D=512, chance floor (theta=5/sqrt(D)) D=2048, theirs (theta=0.2) D=2048, chance floor (theta=5/sqrt(D)) D=8192, theirs (theta=0.2) D=8192, chance floor (theta=5/sqrt(D))
0 9 / 10 9 / 10 9 / 10 9 / 10 7 / 10 7 / 10
2 6 / 10 6 / 10 10 / 10 10 / 10 7 / 10 7 / 10
4 0 / 10 0 / 10 3 / 10 10 / 10 8 / 10 8 / 10
5 0 / 10 0 / 10 0 / 10 7 / 10 0 / 10 8 / 10
6 0 / 10 0 / 10 0 / 10 0 / 10 0 / 10 8 / 10
8 0 / 10 0 / 10 0 / 10 0 / 10 0 / 10 7 / 10
10 0 / 10 0 / 10 0 / 10 0 / 10 0 / 10 3 / 10

Their θ stops the program at σ = 5 for D = 2048 and 8192 alike. With the chance floor, D = 8192 still gets 8 of 10 at σ = 5 and 6. That is as many as at σ = 4, and more than the 7 of 10 at σ = 0, which E1 costs.

residuelisp keeps the 0.2 but compares it with an unnormalised similarity. A noisy pointer keeps similarity about 1 to its own key at any σ. What grows is the spread of chance matches, about √((1 + σ²)/(2D)). So the cutoff should give way at a σ that grows like √D. Here is the two-lambda program, 10 seeds per cell:

σ D=500 D=2000 D=8000
0 10 / 10 10 / 10 10 / 10
1 10 / 10 10 / 10 10 / 10
2 7 / 10 10 / 10 10 / 10
3 0 / 10 10 / 10 10 / 10
4 0 / 10 8 / 10 10 / 10
6 0 / 10 0 / 10 10 / 10
8 0 / 10 0 / 10 9 / 10
12 0 / 10 0 / 10 1 / 10
16 0 / 10 0 / 10 0 / 10
24 0 / 10 0 / 10 0 / 10
32 0 / 10 0 / 10 0 / 10

The last σ with all 10 runs right is 1 at D = 500, 3 at D = 2000 and 6 at D = 8000. It roughly doubles for each 4× in D, as √D predicts. So in residuelisp the fixed numbers do not set a cap independent of D. Its failures are loud: every failing run raised an exception (mostly InterpreterError) or hit our cleanup budget, and none returned a wrong value (raw table in the appendix). The price of the unnormalised similarity is elsewhere, in 4.6.

4.6 A shared field: the integer tag

Applies? Not to holis, which has no records. It does apply to residuelisp, in a form we did not foresee. Every integer carries the same tag, int(x) = ζ(x) + int, which is the paper’s equation (11). Atoms count as eq? when their unnormalised similarity exceeds 0.2, and the tag alone contributes 1. So any two integers are equal.

Reproduced? Yes, noise-free at D = 1000, in 5 of 5 seeds (rows R1 below). The similarities behind it:

seeds sim(3,3) sim(3,5) sim(3,1000) sim(a,b) cos(3,5) cos(3,1000)
5 1.988 1.022 0.952 0.013 0.509 0.482

Their own tests compare an arithmetic result with the expected integer through this equality. So those assertions pass whatever integer the arithmetic returns. In their test’s pattern, the result of (+ 5 5) “equals” 10, 7, 0 and 999:

seed program equals(result, n) for n = 10, 7, 0, 999
0 
(+ 5 5 )
 10 ×#t, 7 ×#t, 0 ×#t, 999 ×#t
1 
(+ 5 5 )
 10 ×#t, 7 ×#t, 0 ×#t, 999 ×#t
2 
(+ 5 5 )
 10 ×#t, 7 ×#t, 0 ×#t, 999 ×#t
3 
(+ 5 5 )
 10 ×#t, 7 ×#t, 0 ×#t, 999 ×#t
4 
(+ 5 5 )
 10 ×#t, 7 ×#t, 0 ×#t, 999 ×#t

4.7 A sum of tuples

Applies? No. Neither codebase builds superpositions of values, and neither has positional vectors, so there are no joint worlds to lose.

Further errata

Running the code turned up problems that our list does not cover. All are noise-free.

E1 (holis). CAR of an atom. To decide “is this head a lambda expression?”, their evaluator compares car(head) with LAMBDA. It does this even when head is an atom, and an atom has no CAR. car() then cleans up a meaningless probe and returns some stored item. When that item happens to match, the evaluator takes the wrong branch. Here is ((LAMBDA (x) (CONS x (b c))) a) over 100 seeds. The control makes car() answer NIL for anything that is not a stored pointer, and changes nothing else:

D variant wrong
512 theirs 7 / 100
512 car(atom) = NIL 0 / 100
2048 theirs 11 / 100
2048 car(atom) = NIL 0 / 100

Some of the wrong results:

D seed result
512 0 
[["a", "b", "LAMBDA", "x", ["CONS", "a", ["b", "c"]]]]
512 34 
[["a", "LAMBDA"]]
512 41 
[["a", "b", "LAMBDA", "a", ["x", ["b", "c"]]]]
512 43 
[["a", "b"]]
2048 2 
[["a", "LAMBDA", ["c"], "LAMBDA"]]
2048 11 
[["LAMBDA", "b", "c"]]
2048 21 
[["a", 1]]
2048 46 
[["a", "b", "LAMBDA", "lhs", "CONS"]]

What car(a) returns for the atom a, after the run, over the 100 seeds. It is spread over the whole vocabulary:

D car(a) → item ×seeds
512 NIL ×11, CONS ×9, b ×9, 1 ×9, lhs ×8, a ×7, φ ×6, F ×6, T ×5, rhs ×5, c ×5, DEFINE ×4, QUOTE ×3, LABEL ×3, x ×2, CDR ×2, EQ ×2, ATOM ×1, COND ×1, CAR ×1, LAMBDA ×1
2048 a ×14, lhs ×11, F ×9, T ×7, x ×7, c ×7, φ ×5, CONS ×5, NIL ×5, EQ ×5, DEFINE ×4, LAMBDA ×4, 1 ×4, CAR ×3, QUOTE ×2, LABEL ×2, b ×2, CDR ×2, rhs ×1, ATOM ×1

E2, E3 (holis). CAR does not evaluate its argument, and LABEL is dispatched but raises. Their paper says it leaves LABEL out, so E3 is a leftover, not a broken claim:

program D results over seeds 
(CAR (CDR (a b c)))
 512 ["CDR"] ×5 
(LABEL f (LAMBDA (x) x))
 512 TypeError: vsa_env..label() got an unexpected keyword argument 'ind' ×5

E4 (holis). The item memory grows quadratically. SimpleCleanUp.memorize appends 100 empty rows once it is full, but it never raises its capacity. So past 100 items, every new item appends another 100 rows. An empty row scores 0, so it can win a lookup only when every stored row scores below 0. Mostly it costs memory and time. It is why the fizzbuzz calls above take minutes, and why our noise sweep at D = 8192 needed smaller memories to stay under 8 GB. residuelisp’s CleanupMemory does raise its capacity.

items stored matrix rows MB at D = 512
100 100 0.4
200 10100 41.4
400 30100 123.3
800 70100 287.1
after their fizzbuzz DEFINEs, D = 512 items stored matrix rows
seed 0 635 53600

R2–R5 (residuelisp).

  • R2: and tests its left argument twice and never the right one. Structural eq? on lists joins car and cdr with and, so it compares only the cars.
  • R3: if does not evaluate its condition. The condition is the unevaluated form, a pointer, which is neither nil nor #f.
  • R4: the decoder searches 0..199, while the moduli cover 0..1154.
  • R5: see the lexer table below.

D = 1000, 5 seeds:

erratum program expected results
R1 
(eq? 3 5 )
 #f #t ×5
R1 
(eq? 3 1000 )
 #f #t ×5
R1 control 
(eq? 3 3 )
 #t #t ×5
R2 
(and #t #f)
 #f #t ×5
R2 
(and #t nil)
 nil or #f #t ×5
R2 
(eq? (cons a (cons b nil)) (cons a (cons c nil)))
 #f #t ×5
R2 control 
(eq? (cons a (cons b nil)) (cons a (cons b nil)))
 #t #t ×5
R3 
(if (eq? a b) yes no)
 no yes ×5
R3 
(if (and #f #f) yes no)
 no yes ×5
R3 control 
(if #f yes no)
 no no ×5
R4 
(+ 150 100 )
 250 37 ×1, 15 ×1, 119 ×1, 77 ×1, 61 ×1
R4 
(+ 199 1 )
 200 173 ×1, 32 ×1, 16 ×2, 61 ×1
R4 
(- 3 5 )
 -2 (1153 mod 1155) 173 ×1, 15 ×1, 121 ×1, 127 ×1, 46 ×1
R4 control 
(+ 100 99 )
 199 199 ×5

R5: the lexer drops a ) that directly follows an integer, so nested arithmetic parses wrongly. Our residuelisp programs put a space there.

source tokens result (seed 0) 
(g 1)
 
( g 1
 – 
(g 1 )
 
( g 1 )
 – 
(+ (+ 1 2) 3)
 
( + ( + 1 2 3
 InterpreterError: Segmentation fault in car hehe 
(+ (+ 1 2 ) 3 )
 
( + ( + 1 2 ) 3 )
 6

What did not reproduce

  • 4.1 does not apply to either codebase as written: both use pointer cells. In our paper mode of holis it shows up as a noise-free failure, but the loss of noise tolerance did not show in our read test.
  • 4.2 shows up only through role names leaking into holis’s symbol table. The (x . y) / (y . x) controls are 40 of 40 correct.
  • 4.3 and 4.4 do not reproduce. residuelisp’s product code has no chimeras in its similarity and no special zero, and its programs never superpose integers.
  • 4.5 does not reproduce in residuelisp in the form “a cap independent of D”, because its similarity is unnormalised (see the table above).
  • 4.7 does not apply.

Summary

trap holis (2024) residuelisp (2025)
4.1 superposed cells code: n/a (pointers), paper mode: noise-free failure reproduced, noise margin not n/a (pointers)
4.2 commuting bind reproduced via role symbols n/a
4.3 chimeras n/a (no integers) not reproduced
4.4 zero n/a not reproduced
4.5 fixed thresholds reproduced not reproduced (the cliff moves with √D)
4.6 shared field n/a reproduced (integer tag)
4.7 sum of tuples n/a n/a
new E1 car of an atom, E2, E3, E4 memory growth R2 and, R3 if, R4 decoder range, R5 lexer

Appendix

A. Commands

cd repro/holis
python3 -m venv .venv          # Python 3.14.7
.venv/bin/pip install numpy more-itertools
export OPENBLAS_NUM_THREADS=1
ulimit -v 8000000
.venv/bin/python holis_control.py
.venv/bin/python holis_errata.py
.venv/bin/python holis_commute.py
.venv/bin/python holis_thresholds.py
.venv/bin/python holis_cells.py
.venv/bin/python residuelisp_control.py
.venv/bin/python residuelisp_errata.py
.venv/bin/python residuelisp_residues.py
.venv/bin/python residuelisp_thresholds.py

Each script writes the JSON file of the same name, which this page reads. The loader upstream.py fetches holis at db208d782863febfb50ec46b25a3700369f5cfea and residuelisp at 09864c74f1a35680a0008e59d7ab2571269a986f into a gitignored cache.

B. Settings, per file

file upstream python / numpy settings
holis_control.json https://github.com/eilene-ftf/holis @ db208d7 3.14.7 / 2.5.4 
{"D":[512,2048],"seeds":[0,1,2,3,4],"fizzbuzz_D":512,"fizzbuzz_seed":0,"sigma":0}
holis_errata.json https://github.com/eilene-ftf/holis @ db208d7 3.14.7 / 2.5.4 
{"program":"((LAMBDA (x) (CONS x (b c))) a)","seeds":100,"dims":[512,2048],"sigma":0}
holis_commute.json https://github.com/eilene-ftf/holis @ db208d7 3.14.7 / 2.5.4 
{"dims":[512,2048,8192],"seeds":40,"sigma":0}
holis_thresholds.json https://github.com/eilene-ftf/holis @ db208d7 3.14.7 / 2.5.4 
{"dims":[512,2048,8192],"sigma_read":[0,1,2,3,4,5,6,8,10,12],"lookup":"25 lists x 8 repeats per (D, sigma, mode), env seed 0","noise":"p + sigma*|p|\/sqrt(D)*N(0,I) before every SimpleCleanUp.recall and SimpleAssoc.recall","sigma_lookup":[0,1,2,3,4,4.5,5,5.5,6,7,8,10,12,16],"max_cells_program":300,"why_small":"their SimpleCleanUp grows by 100 zero rows per stored item past 100 rows (erratum E4); larger memories exceed 8 GB at D = 8192","read_seeds":20,"modes":["theirs (theta=0.2)","chance floor (theta=5\/sqrt(D))"],"sigma_program":[0,2,4,5,6,8,10],"program_seeds":10,"program":"((LAMBDA (x) (CONS x (b c))) a)"}
holis_cells.json https://github.com/eilene-ftf/holis @ db208d7 3.14.7 / 2.5.4 
{"D":2048,"sigma_read":[0,0.5,1,1.5,2,3,4,5,6,8,10,12,16],"read_seeds":20,"program_seeds":10,"program_sigma":0,"max_cells_program":20000}
residuelisp_control.json https://github.com/hanleyc01/residuelisp @ 09864c7 3.14.7 / 2.5.4 
{"D":1000,"vsa":"FHRR","integers":"RHCIntegers, moduli [3, 5, 7, 11]","seeds":[0,1,2,3,4],"sigma":0}
residuelisp_errata.json https://github.com/hanleyc01/residuelisp @ 09864c7 3.14.7 / 2.5.4 
{"D":1000,"seeds":[0,1,2,3,4],"sigma":0}
residuelisp_residues.json https://github.com/hanleyc01/residuelisp @ 09864c7 3.14.7 / 2.5.4 
{"dims":[1000,4096],"seeds":[0,1,2,3,4],"moduli":[3,5,7,11],"range":1155,"superposition":"zeta(11) + zeta(12)","resonator_iters":200}
residuelisp_thresholds.json https://github.com/hanleyc01/residuelisp @ 09864c7 3.14.7 / 2.5.4 
{"program":"((lambda (x) ((lambda (y) (cons x (cons y nil))) n)) m)","max_steps":5000,"dims":[500,2000,8000],"sigmas":[0,1,2,3,4,6,8,12,16,24,32],"seeds":10,"noise":"p + sigma*|p|\/sqrt(D)*CN(0,I) before every CleanupMemory.recall and AssociativeMemory.deref"}

The holis notebook we ran has SHA-256 80eee8cdeed896fe1987bd9c391d3001c3e46f736227f8cac8f9784b2dd09175.

C. Harness excerpts (our code)

Probe noise, wrapped around their two cleanup methods (holis_common.py):

def _noisy(hrr):
    s = STATE["sigma"]
    if s <= 0:
        return hrr
    v = hrr.v
    n = STATE["rng"].normal(size=v.size) * (s * np.linalg.norm(v) / math.sqrt(v.size))
    return H.HRR(data=v + n)

H.SimpleCleanUp.recall = lambda self, hrr: _ORIG_MEM_RECALL(self, _noisy(hrr))
H.SimpleAssoc.recall   = ...  # the same, and counts theta fallbacks

The 4.5 control is one attribute, env["assoc"].theta = 5 / sqrt(D). The E1 control rebinds their inner car in the closures of vsa_env (holis_errata.py):

def car(c, ind=""):
    return orig(c) if c in assoc.A else nil

Paper mode, the 4.1 experiment, is two attributes on their pointer memory (holis_cells.py):

a.memorize = lambda probe, trace: (trace.unit(), trace.unit())
a.recall = lambda probe: probe

For residuelisp we also silence its debug output, stub the decode it calls inside log messages while a program runs, reset its class-level RHC state per seed, and stop a run after a budget of cleanups. Under noise its tuple_to_list loops until car raises, which can be never.

D. Raw results

holis, 4.5 lookups (all rows):

D mode σ correct θ fallbacks
512 theirs (theta=0.2) 0 200 / 200 0
512 theirs (theta=0.2) 1 200 / 200 0
512 theirs (theta=0.2) 2 196 / 200 0
512 theirs (theta=0.2) 3 159 / 200 0
512 theirs (theta=0.2) 4 103 / 200 26
512 theirs (theta=0.2) 4.5 48 / 200 75
512 theirs (theta=0.2) 5 26 / 200 104
512 theirs (theta=0.2) 5.5 21 / 200 141
512 theirs (theta=0.2) 6 9 / 200 160
512 theirs (theta=0.2) 7 3 / 200 183
512 theirs (theta=0.2) 8 5 / 200 191
512 theirs (theta=0.2) 10 1 / 200 198
512 theirs (theta=0.2) 12 1 / 200 200
512 theirs (theta=0.2) 16 2 / 200 200
512 chance floor (theta=5/sqrt(D)) 0 200 / 200 0
512 chance floor (theta=5/sqrt(D)) 1 200 / 200 0
512 chance floor (theta=5/sqrt(D)) 2 196 / 200 0
512 chance floor (theta=5/sqrt(D)) 3 159 / 200 1
512 chance floor (theta=5/sqrt(D)) 4 84 / 200 54
512 chance floor (theta=5/sqrt(D)) 4.5 38 / 200 101
512 chance floor (theta=5/sqrt(D)) 5 15 / 200 147
512 chance floor (theta=5/sqrt(D)) 5.5 12 / 200 165
512 chance floor (theta=5/sqrt(D)) 6 7 / 200 180
512 chance floor (theta=5/sqrt(D)) 7 2 / 200 194
512 chance floor (theta=5/sqrt(D)) 8 4 / 200 197
512 chance floor (theta=5/sqrt(D)) 10 1 / 200 200
512 chance floor (theta=5/sqrt(D)) 12 1 / 200 200
512 chance floor (theta=5/sqrt(D)) 16 2 / 200 200
2048 theirs (theta=0.2) 0 200 / 200 0
2048 theirs (theta=0.2) 1 200 / 200 0
2048 theirs (theta=0.2) 2 200 / 200 0
2048 theirs (theta=0.2) 3 200 / 200 0
2048 theirs (theta=0.2) 4 195 / 200 4
2048 theirs (theta=0.2) 4.5 164 / 200 37
2048 theirs (theta=0.2) 5 83 / 200 118
2048 theirs (theta=0.2) 5.5 31 / 200 165
2048 theirs (theta=0.2) 6 8 / 200 194
2048 theirs (theta=0.2) 7 2 / 200 199
2048 theirs (theta=0.2) 8 1 / 200 200
2048 theirs (theta=0.2) 10 0 / 200 200
2048 theirs (theta=0.2) 12 2 / 200 200
2048 theirs (theta=0.2) 16 2 / 200 200
2048 chance floor (theta=5/sqrt(D)) 0 200 / 200 0
2048 chance floor (theta=5/sqrt(D)) 1 200 / 200 0
2048 chance floor (theta=5/sqrt(D)) 2 200 / 200 0
2048 chance floor (theta=5/sqrt(D)) 3 200 / 200 0
2048 chance floor (theta=5/sqrt(D)) 4 199 / 200 0
2048 chance floor (theta=5/sqrt(D)) 4.5 199 / 200 0
2048 chance floor (theta=5/sqrt(D)) 5 194 / 200 0
2048 chance floor (theta=5/sqrt(D)) 5.5 178 / 200 0
2048 chance floor (theta=5/sqrt(D)) 6 165 / 200 0
2048 chance floor (theta=5/sqrt(D)) 7 119 / 200 15
2048 chance floor (theta=5/sqrt(D)) 8 91 / 200 46
2048 chance floor (theta=5/sqrt(D)) 10 21 / 200 147
2048 chance floor (theta=5/sqrt(D)) 12 8 / 200 179
2048 chance floor (theta=5/sqrt(D)) 16 2 / 200 200
8192 theirs (theta=0.2) 0 200 / 200 0
8192 theirs (theta=0.2) 1 200 / 200 0
8192 theirs (theta=0.2) 2 200 / 200 0
8192 theirs (theta=0.2) 3 200 / 200 0
8192 theirs (theta=0.2) 4 200 / 200 0
8192 theirs (theta=0.2) 4.5 190 / 200 10
8192 theirs (theta=0.2) 5 75 / 200 126
8192 theirs (theta=0.2) 5.5 6 / 200 197
8192 theirs (theta=0.2) 6 1 / 200 200
8192 theirs (theta=0.2) 7 1 / 200 200
8192 theirs (theta=0.2) 8 0 / 200 200
8192 theirs (theta=0.2) 10 1 / 200 200
8192 theirs (theta=0.2) 12 2 / 200 200
8192 theirs (theta=0.2) 16 2 / 200 200
8192 chance floor (theta=5/sqrt(D)) 0 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 1 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 2 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 3 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 4 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 4.5 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 5 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 5.5 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 6 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 7 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 8 200 / 200 0
8192 chance floor (theta=5/sqrt(D)) 10 188 / 200 0
8192 chance floor (theta=5/sqrt(D)) 12 166 / 200 0
8192 chance floor (theta=5/sqrt(D)) 16 83 / 200 46

holis, 4.5 program runs, with what went wrong:

D mode σ correct errors wrong values
512 theirs (theta=0.2) 0 9 / 10 ["a", "b", "LAMBDA", "x", ["CONS", "a", ["b", "c"]]] ×1
512 theirs (theta=0.2) 2 6 / 10 ["x", "b", "c"] ×1, ["lhs", "b", "c"] ×1, ["c", "a", ["b", "c"]] ×1, ["a", "LAMBDA", ["x", ["b", "c"]], "c"] ×1
512 theirs (theta=0.2) 4 0 / 10 rhs ×1, [["x"], ["rhs", "lhs"]] ×1, [["rhs", ["LAMBDA", "x"]], ["rhs", ["x", 1]]] ×1, ["LAMBDA", "CONS", [["a"], [[["LAMBDA", "T"], ["x", "F"]]]]] ×1, [[[[[["F", ["T", ["CONS", "lhs"]], "x"], "LAMBDA"], ["NIL", ×1, ["LAMBDA", "rhs"] ×1, ["lhs", ["a", "LAMBDA"]] ×1, ["LAMBDA", 1, ["NIL", "lhs"]] ×1, [[["b", ["x"], "F"], "rhs"], "lhs"] ×1, ["F", "a"] ×1
512 theirs (theta=0.2) 5 0 / 10 [[["CONS", "rhs"], "ATOM"], "lhs"] ×1, ["lhs", "\u03c6"] ×1, LAMBDA ×1, a ×1, ["ATOM", "EQ"] ×1, ["F", ["NIL", "x"]] ×1, ["x", "\u03c6"] ×1, ["rhs", ["a", ["b", "lhs"]]] ×1, ["LAMBDA", ["rhs", "rhs"]] ×1, ["a", 1] ×1
512 theirs (theta=0.2) 6 0 / 10 ["ATOM", "T"] ×1, ["CONS", "a"] ×1, ["F", "EQ"] ×1, φ ×1, ["CDR", "CONS"] ×1, LAMBDA ×2, a ×1, ["x", "\u03c6"] ×1, c ×1
512 theirs (theta=0.2) 8 0 / 10 a ×1, c ×3, F ×1, ["NIL", "T"] ×1, [[1], ["NIL", "x"]] ×1, LAMBDA ×1, EQ ×1, x ×1
512 theirs (theta=0.2) 10 0 / 10 budget ×1 a ×2, c ×1, ["LAMBDA", "b"] ×1, lhs ×1, [["lhs", ["a", ["EQ", "T"]], "CONS"], [[[["ATOM", "a"], "LAM ×1, [[1], ["NIL", "x"]] ×1, LAMBDA ×1, x ×1
512 chance floor (theta=5/sqrt(D)) 0 9 / 10 ["a", "b", "LAMBDA", "x", ["CONS", "a", ["b", "c"]]] ×1
512 chance floor (theta=5/sqrt(D)) 2 6 / 10 ["x", "b", "c"] ×1, ["lhs", "b", "c"] ×1, ["c", "a", ["b", "c"]] ×1, ["a", "LAMBDA", ["x", ["b", "c"]], "c"] ×1
512 chance floor (theta=5/sqrt(D)) 4 0 / 10 [["CAR", "b", "F", "CONS", "F", "lhs", [["lhs", "rhs"], ["F" ×1, ["F", "EQ"] ×1, x ×1, ["lhs", "\u03c6"] ×1, ["a", ["LAMBDA", "x"]] ×1, ["LAMBDA", "c"] ×1, a ×1, ["LAMBDA", "LAMBDA"] ×1, ["lhs", [["x"], "ATOM"]] ×1, c ×1
512 chance floor (theta=5/sqrt(D)) 5 0 / 10 ["lhs", ["NIL", "x"]] ×1, φ ×1, [[["CONS", "rhs"], "ATOM"], "lhs"] ×1, ["lhs", "\u03c6"] ×1, F ×1, LAMBDA ×2, a ×1, ["x", "\u03c6"] ×1, c ×1
512 chance floor (theta=5/sqrt(D)) 6 0 / 10 a ×1, c ×2, b ×1, LAMBDA ×2, ["ATOM", "T"] ×1, φ ×1, ["CONS", "a"] ×1, x ×1
512 chance floor (theta=5/sqrt(D)) 8 0 / 10 a ×2, c ×3, F ×1, ["NIL", "T"] ×1, [[1], ["NIL", "x"]] ×1, LAMBDA ×1, x ×1
512 chance floor (theta=5/sqrt(D)) 10 0 / 10 budget ×1 a ×2, c ×1, ["LAMBDA", "b"] ×1, lhs ×1, EQ ×1, [[1], ["NIL", "x"]] ×1, LAMBDA ×1, x ×1
2048 theirs (theta=0.2) 0 9 / 10 ["a", "LAMBDA", ["c"], "LAMBDA"] ×1
2048 theirs (theta=0.2) 2 10 / 10
2048 theirs (theta=0.2) 4 3 / 10 rhs ×1, ["a", ["b", "LAMBDA"]] ×1, ["T", "b", "x"] ×1, [["x", "a", ["b", "c"]], "a", ["b", "c"]] ×1, ["a", "b", 1] ×1, c ×1, [["LAMBDA", ["x"], ["CONS", "x", ["b", "c"]]], "a"] ×1
2048 theirs (theta=0.2) 5 0 / 10 [1, "b"] ×1, ["LAMBDA", "CONS"] ×1, CONS ×2, DEFINE ×2, ["LAMBDA", "b"] ×1, NIL ×1, φ ×1, ["T", 1] ×1
2048 theirs (theta=0.2) 6 0 / 10 LAMBDA ×1, rhs ×1, DEFINE ×3, b ×1, x ×2, φ ×1, a ×1
2048 theirs (theta=0.2) 8 0 / 10 LAMBDA ×1, rhs ×1, DEFINE ×3, b ×1, x ×2, φ ×1, a ×1
2048 theirs (theta=0.2) 10 0 / 10 LAMBDA ×1, rhs ×1, DEFINE ×3, b ×1, x ×2, φ ×1, a ×1
2048 chance floor (theta=5/sqrt(D)) 0 9 / 10 ["a", "LAMBDA", ["c"], "LAMBDA"] ×1
2048 chance floor (theta=5/sqrt(D)) 2 10 / 10
2048 chance floor (theta=5/sqrt(D)) 4 10 / 10
2048 chance floor (theta=5/sqrt(D)) 5 7 / 10 ["x", "b", ["x", "b", "c"]] ×1, ["c"] ×1, ["rhs", "lhs"] ×1
2048 chance floor (theta=5/sqrt(D)) 6 0 / 10 ["a", "x"] ×1, ["a", "b"] ×1, [["x", ["a"]], "x", ["b", "c", "c"]] ×1, ["a", "b", "c", [["a"], "a"]] ×1, [["c"], [["b", "c"]]] ×1, ["x", "a"] ×1, a ×1, ["LAMBDA", "CONS", ["CONS", ["x", [["b", [[[["x"], ["CONS", ×1, ["a", "LAMBDA"] ×1, ["LAMBDA", ["x", ["b", "c"], "b", "c"], ["c"]] ×1
2048 chance floor (theta=5/sqrt(D)) 8 0 / 10 T ×1, ["LAMBDA", "a"] ×1, [["DEFINE", ["CONS", [["CAR"], "CONS"]]], [["b", "F"], [["NI ×1, x ×1, [1, "DEFINE"] ×1, a ×1, ["LAMBDA", "LABEL"] ×1, [["LAMBDA", "lhs"], ["a"]] ×1, ["LAMBDA", ["rhs", ["rhs", "x"]], "c"] ×1, [[["x"], "DEFINE", "x"], ["c", [["CONS", [[[1, "T"], "a"], [ ×1
2048 chance floor (theta=5/sqrt(D)) 10 0 / 10 rhs ×1, [["x"], "c"] ×1, φ ×1, x ×1, CONS ×1, DEFINE ×2, LAMBDA ×1, a ×1, 1 ×1
8192 theirs (theta=0.2) 0 7 / 10 ["a", "LAMBDA", ["NIL", ["CONS", "a", ["b", "c"]]], [["b", " ×1, ["a", "b", "LAMBDA", "a", "lhs"] ×1, ["a", "b", "LAMBDA", "x", ["b", "c"]] ×1
8192 theirs (theta=0.2) 2 7 / 10 ["a", ["a", "b", "c"]] ×1, ["a", ["b", "c"]] ×1, ["LAMBDA", "b", "c"] ×1
8192 theirs (theta=0.2) 4 8 / 10 ["a", "rhs"] ×1, ["a", "LAMBDA", [[["b", "c"]], "a"], 1] ×1
8192 theirs (theta=0.2) 5 0 / 10 T ×1, ["rhs", "T"] ×1, CONS ×1, ["NIL", "F"] ×1, ["T", "CONS"] ×1, LAMBDA ×2, a ×1, NIL ×1, [1, ["F", "a"]] ×1
8192 theirs (theta=0.2) 6 0 / 10 rhs ×1, φ ×1, CONS ×1, lhs ×1, LAMBDA ×2, a ×1, 1 ×1, NIL ×1, c ×1
8192 theirs (theta=0.2) 8 0 / 10 rhs ×1, φ ×1, CONS ×1, lhs ×1, LAMBDA ×2, a ×1, 1 ×1, NIL ×1, c ×1
8192 theirs (theta=0.2) 10 0 / 10 rhs ×1, LAMBDA ×2, lhs ×1, c ×1, 1 ×2, CONS ×1, a ×1, φ ×1
8192 chance floor (theta=5/sqrt(D)) 0 7 / 10 ["a", "LAMBDA", ["NIL", ["CONS", "a", ["b", "c"]]], [["b", " ×1, ["a", "b", "LAMBDA", "a", "lhs"] ×1, ["a", "b", "LAMBDA", "x", ["b", "c"]] ×1
8192 chance floor (theta=5/sqrt(D)) 2 7 / 10 ["a", ["a", "b", "c"]] ×1, ["a", ["b", "c"]] ×1, ["LAMBDA", "b", "c"] ×1
8192 chance floor (theta=5/sqrt(D)) 4 8 / 10 ["a", "rhs"] ×1, ["a", "LAMBDA", [[["b", "c"]], "a"], 1] ×1
8192 chance floor (theta=5/sqrt(D)) 5 8 / 10 ["a", "c"] ×1, ["a", "LAMBDA", [[["b", "c"]], "a"], 1] ×1
8192 chance floor (theta=5/sqrt(D)) 6 8 / 10 ["a", "a", "b", "c"] ×1, ["a", "LAMBDA", "\u03c6", 1] ×1
8192 chance floor (theta=5/sqrt(D)) 8 7 / 10 ["a", "a", "b", "c"] ×1, ["a", "LAMBDA", "\u03c6", 1] ×1, ["a", ["b", "c"]] ×1
8192 chance floor (theta=5/sqrt(D)) 10 3 / 10 ["NIL", "a", "b", "LAMBDA", "a", [["CONS", "x", ["b", "c"]]] ×1, ["a", "LAMBDA", "\u03c6", 1] ×1, ["a", ["b", "c"]] ×1, ["b", "a"] ×1, [["a", ["b", "c"]], "b", "c"] ×1, ["a", ["c"], "c"] ×1, ["LAMBDA", "lhs", ["CONS", "a", ["b", "c"]]] ×1

residuelisp, 4.5 runs, with what went wrong:

D σ correct errors wrong values
500 0 10 / 10
500 1 10 / 10
500 2 7 / 10 InterpreterError: Segmentation fault in car hehe ×3
500 3 0 / 10 InterpreterError: Segmentation fault in car hehe ×6, InterpreterError: Segmentation fault in cdr hehe ×2, InterpreterError: ERROR: argument number mismatch in `associate`. ×2
500 4 0 / 10 InterpreterError: Segmentation fault in car hehe ×7, InterpreterError: Segmentation fault in cdr hehe ×2, InterpreterError: ERROR: Tuple is not a list. ×1
500 6 0 / 10 InterpreterError: Segmentation fault in cdr hehe ×4, InterpreterError: Segmentation fault in car hehe ×4, Exception: TODO ×1, InterpreterError: ERROR: Expected function in `get_args`. ×1
500 8 0 / 10 InterpreterError: ERROR: Tuple is not a list. ×2, InterpreterError: ERROR: Expected function in `get_args`. ×1, Exception: TODO ×1, InterpreterError: Segmentation fault in car hehe ×2, InterpreterError: Segmentation fault in cdr hehe ×3, InterpreterError: ERROR: Conditional expression requires `CONSEQUENT` and `ALTERNATE`, see documen ×1
500 12 0 / 10 budget ×4, InterpreterError: ERROR: Expected function in `get_args`. ×2, InterpreterError: Segmentation fault in car hehe ×2, InterpreterError: ERROR: Expected function in `get_body`. ×1, InterpreterError: ERROR: Conditional expression requires `CONSEQUENT` and `ALTERNATE`, see documen ×1
500 16 0 / 10 budget ×7, InterpreterError: ERROR: Expected function in `get_args`. ×1, Exception: TODO ×1, InterpreterError: ERROR: Expected function in `get_body`. ×1
500 24 0 / 10 InterpreterError: ERROR: Conditional expression requires `CONSEQUENT` and `ALTERNATE`, see documen ×1, Exception: TODO ×4, InterpreterError: ERROR: Expected function in `get_body`. ×1, budget ×3, InterpreterError: ERROR: Expected function in `get_args`. ×1
500 32 0 / 10 Exception: TODO ×3, RecursionError ×2, budget ×3, InterpreterError: ERROR: Tuple is not a list. ×1, InterpreterError: ERROR: Expected function in `get_args`. ×1
2000 0 10 / 10
2000 1 10 / 10
2000 2 10 / 10
2000 3 10 / 10
2000 4 8 / 10 InterpreterError: ERROR: argument number mismatch in `associate`. ×1, InterpreterError: Segmentation fault in car hehe ×1
2000 6 0 / 10 InterpreterError: Segmentation fault in car hehe ×3, InterpreterError: ERROR: argument number mismatch in `associate`. ×5, InterpreterError: Segmentation fault in cdr hehe ×2
2000 8 0 / 10 InterpreterError: Segmentation fault in car hehe ×9, InterpreterError: Segmentation fault in cdr hehe ×1
2000 12 0 / 10 InterpreterError: ERROR: Tuple is not a list. ×3, InterpreterError: Segmentation fault in cdr hehe ×3, InterpreterError: Segmentation fault in car hehe ×2, InterpreterError: ERROR: Expected function in `get_args`. ×1, Exception: TODO ×1
2000 16 0 / 10 InterpreterError: ERROR: Expected function in `get_args`. ×3, InterpreterError: ERROR: Tuple is not a list. ×2, InterpreterError: Segmentation fault in cdr hehe ×2, Exception: TODO ×3
2000 24 0 / 10 InterpreterError: ERROR: Expected function in `get_body`. ×2, budget ×6, InterpreterError: Segmentation fault in car hehe ×1, InterpreterError: ERROR: Expected function in `get_args`. ×1
2000 32 0 / 10 InterpreterError: ERROR: Expected function in `get_args`. ×1, InterpreterError: Segmentation fault in car hehe ×1, InterpreterError: ERROR: Expected function in `get_body`. ×2, budget ×6
8000 0 10 / 10
8000 1 10 / 10
8000 2 10 / 10
8000 3 10 / 10
8000 4 10 / 10
8000 6 10 / 10
8000 8 9 / 10 InterpreterError: Segmentation fault in car hehe ×1
8000 12 1 / 10 InterpreterError: Segmentation fault in car hehe ×6, InterpreterError: ERROR: argument number mismatch in `associate`. ×2, InterpreterError: Segmentation fault in cdr hehe ×1
8000 16 0 / 10 InterpreterError: Segmentation fault in car hehe ×7, InterpreterError: ERROR: argument number mismatch in `associate`. ×1, InterpreterError: Segmentation fault in cdr hehe ×2
8000 24 0 / 10 InterpreterError: Segmentation fault in cdr hehe ×4, InterpreterError: Segmentation fault in car hehe ×6
8000 32 0 / 10 InterpreterError: Segmentation fault in cdr hehe ×2, InterpreterError: Segmentation fault in car hehe ×3, budget ×2, InterpreterError: ERROR: Tuple is not a list. ×2, InterpreterError: ERROR: Expected function in `get_args`. ×1

residuelisp, the superposition per seed:

D seed decode_rhc(11+12) decode_rhc(11) resonator(11+12) residues chimera? resonator(11)
1000 0 12 11 11 [2 1 4 0] false 11
1000 1 12 11 12 [0 2 5 1] false 11
1000 2 11 11 11 [2 1 4 0] false 11
1000 3 11 11 11 [2 1 4 0] false 11
1000 4 11 11 11 [2 1 4 0] false 11
4096 0 12 11 12 [0 2 5 1] false 11
4096 1 12 11 12 [0 2 5 1] false 11
4096 2 12 11 11 [2 1 4 0] false 11
4096 3 11 11 11 [2 1 4 0] false 11
4096 4 12 11 12 [0 2 5 1] false 11

Generated by Claude on Benjamin Schwerdtner’s behalf.

source: notebooks/holis_reproduction.clj