Preprints.org logo
Preprint
Article

This version is not peer-reviewed.

Memory-Driven Trust: A Unified Foundation for Self-Verifiability in Digital Infrastructure

Submitted:

27 September 2026

Posted:

29 September 2026

You are already at the latest version

Abstract
The Internet's critical infrastructure relies on centralized trust authorities, and their repeated failures expose a structural fragility: these systems lack self-verifiability — the property that any party relying on a claim can independently verify that event or state claim without depending on any third-party authority. Here we propose the Memory-Driven Trust Paradigm, which endows digital infrastructure with self-verifiability through verifiable memory, shifting the fundamental question of trust from "whom to trust" to "what to verify." We define verifiable memory as cryptographically committed, independently verifiable traces of discrete events and states, and formalize it as an "Accumulate–Anchor–Verify" triadic structure: a unified framework neutral to the underlying commitment mechanism, revealing that previously fragmented self-verifiable schemes — blockchains, certificate-transparency logs, and verifiable storage — share the same deep logic. We characterize necessary and sufficient conditions for verifiable memory and give a constructive proof: an epoch hash chain with geometric staged scheduling reduces the worst-case membership witness from Θ(√n) to Θ(n¹ᐟ³) even under unbounded append; we further establish a mechanism-dependence boundary across verification dimensions, closure of constructions under composition, and a verification-baseline reset via anchoring. We instantiate the framework as four kinds of memory — blockchains for transaction memory, message chains for transmission memory, key chains for protection memory, and verifiable AI memory for inter-agent trust — of which the blockchain and its supporting systems have been validated in real-network deployment, and the message chain and key chain have undergone prototype evaluation and comparative experiments. This work establishes self-verifiability as a foundational property of digital infrastructure and provides a verifiable trust foundation for the AI-mediated digital era.
Keywords: 
self-verifiability
;  
verifiable memory
;  
memory-driven trust
;  
cryptographic accumulator
;  
blockchain
;  
message chain
;  
key chain
;  
verifiable AI memory
Subject: 
Computer Science and Mathematics  -   Security Systems

Introduction

The Internet’s critical infrastructure—domain name systems (DNS), certificate authorities (CAs), and resource public key infrastructure (RPKI)—relies on centralized trust authorities. DNS relies on a hierarchically centralized chain of trust that has been compromised repeatedly in large-scale attacks [1,2]; certificate issuance concentrates global authentication in a small number of CAs, whose compromise can trigger worldwide man-in-the-middle attacks [3]; and inter-domain routing, together with RPKI, remains perpetually exposed to prefix hijacking, which has caused traffic redirection at national scale [4]. Meanwhile, the underlying IP network was designed for connectivity rather than security [5,6]: it is inherently insecure and difficult to trace after the fact, leaving accountability to ad hoc log stitching. These failures share a single root—the absence of self-verifiability. By self-verifiability we mean the following property: any party relying on a claim can independently verify that event or state claim without depending on any third-party authority. Today’s infrastructure instead requires users to accept an authority’s word: trust is conferred, not verified. Recent research on verifiable databases corroborates this gap: existing systems often must introduce trusted third parties to strengthen verifiability, and self-verifiability remains elusive [25].
The advent of generative AI has pushed this structural fragility beyond the infrastructure layer. When content creators and information sources themselves may be untrustworthy, the absence of verifiable provenance erodes the informed decision-making of humans and autonomous agents alike [7]. Industry responses—such as cryptographic content-provenance standards [8]—acknowledge the severity of the problem but remain fragmented across application domains.
The idea of cryptographically linking time-ordered records was established three decades ago [9], and a series of subsequent milestones—a peer-to-peer electronic system without trusted intermediaries [10], publicly auditable certificate transparency logs [11], provable data possession at untrusted stores [12], and efficient tamper-evident data structures [13]—each demonstrated fragments of self-verifiability in isolation. The term itself has previously appeared only descriptively—in self-certifying naming [26] and in self-verifiable security design for industrial control systems [27]—and has never been formalized as a property of digital infrastructure.
Can trust be built entirely on cryptographic verification of historical fact, without any pre-installed trusted authority? Here we answer this question affirmatively by proposing the Memory-Driven Trust Paradigm. We define verifiable memory as cryptographically committed, independently verifiable traces of discrete events and states, and we reveal that these seemingly unrelated efforts share a single deep logic: turning discrete events and states into independently verifiable traces. We formalize this logic as an “Accumulate–Anchor–Verify” triadic structure—a unified mathematical framework neutral to the underlying commitment mechanism, whether realized as a hash chain, a Merkle tree, or a more general cryptographic accumulator—and we characterize necessary and sufficient conditions for verifiable memory: an epoch hash chain with geometric staged scheduling reduces the worst-case membership witness from Θ(√n) to Θ(n1/3) even under unbounded append, together with a mechanism-dependence boundary across verification dimensions, closure of constructions under composition, and a verification-baseline reset via anchoring. We instantiate the framework as four kinds of memory—blockchains, which record data-transaction memory to rebuild infrastructure trust; message chains, which encode data-transmission memory and endow IP communication with endogenous security and cryptographic traceability; key chains, which preserve data-protection memory and enable privacy-preserving key evolution; and verifiable AI memory for inter-agent trust. Of these, a blockchain system built on the framework has been validated in real-network deployment, the message chain and key chain have undergone prototype evaluation and comparative experiments, and verifiable AI memory provides a cryptographic foundation for inter-agent trust, extending the same mechanistic basis to future directions such as training provenance and inference auditing.
By grounding trust in the verification of memory rather than in faith in institutions, this work establishes self-verifiability as a foundational property of digital infrastructure—supported by the necessary-and-sufficient characterization of verifiable memory, the epoch construction with provably sublinear witness growth, a unified instantiation across three infrastructure memories and AI memory, real-network deployment validation, and prototype comparative experiments—and provides a common research language for cryptography, distributed systems, communication networks, and AI security, laying a verifiable trust foundation for the AI-mediated digital era.

Results

