Partitioned Information Architecture

• Partitioned Information Architecture is a design framework that treats partitions as first-class objects to explicitly direct data retrieval, execution, and security.
• It separates semantic clustering from multidimensional partitioning to determine precisely where queries should route based on attributes like time, jurisdiction, and document type.
• The approach is applied across OLTP, cloud security, and distributed optimization, ensuring balanced workloads, enhanced governance, and traceability in system behavior.

Searching arXiv for the cited works and closely related material to ground the article. Partitioned information architecture can be understood, across the supplied literature, as an architectural stance in which the partition is a first-class design object governing placement, routing, execution, and interpretation, rather than a secondary implementation artifact. In this view, partitioning may determine where retrieval is allowed to occur in a RAG corpus, which tuples are colocated for OLTP, which RDF predicates share persistent storage, which blocks of a distributed decision vector are stored at each node, which cloud-resident records remain in cleartext or encrypted, and which tuples are isolated for intrusion containment (Maio et al., 7 Jan 2026, Cao et al., 2013, Notarnicola et al., 2018, Mehrotra et al., 2018, Felemban et al., 2018).

1. Definitional core

A recurrent claim in the literature is that partitioning should not be reduced to low-level sharding, indexing, or storage layout. In large-scale RAG, the central thesis is that corpus partitioning should be designed as a conceptual, OLAP-style multidimensional model, not just as a byproduct of similarity search. The proposed separation is explicit: semantic clustering optimizes locality in embedding space, while multidimensional partitioning governs where retrieval should occur according to dimensions such as time, jurisdiction, document type, organizational context, or procedural posture. The distinction is formulated succinctly as: semantic clustering answers “what is similar?” while multidimensional partitioning answers “where should retrieval occur?” (Maio et al., 7 Jan 2026)

A parallel redefinition appears in main-memory OLTP. “Transactional Partitioning” treats partitioning not primarily as a data-layout problem, but as an application-logic abstraction. A logical partition forms the unit of logical code isolation; the programmer constructs the application in terms of distributed logical partitions by associating application logic to them; and data partitioning is presented as a consequence of code partitioning. The model preserves full global ACID semantics even when cross-partition access occurs through explicit subtransactions (Shah, 2017).

In web applications, the same issue is expressed as a mismatch between MVC’s single-address-space assumptions and the multi-address-space character of client/server systems. SPIM is proposed precisely because web applications force designers to decide which components of MVC are to be partitioned between server and client(s) before the design phase commences, while future policy changes may invalidate that initial split. The architecture therefore treats partitioning as an explicit responsibility allocation across Server Model, Server Controller, Client Model, Client Controller, Data Store, Data Cache, and View, rather than as an arbitrary duplication of the full MVC stack (Sridaran et al., 2010).

2. Partitioning units, dimensions, and boundaries

The supplied works differ sharply in what they choose as the basic partitioning unit, but they converge on the requirement that the unit reflect domain semantics. In multidimensional RAG, the Dimensional Fact Model reinterprets the basic retrieval unit in a RAG system, such as a text chunk or opinion chunk, as the analogue of a fact. Dimensions then become domain-relevant attributes, hierarchies provide movement from fine to coarse granularity, and optional dimensions support incomplete metadata. In the legal example, jurisdiction, legal subject, document type, procedural posture, and rhetorical structure together define a logically partitioned retrieval space (Maio et al., 7 Jan 2026).

For transactional databases, the basic unit is finer-grained and workload-induced. The hyper-graph formulation defines a tuple group as a set of tuples in a relation that are always accessed together during the workload, represented by a min-term predicate

$M = p_1^* \wedge p_2^* \dots \wedge p_n^*,$

where each $p_i^*$ is either a simple predicate $p_i$ or its negation. Each tuple group carries both $size(M)$ and $access(M)$, and each vertex of the hyper-graph $HG(V,E)$ represents one such group. This makes the partitioning unit an access-coherent semantic object rather than an arbitrary row range or hash bucket (Cao et al., 2013).

RDF storage adopts yet another unit: the property hierarchy. roStore defines a top-property $P^T$ as a predicate that is only an rdf:subPropertyOf of itself, and for each such top-property creates one three-column table by merging all descendant predicate tables and adding a predicate-identification column. The storage architecture is therefore ontology-guided: the hierarchy itself induces the partition, and semantic query rewriting (subsume and propertyCheck) acts as a logical front-end over that physical organization (Curé et al., 2013).

Security-oriented systems partition according to sensitivity or containment. In secure cloud outsourcing, the dataset is decomposed into sensitive and non-sensitive parts, with sensitive data either kept on a private cloud or encrypted before outsourcing, and non-sensitive data outsourced in cleartext. The public-cloud notation is explicit:

