Total Reification: Explicit Modeling

• Total reification is the process of converting every implicit element, substructure, or idea into an explicit, first-class object within formal systems.
• It enables reflective architectures where models, metadata, and code are fully traceable, queryable, and optimizable across diverse domains like software engineering and graph databases.
• While it clarifies system representations and supports end-to-end modeling, total reification also raises challenges such as circularity, system closure, and potential misalignment in clinical AI.

Taken together, the cited literature suggests that total reification is an endpoint at which entities that are ordinarily implicit, partial, auxiliary, or second-order are made explicit, first-class, and operable within a formal, computational, or socio-technical system. The term is not used uniformly across fields. In some works it is reconstructed from model chains or total naming schemes; in others it names a pathological closure of representations over themselves; in still others it becomes a foundational commitment to completed totalities. Across these uses, the recurring issue is whether a system can, or should, treat its own descriptions, statements, codes, metadata, or totalities as concrete objects subject to further manipulation (Sirotin, 2018, Selivanov, 2013, Stummer, 2 Apr 2026, Shalom, 2011).

1. Cross-domain structure of the concept

A common structure recurs across the literature. Reification first means turning an abstract idea, relation, statement, or substructure into an explicit object. “Total” reification then denotes a stronger regime in which this conversion is generalized: every relevant name in a coding space denotes something, every triple can be embedded and annotated, every relevant substructure can be turned into a node, every stage of software development is treated as a model in a chain, or every predicate is assigned a complete totality (Selivanov, 2013, Hartig et al., 2014, Sadoughi et al., 2024, Sirotin, 2018, Shalom, 2011).

A second recurring feature is reflexivity. Once reified objects become first-class, they can themselves be queried, transformed, versioned, or folded back into later computation. In software engineering this yields traceable chains from mental models to code. In graph data it yields metadata over statements and subgraphs. In clinical AI it yields a feedback loop in which documentation artefacts and AI outputs become future “ground truth.” In set theory it yields self-inclusive or non-well-founded complete totalities. This suggests that total reification is inseparable from the problem of how a system handles self-reference (Stummer, 2 Apr 2026, Shalom, 2011).

Domain	Reified object	“Total” tendency
Software engineering	Mental and material models	End-to-end model chain
RDF and property graphs	Triples, labels, properties, substructures	Universal first-class metadata
Relational and clinical AI systems	Intent, provenance, ontology, AI influence	Explicit, monitored pipeline state
Computable analysis and set theory	Names, kernels, totalities	No partiality or excluded cases

2. Software engineering: model chains, reflective architectures, and description-driven systems

In Sirotin’s RPSE paradigm, software engineering is “the reification (materialization of ideas) via the transformation of mental models into code executed on computers” (Sirotin, 2018). The core formal split is

$U = M + I$

where $M$ denotes phenomena that can be objectively recorded or measured and $I$ denotes the ideal world of ideas. Within this scheme, software development is represented as a chain

$I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$

whose last most specific model is, as a rule, program code. The paper’s central thesis is that all basic software-engineering processes are concrete variants of constructing such chains, that the essence of software engineering is the construction of such chains, and that optimization of development cost and quality reduces to optimization of their construction (Sirotin, 2018).

Within this framework, total reification is an end-to-end ideal rather than a separate axiom. It is the condition under which early stakeholder ideas, intermediate requirements and design artefacts, implementation-proximate DSLs or configurations, code, and later maintenance updates all become elements of one traceable and optimizable chain. The paper also identifies open problems that delimit this ideal: constructive definition of mental models, criteria for abstraction versus concreteness, criteria for selecting intermediate models, methods for comparing heterogeneous models, and methods for automated and automatic transformation of models (Sirotin, 2018).

A related architectural precursor appears in “Pattern Reification as the Basis for Description-Driven Systems” [0402024]. Its abstract proposes a pattern-based, object-oriented, description-driven system architecture as an extension to the standard UML four-layer meta-model. The architecture embodies four main elements: adoption of a multi-layered meta-modeling architecture and reflective meta-level architecture; identification of four data-modeling relationships that can be made explicit and modified dynamically; identification of five design patterns essential for reusable data management; and encoding of the structural properties of those patterns by means of one fundamental pattern, the Graph pattern. The CRISTAL project is presented as a practical example of using description-driven data objects to handle system evolution [0402024]. This suggests a form of total reification at the meta-model level: relationships, patterns, and descriptions are not merely design-time assumptions but explicit structures subject to runtime modification.

3. Data and graph systems: from statement-level metadata to reified substructures

