Five Types of Systems
Twenty five years ago, I literally could not tell you the difference between "syntax" and "semantics". Over that time, I have made it my business to understand this information so that I could figure out how to build what I was trying to build. This is what I have figured out:
As I understand it, there are fundamentally five types or categories of systems:
- Symbolic: marks (symbols, tokens, strings, formulas)
- Structural: patterns, organization (schemas, tables, models)
- Semantic: concepts (concepts, relationships, meaning)
- Pragmatic: grounding (meaning in use, grounded truth, grounded in real world truth)
- Cognitive: understanding (interpretation, judgement, understanding)
Each of these five types or categories or layers of systems have certain specific capabilities. Each higher number adds additional capabilities beyond what the lower number has.
These five types or categories or layers come from multiple disciplines including philosophy, linguistics, cognitive science, artificial intelligence, and systems engineering.
Symbolic Type Systems
What symbolic type systems fundamentally do is manipulate raw "marks" commonly referred to as tokens, strings, labels, formulas, or marks per a set of rules specified by the system. These systems store symbols, move symbols, compare symbols, transform symbols.
A symbolic system works entirely with marks and rules for arranging marks. They do this without understanding what the marks refer to.
These systems do not understand the symbols (e.g. marks) which are being referred to (storing, moving, comparing, transforming).
Examples of symbolic systems are raw text files, electronic spreadsheet cells with no structure, lists, flat JSON files, flat XML files, CSV files with no headers, byte sequences, character arrays, a list of strings in memory, a flat log file with no schema, LLM token streams.
An LLM is a symbolic statistical system with emergent semantic behavior. An LLM is a symbolic statistical system that produces language with the appearance of semantics but does not contain real semantic meaning, grounding, or understanding.
LLMs are streams of language. Because language encodes meaning, and LLMs learn patterns in language, they can simulate semantic reasoning. But they are not actually reasoning semantically and they do not understand the meaning of the language they are streaming and learning the patterns of.
Symbolic type systems give you form, not meaning. Symbolic type systems are simply formal systems that manipulate marks (e.g. symbols) without understanding what those marks mean.
Core: raw form; raw marks
Definition: Systems that manipulate raw marks (tokens, strings, characters) with no inherent structure and no meaning.
Structural Type Systems
What a structural type system effectively does is organize symbols into patterns using specified structural information. A structural system organizes symbols into structural patterns using hierarchies, tables, schemas, constraints, models, graphs, workflows; but does not assign meaning. A structural system is a necessary bridge between symbolic marks and semantic concepts.
Note that the structure has no meaning. The structure only provides organizational form.
The structural information is defined using rows/columns of a table, keys and relationships, hierarchies, schemas, documents, graphs.
Examples of structural systems include SQL tables and schemas, JSON and JSON Schema, XML and XML schemas, CSV with headers, spreadsheets, XBRL instance documents (facts, contexts, units) without taxonomies, labeled property graph structures without ontologies, RDF without OWL or SHACL.
Excel spreadsheets and relational databases are structural systems. They provide what amounts to a document model, not a knowledge model.
Excel and other electronic spreadsheets are documents with a model, but the model is only for document structure, not meaning structure. A spreadsheet has: cells, rows, columns, ranges, tables, formulas, references, worksheets, workbooks. These define how the spreadsheet document is organized, not what the spreadsheet content means. Spreadsheets are a symbolic container, not a semantic system.
This is why spreadsheets cannot: validate accounting concepts, enforce business rules, infer relationships, guarantee interoperability. A spreadsheet is a document model, not a knowledge model. Excel and spreadsheets are structured symbolic documents; their model governs document layout, not conceptual meaning.
Prolog, at the raw syntax level, is a symbolic system with structural capabilities which has built in reasoning.
Prolog does not provide what the Semantic Web stack provides (RDF, OWL, SHACL, SKOS). But Prolog does contain all of the logical building blocks from which all of those capabilities can be constructed because Prolog is a general Horn‑clause logic engine.
Labeled property graphs (LPGs) are structural systems, not semantic systems. A Labeled Property Graph is a structural system: it organizes symbols into a graph but does not provide semantic meaning, ontological commitments, or logical inference. LPGs are structural systems; they can carry labels that look semantic, but the graph engine does not interpret those labels; meaning must come from an external semantic system.
Structural systems give you better capabilities to organize marks (e.g. symbols), but they still do not understand the meaning of the marks they are storing, moving, comparing, transforming.
Core: organized form; organized marks
Definition: Systems that organize symbols into schemas, models, hierarchies, tables, or constraints; but still without meaning.
Semantic Type Systems
What a semantic type system does is map structured symbols to concepts, relationships, and meaning.
A semantic system adds a mapping layer that connects symbols to concepts. These systems interprets symbols as referring to something; encodes meaning, not just form; supports inference, truth conditions, and shared understanding.
A symbolic system manipulates signs; a semantic system understands what the signs mean. A structural system is basically a better organized symbolic system.
Example of semantic type systems include RDF plus OWL and SHACL, XBRL instances with taxonomies and formulas, simple knowledge organization system (SKOS),
RDF + OWL + SHACL together form a full semantic system. Each component contributes a different layer of meaning, and when combined, they produce machine‑interpretable semantics, not just symbols.
Prolog is a symbolic system that implements a semantic layer. It is not a semantic system by itself, but it is much closer to semantics than most symbolic systems because its symbols participate in logical meaning through unification and inference. Prolog is a symbolic system with a built‑in semantic interpreter; but unlike OWL, SHACL, and SKOS which is provided with RDF; Prolog does not provide them "ready made", you have to build them using the capabilities that Prolog does provide. Prolog is semantics‑aware, but not semantically grounded.
This is why researchers classify Prolog as: symbolic AI, not semantic AI; logic programming, not knowledge representation; syntax with semantics, not ontology.
XBRL becomes a semantic system only when its is properly paired with a taxonomy and formula/dimensional rules are used; otherwise it is purely symbolic. XBRL is one of the few financial systems that already has the semantic layer baked in, but most people only use the symbolic layer.
The W3C Semantic Web stack is a complete semantic system, but it does not provide the numeric‑assertion verification capabilities that XBRL Formula provides. Prolog (or any Horn‑clause engine) is actually better suited for that part.
OWL and SHACL are designed for: logical consistency, semantic constraints, shape validation. They are not designed for: arithmetic, numeric aggregation, financial calculations, computational constraints. SHACL can do some numeric checks, but it is not a numeric rule engine. OWL is even less suited for verifying numeric values; description logic is not arithmetic logic.
The Semantic Web describes what is, not what happens. It is a static meaning system, not a dynamic state system. Semantic systems are timeless and stateless. The W3C Semantic Web stack is timeless. It does not have a native notion of state, change, events, or time‑indexed truth. And this is not an accident; it is a deliberate design choice rooted in formal logic.
Core: explicit meaning; meaningful structures
Definition: Systems that map structured symbols to concepts, relationships, and meaning.
Pragmatic Type Systems
What a pragmatic type system does is connect semantic meaning to real-world referents and real-world constraints. They are "grounded" in that set of real-world referents and constraints; but they cannot reason abstractly beyond that specific grounding.
These pragmatic type systems give you grounded truth.
A pragmatic system is a meaning‑in‑use system: it grounds semantic concepts in real-world operations, evidence, constraints, and truth.
A pragmatic system is the layer where meaning meets reality. It is the system type that connects semantic concepts to real‑world facts, evidence, constraints, and operations.
A pragmatic system knows what things are doing in the real world. Put differently: Semantics = meaning. Pragmatics = meaning in use. A pragmatic system is where concepts become operational, verifiable, and grounded.
A pragmatic system connects abstract concepts to actual states of the world.
Examples of pragmatic systems include: an open banking API that shows your actual checking account balance, an ERP system recording actual inventory movements and providing you with an accurate perpetual inventory. These systems do not just store symbols; they store truths.
Pragmatic systems enforce operational constraints. Pragmatic systems enforce rules that reflect real-world limitations. For example, you cannot withdraw more money than what exists in your checking account, you cannot create a balance sheet which does not balance, you cannot ship inventory that is not in stock, you cannot record revenue without a signed contract. These constraints are pragmatic, not semantic.
Pragmatic systems support checking whether something is true. Examples of this include: audit trails, reconciliations, logs, roll forward analysis, independent third party confirmations. This is why auditors live in the pragmatic layer.
Semantic systems are timeless. Pragmatic systems track state over time. Examples of this include: account balances at a point in time, inventory levels at any point in time, workflow progress between two points in time, machine output for a period. This is the “operational reality” layer.
A pragmatic system must represent state, change, events, and temporal truth. The W3C Semantic Web stack does not; it is timeless and describes meaning, not operations. Pragmatic systems must understand state and changes in state; semantic systems do not, because they are timeless.
A pragmatic system is multidimensional because our world is multidimensional. Neither Prolog nor the W3C Semantic Web stack have a multidimensional model provided which is suitable for representing information. The W3C provides The Data Cube Vocabulary; but that is for statistical data, not for information. XBRL provides a proper multidimensional model.
TerminusDB, because it is Prolog-based and engineered for exact arithmetic and temporal reasoning, is better suited than the pure W3C Semantic Web stack for representing and verifying numeric assertions of the kind XBRL Formula handles. TerminusDB is a pragmatic system: it understands state, change, versioning, and operational truth, which places it squarely in the real‑world grounding layer of your meaning stack. TerminusDB is one of the strongest general‑purpose pragmatic systems.
Core: explicit meaning in operational use; grounded truth
Definition: Systems that connect semantic meaning to real‑world state, evidence, operations, and constraints.
Cognitive Type Systems
What a cognitive type system does is give you real understanding, not simply meaning. Today, only humans are the only "implementation" of cognitive type systems. Computers are not cognitive type systems.
These systems integrate: symbols, structures, semantics, grounding, context, goals, intent, narratives, imagination
Examples of these systems are human reasoning, auditor judgement, management decision making, detective style abduction,
A cognitive system does five things no machine system can do:
- Interpret meaning in context. Machines only manipulate symbols or semantics; they do not interpret.
- Apply judgment. Humans decide: “Is this financial statement trustworthy?” “Does this workflow make sense?” “Is this evidence sufficient?” Judgment is not symbolic, semantic, or pragmatic; it is cognitive.
- Integrate goals, values, and intentions. Humans reason with: purpose, values, ethics, strategy, priorities, intent. No machine system has goals or values.
- Construct narratives. Humans create: explanations, stories, mental models, analogies, metaphors.
- Resolve ambiguity. Humans can interpret incomplete, contradictory, or messy information. Machines cannot.
Comments
Post a Comment