The living catalogue

Alpha's long-term hope is larger than a standard library.

The aim is a growing, inspectable collection of reusable knowledge: algorithms, primitive operations, data structures, equations, mathematical constructions, physical laws, biological mechanisms, learning rules, optimization methods, numerical schemes, experimental procedures, proof obligations, reference implementations, target realizations, and the evidence that tells us when each one applies.

Agents and people would keep adding to it. They would repair definitions, connect equivalent ideas, add stronger proofs, improve implementations, qualify new hardware realizations, record counterexamples, and preserve the history rather than silently replacing it.

That is an ambition, not a description of the current repository. Today's catalogue is primarily a structural inventory of Alpha source. The catalogue browser makes that starting point visible.

Not an encyclopedia in the compiler

“Everything” cannot mean copying every textbook, paper, dataset, and scientific claim into one undifferentiated codebase. That would create an enormous pile of names with no reliable way to know what composes, what conflicts, or what deserves trust.

The useful unit is a knowledge-bearing component with an explicit boundary. Depending on the domain, that component may need:

• a stable identity and version;
• a typed interface;
• mathematical meaning or an operational semantics;
• dimensions, units, coordinate systems, and conventions;
• preconditions and domains of validity;
• exact, approximate, probabilistic, or empirical status;
• laws, proofs, tests, counterexamples, and known failure modes;
• a reference definition independent of optimized realizations;
• one or more target-specific implementations;
• resource, accuracy, and performance envelopes;
• provenance, authorship, licensing, and citations;
• dependency and equivalence relationships; and
• evidence showing what has actually been checked or measured.

Some knowledge is executable. Some is a theorem. Some is a measured regularity that can be invalidated by a better experiment. Some is a model that is useful only within a scale or regime. Alpha must represent those differences instead of flattening them into functions that merely share a call syntax.

Context without one impossible prompt

The catalogue is not meant to be poured wholesale into an agent's context window.

An agent starts with a question: construct a tokenizer, test a non-attention memory mechanism, derive a stable integrator, compile an optimizer for a device, compare two biological learning rules, or investigate an equation under a different numerical regime.

The system can then assemble a relevant context closure:

1. Resolve the concepts and interfaces named by the question.
2. Retrieve candidate definitions, laws, implementations, and counterexamples.
3. Follow typed dependencies rather than nearby words alone.
4. Filter by evidence requirements, dimensions, target capabilities, licenses, and resource budgets.
5. Preserve competing definitions when the domain has not settled on one.
6. Present the smallest useful subgraph to the agent, with provenance attached.
7. Record the resulting experiment and its evidence back into the catalogue.

The value comes from selective, structured recall. A large catalogue gives an agent more possible starting points; types, relationships, and evidence keep that possibility space from becoming noise.

The catalogue-guided search proposal develops this retrieval step into a complete, falsifiable research loop: agent proposals, deterministic contract checks, diversity-preserving exploration, bounded learned judgments, Alpha experiments, and evidence returned to the catalogue.

Why this could change learning-system research

Most model code starts inside the vocabulary of the framework that happens to be available. Its tensor primitives, kernels, model templates, optimizer APIs, hardware assumptions, and examples quietly define which ideas are easy to try.

A broad Alpha catalogue could make a different workflow possible.

Reuse mechanisms rather than inherit one model

An agent could draw on recurrence, sparse routing, finite-state processes, control theory, coding theory, dynamical systems, information theory, probabilistic inference, signal processing, numerical analysis, biological adaptation, and unfamiliar combinations of them without treating any one family as the universal architecture.

The catalogue would supply components and constraints, not a preselected answer.

Compile consequences before spending an experiment

If shapes, quantities, effects, ownership, units, target capabilities, schedules, and resource bounds remain explicit, the compiler can reject many incoherent combinations before a run reaches hardware.

This matters for agentic exploration. Generating one candidate is cheap; discovering late that ten thousand candidates were dimensionally invalid, numerically unsupported, or impossible on the target is expensive.

Keep negative knowledge

A useful scientific catalogue includes failed constructions, counterexamples, unstable regimes, unsupported targets, misleading benchmarks, and disproved equivalences. Otherwise every new agent repeats the same dead ends and the library accumulates only survivorship bias.

Negative evidence should narrow future search without making a local failure look like a universal impossibility.

Compare ideas through shared contracts

When two systems expose compatible semantic and experimental boundaries, an agent can compare them without pretending their implementations are identical. The comparison can bind the data, seed, numerical regime, hardware profile, resource budget, metrics, and stopping rule.

That makes rapid experimentation cumulative: a result becomes a reusable constraint on the next experiment rather than a disconnected log file.

Let improvements compound

A better primitive implementation can improve every system whose checked plan selects it. A stronger law can eliminate invalid candidates earlier. A new target realization can make a whole family of existing ideas executable on new hardware. A counterexample can protect future agents from an attractive but false shortcut.

The collection becomes more valuable when its relationships and evidence improve, not merely when its row count increases.

One idea, several layers

