genetic_hackathon explores cumulative learning through executable composition. Candidate programs start from supplied operations, compete on examples, and can become callable definitions in a growing library. The work asks how that library can expand what later search is able to construct.
The current workbench uses a shared evolutionary engine for mathematical expressions and first-order logic. It retains both callable discoveries and reusable simplifications, so learning can change how a later expression is built and how earlier answers are revised. Earlier addition-only and symbolic studies remain available with their original settings and results.
Why this approach
Discovery needs a route back into search
A retained definition has two jobs: execute correctly and become available in the right later construction. The first can succeed while the second fails. That is why the work records actual candidates and helper calls, as well as the final answer.
Conventional notation is attached after examining a discovered definition. A repeated product can earn a power label without the label supplying its executable body. Parameter extraction, the allowed language, and recognizers remain supplied machinery and should be visible alongside what evolution found.
The other route is to learn a better way of expressing work already done. A simplification discovered while solving one problem can shorten a saved answer to another, then change what is offered to future search. The implementation preserves the old definitions and checks a proposed replacement before using it, so a shorter expression does not silently erase its evidence or alter its meaning.
Where it stands
A task supplies examples; the configured search constructs and evaluates candidates using allowed primitives and learned calls. Candidate subexpressions can suggest reusable reductions. When the algebra establishes a cheaper equivalent form, the shared memory reducer applies it to later candidates, retained definitions, and previously solved answers. Superseded definitions remain inspectable and executable in the archive.
The first-order logic adapter reuses the engine, activity stream, continuation, and interface. Finite interpretations guide its search, while acceptance and reusable logical equalities require a proof of equivalence from the supplied solver. That is a different contract from the finite-probe arithmetic library shown below; inconclusive proofs remain unaccepted.
The division studies began with the six learned helpers shown below. Later expression-runner work also recorded direct reuse of a discovered power definition for squaring. The examples below distinguish saved discoveries from later implementation features.
A discovered power definition was reused for squaring
In a cumulative program-discovery experiment, addition, summation, and product supplied the starting operations. Evolution found a constant-base product in generation one. Supplied parameter abstraction retained a general repeated-product function. In generation two, the next task used that saved body as power(n, 2).
The saved function was reused in one run under a supplied abstraction policy; the repetition evaluator allows integer counts from 0 through 100, so the retained function is not unrestricted exponentiation.
Making learned functions ordinary choices changed the search result
The cube diagnosis found that learned multiplication was almost never proposed because selecting a saved function depended on first selecting a terminal. The revised generator samples learned calls independently. With the same inherited library, cube examples, population, generation allowance, and five seeds, the earlier sampler found no complete match; the revised one matched every example in all five seeds.
Each successful answer composed the retained multiplication function. First matches arrived in generations 14, 18, 11, 15, and 9. Its multiplication still has the original bounded repetition semantics; general arithmetic transfer remains a separate question.
A perfect training fit revealed a precise shortcut
The division selection comparison produced no validated quotient in fifteen trials. Lexicase found two candidates matching all 35 training examples, but both returned 4 for 8 divided by 1. One candidate effectively counted only the first four groups, exactly matching the largest quotient in training.
A separately versioned curriculum expanded the examples and reduced that candidate to 90 correct answers out of 144. Five matched seeds per curriculum still produced no validated quotient. The expanded examples exposed the shortcut; they did not supply the missing general construction.
Experiments and evidence
Selected recorded studies. Each keeps its original conditions, date, interpretation, and limits.
Saved discovery artifact · 8 September 2026
Six learned operations retained for a division benchmark
This frozen library preserves six executable helpers evolved in the addition-only setting. The benchmark begins with those learned helpers, without a supplied quotient or remainder solution. Each entry retains its program tree and the cases used to recognize its behavior.
The original library labels its recognition explicitly: Exact on recorded finite task probes; not a universal proof.The operation names below are recognizer-assigned identities, not evidence that the learner discovered their conventional mathematical names.
Operations in the saved benchmark library
Executable symbol
Recognized behavior
Training cases
Validation cases
op_001
multiply
25
21
op_002
predecessor
6
6
op_003
is zero
6
6
op_004
subtract
25
10
op_005
less equal
25
10
op_006
fits groups
80
12
One retained program: multiplication
The stored tree repeats addition of a to the state b times, starting at zero. The tree below is the saved executable representation.
The saved operation can be called during later search. Its finite tests do not establish universal correctness, and the six helpers alone do not establish that division was learned.
Matched settings, all five seeds, discovered expressions, and the generations at which each sampler found a solution.
What remains open
Test whether the observed gains from learned-call sampling and propagated simplifications extend to unfamiliar problem families and larger independent inputs.
Measure both later solution rate and actual search cost when a learned library is available.
Test discovered arithmetic procedures on larger unseen inputs without confusing supplied notation or finite recognition with a general identity proof.