ICLR 2024 Research Implementation

Neuro-SymbolicRecursive AI

A hybrid AI framework combining neural pattern recognition with symbolic logical reasoning. Explainable decisions, adaptive learning, and recursive self-improvement through the Deduction-Abduction loop.

View on GitHub Read the paper

Framework: Rust
Reasoning Strategies: 5
Advanced Modules: 10+
VSA Dimensions: 10K
vs GNN Speed: 14.6x

Core Innovation

The Deduction-Abduction Loop

A recursive feedback loop where neural perception, symbolic parsing, and program execution continuously improve each other through error-driven learning.

Deduction (Fast)

System 1: Forward pass through the pipeline

→ Input x

→ Neural Perception → Symbols (s)

→ Parser → Parse Tree (e)

→ Executor → Value (v)

Abduction (Slow)

System 2: Error-driven structure search

⚠ Output incorrect?

→ MCTS/Beam Search

→ Try different symbols

→ Find correct GSS structure

Learning (Recursive)

Pseudo-supervision from abduction

↺ Train perception module

↺ Train parser

↺ Update program library

↺ Loop back to Phase 1

Example: Adapting to Anomalies (Manx Cat)

Before: System knows cats have tails, confused by tailless Manx cat

Abduction: Discovers "meow" is the key feature, not "tail"

After: Rules updated - TAIL no longer mandatory for CAT

Hybrid Intelligence

5 Reasoning Strategies

Choose the optimal balance between neural pattern matching and symbolic logic for your use case.

Hybrid Weighted

Combine both approaches with configurable weights (default: 0.6 neural + 0.4 symbolic).

Best For:

Balanced reasoning with explainability

Processing Flow

Query→Parallel Processing→Weighted Fusion→Confidence Score→Result

Research-Grade

Advanced Modules

10+ cutting-edge modules implementing the latest neuro-symbolic research from ICLR 2024.

Grounded Symbol System

Core representation unifying perception (input), syntax (symbol), and semantics (value) into coherent triplets.

Core Equation

GSS = {(x, s, v) | x ∈ Input, s ∈ Symbol, v ∈ Value}

Key Features

Symbol grounding
Semantic binding
Structure learning
Value computation

Architecture

Core Pipeline

Perception Module

Neural network mapping raw inputs to symbol probability distributions

p(s|x; θ_p) = Π_i softmax(φ(w_i, x_i; θ_p))

OpenAI EmbeddingsFastEmbedONNX RuntimePyTorch

Dependency Parser

Transition-based parsing converting symbols into dependency trees

p(e|s; θ_s) = Π_{t_i ∈ T} p(t_i|c_i; θ_s)

Arc-standardNeural-guidedDeterministic

Program Executor

Functional program interpreter with Peano axioms and recursion

eval(prog, env) → SemanticValue

Zero/Inc/DecMap/Fold/FilterY-combinatorLambda calculus

Why NSR?

Problems Solved

NSR addresses fundamental limitations of both pure neural and pure symbolic AI systems.

Black Box Problem

Solution: Proof trees and symbolic chains are fully explainable

Hallucination Problem

Solution: Symbolic layer rejects outputs violating rules

Binding Problem

Solution: GSS unifies (input, symbol, value) triplets

Adaptation Problem

Solution: Abduction discovers new rules for anomalies

Learning Efficiency

Solution: Learn from input-output pairs alone via pseudo-supervision

Compositionality

Solution: Program synthesis learns generalizable algorithms

Production Ready

REST API

Async-first Axum-based API with OpenAPI 3.0 documentation, multi-tenancy, and enterprise features.

Method	Endpoint	Description
POST	/api/v1/reason	Main reasoning endpoint
POST	/api/v1/forward-chain	Forward inference from facts
POST	/api/v1/backward-chain	Goal-driven proof search
POST	/api/v1/explain	Generate explanations
GET/POST	/api/v1/entities	Entity CRUD operations
POST	/api/v1/triples	Knowledge graph facts
GET/POST	/api/v1/rules	Rule engine management
POST	/api/v1/query	Knowledge base queries

Example Request

POST /api/v1/reason

{
  "query": "Is Socrates mortal?",
  "strategy": "HybridWeighted",
  "options": {
    "max_depth": 5,
    "confidence_threshold": 0.7
  }
}

Response

{
  "answer": "Yes, Socrates is mortal",
  "confidence": 0.95,
  "reasoning_type": "hybrid",
  "explanation": {
    "rule_chain": [
      "Socrates is_a Human",
      "Human is_a Mortal"
    ]
  },
  "metadata": {
    "query_time_ms": 42,
    "facts_used": 3,
    "rules_fired": 2
  }
}

Configuration

Flexible Setup

Server Configuration

[server]
host = "0.0.0.0"
port = 8080
rate_limit = 60  # requests/minute

[reasoning]
confidence_threshold = 0.7
max_reasoning_depth = 10
default_strategy = "HybridWeighted"

[neural]
backend = "openai"  # openai, fastembed, onnx, torch
embedding_dimension = 1536
model = "text-embedding-3-large"

NSR Machine Configuration

[nsr_machine]
embedding_dim = 256
hidden_size = 512
max_seq_len = 100
beam_width = 8
enable_synthesis = true

[mcts]
exploration_constant = 1.414
num_simulations = 100
max_depth = 50
use_dirichlet_noise = true

Enterprise Ready

Production Features

Multi-Tenancy

Org-scoped knowledge bases with isolated reasoning contexts

Rate Limiting

Per-route and per-key configurable limits with circuit breakers

Observability

Prometheus metrics, OpenTelemetry tracing, structured logging

Persistence

PostgreSQL via SeaORM, file-based snapshots, Redis caching

Build Explainable AI Systems

Combine the power of neural networks with the transparency of symbolic reasoning.

Get Started Request Demo