Reasoning Engines Partial

Home · Architecture · Reasoning · Theory · Syntax · APIs · Wiki · Specs · Research Two reasoning approaches: Symbolic-first and Holographic-first

Overview

AGISystem2 implements two distinct reasoning engines that can be used interchangeably based on the reasoningPriority configuration. Both engines share the same API interface but differ in their approach to proof search and query resolution.

Key Design Principle: Both engines are drop-in replacements for each other. The choice between them is a configuration option, not a code change. This allows seamless switching and A/B testing.
Status: Advanced reasoning (abduction/induction) is partial (DS06). Linked pages describe research workflows.

Quick Links

Symbolic Engine

Symbolic-first proof search with HDC as an acceleration layer.

Holographic Engine

Similarity-guided candidate discovery with symbolic validation.

Query Engine

How variable binding, unification, and retrieval are implemented.

Proof Engine

Backward chaining, rule application, traces, and validation steps.

Abduction

Hypothesis generation under constraints (explain observations).

Induction

Generalize patterns into rules (learn from examples).

The Two Reasoning Paradigms

Symbolic Reasoning Engine

Mode: symbolicPriority (default)

Classical logical reasoning with HDC for efficient storage and retrieval. Uses explicit rules, transitive chains, and backward chaining with symbolic validation at each step.

  • Deterministic proof search
  • Proof traces (audit logging/export is external)
  • HDC as acceleration layer

Holographic Reasoning Engine

Mode: holographicPriority

HDC-first approach using vector similarity to find candidate proofs, then validates with symbolic logic. Leverages the full power of hyperdimensional computing for pattern matching.

  • Similarity-guided search
  • Faster candidate discovery
  • Symbolic validation layer

Architecture Comparison

Reasoning Pipeline Comparison
Symbolic Priority Holographic Priority 1. Direct KB Match (Symbolic) 2. Transitive Chain Reasoning 3. Backward Chaining (Rules) 4. Weak Match / Disjoint Proof HDC used for storage/retrieval only Master Equation: KB search acceleration 1. HDC Similarity Search 2. Find Candidate Proofs (HDC) 3. Symbolic Validation 4. Fall back to Symbolic (if needed) HDC drives proof search Master Equation: Answer = KB BIND Query⁻¹ Symbolic operations HDC operations

Key Components

Component Symbolic Engine Holographic Engine
Proof Engine ProofEngine
prove.mjs		 HolographicProofEngine
holographic/prove-hdc-first.mjs
Query Engine QueryEngine
query.mjs		 HolographicQueryEngine
holographic/query-hdc-first.mjs
CSP Solver CSPSolver
csp/solver.mjs		 HolographicCSPSolver
holographic/csp-hdc-heuristic.mjs
Abduction AbductionEngine - Shared ("best explanation" reasoning)
Induction InductionEngine - Shared (pattern generalization)

Selecting a Reasoning Mode

Via Environment Variable

# Use holographic priority
export REASONING_PRIORITY=holographicPriority

# Use symbolic priority (default)
export REASONING_PRIORITY=symbolicPriority

Via Session Configuration

// Symbolic priority (default)
const session = new Session({ reasoningPriority: 'symbolicPriority' });

// Holographic priority
const session = new Session({ reasoningPriority: 'holographicPriority' });

Factory Functions

import { createQueryEngine, createProofEngine, createCSPSolver } from './reasoning/index.mjs';

// Automatically selects engine based on session/env config
const queryEngine = createQueryEngine(session);
const proofEngine = createProofEngine(session);
const cspSolver = createCSPSolver(session);

When to Use Which Engine?

Scenario Recommended Rationale
High-stakes decisions requiring traceable proofs Symbolic Every step is explicitly logged and traceable
Large KB with many similar facts Holographic HDC similarity excels at finding patterns in noise
Strict logical correctness required Symbolic No false positives from similarity matching
Exploratory queries ("find similar to X") Holographic Native support for similarity-based search
Complex CSP with many constraints Holographic HDC heuristics can prune search space faster
Formal verification / compliance Symbolic Deterministic, reproducible proofs

Reasoning Engine Documentation

Detailed documentation for each reasoning capability:

Proof Engine

Backward chaining proof search with confidence tracking. Determines if KB ⊢ G (KB entails G) using goal-directed reasoning.

  • Direct KB matching
  • Rule application with unification
  • Transitive chain reasoning

Query Engine

Finding answers to open queries with variables. Returns sets of bindings that satisfy the goal pattern.

  • Variable binding propagation
  • Compound query handling
  • HDC-accelerated candidate search

Abduction Engine

Inference to the best explanation. Given observations, finds hypotheses that would explain them.

  • Hypothesis generation
  • Bayesian scoring
  • Consistency checking

Induction Engine

Learning general rules from specific examples. Discovers patterns and generalizes from KB facts.

  • Pattern generalization
  • MDL-based rule selection
  • Exception handling

Shared Components

Both engines share the following components that are used regardless of reasoning mode:

TransitiveReasoner

Handles transitive relations like isA, locatedIn, partOf.

// Tweety isA Bird, Bird isA Animal
// → Tweety isA Animal (transitive chain)

PropertyInheritanceReasoner

Inherits properties along class hierarchies.

// Bird can Fly, Tweety isA Bird
// → Tweety can Fly (property inheritance)

UnificationEngine

Finds substitutions that make two expressions identical.

unify(isA ?x Human, isA Socrates Human)
// → { ?x → Socrates }

CSPSolver

Constraint satisfaction for compound queries with multiple variables.

// And (isA ?x Animal) (eats ?x ?y)
// → All (animal, food) pairs

Performance Characteristics

Metric Symbolic Holographic
Proof search strategy Depth-first with backtracking Similarity-guided + validation
KB size scaling Linear scan possible Sub-linear with HDC bundle
Memory usage Lower (no bundles) Higher (KB bundle + candidate sets)
Precision 100% (symbolic match) High with validation layer
Recall for fuzzy queries Limited to exact matches Better for similarity queries
Note: Both engines ultimately rely on symbolic validation for correctness. The holographic engine uses HDC to find candidates faster, not to replace symbolic proof.

Theoretical Foundations

The Four Modes of Reasoning

AGISystem2 implements all four classical modes of logical inference, each serving a distinct cognitive purpose:

Mode Direction Question Example
Deduction (Proof) Rule + Case → Conclusion "What must be true?" Humans are mortal + Socrates is human → Socrates is mortal
Query Pattern → Instances "What satisfies this?" Find all X where isA(X, Mortal)
Abduction Rule + Conclusion → Case "What explains this?" Ground is wet + Rain wets ground → It rained (maybe)
Induction Cases → Rule "What pattern fits these?" Swan1 is white, Swan2 is white → Swans are white

Confidence Propagation

All reasoning modes track confidence scores that decay through inference chains:

Next: Symbolic Reasoning Engine →

Next: Holographic Reasoning Engine →

← Back to Documentation Home