$R = R_e \cup R_p,$

with the chapter mostly assuming $R_e = R_s$ and $R_p = R_{ns}$. In PIMS, the unit is the Intrusion Boundary, while tuples assigned to two or more IBs are boundary tuples. These two cases differ in objective, but both make the boundary itself a security-relevant construct (Mehrotra et al., 2018, Felemban et al., 2018).

3. Routing, locality, and execution flow

Once partitions are defined, they become routing constraints. In multidimensional RAG, hierarchical routing proceeds by parsing the query, extracting explicit or implicit dimensional constraints, selecting relevant partitions, and searching only inside those partitions. The framework is intended to support progressively broader or narrower routing and controlled fallback when metadata is incomplete, so that the search process becomes conceptual navigation through a multidimensional space rather than undifferentiated nearest-neighbor lookup (Maio et al., 7 Jan 2026).

Transactional database partitioning turns routing into an explicit runtime artifact. After hyper-graph partitioning converges, each tuple group is assigned to a node and the final decision is encoded as a lookup table that maps tuple-group predicates to partition or node identifiers. This table is then used both when loading the database and when routing incoming transactions to the correct node(s). The routing logic is thus externalized as metadata derived from workload structure (Cao et al., 2013).

SPIM makes locality operational through an explicit request-response path. On a cache hit, the request flows from View to Client Controller to Client Model to Data Cache, then returns through XML generation to the View. On a cache miss, the request is escalated from Client Controller to Server Controller to Server Model to Data Store, after which the result is cached and formatted on the client side. Cache hits are therefore handled entirely on the client side, while cache misses are escalated to the server side, and XML serves as the transfer format between components (Sridaran et al., 2010).

Distributed optimization expresses the same principle algebraically. The global variable is partitioned as

$p_i^*$0

and node $p_i^*$1 stores only

$p_i^*$2

that is, its own block and neighboring blocks. Coherence constraints are enforced only among nodes sharing a block, and the asynchronous method is analyzed as a random coordinate ascent on the dual problem. The memory load is explicitly local-degree dependent rather than network-size dependent (Notarnicola et al., 2018).

In Transactional Partitioning, routing is encoded by programmer-defined partitioning functions and invocation syntax such as

$p_i^*$3

with remote access realized through subtransactions and optionally parallelized via PARALLEL EXEC. A transaction starts on a specified logical partition and, by default, can access only local partition data unless it explicitly invokes another transaction on another partition. Partitioning therefore constrains both control flow and access scope (Shah, 2017).

4. Governance, security, and resilience

A major theme in the literature is that explicit partitions improve governance. In multidimensional RAG, routing is deterministic given the query’s dimensional interpretation, retrieval scope is explainable in terms of a specific jurisdiction/time/document-type slice, and controlled fallback prevents missing metadata from producing opaque behavior. The proposal is explicitly positioned against “black-box” similarity retrieval and ad hoc metadata filtering, especially in enterprise and legal settings that demand traceability, reproducibility, scope control, and auditable retrieval behavior (Maio et al., 7 Jan 2026).

In secure cloud outsourcing, partitioning introduces both efficiency and new leakage channels. Hybrid-cloud execution is written as

$p_i^*$4

while the public-cloud-only variant becomes

$p_i^*$5

The central threat is that naïve split execution allows the cloud to correlate the encrypted and plaintext sides. The chapter therefore defines a partitioned data security criterion requiring that query execution not increase the adversary’s ability to infer equality links between sensitive and non-sensitive values or frequency relations among sensitive values. Query Binning addresses this by querying a sensitive bin and a non-sensitive bin together so that the exact target remains hidden inside the bin intersection (Mehrotra et al., 2018).

PIMS turns partitions into resilience domains. Its architecture includes an IBDP Solver, Transactions Log, Admission Controller, Response Subsystem, Recovery Subsystem, and Corrupted Tuples Table. Once an intrusion is detected, the response phase rapidly marks potentially corrupted tuples in the IBs spanned by the malicious transaction, while delayed access to boundary tuples prevents immediate cross-partition propagation. Recovery then acquires recovery locks on the relevant IBs, computes the affected transaction set, and performs compensating transactions in two phases: undo malicious and affected transactions, then redo benign affected work in commit order. The partition is therefore both the containment unit and the recovery unit (Felemban et al., 2018).

SPIM also associates partitioning with security, though at application rather than database level. One stated advantage is that SPIM shields the Server Controller from unauthorized service requests, while avoiding the model synchronization burden of duplicated MVC-style approaches. This does not formalize a threat model comparable to cloud or intrusion papers, but it reinforces the broader pattern that partition boundaries often double as control boundaries (Sridaran et al., 2010).

5. Formal models and analytical frameworks