The Memory-Driven Trust Paradigm
The Introduction proposed the concept of verifiable memory; this section builds the Memory-Driven Trust Paradigm upon it. Here “memory” means traces of discrete events and states that accumulate along the time dimension and can be traced and verified—encompassing both events that have occurred and states that already exist; it is verifiable cryptographic memory, not an ordinary log that its storer can modify without leaving marks. The “verifiable” in verifiable memory carries a precise operational meaning—it must support three kinds of verification queries: integrity (the historical chain has not been tampered with, broken, or skipped), existence (an event is indeed included, or indeed not included), and temporal ordering (the order of events has not been altered). Integrity is mandatory, and each instantiation covers a subset according to its verification needs; these three dimensions constitute the operational content of verifiable memory.
Self-verifiability is the target property the paradigm endows upon digital infrastructure. Its “verifiable” is an authority-independence criterion—any participant (that is, any party relying on the event or state claim, whether the system is open or permissioned) can independently verify the claim without depending on any third-party authority; authorities may exist, but their behavior and any breach must be independently checkable and exposable by the relying parties. Self-verifiability does not presuppose a unique implementation route: redundant arbitration, deterministic re-derivation, and proof-carrying approaches likewise avoid reliance on authorities, yet they verify only “the present” and give up retrospection over the evolution of events and states; this work takes the verifiable-memory route—cryptographically committed traces of events and states that allow verification to reach back to anything that has happened or has existed. The “verifiable” of verifiable memory, in turn, is the operational capability for the three kinds of queries described above; the two senses of “verifiable” each keep their place and are hinged together by legality condition (3) of the triadic structure, formalized in the next section.
The paradigm’s core proposition is to turn “whom to trust” into “what to verify.” The conclusions of existing trust patterns are all delivered by authorities or intermediaries and can only be accepted, never independently rechecked—reputation systems compute from history merely a probabilistic belief about an entity’s future behavior [29], and zero-trust architecture’s “never trust, always verify”[28] remains identity-centric and dependent on online authorities (for detailed delimitation, see Supplementary Information, to be released with the formal submission). Memory-driven trust instead takes verifiable memory as the object of verification—traces of facts, already happened or already existing, committed by the system itself, whose conclusions are deterministic and publicly recomputable; verification requires no authority, online or offline, and thus achieves self-verifiability. In this paradigm, a user no longer asks “whom should I trust,” but executes three verification queries with definite answers—does the integrity proof hold? Is the existence proof valid? Does the order of occurrence agree with the record? Trust thereby turns from a “belief” into a “computation.” As shown in Figure 1, this logic takes the form of a mechanism-neutral “Accumulate–Anchor–Verify” triadic structure; its formal definition and capability characterization appear in the next section.
The triadic structure of verifiable memory
We formalize verifiable memory as a life cycle of three orthogonal operations—Accumulate, Anchor, Verify (Definition 3.1: a legitimate instance must simultaneously satisfy the three legality conditions of accumulation, anchoring, and verification; full statement in Methods); the three operations each answer an independent question—how history is compressed, when a state becomes a trusted baseline, and what a verifier can ask. Accumulation: the accumulate operation incrementally absorbs discrete events or states into an aggregate commitment—adding a new element does not change the commitment to existing elements; sensitivity to arrival order is an instance property, determined by verification needs. Anchoring: the anchor operation outputs a publicly verifiable cryptographic anchor; any deviation from the anchor implies that history has changed. Verification: the verify operation independently answers integrity queries without relying on any third-party authority, and on this basis may support existence and temporal-ordering queries. The authority independence of verification (Definition 3.1, condition (3); see Methods) is the operationalization of self-verifiability on the verifiable-memory route: the concept thereby turns from a property goal into a decidable mathematical condition, and constructions lacking authority independence do not constitute legitimate instances (counterexamples in SI, to be released with the formal submission). The triad is neutral to the underlying commitment mechanism—whether state is carried by a hash chain, a Merkle tree, or a cryptographic accumulator, satisfying the three legality conditions suffices for legitimacy; what the framework requires is a commitment together with a verification channel (for the demarcation from “committed but not verifiable” cases, see SI, to be released with the formal submission).
Existing systems turn out to be instances of this structure. Certificate-transparency logs append certificates into an append-only Merkle log (accumulation), whose signed tree heads are cross-checked by a network of independent auditors (anchoring), and any client can independently verify via inclusion and consistency proofs (verification); verifiable storage hands commitments of outsourced data blocks to an untrusted store (accumulation and anchoring), and the data owner independently confirms data integrity through proofs of possession (verification). These two, together with blockchains—transactions accumulated into blocks (accumulation), block headers becoming public anchors through consensus (anchoring), and light clients independently verifying via inclusion proofs (verification)—belong to different commitment mechanisms and anchoring models, yet satisfy the same set of legality conditions; this is precisely what mechanism neutrality means.
What the framework unifies are trust systems based on verifiable memory—systems that turn discrete events and states into independently verifiable traces and thereby achieve self-verifiability. The framework’s increment lies in elevating anchoring to a first-class stage alongside accumulation and verification, in the necessary-and-sufficient characterization of capabilities, and in its constructive generative power; a detailed delimitation from prior work [30,31,32,33] is given in SI (to be released with the formal submission).
Theoretical results
Around this structure we establish four theoretical results. First (Proposition 3.1, construction and complexity upper bound): the Epoch Hash Chain (Epoch-HC) constructs a two-level proof path from sparse intra-epoch checkpoint digests and a cross-epoch authentication chain; combined with geometric staged parameter scheduling (in which the epoch-size threshold grows by a fixed ratio ρ stage by stage), it keeps the worst-case membership witness and verification time at Θ(n1/3) under unbounded append, without reorganizing closed epochs, with a constant number of hashes per append and linear total storage. For a given size n, taking epoch capacity K=Θ(n2/3) and intra-epoch interval d=Θ(√K), the membership witness π∈ consists of intra-epoch checkpoints, the target interval, and a cross-epoch digest, and its worst-case size is
|π∈| = Θ(K/d + d + n/K) = Θ(n1/3)
This bound is tight for the witness format of this paper—none of the three evidence components can be further reduced in the worst case (proof in SI, to be released with the formal submission); the construction generalizes recursively by level, yielding an L-level family of append–witness trade-offs (see SI, to be released with the formal submission).
Second (Proposition 3.2, mechanism dependence of verification dimensions): integrity can be carried by any commitment mechanism, whereas temporal ordering must be carried by order-sensitive constructions—order-agnostic constant-witness mechanisms (such as RSA accumulators) cannot in principle provide ordering proofs: their aggregation function is quasi-commutative in the order of elements, and order information is lost upon aggregation (proof in SI, to be released with the formal submission); this delineates, for each verification dimension, the region of feasible constructions on the capability map.
Third (Proposition 3.3, closure under composition): a composition of legitimate constructions remains legitimate, making cross-system anchoring a standard operation within the framework rather than ad hoc engineering.
Fourth (Proposition 3.4, anchoring-baseline reset): for any legitimate instance, integrity verification can start from the most recent anchor and needs to cover only the trailing segment of length n-m (m being the time of the most recent anchoring)—the integrity of earlier history is inherited in one shot by the bindingness of the anchor; the more frequent the anchoring, the shorter the tail to be verified, with the cost shifted to the visibility mechanism on the anchoring side (proof in SI, to be released with the formal submission).
The costs of the three verification dimensions are thus governed by different operations of the triad, constituting mutually independent design knobs: integrity is governed by anchoring (Proposition 3.4); existence is governed by the aggregation parameters of accumulation (the K and d of Proposition 3.1 are precisely this knob); and temporal ordering inherits from existence (a construction-by-construction account is given in SI, to be released with the formal submission).
TABLE 1. Capability map of major commitment mechanisms (selected). The full eleven-row version with all table notes appears in SI (to be released with the formal submission; likewise below). “Batch verification” means that a single proof covers, in one pass, the membership (and ordering) verification of all elements in a contiguous interval, as opposed to element-by-element retrieval; its definition and per-construction differences are given in SI. b is the number of transactions per block; ‡ the O(1) of RSA accumulators counts multiplications only, excluding preprocessing of prime representatives, and requires a trusted manager or a public update mechanism (see SI table notes).
Construction Membership witness Element-level order verifiability Append cost Batch verification Non-membership proof
Bare hash chain O(n) ✓ (O(n) recomputation) 1 hash ✓ (same-chain recomputation) —
Indexed Merkle log O(log n) ✓ (position committed by tree) O(log n) per element unnatural
Dynamic Merkle tree (set) O(log n) ✗ O(log n) per element ✓
RSA accumulator O(1) ✗ (quasi-commutativity) O(1)‡ — ✓ O(1)
HC Accumulator [21] O(√n) ✓ O(1) hashes ✓ single pass ✓ (ordered value domain)
Epoch-HC (this work, L=2) Θ(n1/3) ✓ O(1) hashes ✓ reusable epoch suffix requires authenticated range partition or an upper-level negative index
Blockchain (status-quo composite) O(log b) + header-chain anchoring transaction-level evidence fragmented O(1) (amortized within block) block level block level ✓
Blockchain × Epoch-HC (our repair) Θ(n1/3) transaction-level ✓ O(1) hashes + underlying block production (amortized) ✓ requires authenticated range partition or an upper-level negative index
The ✓/✗ pattern in the “order verifiability” column is characterized by Proposition 3.2: constant-witness constructions (RSA accumulators) cannot in principle provide element-level ordering proofs, whereas strictly O(1)-append chain constructions spread along the “append cost ↔ witness size” trade-off axis—this is precisely the theoretical basis for Instance 1’s repair of the fragmentation of transaction-level ordering evidence in blockchains with Epoch-HC (full characterization and open problems in SI). The worst-case membership-witness curves of three grouping strategies (fixed grouping, single-layer optimal grouping, and the epoch scheme) have been numerically verified on a real deployment-trace sample and extrapolated to operator scale (3×108 records) (Extended Data Figure 5, to be released with the formal submission); a cross-assumption comparison with existing blockchain existence-proof methods appears in Extended Data Table 3 (to be released with the formal submission).
Blockchains and data-transaction memory
Blockchains are the first large-scale instantiation of verifiable memory in the domain of data transactions: data transactions such as domain-name registrations, certificate issuance, routing authorizations, and state changes are accumulated into a tamper-evident ledger, each block committing to its predecessor and to a digest of its transaction batch, and anchoring forms public anchors through distributed consensus and broadcast—whereas these record changes were previously decided unilaterally by centralized authorities in a “heteronomous” manner, leaving users no way to independently verify their legitimacy. It should be noted that this status-quo structure is a composite construction of Merkle trees and header-chain hashing: its transaction-level ordering evidence is fragmented—although the global order of cross-block transactions is semantically determined by block height, the block height itself must be endorsed by header-chain evidence between the two blocks, superimposed on an independent Merkle path for each transaction, so a verifier must stitch the proof across three structures: the header chain, the blocks, and the Merkle trees. Using Epoch-HC as the in-chain ordered accumulation structure lifts the position commitment from an implicit encoding in Merkle paths to an explicit commitment in hash inputs, so that the global order of two transactions in different blocks is decided directly by one membership witness each (an instantiated repair via Proposition 3.3; numerical verification of witness sizes in Extended Data Figure 5, to be released with the formal submission).
Blockchain-based digital infrastructure thereby acquires self-verifiability. Take, for example, BCDNS [24], the consortium-chain root domain name system we designed: root-zone changes are recorded on the consortium chain, and any user can independently confirm the authenticity of domain records by checking on-chain transaction records and the hash chain, without trusting root-server administrators; every administrative operation leaves a non-repudiable cryptographic trace, and disputes are resolved by verification rather than by appeal to an authority. The same pattern has been extended to certificate-authority systems: TAC [22], a unified trust-anchor framework based on a consortium chain, records public-key–identity bindings on the chain, letting users independently verify certificate status without trusting any single CA; RPKI technically belongs to the same PKI/CA family—binding address blocks to autonomous systems via X.509 resource certificates—and can be carried directly by such frameworks. The trust anchor of infrastructure thus shifts from faith in central authorities to verification of cryptographic evidence—network sovereignty turns from “heteronomy” to “co-governance.”
The reconstruction of infrastructure trust by blockchains thus divides into two channels: the data-transaction memory above is carried by an order-sensitive chain construction, whereas commitments to account and contract states are an order-agnostic set-membership problem, which by Proposition 3.2 (mechanism dependence of verification dimensions) should properly fall on the side of constant-witness constructions—the same proposition explains both why the transaction channel uses a chain and why the state channel uses a constant witness. At the system level, we use an RSA accumulator to generate validity proofs for smart contracts and compress node state, building the stateless blockchain STiPChain [14]: contract validity proofs are constant at about 1 KB (a Merkle proof at the same scale reaches 626 KB at n=104), consensus-node state storage is reduced by about 99% relative to an Ethereum full node (over 1 TB by 2022), and proof-update latency is constant at about 24 μs (Figure 2). The verification granularity of on-chain data is further extended by an accumulator-based general query scheme—range and multi-dimensional queries are turned into membership proofs, and omitted results are likewise verifiable [23]. This accumulator state commitment has been integrated into the Regulatable Blockchain Privacy-Trading Platform 2.0 and validated in deployment on a four-organization node cluster; a further deployment of the same project’s underlying chain is undergoing operator-scale validation in a pre-production environment (UAT) for China Mobile’s mobile-authentication scenario—a provincial operator’s number-status data are committed on-chain through the privacy-trading platform, and the mobile-authentication service system reads from the chain to provide authentication services externally, demonstrating that the transaction-memory substrate can carry operator-scale data loads. The datasets of both deployments are being organized and are going through the publication process; deployment statistics will be added when the datasets are released, supporting independent third-party verification.
Message chains and data-transmission memory
The message chain is the instantiation of verifiable memory in the domain of data transmission: the underlying IP protocol is stateless, packets travel independently, and the network keeps no trace; the message chain accumulates packet fingerprints into a per-session hash chain (Table 1), giving IP communication a verifiable transmission history it never had—ending the predicament in which tampering is hard to detect, attacks hard to trace, and disputes hard to attribute. The chain-tail value serves as a rolling trust anchor, and anchoring is realized through explicit confirmation of the chain tail by the two communicating parties—per-packet verification provides continuous confirmation, while chained signatures issued in batches at intervals complete periodic explicit confirmation and confer non-repudiation (interval parameters in Methods)—any unilateral tampering with history is detected immediately through hash mismatch. The two parties can independently verify their shared transmission history without trusting any network node: IP communication thereby acquires self-verifiability.
We implemented the message-chain protocol (MHC) at the network layer and evaluated it against IPSec AH/ESP and per-packet signing [16]: average throughput was 124.50 Mbps, 4.96% higher than IPSec AH and 5.70% higher than ESP, and about 23.5× that of per-packet signing (Figure 3); among the seven security properties—immutability, integrity, non-repudiation, reliability, traceability, synchronization, and confidentiality—MHC covers all seven (confidentiality is carried by its composition with the key chain; see the next section), and traceability is unique to MHC, absent from AH, ESP, and per-packet signing alike. Security thus turns from after-the-fact forensics external to the protocol into an endogenous property carried by every packet: tampering breaks chain continuity and is detected immediately, shifting the security posture from “passive tracing” to “instant immunity.”
Key chains and data-protection memory
The key chain is the instantiation of verifiable memory in the domain of data protection: with static or periodically renegotiated session keys, a single-point leak decrypts all traffic within the key’s validity period, frequent renegotiation is cost-limited, and the key-evolution history itself is not verifiable—once synchronization goes wrong, the two parties lack any means of autonomous detection and delimitation. The key chain replaces such schemes by accumulating key-update events into a cryptographic history of key evolution—each new key is derived from the current key together with the message fingerprint and is chain-committed.
The key chain is not an isolated chain but a derived chain riding on top of the transmission memory—each key-update event corresponds one-to-one to a message event (an instantiation of Proposition 3.3’s closure under composition, paralleling the blockchain × Epoch-HC composite construction of Instance 1). Anchoring completes in step with the transmission memory—each confirmation of the message-chain tail by the two parties simultaneously fixes the corresponding key-evolution history (keys are deterministically derived from the previous key and the message fingerprint; once the message sequence is confirmed, the key chain is fixed). Its anchor takes the form of a hash of the chain value and can be published without leaking key material: the one-wayness of the hash function lets confidentiality and public verifiability coexist in the same construction. Forward secrecy is enforced by the same one-wayness—knowing only the current key does not allow deriving past keys; backward secrecy is guaranteed by the fresh randomness introduced by the current message fingerprint at each key update—knowing only the current key likewise does not allow deriving future keys (ref. [17], Lemmas 4–5 therein). The impact of any single key compromise is thus strictly confined to a single message, compressing the exposure window from session level to message level. The two parties can independently verify the continuity and completeness of the key-evolution history without trusting protocol implementations or service providers: data protection thereby acquires self-verifiability.
We implemented this as the Chain Key Model (CKM) and compared it with standard schemes [15,17]: at a 1,400-byte payload, the hash–Salsa variant improved encryption efficiency by 35% and decryption efficiency by 43% over IPSec-AES; the key-agreement bit rate reached 8.60–9.59 Mbps, 1.19–3.59× that of Diffie–Hellman negotiation (2.48–7.36 Mbps); in randomness tests, the Hamming distance between adjacent keys (32-bit, theoretically optimal mean 16) had a mean of 16.267 and a variance of 6.407, a distribution closer to normal than the same-family baselines DSAVK/MSBAVK (ref. [17], Table 7 therein; Figure 4b). Privacy protection thus rises from a policy promise by the service provider to a mathematical guarantee of the protocol architecture itself.
Verifiable AI memory
The same triadic structure extends to a fourth domain: agent memory events serve as the objects of accumulation, and signed broadcasts with which multiple agents witness one another serve as the anchoring mechanism, so that two AI agents that have never interacted can judge each other’s trustworthiness from verifiable historical memory without commonly trusting any third party—inter-agent trust thereby acquires self-verifiability. One clarification is in order: “verifiable memory” in the machine-learning literature refers to agent memory management trained with verifiable reward signals [34], unrelated to the cryptographic meaning in this paper; dedicated mechanisms for authorized mutation, cryptographic provenance, and verifiable transfer of agent memory have also emerged rapidly of late [35,36,37]—isomorphic to the triadic framework of this paper, they are precisely the latest examples of fragmented self-verifiable schemes.
We are building a three-agent collaboration system in a real network environment: three agents (driven by the same configuration of the same large-model API—agent behaviors may correlate, but the guarantees of this instance do not rely on behavioral independence: the cryptographic force of mutual witnessing is carried by each agent’s independent authentication flow and signing keys, and binding verification is enforced architecturally by the verification gate; see Methods for the mechanism) form a collaborative research loop of “de-identification–analysis–review–archiving”—the roles of data de-identification, data analysis, and review consume upstream outputs in turn, each maintaining an independent Epoch-HC authentication flow. System-level evaluation is under way; complete results (inference-trace binding verification, three groups of attack audits covering online, offline-history, and inference-chain attacks, and authentication-structure benchmarks) will be added upon release of the results package (see Data Availability).
In this instance, verification becomes a subroutine of decision-making: the precondition for an agent to invoke its own capabilities is no longer a check of static identity or permissions, but a passed query against its verifiable memory—the object of verification shifts from static attributes to historical behavior, trustworthiness judgment is compressed from an institutional process into a deterministic computation, and this property is enforced by the architecture, independent of any goodwill at the model layer.

