Glossary

help edit space_dashboard

Short definitions of the core technologies, languages, and concepts in the Hyperon ecosystem. Each term links to its full page; the definitions here are the same ones shown in the hover tooltips on links throughout the wiki.

Core Concepts

  • Hyperon — Hyperon (OpenCog Hyperon) is SingularityNET's open-source AGI framework, built around the MeTTa language and the AtomSpace metagraph atop decades of OpenCog research.
  • MeTTa — MeTTa (Meta-Type Talk) is Hyperon's native AGI programming language, unifying functional, logic, and probabilistic computation over a self-modifying knowledge metagraph (the AtomSpace).
  • AtomSpace — The AtomSpace is Hyperon's core knowledge store: a weighted, typed metagraph (hypergraph) of atoms over which MeTTa programs query, pattern-match, and rewrite.

MeTTa Runtimes & Implementations

  • Hyperon Experimental — The official trueagi-io reference implementation of MeTTa: a small-step Rust interpreter with a MeTTa-coded standard library, serving as the canonical Hyperon runtime.
  • PeTTa — A high-performance MeTTa runtime by Patrick Hammer that compiles to Prolog, using tabling and 'smart dispatch' to eliminate slow dynamic method lookups.
  • MeTTaTron —

    The F1R3FLY-native MeTTa compiler: it lowers MeTTa programs into MeTTa-IL, providing the route by which MeTTa code reaches the F1R3FLY / ASI Chain execution stack for concurrent, distributed, blockchain-native execution.

  • JeTTa — An experimental JVM/Kotlin MeTTa compiler that leverages the JVM for high-performance multithreading and custom Space implementations, aimed at enterprise deployment.
  • MeTTa-Morph — A translator that compiles a substantial subset of MeTTa to Chicken Scheme via hygienic macros, trading full coverage for native-compiled execution speed.
  • MeTTaLog (Legacy) — An earlier Prolog-hosted MeTTa implementation (metta-wam) by Douglas Miles, running MeTTa on a Warren Abstract Machine; now largely superseded but historically important.

Knowledge Representations

  • DAS (Distributed AtomSpace) — DAS (Distributed AtomSpace) is the scalable, distributed knowledge backend for Hyperon, serving atoms across processes and machines with pluggable storage engines.
  • MORK (MeTTa Optimized Reduction Kernel) — MORK (MeTTa Optimized Reduction Kernel) is a high-performance, single-process triemap substrate for storing and querying large MeTTa atom collections, built on the PathMap trie.
  • PathMap — PathMap is the foundational trie (prefix-tree) by Luke Peterson that underlies MORK, encoding atoms as paths for fast set-based query and storage.
  • Sensory — The opencog/sensory project defines atom types that connect an AtomSpace to external data sources and streams (files, networks, LLMs) as first-class sensory channels.

