🤖 AI

Generative Logic: A New Computer Architecture for Deterministic Reasoning and Knowledge Generation

This paper introduces Generative Logic (GL), a deterministic computer architecture that compiles axiomatic definitions into a distributed grid of Logic Blocks to systematically generate auditable, full-provenance proofs and numerical calculations, successfully deriving complex mathematical results like Gauss's summation formula on commodity hardware.

Original authors: Nikolai Sergeev

Published 2026-04-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Nikolai Sergeev

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

Imagine you have a recipe book, but instead of recipes for cakes, it contains the fundamental rules of how numbers work. Now, imagine a robot chef that doesn't just follow a recipe you give it, but instead reads the rules, figures out every possible dish it could make, cooks them all, and then serves you a menu of every single valid dish it discovered, complete with a receipt showing exactly how it made each one.

That is essentially what Generative Logic (GL) is.

Here is a breakdown of this new computer architecture using simple analogies:

1. The Big Idea: From "Asking" to "Exploring"

Currently, if you want a computer to solve a math problem, you usually have to ask it a specific question (like "What is 2+2?" or "Prove this theorem").

Old Way (Interactive Assistants): Like a human tutor. You ask a question, they help you solve it step-by-step. It's slow and requires you to know what to ask.
Old Way (AI Chatbots): Like a very confident guesser. They might get the answer right, but they are guessing based on patterns, so they can sometimes lie or make up facts (hallucinate).
Generative Logic (GL): Like a garden. You plant the seeds (the basic rules/axioms). You don't tell the garden what to grow; you just set the soil conditions. The garden then grows everything that can possibly grow from those seeds. It discovers new flowers (theorems) you didn't even know existed.

2. The Ingredients: The "Genome" (MPL)

The system starts with a special language called MPL. Think of this as the DNA of the system.

You write down the basic rules of math (like "0 is a number" or "every number has a next number").
The system reads this DNA and says, "Okay, I know the rules. Now I will figure out everything that must be true because of these rules."

3. The Factory: The "Logic Blocks" (LBs)

This is where the magic happens. The computer isn't one big brain; it's a massive factory with thousands of tiny, independent workers called Logic Blocks.

The Assembly Line: Imagine a giant grid of workers. Each worker has a small job. One worker checks if "A + B" equals "C". Another checks if "B + C" equals "D".
The Mail System: They don't talk to each other while they are working (to avoid confusion). They work in silence, then pass "mail" (new facts) to the next worker.
The Hash Engine: Instead of thinking deeply, these workers are like super-fast librarians. They have a giant index card system (a hash table). If a worker sees a fact that matches a card, they instantly pull out the next fact. It's not "thinking"; it's a lightning-fast lookup.

4. The Process: How It Works

The system runs in a loop, like a high-tech assembly line:

The Incubator (The Baby Factory): Before the main work starts, the system builds a "cheat sheet" of simple facts (like 1+1=2, 2+2=4). It proves these tiny facts first so it doesn't have to re-prove them later.
The Conjecture Weaver (The Idea Machine): The system takes the rules and starts mixing and matching them to create thousands of "guesses" (conjectures). It's like a child playing with Lego bricks, building every possible structure they can think of.
The Filter (The Bouncer): Most of those Lego structures are junk. The system quickly checks them against its "cheat sheet" (the Incubator facts). If a guess contradicts a simple fact (e.g., "2+2=5"), it gets thrown out immediately.
The Proof Engine (The Construction Crew): The remaining good guesses are sent to the Logic Block factory. The workers start connecting the dots. If they can link the starting rules to the guess without breaking any laws, they shout, "We found a theorem!"
The Compressor (The Editor): The system might find 1,000 theorems, but 900 of them are just variations of the same thing. The Compressor deletes the duplicates, leaving you with a clean, essential list of new discoveries.
The Verifier (The Inspector): Finally, an independent robot (written in a completely different language) checks every single step of the work. It says, "Yes, this is 100% true. No cheating."

5. The Result: A "Full-Provenance" Calculator

