arxiv: 2604.10908 · v1 · submitted 2026-04-13 · 💻 cs.AI

Recognition: unknown

Reasoning as Data: Representation-Computation Unity and Its Implementation in a Domain-Algebraic Inference Engine

Chao Li , Yuru Wang

Authors on Pith no claims yet

Pith reviewed 2026-05-10 16:23 UTC · model grok-4.3

classification 💻 cs.AI

keywords knowledge representationinference enginedomain algebrapredicate arityrepresentation-computation unitymulti-domain reasoningsymbolic inferencearc consistency

0 comments

The pith

Embedding domain as a structural field in predicate arity lets any respecting system perform domain-scoped inference without separate rules or computation layers.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper argues that knowledge systems need not separate storage from computation. By encoding facts as four-tuples that place domain context inside predicate arity, the structure itself generates domain-scoped closure, typed inheritance, and cycle-based falsification. Four theorems establish this representation-computation unity formally, and a 2400-line engine demonstrates it by resolving shared-fiber handling and intersective convergence. Case studies on ICD-11 classifications and CBT clinical sessions show the approach handles multiple inheritance and temporal indexing while achieving arc-consistency queries whose cost follows domain-lattice sparsity.

Core claim

In the CDC four-tuple structure, domain becomes a field embedded in predicate arity rather than residing in queries or external rules. Any system that respects arity therefore carries out domain-scoped inference automatically. Three mechanisms emerge directly: domain-scoped closure, typed inheritance, and write-time falsification via per-fiber cycle detection. The paper proves representation-computation unity through four theorems and implements it in a working symbolic engine that treats data as self-computing once domain is structural.

What carries the argument

The CDC four-tuple with domain embedded as a structural arity field, which produces representation-computation unity (RCU) and generates inference mechanisms without external rule layers.

If this is right

Domain-scoped closure, typed inheritance, and write-time falsification arise automatically from the four-tuple structure.
A concrete engine implements RCU while solving rule-data separation, shared-fiber handling, and intersective convergence.
Domain-constrained inference differs from simply passing a domain argument to Prolog.
Multi-constraint queries realize CSP arc-consistency whose complexity is governed by domain-lattice sparsity.
Fibers in the structure resolve multiple inheritance in large taxonomies and support temporal reasoning when domain indices are ordered.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

The same arity-based unification could reduce the need for separate reasoning modules when merging knowledge bases from distinct scientific or legal domains.
Performance tied to domain-lattice sparsity suggests the method scales best for sparse, context-separated data rather than dense monolithic graphs.
If the four-tuple approach generalizes, existing triple stores could be extended by arity without rewriting their inference engines.
The distinction from Prolog-with-domain-argument implies that structural embedding may avoid certain variable-binding overheads in large-scale queries.

Load-bearing premise

Placing domain context inside predicate arity is enough to guarantee correct, complete, and non-conflicting inferences across arbitrary multi-domain collections without further mechanisms.

What would settle it

A multi-domain knowledge base expressed only in four-tuples that produces an incorrect inference or unresolved conflict when processed by an arity-respecting engine but is handled correctly by a conventional rule-plus-data system.

Figures

Figures reproduced from arXiv: 2604.10908 by Chao Li, Yuru Wang.

**Figure 1.** Figure 1: Operational structure of the CDC inference engine. This is not a metaphor. It is a structural consequence of RCU. 6. CDC vs. Storage-Computation Separation: Systematic Comparison Dimension SQL RDF LLM RAG Neuro-Sym CDC Context location Application code Query clause Prompt Retrieval filter Bridge code Predicate arity Rule location Separate code SPARQL query Implicit in weights LLM forward pass Symbolic KB M… view at source ↗

read the original abstract

