Cross-subnet Consistency Preservation (CCP)

• Cross-subnet Consistency Preservation (CCP) is a framework for maintaining invariant consistency across isolated computational or communication partitions by enforcing semantic, causal, or state synchronization.
• It employs serialization-based propagation and visibility constraints to bridge isolated processing units, ensuring that critical information is preserved across samples, observers, or domains.
• Empirical and mechanized studies indicate that CCP-based approaches improve performance and stability, achieving robust semantic alignment and state integrity across diverse systems.

Cross-subnet Consistency Preservation (CCP) is not introduced as a single named formalism in the cited literature. As an Editor’s term, it can be used to denote a family of preservation problems in which consistency must survive boundaries between samples, observers, or domains. In the 2026 literature, that family appears in three technically distinct forms: semantic alignment across scenes in self-supervised point cloud learning, visibility constraints on observer-specific sub-DAGs in message-passing systems, and structure-preserving synchronization of regulatory state transitions across heterogeneous domains (Yu et al., 3 May 2026, Landers et al., 9 May 2026, Kim, 4 Apr 2026).

1. Preservation targets and formal objects

The three cited works converge on preservation as a constraint on what may diverge across partitions of computation, data, or communication. In "PointCSP: Cross-Sample Semantic Propagation and Stability Preservation in Self-Supervised Point Cloud Learning" (Yu et al., 3 May 2026), the preserved object is a unified semantic space spanning multiple scenes. In "Light Cone Consistency: Toward a Unified Theory of Consistency in Message-Passing Systems" (Landers et al., 9 May 2026), the preserved object is the shape, ordering, and growth rate of each observer’s visible causal sub-DAG. In "Safety and Liveness of Cross-Domain State Preservation under Byzantine Faults: A Mechanized Proof in Isabelle/HOL" (Kim, 4 Apr 2026), the preserved object is the transition structure of regulatory state across connected domains.

Work	Formal object	Preserved consistency
PointCSP	Serialized batch of point-cloud feature sequences processed by an SSM	Semantic alignment across samples/scenes during pretraining and stable semantic transfer during finetuning
LCC	Causal DAG $G=(M,E)$ with observer-visible sub-DAGs $V(n,t)$	Causal closure $C(\mathit{deps})$, fork resolution $O(\pi)$, timeliness $R(\delta)$, with orthogonal return-value function $F$
Mechanized state preservation	Finite set of domains with deterministic partial transition function and atomic sync	Faithfully reflected state across all connected domains with structural preservation, bidirectional roundtrip preservation, consistency across an arbitrary finite set of domains, and per-asset isolation

A plausible synthesis is that CCP names the common problem underlying these formulations: preserving a nonlocal invariant when the system is decomposed into partially isolated units. The units differ by paper—samples, observers, or domains—but the preservation burden is similar. Each work therefore addresses a version of the same question: what must propagate across boundaries, how is that propagation constrained, and what additional mechanism stabilizes the result when the original communication context is unavailable or adversarial?

2. Cross-sample semantic preservation in scene-level point cloud learning

PointCSP is explicitly presented as a consistency-preservation framework for scene-level point cloud self-supervised learning. Its motivating diagnosis is that most scene-level point cloud SSL methods still follow a sample-independent modeling paradigm: each scene is processed in isolation, and the representation objective mainly aligns local crops, views, or masked reconstructions inside one sample. The paper identifies two resulting pathologies: inter-scene semantic fragmentation, in which features from the same semantic class but different scenes may land in disconnected regions of the embedding space, and lack of semantic continuity across samples, because the network cannot learn explicit inter-sample dependencies or a global semantic topology (Yu et al., 3 May 2026).

The pretraining-side mechanism is Cross-Sample Semantic Propagation (CSP). For a batch of $B$ point-cloud samples, each sample $i$ is represented as

$$\mathbf{F}_i = [\mathbf{f}_{i,1}, \mathbf{f}_{i,2}, \ldots, \mathbf{f}_{i,L}] \in \mathbb{R}^{L\times C}.$$

The batch is then concatenated into a single serialized sequence

