Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

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

Nikolai Sergeev

TL;DR

A hardware-software co-design path toward massively parallel realizations is outlined and future integration with large language models (LLMs) for auto-formalization and conjecture seeding is described.

Abstract

We present Generative Logic (GL), a deterministic architecture that starts from user-supplied axiomatic definitions, written in a minimalist Mathematical Programming Language (MPL), and systematically explores a configurable region of their deductive neighborhood. A defining feature of the architecture is its unified hash-based inference engine, which executes both algebraic manipulations and deterministic logical transformations. Definitions are compiled into a distributed grid of simple Logic Blocks (LBs) that exchange messages; whenever the premises of an inference rule unify, a new fact is emitted with full provenance to its sources, yielding replayable, auditable proof graphs. Experimental validation is performed on Elementary Number Theory (ENT) utilizing a batched execution strategy. Starting from foundational axioms and definitions, the system first develops first-order Peano arithmetic, which is subsequently applied to autonomously derive and prove Gauss's summation formula as a main result. To manage combinatorial explosion, GL algorithmically enumerates conjectures and applies normalization, type constraints, and counterexample (CE) filtering. On commodity hardware, an end-to-end run completes in under 7 minutes. Generated proofs export as navigable HTML so that every inference step can be inspected independently. We outline a hardware-software co-design path toward massively parallel realizations and describe future integration with large language models (LLMs) for auto-formalization and conjecture seeding. The Python, C++, and MPL code to reproduce these experiments, along with the full proof graphs in HTML as well as machine-readable text format, are available in the project's GitHub repository at github.com/Generative-Logic/GL commit 1771330 and are permanently archived at doi:10.5281/zenodo.17206386.

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

TL;DR

A hardware-software co-design path toward massively parallel realizations is outlined and future integration with large language models (LLMs) for auto-formalization and conjecture seeding is described.

Abstract

We present Generative Logic (GL), a deterministic architecture that starts from user-supplied axiomatic definitions, written in a minimalist Mathematical Programming Language (MPL), and systematically explores a configurable region of their deductive neighborhood. A defining feature of the architecture is its unified hash-based inference engine, which executes both algebraic manipulations and deterministic logical transformations. Definitions are compiled into a distributed grid of simple Logic Blocks (LBs) that exchange messages; whenever the premises of an inference rule unify, a new fact is emitted with full provenance to its sources, yielding replayable, auditable proof graphs. Experimental validation is performed on Elementary Number Theory (ENT) utilizing a batched execution strategy. Starting from foundational axioms and definitions, the system first develops first-order Peano arithmetic, which is subsequently applied to autonomously derive and prove Gauss's summation formula as a main result. To manage combinatorial explosion, GL algorithmically enumerates conjectures and applies normalization, type constraints, and counterexample (CE) filtering. On commodity hardware, an end-to-end run completes in under 7 minutes. Generated proofs export as navigable HTML so that every inference step can be inspected independently. We outline a hardware-software co-design path toward massively parallel realizations and describe future integration with large language models (LLMs) for auto-formalization and conjecture seeding. The Python, C++, and MPL code to reproduce these experiments, along with the full proof graphs in HTML as well as machine-readable text format, are available in the project's GitHub repository at github.com/Generative-Logic/GL commit 1771330 and are permanently archived at doi:10.5281/zenodo.17206386.

Paper Structure

This paper contains 46 sections, 4 equations, 6 figures, 1 table.

Table of Contents

  1. Introduction
  2. The GL Workflow
  3. System Architecture
  4. Architecture Overview
  5. MPL
  6. LEs and Ports
  7. Core Operators
  8. Type System and Recursion Constraint
  9. Unique Naming of Reusable LEs
  10. Creation of Conjectures
  11. CE Filter
  12. Goal.
  13. Organization.
  14. Inputs.
  15. Operation.
  16. ...and 31 more sections

Figures (6)

  • Figure 1: An example for connection of two LBs.
  • Figure 2: Mapping a conjecture premise onto a sequence of LBs.
  • Figure 3: Shared tree structure for multiple conjectures.
  • Figure 4: Compiled structure of the fold definition. Existence and and-nodes expand further; implication nodes are terminal stop points; predicate leaves are ground facts. The same map is traversed in both directions by the Deterministic Logical Transformer.
  • Figure 5: A screenshot of the main index.html page, showing the list of proven theorems with both their formal MPL and simplified algebraic representations.
  • ...and 1 more figures