Skip to content

DATR

A declarative node–path–value equation language for compact lexical knowledge bases with default inheritance, override, path extension, and query evaluation.

Version
v2 · 2026-09-06 · History
Domain-specific #
1626
Origin domain
computer science
Subdomain
computational linguistics
Aliases
DATR language

Core Idea

DATR is a declarative language for lexical knowledge representation. A theory consists chiefly of equations associating a named node and an attribute path with a value or with another node–path description. More specific path equations override inherited general ones, enabling compact nonmonotonic default inheritance.[1]

Evaluation answers a query such as a node at a path by selecting the most specific applicable definition, extending paths where required, and recursively resolving local or global inheritance. The language deliberately remains small while representing morphology, phonology, syntax, lexical rules, ambiguity, and reusable paradigms.[2]

The recognition invariant is named node + attribute path + equation-defined value + longest-applicable default + path-sensitive inheritance and recursive evaluation.

Structural Signature

  • A finite textual theory of node declarations.
  • Attribute paths represented as sequences.
  • Node–path–value equations.
  • Atomic and list-like values under the language syntax.
  • Local inheritance relative to the query node.
  • Global inheritance naming another node.
  • Path extension from a shorter defining path.
  • Specific equations overriding inherited defaults.
  • Evaluative rather than destructive update semantics.
  • Queries returning values or failing under defined conditions.
  • Compact encoding of lexical regularity and exceptions.

What It Is Not

DATR is not a general-purpose programming language, database query language, grammar formalism, or unification engine. It can encode structures used by those systems, but its identity lies in node/path equations and default inheritance.

It is not an acronym that can be freely expanded; the name functions as the language's proper name. Nor is every inheritance network a DATR theory: syntax and evaluation rules are essential.

Scope of Application

DATR has represented inflectional paradigms, lexical entries, phonological alternations, morphological rules, typed feature-like structures, finite-state transductions, and nonlinguistic inheritance networks. Its compactness is strongest where many entries share defaults but retain structured exceptions.[1] It has also been integrated as a lexical component for feature-based grammar environments.[3]

Cycles, undefined paths, implementation-specific quoting, and external interfaces require explicit handling. Use today is specialist and historical, but the abstraction remains a clear design point in knowledge representation.

Clarity

Provide the DATR version or reference specification, exact equations, query node/path, and expected value. Distinguish local from global inheritance and literal from evaluable descriptions. Explain which shorter path licenses extension and why a more specific definition overrides a default.

Manages Complexity

DATR factors repeated lexical information into inheritance nodes while preserving exceptions close to the affected path. A small evaluator computes the effective entry rather than materializing all inherited facts. Path extension provides structured reuse finer than whole-record inheritance.

Abstract Reasoning

  1. Identify the node and query path.
  2. Find the longest prefix with an applicable equation.
  3. Retain any remaining path suffix for extension.
  4. Resolve local or global inheritance under its context rule.
  5. Recursively evaluate the resulting descriptor.
  6. Apply the suffix and assemble the value.
  7. Detect undefined or cyclic evaluation.
  8. Verify that overrides affect only their intended paths.
  9. Compare implementations against the reference semantics.

Knowledge Transfer

The portable pattern is inherit defaults at path granularity, then compute the effective value by the most specific applicable equation. It transfers to prototype systems, configuration inheritance, cascading styles, lexical paradigms, and sparse exception tables. The proposed immediate parent is Inheritance.

Examples

Inflectional default. A general noun node supplies plural formation; a lexical node inherits it but overrides the plural path for an irregular form.

Path extension. A definition at a shorter path handles a longer query by passing the unmatched suffix into the inherited description.

Non-example. Copying a parent record and editing fields produces similar output but lacks DATR's declarative equation and evaluation semantics.

Structural Tensions

  • Compact defaults versus transparent effective values.
  • Local inheritance versus global reference.
  • General path equation versus specific exception.
  • Declarative purity versus implementation extensions.
  • Recursive expressiveness versus cycles.
  • Lexical specialization versus domain-general reuse.

Structural–Framed Character

Inheritance, override, path specificity, recursion, and evaluation are structural. Lexical nodes, feature paths, paradigms, and DATR syntax provide the constitutive computational-linguistic frame.

Structural Core vs. Domain Accent

The portable core is most-specific default resolution over structured paths. The domain accent is DATR's spartan equation language and its use for lexical knowledge.

Inheritance is the proposed immediate parent. Default, Hierarchy, Path, Override, Representation, Compression, and Recursion are related. Formal accounts show how the language encodes DAGs, lexical rules, and finite-state behavior without adopting a full grammar formalism.[4]

The prospective queue contains one strict edge to prime:inheritance. No live DAG mutation is authorized.

Relationships to Other Abstractions

Local relationship map for DATRParents appear above the current abstraction, mutual partners to the right, and children below. Node labels state whether each abstraction is prime or domain-specific; colors identify relation types.DATRDOMAINPrime abstraction: Inheritance — is a kind ofInheritancePRIME

Current abstraction DATR Domain-specific

Parents (1) — more general patterns this builds on

  • DATR is a kind of Inheritance Prime

    Inheritance is the proposed immediate parent.

Hierarchy path (1) — routes to 1 parentless root

Neighborhood in Abstraction Space

DATR sits in a sparse region of the domain-specific corpus (81st percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Automata, Model Checking & Formal Semantics (10 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-09-08

Not to Be Confused With

  • A generic semantic network.
  • Object-oriented class inheritance.
  • Feature-structure unification.
  • Datalog.
  • A full grammar formalism.
  • A database schema.
  • Any language whose name merely resembles DATR.

References

[1] Roger Evans and Gerald Gazdar, “DATR: A Language for Lexical Knowledge Representation,” Computational Linguistics 22, no. 2 (1996): 167–216. registry ↩a ↩b

[2] Gerald Gazdar, “The Sussex Prolog DATR System,” in Antonio Zampolli et al., eds., Linguistica Computazionale IX–X (1994), treatments of DATR theory and implementation. withdrawn registry ↩

[3] James Kilbury, Petra Naerger, and Ingrid Renz, “DATR as a Lexical Component for PATR,” Computational Linguistics 17, no. 2 (1991): 137–158. registry ↩

[4] Bill Keller, “DATR Theories and DATR Models,” in Proceedings of the Seventh Conference of the European Chapter of the ACL (1995), 71–78, doi:10.3115/976973.976984. registry ↩