$$\mathbf{F}' = [\mathbf{f}_{1,1}, \ldots, \mathbf{f}_{1,L}, \mathbf{f}_{2,1}, \ldots, \mathbf{f}_{B,L}] \in \mathbb{R}^{(B\times L)\times C}.$$

This converts scene-by-scene processing into a continuous token stream so that a state-space model can propagate semantic information across sample boundaries. The SSM block is written as

$V(n,t)$0

Here $V(n,t)$1 carries semantic context accumulated from previous tokens, including tokens from earlier samples, and $V(n,t)$2 injects the current point’s information. The paper describes this as semantic state propagation: the representation of one scene is no longer independent of the others, but is influenced by a shared semantic history.

CSP is embedded in a DINO-style self-distillation pretraining scheme with multi-region augmentations. For each point cloud $V(n,t)$3, the method first selects a candidate region $V(n,t)$4 covering about $V(n,t)$5 of the cloud, then samples $V(n,t)$6 global subregions $V(n,t)$7 with about $V(n,t)$8 coverage and $V(n,t)$9 local subregions $C(\mathit{deps})$0 with about $C(\mathit{deps})$1 coverage. The teacher sees only global views, while the student sees both global and local views. The teacher is updated by EMA,

$C(\mathit{deps})$2

which stabilizes the semantic target and prevents collapse.

The finetuning-side mechanism is asymmetric semantic preservation distillation (SPD). The paper’s claim is that serialization-based pretraining is batch-dependent, whereas downstream finetuning and inference typically operate on one scene at a time. SPD therefore preserves the pretrained semantic manifold while adapting to single-scene inputs. The teacher branch keeps batch-serialized processing to preserve the pretrained global topology, while the student branch uses standard single-scene inputs. The student is trained with a semantic feature alignment constraint, and the teacher is again EMA-updated. This is intended to decouple finetuning from the batch organization required by CSP while preserving the benefits of the global semantic topology learned during pretraining.

The paper’s own summary of the division of labor is precise: CSP enforces cross-sample alignment during pretraining by serializing the batch and propagating semantic state through an SSM, whereas SPD ensures stable semantic transfer during finetuning by distilling the batch-aware teacher into a batch-independent student. In CCP terms, this is preservation across training stages as well as across samples.

3. Empirical characterization of semantic consistency

The empirical evidence for PointCSP is reported across scene-level segmentation, boundary analysis, and instance-level tasks. The central claim is that the method consistently outperforms state-of-the-art methods in both performance and semantic consistency, with t-SNE visualizations showing tighter, more aligned clusters for same-class features across scenes and S3DIS visualizations showing clearer boundaries and less category confusion than CamPoint (Yu et al., 3 May 2026).

Benchmark	Metric(s)	PointCSP result
S3DIS Area 5	mIoU	88.2%
S3DIS 6-fold CV	mIoU	93.1%
3DSES Silver with pseudo labels	OA / mIoU	96.41% / 69.07%
3DSES Silver with real labels	OA / mIoU	95.78% / 65.13%
ModelNet40	OA / mAcc	93.9% / 91.5%
ScanObjectNN (PB_T50_RS)	OA / mAcc	92.8% / 91.7%
ShapeNetPart	Ins. mIoU / Cls. mIoU	86.8% / 84.9%

The ablation study is especially diagnostic for a consistency-preservation interpretation. The baseline achieves 84.7 mIoU; adding SPD yields 86.8 mIoU; adding CSP yields 87.8 mIoU; combining CSP and SPD yields 88.2 mIoU. The paper treats this as direct support for three claims: SPD stabilizes transfer, CSP improves cross-sample semantic structure, and their combination is best. The batch-size sensitivity study further shows that performance remains stable across batch sizes during finetuning, which the paper interprets as evidence that SPD successfully removes dependence on the serialized pretraining batch structure.

The boundary or edge-strip analysis on S3DIS uses mIoU and F1 at neighborhood radii $C(\mathit{deps})$3. PointCSP consistently outperforms CamPoint in that analysis, which the paper presents as evidence of better boundary awareness and semantic stability under spatial perturbations. This suggests that the preserved semantic structure is not only cluster-level but also spatially local around difficult class boundaries.

