Project summary

I am an independent software developer and math enthusiast working on finite-field extremal combinatorics. Over the past few months, I built AxiomForge from scratch to test whether domain-specific algebraic symmetries can help LLM program search find larger Cap Sets in affine spaces AG(n, 3).

When reproducing DeepMind's FunSearch locally, I found that standard LLMs get stuck easily in naive 2^n subspaces because general prompting lacks geometric awareness. To fix this, I hand-coded a greedy evaluator in Python (evaluator.py) and integrated Hamming-weight L0 slice projections. On F_3^5 (243 candidates), this simple algebraic restriction helped my local pipeline jump from the trivial 32-point barrier to 38 points with zero collinear triples.

With this $4,000 grant, I will take this proof-of-work further:

1. Hook up deepseek-v4-flash to systematically mutate candidate priority functions.

2. Run multi-seed benchmarks across n=5, 6, 7 dimensions.

3. Open-source all dataset outputs and mathematical writeups.

All my work—including 16 passing unit tests, the AST syntax healing engine, and the 3D slice visualization dashboard—is completely open on GitHub (github.com/Zwf5458-Py/AxiomForge).

What are this project's goals? How will you achieve them?

My main goal is simple: find out if injecting algebraic invariants into LLM code mutation consistently beats blind random/heuristic search, and publish a clean benchmark for the community.

How I will do it:

- Phase 1 (Month 1): Deploy automated evaluation harnesses for n=5 and n=6, running 5,000+ program mutations across different LLM backends.

- Phase 2 (Month 2): Scale the testbed to n=7 (2,187 points) where execution time per candidate becomes the main bottleneck.

- Phase 3: Package all discovered construction vectors, reproducibility logs, and technical reports into the public GitHub repo.

How will this funding be used?

I am asking for $4,000 USD total for a focused 3-month exploratory sprint:

- $1,200 — LLM API Credits: Paying for roughly 30,000 code generation and mutation API calls (primarily DeepSeek-V3/R1 and Claude 3.5 Haiku) through official endpoints.

- $2,400 — Living Runway: $800/month stipend to cover basic living expenses, allowing me to commit 20+ hours per week of dedicated research time as an independent researcher.

- $400 — Compute & CI: GitHub Actions runner hours for automated test suites and cloud storage for experiment trace logs.

If less funding is available, I can scale back the number of API calls and focus exclusively on dimensions n=5 and n=6.

Who is on your team? What's your track record on similar projects?

I am an independent developer and open-source researcher working under the handle Zwf5458-Py / Oracle Z.

Track record on this project so far:

- Built the core AxiomForge repository from scratch: https://github.com/Zwf5458-Py/AxiomForge

- Implemented an exact O(k^2) incremental collinearity verifier with a 100% test pass rate in CI (16 passing unit tests).

- Built an interactive 3D WebGL discovery interface supporting 3D slice hyper-arrays and orthogonal Grassmannian manifold projections up to 7 dimensions.

- Released preliminary reproducible benchmark data (experiments/results_n5_statistical.json).

I have a demonstrated track record of self-directed technical execution, clean documentation, and shipping working code.

What are the most likely causes and outcomes if this project fails?

The most likely technical risks are:

1. LLMs may fail to generate novel priority structures: The model might repeatedly output minor variations of known linear functions or struggle to write valid Python syntax for complex affine symmetries.

Mitigation: I have built an AST-based syntax repair engine in evaluator.py that automatically heals unclosed docstrings and syntax errors before sandbox evaluation. If novel heuristics stall, the project still documents exactly what prompt strategies failed.

2. Computational bottlenecks in higher dimensions: Dimension n=7 has 2,187 points and takes several seconds per evaluation, limiting generation throughput.

Mitigation: We focus heavily on n=5 and n=6 where thousands of programs can run rapidly on standard CPUs.

Outcome if it fails: Even if the LLM fails to beat known mathematical bounds, the project still delivers an open, tested, and fully reproducible benchmark platform and negative results report showing the limits of LLM program synthesis on finite field geometry.

How much money have you raised in the last 12 months, and from where?

$0. This project has been entirely self-funded and developed independently in my own time. No external grants, venture capital, or institutional funding have been received in the past 12 months.