In RDF, the most direct attempt at total reification appears in the alternative reification mechanism later known as RDF-star/SPARQL-star (Hartig et al., 2014). Standard RDF reification represents metadata about a triple by introducing a resource and asserting four reification triples using rdf:Statement, rdf:subject, rdf:predicate, and rdf:object. The alternative proposal instead extends the data model so that triples themselves may occur in subject or object position of other triples. Formally, if $T$ is the recursively defined set of triple$*$s, then ordinary RDF triples are included in $T$, and whenever $t,t' \in T$, constructions such as $\langle t,p,o\rangle$, $\langle s,p,t\rangle$, and $M$0 also belong to $M$1 (Hartig et al., 2014).

The significance for total reification is precise. Every triple is embeddable, every metadata statement can directly target the triple it annotates, and SPARQL$M$2 allows variables to bind to triple$M$3s rather than only to IRIs, blank nodes, and literals. The proposal remains backwards compatible by assigning each embedded triple a fresh blank node and unfolding an RDF$M$4 graph into ordinary RDF plus standard reification triples through the functions $M$5, $M$6, and $M$7. Under the semantics given in the paper, any embedded triple in metadata position is also entailed in the unfolded RDF graph (Hartig et al., 2014). In this sense, total reification means universal statement-level referentiality.

“Meta-Property Graphs: Extending Property Graphs with Metadata Awareness and Reification” generalizes the same idea for ISO property graphs (Sadoughi et al., 2024). Its central device is a function

$M$8

where a node $M$9 reifies a substructure consisting of nodes, edges, properties, and labels. A sub-structure of a meta-property graph can therefore be reified as a node, thereby making it a first-class citizen. The model also treats labels and properties as queryable objects, and MetaGPML introduces the :: operator so that a pattern like $I$0 matches a node $I$1 with label $I$2 whose induced subgraph $I$3 matches $I$4 (Sadoughi et al., 2024).

The resulting regime is close to total reification within graph data modeling. Properties can have meta-properties, because $I$5 may contain a singleton property. Labels, property keys, and reified substructures can all be queried in one pattern language. The model intentionally avoids a stratified meta-level hierarchy; the only hard well-foundedness condition is that a node cannot occur in its own transitive reification closure. This yields a highly uniform treatment of graph objects, while leaving questions of constraints, optimization, and physical representation to future work (Sadoughi et al., 2024).

4. Relational and clinical AI systems: explicit intent versus self-reinforcing artefacts

In Pneuma-Seeker, total reification is approached as a mechanism for aligning AI agents with human work over relational data (Balaka et al., 11 Mar 2026). The paper defines a latent information need $I$6 and an active information need $I$7, then proposes “relational reification” as the conversion of $I$8 into an explicit target model $I$9, where $I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$0 is a set of derived views and $I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$1 is an executable transformation over $I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$2. The system does not answer prompts directly. It iteratively refines this schema, discovers and prepares relevant sources, materializes the necessary relations, and records its transformation history in a provenance DAG (Balaka et al., 11 Mar 2026).

Here total reification is an aspirational state in which as much of the user’s information need as possible is externalized into inspectable artefacts: schemas, view definitions, executable programs, sampled data, and provenance. The architecture couples conductor-style planning with macro- and micro-level context management, including Context Extraction through DB-backed probing rather than prompt-time guessing. The paper reports higher answer quality than academic and industrial baselines across multiple domains, and its ablations indicate that both Context Extraction and the explicit target model $I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$3 are materially important for correctness (Balaka et al., 11 Mar 2026).

A contrasting use appears in “Ontology-Aware Design Patterns for Clinical AI Systems” (Stummer, 2 Apr 2026). There, total reification is not a design goal but the pathological endpoint of a feedback-dominated pipeline. Clinical data are treated as “documentary enactment” shaped by clinical necessity, administrative requirements, and institutional incentives. Reification occurs when AI and analytics treat administratively convenient codes as direct proxies for disease, and total reification is implied when the entire pipeline—clinical practice, documentation, terminologies, AI, and governance—closes over its own representations such that there is no independent signal left to check against (Stummer, 2 Apr 2026).

The paper’s seven ontology-aware patterns are explicitly anti-reification mechanisms. Ontological Checkpoint assigns each record a coding fidelity score in $I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$4; Dormancy-Aware Pipeline preserves dormant low-frequency but clinically important features; Drift Sentinel tracks semantic fingerprints and classifies drift as Type A epidemiological, Type B administrative, or Type C terminological; Dual-Ontology Layer maintains separate administrative and clinical layers; Reification Circuit Breaker tags AI-influenced data and pauses automatic retraining if the AI influence ratio exceeds a threshold, with a suggested starting point of $I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$5; Terminology Version Gate forces explicit versioning and reconciliation; and Regulatory Compliance Adapter encapsulates jurisdiction-specific compliance logic behind a standard interface (Stummer, 2 Apr 2026). In this literature, total reification names the point at which representation and reality are no longer operationally separable.

5. Computable analysis: total representations as fully populated naming schemes

Selivanov’s “Total Representations” makes totality itself the defining technical move (Selivanov, 2013). In ordinary computable analysis, a representation of a set $I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$6 is usually a partial surjection

