Contextual Chain: Single-State Ledger Design for Mobile/IoT Networks with Frequent Partitions Song-Ju Kim∗
arXiv:2604.06529v1 [cs.DC] 8 Apr 2026
SOBIN Institute LLC, Kawanishi, Hyogo, Japan (Dated: April 9, 2026) We study a lightweight ledger protocol for intermittent and noisy networks, motivated by IoT and mobile settings in which partitions are common and full-history verification is impractical. Our design centers on an operational notion of contextual authentication: each node decides whether a chain extension is acceptable in its current local context, using checkpoint-first fork choice, a local branch score derived from recent proposer behavior, and an inconsistency-driven quarantine signal. To improve recovery after partitions, we combine this acceptance rule with adaptive synchronization, which increases gossip effort only when inconsistency becomes prevalent. We evaluate the protocol with a discrete-event simulator under controlled partitions and two network regimes (clean and noisy). Across 500 seeds at N = 20, the main result is that quarantine alone does not materially improve agreement or recovery under noisy conditions, whereas increased synchronization (Gossip only and Both) substantially improves both final agreement probability and recovery-time tails after partition rejoin. Longer-horizon experiments show that low-synchronization failures are not removed simply by waiting longer, and scaling experiments at N = 50 and N = 100 show that parameters that work at small scale do not automatically generalize. These results indicate that, under noisy partition/rejoin dynamics, recovery in the current design is limited primarily by information availability, making synchronization policy a first-class design problem.
INTRODUCTION
Distributed ledger protocols are often designed for settings with relatively stable connectivity and participants that can store, replay, and validate long histories. Representative examples include longestchain systems such as Bitcoin [1] and stronger agreement protocols such as HoneyBadgerBFT [2]. A separate line of work has addressed lightweight verification and compact-state operation [3, 4], while other work has explored constrained or IoT-oriented ledger settings [5]. These directions motivate a broad question: what should a ledger protocol look like when connectivity is poor, partitions are common, and full-history validation is impractical? This paper studies that regime. We focus on intermittent and noisy environments in which nodes are resource-constrained, links are unreliable, and storing or replaying full history is undesirable. In such settings, the main systems question is not only whether agreement is possible in principle, but also how quickly and how reliably the system recovers after disruption. Our protocol addresses that question through two coupled mechanisms. First, nodes use an operational notion of contextual authentication: each node maintains a compact local view and uses it to decide which branch is acceptable. Second, because local acceptance alone cannot repair missing information, the protocol uses adaptive synchronization, increasing gossip effort only when inconsistency becomes prevalent.
The main empirical result is clear. Under noisy partition/rejoin dynamics, conservative local decision logic by itself is not enough. Quarantine alone does not materially improve agreement or recovery, whereas increased synchronization substantially improves both final agreement probability and recovery-time tails. Longer-horizon experiments show that low-synchronization failures are not removed simply by waiting longer, and scaling experiments show that parameters that work at small scale do not automatically generalize to larger networks. Taken together, these results make synchronization policy a first-class design problem rather than a minor tuning detail. Our use of the term “authentication” is operational rather than cryptographic. In particular, the term does not denote a cryptographic identity or unforgeability guarantee in the present paper; it denotes a node-local acceptance rule for choosing a plausible chain head from compact context. We do not claim a signature-based or indistinguishabilitystyle security theorem. Instead, the paper makes a systems claim about protocol-level acceptance, recovery, and synchronization under disruption. A broader motivation for this viewpoint comes from recent work on fixed shared-state semantics and contextual bookkeeping cost [6–8], but in the present paper we use that perspective only as architectural motivation and as background for the later proof-ofcontext extension. Contributions. • We define and implement an operational
2 contextual authentication rule for lightweight nodes, based on checkpoint-first fork choice, branch scoring from recent proposer behavior, and an inconsistency-driven quarantine signal. • We couple this decision rule with adaptive synchronization and evaluate four clear variants: NoQ, Q only, Gossip only, and Both. • We provide extensive simulation results under controlled partitions and noisy links, including main experiments at N = 20, robustness to partition ratio, longer-horizon tests, and scaling experiments at N = 50 and N = 100. • We show that improved recovery is driven primarily by synchronization effort rather than by quarantine alone, and that the same parameters do not automatically scale to larger networks.
RELATED WORK Ledger and consensus protocols
Distributed ledger research spans several different agreement models. Bitcoin is the canonical longestchain ledger protocol [1], while PBFT and HoneyBadgerBFT represent the Byzantine-agreement tradition under stronger fault models and different timing assumptions [2, 9]. Other prominent directions include scalable public-ledger designs such as Algorand [10] and newer consensus families such as Avalanche [11]. Our paper does not compete with these protocols on their primary axis. Instead, it focuses on lightweight recovery under intermittent connectivity and noisy partition/rejoin dynamics.
Lightweight verification and compact-state operation
A second relevant line of work studies how to reduce the burden on lightweight participants. Examples include compact proof and light-client mechanisms such as NiPoPoWs and FlyClient [3, 12], as well as storage-reduction approaches such as Utreexo [4]. These works are close to our motivation because they also treat long history as a practical systems cost. However, their main focus is compact verification or compact state commitment, whereas our focus is node-local acceptance and post-disruption recovery under noisy links.
IoT- and DAG-oriented ledger designs
Several prior works have explored ledger designs motivated by constrained or IoT settings. The Tangle line and related DAG-ledger work study mergefriendly or high-throughput structures for machineto-machine environments [5, 13]. These systems are relevant because they also move away from the assumptions of a simple linear longest chain. Our paper differs in that we do not propose a new DAG consensus structure. Instead, we isolate a compact local acceptance rule and study how it interacts with adaptive synchronization after partitions.
Synchronization as a systems resource
Our synchronization mechanism is also loosely related to work in communication systems that treats synchronization or desynchronization as an explicit control resource. A classical example is DESYNC for self-organized desynchronization and TDMA in wireless sensor networks [14–16]. More recently, synchronization has also been combined with TOWbased resource allocation in constrained wireless settings [17]. These works are not direct precursors of our contextual-authentication rule. We cite them because they support a broader systems viewpoint in which synchronization effort itself can be adjusted in response to current operating conditions.
Resource-theoretic motivation for contextual bookkeeping
The broader motivation for our extension experiments is informed by recent information-theoretic work on fixed shared-state semantics. Kim studies classical models that must reuse a shared internal description across multiple contexts and shows, within a simple external-label simulation class, that contextual statistics can imply a nonzero external bookkeeping cost [6, 7]. A related empirical study uses the same perspective only as architectural motivation and evaluates an operational analogue rather than a literal theorem instantiation [8]. Our proofof-context extension follows the same cautious interpretation: we do not claim a theorem-level security result for the ledger protocol, but we do use the same resource-accounting viewpoint to motivate a budgetsensitive contextual-burden experiment.
3 PROBLEM SETTING AND METHOD
Operational meaning of “contextual authentication”
System model and evaluation setting
In this paper, contextual authentication is an operational notion. A node decides whether a newly observed chain extension is acceptable relative to its current local context, where the context is a compact summary of the node’s present view. Concretely, each node maintains a compact local context that includes its current head and local block graph, checkpoint metadata, a recent-history branch score, and an inconsistency estimate with a quarantine flag. Given new information received by broadcast or gossip, the node accepts and ranks candidate branches using a checkpoint-first fork-choice rule. In the main configuration used in this paper, the priority is
We target environments in which (i) nodes are resource-constrained (e.g., IoT devices and phones), (ii) network connectivity is intermittent and partitions are common, (iii) link quality is poor due to delay and packet loss, and (iv) storing and replaying full ledger history is undesirable. Our goal is not to design a full cryptocurrency stack. Instead, we isolate a lightweight protocol layer that lets nodes recover agreement after disruption while keeping only compact local state. The main question of this paper is therefore not fullhistory validity in an ideal network, but how a lightweight node should decide what to accept, and how the system should resynchronize, after partitions and under noisy links. Network and partition model. We use a discreteevent network model with probabilistic packet drops and random delays. A hard partition is imposed between two groups A and B during a fixed interval, after which the groups rejoin. The main experiments use two split ratios: 50/50 (CaseA 50 50) and 80/20 (CaseB 80 20), and we also evaluate 90/10 as an additional robustness case. We consider two network regimes: clean and noisy, where the noisy regime has larger delay and nonzero packet loss. The simulator is event-driven rather than difference-equation-based. Time advances from one scheduled event to the next, including block proposals, block deliveries, and periodic gossip ticks. Proposal times are sampled stochastically from the target block interval, while delay, jitter, packet loss, and partition intervals are given as exogenous parameters. Nodes then update local state by deterministic acceptance, scoring, quarantine, and synchronization rules. Convergence and recovery measurement. A convergence event is detected when all nodes share the same head for a sustained window. The simulator parameter controlling this window is K CONVERGE. Recovery time is measured from rejoin time (partition end) to the first detected convergence event. This is an operational recovery metric rather than a finality theorem: it measures how quickly the system returns to a stable common head after disruption.
(1) higher checkpoint level → (2) higher height → (3) higher branch score. When quarantine is active, head switching becomes more conservative. Scope note. This is not a cryptographic authentication definition. It is a protocol-level acceptance rule that can later be combined with a proof layer or other cryptographic mechanisms. Our claims in this paper are therefore about acceptance behavior, recovery, and synchronization under disruption, not about cryptographic unforgeability. Architectural motivation. Our use of compact local context is also motivated by a representational viewpoint. Recent information-theoretic work studies classical models that must reuse a shared internal description across multiple contexts. In that setting, if observable behavior remains context dependent, then reproducing the statistics may require an auxiliary contextual variable and a nonzero external bookkeeping cost [6, 7]. We do not claim that the present ledger protocol instantiates that theorem literally. We use it only as background motivation for studying recovery under compact-state constraints, and for the separate proof-of-context extension introduced later in the paper.
Overview of quarantine and adaptive synchronization
Inconsistency signal. Each node computes a recent inconsistency score from fork pressure, reorganization magnitude, and equivocation events. This signal is smoothed by an exponential moving aver-
4 age (EMA) and thresholded with hysteresis to avoid rapid toggling. Behavior under quarantine. When Q = 1, the node becomes more conservative in head switching in order to reduce oscillation under local inconsistency. Because quarantine alone does not repair missing information, it is paired with a synchronization mechanism that can increase information flow when inconsistency becomes prevalent. Ablations. We use four ablations throughout the paper: • NoQ: quarantine disabled; baseline gossip budget. • Q only: quarantine enabled; gossip budget unchanged. • Gossip only: quarantine disabled; gossip budget fixed at an aggressive level. • Both: quarantine enabled; gossip budget increased only when quarantine prevalence is high. Protocol and simulator overview. Figure 1 summarizes the interaction between node-local acceptance, adaptive synchronization, and the partition/rejoin evaluation setting. At the node level, compact local context is used to rank branches and detect inconsistency. At the system level, synchronization effort is increased only when inconsistency becomes prevalent. The simulator then evaluates how this interaction affects agreement, recovery, and synchronization-related cost proxies.
CONTEXTUAL AUTHENTICATION MODULE
• a local reputation table R[·] over proposers, • equivocation records keyed by proposer and height, • recent-window statistics for fork pressure, reorg magnitude, and equivocation, • a smoothed inconsistency estimate and a binary quarantine flag. The local state is intentionally compact. The protocol does not require a node to replay or store the full global history before making a head-selection decision. Checkpointing. Each block carries a checkpoint level cp level and checkpoint hash cp hash. The simulator supports two checkpoint modes. Let E denote the epoch length in blocks. When a proposer extends its current head to height t, the checkpoint level is updated by ( cp level(t − 1) + 1 if t mod E = 0, cp level(t) = otherwise. cp level(t − 1) The simulator also supports a time-based mode in which checkpoint epochs are defined by elapsed time rather than by block height. This mode is used only in diagnostic comparisons. The main reported configuration in this paper uses checkpointing without sticky checkpoint tie-breaking. In the final main configuration, checkpoint level is used as the primary ordering signal, while checkpoint hash is stored as metadata. We evaluated an optional checkpoint-hash sticky tie-break during development, but it degraded recovery in the current evaluation regime and is therefore not part of the final main configuration. Fork-choice and branch scoring
This section defines the contextual authentication rule as implemented in the simulator. The mechanism is node-local. It decides which chain head is acceptable from the node’s current view, using checkpoint information, recent proposer history, and local inconsistency state.
Local context state and checkpointing
Each node maintains: • a local block graph with parent pointers and a current head h, • per-block checkpoint metadata,
Given the set of visible tips T , the node selects a candidate head h⋆ by lexicographic priority: h⋆ = arg max cp level(t), height(t), branch score(t) , t∈T
with deterministic tie breaking. Branch score. For a tip t, let tailL (t) denote the last L blocks on the chain to t, where L is a fixed recent-history window. We define X branch score(t) = log 1 + max{0, R[p(b)]} b∈tailL (t)
where p(b) denotes the proposer of block b. This score is intended to be lightweight and local. It
5 Simulation setting Simulation setting N nodes, target block interval 30s, clean / noisy links hard partition from t = 1200 to t = 2400, then rejoin Node-local acceptance and recovery logic Node-local context current head h and local DAG; checkpoint metadata (cp level, cp hash); branch score from recent proposer history; inconsistency EMA I t ; quarantine flag Q
Block / gossip arrival
Update local state insert block or suffix detect equivocation update recent statistics
Checkpoint-first fork choice higher checkpoint level → higher height → higher branch score
Compute inconsistency fork pressure, reorgs, equivocation EMA + hysteresis
Head switching immediate if Q = 0; more conservative if Q = 1 Synchronization control Adaptive synchronization compute quarantine fraction q; if q ≥ 0.25, increase gossip budget normal gossip pairs = 1, quarantine gossip pairs = 4
Evaluation variants NoQ, Q only, Gossip only, Both Evaluation outputs Measured outputs final agreement (success rate), recovery time after rejoin (mean, p95), fork/reorg summaries, gossip effort, estimated byte volume
FIG. 1. Overview of the simulated protocol and evaluation flow. Each node maintains compact local context, updates an inconsistency estimate from recent local observations, selects a candidate head by checkpoint-first fork choice, and applies a more conservative switching rule when quarantine is active. At the system level, gossip effort is increased only when the fraction of quarantined nodes becomes sufficiently large. The simulator evaluates how this interaction affects final agreement, recovery after partition rejoin, and synchronization-related cost proxies.
gives a mild preference to branches that were recently extended by proposers with better recent behavior, while damping the contribution through the logarithm. Equivocation handling. If a node observes two different block IDs from the same proposer at the same height, it records an equivocation event and applies a local penalty:
• reorg recent be the maximum reorg magnitude in the recent window, • equiv recent be the number of recent equivocation events. We define √ It = 1.2 log(1 + forktop) + 0.7 reorg recent + 0.9 log(1 + equiv recent).
R[p] ← max{0, R[p] − 1.0}. Equivocation events are also added to the recent window used by the inconsistency signal.
Inconsistency, quarantine, and head switching
At each block acceptance, the node computes a snapshot inconsistency score from recent local statistics. Let: • forktop be the number of tips at the current maximum height,
The EMA is then updated by I t = αI t−1 + (1 − α)It , with α = 0.85. Hysteresis. With thresholds Ton and Toff and offstreak length S, the node enters quarantine when I t > Ton , and exits quarantine only after I t < Toff for S consecutive updates. In the experiments with quarantine enabled, we use Ton = 1.05, Toff = 0.75, and S = 25. Head switching under quarantine. Outside quarantine, the node switches immediately to the current fork-choice winner.
6 Algorithm 1: Contextual authentication on block acceptance
ADAPTIVE SYNCHRONIZATION
1. Receive block b with parent pointer b.prev.
Contextual authentication can reduce local oscillation, but it cannot resolve ambiguity if nodes do not receive enough missing information. For that reason, we couple the acceptance rule with adaptive synchronization implemented as periodic gossip.
2. If b is already known, return. 3. If b.prev is unknown, store b as an orphan and return. 4. Detect equivocation for (b.proposer, b.height). 5. Update local reputation and recent equivocation statistics.
Gossip and adaptive budget control
6. Insert b into the local block graph. 7. Compute the inconsistency snapshot It and update the EMA I t . 8. Update the quarantine flag by hysteresis. 9. Compute the candidate head checkpoint-first fork choice.
h⋆
using
10. If quarantine is active, apply the conservative head-switch rule; otherwise set h ← h⋆ . 11. If the head changed, record the reorg magnitude in the recent window. 12. Apply a small proposer reward if no equivocation penalty was triggered. FIG. 2. Contextual authentication on block acceptance.
Inside quarantine, switching is more conservative: • switch immediately if the candidate has higher checkpoint level;
At every gossip tick, provided the network is not currently partitioned, the simulator samples sender/receiver pairs. The sender transmits the missing suffix of its head chain to the receiver. The receiver first finds the highest common ancestor on the sender’s chain, then receives all subsequent blocks in order. This models a compact resynchronization channel distinct from per-block broadcast. Adaptive gossip budget. Let q be the fraction of nodes currently in quarantine. If q ≥ 0.25, the protocol uses an increased gossip budget; otherwise it uses the normal budget. In the main experiments, normal gossip pairs = 1,
quarantine gossip pairs = 4.
This is a simple feedback rule: spend additional synchronization effort only when inconsistency is sufficiently widespread.
Evaluation variants and recorded quantities
• if checkpoint levels match, switch when the candidate improves height by at least 1;
The four protocol variants used in evaluation are implemented as follows:
• if heights also match, switch only when the candidate branch score exceeds the current head by at least 0.15.
• NoQ: quarantine disabled; gossip fixed at 1 pair.
This policy is intended to reduce short-term oscillation without freezing progress completely. Reputation updates. When a block is accepted and no equivocation penalty is triggered, the proposer receives a small positive update:
• Gossip only: quarantine disabled; gossip fixed at 4 pairs.
R[p] ← R[p] + 0.05. Algorithmic summary. Figure 2 summarizes the implemented node-local acceptance procedure on block arrival. It highlights the order in which the simulator updates equivocation statistics, inconsistency EMA, quarantine state, and the final headselection decision.
• Q only: quarantine enabled; gossip fixed at 1 pair.
• Both: quarantine enabled; gossip equals 1 pair normally and 4 pairs when q ≥ 0.25. Cost quantities recorded. In addition to agreement and recovery metrics, the simulator records several synchronization-related quantities. These include mean gossip-pair usage, the mean number of gossip-transferred blocks, and an estimated total byte volume. These quantities are still simulatorside proxies rather than full protocol measurements, but they are sufficient to compare synchronization effort across variants in the current study.
7 Scope note. The protocol evaluated in the main part of the paper is the operational recovery protocol defined above. A later proof-of-context extension adds a separate budget-sensitive simulation on top of this base protocol. Those extension results should be read as preliminary resource-burden evidence, not as part of the main protocol definition.
RESULTS Experimental setup
We evaluate a discrete-event simulation of a lightweight ledger protocol with context authentication and adaptive synchronization. All main results in this section use checkpointing with sticky tie-breaking disabled (cp tiebreak=none). Unless otherwise stated, the main experiments use: (i) N = 20 nodes, (ii) simulation horizon SIM TIME=3600 seconds, (iii) target global block interval BLOCK INTERVAL=30 seconds, (iv) a partition from t = 1200 to t = 2400 seconds, (v) checkpoint epoch length EPOCH LEN=30 blocks, and (vi) convergence detection parameter K CONVERGE=30. The main and ratio suites use n = 1000 random seeds per condition. The scaling suite uses n = 500 seeds per condition for N ∈ {20, 50, 100}. The longerhorizon suite uses n = 1000 seeds per condition with SIM TIME=5400 seconds. We test two network regimes: clean (drop=0.00, delay mean=0.25, jitter=0.10) and noisy (drop=0.02, delay mean=0.80, jitter=0.20). Metrics. Success rate is the fraction of runs in which all nodes end with the same head (success end rate). Recovery time is measured from partition end (rejoin) to the first detected convergence event; we report mean and p95 (recovery mean s, recovery p95 s). Because recovery time is defined only for runs that recover, recovery plots should be read together with success rate. We also track fork and reorg summary statistics, mean simulation runtime per run in milliseconds (runtime mean ms), and an estimated communication volume (total bytes est mean). Important limitation about cost metrics. runtime mean ms is a compute proxy measured on one machine. total bytes est mean is not a packet-level trace. It is an estimate derived from transferred block counts and a fixed per-block byte estimate. We therefore use it as a relative communication indicator, not as an exact network accounting metric.
FIG. 3. Main noisy success rate under the final sticky-free configuration. Final agreement probability for the two main partition scenarios under noisy links. The high-level message is unchanged after removing sticky tie-breaking: variants with increased synchronization (Gossip only and Both) clearly outperform NoQ and Q only.
Main result: noisy networks require increased synchronization budget
Figures 3 and 4, together with Table I, show the main outcome under the final sticky-free configuration. Under clean conditions, all variants achieve high final agreement, with success rates between 0.972 and 0.985 in CaseA and between 0.975 and 0.984 in CaseB. The main differences in clean settings are in recovery time rather than final success. Under noisy conditions, the pattern is much stronger: NoQ and Q only degrade sharply, while Gossip only and Both substantially improve both success rate and recovery tails. The estimated byte volume varies only mildly across variants because it is defined from transferred block units rather than from packet-level gossip attempts. In the current simulator, many additional gossip-pair attempts do not produce many additional missing-block transfers once peers have largely synchronized, so mean gossip-pair usage is a more sensitive indicator of synchronization effort than estimated total bytes. For CaseA 50/50 under noisy links, NoQ and Q only reach only 0.591 and 0.581 success, with mean recovery times 189.891 s and 194.216 s and recovery p95 values 344.05 s and 365.10 s, respectively. By contrast, Gossip only and Both reach 0.837 and 0.848 success, with mean recovery times 77.796 s and 82.570 s and recovery p95 values 152.05 s and 172.00 s. The same qualitative result appears in CaseB 80/20 under noisy links: NoQ/Q only remain near 0.60 success, whereas Gossip only/Both reach 0.858 and 0.847 success with much shorter recovery
8 TABLE I. Main noisy results under the final sticky-free configuration. Success rate and recovery statistics for the two main partition scenarios under noisy links. The strongest pattern is that NoQ and Q only remain much worse than Gossip only and Both in both scenarios. Scenario Variant Success rate Recovery mean (s) Recovery p95 (s) CaseA 50/50 NoQ 0.591 189.891 344.05 0.581 194.216 365.10 CaseA 50/50 Q only CaseA 50/50 Gossip only 0.837 77.796 152.05 CaseA 50/50 Both 0.848 82.570 172.00 CaseB 80/20 NoQ 0.599 167.899 329.10 CaseB 80/20 Q only 0.607 169.551 338.05 0.858 69.786 154.05 CaseB 80/20 Gossip only CaseB 80/20 Both 0.847 75.046 166.00
TABLE II. Estimated synchronization effort and communication volume in the main noisy cases. gossip pairs mean summarizes synchronization effort. total bytes est mean is shown in KiB and should be interpreted as a relative estimate. The high-success variants spend substantially more synchronization effort than NoQ/Q only. Scenario Variant Success rate Recovery p95 (s) Mean gossip pairs Estimated bytes (KiB) CaseA 50/50 NoQ 0.591 344.05 2352.0 568.4 CaseA 50/50 Q only 0.581 365.10 2352.2 569.5 CaseA 50/50 Gossip only 0.837 152.05 9408.4 572.7 CaseA 50/50 Both 0.848 172.00 6711.3 574.4 CaseB 80/20 NoQ 0.599 329.10 2352.0 573.0 CaseB 80/20 Q only 0.607 338.05 2352.1 572.9 CaseB 80/20 Gossip only 0.858 154.05 9408.3 576.8 CaseB 80/20 Both 0.847 166.00 6713.9 574.2
FIG. 4. Main noisy recovery tail under the final sticky-free configuration. Recovery p95 after rejoin for the two main partition scenarios under noisy links. The low-gossip variants have much heavier tails than Gossip only and Both.
tails. The comparison between Q only and Gossip only is especially informative. Quarantine without additional synchronization does not materially improve outcomes in noisy networks. The decisive gain comes
from increased information flow. This supports the interpretation that conservative local decision making alone is not enough when links are lossy and delayed; nodes also need more context from the network. Clean networks. Even in clean settings, aggressive synchronization reduces recovery time. For example, in CaseA-clean, Gossip only reduces mean recovery from 115.587 s (NoQ) to 64.165 s and reduces recovery p95 from 183.00 s to 114.00 s, while maintaining high success (0.985). The same pattern appears in CaseB-clean, where Gossip only achieves 57.930 s mean recovery versus 88.235 s for NoQ. These clean-network improvements are smaller in final agreement because all variants already converge reliably.
Synchronization effort is aligned with improved outcomes
Figure 5 and Table II connect the performance gains to the amount of synchronization actually used. In both noisy scenarios, NoQ and Q only re-
9
FIG. 5. Synchronization effort versus success rate in the main noisy suite. Each point is one (scenario, variant) pair. Higher synchronization effort is associated with higher final agreement within this family of ablations. Both lies between the low-gossip baselines and Gossip only, as expected from an adaptive policy.
main near 2352 mean gossip pairs. Both increases this to about 6711–6714 mean gossip pairs, and Gossip only reaches about 9408 mean gossip pairs. The same ordering appears in recovery tails and, to a lesser extent, in final success. This is consistent with the intended role of adaptive synchronization: the protocol does not recover by being more conservative alone; it recovers by spending more synchronization effort when inconsistency is present. The estimated communication volume in Table II shows a milder difference than mean gossip pairs. This is expected in the current implementation because the byte estimate is derived from block transfers and a fixed per-block size, not from packet-level accounting. We therefore treat the table as supporting evidence that the improved variants spend more synchronization effort, not as a precise bandwidth benchmark.
FIG. 6. Scaling on CaseA 50/50 under noisy links: success rate. The same synchronization policies do not automatically generalize from N = 20 to N = 50 and N = 100. Increased synchronization remains better than the low-gossip baselines, but performance still degrades sharply with scale.
FIG. 7. Scaling on CaseA 50/50 under noisy links: recovery tail. Recovery p95 grows sharply with network size. The gap between high-gossip and low-gossip variants remains visible, but all variants become much slower at larger N .
not specific to one split ratio. Robustness to partition ratio (noisy, N=20)
The same qualitative pattern holds when the partition ratio is varied under noisy links. For 50/50, 80/20, and 90/10 splits, NoQ and Q only remain near the low-success regime, while Gossip only and Both remain near the high-success regime. At 90/10, for example, NoQ reaches 0.614 success and Q only reaches 0.579, whereas Gossip only and Both reach 0.839 and 0.843, respectively. Recovery tails show the same separation: at 90/10, NoQ and Q only have recovery p95 values 336.10 s and 348.05 s, while Gossip only and Both have 146.00 s and 151.00 s. This indicates that the main noisy-network result is
Scaling: the same parameters do not automatically generalize to larger N
Figures 6 and 7 evaluate CaseA 50/50 under noisy links for N = 20, 50, 100. At N = 20, the pattern is still favorable to increased synchronization. At N = 50, Both and Gossip only retain non-trivial success (0.514 and 0.558), while NoQ and Q only fall to 0.094 and 0.078. At N = 100, even the better variants remain low: Both reaches 0.194 and Gossip only reaches 0.162, while NoQ and Q only are effectively zero at 0.002. The recovery-tail figure adds an important detail.
10 At N = 50, recovery p95 is already 343.10 s for Gossip only and 388.10 s for Both, versus 1116.10 s and 1133.00 s for Q only and NoQ. At N = 100, even Both and Gossip only have recovery p95 above 1000 seconds (1019.00 s and 1031.75 s), and Q only reaches 1171.60 s. This indicates that the current parameters do not scale by themselves. Additional protocol design is needed, for example budget scaling with N , topology-aware peer selection, or hierarchical relays.
N=50 budget study: stronger synchronization restores a usable regime
To test whether the N = 50 degradation reflects an intrinsic failure of the protocol family or an underprovisioned synchronization budget, we ran a follow-up budget study under the same noisy partition/rejoin setting. We fixed the protocol to the final sticky-free configuration and swept both fixed and adaptive gossip budgets for CaseA 50/50 and CaseB 80/20. Table III reports representative operating points from this sweep, while Figures 8 and 9 show how success rate and recovery tail vary with synchronization effort. Together, these results clarify that the original N = 50 degradation was primarily a low-budget provisioning problem rather than a regime in which the protocol family becomes unusable in principle. The resulting picture is substantially more favorable than the original low-budget scaling point alone suggests. Under the low-budget baselines, N = 50 remains effectively unusable: NoQ 1 1 and Q only 1 1 stay near 0.08–0.09 success with recovery tails above 1100 s. However, once synchronization budget is increased, the same protocol family enters a substantially more usable regime. Figure 8 shows that success increases sharply as mean gossip-pair usage increases from the low-budget baseline, and that the adaptive Both curve stays close to the fixed Gossip only curve. Figure 9 shows the matching trend for recovery tails: larger synchronization budgets substantially reduce recovery p95, with adaptive synchronization remaining competitive with the strongest fixed-budget setting. The representative operating points in Table III make this comparison concrete. In particular, they show that adaptive settings remain close to the strongest fixedbudget point while requiring substantially fewer gossip pairs. For CaseA, Both 1 12 and Both 1 16 reach 0.750 and 0.772 success with recovery p95 values 193.05 s and 173.05 s, while Gossip only 16 16 reaches 0.798 success with 172.25 s recovery p95.
For CaseB, Both 1 12 and Both 1 16 reach 0.770 and 0.810 success with recovery p95 values 190.05 s and 157.20 s, while Gossip only 16 16 reaches 0.808 success with 137.05 s recovery p95. This follow-up changes the interpretation of the N = 50 result. The protocol is not failing simply because N = 50 is too large in principle. Rather, the original degradation should be read primarily as a synchronization-budget failure. Once sufficient synchronization effort is provided, N = 50 becomes practically recoverable in this simulator. A second important result is that adaptive synchronization remains competitive in efficiency. In both CaseA and CaseB, Both 1 16 achieves performance very close to Gossip only 16 16, while using about 38% fewer mean gossip pairs. At a more moderate operating point, Both 1 12 still reaches 0.750 and 0.770 success in CaseA and CaseB, respectively, while using about 53% fewer mean gossip pairs than Gossip only 16 16. Thus the adaptive policy is not only qualitatively better than the low-budget baselines; it also remains attractive as an effort-saving design relative to permanently aggressive synchronization.
Longer simulation horizon does not fix noisy failures by itself
Figure 10 compares the default 3600-second horizon with a 5400-second horizon in the noisy main scenarios. The main conclusion does not change. For CaseA-noisy, NoQ improves only slightly from 0.591 to 0.601, while Gossip only remains high at 0.854 and Both reaches 0.825. For CaseB-noisy, NoQ changes from 0.599 to 0.613, while Gossip only remains high at 0.855 and Both remains at 0.822. Thus the low-gossip failures are not explained simply by insufficient wall-clock time. This longer-horizon comparison strengthens the interpretation of the noisy failure cases. The protocol does not simply need more time to recover. Instead, when synchronization effort remains too low, some runs stay trapped in poor information states for much longer. Sticky-free checkpoint-mode robustness. We also compared the final sticky-free configuration under height-based and time-based checkpointing; the detailed results are reported in Table V(Appendix). Across the main noisy conditions, this change did not materially alter the conclusions: the same separation between low-synchronization variants (NoQ, Q only) and stronger-synchronization variants (Gossip only, Both) remained visible in both suc-
11 TABLE III. Representative operating points from the N = 50 noisy budget study. Low-budget baselines collapse, whereas stronger synchronization restores substantially better success and recovery. The adaptive setting Both 1 16 remains close to the strongest fixed setting while using much less synchronization effort. Case
Variant
Success rate Recovery p95 (s) Mean gossip pairs Pair reduction vs. Gossip only 16 16
CaseA 50/50 NoQ 1 1 CaseA 50/50 Q only 1 1 CaseA 50/50 Both 1 12 CaseA 50/50 Both 1 16 CaseA 50/50 Gossip only 16 16
0.094 0.078 0.750 0.772 0.798
1133.00 1116.10 193.05 173.05 172.25
2352.43 2352.52 17672.05 23242.44 37633.83
– – 53.0% less 38.2% less baseline
CaseB 80/20 NoQ 1 1 CaseB 80/20 Q only 1 1 CaseB 80/20 Both 1 12 CaseB 80/20 Both 1 16 CaseB 80/20 Gossip only 16 16
0.088 0.084 0.770 0.810 0.808
1103.75 1122.40 190.05 157.20 137.05
2352.18 2352.60 17704.77 23287.34 37633.41
– – 52.9% less 38.1% less baseline
Success rate
0.8
0.6
0.4
0.2
0
0
0.5
1
1.5
2 2.5 Mean gossip pairs
CaseA fixed (Gossip only) CaseB fixed (Gossip only) Low-budget baselines (NoQ/Q only)
3
3.5
4 4
·10
CaseA adaptive (Both) CaseB adaptive (Both)
FIG. 8. N = 50 noisy budget study: success rate versus synchronization effort. The low-budget baselines remain near failure, while increased synchronization restores substantially higher success. Adaptive synchronization (Both) stays close to the fixed high-budget curve while using much less synchronization effort.
cess rate and recovery tail. Over all 16 main conditions, the largest absolute success-rate difference between the two checkpoint modes was 0.025, and the largest recovery-p95 difference was 8.10 s. This indicates that, once sticky checkpoint tie-breaking is removed, the main empirical result is robust to the choice between height-based and time-based checkpoint epochs.
BUDGET-SENSITIVE PROOF-OF-CONTEXT EXTENSION
This section reports a separate proof-of-context extension built on top of the main recovery protocol. Its purpose is not to replace the main protocol with a cryptographic proof system, but to test a narrower question: whether a budget-sensitive challenge over multiple active contexts creates a measurable contextual bookkeeping burden. The motivation for this extension is a resourceaccounting view of context dependence. Recent
12 1,200
Recovery p95 (s)
1,000 800 600 400 200 0
0.5
1
1.5
2 2.5 Mean gossip pairs
CaseA fixed (Gossip only) CaseB fixed (Gossip only) Low-budget baselines (NoQ/Q only)
3
3.5 ·10
4 4
CaseA adaptive (Both) CaseB adaptive (Both)
FIG. 9. N = 50 noisy budget study: recovery tail versus synchronization effort. The low-budget baselines have extremely heavy recovery tails. Both fixed and adaptive budget increases reduce recovery tail substantially, and the adaptive curve remains competitive with the fixed high-budget setting.
terpretation: it is a budget-sensitive resource experiment, not a cryptographic proof system.
Design rationale and ideal protocol
FIG. 10. Longer-horizon comparison under noisy links. Extending the simulation horizon from 3600 s to 5400 s does not remove the gap between the lowgossip and high-gossip variants. The difficult failures in NoQ/Q only are therefore structural in this regime rather than a simple timeout artifact.
work on fixed shared-state semantics argues that, when context-dependent behavior must be reproduced without allowing the shared internal description itself to split by context, additional contextual bookkeeping may become unavoidable [6, 7]. A related empirical study in sequential decision making used the same perspective only as architectural motivation and evaluated an operational analogue rather than a literal theorem instantiation [8]. Our proofof-context extension follows the same cautious in-
The original motivation behind this extension is stronger than the simplified simulator reported in this paper. The intended goal is a contextdependent authentication mechanism in which a synchronized participant can answer cheaply, while an adversary that must remain compatible with many competing contexts incurs a substantially larger bookkeeping cost. Abstract interface of the idealized proof layer. The notation in this subsection is intentionally schematic, because the present paper does not implement the full proof layer. Here H(·) denotes a collision-resistant hash function. The remaining functions describe an abstract interface for the idealized protocol: Build(·) constructs a contextdependent memory object from the derived seed, Commit(·) maps that object to a short commitment, Open(·, ·) returns a proof for a verifier-specified challenge, and Verify(·, ·, ·) checks whether the proof is consistent with the commitment and the challenge. In this notation, At is the context-dependent memory object built by the prover, Rt is its short commitment, chalt is the verifier’s challenge, and πt is
13 the proof returned in response. Thus these symbols should be read as an abstract interface for the idealized design, not as a fully instantiated cryptographic construction. At a high level, let St denote the compact shared state at time t, let Ct denote the current interaction context, and let Ot−1 denote the previous accepted outcome or checkpoint summary. An idealized protocol derives a context-dependent seed seedt = H(St ∥ Ot−1 ∥ Ct ),
small. If contextual ambiguity persists across multiple rounds, then an attacker may need to keep several overlapping context histories alive at once. In that regime, the required bookkeeping burden can grow much faster than the compact local state maintained by an honest node, because the adversary must remain compatible with multiple context trajectories rather than with a single synchronized one.
Simplified simulation used in this paper
and then proceeds through the abstract interface At = Build(seedt ),
Rt = Commit(At ),
followed by a challenge-response step πt = Open(At , chalt ),
Verify(Rt , chalt , πt ) = 1.
Here BuildCost denotes the one-context cost of constructing and maintaining the committed memory object for a single active context. The intended asymmetry is that an honest participant needs to maintain only the currently relevant context, whereas an adversary that wishes to remain compatible with many plausible contexts must maintain multiple candidate committed objects. If Bt denotes the number of simultaneously plausible branches or contexts and Dt denotes the relevant contextual depth, then the adversarial bookkeeping burden is intended to scale roughly as Costadv (t) ∝ Bt · Dt · BuildCost, whereas the honest participant pays only the singlecontext cost Costhon (t) ∝ BuildCost. The qualitative claim is therefore not that the adversary is impossible, but that remaining compatible with many contexts becomes increasingly expensive as contextual ambiguity accumulates over time. If Xt denotes the set of still-plausible contexts at time t, then even a minimal contextual index requires H(Mt ) ≳ log |Xt |, where Mt denotes the auxiliary contextual bookkeeping needed to distinguish among those contexts. The idealized proof-of-context mechanism is intended to make that burden operational by tying acceptance to context-dependent commitments rather than to a single context-free state. As partitions, delay, and equivocation accumulate, the set of still-plausible contexts need not remain
The present paper does not implement the idealized proof layer literally. In particular, we do not build a DRG-based memory object, we do not compute Merkle opening proofs, and we do not prove a cryptographic soundness theorem for the ledger setting. Instead, we evaluate a simplified budgetsensitive simulation that preserves the main systems intuition while remaining executable in the current simulator. In this simplified version, the underlying recovery protocol is kept fixed and only an additional shadow proof-of-context layer is added. The attacker is modeled as having a bounded budget on the number of contexts that can be tracked simultaneously. At each proof event, the challenge samples multiple active contexts and asks whether the attacker covers them. The version reported in this paper uses a uniform-active challenge with two targets per challenge. This makes the acceptance probability explicitly budget sensitive: an attacker that tracks only one or two contexts may fail even if it can still follow the dominant final branch. The purpose of the simplified experiment is to test whether a budget-sensitive challenge over multiple active contexts produces a measurable contextual bookkeeping burden in the current partition/rejoin setting. Accordingly, the present results should be read as evidence for a contextual bookkeeping burden, not as a complete authentication theorem.
Extension setup
The extension simulation is evaluated on the CaseA 50/50 noisy condition with the Both synchronization variant. The main protocol dynamics are fixed. Only the attacker’s context budget is varied. The challenge mode is uniform active with two targets per challenge, so the attacker must cover multiple currently active contexts rather than only a single canonical one.
14
FIG. 11. Proof-of-context extension: success vs. attacker budget. Mean challenge success, rejoin success, and end-of-run success are shown as functions of attacker context budget. The clearest threshold effect appears at rejoin, where small budgets fail frequently.
mean required peak memory for full context coverage is about 5.28 MiB. In this setting the required peak burden is about 7.89 times the honest-node peak. Third, the budget-sensitive challenge produces a visible threshold effect. Mean challenge success rises from 0.568 at budget 1 to 1.000 at budget 16. The pattern is stronger at rejoin: rejoin success is 0.000, 0.036, 0.219, 0.818, and 1.000 for budgets 1, 2, 4, 8, and 16, respectively. This is the main difference from the earlier simplified challenge: a bounded-budget attacker is no longer accepted almost automatically. The same qualitative behavior also appears in the additional CaseB 80/20 noisy validation. In that setting, the mean number of required contexts still peaks near rejoin (9.59 at peak and 8.57 at rejoin on average), and the required peak memory remains much larger than the honest-node peak (about 5.74 MiB versus 0.71 MiB, or about 8.13×). The budget-sensitive challenge again shows a clear threshold effect: mean challenge success rises from 0.581 at budget 1 to 1.000 at budget 16, while rejoin success rises from 0.000 to 1.000 over the same range. This indicates that the resource-burden pattern is not specific to the 50/50 split and persists in the 80/20 noisy regime as well.
Interpretation and limitation
FIG. 12. Proof-of-context extension: peak memory burden. Stored peak context memory rises with attacker budget and approaches the required peak memory for full context coverage. The gap between honest-node peak memory and full required coverage is substantial in this setting.
Extension results
Table IV and Figures 11–12 summarize the results. Three observations are important. First, the burden concentrates around rejoin rather than at the final settled state. Across all budgets, the mean number of required contexts peaks at 9.29, and the mean number required at rejoin is 8.57, while the final mean is close to one context. This means the extension is probing the unstable period after rejoin, not mainly a final-state property. Second, the contextual memory burden is substantially larger than honest-node peak memory. The mean honest-node peak is about 0.67 MiB, while the
The correct interpretation of these results is limited but still useful. The extension supports a resource-burden reading: under noisy partition/rejoin dynamics, covering multiple active contexts may require substantially more context memory than the honest node’s compact local state, and small context budgets fail much more often around rejoin. At the same time, the experiment does not yet implement the full intended proof layer. There is no DRG construction, no Merkle proof, and no cryptographic security claim. Accordingly, the extension results should be read as preliminary evidence for contextual bookkeeping burden, not as a formal authentication theorem.
Other extension directions
We do not develop all candidate contextauthentication extensions in the present paper. A context-suffix challenge would be closer to the current recovery protocol and would directly test whether a peer remains synchronized with the cur-
15 TABLE IV. Proof-of-context extension results under a budget-sensitive active-context challenge. The attacker budget is the maximum number of contexts that can be tracked simultaneously. Memory values are reported in MiB.
Budget Chall. succ. Rejoin succ. End succ. Stored peak Required peak Peak ratio Peak ctx. Rejoin ctx. 1 0.568 0.000 0.840 0.67 5.28 7.89 9.29 8.57 2 0.717 0.036 1.000 1.33 5.28 7.89 9.29 8.57 4 0.835 0.219 1.000 2.31 5.28 7.89 9.29 8.57 8 0.984 0.818 1.000 4.42 5.28 7.89 9.29 8.57 16 1.000 1.000 1.000 5.28 5.28 7.89 9.29 8.57
rent suffix after rejoin. A checkpoint-attestation design would move the system toward a signaturebased mechanism and would therefore change the paper’s scope more substantially. A quarantinetriggered handshake would remain fully operational and could be attractive as a lightweight systems extension. We chose to study the proof-of-context extension in more detail because it is the clearest vehicle for examining contextual bookkeeping burden under bounded adversarial resources.
DISCUSSION What the ablations imply
The central result of the paper is that quarantine alone is not enough in noisy partition/rejoin settings. Across the main experiments, Q only remains close to NoQ in both final agreement and recovery tails, whereas Gossip only and Both improve both. This suggests that, in the current protocol, ambiguity after disruption is limited primarily by missing information rather than by insufficient local caution. A node may become more conservative when inconsistency is detected, but without additional synchronization it still lacks the information needed to resolve competing branches reliably. This also clarifies the operational meaning of contextual authentication in our setting. The mechanism is useful as a lightweight acceptance rule, but it should not be interpreted as a substitute for synchronization. Compact local context remains useful for fork choice and inconsistency detection, but reliable recovery still depends on receiving enough missing information after rejoin.
Why adaptive synchronization is still useful
Among the four variants, Gossip only often gives the best recovery-time tails. However, it does so by
using a larger synchronization budget all the time. The role of Both is different: it approximates a policy that keeps synchronization effort low in normal periods and increases it only when inconsistency becomes prevalent. Our simulator now records synchronizationrelated proxies, including mean gossip-pair usage, gossip-transferred blocks, and estimated total byte volume. These are still simulator-side estimates rather than full protocol measurements, but they are sufficient to support the qualitative interpretation of Both as an adaptive compromise. In the current data, Both usually recovers substantially better than low-budget variants, while avoiding the permanently aggressive behavior of Gossip only. This is exactly the design role we intended for it.
Sticky tie-breaking as an excluded design option
During development, we also evaluated an optional checkpoint-hash sticky tie-break intended to reduce oscillatory switching among equal-checkpoint branches. In the current evaluation regime, however, that mechanism did not improve recovery and often made it worse, especially when applied too broadly. For this reason, the final main configuration reported in the paper uses checkpointing without sticky checkpoint tie-breaking. We view sticky tie-breaking as a design option that may still be worth revisiting under other regimes, but it is not part of the final protocol configuration supported by the present results. A further robustness check supports this interpretation. When sticky checkpoint tie-breaking is disabled, switching the checkpoint mode from heightbased to time-based does not materially change the main conclusions. The separation between lowsynchronization and high-synchronization variants remains, and the resulting differences are small relative to the main noisy-network gaps. This strengthens the conclusion that the earlier degradation was
16 driven primarily by sticky tie-breaking rather than by checkpoint activation itself.
Longer time does not solve an information problem
The longer-horizon experiments are useful because they rule out a simple alternative explanation. If the failures of NoQ and Q only were mainly due to insufficient time after rejoin, then extending the simulation horizon should have substantially closed the gap. Instead, the gap remains. This indicates that the low-synchronization failures are structural in the current noisy setting: the system is not merely slow, but under-informed.
Scaling limitations
At N = 50 and N = 100, the same parameters that work at N = 20 do not automatically remain effective. Even the stronger synchronization variants degrade substantially as the network grows. This means that the current protocol should not be read as a plug-and-play scalable solution. Rather, it should be read as evidence that lightweight contextual acceptance can be useful, but only when paired with synchronization policies that are themselves designed for scale. Several directions follow naturally from this observation. One is explicit budget scaling with network size. Another is topology-aware peer selection instead of uniformly sampled gossip pairs. A third is some form of hierarchy or relay structure that reduces the burden of global resynchronization. These are systems questions rather than minor parametertuning questions, and the scaling results make that point clearly. We additionally reran the scaling experiment with 1000 seeds to check whether the scaling trend was sensitive to sampling variability. The qualitative conclusion was unchanged: stronger-synchronization variants still remained well above the low-gossip baselines at N = 50 and N = 100, while all variants degraded substantially with network size. We therefore keep the original 500-seed figures for consistency of presentation and use the 1000-seed rerun only as a robustness check against small-sample effects. A useful next question is whether the required synchronization budget grows according to a simple scaling law in N , or whether larger deployments will require more structural changes than a single budget
rule can provide. For example, one possible hypothesis is that the gossip budget should increase sublinearly with network size, but our current results are not yet sufficient to identify a reliable scaling law. Implication of the N = 50 budget study. The follow-up N = 50 budget study clarifies that the original scaling failure should not be read as showing that the protocol family is intrinsically unusable at that size. Rather, it shows that the original low-budget parameterization was insufficient for the noisy partition/rejoin regime. Once synchronization budget is increased, the same protocol family reaches a substantially more usable operating region, with success rates around 0.75–0.81 and recovery p95 values around 157–193 s, depending on case and budget. Moreover, the adaptive setting remains competitive with the strongest fixed setting while using substantially fewer gossip pairs. We therefore interpret the scaling result as evidence that the key design problem at larger N is synchronization provisioning, not the irrelevance of the contextual-authentication approach itself.
Security scope and the role of the proof-of-context extension
This paper does not claim a cryptographic authentication theorem. The contextual authentication rule studied here is a protocol-level acceptance mechanism. It tells us how a lightweight node chooses a plausible head from its current local view; it does not by itself define unforgeability, secrecy, or a signaturebased proof system. Section should be read in that scope. The proof-of-context extension do not implement a full DRG/Merkle proof layer, and they do not prove cryptographic soundness. What they provide is narrower but still informative: a budget-sensitive proofof-context simulation in which an attacker must cover multiple active contexts. In that simulation, the resource burden concentrates around rejoin rather than at the final settled state, and small context budgets fail much more often at rejoin than at the end of the run. We therefore interpret Section as preliminary evidence for a contextual bookkeeping burden, not as a replacement for a formal security proof. This reading is consistent with recent work that treats contextuality under fixed shared-state semantics as a source of explicit external bookkeeping cost rather than only as a binary nonclassical anomaly [6, 7]. It is also consistent with recent empirical work that used the same theorem only as a moti-
17 vating perspective and interpreted I(C; O | S) as an operational probe rather than as a literal numerical verification of the theorem [8]. We adopt the same discipline here: The proof-of-context extension is intended as a resource-burden analogue for adversarial context tracking, not as a full theorem-level security statement. This distinction is important because the main protocol should be evaluated as a recovery and synchronization mechanism under disruption, not as a completed cryptographic authentication scheme.
Limitations and next steps
The main limitations of the current study are straightforward. First, the synchronization-cost quantities are still simulator-side proxies. They are useful for comparing variants, but they are not yet a full implementation-level cost analysis. Second, convergence is measured operationally through sustained common-head agreement rather than through a stronger finality theorem. Third, the extension experiments remain simplified resource models rather than deployable proof layers. These limitations point to a concrete next-step agenda. At the systems level, the most important next step is better synchronization design for larger networks, including scaling-aware budgets and better peer selection. A particularly important open question is whether synchronization effort can be scaled with network size according to a simple policy, or whether larger deployments will require more structural changes such as topology-aware peer selection or hierarchical relays. At the measurement level, the next step is more explicit accounting of protocol traffic and state costs. At the proof-layer level, the next step is to replace the current extension approximation with a stronger mechanism in which context-dependent acceptance becomes a formally stated resource-bounded authentication game. Finally, the present noisy regime should be read as a representative disturbed setting rather than as an extreme worst-case stress test, and more severe loss rates remain an important direction for future evaluation.
CONCLUSION
We studied a lightweight ledger protocol for intermittent and noisy networks, motivated by IoT and mobile settings in which full-history verification is costly and partitions are common. The protocol
combines an operational form of contextual authentication with adaptive synchronization: nodes select a chain head from compact local context, and synchronization effort increases only when inconsistency becomes prevalent. The main empirical result is clear. Under noisy partition/rejoin dynamics, conservative decision logic alone is not enough. In our experiments, variants without increased synchronization budget (NoQ and Q only) show substantially lower final agreement and much worse recovery tails, while variants with stronger synchronization (Gossip only and Both) recover more reliably and more quickly. This means that recovery in the current design is limited primarily by information availability, not only by local acceptance policy. Our additional experiments also show two limits of the current approach. First, simply extending the simulation horizon does not remove the failures of low-synchronization variants under noisy conditions. Second, parameters that work at N = 20 do not automatically generalize to N = 50 and N = 100. These results indicate that larger deployments will require explicit design changes such as budget scaling, improved peer selection, or hierarchical relay structure. The contribution of this paper is therefore not a cryptographic authentication theorem. It is a systems result about protocol-level acceptance and recovery under disruption. The current evidence supports the following claim: compact local context can be used to guide fork choice, but reliable recovery after partition still depends on supplying enough synchronization bandwidth at the right time. As a preliminary extension, we also evaluated a budget-sensitive proof-of-context simulation that treats adversarial tracking as a contextual bookkeeping problem. Those results suggest that the resource burden concentrates around rejoin and can exceed honest-node peak context memory by a substantial factor. However, this extension remains a simplified resource model rather than a cryptographic proof layer. Future work should focus on three directions: (i) direct network-cost measurement with explicit message and byte counts, (ii) synchronization policies for larger networks, including explicit budget scaling and topology-aware peer selection, and (iii) a stronger proof layer that turns context-dependent recovery into a formally stated resource-bounded authentication mechanism.
18 DATA AVAILABILITY STATEMENT
The code, evaluation scripts, aggregated result files, and specification document necessary to reproduce the main tables and figures are publicly available on Zenodo at https://doi.org/10.5281/ zenodo.19462900. The corresponding source repository is available at https://github.com/songju1/ Contextual-Chain. Additional intermediate logs and auxiliary files are available from the corresponding author upon reasonable request.
ACKNOWLEDGMENTS
This work was supported by SOBIN Institute LLC under Research Grant SP009. The author used ChatGPT (OpenAI) for English editing and takes full responsibility for the final version.
19 Checkpoint-mode robustness
TABLE V. Sticky-free checkpoint-mode comparison in the main noisy suite. Height-based and timebased checkpointing give very similar results once sticky checkpoint tie-breaking is removed. Scenario Variant Success (height) Success (time) Recovery p95 height (s) Recovery p95 time (s) CaseA 50/50 NoQ 0.591 0.575 344.05 352.15 CaseA 50/50 Q only 0.581 0.606 365.10 366.05 0.837 0.860 152.05 153.10 CaseA 50/50 Gossip only CaseA 50/50 Both 0.848 0.838 172.00 169.05 CaseB 80/20 NoQ 0.599 0.611 329.10 334.35 0.607 0.621 338.05 330.05 CaseB 80/20 Q only CaseB 80/20 Gossip only 0.858 0.867 154.05 148.05 CaseB 80/20 Both 0.847 0.838 166.00 159.00
20
∗
[email protected] [1] Satoshi Nakamoto. Bitcoin: A peer-to-peer electronic cash system. White paper, 2008. [2] Andrew Miller, Yu Xia, Kyle Croman, Elaine Shi, and Dawn Song. The honey badger of BFT protocols. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pages 31–42. ACM, 2016. [3] Benedikt B”unz, Lucianna Kiffer, Loi Luu, and Mahdi Zamani. Flyclient: Super-light clients for cryptocurrencies. In 2020 IEEE Symposium on Security and Privacy (SP), pages 928–946. IEEE, 2020. [4] Thaddeus Dryja. Utreexo: A dynamic hash-based accumulator optimized for the bitcoin UTXO set. Cryptology ePrint Archive, Paper 2019/611, 2019. [5] Serguei Popov. The tangle. IOTA White Paper, 2017. [6] Song-Ju Kim. Contextuality as an external bookkeeping cost under fixed shared-state semantics. arXiv preprint arXiv:2601.20167, 2026. [7] Song-Ju Kim. Contextuality from single-state ontological models: An information-theoretic no-go theorem. arXiv preprint arXiv:2602.16716, 2026. [8] Song-Ju Kim. Contextual control without memory growth in a context-switching task. arXiv preprint arXiv:2604.03479, 2026. [9] Miguel Castro and Barbara Liskov. Practical byzantine fault tolerance. In Proceedings of the Third Symposium on Operating Systems Design and Implementation (OSDI), pages 173–186. USENIX, 1999.
[10] Yossi Gilad, Rotem Hemo, Silvio Micali, Georgios Vlachos, and Nickolai Zeldovich. Algorand: Scaling byzantine agreements for cryptocurrencies. In Proceedings of the 26th Symposium on Operating Systems Principles, pages 51–68. ACM, 2017. [11] Team Rocket. Snowflake to avalanche: A novel metastable consensus protocol family for cryptocurrencies. Technical report / white paper, 2019. [12] Aggelos Kiayias, Andrew Miller, and Dionysis Zindros. Non-interactive proofs of proof-of-work. In Financial Cryptography and Data Security (FC 2020), volume 12059 of Lecture Notes in Computer Science, pages 505–522. Springer, 2020. [13] Yixin Li, Bin Cao, Mugen Peng, Long Zhang, Lei Zhang, Daquan Feng, and Jihong Yu. Direct acyclic graph-based ledger for internet of things: Performance and security analysis. IEEE/ACM Transactions on Networking, 28(4):1643–1656, 2020. [14] Julius Degesys, Ian Rose, Ankit Patel, and Radhika Nagpal. DESYNC: Self-organizing desynchronization and TDMA on wireless sensor networks. In Proceedings of the 6th International Symposium on Information Processing in Sensor Networks, pages 11–20. ACM/IEEE, 2007. [15] Ueon-Sang Yu, Hyung-Ho Choi, and Jung-Ryun Lee. Kuramoto-desynch: Distributed and fair resource allocation in a wireless network. IEEE Access, 7:104769–104776, 2019. [16] Hiroyuki Yasuda, Takahito Mitsui, Aohan Li, Kazuyuki Aihara, and Mikio Hasegawa. Decentralized TDMA for IoT networks based on synchronization theory with intermittent communication. Discover Artificial Intelligence, 2026. in press. [17] Song-Ju Kim, Hiroyuki Yasuda, Ryoma Kitagawa, and Mikio Hasegawa. Resource allocation method using tug-of-war-based synchronization. IEICE Communications Express, 10(12):1021–1025, 2021.