The most abstract formalization in the supplied corpus is the hierarchical generalization of information theory. A hierarchical partition $p_i^*$6 of a universe $p_i^*$7 is defined by a rooted tree whose children partition each parent subset:

$p_i^*$8

The core similarity measure, Hierarchical Mutual Information, admits both a recursive definition and a levelwise decomposition:

$p_i^*$9

The theory proves

$p_i$0

defines hierarchical entropy by self-mutual information, and shows that the hierarchical Variation of Information is nonnegative but not a metric; a transformed quantity

$p_i$1

does satisfy the triangle inequality. The same work also introduces Expected Hierarchical Mutual Information and Adjusted Hierarchical Mutual Information to correct for chance similarity (Perotti et al., 2020).

Transactional database partitioning frames its optimization target as a multi-constraints hyper-graph partitioning problem. The key practical measure of imbalance is the skew factor

$p_i$2

where $p_i$3 is node data size, $p_i$4 is node transaction count, and $p_i$5. The optimizer simultaneously seeks minimum $p_i$6-way net-cut, balanced partition sizes, balanced workload accesses, and satisfaction of cluster constraints (Cao et al., 2013).

Distributed optimization supplies a complementary analytical template. Under strong convexity, compact convex local feasible sets, and a Slater-type condition, the partial Lagrangian becomes separable over neighborhood-sized local problems, and the local dual gradient is Lipschitz with

$p_i$7

The synchronous method converges for step sizes $p_i$8, while the asynchronous method converges with high probability for $p_i$9 (Notarnicola et al., 2018).

PIMS adds a security-oriented partitioning model. The IB Demarcation Problem is formulated as a mixed integer nonlinear program minimizing boundary tuples and partition imbalance, with binary variables indicating tuple-to-IB assignment, transaction-to-IB assignment, and whether a tuple is boundary. The paper proves that IBDP is NP-hard, then introduces Best-Fit Assignment and Balanced Assignment as heuristics trading overlap minimization against size balance (Felemban et al., 2018).

6. Comparative patterns, trade-offs, and recurring misconceptions

A persistent misconception is that partitioning is equivalent to filtering after the fact. The RAG position paper explicitly distinguishes multidimensional partitioning from ad hoc metadata filtering: the latter is often isolated, inconsistently designed, and poorly aligned across the corpus, whereas the former provides named dimensions, explicit hierarchies, controlled granularity, modeled optionality, and planned fallback. SPIM makes a comparable point in web architecture: duplicating Model and Controller on both client and server may appear to simplify partitioning, but it introduces delayed data fetch, security problems, scalability issues, model synchronization requirements, and redundant searches in both cache and datastore (Maio et al., 7 Jan 2026, Sridaran et al., 2010).

A second recurring pattern is that partition quality is always objective-dependent. Hyper-graph partitioning minimizes distributed transactions while balancing data size and workload access under cluster constraints; roStore improves hierarchy-spanning RDF queries by replacing multiple UNIONs with one table scan, but vertically partitioned storage can be faster when only one or a few predicates from a hierarchy are needed; and PIMS exposes a similar tension through Best-Fit Assignment versus Balanced Assignment and through the fact that more IBs may reduce affected transactions and recovery time while increasing response overhead because more boundary tuples must be managed (Cao et al., 2013, Curé et al., 2013, Felemban et al., 2018).

Security-oriented partitioning adds a further trade-off: selective protection reduces expensive encrypted processing, but the partition itself can become a side channel. The secure outsourcing chapter states that partitioned computing can bring efficiencies because non-sensitive data is processed in the cleartext, yet it can lead to information leakage through cross-partition inference, frequency leakage, access-pattern leakage, and poorly chosen partitioning decisions. Query Binning is beneficial when $size(M)$0, but this gain comes from trading increased communication and query fan-out against reduced encrypted computation (Mehrotra et al., 2018).

At the theoretical end, the hierarchy literature corrects another simplification: not every partition-based dissimilarity is a metric. Hierarchical Variation of Information can violate the triangle inequality, and hierarchical entropy depends only on the leaf partition, not on internal levels. This suggests that partitioned information architecture is not exhausted by flat partition counts or leaf-level uncertainty; internal organization, overlap structure, and levelwise semantics may matter even when conventional scalar summaries do not (Perotti et al., 2020).

Across these domains, a common conclusion emerges: partitioning is most consequential when it governs not only where information is stored, but also how queries are routed, how execution is decomposed, how security boundaries are enforced, how failures are contained, and how system behavior is rendered explainable. A plausible implication is that “partitioned information architecture” names a family of designs in which information locality, semantic scope, and control boundaries are co-designed rather than inferred post hoc from generic storage or similarity mechanisms.