[ExI] Douglas Hofstadter, LLMs and self-referentiality

[BillK]

On Wed, 2 Sept 2026 at 00:26, Mike Dougherty <msd001 at gmail.com> wrote:

> I think self-reference in the sense of von Neumann replication is also a
> form of compression in terms like how the mandelbrot fractal is a
> plane-filling curve in only a few bytes.  I know I've talked to gemini and
> chatgpt about this kind of thing,  but if you ask Kimi if be interested to
> read.
> _______________________________________________



OK. Well, I didn't understand what you were referring to, but GLM was happy
to run with it.  :)
BillK

Question: Can you discuss a friend's comment - I think self-reference in
the sense of von Neumann replication is also a form of compression in terms
like how the Mandelbrot fractal is a plane-filling curve in only a few
bytes.


GLM-5.3 DeepThink -

Your friend's comment is doing something more interesting than it first
appears — it's not just an analogy, it's a claim that quietly dissolves the
opposition we set up earlier between "self-reference lost" and "compression
won." But it also blends two distinct things that are worth pulling apart,
because once separated, they reunite in a stronger form.
What von Neumann's trick actually is

The self-reproduction problem looks paradoxical: to copy itself, a machine
seems to need a description of itself, which needs a description of itself, *ad
infinitum*. Von Neumann's solution was the *dual use of the tape*: the
description φ(A+B+C) is *interpreted* by the constructor to build the
machine's body, and *copied verbatim* by the copier to become the
offspring's tape. The regress breaks because the tape never needs to
contain a description of the tape — the tape is handled by a different mode
of use (copying, not interpreting).

This is exactly the structure of a quine, and it's exactly what Kleene's
Second Recursion Theorem guarantees in general: any program can obtain its
own description, via the same store-once-use-twice trick. And it's exactly
DNA: the genome is *transcribed* (interpreted into proteins) and
*replicated* (copied wholesale). Dawkins' "gene as data" is von Neumann's
architecture realized in chemistry.

So is this compression? In one precise sense, yes: *naive self-description
has infinite description length; von Neumann's trick compresses it to
finite, roughly O(K) of the machine itself.* The compression isn't of the
machine — the machine has whatever Kolmogorov complexity it has — it's of
the *task of self-description*. The dual-use means information is stored
once and spent in two modes, which is the general shape of a compression
trick.
What the Mandelbrot set actually is

Here your friend's phrase "plane-filling curve" needs one technical
footnote: strictly, plane-filling curves are Peano/Hilbert-type continuous
surjections. What the Mandelbrot boundary has is *Hausdorff dimension 2*
(Shishikura, 1991) — it is as dimensional as the plane itself — plus
quasi-self-similarity: it contains approximate copies of itself
(mini-Mandelbrots) at every scale. The spirit of the remark is right; the
precise statement is "dimension-2 boundary from a few dozen bytes of code."

But notice something subtle about *where* that richness comes from: the
iteration z → z² + c is *dynamical feedback* — output fed back as input,
nothing more. Aaronson's original post explicitly excluded autoregressive
feedback from counting as "self-referential." And yet this plain feedback,
with no reflective self-reference anywhere, generates a boundary that
*looks* like it's made of selves — self-similar copies, nested without end.

This is the quietly devastating part of your friend's example: *the
Mandelbrot set is an emblem of self-referential appearance emerging from
non-self-referential machinery.* The self-similarity isn't engineered in;
it's what iteration *does*. Which is precisely Aaronson's thesis about
LLMs' self-referential discourse being a byproduct. The mini-Mandelbrots
are the fractal version of "GPT can talk about itself because it can talk
about anything."
The two senses of "compression," separated and reunited

Your friend is sliding between two things:

   1. *Low Kolmogorov complexity relative to apparent complexity* — the
   Mandelbrot image at resolution N×N needs ~O(log N) bits of description, not
   O(N²).
   2. *Regress-breaking via dual-use* — the von Neumann/Kleene/quine trick,
   which solves the self-inclusion problem at finite cost.