4. Observer-visible consistency in message-passing systems

LCC provides a general theory of consistency in message-passing systems by recasting every such system as a growing causal log observed through per-node visible sub-DAGs. The model consists of a causal DAG $C(\mathit{deps})$4, a set of observers $C(\mathit{deps})$5, a visibility predicate $C(\mathit{deps})$6, and each observer’s visible sub-DAG

$C(\mathit{deps})$7

Consistency models are then represented as configurations of three visibility constraints plus a return-value function,

$C(\mathit{deps})$8

The paper’s central claim is that consistency is about the shape, ordering, and growth rate of the visible sub-DAG: $C(\mathit{deps})$9 controls causal closure, $O(\pi)$0 controls fork resolution, $O(\pi)$1 controls timeliness, and $O(\pi)$2 controls the observable result computed from the visible sub-DAG (Landers et al., 9 May 2026).

The three core constraints are given formally. Causal closure requires that if an observer sees a message, it must also see the selected causal past of that message: $O(\pi)$3 Fork resolution requires that within each partition class, visibility respect a total order $O(\pi)$4: $O(\pi)$5 Timeliness requires bounded or eventual propagation: $O(\pi)$6 The return-value function is

$O(\pi)$7

and the paper explicitly states that $O(\pi)$8 is independent of the impossibility surfaces.

The work is particularly relevant to CCP because it makes boundary-crossing consistency a question of observer-visible sub-DAGs. The paper notes monotonic visibility, creator visibility, and observation-induced dependency. It also emphasizes that ordering decisions are themselves messages; if a total-order or fork-resolution decision is communicated, that decision becomes part of the DAG and must propagate like any other message. Incomplete visible sub-DAGs can therefore produce fork misclassification: an observer missing ancestors may mistake causal order for concurrency and may resolve forks differently from other observers.

The impossibility results are expressed as surfaces over the three constraints. The CAP surface states that

$O(\pi)$9

is unachievable during a network partition of duration $R(\delta)$0. The FLP surface states that $R(\delta)$1 together with deterministic finite $R(\delta)$2 is unachievable in an asynchronous system with at least one crash failure. The AFC surface states that $R(\delta)$3 under $R(\delta)$4 is not achievable in an available wait-free implementation. The paper proves the three surfaces minimal and independent.

A central interpretive statement is that the triangle activates only when the system is in use: $R(\delta)$5, $R(\delta)$6, or $R(\delta)$7 each introduces a constraint that exposes the system to the surfaces. It also states that a system that writes far slower than its propagation delay produces no concurrent events, and the surfaces are never approached. For CCP, a plausible implication is that cross-subnet preservation is inherently workload-relative: the same visibility guarantees may be trivial at low concurrency and impossible under active partition or high write rates.

5. Mechanized cross-domain state preservation under Byzantine faults

The Isabelle/HOL paper treats preservation as a theorem about state synchronization across a finite set of domains $R(\delta)$8, where each domain may be a blockchain, an off-chain ledger, or a similar stateful system. Per-domain evolution is abstracted by a deterministic partial transition function

$R(\delta)$9

with $F$0. The global system state is represented as $F$6 and validity is defined by $F$7 The synchronization function sync is atomic and follows a lock–validate–update–unlock discipline. Synchronization succeeds only if the asset exists on the source chain, the requested regulatory transition is valid, the asset lock can be acquired, all connected chains are updated, and the lock is released (Kim, 4 Apr 2026).

The regulatory instance is based on the RCP framework, which organizes 31 regulatory requirements from 15 global financial regulators into a model with five states and seven actions. The states are ACTIVE, FROZEN, SEIZED, CONFISCATED, and RESTRICTED; the actions are FREEZE, SEIZE, CONFISCATE, RESTRICT, UNFREEZE, UNRESTRICT, and RELEASE. The transition function defines 35 $F$1 pairs, of which 12 are valid and 23 return None. Three foundational invariants are proved: CONFISCATED is terminal, confiscation is universal for non-terminal states, and there are no self-loops.

