Quick Links

Available Guides

Guide: Geometric Reasoning

Why High Dimensions Work

In high-dimensional spaces (32,768+ dimensions), random vectors are almost orthogonal to each other. This "blessing of dimensionality" provides:

• Unlimited symbols: Any new concept gets a unique, non-interfering representation
• Content-addressable memory: Similar queries retrieve similar facts
• Noise tolerance: Small errors don't significantly affect similarity

The Binding Equation

All queries reduce to the fundamental equation:

Answer = UNBIND(KB, Partial_Query)

where Partial_Query = everything known in the query
      Answer = the unknown bindings

Note: in XOR-based strategies, UNBIND is implemented by BIND again.

Query Mechanics Step by Step

1. Parse: Identify holes (?variables) in the query
2. Build Partial: Bind operator with known arguments (skip holes)
3. Unbind: UNBIND the partial from the KB (XOR-based strategies use BIND again)
4. Extract: Remove position markers from candidates
5. Match: Find most similar atoms in vocabulary
6. Score: Calculate confidence from similarities

Confidence Interpretation

Score	Meaning	Recommended Action
> 0.80	Strong match	Trust the result
0.65 - 0.80	Good match	Probably correct, verify if critical
0.55 - 0.65	Weak match	Multiple interpretations possible
< 0.55	No match	Query failed, don't use result

Guide: Theory Layering

Theory Architecture

Theories are self-contained knowledge modules that can be stacked:

Best Practices

• Single Responsibility: Each theory should cover one domain
• Explicit Exports: Only export atoms that downstream theories need
• Geometry Consistency: Use the same geometry across related theories
• Documentation: Include comments explaining each atom's purpose

Guide: Explainability

Proof Trace Structure

Every proof generates a trace that can be inspected (replay/export requires external logging):

ProofTrace {
  goal: "isA Socrates Mortal",
  method: "rule",
  rule: "humans_are_mortal",
  premises: [
    {
      goal: "isA Socrates Human",
      method: "direct",
      kbMatch: true,
      confidence: 0.95
    }
  ],
  timestamp: "2024-01-15T10:30:00Z",
  duration_ms: 12
}

Generating Explanations

1. Decode: Extract structure from result vector
2. Template: Look up phrasing template for operator
3. Fill: Replace slots with decoded arguments
4. Refine: Optionally improve fluency with LLM

Guide: LLM Integration

Complementary Strengths

Capability	LLM	AGISystem2
Natural Language	Excellent	Template-based
Determinism	None	100%
Explainability	Limited	Full traces
Factual Accuracy	Hallucinations	Verified KB
Creativity	Excellent	Rule-based

Integration Pattern

// Use LLM for natural language input
const userQuery = "Who sold the car to Bob?";
const dsl = await llm.translate(userQuery);  // LLM generates DSL

// Use AGISystem2 for reasoning
const result = session.query(dsl);  // Deterministic, verifiable

// Use LLM for fluent output
const explanation = session.elaborate(result, { useLLM: true });
// LLM improves style only, cannot change facts

Trust Boundaries

Coming Soon

• Performance Tuning Guide
• Compliance Pattern Guide
• Testing and Validation Guide
• Deployment Guide