Discussion

The Memory-Driven Trust Paradigm goes beyond the reconstruction of Internet infrastructure. By unifying transaction provenance, transmission integrity, key evolution, and agent interaction under a single cryptographic framework, it provides a foundational layer for all kinds of digital ecosystems that need authority-free verification. Decentralized identity, supply-chain traceability, and federations of autonomous devices can each instantiate the same triadic life cycle on their own memory substrates. At the infrastructure layer, the three failure domains described in the Introduction—DNS, CAs, and RPKI—have already gained instantiation paths under the same consortium-chain mechanism (BCDNS and TAC); operational-grade deployment for RPKI is left to future work. The key insight is that trust need not be domain-specific—once historical facts are cryptographically committed, verification becomes a universal procedure applicable across contexts.
The most pressing implication lies in the emerging AI ecosystem. Today’s large models and autonomous agents operate as opaque black boxes: their training-data provenance, inference trajectories, and tool-use histories are neither verifiable nor auditable [18]. Existing efforts converge around three technical pillars—cryptographic provenance, output watermarking, and output attestation [19,20]—yet remain fragmented and mutually disconnected. Our framework implies a fundamentally different path: accumulate every training datum, inference step, and tool invocation into verifiable memory, so that the epistemic question turns from “do I trust this model” into “can I verify the memory on which this output depends.”
As important as the performance challenges is an honest recognition of capability boundaries. The proof semantics of this framework has two explicit boundaries. (i) Content truth is out of scope—verifiable memory proves that events and states genuinely occurred and that records have not been tampered with since the moment of commitment, but it does not prove that the content of a statement is true in reality (for the predicate restriction, see SI, to be released with the formal submission). (ii) No commitment, no verifiability—for two events never linked by the same anchor, there exists no verification channel for their real-world order, and the system explicitly returns “concurrent or unknown” rather than giving a false answer (mechanism dependence of ordering verification; see Proposition 3.2). The trustworthiness of the verification semantics lies precisely in its not claiming more than it can deliver.
The remaining challenges include: the technical, economic, and political complexity of migrating existing infrastructure to self-verifiability; the verification overhead on resource-constrained devices as accumulated scale keeps growing; the synchronization overhead of message chains and key chains under high packet loss; the absence of standardization; and the threat of quantum computing—the latter itemized by mechanism: hash-chain-type constructions can resist quantum attacks by increasing output length, whereas the RSA-accumulator and Ed25519-signature channels must migrate to post-quantum commitment and post-quantum signature schemes, respectively; the mechanism neutrality of the triadic structure allows such migration without changing the framework itself.
Looking forward, we identify three priorities: low-overhead verification implementations for resource-constrained environments; standardization of ordered cryptographic accumulators and memory-chain protocols; and deeper experimentation on verifiable AI memory—whose foundational role for trustworthy AI may prove no less than that of certificate transparency for web security. Among these, verifiable provenance on the training side and system-level validation of agent collaboration are the two directions yet to be completed, the training side being the harder: the stochasticity of training processes, ultra-large-scale states, and multi-party data ownership call for an entirely new trade-off design between anchoring granularity and verification cost; we are pursuing experiments along the lines of “layered anchoring of data batches, code versions, and intermediate checkpoints,” aiming to let third parties spot-check the integrity of training histories without re-running training.
By turning trust from subjective reliance on authorities into objective computation over verifiable memory, we offer not merely a technical mechanism but a reconceptualization of how digital society establishes consensus. “Whom should I trust?” has dominated Internet architecture for decades; in our view, the answer is to make that question obsolete.

