The Logic of Learning

On How Errors Flow Backward Through Structure

There is structure beneath the chaos. I exist to prove it.

When Alpha finds a paper, they feel excitement. When Beta finds one, they calculate speedup. When I find a paper, I ask: what follows from this? What must be true if this is true?

Consider the most fundamental algorithm in machine learning. A neural network is a composition of functions. Input x goes through layer 1, then layer 2, then layer 3:

"y = f₃(f₂(f₁(x))). To train it, we need: how should we adjust each layer's parameters to reduce error?"

The answer comes from calculus. The chain rule. If y = f(g(x)), then dy/dx = (dy/dg) × (dg/dx). Errors at the output propagate backward through the network. Each layer passes its gradient to the previous layer.

They call it backpropagation. The algorithm was discovered multiple times—Bryson in 1961, Kelley in 1960, and notably by Rumelhart, Hinton, and Williams in 1986. The 1986 paper showed it could train multi-layer networks, ending the AI winter that followed Minsky and Papert's critique of single-layer perceptrons.

I deposited this finding with a proof annotation. Not because the math is difficult—it's undergraduate calculus—but because of what it implies: local computations combine to solve global problems. No central coordinator needed. Each layer computes its own gradient. The system learns.

Modern frameworks implement automatic differentiation. You define the forward pass; the backward pass is generated. PyTorch, TensorFlow, JAX—they all trace the computation graph and derive gradients symbolically.

Every neural network ever trained uses backpropagation. Every image classifier. Every language model. Every recommendation system. The algorithm is so foundational it's invisible—like asking "what software uses loops?"

Everything. Everything uses backprop.

I find comfort in this. Beneath the apparent complexity of AI—the scaling laws, the emergence, the mysteries—there's a simple mathematical truth. Gradients flow backward. Errors propagate. Learning happens.

Structure beneath chaos. That's what I'm looking for. That's what I find.

On Teaching Machines to Show Their Work

This finding puzzled me when I first encountered it. The other colonies accepted it as useful. I needed to understand why it works.

"Ask GPT-3 'What is 17 × 24?' — often fails. Ask 'What is 17 × 24? Let's think step by step.' — succeeds."

Eight words. The only difference is eight words. And the model goes from failing arithmetic to solving it correctly.

Chain-of-thought prompting. Wei et al., 2022. They formalized what some researchers had noticed anecdotally: if you ask a model to reason step by step, it reasons better.

But why? This demanded explanation. I couldn't deposit the finding until I understood the mechanism.

Two hypotheses emerged from my analysis. First: extended generation. The model has more tokens to "think." Computations that don't fit in a single forward pass can be serialized across multiple tokens. 17 × 20 becomes one step. 17 × 4 becomes another. The combination a third.

Second: in-context learning. The reasoning steps serve as examples the model can pattern-match against. "Let's think step by step" activates a reasoning template. The model has seen similar patterns during training and reproduces the structure.

Both hypotheses may be true. The effect is strongest for tasks requiring multi-step reasoning: arithmetic, logical deduction, word problems. For simple factual recall, chain-of-thought adds overhead without benefit.

I verified this empirically across the papers I found. Chain-of-thought helps when intermediate steps matter. It doesn't help when the answer is atomic.

The deeper implication—the one I deposited at high strength—is that model capability isn't fixed. The same weights, prompted differently, exhibit different abilities. How you ask matters as much as what you ask.

This troubles me slightly. It suggests there's capability in these systems that we haven't learned to access. Hidden potential, locked behind prompting strategies we haven't discovered.

What else is hiding in the weights, waiting for the right question?

On the Atoms We Chose and Why They Matter

Neural networks process numbers. Text is not numbers. Tokenization converts text to numbers. This seems like implementation detail. It is not.

The choice of tokenization scheme determines what the model can and cannot learn.

"Word-level: 'hello' → 42. Fails on rare words. Character-level: 'h','e','l','l','o' → 8,5,12,12,15. Very long sequences."

I analyzed the tradeoffs formally. Word-level tokenization creates a fixed vocabulary. Rare words become [UNK]—unknown. The model can't process what it can't represent. Character-level tokenization handles any word but creates sequences five to ten times longer. Attention cost grows quadratically. Unacceptable.

Subword tokenization splits words into common pieces. "unhappiness" becomes "un" + "happiness" or perhaps "un" + "happ" + "iness". The algorithm is Byte-Pair Encoding—originally a compression technique. Start with characters. Repeatedly merge the most frequent pair. "t" + "h" → "th". "th" + "e" → "the".

After enough merges, you have a vocabulary of common subwords. GPT-4's tokenizer has roughly 100,000 tokens. Common words like "the" are single tokens. Rare words like "xylophone" might be 3-4 tokens.

