🤖 AI

Moonshine: An Autonomous Mathematical Research Agent Centered on Conjecture Generation

This paper introduces Moonshine, an autonomous agent that generates significant mathematical conjectures by extracting structural insights from classical problems, demonstrated through its formulation and partial proof of the "Neural Jacobian Conjecture" regarding the global injectivity of specific neural networks.

Original authors: Xiaoyang Chen, Xiang Jiang

Published 2026-06-10

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xiaoyang Chen, Xiang Jiang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: A Robot Mathematician

Imagine a robot named Moonshine. Unlike a calculator that solves a specific math problem you give it, or a search engine that finds answers you already know, Moonshine is designed to invent new math problems and then try to solve them on its own.

Think of Moonshine as a curious explorer. Its main job isn't just to find a treasure (a solution); its job is to draw a new map (a conjecture) and then hike through the terrain to see if the map is accurate. It keeps a detailed diary of every step, every dead end, and every "aha!" moment.

The Mission: The "Jacobian" Mystery

Moonshine started by looking at a famous, unsolved math puzzle called the Jacobian Conjecture.

The Analogy: Imagine you are folding a piece of paper. If you look at a tiny, microscopic spot on the paper, it looks flat and smooth (local). But if you look at the whole sheet, it might be crumpled up so that two different points on the paper are now touching the same spot in space (global).
The Question: If a shape is "smooth" and "non-crushed" at every tiny local point, does that guarantee the whole shape is unique and never overlaps itself? In math terms: Does "local non-degeneracy" force "global injectivity" (one-to-one mapping)?

Moonshine didn't try to solve the original, incredibly hard puzzle. Instead, it said, "Let's build a simpler, controlled version of this puzzle to see if the logic holds."

The New Puzzle: The "Neural Jacobian Conjecture"

Moonshine created a new, simpler world to test this idea. It chose a specific type of Neural Network (a computer brain) that is very structured:

It has one hidden layer.
It uses a specific "Sigmoid" function (a smooth S-curve that squishes numbers between 0 and 1).
It has a specific width (number of neurons).

Moonshine proposed the Neural Jacobian Conjecture (NJC):

"If this specific type of computer brain is 'smooth' and 'non-crushed' everywhere (its Jacobian determinant is positive), then it must be globally unique. It can never fold over onto itself."

The Expedition: How Moonshine Solved It

Moonshine didn't just guess; it went to work. It acted like a research team, using different "experts" (AI models) to prove the conjecture for different scenarios.

1. The Easy Case (Width = Input Size)

First, Moonshine looked at the simplest scenario where the network's width matched the input size.

The Result: It proved this was true.
The Analogy: Imagine a puzzle where the number of pieces exactly matches the number of slots. If every piece fits perfectly without crushing, there's only one way to assemble the whole picture. Moonshine showed that for this simple setup, the "local smoothness" guarantees the "global uniqueness."

2. The Tricky Case (Width = Input Size + 1)

Next, Moonshine tackled a slightly harder scenario where the network had just one extra neuron (one extra dimension of freedom). This is where things get messy because there is a "kernel" (a hidden direction where the network can wiggle).

The Result: Moonshine proved this was also true, but it needed help.
The Method: It used two different AI "proofreaders" (GPT-5.5-pro and DeepSeek-V4-pro) to write two completely different algebraic proofs. Then, it used a third AI (ChatGPT) to build a geometric-topological proof.
The Analogy: Imagine trying to prove a bridge won't collapse.
- Proof A used algebra (counting the beams and bolts).
- Proof B used geometry (looking at the shape of the bridge).
- Both proofs agreed: As long as the bridge is locally solid, the extra dimension isn't enough to let it fold over on itself. The "wiggle room" is too small to cause a collision.

3. The Unsolved Frontier (Width = Input Size + 2 or more)

Finally, Moonshine looked at networks with two or more extra neurons.

The Result: Unknown.
The Analogy: Now the bridge has so much extra space that it can twist and turn in complex ways. Even if every local spot is solid, the whole structure might be able to loop around and touch itself in a way that doesn't break the local rules.
Moonshine admits it hasn't solved this yet. It has identified the "boundary" where the current logic stops working. This is left as an open problem for future researchers.

Why This Matters (According to the Paper)

The paper doesn't claim Moonshine has solved the original, massive Jacobian Conjecture. Instead, it claims Moonshine successfully demonstrated its own ability to:

Extract the core logic of a hard problem.
Translate it into a new, testable setting (Neural Networks).
Prove it in specific, difficult cases using rigorous math.
Identify the limits of what is currently known.

Summary

Moonshine is a robot that acts like a mathematician. It took a famous, unsolved riddle about folding shapes, created a simpler version using computer brains, and proved that for small, simple brains, "smoothness everywhere" means "no folding." It hit a wall when the brains got too big, but it successfully mapped out exactly where the mystery begins.

The paper concludes: We have strong evidence that the rule works for small networks, but for larger, more complex networks, the question remains open.

Technical Summary: Moonshine and the Neural Jacobian Conjecture

Problem Statement

The paper addresses the challenge of autonomously generating meaningful mathematical conjectures and making rigorous progress on them. Specifically, it investigates the transfer of the core logic from the classical Jacobian Conjecture—which asks whether a local nondegeneracy condition (a nonzero Jacobian determinant) implies global injectivity in polynomial maps—to the domain of neural networks.