The catalogue must avoid treating a concept, its implementation, and a successful run as the same object.

For example, an algorithm may have:

A source file may participate in several layers, but the claims remain distinct. “Indexed,” “checked,” “compiled,” “ran,” “matched an oracle,” and “produced a scientifically useful result” are not synonyms.

Mathematics, physics, and biology are not the same kind of truth

A universal catalogue has to preserve the epistemic character of each entry.

Mathematics

Mathematical objects may support exact definitions and machine-checkable proofs, but notation, axioms, constructive assumptions, and representation choices still matter. Two definitions that are extensionally equivalent may have very different computational behavior.

Physics

Physical equations carry units, frames, scales, approximations, boundary conditions, and experimental provenance. Newtonian mechanics is not “wrong” because relativity exists; it has a domain in which it is an effective model. A compiler must not erase that domain.

Biology

Biological mechanisms are often contingent, stochastic, multi-scale, population-dependent, and described by incomplete evidence. A pathway diagram is not a total program. Competing models and unresolved observations must be representable without manufacturing certainty.

Algorithms and software

An asymptotic algorithm, a constant-time security claim, a numerically stable implementation, and a kernel optimized for one architecture are different artifacts. The catalogue needs to connect them without collapsing them.

This is why provenance and qualification are part of the object rather than documentation added afterward.

How additions should mature

A possible lifecycle is:

1. Propose — add a named component with provenance and an honest initial status.
2. Structure — parse it, establish its interface, and index its relationships.
3. Check — verify the contracts the current checker can actually establish.
4. Compare — test against independent references, laws, fixtures, and counterexamples.
5. Realize — provide target-specific implementations without moving target assumptions into the concept.
6. Measure — attach performance, resource, numerical, and physical evidence to exact revisions.
7. Use — compile it into larger systems and observe whether its contract survives composition.
8. Revise — improve or supersede it while keeping old identities and evidence interpretable.

An entry need not reach every stage to be useful. It must, however, say which stage it has reached.

What agents should be able to ask

A useful catalogue should eventually answer questions such as:

• Which maintained definitions implement this contract?
• What must be true before this equation or approximation is valid?
• Which modules depend on this primitive, directly or transitively?
• Which realizations fit a particular target and memory budget?
• Which laws and negative cases cover this public function?
• Which alternatives have the same observable contract but different resource behavior?
• What evidence was produced independently of the implementation under test?
• Which result changed after a compiler, dataset, numerical regime, or hardware revision?
• What has never been tested outside one fixture or device?
• Which apparently novel proposal is equivalent to something already catalogued?
• What is the smallest dependency closure needed for this experiment?

Those queries require more than full-text search. They require stable identities, typed relationships, dependency graphs, evidence links, and eventually semantic alignment among different vocabularies.

The current catalogue

The repository already has a SQLite catalogue generated from the project tree. Its structural Alpha records come from compiler-owned syntax tooling rather than a separate regular-expression parser. The current public snapshot exposes:

• Alpha module identities and their source records;
• families, constructors, fields, and definitions;
• repository areas and dispositions;
• direct import edges and inbound dependency counts;
• content hashes and revision-bound source links;
• verification, historical, and library/system scopes; and
• explicit index exceptions.

The underlying database also has places for contracts, evidence, migrations, and deprecations. Some are populated; some are still empty. In particular, a structural symbol inventory is not yet a semantic catalogue of all reusable knowledge.

That gap is deliberately visible in the catalogue browser. The browser reports the catalogue capture separately from the website build and labels indexed source as indexed source—nothing stronger.

The generator and database contract are documented in the repository's catalogue README. Library ownership decisions are maintained separately in LIBRARY-OWNERS.tsv.

What must be built next

Moving from a structural inventory to the larger vision requires several hard capabilities:

• stable public symbol identities across moves and editions;
• AST-resolved references and dependency closures available as queryable data;
• first-class contract, law, counterexample, evidence, and realization records;
• dimensional, numerical, probabilistic, and empirical metadata;
• equivalence and refinement relationships with explicit justification;
• provenance and licensing that survive composition;
• scalable retrieval that gives agents a relevant subgraph rather than a dump;
• quality controls that resist duplicate, low-evidence, or agent-invented entries;
• independent verification paths; and
• governance for disputes, supersession, and domains where no single canonical answer exists.

The catalogue should grow only as quickly as its distinctions remain trustworthy. A million unqualified names would give agents less usable context than ten thousand components whose boundaries and evidence can be inspected.

The compounding loop

The intended loop is simple to state:

More well-structured knowledge gives agents better material for experiments. Better experiments produce evidence and improved components. Those results make the catalogue more useful for the next agent.

Alpha's language and compiler matter because they can make more of that loop checkable. The catalogue matters because no agent should have to rediscover the whole intellectual world before it can try one genuinely new combination.

The north star is not a static archive of everything humanity knows. It is a living, typed, evidence-bearing substrate from which agents can assemble ideas, challenge assumptions, compile consequences, run experiments, and return what they learned.