Every existing knowledge system separates storage from computation. We show this separation is unnecessary and eliminate it. In a standard triple is_a(Apple, Company), domain context lives in the query or the programmer's mind. In a CDC four-tuple is_a(Apple, Company, @Business), domain becomes a structural field embedded in predicate arity. Any system respecting arity automatically performs domain-scoped inference without external rules. We call this representation-computation unity (RCU). From the four-tuple structure, three inference mechanisms emerge: domain-scoped closure, typed inheritance, and write-time falsification via cycle detection per domain fiber. We establish RCU formally via four theorems. RCU is implementable. We present a working symbolic engine (2400 lines Python+Prolog) resolving four engineering issues: rule-data separation, shared-fiber handling, read-only meta-layer design, and intersective convergence. A central result: CDC domain-constrained inference is distinct from Prolog with a domain argument. Two case studies validate the engine. ICD-11 classification (1247 entities, 3 axes) shows fibers resolve multiple inheritance. CBT clinical reasoning shows generalization to temporal reasoning with session turn as ordered domain index. Multi-constraint queries realize CSP arc-consistency with complexity O(m (N/K)^2), confirming the domain lattice's sparsity governs performance. When domain is structural, data computes itself.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

Embedding domain as an arity field is presented as enough for automatic scoped inference, but the custom engine and lack of proof details leave the 'without external rules' claim under-supported.

read the letter

The paper's central move is to embed domain context directly into predicate arity via a CDC four-tuple, so that is_a(Apple, Company, @Business) carries its scope structurally. From this they derive three mechanisms—domain-scoped closure, typed inheritance, and write-time falsification by cycle detection per fiber—and claim any arity-respecting system will perform the inference without added rules. They call the result representation-computation unity and support it with four theorems plus a 2400-line Python-plus-Prolog engine. Two case studies follow: ICD-11 classification on 1247 entities across three axes, where fibers manage multiple inheritance, and a CBT clinical-reasoning example that treats session turns as ordered domain indices. They also give a complexity bound for multi-constraint queries that depends on domain-lattice sparsity. Those concrete pieces are the parts worth looking at first. The implementation is real and the distinction from plain Prolog-plus-domain-argument is stated explicitly. The soft spot is the gap between the abstract claim and what is shown. The mechanisms are presented as emergent, yet the engine implements them explicitly, and standard arity-respecting systems do not produce closure or per-fiber cycle detection without further clauses. No proof sketches appear in the supplied material, so it is difficult to tell whether the theorems establish a general property or simply restate the four-tuple definition. That leaves the circularity concern live. The work is aimed at people who build or maintain symbolic knowledge systems and want to explore alternatives to separate rule and data layers. A reader already working on domain-aware reasoning or multi-inheritance handling could extract usable ideas from the engine and the case studies. It deserves a serious referee because the artifact and applications give referees something concrete to examine, even if the theoretical framing needs tightening on the emergence question.

Referee Report

3 major / 2 minor

Summary. The manuscript claims that embedding domain as a structural field in a CDC four-tuple (e.g., is_a(Apple, Company, @Business)) unifies representation and computation such that any arity-respecting system automatically performs domain-scoped inference without external rules. This representation-computation unity (RCU) is said to generate three mechanisms—domain-scoped closure, typed inheritance, and write-time falsification via cycle detection per domain fiber—which are formally established by four theorems. The paper presents a 2400-line Python+Prolog implementation resolving rule-data separation and related issues, distinguishes CDC inference from standard Prolog with an added domain argument, and validates the approach via ICD-11 classification (1247 entities) and CBT clinical reasoning case studies, including CSP arc-consistency performance.

Significance. If the central claim holds, RCU would eliminate the storage-computation separation in knowledge systems, enabling simpler inference for multi-domain scenarios such as ontologies and temporal reasoning. The working implementation and concrete case studies (ICD-11 fibers resolving multiple inheritance, CBT generalization to ordered domains) provide practical grounding and reproducible code, which are strengths; however, the absence of proof details limits assessment of whether the result is a general property of arity or an artifact of the custom engine.

major comments (3)