AI Algorithms

  • AI-DSL — AI-DSL is a domain-specific language for formally describing and automatically composing AI services, developed for the SingularityNET marketplace.
  • AIRIS — AIRIS (Autonomous Intelligent Reinforcement Inferred Symbolism) learns explicit causal rules from experience, building a state graph an agent uses for curiosity-driven planning.
  • Concept Blending — Concept Blending computationally combines existing concepts into novel ones, with Hyperon prototypes spanning information-theoretic, genetic, and category-theoretic (colimit) approaches.
  • ECAN — ECAN (Economic Attention Networks) allocates limited compute by assigning atoms economic attention values (STI/LTI), focusing reasoning on what currently matters most.
  • MetaMo — MetaMo is a category-theoretic motivational framework that models an agent's drives and homeostatic self-regulation as composable goal dynamics over its cognitive state.
  • MeTTa-Motto — MeTTa-Motto is a library for integrating large language models into MeTTa, letting programs call and compose LLM prompts as grounded operations.
  • MeTTa-NARS — MeTTa-NARS is a MeTTa implementation of NARS (NAL levels 1-5), reasoning from incomplete evidence under the Assumption of Insufficient Knowledge and Resources.
  • MOSES — MOSES (Meta-Optimizing Semantic Evolutionary Search) is a program-evolution algorithm that learns compact, human-readable programs via estimation-of-distribution genetic search.
  • NACE — NACE (Non-Axiomatic Causal Explorer) is a pure-Python causal-learning agent, derived from AIRIS and adjacent to NAL, that explores and models its environment's dynamics.
  • Pattern Mining — Pattern Mining discovers frequent and surprising sub-structures (frequent subgraphs) in an AtomSpace, surfacing regularities that downstream reasoning and learning can exploit.
  • PLN — PLN (Probabilistic Logic Networks) is Hyperon's framework for reasoning under uncertainty, combining probability with logic so inference can handle incomplete and contradictory knowledge.
  • Semantic Parsing — Semantic Parsing covers Hyperon's pipeline for turning natural language into structured MeTTa/PLN knowledge, increasingly via LLM-to-logic translation rather than classical grammars.

Cognitive Architecture & Research

  • PRIMUS — PRIMUS (formerly CogPrime) is Hyperon's integrative cognitive architecture, wiring reasoning, attention, learning, and motivation modules into a unified AGI design.

ASI:Chain Runtime Environment

  • F1R3FLY — The concurrent, sharded execution layer powering ASI:Chain, grounded in the Rholang process calculus and using reified RSpaces with MORK PathMaps for storage.
  • MeTTaCycle — The AGI execution engine for ASI:Chain that orchestrates evolving AtomSpaces, using ChromaDB for embeddings and PeTTa for reasoning.
  • MeTTa-IL — MeTTa-IL (MeTTa Intermediate Layer), by Greg Meredith, performs semantic analysis on MeTTa programs and reifies them into a precise operational form that routes execution across the ASI:Chain stack.

Concepts & Terminology