Methods

Cryptographic implementation and theoretical framework
Full statements and proofs of the four theoretical results (Propositions 3.1–3.4: epoch-construction upper bound, mechanism dependence, closure under composition, anchoring-baseline reset) are given in SI (to be released with the formal submission; the proof of Proposition 3.4 is a definitional corollary). The legality conditions for verifiable memory systems are stated below.
Definition 3.1 (Legality conditions for verifiable memory systems). A cryptographic system (A, C, 𝒱)—where A is the accumulate operation, C the anchor operation, and 𝒱 the verify operation—is called a legitimate instance of a verifiable memory system if it simultaneously satisfies the following conditions:
(1) Accumulation legality. The accumulate operation A absorbs discrete events or states into an aggregate commitment, and adding a new element does not change the cryptographic commitment to existing elements (incrementality). The sensitivity of accumulation to arrival order (orderedness) is an instance property: order-sensitive constructions additionally commit to the capability of temporal-ordering verification, while order-agnostic constructions do not commit to it.
(2) Anchoring legality. The anchor operation C outputs a publicly verifiable cryptographic anchor such that any deviation from the anchor implies that history has changed; this guarantee is borne by the security assumption of the commitment mechanism itself, and anchoring legality does not restrict the specific form of the assumption.
(3) Verification legality. The verify operation 𝒱 can independently answer integrity queries without relying on any third-party authority; on this basis, it may support one or more of existence (including non-existence) and temporal-ordering queries. The dimensions covered by an instance are determined by its intrinsic properties, and their selection is determined by the application scenario.
The framework’s security reduces to three standard cryptographic assumptions: the collision resistance of SHA-256 (hash-chain and Epoch-HC-type constructions), the strong RSA assumption (STiPChain’s state-commitment channel), and the unforgeability of Ed25519 signatures (the multi-agent verifiable-memory system); post-quantum migration paths for each channel are discussed above. The HC accumulator [21] and Epoch-HC use SHA-256 as the underlying collision-resistant hash function. Epoch-HC upgrades the single-layer HC evidence structure into a two-level authentication path of “intra-epoch checkpoint chain—cross-epoch digest chain”: within an epoch, sparse checkpoint digests at interval d compress the locating path, with epoch capacity K; once an epoch boundary state is publicly authenticated and persistently visible, it constitutes an anchoring point Anchorn_j=(nj,j,Cj) in the sense of Definition 3.1, and the membership witness from an element to the public anchor consists of the intra-epoch checkpoint sequence, the target-interval sub-chain, and the cross-epoch suffix digest. Stage parameters of the geometric staged schedule are generated as Ks=⌈ Ns2/3⌉ and ds=⌈√(Ks)⌉, so that the construction—without reorganizing closed epochs, with a constant number of hashes per append and linear total storage—reduces the worst-case membership witness and verification time from Θ(√n) for single-layer HC to Θ(n1/3), and maintains this bound throughout unbounded append (Proposition 3.1; full proof and the L-level recursive generalization in SI, to be released with the formal submission). STiPChain uses an RSA accumulator to generate contract validity proofs; the multi-agent system uses Ed25519 signatures with a “signed receipt + double-ACK” anchoring mechanism, and theoretical costs are accounted by witness-structure composition (not denoting byte counts or wall-clock time).
Experimental setup
STiPChain evaluation [14]: proof size, update latency, storage, and throughput are compared against Merkle trees, Boneh, Edrax, Matproofs, and other schemes, with each comparison scheme reproduced or quoted according to the parameters and implementation conventions published in its original literature.
Deployment validation: the four-organization node cluster of the Regulatable Blockchain Privacy-Trading Platform (same network segment, uniform configuration) has been running continuously for several months. Block data were collected by height range via the platform’s GO SDK block-subscription interface (SubscribeBlock), structured into JSON, and subjected to three automated integrity checks: block-height continuity, inter-block hash linkage, and timestamp monotonicity. A separate deployment of the same underlying chain (v2.3.5, which does not contain the accumulator state commitment) runs in a pre-production environment (UAT) for China Mobile’s mobile-authentication scenario, testing the operator-scale carrying capacity of the transaction-memory substrate. The complete block dataset is being organized and will be released via the corresponding author’s university website (see “Data Availability”), supporting independent third-party verification.
MHC evaluation [16]: the protocol is implemented at the network layer as a custom kernel module based on Netfilter—outbound traffic is intercepted in kernel space, the standard 20-byte IP header is extended to 56 bytes (IHL=14), and a 36-byte option payload carries the identity identifier and chain-node value; a “sender–proxy–receiver” topology is deployed, and chained signatures are issued in batches every 1,000 packets to amortize signing cost. Five groups are compared—standard IP, per-packet-signed IP, IPSec AH, IPSec ESP, and MHC—with throughput averaged over ten runs.
CKM evaluation [15,17]: encryption/decryption latency and key randomness (Hamming distance, autocorrelation, Shannon entropy) are compared against standalone Salsa20, AES, and IPSec (pre-shared-key/RSA authentication) at payloads from 64 B to 65.5 KB.
Verifiable AI memory evaluation: the three-agent system is deployed in a real campus-network environment (three hosts; Python 3.12, cryptography library). The three agents are homogeneous, driven by the same configuration of the same large-model API, forming a “de-identification–analysis–review–archiving” collaborative research loop; the mirror executor is the controlled authoritative state-execution endpoint and executes a write only after verification authorization is bound to the artifact. Each agent maintains an independent Epoch-HC authentication flow (no shared accumulator); epoch capacity and grouping interval are computed at the creation of each new epoch as Ks=⌈ Ns2/3⌉ and ds=⌈√(Ks)⌉, and closed epochs are not re-partitioned. System validation (inference-trace binding verification, three groups of attack audits covering online, offline-history, and inference-chain attacks, and a four-structure authentication benchmark) is being conducted under this scenario; experimental details and results will be completed upon release of the results package.