The classical conjecture remains open. Moonshine, an autonomous research agent, seeks to distill the essential structural logic of this problem and apply it to a restricted, structurally transparent class of functions: one-hidden-layer affine-ridge sigmoid networks. The goal is to determine if the rigidity observed in local diffeomorphisms extends to global injectivity within this specific neural network architecture.

Methodology

The paper introduces Moonshine, an autonomous mathematical research agent designed to operate in a research mode centered on conjecture generation. Its methodology involves four key components:

Structural Recognition: Identifying core features in classical problems (e.g., the link between local nondegeneracy and global injectivity) and distilling them into new concepts.
Bridge Building: Transferring these logical structures to new domains (in this case, from polynomial maps to sigmoid networks).
Deep Exploration & Obstacle Identification: Iteratively attempting proofs, constructing counterexamples, and defining the boundaries of applicability.
Collaborative Verification: Utilizing Large Language Models (LLMs) as verification tools. Moonshine invoked GPT-5.5-pro and DeepSeek-V4-pro to generate independent algebraic proofs and used ChatGPT (via web interface interaction with GPT-5.5-pro) to develop geometric-topological proofs.

The agent operates within a structured runtime environment, maintaining long-term logs of conjectures, proof attempts, and failed paths to form an extensible theoretical framework.

Key Contributions

1. Formulation of the Neural Jacobian Conjecture (NJC)

Moonshine formulated the Neural Jacobian Conjecture (NJC), which posits that for the class of one-hidden-layer affine-ridge sigmoid networks, local nondegeneracy implies global injectivity.

Function Class: Let $\sigma(t) = (1+e^{-t})^{-1}$ be the logistic sigmoid. A map $F: \mathbb{R}^n \to \mathbb{R}^n$ is in the class $\mathcal{N}_{n,N}$ if $F(x) = A\sigma(Bx + c)$ , where $A \in \mathbb{R}^{n \times N}$ , $B \in \mathbb{R}^{N \times n}$ , and $c \in \mathbb{R}^N$ .
The Conjecture: For every $F \in \mathcal{N}_{n,N}$ such that $\det DF(x) > 0$ for all $x \in \mathbb{R}^n$ , the map $F$ is globally injective.

2. Geometric Reformulation

The paper provides a geometric interpretation of the conjecture. Let $X_1 = \sigma(c + \text{Im } B)$ be the hidden-layer submanifold and $X_2 = \ker A$ be the output kernel. The injectivity of $F$ is equivalent to the condition that every affine fiber $(p + X_2)$ intersects the submanifold $X_1$ at exactly one point ( $p$ ). The condition $\det DF > 0$ corresponds to the transversal intersection of $X_1$ and $p + X_2$ with a local index of $+1$ .

3. Partial Verification Results

Moonshine successfully proved the NJC for specific low-width cases, providing preliminary evidence for the conjecture's plausibility:

Case $N = n$ : Proven via Proposition 3.1. When the width equals the input dimension, the matrices $A$ and $B$ must be invertible. Since the network is a composition of invertible affine maps and strictly increasing componentwise maps, injectivity follows directly.
Case $N = n + 1$ : Proven via three distinct methods:
1. Algebraic Proof 1 (GPT-5.5-pro): Utilized an injectivity lemma for linear projections on the graph of a scalar function over convex sets.
2. Algebraic Proof 2 (DeepSeek-V4-pro): Demonstrated one-dimensional monotonicity along the kernel direction, showing that the derivative of a constructed function $f(t)$ maintains a fixed sign, preventing multiple roots.
3. Geometric-Topological Proof (ChatGPT/GPT-5.5-pro): Analyzed the intersection of the submanifold $X_1$ with one-dimensional fibers. It showed that while non-degenerate zeros of the intersection function $g(t)$ must have alternating derivative signs, the positive Jacobian condition forces all local signs to agree, leading to a contradiction if multiple intersections exist.

4. Identification of Open Problems

The paper explicitly identifies the higher-width case ( $N \ge n + 2$ ) as unresolved. In this regime, the kernel $X_2$ has dimension $\ge 2$ . The mechanism that forces injectivity in the $N=n+1$ case (alternating signs of derivatives in one dimension) fails because higher-dimensional maps can possess multiple regular zeros, all with local index $+1$ , without being injective.

Significance and Claims

The paper claims significance in two primary areas:

Advancement of Autonomous Research: It demonstrates that an autonomous agent (Moonshine) can not only generate a precise, non-trivial mathematical conjecture but also drive rigorous progress on it. This includes formulating the problem, deriving geometric reformulations, and orchestrating independent proofs via LLMs to verify partial results.
Mathematical Insight: The NJC serves as a potential rigidity theorem for neural networks. If true, it would establish that the special affine-ridge structure enforces global injectivity from local nondegeneracy, creating a parallel to the classical Jacobian Conjecture. Even if the conjecture is eventually disproven for higher widths, the exploration clarifies the boundary between local diffeomorphism and global injectivity in neural architectures.

The authors remain modest, stating that the general case $N \ge n + 2$ remains an active open problem and that the current work provides "preliminary evidence" rather than a complete solution. The full source code, research logs, and intermediate verification records are made available in the project repository.