General technical vocabulary used throughout the Hyperon ecosystem — the underlying ideas the named technologies above are built from.

  • Abduction — Inferring the most plausible explanation for an observation (the grass is wet, and rain would explain it, so it probably rained) — "inference to the best explanation."
  • Abstract Syntax Tree — A tree representation of a program's structure, with nodes for operations and operands; MOSES analyzes the AST to decide where knobs can vary.
  • Admission Certificate — A machine-checkable safety voucher attached to a proposed self-modification (or new skill/option): a record that it met the required criteria — bounded behavioral drift, preserved invariants, no loss of goal stability — before being allowed into the running system.
  • AGI — Artificial General Intelligence — AI systems with human-level cognitive abilities that can understand, learn, and apply knowledge across diverse domains.
  • AIKR — Assumption of Insufficient Knowledge and Resources — the foundational NARS premise that an intelligent agent must always reason and act under finite time, memory, and evidence.
  • Appraisal — In MetaMo, the process that updates an agent's mood and modulators in response to context — "what's happening and how much does it matter?" — paired with, but distinct from, decision.
  • Arrow Type — A function's type signature, written with the arrow → (e.g. (-> Number Number)), declaring its argument and result types. MeTTa uses arrow types for optional, gradual type-checking of definitions and applications — not to trigger evaluation (that is driven by = rules).
  • Artificial Curiosity — An exploration strategy that steers an agent toward the states it is least certain about. In AIRIS and NACE, the lowest-confidence predicted state becomes the next goal to investigate.
  • Atom — The basic unit of knowledge in AtomSpace and MeTTa. There are four kinds: Symbol (a name), Variable ($-prefixed), Expression (a parenthesized list of atoms), and Grounded (an atom backed by host-language data or code).
  • AtomDB — DAS's pluggable storage interface: the same distributed AtomSpace can sit on different backends (Redis + MongoDB, in-memory, MorkDB, RocksDB) behind one AtomDB API.
  • Atomese — Atomese is the S-expression language of the classical OpenCog AtomSpace, in which knowledge and programs are written directly as typed atoms. MeTTa is its Hyperon-era successor.
  • Attention Allocation — ECAN's core job: distributing a limited budget of attention (STI/LTI values) across atoms so the system spends computation on what currently matters most.
  • Attention Broker — DAS's distributed attention service: it stores and updates the STI/LTI (importance) values for atoms across the cluster — the distributed-systems counterpart to ECAN's in-process AttentionBank.
  • Attentional Focus — The set of atoms whose STI is above a threshold — effectively the system's working memory, where reasoning is concentrated.
  • AttentionBank — The AttentionBank is ECAN's ledger of attention: it records each atom's Short- and Long-Term Importance (STI/LTI) and conserves the system's fixed attention budget as importance spreads.
  • Backward Chaining — Goal-driven reasoning: start from a statement you want to prove and search backward for the facts and rules that would support it.
  • Bisimulation — A formal "behaves identically" equivalence between two systems: each can match the other's observable steps. Used to prove that compiling MeTTa to Rholang preserves behavior.
  • BlockDAG — A Directed Acyclic Graph of blocks that allows parallel block production, breaking the sequential bottleneck of traditional blockchain architectures.
  • Causal Reasoning — The ability to understand and model cause-and-effect relationships, enabling prediction and intervention planning.
  • CID — A CID (Content Identifier) is a hash-derived address that names data by its content rather than its location, so identical content always has the same identifier. Core to content-addressed storage.
  • CMA-ES — Covariance Matrix Adaptation Evolution Strategy — a powerful black-box optimization algorithm that adapts a search distribution over candidate solutions; one of the optimizers in Concept Blending's information-theoretic branch.
  • Cognitive Architecture — A blueprint that integrates the parts of a mind — perception, memory, reasoning, learning, attention, and action — into one working system. PRIMUS is Hyperon's cognitive architecture.
  • Cognitive Schematic — PRIMUS's basic unit of procedural knowledge: in this Context, performing this Procedure achieves this Goal, with probability p — written Context ∧ Procedure → Goal ⟨p⟩.
  • Cognitive Synergy — The emergent phenomenon where multiple specialized cognitive processes interact and enhance each other's capabilities beyond what any single process could achieve alone.
  • Combinator — A higher-order function that builds new functions purely by combining its arguments, with no variables of its own; AI-DSL's MeTTa track composes AI services using combinator algebra (combinatory logic).
  • Content Addressing — Identifying data by what it contains rather than by a location or ID. In AtomSpace, structurally identical atoms are automatically the same atom, giving free deduplication and authority-free naming.
  • CRDT — A CRDT (Conflict-free Replicated Data Type) is a data structure whose replicas can be updated independently and merged automatically without conflicts, enabling consistent distributed state.
  • Currying — Expressing a multi-argument function as a chain of single-argument functions. In MeTTa currying is explicit — it is not applied automatically (unlike Haskell).
  • Decentralized — A system architecture where control is distributed across multiple nodes rather than concentrated in a single authority, enabling censorship-resistant and fault-tolerant computation.
  • Deduction — Inferring a conclusion that must follow from general premises (every Human is Mortal and Socrates is Human, so Socrates is Mortal); in PLN the most confidence-preserving inference direction.
  • Deme — A subpopulation of candidate programs all exploring small variations of one program template; MOSES runs many demes in parallel and retires unproductive ones.
  • Dependent Types — A type system where types can depend on values, enabling more precise specifications and compile-time verification of program properties.
  • Effort Object — ASI Chain's resource-metering unit (like Ethereum "gas"): every computation and storage step costs effort objects, so decentralized MeTTa execution is economically bounded against abuse.
  • Embedding — A representation of data (text, an image, a concept) as a vector of numbers, positioned so that similar items land near each other; LLMs and "neural spaces" use embeddings for semantic similarity and search.
  • Evolutionary Search — An optimization approach inspired by biological evolution, using mutation, crossover, and selection to evolve solutions over generations.
  • Fitness — The score that ranks candidates in evolutionary search; in MOSES it balances how well a program performs against how simple it is (an Occam's-razor preference).
  • Forgetting — Discarding the least-important atoms (lowest LTI) when memory fills, so the knowledge store stays within capacity.
  • Forward Chaining — Data-driven reasoning: repeatedly apply inference rules to the facts you already know to derive new conclusions, working outward.
  • Frequent Subgraph Mining — Searching a large graph for substructures (subgraphs) that recur often; in Hyperon, the core of pattern mining over the AtomSpace metagraph.
  • GEO-EVO — GEO-EVO (Geodesic Evolutionary Optimization) is a proposed, not-yet-implemented reframing of MOSES evolution as optimal transport along geodesics in program space, integrated with TransWeave.
  • Geodesic — The least-effort path that advances from the current state toward a goal at roughly even cost per step (a forward/backward "Schrödinger-bridge" control rule). One notion of effort shared across inference, planning, and self-modification.
  • Gradual Typing — A type discipline that mixes checked and unchecked code: an atom may carry a declared type or remain a permissive wildcard (%Undefined%), so type checking is optional and incremental.
  • Grammar Induction — Learning a language's grammar automatically from data rather than hand-writing rules; in the Hyperon lineage via unsupervised statistical (mutual-information) learning and, more recently, LLM guidance.
  • Graph Neural Network — A neural network that operates directly on graph-structured data, learning from nodes and their connections; the neural paradigm of pattern mining (rejuve-bio's matcher-miner) uses GNNs.
  • Grounded Atom — An atom whose behavior is implemented in the host language (Rust or Python) rather than defined by MeTTa equations — for example arithmetic, file I/O, or a call into a neural network.
  • hash-consing — Hash-consing stores each distinct value only once and returns a shared reference for equal values, letting a system such as the AtomSpace deduplicate atoms and compare them cheaply by identity.
  • Hebbian Learning — A learning rule based on the principle 'neurons that fire together, wire together' — strengthening connections between co-activated elements.
  • Homeostasis — Keeping internal variables within a stable range by damping disturbances, so an agent's motivations settle rather than run away.
  • Homoiconicity — A language property in which code and data share a single representation, so a program can inspect and rewrite itself as ordinary data. In MeTTa, every program is itself a metagraph of atoms.
  • Hypergraph — A generalization of a graph where edges can connect any number of nodes, enabling representation of complex multi-way relationships.
  • hyperpose — hyperpose is PeTTa's superposition operator for nondeterministic branching: it evaluates alternative results in parallel, and is the mechanism under which ECAN's attention agents run on PeTTa.
  • I-Surprisingness — An information-theoretic "interestingness" score for a mined pattern: how far its observed frequency deviates from what you'd expect if its parts were independent — high surprise means a genuinely informative pattern, not just a common one.
  • Importance Spreading — How attention flows along links: an important atom passes some of its STI to its neighbors, so relevance radiates through related concepts — a form of spreading activation.
  • Induction — Generalizing from specific observations to a broader rule (these swans are white, so swans tend to be white); evidence-accumulating and less certain than deduction.
  • Knob — A tunable parameter attached to a position in a MOSES program template; turning knobs yields valid program variants, converting program search into structured numeric optimization.
  • Kolmogorov Complexity — The length of the shortest program that can reproduce a given object — a formal measure of its inherent complexity; WILLIAM's compression bounds are stated in these terms.
  • Link Grammar — A dependency-style grammar formalism (Sleator & Temperley) that parses a sentence by connecting words with typed "links"; the foundation of the legacy OpenCog NLP pipeline.
  • Merkle Trie — A tree data structure that combines a trie (prefix tree) with cryptographic hashing for efficient and verifiable storage of key-value pairs.
  • Metagraph — A generalized graph where edges (links) can connect not just nodes but also other edges, enabling representation of higher-order logic and nested relationships.
  • MindAgent — A MindAgent is an OpenCog scheduling unit — a process that runs repeatedly over the AtomSpace (for example an attention or inference agent), invoked in turn by the CogServer's cognitive cycle.
  • Minimum Description Length — A principle for choosing models: the best explanation is the one that lets you describe the data in the fewest bits (model plus data-given-model). WILLIAM treats pattern-finding as MDL compression.
  • MM2 — MORK's rewrite-rule execution model: MeTTa expressions compiled into (exec location pattern template) triples over the PathMap trie and run by a priority-ordered scheduler — fast at bulk forward chaining.
  • Modulator — A variable that tunes how an agent behaves rather than what it wants. Following Psi/MicroPsi, MetaMo's OpenPsi carries six: valence, arousal, approach, resolution, threshold, and securing (caution).
  • NAL — NAL (Non-Axiomatic Logic) is the term logic at the core of NARS, reasoning from incomplete, uncertain evidence using (frequency, confidence) truth values rather than from fixed axioms.
  • NARS — Non-Axiomatic Reasoning System — Pei Wang's theory of intelligence as reasoning under the Assumption of Insufficient Knowledge and Resources, using Non-Axiomatic Logic (NAL) with frequency/confidence truth values.
  • Neural Networks — Computing systems inspired by biological neural networks. In Hyperon, they are integrated with symbolic reasoning to form neural-symbolic hybrid architectures.
  • Non-Deterministic — A computation model where multiple possible execution paths exist simultaneously, enabling parallel search across solution spaces.
  • Object-Capability — A security model where the right to act is an unforgeable token you hold — you can only touch resources you've been handed a capability for. ASI Chain's MeTTa-IL and self-modification pipeline use it.
  • ONA — OpenNARS for Applications (Patrick Hammer) — a practical, real-time implementation of NARS for embedded/application use. Part of the patham9 NAL portfolio alongside NACE and MeTTa-NARS.
  • OpenPsi — The earlier OpenCog motivational framework, based on Dörner's Psi theory, that MetaMo descends from; it models behavior as the interplay of drives and modulators.
  • Overgoal — In MetaMo's MAGUS-derived goal hierarchy, a single slowly-varying top-level goal that defines an agent's enduring purpose — a global utility function that top-down gates all lower drives, amplifying aligned subgoals and suppressing conflicting ones, and is itself revisable by reflection.
  • Paraconsistent Logic — A logic that tolerates contradictions without collapsing (in classical logic, one contradiction lets you prove anything); used in Concept Blending so blended properties can resonate or cancel rather than break the system.
  • Pattern Matching — Querying knowledge by shape: a template containing variables is matched against stored atoms, returning every set of bindings that makes it fit.
  • posting list — A posting list is an index structure listing all the places a given key occurs; query engines intersect posting lists to find matches quickly. Used in MORK's trie-based indexing.
  • Probabilistic Inference — Reasoning under uncertainty where beliefs are represented with graded confidence values rather than binary true/false.
  • Process Calculus — A mathematical framework for modeling concurrent and distributed systems as collections of interacting processes.
  • Quantale — An ordered algebraic structure (a lattice with a join ⊕ and a product ⊗) that supplies the combination rules shared by Hyperon's weakness/simplicity measures and PLN truth values.
  • Rent and Wages — The economic metaphor driving ECAN: atoms pay "rent" (lose STI over time) and earn "wages" (gain STI when they prove useful), keeping the attention economy bounded and self-regulating.
  • REPL — Read-Eval-Print Loop — an interactive prompt where you type an expression, it's evaluated, and the result is printed; Hyperon Experimental ships a MeTTa REPL.
  • Revision — PLN's operation for merging two truth values about the same statement into a single combined belief, accumulating confidence as independent evidence piles up.
  • Rho-Calculus — A mathematical foundation for concurrent computation where programs are treated as asynchronous processes that execute in parallel.
  • RSpace — Rholang's reactive tuple-space store: data and continuations are matched and consumed like messages, so storage doubles as the concurrency and communication mechanism in F1R3FLY.
  • S-expression — The parenthesized (operator arg1 arg2 …) list notation MeTTa inherits from Lisp. Programs and data are both built from nested S-expressions (plus atomic symbols and variables) — the basis of MeTTa's homoiconicity.
  • ShardZipper — ShardZipper is a MORK/RAPTL mechanism for Merkle-based management of distributed, sharded atom storage, using confidence-weighted scoring to decide how to partition data across shards.
  • Space API — Hyperon's abstract interface to a knowledge store — match (query), add, remove, and replace — that many backends can implement (in-memory, MORK, DAS, and experimental neural or blockchain stores), so the same MeTTa program can run over different storage.
  • State Graph — AIRIS's internal world model: a graph of states it has predicted by applying its learned causal rules, which it searches to plan a path from the current state toward a goal.
  • STI / LTI — STI and LTI (Short- and Long-Term Importance) are the two attention values ECAN assigns each atom: STI tracks momentary relevance, LTI lasting usefulness — together they form its attention economy.
  • Superpose — A MeTTa operation that turns a set of values into multiple nondeterministic results at once (a "superposition"); its partner collapse gathers them back into a single set.
  • Symbolic Reasoning — A form of AI that manipulates human-readable symbols and rules to perform logical inference, as opposed to statistical pattern matching.
  • Term Rewriting — A model of computation that repeatedly replaces an expression matching a rule's left-hand side with its right-hand side. MeTTa evaluation is nondeterministic term rewriting over the AtomSpace.
  • Tokenizer — The parser component that turns raw text into atoms via (regex, constructor) pairs — e.g. matching a number and wrapping it as a Grounded atom.
  • Transfer Learning — Reusing knowledge learned on one task to do better or faster on a related task; TransWeave is Hyperon's framework for doing this across different cognitive paradigms with formal guarantees on what carries over.
  • Trie — A tree that stores sequences by sharing their common prefixes along paths (a "prefix tree"); the foundation of MORK's PathMap and of Merkle tries. Lookups walk the path step by step.
  • Truth Value — A two-number measure of belief attached to an atom. PLN uses strength and confidence; NARS uses frequency and confidence. The two conventions are related but not interchangeable.
  • Unification — The matching operation that finds variable bindings making two expressions equal. It is the core engine behind MeTTa queries and equation (rule) application.
  • URE — URE (Unified Rule Engine) is OpenCog/Hyperon's generic forward- and backward-chaining inference engine, applying declarative rewrite rules over the AtomSpace. PLN is one rule set that runs on it.
  • Value — Small, mutable, unindexed data attached to an Atom through a key-value store — truth values, probabilities, attention weights, sensor streams. The fast-changing counterpart to Atoms, which are the immutable, indexed graph structure.
  • WAM — Warren Abstract Machine — the standard virtual machine architecture for executing Prolog and logic programming languages efficiently.
  • WASM — WebAssembly — a binary instruction format for a stack-based virtual machine, enabling near-native performance in web browsers and other environments.
  • Weakness — A generalized-Occam measure of simplicity: a "weaker" hypothesis rules out fewer possibilities, so it applies more broadly and generalizes better. Hyperon's system-wide simplicity prior, shared by WILLIAM, PLN, and self-modification.
  • World Model — An agent's internal model of how its environment works and how its actions change it, used to predict outcomes and plan ahead without acting in the real world.
  • Zipper Abstract Machine — MORK's execution engine: a "zipper" cursor navigates and rewrites the triemap in place, applying MeTTa operations without copying the whole structure.