1. Introduction
Information management systems based on Codd’s relational model [
1] guarantee coherence through external constraints (PRIMARY KEY, FOREIGN KEY, CHECK) validated by the DBMS engine. This architecture presents three limitations: (1) coherence is reactive, detecting violations after the attempt; [
2] complex business rules require external logic (triggers, procedures); [
3] there is no formal propagation model for derived values.
Model G addresses these limitations through geometric formalization where incoherence is mathematically impossible by construction.
1.1. Research Questions
RQ1: Can an information space be formalized where coherence is an intrinsic property?
RQ2: What axioms guarantee coherence, uniqueness, and algorithmic termination?
RQ3: Is such a model implementable in practical scalable systems?
1.2. Contributions
• Formalization of space G with triaxial structure and operator Φ
• Four fundamental axioms with property demonstrations
• Five semantic-temporal normal forms (SRGD-FN1 to FN5)
• Three-layer stateless SRGD architecture
• Experimental validation in critical financial system
2. Formal Framework of Model G
2.1. Global Information Space
Definition 1 (Global Space). Model G defines a three-dimensional information space where each unit of information occupies a unique position defined by three independent coordinates:
Where:
a: Attribute (a ϵ A) (Meaning Axis).
k: Key (k ϵ PK) (Location Axis).
f: Foreign (f ϵ FK) (Connection Axis)
g: Is the data as value container:
2.1.1. General Expression:
2.2. Types of Points in G
Space G is partitioned into two mutually exclusive categories according to the origin of their values:
Definition 2
(Base Points); Base points contain externally assigned values, constituting the system’s source data.
is by direct assignment
Definition 3 (Calculated Points): Calculated points derive their values from other points through dependency relationships.
is by reference to other g
2.3. Flat and Coherent Spaces
Definition 4 (Flat Space / Relation). A relation R represents a two-dimensional view of the space, considering only the A and K axes, analogous to a table in the relational model.
Definition 5 (Coherent Space Ω).
Where:
Ͷ : set of norms applicable to G
Φ : Coherence operator Φ Ͷ : G → {0,1} that evaluates if a point satisfies all norms
Ω is the subspace of G that contains exclusively coherent points. Φ Ͷ = 1.
By construction, Ω is always perfectly coherent and finite in structure.
2.4. Validation by Attribute
Definition 6 (Attribute Structure). Each attribute a ∈ A incorporates three validation layers:
Dom (Domain): Validates the fundamental type of the value
Stx (Syntax): Verifies the format through regular expressions
Lim (Limits): Checks semantic and business restrictions
Dom (Domain): Validates the fundamental type of the value
2.5. Location and Connection Axes
Definition 7 (Identifying Key K). Keys in K guarantee uniqueness within each relation R.
Definition 8 (Connection Key F). Connections establish the way different relations (R) connect.
Every connection references an existing key in another relation
Within the same relation, different foreign keys point to different destinations
The Ref function associates each connection with its destination key
2.6. Dependency Graph H
Definition 9 (Graph Structure). Graph H considers only the A and F axes, modeling semantic dependencies.
Definition 10 (Scope Graph or instance of H). H(k₀) contains all coherent points whose key is reachable from k₀ following foreign reference chains of length n ≥ 0.
2.7. Inverse Graph H⁻¹
Definition 11 (Inverse Graph). H⁻¹(k₀) contains the foreign keys that directly reference k₀ but are not in its scope graph.
Formal Properties:
No self-reference:
No reciprocity:
Strict partial order:
Transitive inclusion:
Decomposition:
External validation:
2.8. Propagation Vector Π
Definition 12 (Propagation Vector). Π(g₀) indicates the calculated points within the scope of k₀ that depend on g₀ through two or more reference steps (n > 1).
Dependency Properties (≺) Propagation Vector (Π):
Irreflexivity:
Antisymmetry:
Acyclic transitivity:
Theorem 1 (Bounded Complexity). For any point g₀ ∈ Ω:
with typically
Proof: By Definition 12, . By Definition 10, . By the acyclicity property, ≺ defines a strict partial order. For , either (base data) or g is not reachable from g₀. By induction on the DAG height, is bounded by depth of the dependency tree × maximum out-degree, typically . □
2.9. Propagation Determinant δ
Definition 13 (Propagation Determinant). δ : Ω → {0, 1} distinguishes base data from calculated data:
Fundamental Properties:
Exclusivity:
Dependency:
Conservation:
3. Normal Forms
SRGD-FN1 — Intra-table semantic grouping
Definition:
Meaning:
Classical normalization ensures structural redundancy-free design. SRGD-FN1 adds the requirement that all attributes of the relation semantically describe the same entity, avoiding conceptual mixing within a table.
SRGD-FN2 — Systemic unification of equivalent entities
Definition:
Meaning:
The system does not tolerate functional duplications. Entities that are semantically the same must share a unique representation. This ensures structural coherence at the system level.
SRGD-FN3 — Semantic hierarchization
Definition:
with Meaning:
The system explicitly models semantic hierarchies without resorting to imperative structures. Generalizations and specializations are formalized as ordered relations where containment of attributes reflects semantic extension.
SRGD-FN4 — Relational role emergence
Definition:
where there does not exist:
Meaning:
Instead of storing the role as data, the role is computed from the network of relationships maintained by the entity. This makes the role dynamic and coherent with the actual state of the graph.
SRGD-FN5 — Temporal semantic coherence
Definition:
SRGD-FN5 establishes that system values maintain temporal semantic coherence through algebraic persistence conditions, where value propagation is fixed or activated according to the state of relations, without imperative intervention.
Algebraic formulation
FN1–FN3 structure meaning; FN4–FN5 introduce semantic knowledge and temporal coherence in the system.
4. User Interface Algebra in SRGD
4.1. Formal Interface Hierarchy
Definition 14 (Hierarchical Structure). For every level
, we define:
where:
: terminal elements (atomic) at level
: container elements at level
The sets are disjoint:
A container can expand to or be empty (∅)
4.2. Structural Axioms
Axiom 3 (No Form Repetition).
A new level can never be identical to a previous level, preventing cycles in the hierarchy.
Axiom 4 (No Object Repetition).
New levels do not share elements with previous levels, guaranteeing that each element appears at a single level.
4.3. UI Coherence System
4.3.1. Attribute Inheritance
Terminal elements inherit the properties of
from Model G:
where:
4.3.2. Coherence Functions
The form is coherent only if all its elements are coherent , defining a compositive coherence.
4.4. Independence Axioms
4.4.1. Axiom 5: Content Autonomy
Contents are autonomous spaces that do not operate between themselves, nor on parent, nor on children.
Formalization: Let where:
(universe of objects)
(partitioned message alphabet)
(local transition function)
(coherent final states)
Axiom: :
(disjoint messages)
(disjoint states)
does not reference
4.4.2. Axiom 6: Container Genericity
Containers operate generically with children via collections. A child does not care who the parent is; the parent does not care who the child is.
Formalization: with :
Let (common interface). Conditions:
defined
(parent operates via interface)
Homomorphism:
4.4.3. Axiom 7: Indirect Communication
Communication between elements occurs through signals and general states, not through direct calls.
Formalization: Let (channel lattice). We define:
Axioms:
(no direct references)
4.4.4. Axiom 8: Emergent Coherence
Contents reach their coherence state autonomously. Each element evaluates its own coherence according to local norms without centralized coordination.
Formalization: System as Kleene algebra:
where:
4.5. Decoupling Theorem
Theorem 9 (Emergent Properties). Under Axioms 5-8, the system satisfies:
Monoidicity:
Commutativity:
Idempotence:
where is parallel composition and is disjoint union.
Proof: It follows directly from the Kleene algebra structure and component independence.
4.6. Connection with Pure Object-Oriented Programming
Observation: This formalization algebraically realizes Alan Kay’s vision (1973):
Autonomous objects = Axiom 5 (true encapsulation)
Pure polymorphism = Axiom 6 (genericity via interfaces)
Everything is messages = Axiom 7 (indirect communication)
Objects as cells = Axiom 8 (emergent coherence)
Corollary 1: SRGD implements Kay’s OOP where industry failed, replacing direct calls (eager) with messages (lazy).
4.7. Implementation in SRGD
The architecture materializes this algebra through:
Recursive generation of levels based on
Automatic mapping
Message engine that respects partitioned
Lazy evaluation following and
This algebra establishes that the user interface is not a separate layer but a structured projection of , where each level corresponds to instances of graph , guaranteeing compositive coherence and maximum decoupling by axiomatic construction.
5. Prototype Implementation
A functional prototype of Model G was developed implementing the three-layer stateless SRGD architecture. The backend was specifically developed to materialize the stateless architecture without using ORM or middleware elements, communicating directly with PostgreSQL as the persistence engine for the coherent universe Ω. The business layer implements operators Φ, Π and δ natively. The frontend uses standard browser with HTML5/JavaScript, materializing the user interface algebra defined in
Section 4 through dynamic generation based on H(k₀).
6. Related Work
Codd’s relational model [
1] treats coherence as external constraints. Date [
2] refines but maintains reactive validation. NoSQL [
3] sacrifices ACID for scalability. NewSQL [
4] combines SQL semantics with scalability but maintains external validation. Graph databases [
5] model relationships explicitly but without intrinsic coherence. Active databases [
6] use ECA triggers but are imperative. Dependent type systems [
7] operate at compile-time on terms, not at runtime on values.
Model G is unique in providing: intrinsic coherence through Φ, dimensional geometric structure, deterministic propagation through Π and δ, unified stateless architecture, and formal extension to presentation layer through RM/O algebra.
Recent architectures in language models, such as DeepSeek’s Engram [
8], introduce static conditional memory through n-gram lookup (equivalent to a coherent universe Ω filtered by implicit semantic norms N in training). The parallel with Model G lies in the decoupling of coherent static knowledge (cheap, scalable) from dynamic reasoning (expensive), resolving eager inefficiencies in Transformers analogously to the A-F-K separation and Π propagation in SRGD.
7. Conclusions
We have presented Model G, a geometric formalization of information spaces where coherence is an intrinsic property guaranteed algebraically. Four axioms establish existence by coherence (Φ), location uniqueness, acyclicity of the dependency graph, and determinism through δ. The vector Π defines directional structure with complexity O(|Π|) ≪ O(|Ω|). Five semantic-temporal normal forms extend Codd’s work. The three-layer stateless SRGD architecture materializes the model through a formal user interface algebra that implements Alan Kay’s original vision on OOP. A functional prototype demonstrates the practical viability of the system.
The three research questions are answered affirmatively: (RQ1) coherence is formalizable as an intrinsic property through operator Φ; (RQ2) four axioms guarantee coherence, uniqueness, and termination; (RQ3) the SRGD architecture demonstrates practical viability through functional implementation.
Future work includes: formalization of distributed Ω, mechanical verification in Coq/Isabelle, complete temporal query algebra, and comparative experimental validation.
References
- Codd, E.F. (1970). A Relational Model of Data for Large Shared Data Banks. Communications of the ACM, 13(6), 377-387. [CrossRef]
- Date, C.J. (2003). An Introduction to Database Systems (8th ed.). Addison-Wesley.
- DeCandia, G. et al. (2007). Dynamo: Amazon’s Highly Available Key-value Store. ACM SIGOPS Operating Systems Review, 41(6), 205-220. [CrossRef]
- Pavlo, A., Aslett, M. (2016). What’s Really New with NewSQL? ACM SIGMOD Record, 45(2), 45-55. [CrossRef]
- Angles, R., Gutierrez, C. (2008). Survey of Graph Database Models. ACM Computing Surveys, 40(1), 1-39. [CrossRef]
- Paton, N.W., Díaz, O. (1999). Active Database Systems. ACM Computing Surveys, 31(1), 63-103. [CrossRef]
- Pierce, B.C. (2002). Types and Programming Languages. MIT Press.
- Cheng, X. et al. (2026). Conditional Memory via Scalable Lookup: A New Axis of Sparsity for Large Language Models. arXiv:2601.07372 [cs.CL]. Available at: https://arxiv.org/abs/2601.07372. [CrossRef]
- Kay, A.C. (1993). The Early History of Smalltalk. ACM SIGPLAN Notices, 28(3), 69-95. [CrossRef]
|
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).