$I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$7

from Baire space $I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$8. A total representation instead has full domain:

$I_1, I_2, \dots, I_n, M_1, M_2, \dots, M_m$9

Every name denotes something; there are no undefined names or “junk” regions of the coding space (Selivanov, 2013).

The paper argues that total representations bring representations closer to classical numberings, simplify technical details, and support new invariants of topological spaces. Reducibility between total representations is defined by $T$0 iff $T$1 for some continuous $T$2. This yields a Wadge-style preorder on $T$3. The kernel

$T$4

then becomes an equivalence relation on all of $T$5, not merely on a partial domain (Selivanov, 2013).

Within the paper’s own interpretive frame, this amounts to a strong form of total reification: the whole coding universe participates semantically. The paper proves that for any countably based space $T$6 and any non-selfdual level $T$7 of the Borel, difference, or projective hierarchies, $T$8 has a principal $T$9-TR; that such principal TRs are acceptable; and that they are precomplete. It also records the equivalence, for countably based $*$0, between being quasi-Polish, having an open continuous total representation, and having an admissible partial representation (Selivanov, 2013). The abstract structure of a space is thus made concrete through total names, universal sets, kernels, and degree-theoretic invariants.

6. Foundational limit case: complete totalities and concurrent aggregation

The most literal form of total reification appears in Shalom’s “Complete Totalities” (Shalom, 2011). Against the cumulative hierarchy conception, which enforces both limitation of size and rejection of non-well-founded sets, the paper proposes a new approach to sets as totalities based on “concurrent aggregation.” The idea is to acknowledge, rather than forbid, the circularities that arise when one takes “all the $*$1’s” as a completed object and then allows that totality itself to fall under the predicate in question (Shalom, 2011).

The paper distinguishes the ideal totality of a predicate $*$2,

$*$3

from its complete totality $*$4. The replacement operation $*$5 is defined recursively: if $*$6, then $*$7; otherwise $*$8, with a modified convention for non-well-founded sets. The elements of $*$9 are, first, all sets $T$0 such that $T$1 holds, and second, for any non-set $T$2 such that $T$3 holds, the set $T$4 whenever that replacement is a set. The central axiom schema is that for any property $T$5, $T$6 is a set (Shalom, 2011).

This is total reification in the strongest possible sense: every one-variable predicate is assigned a corresponding set. The cost is that complete totalities are not simply extensions of their predicates. For benign predicates, the complete totality may collapse to the ordinary extension, as with finite ordinals. For global or circular predicates, complete totalities become self-inclusive or non-well-founded: the universal predicate yields a universal set, and the complete totality of the ordinals becomes a self-membered set containing all ordinals and itself (Shalom, 2011). The paper explicitly rejects Russell’s vicious circle principle, proposing that such circularities can instead be investigated as “amiable circles.”

7. Recurring tensions, misconceptions, and open problems

The literature does not support a single evaluative stance toward total reification. In RPSE and relational reification, it is an organizing ideal of traceability, inspectability, and transformation (Sirotin, 2018, Balaka et al., 11 Mar 2026). In total representations, it is a technical strategy that removes partiality and yields stronger structural invariants (Selivanov, 2013). In RDF-star and Meta-Property Graphs, it is a modeling capability by which statements, labels, properties, and substructures become first-class queryable objects (Hartig et al., 2014, Sadoughi et al., 2024). In clinical AI, by contrast, total reification is the failure mode in which documentation artefacts, coding incentives, ontology drift, and AI outputs silently define reality for the system (Stummer, 2 Apr 2026). In complete totalities, it is a foundational doctrine that accepts circularity rather than treating it as disqualifying (Shalom, 2011).

A common misconception is therefore to treat total reification as either uniformly desirable or uniformly dangerous. The papers imply a more specific distinction. Total reification is beneficial when it renders hidden assumptions explicit, versioned, queryable, and interruptible; it is hazardous when it collapses representational layers into an unquestioned single truth layer; and it is philosophically radical when it turns totalities themselves into concrete objects regardless of impredicativity. The unresolved issues track these differences: RPSE lacks a fully developed theoretical basis and tooling for mental-model extraction; Meta-Property Graphs defer indexing, optimization, and schema constraints; Pneuma-Seeker does not claim full access to latent information need $T$7; clinical anti-reification patterns have no empirical validation or runtime benchmarks; and the complete-totality framework does not provide a finished relative consistency proof (Sirotin, 2018, Sadoughi et al., 2024, Balaka et al., 11 Mar 2026, Stummer, 2 Apr 2026, Shalom, 2011).

Across these fields, total reification is best understood not as one doctrine but as a family of maximal-explicitness programs. Each asks, in its own formal language, what follows when a system stops treating models, codes, statements, metadata, ontologies, or totalities as merely derivative and instead treats them as objects in their own right.