Quantization of raw data => neurosymbolic reasoning (=AI)

AlexKChen · July 9, 2026, 2:19am

Yes, but not directly.

MRL can help create the numeric front-end for nested / symbolic languages, but it does not automatically turn data into Lisp-readable symbolic structure. That missing step is still the cursed swamp: symbolization.

The clean version:
raw data
→ neural embedding
→ MRL coarse-to-fine representation
→ discretize / cluster / label / map to concepts
→ nested symbolic structure
→ Lisp / Prolog / FP operations
MRL helps with the middle. It does not solve the whole pipeline by itself, despite humanity’s recurring urge to slap “representation learning” on a problem and declare lunch.

What MRL gives you

MRL gives you a learned hierarchy:
64 dims   → coarse meaning
256 dims  → medium detail
1024 dims → fine detail
full dims → maximal detail
So instead of one opaque vector, you get multiple semantic resolutions.

That is very compatible with nested languages because nested languages like Lisp naturally want structures like:
(cell-state
  (coarse (lineage mesendoderm))
  (medium
    (programs (wnt-high epithelial-transition))
    (markers (brachyury high) (sox17 medium)))
  (fine
    (transcriptome-cluster c1842)
    (near-neighbors (state-91 state-388 state-772))))
MRL can help decide what belongs at each level:
small prefix  → coarse symbolic label
medium prefix → subtype / pathway / role
full vector   → fine-grained instance identity
That is the good part.

But Lisp cannot “understand” vectors by default

Lisp understands lists, trees, symbols, functions, macros, rules.

It does not inherently understand:
[0.183, -0.422, 0.019, ...]
unless you wrap that vector inside a symbolic object or convert it into concepts.