The safety argument is organized through four generic locales. The locale state_machine fixes a finite state machine with terminal absorptivity and transition closure. The locale state_preservation introduces a structure-preserving map between source and target state machines, with a naturality condition stating that synchronization commutes with transition. Its central theorem, sequential_preservation, states that a valid action sequence at the source maps to a valid action sequence at the target and ends in the mapped final state. The locale symmetric_state_preservation adds inverse maps and roundtrip properties, from which injectivity is derived. The locale multi_domain_preservation generalizes to an arbitrary finite set of domains and proves two main theorems: cross_domain_consistency, meaning that after synchronization every connected domain agrees on the same new state for the asset, and sync_isolation, meaning that synchronization on one asset does not affect any other asset.

These generic results are instantiated in the regulatory model. The theorem regulatory_homomorphism states that if synchronization succeeds from a valid global state, then every connected chain agrees on the new regulatory state. The theorem valid_state_preservation shows that synchronization preserves both consistency and lock discipline.

The liveness side is developed through three further generic locales. priority_system proves unique highest-priority selection in any non-empty finite set. In the regulatory instantiation, the priority key is a 4-tuple of authority rank, inverted timestamp, action severity, and inverted node ID, yielding deterministic conflict resolution. deadlock_free_locking proves bounded lock expiry through a positive timeout, and fair_leader_system proves starvation freedom and eventual completion under fair leader scheduling. These are then instantiated in a BFT setting with the threshold $F$2, equivalently $F$3, from which honest majority is derived.

The paper’s main combined-result insight is that liveness discharges the honest-node assumption used in the safety proof. The combined theorem states that from a valid initial state, a valid action request on an unlocked asset necessarily succeeds, and the resulting state is valid. Relative to CCP, this is a stronger preservation notion than mere value agreement: it is roundtrip-preserving, multi-domain, per-asset-isolated structural preservation of state transitions under Byzantine faults.

6. Comparative interpretation, misconceptions, and open questions

A common misconception is to treat consistency preservation as simple equality of visible outputs. The cited works collectively reject that reduction. PointCSP explicitly states that the relevant consistency is not merely invariance to augmentation, but semantic alignment across samples/scenes during pretraining and stable semantic transfer during finetuning (Yu et al., 3 May 2026). LCC distinguishes visibility constraints from return semantics and states that strong eventual consistency and causal+ differ only in $F$4, not in the visibility constraints (Landers et al., 9 May 2026). The mechanized Isabelle/HOL work frames preservation as a structure-preserving homomorphism with roundtrip preservation and per-asset isolation, not merely matching values across replicas (Kim, 4 Apr 2026).

Another misconception is that stronger return-value semantics determine the fundamental impossibility boundary. LCC states the opposite: $F$5 is orthogonal to the impossibility surfaces. The hard constraints arise from closure, ordering, and timeliness, and the paper’s central observation is that these three constraints are fully entangled: violation of any one surface cascades to the other two, because restoring any parameter requires messages, and those messages are subject to all three constraints.

The principal caveats differ by formulation. PointCSP still assumes that batching and serialization are meaningful ways to create semantic continuity. Its cross-sample consistency is learned through a specific serialized ordering mechanism rather than a fully permutation-invariant relational model, and SPD mitigates, but does not entirely eliminate, the mismatch between batch-serialized pretraining and single-scene deployment. LCC does not fully formalize a theorem specifically for subnets or cross-subnet consistency; it treats partition and subnet issues through observers and message propagation rather than a subnet-native model, handles fork-based models with caveats, does not natively express release/acquire memory models through the point-event DAG model, and leaves open a conjectured fourth surface, log locality. The mechanized state-preservation result is domain-independent at the locale level, but its application context is a regulatory state transition model based on the RCP framework.

Taken together, the three works suggest that CCP is best understood not as a single completed theory but as a comparative lens over preservation problems in distributed representation learning, message-passing semantics, and cross-domain state synchronization. In each setting, the central issue is the same: local processing units can remain internally coherent while becoming globally inconsistent unless the system explicitly preserves semantic history, visible causal structure, or transition structure across the boundaries that separate them.