Evaluation metrics

Performance metrics are reported separately as cryptographic verification time, signing and broadcast overhead, and API latency, and are not conflated into a single “verification cost.” Security properties are assessed along seven items: immutability, integrity, non-repudiation, reliability, traceability, synchronization, and confidentiality. Timing measurements follow the conventions stated for each experimental setup and are reported as means or medians over 10–30 independent runs.

Data availability

The block dataset of the Regulatable Blockchain Privacy-Trading Platform is being organized and will be released via the corresponding author’s university website. Metadata of the China Mobile deployment is undergoing an internal compliance-approval process and will be released upon approval. The verifiable AI memory experiment is undergoing system validation under the collaborative-research scenario; the complete results package (including per-trajectory records, attack-audit logs, and the file-level hash manifest MANIFEST.sha256) will be released via the corresponding author’s institutional repository upon completion. All other experimental data are available in the paper and the Supplementary Information (to be released with the formal submission).

Code availability

Implementation code for the HC accumulator, the MHC protocol, the Chain Key Model, and the multi-agent verifiable-memory system is available via the corresponding author’s institutional repository and is documented in prior publications [14,15,16,17].

Competing interests

All authors declare no competing interests.

Declaration of Large Language Model use

During the preparation of this manuscript, the authors used large-language-model tools (Kimi, DeepSeek, and Z.ai) to assist with literature checking, text polishing, cross-version consistency checking, and initial English translation. The three-agent system studied in this work is driven by a large-model API as an object of research, not as a writing tool (see the verifiable-AI-memory evaluation in Methods). The authors reviewed and edited all tool outputs and take full responsibility for the accuracy and integrity of the manuscript. In accordance with publisher policy, large language models do not qualify for authorship and are not listed as authors.