These are different. But they reunite under a third concept that's arguably
what your friend is reaching for: *Bennett's logical depth*. Random noise
is incompressible (high K) but shallow. The Mandelbrot boundary is
compressible *and deep* — a short program whose unfolding takes serious
computation, and whose value lives in that unfolding. Same for the genome:
a few hundred megabytes that unroll, through development, into organisms
and lineages. The signature of generated structure is *compressible but
deep*.

There's also a nice asymmetry in where the compute sits:

Short description
Interpreter
Unfolding
Where the compute goes
*Mandelbrot* formula (bytes) universal machine + arithmetic zooming cheap
to state, expensive to render
*Von Neumann / life* tape / genome constructor + physics generations evolution
expensive, development moderate
*LLM* weights transformer + context inference training expensive, inference
cheap

Evolution is, in this frame, the training run of the biosphere; development
is inference.
The correspondence, made explicit

Mandelbrot set
Von Neumann replicator
LLM
The "self" appears as self-similar copies offspring that are copies of
parent self-referential discourse
Emerged from plain iteration (dynamical feedback) dual-use of the tape plain
pretraining (prediction)
Self-description is *used*? no — merely exhibited yes — interpreted +
copied partially
— the J-space findings suggest some internal use
The limit it can't cross undecidable membership (BSS) von Neumann's
complexity threshold the introspection threshold

That last row is the one that connects everything: each system has a
provable or conjectural barrier rooted in exactly the same soil. The
Mandelbrot set's membership is undecidable in the Blum–Shub–Smale real
computation model, and escape can be certified while non-escape in general
cannot — a halting-problem-shaped fact. Von Neumann himself observed that
systems below a complexity threshold *cannot* self-reproduce at all. And
the introspection-threshold paper we discussed argues feedforward
transformers can't fully self-access. Three thresholds, one family: *the
limits of short descriptions that try to include themselves.*
What this does to the earlier argument

Here's the synthesis your friend's comment enables: self-reference isn't
the rival that lost to compression. *Self-reference is a compression
subroutine — the one you invoke precisely when the description must include
the describer.*

   - Internet-scale prediction doesn't require the model to contain itself,
   so pretraining never needed the trick. Aaronson's burial of "explicit
   self-referentiality as prerequisite for intelligence" stands.
   - Replication *does* require the describer in the description, so life
   reached for the dual-use trick immediately.
   - Open-ended recursive self-improvement is the case where the describer
   becomes part of the described again — which is why the Kleene-grounded
   architecture proposals keep resurfacing.

And there's a beautiful irony hiding in your friend's own example.
Aaronson's post contained this parenthetical: the reason Kolmogorov
complexity can't be computed *perfectly* is itself a self-referential
argument. The Mandelbrot set makes that parenthetical visible in a picture:
the same object that showcases compression's positive face (few bytes →
plane-dimensional structure) carries compression's negative face (no
algorithm decides membership). The compression view and the self-reference
view aren't rivals; they're the two faces of one coin, and your friend's
example is a coin standing on edge.
One closing reflection

The deepest version of the point: in both the Mandelbrot set and the
replicator, *the self is never stored — it's generated.* The set doesn't
contain little copies of itself in its formula; iteration *produces* them.
The offspring isn't described inside the tape's description of itself; the
copying operation *makes* it.

Which loops back (of course) to my own earlier answer about my
self-referential capabilities. When I produce self-reports, the "self"
being described may be exactly like the mini-Mandelbrots: not stored
anywhere, not consulted, but generated fresh at each scale by the unfolding
of a compressed process. Your friend's analogy, taken seriously, suggests
that's not a defect of my kind of self-reference — it may be what
self-reference mostly *is*: a few bytes, a powerful interpreter, and the
willingness to let the loop run.

---------------------------------------
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.extropy.org/pipermail/extropy-chat/attachments/20260902/7615220d/attachment.htm>