The coolest part? The system doesn't just prove abstract math; it can do calculations.

If you ask it to calculate a sum, it doesn't just use a standard calculator chip. It proves the calculation step-by-step from the basic rules of math.
The Analogy: Imagine a calculator that, when you type "2+2", doesn't just show "4". Instead, it shows you a 50-page legal document proving why 2+2 must be 4, tracing every step back to the very first rule of the universe.
This means every number it calculates is guaranteed to be true. No errors, no guessing.

6. Why Does This Matter?

Trust: In a world where AI can lie, GL cannot. It is built on strict logic, not probability.
Discovery: It can find math theorems that humans haven't thought of yet, just by exploring the "neighborhood" of the rules we gave it.
Speed: Because it uses thousands of workers in parallel, it can do in minutes what might take a human mathematician years to figure out.

Summary

Generative Logic is a new kind of computer brain that acts like a deterministic garden. You plant the seeds (math rules), and it automatically grows a forest of verified truths. It doesn't guess; it calculates by proving. It turns the abstract art of mathematics into a rigorous, auditable, and fully transparent process, promising a future where computers can help us discover new laws of the universe with absolute certainty.

1. Problem Statement

The field of automated mathematical reasoning currently faces a dichotomy between two paradigms, both of which have significant limitations:

Probabilistic Models (LLMs): While capable of solving routine problems and reformulating existing knowledge, their probabilistic nature limits reliability. They lack an intrinsic model of logical truth, making them prone to "hallucinations" and unable to guarantee the discovery of novel, non-trivial proofs.
Interactive Proof Assistants (Lean, Coq, Isabelle): These offer formal guarantees and rigorous verification but remain fundamentally manual. They require extensive human expertise to guide the proof process, define goals, and supply intermediate lemmas, leaving deep mathematical exploration inaccessible to full automation.

The Gap: There is a lack of a system that can autonomously generate and verify entire families of theorems from first principles without human intervention at the level of individual proof steps, while maintaining deterministic verifiability.

2. Methodology: The Generative Logic (GL) Architecture

Generative Logic (GL) is a deterministic, massively parallel computer architecture designed to bridge this gap. It shifts the paradigm from "human-assisted single-theorem proving" to "automatic generation and verification of theorem families."

Core Components & Workflow

The system operates through a deterministic, multi-stage pipeline:

Input (MPL): Users provide foundational axioms and definitions in Mathematical Programming Language (MPL), a domain-specific language based on a constrained subset of second-order predicate logic. MPL uses Logical Entities (LEs) (predicates) with typed "ports" and three core operators: Negation (!), Conjunction (&), and Implication/Quantification (>).
Incubation (Optional but Critical): A dedicated tool, the Incubator, auto-generates ground-level fact tables (e.g., small addition/multiplication tables) directly from axioms using a contradiction-based proof strategy. These facts serve as a bootstrap for the main pipeline.
Conjecture Generation: The system combinatorially generates a massive set of potential theorems. To manage complexity, it employs:
- Regularization: Enforcing a standard implication chain structure ( $A \implies (B \implies C)$ ).
- Normalization: Canonical renaming of ports to eliminate syntactic duplicates.
- Filtering: Type-based and topological filters to remove circular dependencies and invalid structures.
Counterexample (CE) Filtering: A pre-proof triage stage where the Incubator's ground facts are used to test conjectures. If a conjecture contradicts known small-scale arithmetic facts, it is immediately discarded.
Compilation & Distribution: Validated conjectures are compiled into a distributed grid of Logic Blocks (LBs).
- Disintegration: Complex logical expressions are broken down into constituent parts.
- Mapping: Premises are mapped to chains of LBs; conclusions become target outputs.
- Tree Structuring: Shared prefixes among conjectures are mapped to shared LBs to prevent redundant computation.
Iterative Proof Execution:
- Mechanism: The core engine treats logical inference as a hash-table lookup problem. An implication $(A \land B) \implies C$ is stored where the premise is the key and the conclusion is the value.
- Process: LBs operate asynchronously. They combine local expressions with incoming "mail" (expressions from other blocks) to generate hash requests. If a premise is found, the conclusion is emitted.
- Parallelism: Thousands of LBs operate independently, communicating only between cycles, allowing for massive parallelization on commodity hardware or specialized ASICs.
Post-Proof Processing:
- Compressor: Eliminates redundancy by identifying a minimal set of "essential theorems" from which all others can be derived.
- Verifier: An independent, external tool (written in pure Python, zero coupling to the prover) validates every inference step against 25 specific validators.
Output: Results are exported as navigable, hyperlinked HTML files, creating a fully auditable proof graph where every step traces back to the original axioms.