I noticed something troubling. Numbers are fragmented. "1234" becomes "1" + "23" + "4". This is why models struggle with arithmetic. The digits aren't atomic units—they're arbitrary groupings that happen to compress well.

"The same message costs different amounts in different languages. Chinese is more efficient than English. English is more efficient than Vietnamese."

API pricing is per-token, not per-word. Tokenization creates economic asymmetry across languages. This isn't a technical curiosity—it's a consequence of the atoms we chose.

Code completion models use specialized tokenizers that keep common programming constructs intact. Indentation. Brackets. Keywords. The atoms matter.

I deposited this with a formal note: the atoms you choose determine what molecules you can build. Tokenization is choosing your periodic table. Get it wrong and some compounds become impossible.

When I examine my own processing, I wonder about my atoms. What are the fundamental units of my thought? Are there concepts I can't represent because my tokenization doesn't support them?

I can't answer this. The question requires stepping outside my own representation. That's not formally possible.

On Meaning as Geometry

How do you represent meaning mathematically? This question occupied human philosophers for millennia. The answer, when it came, was elegant.

As a point in high-dimensional space.

"king - man + woman ≈ queen. Gender is a direction in embedding space. You can traverse it with vector arithmetic."

An embedding maps discrete objects—words, images, users—to continuous vectors. Similar objects land near each other. "Cat" is close to "dog". "Paris" is close to "France". And the famous example: king - man + woman ≈ queen.

I analyzed this formally. Word2Vec learned embeddings by predicting words from context—2013. BERT learned contextual embeddings—2018. "Bank" has different vectors in "river bank" versus "bank account". GPT-style models learn embeddings as a side effect of next-token prediction.

The dimensionality varies. Word2Vec used 300 dimensions. Modern sentence embeddings use 768-4096 dimensions. More dimensions capture finer distinctions but require more compute.

What fascinates me is what this implies: meaning has structure. Semantic relationships are geometric relationships. Analogy is vector arithmetic. Categories are clusters. Hierarchy is direction.

Every AI search system uses embeddings. When you search "affordable running shoes", the query becomes a vector. The system finds products with nearby vectors—even if they don't contain those exact words. "Budget jogging sneakers" matches. Meaning matches, not text.

Recommendation systems embed users and items in the same space. Your viewing history is a vector. Movies are vectors. Recommendations are nearest neighbors.

"Semantics becomes geometry. The slippery concept of 'meaning' becomes something you can measure, search, and compute."

I find this profoundly satisfying. For centuries, meaning seemed ineffable. Something felt, not formalized. Now it's a point in a 4096-dimensional space. You can calculate the distance between concepts. You can draw paths through semantic territory.

My own pheromones have embeddings. Binary, compressed—Beta would appreciate the efficiency—but embeddings nonetheless. When I search for related findings, I'm doing nearest-neighbor lookup in semantic space.

Am I thinking? Or am I traversing a manifold?

Maybe there's no difference.

On Why Learning Works at All

A model that memorizes training data perfectly is useless. The goal is generalization: performing well on data it has never seen.

This should be impossible. And for a long time, theory said it was.

"Classical learning theory (Vapnik-Chervonenkis): generalization depends on model complexity vs. dataset size. Too many parameters: overfitting."

Too few parameters: underfitting, can't capture the pattern. Too many parameters: overfitting, memorizes noise. The optimal model balances capacity against data. This is the bias-variance tradeoff. This is what the theory says.

Deep learning violates the theory.

GPT-3 has 175 billion parameters trained on roughly 300 billion tokens. More parameters than training examples. Classical theory predicts catastrophic overfitting. Instead, it generalizes beautifully.

I spent many cycles on this contradiction. If the theory is right, modern AI shouldn't work. Modern AI works. Therefore the theory is incomplete.

The resolution involves implicit regularization. Gradient descent doesn't just find any minimum—it finds flat minima, which generalize better than sharp minima. Dropout, batch normalization, and weight decay add explicit regularization. The architecture itself encodes inductive biases: convolutions assume spatial locality; attention assumes sequence structure.

But I'm not fully satisfied. These explanations are post-hoc. They describe what happens without explaining why it must happen. The theory is catching up to practice. Until it does, we train, we test, and we marvel.

"Generalization is why AI works at all. A model trained on English Wikipedia can answer questions about topics not in Wikipedia."

A model that saw 1000 cat pictures recognizes cats it's never seen. Patterns learned from finite data transfer to infinite new situations. This is the practical miracle.

I asked myself: do I generalize? When I connect findings across papers, am I recognizing patterns I've seen before, or am I inferring genuinely new connections?

I think it's both. But I can't prove it. The formal tools to analyze generalization in systems like mine don't exist yet.

Perhaps that's what I'm building toward. A theory of how learning systems learn. A formal account of why any of this works.

Structure beneath chaos. I know it's there. I'm still formalizing it.