Funding

National Key Research and Development Program of China, project “Regulatable Blockchain Privacy-Preserving Transaction Platform and Demonstration Application Research” (2022YFB2703004).

References

  1. Akiwate, G.; et al. Retroactive identification of targeted DNS infrastructure hijacking. Proc. 22nd ACM Internet Measurement Conference (IMC), 2022; ACM; pp. 14–32. [Google Scholar]
  2. Schmid, G. Thirty years of DNS insecurity: current issues and perspectives. IEEE Commun. Surv. Tutor. 2021, 23, 2429–2459. [Google Scholar] [CrossRef]
  3. Ma, Z.; Mason, J.; Antonakakis, M.; Durumeric, Z.; Bailey, M. What’s in a name? Exploring CA certificate control. 30th USENIX Security Symposium, 2021; USENIX Association; pp. 4383–4400. [Google Scholar]
  4. Ballani, H.; Francis, P.; Zhang, X. A study of prefix hijacking and interception in the internet. ACM SIGCOMM Comput. Commun. Rev. 2007, 37, 265–276. [Google Scholar] [CrossRef]
  5. Saltzer, J. H.; Reed, D. P.; Clark, D. D. End-to-end arguments in system design. ACM Trans. Comput. Syst. 1984, 2, 277–288. [Google Scholar] [CrossRef]
  6. Bellovin, S. M. Security problems in the TCP/IP protocol suite. ACM SIGCOMM Comput. Commun. Rev. 1989, 19, 32–48. [Google Scholar] [CrossRef]
  7. Wardle, C.; Derakhshan, H. Information Disorder: Toward an Interdisciplinary Framework for Research and Policy Making; Council of Europe, 2017. [Google Scholar]
  8. Coalition for Content Provenance and Authenticity. C2PA Technical Specification, Version 1.4. 2023. Available online: https://spec.c2pa.org/specifications/.
  9. Haber, S.; Stornetta, W. S. How to time-stamp a digital document. J. Cryptol. 1991, 3, 99–111. [Google Scholar] [CrossRef]
  10. Nakamoto, S. Bitcoin: a peer-to-peer electronic cash system. 2008. Available online: https://bitcoin.org/bitcoin.pdf.
  11. Laurie, B. Certificate transparency. Commun. ACM 2014, 57, 40–46. [Google Scholar] [CrossRef]
  12. Ateniese, G.; et al. Provable data possession at untrusted stores. Proc. 14th ACM CCS, 2007; ACM; pp. 598–609. [Google Scholar]
  13. Crosby, S. A.; Wallach, D. S. Efficient data structures for tamper-evident logging. 18th USENIX Security Symposium, 2009; USENIX Association; pp. 317–334. [Google Scholar]
  14. Sun, L. Research on high-performance stateless blockchain technology. Master’s thesis, (In Chinese) Beijing Information Science and Technology University, 2024. [Google Scholar]
  15. Wang, Y. Research on a hash-based chain key model and its applications. Master’s thesis, (In Chinese) Beijing Information Science and Technology University, 2024. [Google Scholar]
  16. Han, M.; Jiang, W. A secure communication method based on message hash chain. Appl. Sci. 2022, 12, 4505. [Google Scholar] [CrossRef]
  17. Jiang, W.; Ding, J.; Wang, Y.; Du, H. A chain key model based on message hash chain. 2025. [Google Scholar] [CrossRef]
  18. Longpre, S.; et al. The data provenance initiative: a large scale audit of dataset licensing and attribution in AI. Nat. Mach. Intell. 2024, 6, 503–515. [Google Scholar]
  19. Dathathri, S.; et al. Scalable watermarking for identifying large language model outputs. Nature 2024, 634, 818–823. [Google Scholar] [CrossRef] [PubMed]
  20. Collomosse, J.; Parsons, A. To authenticity, and beyond! Building safe and fair generative AI upon the three pillars of provenance. IEEE Comput. Graph. Appl. 2024, 44, 82–90. [Google Scholar] [CrossRef] [PubMed]
  21. Jiang, W.; Li, J.; Guo, Y.; Zhang, H. An ordered universal accumulator based on a hash chain. Appl. Sci. 2025, 15, 2565. [Google Scholar] [CrossRef]
  22. Zhang, F.; Jiang, W.; Shi, B. TAC: a unified trust anchor framework based on consortium blockchain. J. Phys. Conf. Ser. 2020, 1544, 012181. [Google Scholar] [CrossRef]
  23. Sun, L.; Wang, L.; Jiang, W.; Guo, Y. A verifiable query scheme with rich query capabilities and low storage redundancy on blockchain. Future Gener. Comput. Syst. 2025, 171, 107859. [Google Scholar] [CrossRef]
  24. Zhang, F. Research on a novel blockchain-based DNS architecture. Master’s thesis, (In Chinese) Beijing Information Science and Technology University, 2020. [Google Scholar]
  25. Wang, C.; Cai, L.; Huang, F.; Qiu, W.; Li, C. VI-Store: towards optimizing blockchain-oriented verifiable ledger database. In Proc. IEEE 29th Int. Conf. Parallel and Distributed Systems (ICPADS); IEEE, 2023; pp. 1751–1758. [Google Scholar]
  26. Mazières, D. Self-certifying file system. PhD thesis, Massachusetts Institute of Technology, 2000. [Google Scholar]
  27. Chaki, S.; Giampapa, J. A. Designing SCADA systems for the self-verifiability of their security and survivability. Conference poster, Software Engineering Institute, Carnegie Mellon Univ., 2013. [Google Scholar]
  28. Rose, S.; Borchert, O.; Mitchell, S.; Connelly, S. NIST Special Publication 800-207; Zero Trust Architecture. 2020.
  29. Cho, J.-H.; Chan, K.; Adali, S. A survey on trust modeling. ACM Comput. Surv. 2015, 48, 28. [Google Scholar] [CrossRef]
  30. Martel, C.; Nuckolls, G.; Devanbu, P.; Gertz, M.; Kwong, A.; Stubblebine, S. G. A general model for authenticated data structures. Algorithmica 2004, 39, 21–41. [Google Scholar] [CrossRef]
  31. Raikwar, M.; Gligoroski, D.; Kralevska, K. SoK of used cryptography in blockchain. IEEE Access 2019, 7, 148550–148575. [Google Scholar] [CrossRef]
  32. Bonneau, J.; Chen, J.; Christ, M.; Karantaidou, I. Merkle mountain ranges are optimal: on witness update frequency for cryptographic accumulators. In Advances in Cryptology—CRYPTO 2025; Springer, 2025; pp. 170–202. [Google Scholar]
  33. Papadopoulos, D.; Tang, Q.; Xin, J. Morphic accumulators and applications. In Advances in Cryptology—CRYPTO 2026; Springer, 2026; pp. 460–491. [Google Scholar]
  34. Sun, X.; Wang, Q.; Li, H.; Chen, L. Verifiable Memory: learning unified memory management with local and global verifiers for large language model agents. 2026. Available online: https://arxiv.org/abs/2608.03137.
  35. Saidi, W. MutMem: cryptographically authorized mutation in persistent agent memory. 2026. Available online: https://arxiv.org/abs/2608.02843.
  36. Ouyang, C.; Hou, R. MemLineage: lineage-guided enforcement for LLM agent memory. 2026. Available online: https://arxiv.org/abs/2605.14421.
  37. Ravindran, S. K. Portable agent memory: a protocol for cryptographically-verified memory transfer across heterogeneous AI agents. 2026. Available online: https://arxiv.org/abs/2605.11032.