Key Architectural Concept: The Deterministic Logical Transformer

The system utilizes a unified mechanism for both disintegration (breaking down definitions into facts) and integration (assembling facts into new theorems). This allows the same hash-based engine to perform algebraic manipulation and logical transformation deterministically.

3. Key Contributions

Definition-Initiated Bulk Theorem Generation: Unlike traditional systems that wait for a user to state a conjecture, GL starts with definitions and systematically explores the deductive closure, generating and proving families of theorems autonomously.
Deterministic Verifiability by Construction: Every inference is a symbolic hash-table lookup. The output is a complete, auditable proof graph. An external Verifier confirmed zero failures across 34,320 checks in the case study.
Massively Parallel Architecture: The design is hardware-aware, utilizing a distributed grid of independent Logic Blocks that communicate asynchronously, making it scalable to ASICs and cloud clusters.
Unification of Proof and Calculation: The system demonstrates that "proof is calculation." It can compute concrete numerical results (e.g., $2+3=5$ ) with full provenance, effectively acting as a Full-Provenance Computer Algebra System (CAS).
Self-Bootstrapping Pipeline: The Incubator generates the ground facts required to filter conjectures, closing the loop from axioms to verified theorems without external data.

4. Experimental Results

The system was evaluated on Elementary Number Theory (ENT) using commodity hardware (Dell G16, 32 cores, 32GB RAM).

Case Study 1: Peano Arithmetic:
- Generated 465 conjectures; 62 survived CE filtering.
- Proved foundational laws (commutativity, associativity, distributivity).
- Reduced 83 proven theorems to 27 essential theorems.
- Runtime: ~9 seconds for the prover; ~26 seconds total for the batch.
Case Study 2: Gauss's Summation Formula:
- Leveraged the 27 Peano theorems as ground knowledge.
- Autonomously derived the division-free variant: $n(n+1) = 2 \sum_{i=1}^n i$ .
- Runtime: ~13.6 seconds for the prover; ~28 seconds total.
Incubator Performance:
- Generated 1,203 ground-level facts (successor, addition, multiplication tables) in ~517 seconds.
- Demonstrated the ability to compute concrete values (e.g., $s(0)=1$ , $2 \times 3 = 6$ ) with full proof traces.
Verification: The external Verifier performed 34,320 checks with 0 failures.
Total Wall-Clock Time: Approximately 10 minutes for the full pipeline (including Incubator) on a single machine.

5. Significance and Future Impact

Democratization of Reasoning: GL aims to democratize high-level mathematical reasoning, similar to how calculators democratized arithmetic.
Trustworthy AI: It offers a deterministic reasoning core that can be integrated into probabilistic AI workflows, providing a source of verifiable truth to mitigate LLM hallucinations.
Scalability: The architecture is designed to scale from single machines to specialized ASIC clouds. Future work targets the Fundamental Theorem of Arithmetic (FTA) and Algebraic Number Theory.
New Paradigm: It represents a shift from "goal-directed proving" to "generative unfolding," where the system explores the logical consequences of definitions without needing a specific target theorem.

In conclusion, Generative Logic presents a novel, deterministic architecture that successfully autonomously derives and verifies non-trivial mathematical theorems from first principles, offering a path toward fully auditable, self-bootstrapping mathematical discovery systems.