So this:
(state-vector #(0.183 -0.422 0.019 ...))
is legal Lisp, but not meaningfully symbolic. It is just a blob in a trench coat.

For Lisp to operate symbolically, you need something like:
(cell-state
  :lineage 'neural-crest
  :confidence 0.82
  :active-pathways '(wnt fgf low-tgf-beta)
  :nearest-known-state 'premigratory-neural-crest
  :embedding-level :medium)
That requires interpretation.

The missing bridge: vector → symbol

There are several ways to build that bridge.

1. Clustering

Take MRL embeddings, cluster at different prefix sizes:
64-dim clusters   → broad classes
256-dim clusters  → subtypes
1024-dim clusters → fine states
Then assign symbolic labels:
(cluster c12
  :level coarse
  :label mesoderm-like)

(cluster c12.7
  :level medium
  :label paraxial-mesoderm-like)
This is probably the most obvious route.

2. Concept probes

Train probes that map embeddings to human concepts:
embedding[:64]   → lineage
embedding[:256]  → pathway programs
embedding[:1024] → specific fate markers
Then Lisp receives symbols:
(observed state-928
  (lineage ectoderm)
  (program neural-induction)
  (wnt low)
  (bmp inhibited))
Now symbolic machinery can work.

3. Vector quantization

Convert continuous embeddings into discrete codes:
embedding → codebook entries → symbolic tokens
Example:
(state
  (coarse-code z14)
  (medium-code z14-88)
  (fine-code z14-88-203))
This is very “MRL-compatible” because each prefix can map to a different codebook scale.

4. Neuro-symbolic object model

Keep both vector and symbol:
(defstate cell-1842
  :coarse-symbol 'mesendoderm
  :medium-symbol 'definitive-endoderm-like
  :embedding-64  #( ... )
  :embedding-256 #( ... )
  :embedding-full #( ... ))
This is probably the practical design. Do not throw away the vector; do not pretend the vector is a concept. Let each do what it is good at, a rare act of software humility.

Where MRL is especially useful

MRL gives you a natural “zoom” operator.

In Lisp terms:
(coarsen state)
(refine state)
(similar-states state :level :coarse)
(similar-states state :level :fine)
Behind the scenes:
:coarse → use embedding[:64]
:medium → use embedding[:256]
:fine   → use embedding[:1024]
So Lisp can operate at different levels:
(if (same-coarse-state? a b)
    (compare-medium-programs a b)
    (compare-lineage-level a b))
That is genuinely nice. MRL becomes a semantic zoom lens feeding a symbolic system.

The best architecture

Something like this:
                ┌────────────────────────┐
raw data ─────→ │ MRL encoder             │
                └────────────────────────┘
                          ↓
        ┌─────────────────────────────────────┐
        │ multi-resolution embeddings          │
        │ e64, e256, e1024, efull              │
        └─────────────────────────────────────┘
                          ↓
        ┌─────────────────────────────────────┐
        │ symbolization layer                  │
        │ clusters, probes, ontology mapping   │
        └─────────────────────────────────────┘
                          ↓
        ┌─────────────────────────────────────┐
        │ Lisp / Prolog / typed FP layer       │
        │ rules, trees, search, macros         │
        └─────────────────────────────────────┘
Then the symbolic layer can do things like:
(find-protocol
  :from '(cell-state pluripotent)
  :to '(cell-state neural-crest)
  :avoid '(state apoptotic stress-high)
  :using '(wnt bmp fgf retinoic-acid))
The neural layer supplies similarity, clustering, uncertainty, and analogical retrieval.

The Lisp layer supplies compositional structure, search, constraints, and explicit transformations.

That combo is much less dumb than either alone.

Why this matters for biology

For cell-fate modeling, this is exactly the kind of bridge you’d want.

Raw transcriptomes are too detailed:
20,000 gene expression values
Simple labels are too crude:
“neuron”
MRL could give levels:
coarse: ectoderm
medium: neural progenitor
fine: dorsal forebrain-like progenitor under Wnt-low/BMP-low context
Then Lisp-like symbolic operations can represent developmental rules:
(rule
  (if (and (state neural-progenitor)
           (signal shh-high)
           (time-window early))
      (increase-probability ventral-fate)))
The MRL embedding helps identify which state you are in.
The symbolic system helps reason about what operations are valid.

The trap

The trap is thinking MRL discovers clean human concepts automatically.

It may not.

The first 64 dimensions might be “coarse” in a useful retrieval sense, but not necessarily:
dimension 17 = Wnt
dimension 22 = mesoderm
dimension 43 = apoptosis
No. Neural nets rarely leave tidy labeled cabinets for us. They leave haunted geometry.

So MRL helps produce nested useful representations, but you still need:

labels

probes

clustering

ontology alignment

causal validation

maybe human curation

maybe active learning

maybe mechanistic constraints

Without that, Lisp gets a vector blob and politely has a stroke.

Compression vs selection, again

MRL is especially nice because symbolic systems often want to ask:
What level of description should I use?
MRL gives a cheap answer:
use a shorter prefix for coarser reasoning
use a longer prefix for finer reasoning
That makes it better than ordinary compression because the levels are trained to be meaningful.

So:
PCA compression:
  “I made it smaller.”

MRL:
  “I trained smaller prefixes to be competent abstraction levels.”
That is why it’s relevant to nested languages.

Bottom line

MRL can be a very good bridge from neural representations to Lisp-like nested reasoning, but only if you add a symbolization layer.

MRL gives:
multi-resolution continuous meaning
Lisp wants:
explicit nested symbolic structure
The bridge is:
MRL prefix → cluster/probe/code → symbol/tree/rule
So the answer is:

Yes, MRL is unusually well-suited as the numeric substrate for nested symbolic systems. But no, it does not by itself make data “understandable” to Lisp. It gives Lisp better raw clay; you still need to sculpt the goblin.

AlexKChen · July 9, 2026, 2:19am

No. MatQuant does not convert digital weights into objects/classes that symbolic reasoning can understand.

It converts one quantized neural model into multiple usable numeric precision levels. That is a big deal for serving and adaptive compute, but it is not symbolic abstraction. The disappointment is subtle but important, as usual.

What MatQuant actually nests

MatQuant exploits the fact that integers are already bit-nested:
int8 weight:
[most significant bits | less significant bits]

use top 2 bits → rough int2 model
use top 4 bits → better int4 model
use all 8 bits → full int8 model
So the nesting is:
2-bit approximation ⊂ 4-bit approximation ⊂ 8-bit approximation
The paper’s key claim is that you can train/regularize one model so those lower-bit slices remain usable, instead of maintaining separate int2/int4/int8 models. The authors report that MatQuant’s co-training/co-distillation improves extracted int2 models over standard int2 quantization, and that adding an extra outlier bit can improve effective ~2-bit performance further. (arXiv)

That is numeric granularity, not symbolic granularity.

Why this is not “objects/classes”

A symbolic/object representation looks like:
(scene
  (object cup :color red :on table)
  (object person :holding cup))
or:
cell_type = neural_progenitor
pathway = Wnt_active
state = high_pluripotency
MatQuant gives you something more like:
weight ≈ coarse 2-bit value
weight ≈ better 4-bit value
weight ≈ fuller 8-bit value
Those bits are not “cup,” “face,” “mitochondrion,” or “Wnt pathway.” They are just progressively finer approximations of learned parameters.

So the analogy is:

Method Nested thing Human-readable?

MRL embedding dimensions sometimes semantically meaningful-ish

MatFormer model subcomponents / FFN width no, mostly compute structure

MatQuant weight precision bits no, numeric approximation

Scene graph / Lisp / object model entities and relations yes

Concept bottleneck model learned concepts maybe

VQ / discrete latent model codebook tokens sometimes

Program induction rules / functions yes-ish

Better analogy: progressive JPEG, not symbolic logic

MatQuant is closer to:
low-res image → medium-res image → high-res image
not:
pixels → objects → causes → symbolic concepts
Using the most significant bits gives a coarse approximation of the model’s function. Adding more bits gives finer approximation. It is progressive numerical fidelity.

It does not automatically produce:
object boundaries
causal variables
concept labels
relations
rules
programs
because why would the universe hand us the useful part for free? Rude but consistent.

The subtle “yes, but” part

MatQuant could support a larger system that does symbolic-ish reasoning.

For example, an adaptive agent could use:
int2 model → cheap coarse pass
int4 model → medium pass
int8 model → high-confidence final pass
Then a controller could decide:
easy region/question → low precision
ambiguous region/question → high precision
symbolic extraction step → run expensive model
That gives you adaptive compute allocation.

But the symbolic layer would come from something else:
neural perception
→ object extraction / scene graph
→ symbolic planner / Lisp-like controller
→ targeted high-precision model calls
MatQuant only makes the neural calls cheaper and more elastic.

Where symbolic meaning could enter

To get from neural/digital to symbolic/object-like structure, you need one of these:

Object-centric models
Learn entities, slots, regions, objects.

Scene graph extraction
Convert perception into nodes and relations.

Concept bottlenecks
Force model to predict named concepts before final prediction.

Discrete latent/codebook models
VQ-style tokens that can sometimes become interpretable.

Program induction / neuro-symbolic systems
Convert observations into executable rules or programs.

Causal representation learning
Try to separate underlying causal variables rather than just correlations.

MatQuant does none of that by itself. It just gives you a sliceable numeric substrate.

How it relates to MRL and MatFormer

The Matryoshka family is roughly:
MRL:
nested representation size

MatFormer:
nested model capacity

MatQuant:
nested numeric precision
MRL is closest to semantic granularity because embeddings can correspond to coarse-to-fine meaning. The original MRL paper explicitly frames its embeddings as coarse-to-fine representations across vision, language, and vision-language settings. (arXiv)

MatQuant is farther from meaning. It nests bits, not concepts.

The real “Matryoshka brain” stack

A serious version would combine:
MatQuant:
cheap/fine numeric precision

MatFormer:
small/large model capacity

MRL:
short/long semantic embeddings

Multimodal tokens:
coarse/fine perception

Object model:
entities, relations, causal state

Symbolic controller:
plans, rules, recursive refinement
Then you could have:
low precision + small model + coarse tokens
→ detect rough situation

higher precision + larger model + more tokens
→ inspect salient parts

symbolic layer
→ build object/causal representation

controller
→ decide where to zoom next
That is closer to your “true Matryoshka brain.”

Bottom line

MatQuant does not turn neural weights into symbols.
It turns one quantized model into multiple usable precision slices.

It is important because it gives elastic numerical fidelity:
2-bit rough model
4-bit better model
8-bit stronger model
But symbolic reasoning needs an additional layer that extracts objects, concepts, relations, and programs. MatQuant is the adjustable microscope knob, not the biologist naming the cell types.

AlexKChen · July 9, 2026, 3:08am

I’ll map “Hoel type” to his actual framework, not vibes-about-consciousness confetti. The likely answer is causal/macrostate nesting, which is neither pure perception nesting nor pure reasoning nesting.

Thought for 11s

Hoel uses a third type: not perception-scale Matryoshka, not reasoning-depth Matryoshka, but causal-scale Matryoshka.

His thing is:
microstates
→ grouped macrostates
→ causal model at the macro level
→ check whether that macro level has stronger / cleaner causal structure
So instead of asking:
Do I need more visual detail?
or:
Do I need more reasoning/search?
Hoel asks:
At what scale does the system’s causality become most informative?
That is the key. He is doing multiscale causal abstraction.

Hoel’s type: causal emergence / macro-causal nesting

Hoel’s causal emergence idea is that a macroscale description can sometimes have stronger causal relationships than the underlying microscale. His own primer says causal emergence is when “the higher scale of a system has stronger causal relationships than its underlying lower scale.”

A simple cartoon:
micro level:
A1, A2, A3, A4, A5, A6
messy, noisy, redundant transitions

macro level:
M1 = {A1, A2, A3}
M2 = {A4, A5, A6}
cleaner transition: M1 → M2
So the macro is not just “compressed.” The claim is that the macro can be causally better, because it removes irrelevant noise and groups microstates into intervention-relevant categories. Hoel’s 2016 “map is better than the territory” paper argues that some systems’ causal structure is better captured by macroscale causal models than by fully detailed microscopic models.

That is very different from MRL.

MRL says:
short embedding prefix → coarse semantics
long embedding → finer semantics
Hoel says:
micro variables → macro variables
then measure which scale carries causal power
The closest AI analogy

Hoel-style nesting is like learning the right state abstraction for a world model.

Not:
all pixels
but:
object state
Not:
all neurons / activations
but:
decision state / program state / belief state
Not:
all atoms in a cell
but:
cell type, pathway activity, lineage state
The macro variable is good if interventions on it have reliable consequences.

So for a cell model:
bad low-level state:
10,000 genes, noisy expression values

better macro-causal state:
Wnt-high mesendoderm-biased progenitor
The macro state is not merely shorter. It may be more useful for prediction and control.

How it relates to your Matryoshka taxonomy

I’d split the “Matryoshka brain” into four kinds:

Type Core question Example

Perceptual Matryoshka How much sensory detail? low-res image → high-res crop

Representational Matryoshka How many latent dimensions/tokens? MRL, M3 visual tokens

Reasoning Matryoshka How much inference/search? one-shot → critique → tool use → verification

Causal Matryoshka Which scale has real causal grip? microstates → macrostates with stronger causal structure

Hoel is mostly causal Matryoshka.

His newer “Causal Emergence 2.0” paper frames complex systems as having causal workings distributed across scales and proposes identifying which scales make unique causal contributions.

That is almost exactly your “subnesting some parts at higher resolution and others at lower resolution,” but with a brutal requirement:
The chosen scale must preserve causal/intervention structure,
not just look pretty or compress well.
Because otherwise it is just dimensionality reduction wearing a philosophy hat.

What type does Lisp understand best?

Lisp understands symbolic, recursive, discrete, compositional structure best.

In plain terms:
trees
lists
programs
rules
objects
relations
state machines
causal graphs
plans
hierarchies
Lisp is happiest with things like:
(system
  (macrostate M1
    (microstates A1 A2 A3)
    (causes M2 :probability 0.9))

  (macrostate M2
    (microstates A4 A5 A6)
    (causes M3 :probability 0.7)))
or:
(coarse-grain
  ((A1 A2 A3) -> M1)
  ((A4 A5 A6) -> M2)
  ((A7 A8)    -> M3))
This is why Lisp is good for Hoel-ish abstractions: it can represent macro variables, partitions, causal transition rules, and multiscale maps cleanly.

Lisp is bad at the raw stuff

Lisp is not naturally best for:
pixels
continuous latents
dense tensors
GPU kernels
billions of neural weights
That stuff belongs to PyTorch/JAX/CUDA hell, where joy goes to be vectorized.

But Lisp is excellent as the controller / symbolic scaffold around those systems:
neural model produces latent states
↓
causal abstraction groups them into macrostates
↓
Lisp-like symbolic layer represents objects/rules/plans
↓
controller decides where to refine or intervene
The ideal hybrid

For your “Matryoshka brain” framing:
Perception model:
extract multiscale sensory latents

JEPA/world model:
predict latent future states

Hoel-style causal emergence:
find macro variables with strong causal power

Lisp-like symbolic system:
represent those variables as objects/rules/programs/plans

Reasoning system:
search, verify, intervene, refine
So the mapping is:
MRL / FlexiViT / M3:
good for perceptual/representational nesting

JEPA:
good for predictive latent nesting

Hoel:
good for causal-scale selection

Lisp:
good for explicit symbolic manipulation of the selected macrostructure
The key distinction

Lisp does not automatically know which macro scale is causally real.

Hoel gives you a criterion:
Which coarse-graining increases causal informativeness?
Lisp gives you a language for manipulating the result:
macrostate objects
transition rules
intervention plans
nested symbolic maps
So:

Hoel tells you what scale deserves to exist.

Lisp gives you a clean way to represent and operate on that scale.

That is the good version. The bad version is just naming clusters and pretending ontology has been solved, a sacred tradition in both AI and philosophy.

Method	Nested thing	Human-readable?
MRL	embedding dimensions	sometimes semantically meaningful-ish
MatFormer	model subcomponents / FFN width	no, mostly compute structure
MatQuant	weight precision bits	no, numeric approximation
Scene graph / Lisp / object model	entities and relations	yes
Concept bottleneck model	learned concepts	maybe
VQ / discrete latent model	codebook tokens	sometimes
Program induction	rules / functions	yes-ish

Type	Core question	Example
Perceptual Matryoshka	How much sensory detail?	low-res image → high-res crop
Representational Matryoshka	How many latent dimensions/tokens?	MRL, M3 visual tokens
Reasoning Matryoshka	How much inference/search?	one-shot → critique → tool use → verification
Causal Matryoshka	Which scale has real causal grip?	microstates → macrostates with stronger causal structure