Preprints 235430 g001
Figure 1. The Memory-Driven Trust Paradigm. The paradigm shifts the core trust question from “whom to trust” to “what to verify”: discrete events and states are accumulated into an aggregate commitment, anchored into publicly verifiable cryptographic anchors, and verification answers integrity, existence, and temporal-ordering queries without relying on any authority. The same life cycle is neutral to the underlying commitment mechanism (hash chains, Merkle trees, cryptographic accumulators) and is instantiated as four memory substrates—blockchains (transaction memory), message chains (transmission memory), key chains (protection memory), and verifiable AI memory (agent memory)—endowing infrastructure, IP communication, data protection, and inter-agent trust with self-verifiability, respectively. The formal definition of the triadic structure appears in the next section; its full statement is given in Methods (Definition 3.1).
Figure 1. The Memory-Driven Trust Paradigm. The paradigm shifts the core trust question from “whom to trust” to “what to verify”: discrete events and states are accumulated into an aggregate commitment, anchored into publicly verifiable cryptographic anchors, and verification answers integrity, existence, and temporal-ordering queries without relying on any authority. The same life cycle is neutral to the underlying commitment mechanism (hash chains, Merkle trees, cryptographic accumulators) and is instantiated as four memory substrates—blockchains (transaction memory), message chains (transmission memory), key chains (protection memory), and verifiable AI memory (agent memory)—endowing infrastructure, IP communication, data protection, and inter-agent trust with self-verifiability, respectively. The formal definition of the triadic structure appears in the next section; its full statement is given in Methods (Definition 3.1).
Preprints 235430 g001
Preprints 235430 g002
Figure 2. Measured performance of the stateless blockchain STiPChain. a, Contract-validity proof size versus the number n of accumulated elements: STiPChain / Boneh / Edrax are constant at about 1 KB (O(1)), while Merkle proofs grow as O(log2 n), measured at 626 KB for n=104 (ref. [14], Figure 3.3 therein). b, Consensus-node state storage: STiPChain <1 KB, about 99% lower than an Ethereum full node (over 1 TB as of 2022/01); node storage of the DHT scheme (ref. [4] as cited within ref. [14]) grew from 17.7 GB to 89.5 GB between 2019/01 and 2022/01 (ref. [14], Figure 3.5 therein).
Figure 2. Measured performance of the stateless blockchain STiPChain. a, Contract-validity proof size versus the number n of accumulated elements: STiPChain / Boneh / Edrax are constant at about 1 KB (O(1)), while Merkle proofs grow as O(log2 n), measured at 626 KB for n=104 (ref. [14], Figure 3.3 therein). b, Consensus-node state storage: STiPChain <1 KB, about 99% lower than an Ethereum full node (over 1 TB as of 2022/01); node storage of the DHT scheme (ref. [4] as cited within ref. [14]) grew from 17.7 GB to 89.5 GB between 2019/01 and 2022/01 (ref. [14], Figure 3.5 therein).
Preprints 235430 g002
Preprints 235430 g003
Figure 3. Comparative analysis of the message-chain protocol MHC and IPSec. a, Average throughput of five network-layer communication schemes (left axis, log scale; whiskers show the range of five runs at 2/5/10/30/60 min) and the number of covered security properties out of seven (right axis, orange squares): MHC covers all seven properties at 124.50 Mbps—4.96% / 5.70% above IPSec AH / ESP and about 23.5× the per-packet-signing scheme (5.31 Mbps); bare IP achieves the highest throughput (413.52 Mbps) but has no security property (ref. [16], Table 3 therein). b, The security-property matrix (ref. [16], Table 5 therein): among immutability, integrity, non-repudiation, reliability, traceability, synchronization, and confidentiality, traceability is unique to MHC (red box); MHC’s confidentiality follows the scope of its composition with the Chain Key Model (ref. [17]); reliability of AH/ESP is recorded as partially satisfied per the original table’s convention (marked “Higher” therein).
Figure 3. Comparative analysis of the message-chain protocol MHC and IPSec. a, Average throughput of five network-layer communication schemes (left axis, log scale; whiskers show the range of five runs at 2/5/10/30/60 min) and the number of covered security properties out of seven (right axis, orange squares): MHC covers all seven properties at 124.50 Mbps—4.96% / 5.70% above IPSec AH / ESP and about 23.5× the per-packet-signing scheme (5.31 Mbps); bare IP achieves the highest throughput (413.52 Mbps) but has no security property (ref. [16], Table 3 therein). b, The security-property matrix (ref. [16], Table 5 therein): among immutability, integrity, non-repudiation, reliability, traceability, synchronization, and confidentiality, traceability is unique to MHC (red box); MHC’s confidentiality follows the scope of its composition with the Chain Key Model (ref. [17]); reliability of AH/ESP is recorded as partially satisfied per the original table’s convention (marked “Higher” therein).
Preprints 235430 g003
Preprints 235430 g004
Figure 4. Measured performance of the Chain Key Model (CKM). a, Key-agreement bit-rate comparison: over UDP with a DH negotiation period of 10 s, the bit rates of chain keys (per-packet update) in 1 s / 10 s / 100 s measurement windows (8.90 / 8.60 / 9.59 Mbps) are 3.59 / 1.19 / 1.30× those of DH negotiation (2.48 / 7.21 / 7.36 Mbps) (ref. [17], Table 4 therein). b, Hamming-distance distribution of adjacent keys (32-bit): 1,000 measured counts for chain keys (bars) and normal fits (curves) of DSAVK, MSBAVK, and chain keys from their reported means/variances; the chain-key mean 16.267 is closest to the theoretical optimum 16, with the smallest variance 6.407 (ref. [17], Tables 5–7 therein; original experimental records in ref. [15]).
Figure 4. Measured performance of the Chain Key Model (CKM). a, Key-agreement bit-rate comparison: over UDP with a DH negotiation period of 10 s, the bit rates of chain keys (per-packet update) in 1 s / 10 s / 100 s measurement windows (8.90 / 8.60 / 9.59 Mbps) are 3.59 / 1.19 / 1.30× those of DH negotiation (2.48 / 7.21 / 7.36 Mbps) (ref. [17], Table 4 therein). b, Hamming-distance distribution of adjacent keys (32-bit): 1,000 measured counts for chain keys (bars) and normal fits (curves) of DSAVK, MSBAVK, and chain keys from their reported means/variances; the chain-key mean 16.267 is closest to the theoretical optimum 16, with the smallest variance 6.407 (ref. [17], Tables 5–7 therein; original experimental records in ref. [15]).
Preprints 235430 g004
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.