[Abstract] Abstract: The assertion that 'any system respecting arity automatically performs domain-scoped inference without external rules' is load-bearing for RCU but is not supported by the provided text. The paper explicitly distinguishes CDC from 'Prolog with a domain argument,' indicating that domain-scoped closure, typed inheritance, and per-fiber cycle detection require explicit implementation rather than emerging solely from arity respect and unification.
[Abstract] Theorems (referenced in Abstract): Four theorems are stated to establish RCU formally, yet no proof sketches, derivations, or verification steps are supplied. Without these, it is impossible to determine whether the theorems derive the three mechanisms independently or merely restate properties already encoded in the four-tuple definition and the 2400-line engine.
[Implementation and Case Studies] Implementation and Case Studies sections: The engine is presented as realizing RCU, but the central claim requires showing that the mechanisms (closure, inheritance, falsification) are not 'external rules' added by the custom design. The ICD-11 and CBT examples demonstrate functionality yet provide no error analysis, completeness arguments, or comparison showing that standard arity-respecting systems (without the engine's additions) would produce the same inferences.

minor comments (2)

[Abstract] Abstract: The phrase 'data computes itself' is evocative but should be tied more explicitly to the four-tuple structure and the three mechanisms for clarity.
[Introduction] Notation: The CDC four-tuple format and '@Business' domain marker should be defined with an example in the introduction before use in the abstract.

Simulated Author's Rebuttal

3 responses · 0 unresolved

We thank the referee for the constructive and detailed review. The comments identify important areas where the manuscript's central claims about representation-computation unity require stronger textual support and empirical grounding. We address each major comment below and indicate the revisions that will be incorporated.

read point-by-point responses

Referee: [Abstract] Abstract: The assertion that 'any system respecting arity automatically performs domain-scoped inference without external rules' is load-bearing for RCU but is not supported by the provided text. The paper explicitly distinguishes CDC from 'Prolog with a domain argument,' indicating that domain-scoped closure, typed inheritance, and per-fiber cycle detection require explicit implementation rather than emerging solely from arity respect and unification.

Authors: The RCU claim rests on the observation that placing the domain as a fixed structural position within predicate arity causes standard unification to treat distinct domains as distinct predicate signatures, thereby scoping all operations without rule-level modifications. The explicit contrast with 'Prolog plus a domain argument' is intended to underscore that an extra argument treated as a variable would require manual scoping logic in rules and queries, whereas the arity embedding makes scoping a direct consequence of predicate identity. We acknowledge that the current abstract and surrounding text do not supply a self-contained derivation of this emergence. We will revise the abstract and add a short illustrative subsection in the introduction that walks through a minimal arity-unification example, showing how any engine obeying standard predicate arity automatically inherits domain scoping. revision: partial
Referee: [Abstract] Theorems (referenced in Abstract): Four theorems are stated to establish RCU formally, yet no proof sketches, derivations, or verification steps are supplied. Without these, it is impossible to determine whether the theorems derive the three mechanisms independently or merely restate properties already encoded in the four-tuple definition and the 2400-line engine.

Authors: The four theorems are formulated to derive domain-scoped closure, typed inheritance, and per-fiber cycle detection as logical consequences of the four-tuple structure and arity respect, using only the definitions of domain fibers and standard unification. We agree that the absence of any proof outline prevents readers from verifying this independence. We will add concise proof sketches for each theorem, placed in a dedicated subsection following the formal definitions, that proceed step by step from the CDC predicate axioms without reference to engine-specific code. revision: yes
Referee: [Implementation and Case Studies] Implementation and Case Studies sections: The engine is presented as realizing RCU, but the central claim requires showing that the mechanisms (closure, inheritance, falsification) are not 'external rules' added by the custom design. The ICD-11 and CBT examples demonstrate functionality yet provide no error analysis, completeness arguments, or comparison showing that standard arity-respecting systems (without the engine's additions) would produce the same inferences.

Authors: The engine implements RCU by delegating all inference to Prolog's native unification over four-tuple predicates; the listed mechanisms arise because the domain position participates in predicate identity rather than being passed as a separate variable. The 2400 lines address only engineering concerns (shared fibers, meta-layer isolation, etc.) and do not insert inference rules beyond standard logic programming. We accept that the case-study sections lack the requested comparison and analysis. We will insert a new comparison subsection that contrasts CDC inference against an otherwise identical Prolog program using an explicit domain argument, demonstrating the additional clauses required in the latter. We will also augment the ICD-11 and CBT sections with error counts for fiber resolutions and a brief completeness argument tied to the domain lattice. revision: partial

Circularity Check

1 steps flagged

RCU claim reduces to four-tuple definition by construction; mechanisms not shown to emerge automatically in arbitrary arity-respecting systems

specific steps

self definitional [Abstract]
"Any system respecting arity automatically performs domain-scoped inference without external rules. We call this representation-computation unity (RCU). From the four-tuple structure, three inference mechanisms emerge: domain-scoped closure, typed inheritance, and write-time falsification via cycle detection per domain fiber. We establish RCU formally via four theorems."

The four-tuple (e.g., is_a(Apple, Company, @Business)) is defined by embedding domain as a structural arity field. RCU and the three mechanisms are then claimed to emerge automatically from this structure and to be formally established by theorems. This makes the result equivalent to the input by construction: scoping and the listed mechanisms follow from how the representation is defined and implemented, not from a general property of arity respect that would hold in unmodified standard systems without added code or rules.

full rationale

The paper's derivation begins by redefining knowledge representation as four-tuples with domain embedded in predicate arity, then asserts that this choice causes domain-scoped inference mechanisms to emerge automatically in any arity-respecting system without external rules, labeling the result RCU and establishing it via four theorems. This chain is partially circular because the specific mechanisms (domain-scoped closure, typed inheritance, per-fiber cycle detection) are not independently derived from arity respect alone; they require explicit implementation as evidenced by the 2400-line engine and the explicit distinction from standard Prolog with a domain argument. The 'any system' and 'without external rules' assertions therefore rest on the representational choice and custom engine design rather than a general property, making the central result equivalent to the input definition by construction. The implementation and case studies provide some independent content, preventing a higher score.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 2 invented entities

The central claim rests on the unproven premise that arity respect alone suffices for all required inference behaviors; the paper introduces new structural entities without external falsifiable evidence.

axioms (1)

domain assumption Any system that respects predicate arity will automatically perform domain-scoped inference without external rules
Invoked as the foundation of RCU in the abstract; no independent justification supplied.

invented entities (2)

CDC four-tuple no independent evidence
purpose: To embed domain context as a structural field inside each predicate
New representation introduced to achieve representation-computation unity; no prior existence claimed.
domain fiber no independent evidence
purpose: To enable per-domain cycle detection and scoped closure
Emerges from the four-tuple structure; introduced without external validation.

pith-pipeline@v0.9.0 · 5550 in / 1342 out tokens · 46857 ms · 2026-05-10T16:23:29.168844+00:00 · methodology

discussion (0)

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

DALM: A Domain-Algebraic Language Model via Three-Phase Structured Generation
cs.CL 2026-04 unverdicted novelty 5.0

DALM is a proposed language model architecture that enforces algebraic constraints via a three-phase process over domain lattices to prevent cross-domain knowledge contamination during generation.

Reference graph

Works this paper leans on

4 extracted references · 1 canonical work pages · cited by 1 Pith paper · 1 internal anchor

[1]

G., & Çelik, C

Chute, C. G., & Çelik, C. (2022). Overview of ICD-11 architecture and structure.BMC Medical Informatics and Decision Making, 21(Suppl 6),

2022
[2]

Codd, E. F. (1970). A relational model of data for large shared data banks.Communications of the ACM, 13(6), 377–387. Fillmore, C. J. (1982). Frame semantics. InLinguistics in the Morning Calm(pp. 111–137). Hanshin Publishing. Guha, R. V., & McCarthy, J. (2003). Varieties of contexts. In P. Brézillon (Ed.),Modeling and Using Context (CONTEXT 2003)(LNCS 26...

1970
[3]

Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., Küttler, H., Lewis, M., Yih, W.-t., Rocktäschel, T., Riedel, S., & Kiela, D. (2020). Retrieval-augmented generation for knowledge-intensive NLP tasks.Advances in Neural Information Processing Systems, 33, 9459–9474. Li, C., Wang, Y., & Zhao, C. (2026a). Domain-constrained knowledge r...

work page internal anchor Pith review Pith/arXiv arXiv 2020
[4]

J., Eilbeck, K., Ireland, A., Mungall, C

Smith, B., Ashburner, M., Rosse, C., Bard, J., Bug, W., Ceusters, W., Goldberg, L. J., Eilbeck, K., Ireland, A., Mungall, C. J., Leontis, N., Rocca-Serra, P., Ruttenberg, A., Sansone, S.-A., Scheuermann, R. H., Shah, N., Whetzel, P. L., & Lewis, S. (2007). The OBO Foundry: coordinated evolution of ontologies to support biomedical data integration.Nature B...

2007