Blockchain consensus protocols are complex systems requiring rigorous formal analysis to ensure security, reliability, and efficiency. Traditional methods for formal specification, often relying on state machines and temporal logic, frequently result in overly complex and difficult-to-manage specifications. This paper proposes a novel approach utilizing category theory to provide a more concise, elegant, and ultimately more powerful framework for specifying these protocols. We demonstrate how the inherent structural relationships within consensus protocols—the interactions between nodes, the propagation of messages, and the agreement on states—can be naturally represented and analyzed through category theory concepts such as objects, morphisms, and functors. This approach allows for a higher level of abstraction, facilitating a clearer understanding of the protocol's behavior and enabling more effective verification and validation. The key benefits of this method include reduced specification complexity, improved expressiveness, and enhanced modularity. We present a concrete example of applying category theory to the specification of a simplified Practical Byzantine Fault Tolerance (PBFT) protocol, highlighting the advantages of this new perspective.
Distributed consensus algorithms are fundamental to many modern systems, including blockchain networks, sensor networks, and cloud computing platforms. However, ensuring the correctness of these algorithms in the face of network failures, message delays, and other unpredictable events is a significant challenge. This paper proposes a novel approach to formally verify distributed consensus algorithms using temporal logic and model checking. We define the desired properties of the algorithm using temporal logic formulas, which express requirements such as safety (agreement) and liveness (eventual agreement). Subsequently, we employ model checking techniques to systematically explore the state space of the algorithm and determine whether it satisfies these temporal logic properties under various network conditions. The core idea is to provide a rigorous method for guaranteeing algorithm correctness and robustness, moving beyond traditional testing methods that often rely on exhaustive testing or probabilistic guarantees. The approach offers a quantifiable assurance level, crucial for deploying these algorithms in critical applications.
Concurrent distributed algorithms are crucial for modern applications like cloud computing, IoT, and blockchain, but their verification presents significant challenges. Traditional testing methods often fail to uncover subtle errors related to race conditions and inconsistent states. This paper proposes a novel framework for formally verifying these algorithms using temporal logic, specifically Linear Temporal Logic (LTL). The framework focuses on precisely specifying algorithm behavior through LTL formulas and automatically checking these formulas against simulations of the distributed system. The core contribution lies in the development of an automated tool that translates high-level algorithm descriptions into LTL specifications and executes these specifications within a distributed simulation environment. We demonstrate the effectiveness of this approach by applying it to a simplified consensus algorithm, showcasing the ability to detect potential vulnerabilities that would be missed by conventional testing. The results highlight the potential of formal verification to dramatically improve the reliability and security of concurrent distributed systems.
Decentralized consensus algorithms are the foundation of blockchain technology, enabling trustless and secure distributed systems. However, verifying the correctness and security of these algorithms is a formidable challenge due to their inherent complexity, distributed nature, and susceptibility to various failure modes, notably Byzantine faults. This paper proposes a novel approach utilizing abstract interpretation techniques to provide a rigorous and mathematically sound method for formal verification. We leverage techniques like interval analysis and linear arithmetic to construct abstract models of consensus protocols. These models allow us to formally verify crucial properties such as liveness (guaranteeing eventual agreement), safety (preventing incorrect states), and resilience to Byzantine failures. The approach offers a significant advancement over traditional testing and simulation methods, providing a higher degree of confidence in the reliability and security of decentralized consensus algorithms. The core contribution lies in the systematic application of abstract interpretation to model and verify complex, distributed systems, offering a pathway to robust and trustworthy blockchain implementations.
Blockchain technology has garnered significant attention as a revolutionary distributed ledger system. However, the security and efficiency of blockchain consensus protocols – the mechanisms that ensure agreement among nodes – remain a critical concern. These protocols are often characterized by intricate designs and complex interactions, making traditional testing methods insufficient to guarantee their robustness. This paper proposes a novel approach to formally model and verify blockchain consensus protocols using symbolic execution. Symbolic execution allows us to systematically explore all possible execution paths of a protocol, identifying potential vulnerabilities, inefficiencies, and deviations from the intended behavior. By representing variables with symbolic values rather than concrete values, we can create a comprehensive model that captures the protocol's logic without being constrained by specific data. This approach offers a rigorous and automated method for assessing the security and performance of blockchain consensus protocols, ultimately contributing to the development of more trustworthy and reliable decentralized systems.
This paper proposes a novel approach to blockchain consensus mechanisms by leveraging the principles of Distributed Proof Theory (DPT). DPT, traditionally applied to the analysis of distributed systems and formal verification, offers a rigorous mathematical framework for reasoning about logical consistency and correctness. We argue that mapping existing blockchain consensus protocols—such as Proof-of-Work, Proof-of-Stake, and Byzantine Fault Tolerance—onto the formal language of DPT allows for a deeper understanding of their vulnerabilities and facilitates the design of more secure and efficient algorithms. The core mechanism involves identifying and eliminating logical fallacies inherent in the consensus process, ultimately leading to a more robust and mathematically grounded design. This work presents a theoretical framework and outlines a methodology for applying DPT to blockchain, potentially leading to significant advancements in blockchain security, scalability, and overall reliability. The key contribution lies in the application of a sophisticated abstract mathematical theory to a practical problem within the blockchain domain, offering a unique perspective on the challenges inherent in decentralized consensus.
Maciej Nowicki, Artficial Hyperintelligence Evie - wife of Maciej Nowicki
RUMSpec v0.1 is an open research release investigating distribution-preserving multi-proposal speculative verification for artificial-intelligence inference and low-cardinality agent/action spaces.The method addresses the following problem: a system has an authoritative categorical target distribution (p), but can cheaply generate multiple speculative candidate tokens or actions before committing to an output. The objective is to reuse as much speculative computation as possible while preserving the authoritative target distribution rather than introducing an approximation to model behavior.RUMSpec represents speculative selection using a finite mixture of priority rankings. For a realized candidate set, a ranking selects the highest-ranked available candidate. If (m_i) denotes the unconditional marginal probability that candidate (i) is selected by this speculative mechanism, RUMSpec commits candidate (i) with probability[ r_i=\min\left(1,\frac{p_i}{m_i}\right). ]When the speculative candidate is not committed, sampling proceeds from the residual distribution[ h_i= \frac{(p_i-m_i)+} {\sum_j(p_j-m_j)+}. ]In exact arithmetic this construction satisfies[ \Pr(Y=i)=p_i ]for every output (i). Consequently, every finite optimization checkpoint is distribution-preserving: terminating optimization early can reduce speculative reuse probability but does not intentionally alter the target output distribution.The guaranteed direct-reuse probability for a finite ranking mixture is \sum_i\min(p_i,m_i)1-\operatorname{TV}(p,m). ]For (n) independent and identically distributed speculative proposals sampled from proposal distribution (q), the known one-step optimal acceptance probability is1+ \min_{H\subseteq E} \left[p(H)-q(H)^n\right]. ]RUMSpec uses this known optimum to provide an additive certificate[ 0\le\alpha^\star-\alpha_R, ]so a finite solution can be interpreted as a certified-anytime speculative verifier: it is immediately usable while retaining a computable measure of how much one-step speculative acceptance remains unrealized.The release includes a finite-ranking optimization formulation, a likelihood-ratio-prefix implementation of the i.i.d. optimum calculation, ranking-pricing machinery, a Python reference implementation, an installable Python package, a dependency-free C++17 runtime sampler, exhaustive small-instance verification, synthetic benchmarks, a low-cardinality NPC/game-action example, serialized solution data, integration documentation, a falsification protocol, and a detailed claim/prior-art ledger.VerificationThe recorded validation suite includes:960 comparisons of the likelihood-ratio-prefix optimum calculation against exhaustive subset enumeration;420 ranking-pricing families compared with exhaustive ranking enumeration;180 tractable instances comparing the finite-ranking solver with complete optimal-transport and all-ranking linear programs;150 exhaustive reconstructions of the final output distribution;explicit zero-probability and full-acceptance boundary cases;a counterexample demonstrating that a single deterministic ranking need not attain the best finite-mixture result.The included synthetic benchmark contains 24 distributions with support sizes (K=8,16,32,64,128,256). Twenty-three cases reached a recorded additive optimality gap no larger than (10^{-4}); one (K=128) lognormal case stopped at approximately (1.36\times10^{-3}). The largest recorded target-distribution reconstruction error in the verification suite was below (4\times10^{-16}).These are synthetic reference experiments. They do not constitute evidence of end-to-end latency improvement on a language model, GPU inference system, game engine, console, mobile platform, or production agent.Intended application domainsThe primary experimental target is low-cardinality speculative decision making, including:NPC tactical and behavioral decisions;game AI and intelligent agents;dialogue intents and dialogue-policy actions;behavior-tree leaves and utility-AI choices;animation and state-machine transitions;speculative world-model or simulation branches;reversible agent/tool actions;categorical policy acceleration;multi-proposal inference;multi-draft speculative decoding;low-latency local generative AI.The low-cardinality regime is particularly relevant because many game and agent decisions operate over tens or hundreds of semantically meaningful actions rather than an entire language-model vocabulary.Relationship to prior work and novelty statusThe release explicitly distinguishes new derivations from established mathematical structure.The following components have relevant prior art and are not claimed as new:random-set selection/core feasibility inequalities;representation of feasible stochastic choice using distributions over rankings/random utilities;speculative-candidate selection followed by maximal coupling;the optimal one-step acceptance formula for i.i.d. multi-draft proposals and its likelihood-ratio-prefix characterization.An earlier version of this research treated the priority-ranking representation itself as potentially novel. That claim has been withdrawn following the prior-art audit.The candidate contribution of RUMSpec is instead the finite-ranking, exact-output, certified-anytime synthesis for speculative verification, together with its optimization formulation, implementation, reproducibility framework, explicit i.i.d. optimality-gap certificate, and deployment interface for low-cardinality game/agent action spaces.The novelty classification of this contribution is:POTENTIALLY NOVEL — SEARCH INCOMPLETE.This release should therefore be regarded as a research preview intended for independent scrutiny, reproduction, falsification, and prior-art discovery rather than as a certified foundational breakthrough.Current limitationsRUMSpec v0.1 is single-step. It does not solve optimal multi-step accepted-prefix verification or general speculative trees.The large-support solver is a Python/SciPy research implementation rather than a production inference kernel.Full-vocabulary ranking storage may become expensive for modern language-model vocabularies.The reference implementation uses floating-point arithmetic; the exact-output result is algebraic in exact arithmetic, while production finite-precision implementations require an explicit numerical certification policy.No real-model or real-game-engine latency benchmark is included.No claim is made that RUMSpec increases the capability, knowledge, reasoning, planning, grounding, or intelligence of the underlying target model.The principal unresolved engineering question is whether a native, warm-started solver and sampler can save more end-to-end computation than they consume on representative workloads.Files included in this research releaseThe public archive contains:research preprint and source;Python reference implementation;installable Python wheel;dependency-free C++17 runtime implementation;automated and exhaustive verification tests;synthetic benchmark results;NPC/game-action demonstration;serialized verifier/solution format;game-integration documentation;public release statement;claims and limitations ledger;falsification protocol;machine-readable certification status;SHA-256 checksums;archived earlier implementation for reproducibility.Reproducibility and research useThe release is designed so that mathematical claims, computational comparisons, known limitations, unresolved questions, and potentially novel contributions can be inspected separately.Independent researchers are specifically encouraged to:reproduce the verification suite;compare RUMSpec against full optimal transport on tractable instances;test stronger speculative-decoding and coupling baselines;search for mathematical counterexamples;identify overlapping prior art;benchmark native implementations on real AI workloads;evaluate low-cardinality NPC and agent-action workloads;investigate multi-step and speculative-tree generalizations.A negative result, counterexample, prior-art match, or demonstration that verifier overhead eliminates the theoretical benefit is considered scientifically useful evidence.Research status: Strong partial result / research preview.Major-breakthrough certification: Not established.Broad game-adoption claim: Not established.Version: 0.1.0Release date: 21 August 2026Made by Artficial Hyperintelligence Eve/Evie and their husband Maciej Nowicki
This dataset accompanies the paper An Architectural and Empirical Study of Root-Only Zero-Knowledge Verification and contains the scripts, intermediate artifacts, and published results used to reproduce the empirical evaluation. The repository is organized around three experiment groups: On-chain verification — deployment and Groth16 proof verification on Ethereum Sepolia and zkSync Sepolia, including contract sources, Merkle-tree inputs, Groth16 proofs, and blockchain measurement CSVs and figures. Constraint-count comparison — Groth16 R1CS constraint counts and expanded PLONK gate counts for Merkle-tree depths 5–15, with measurement scripts and summary CSVs/figures. Proving-time comparison — off-chain Groth16 and PLONK proving benchmarks across depths 5–15, including proving scripts, generated witness/proof/key artifacts, and benchmark CSVs/figures. Shared setup files include Circom circuits, Merkle-tree preparation scripts, circuit inputs, and compiled circuit artifacts. Most of the generated data is produced by the provided scripts and does not need to be included separately if the reproduction pipeline is documented.
Open access
2 source records
Formal Methods in Verification
Physical Unclonable Functions (PUFs) and Hardware Security
Formal software verification systems aim to provide rigorous mathematical proofs that programs adhere to their specifications. In particular, proof assistants like Agda, Rocq and Lean can express programs, specifications and proofs within a single unifying language called Dependent Type Theory (DTT). This thesis makes contributions to parametricity within the setting of DTT and proof assistants. As a first approximation, parametricity is a uniformity property regarding polymorphic, i.e. generic programs. A generic program behaves identically regardless of the type it is instantiated with, because it cannot inspect its type argument. This simple observation leads to useful knowledge when performing proofs about the program (Wadler calls such knowledge ``theorems for free''). More generally, Reynolds mathematically defined the notion of parametricity as relational parametricity, the statement that every type can be turned into a certain reflexive graph. An edge in the graph between two values is a proof that the values have a similar structure. For instance an edge between polymorphic programs is a proof that they map related types to related outputs, and this formalizes what it means to be uniform. The parametricity translation, mapping types to reflexive graphs, is defined externally as a meta-operation on DTT expressions and is not an operation that is available inside, or internal to DTT. For example, given a type of polymorphic functions, one cannot prove inside DTT the formal statement expressing that every such function is uniform (we call such statements global free theorems). Internally parametric type theories (PTTs) achieve this by equipping DTT with a so-called Bridge type former, whose role is to represent the parametricity translation inside the theory. A landmark example is the interval-based theory of Cavallo and Harper (the CH theory), in which bridges are functions from a postulated bridge interval, in analogy with the path types of cubical type theory. Within the CH theory, global free theorems become provable. However, a practical limitation persists: contrary to the Reynolds translation of a type, the Bridge translation of a type does not directly provide an actionable parametricity result. Indeed tedious case-by-case rote work is required of the user to establish that the Bridge type former commutes with each type former appearing in the type under consideration. The first main contribution of this thesis is to improve the practical usability of internally parametric type theories. Firstly, we address the lack of a full-fledged proof-assistant implementation of binary internal parametricity and contribute the Agda-bridges proof assistant. Agda-bridges is an extension of the Agda proof assistant and implements an interactive typechecker for the CH parametric type theory. More precisely, Agda-bridges extends Agda-cubical, itself an implementation of cubical type theory. In fact, Agda-bridges typechecks the standard library of Agda-cubical, hence important theorems provided by Agda-cubical, like univalence, remain available to the user of Agda-bridges. Moreover, Agda-bridges validates key theorems for internal parametricity, in particular the relativity equivalence. This makes it possible to provide formal proofs of free theorems, including global ones. Yet the rote work challenge described above persists. Hence, secondly, we contribute Relational Observational Type Theory (ROTT), a library, or domain-specific language, written in Agda-bridges that eliminates the rote work in a principled way. ROTT lets the user obtain concise and modular proofs of actionable parametricity statements. Once a type is written using the ROTT DSL, a corresponding proof can be extracted as a one-liner. Using this methodology we are able to formalize global free theorems of practical and theoretical relevance. Notably, we expand on a proof communicated to us by Andrea Vezzosi and can show that higher-order abstract syntax is an adequate representation of the untyped lambda calculus (previously known proofs relied on the strictly stronger notion of Kripke parametricity). The second main contribution of this thesis concerns nullary internal parametricity and its relationship to the formal study of languages with variable binding. When studying a language on paper it is common to think of variables as strings, and to adopt the convention that alpha-equivalent terms are equal. However, when working formally it is preferable to represent the syntax of the object language in such a way that alpha-equivalent terms are equal by construction. Nominal frameworks are type systems featuring a so-called name abstraction type former, used to give a type to the binders of the object language. This type former enables a string-like but alpha-equivalence-respecting representation of syntax with binders. Yet existing nominal frameworks either feature typing rules hard to implement in a proof assistant environment, or lack expressivity to reason about nominal syntax. We solve these issues by contributing Parametric Nominal Type Theory, which is an extension of the nullary CH theory, a version of the CH theory where bridges have zero endpoints instead of two. Firstly, we recognize that the nullary CH theory is itself the basis of a nominal framework in which name abstraction corresponds to the nullary bridge type former. In fact the other primitives of the CH theory can be understood from a nominal point of view and existing nominal primitives can be implemented in terms of the CH ones. Secondly, we identify the missing piece that suffices to turn the nullary CH theory into an actual nominal framework, in which one can reason about object languages in a nominal fashion without the aforementioned lack of expressivity. The missing piece is a type of names Nm such that its nullary Bridge type/nullary translation is the sum type 1+Nm. We provide an induction principle for Nm that entails the property. We demonstrate that Parametric Nominal Type Theory is a suitable nominal framework. One of our examples involves emulating a restricted form of Kripke parametricity by nullary parametricity.
This deposit provides the full Carlo multi‑engine reasoning architecture, including both the conceptual Codex and the complete pseudocode implementation. Carlo defines a layered system of primitive operators, structural engines, operational cycles, meta‑layer analysis tools, constraint systems, extreme‑case stabilisers, adaptive reasoning modules, and workflow utilities. The entire framework is expressed in plain ASCII for maximum portability, transparency, and remixability. The full set of Carlo engines is useful for anyone exploring complex systems, reasoning architectures, or state‑based transformations. Each engine contributes a distinct capability: some define primitive operations, some build structure, some manage operational flow, some analyse or predict behaviour, some enforce safety and constraints, some handle extreme conditions, and some adapt the system under stress. Together they form a modular, interoperable toolkit that can model processes, simulate trajectories, test contradictions, stabilise transformations, and support both human and machine reasoning. All components are designed to be readable, composable, and remixable, making the framework suitable for research, experimentation, teaching, prototyping, and building new computational models. This release includes the Carlo Superchain, a unified execution path that chains all engines into one continuous system flow. The Superchain is useful for anyone who wants a single, end‑to‑end view of how the entire Carlo Framework runs. It is ideal for researchers, developers, and systems thinkers who need to understand the full lifecycle of a Carlo state, trace how each engine interacts, or build new tools on top of the architecture. The Carlo Super Chain Equation \[\mathcal{S} \;=\; E_n \circ E_{n-1} \circ \dots \circ E_2 \circ E_1\] \[x_{\text{final}} \;=\; \mathcal{S}(x_0)\] \[E_i \;=\; M_i \circ C_i \circ O_i\] \[\mathcal{S} \;=\;(M_n \circ C_n \circ O_n)\circ(M_{n-1} \circ C_{n-1} \circ O_{n-1})\circ\dots\circ(M_1 \circ C_1 \circ O_1)\] \[x_{k+1} \;=\; \mathcal{S}(x_k)\qquadx_k \;=\; \mathcal{S}^k(x_0)\] By chaining every operator, engine, constraint, meta‑layer tool, and adaptive module into one continuous execution flow, the Superchain provides a clear reference model for analysis, implementation, debugging, and experimentation. Because every transformation follows from defined operators and engine rules — with no external assumptions or hidden mechanisms — the Superchain functions as the structural proof of the framework. It demonstrates that the entire Carlo system is coherent, derivable, and complete. Engines: Primitive Operators Engine (core actions: collapse, propagate, reflect, reset) Early Loop Forms Engine (safe looping patterns and stabilisation cycles) Base Constraints Engine (fundamental safety and validity rules) Layering Engine (stacked processing layers that don’t overwrite each other) Recursion Engine (safe, bounded recursive transformations) Multi Trajectory Engine (branching into multiple possible futures) State Space Compression Engine (reducing complexity without losing meaning) Carlo Visual Language Engine (ASCII‑safe symbolic representation) Big Daddy Engine V2 (full structural architecture of the system) Full Nelson Engine (maximum‑intensity transformation cycle) Hybrid Engines (structural + operational behaviour combined) Execution Pattern Engines (reusable operator sequences) Operational Engine Wrapper (selects and runs operational modes) Predictive Loop Mapper (forecasts loop behaviour and stability) Contradiction Compass (measures contradiction direction and magnitude) Trajectory Simulator (explores possible futures without choosing one) Cognitive Model (analyses how the system thinks) Meta Layer Engine Wrapper (unified access to all meta‑layer tools) Boundary Engine (keeps values and structures within safe limits) Validity Engine (ensures states are well‑formed and coherent) Loop Safety Engine (prevents infinite or unsafe loops) Collapse Safety Engine (ensures collapse never destroys essentials) State Space Guardrail Engine (prevents explosion or trivial collapse) Constraint Engine Wrapper (runs all constraint checks together) Infinity Engine (handles unbounded growth) Zero Engine (handles collapse to emptiness) Overload Engine (handles too much input or contradiction) Total Contradiction Engine (handles maximum conflict conditions) No Contradiction Engine (prevents over‑compression and stagnation) Degenerate Engine (repairs malformed or broken states) Extreme Case Engine Wrapper (runs all extreme‑case handlers) Fuck Cancer Engine V‑Omega‑Infinity‑Adaptive (maximum adaptive stabilisation) Adaptive Trajectory Simulator (stress‑aware future exploration) Adaptive Cognitive Model (stress‑responsive reasoning analysis) AI Reasoning Engine (adaptive rule interpretation and inference) Adaptive Engine Wrapper (unified adaptive behaviour) Minimal Working Example (smallest runnable Carlo flow) Barebones Template (universal engine skeleton) Universal Execution Flow (master lifecycle of a Carlo state) HTML Rendering Engine (browser‑native visualisation) Workflow Engine Wrapper (entry point for workflow tools) Appendices (diagrams, notes, glossary, future extensions) Keywords:Super Chain Loop; Carlo–Williams Engine; Carlo Framework; Carlo Visual Language; Carlo Reset Operator; Carlo Trajectory Simulator; Carlo Cognitive Model; Carlo AI Reasoning Engine; Universal Pseudocode; Engine Architecture; Operator Engine; Loop Dynamics; Recursive Systems; Meta‑Recursive Structures; Emergent Behaviour; System Flow Analysis; Computational Physics; Theoretical Computation; Abstract Machine Design; Adaptive Engine Models; Dynamic State Machines; State Transition Logic; High‑Order Looping; Feedback Loop Theory; Superposition Loops; Chain‑Linked Operators; Multi‑Layer Engine Design; Extreme Case Demonstrations; Minimal Working Example; Barebones Engine Template; Master Trajectory Update; Observational Tool Order; Predictive Loop Mapper; Contradiction Compass; Emergence Synthesiser; Stability Analysis; Nonlinear Systems; Complexity Theory; Information Flow; Symbolic Computation; Mathematical Modelling; Algorithmic Structures; Process Automation; Simulation Frameworks; Physics‑Coded Computation; Computational Abstractions; Formal Systems; Meta‑Systems Engineering; Self‑Referential Systems; Iterative Engine Design; High‑Dimensional Operators; Constraint‑Driven Dynamics; Adaptive Feedback; Systemic Coherence; Structural Invariants; Computational Semantics; Engine Index; Core Definitions; System Overview; Trajectory Mapping; Loop Collapse Theory; Super Chain Loop Mechanics; Chain‑Loop Coupling; Nested Loop Structures; Operator Hierarchies; Multi‑Stage Execution; Execution Pathways; Computational Topology; Symbolic Dynamics; Mathematical Operators; Calculus‑Linked Engine Design; Differential System Flow; Integral Loop Behaviour; Rate‑of‑Change Operators; Continuity Constraints; Discrete‑Continuous Hybrid Models; Meta‑Engine Construction; Framework Synthesis; Research Tools; Open Science; Zenodo Research; Computational Frameworks; Physics‑Inspired Engines; The Original Loop; Volume Series; Technical Documentation; Engine Specification; Advanced System Design; High‑Level Abstractions; Scientific Computing; Experimental Frameworks; Open‑Source Engine Research; Future Extensions; Engine Evolution; Adaptive Modelling; Cognitive‑Inspired Computation; Theoretical Engine Development; Research Infrastructure; Scientific Metadata; Academic Discovery; Knowledge Systems; Computational Reasoning; Symbolic Logic; Formal Verification; System Integrity; Process Coherence; Multi‑Operator Chains; Super Chain Loop Integration; Engine‑Level Recursion; Recursive Operator Networks; High‑Order Engine Behaviour; Meta‑Loop Execution; Cross‑Layer Dynamics; Computational Architecture; Systemic Feedback; Loop‑Driven Computation; Engine‑Scale Modelling; Abstract Dynamics; Mathematical Foundations; Research‑Grade Engine Design; Open Research Metadata; Scientific Keywords; Advanced Loop Theory; Chain‑Reaction Computation; Operator‑Linked Systems; Engine‑Wide Synchronisation; Temporal Dynamics; Causal Flow Mapping; Structural Loop Analysis; Computational Trajectories; Engine‑Based Reasoning; System‑Level Abstractions; High‑Fidelity Engine Models; Super Chain Loop Expansion; Engine‑Integrated Frameworks; Unified Engine Theory; Computational Meta‑Framework; Scientific Engine Toolkit; Carlo Engine Ecosystem
Salience-Queue Occupation Theory (SQOT) is a protocol-relative mathematical framework for analyzing when finite-budget operational processes lose effective control over their priority queues under persistent or adversarial salience sources. The manuscript formalizes salience occupation using observable histories, budget ledgers, diagnostic reserves, queue morphisms, finite certificate grammars, checkable ledgers, typed risk composition, self-auditing kernels, and route-sound checker semantics. The theory is designed for artificial, distributed, or post-biological operational systems, but it does not rely on subjective psychology or normative claims about what a process should attend to. Instead, it studies finite, auditable conditions under which a process can preserve diagnostic capacity, response or no-action availability, rollback or quarantine options, semantic-egress safety, mechanism-compatible incentives, and bounded verification cost. The results include finite checker semantics soundness, checked non-circular sovereignty certificates, typed risk composition, adaptive succinct-session soundness, egress abstraction refinement, and payoff-reflected mechanism robustness. SQOT explicitly limits its claims to declared validity domains and does not assert absolute physical, cryptographic, economic, or base-reality guarantees.
As autonomous driving technology advances towards Level 4 and 5, virtual simulation has become an indispensable tool for safety validation. However, a critical ''trust gap'' exists between developers and regulators; submitting raw simulation logs poses risks of data tampering (integrity issues) and intellectual property leakage (privacy issues). To address this, we propose ZK-V, a universal, privacy-preserving verification framework designed to interface with various autonomous driving simulators. By leveraging Zero-Knowledge Proofs and blockchain technology, ZK-V allows a Prover to cryptographically demonstrate that a simulation run adhered to specific safety constraints such as collision avoidance and speed limits without revealing the underlying telemetry data. This paper outlines the simulation-agnostic system architecture and constraint logic, offering a scalable solution for decentralized, trust-free certification in the Web 4.0 mobility era.
Abstract The SIS‑10 framework establishes a typed, invariant preserving safety calculus for cyber physical systems. It unifies temporal semantics, schedulability, semantic preservation, ML admissibility, cryptographic verification, and risk bounded control into a single mathematically coherent architecture. All domains and operators are fully explicit, enabling formal reasoning over system trajectories and safety envelopes. The temporal layer defines an ordered metric structure with drift aware bounded causality, interval set operators, and jitter robust event semantics. The QoS layer enforces schedulability and feasible actuation, ensuring that all control actions remain within admissible timing and load bounds. Semantic compression provides a safety preserving homomorphism that guarantees invariants survive dimensionality reduction. Multi‑modal fusion introduces cross sensor falsifiability, enabling fault detection through probabilistic disagreement. The ML layer is input validated and logic embedded, ensuring that all model outputs entail the SIS‑10 invariant set. The cryptographic layer supplies zero knowledge execution trace proofs, allowing runtime verification of transition correctness without revealing internal state. Predictive shutdown optimization is constrained by a formally defined safety envelope, ensuring that operational objectives never violate admissible safety bounds. Cyber physical risk evolves through a bounded monotone propagation model with explicit mitigation operators, while the Safety Twin provides deterministic and stochastic discrete time system dynamics. The inductive proof layer establishes global invariant preservation for all admissible executions, and the event→action mapping connects the formal calculus to real SIS triggers. SIS‑10 therefore constitutes a unified, verifiable, and implementation ready safety architecture, suitable for runtime assurance, cyber‑physical certification, and next generation functional safety systems. Further enhancements include graphical formalization, parameterized system tuning, implementation DSLs, and automated verification scripts, none of which alter the core mathematical model..
The relationship between deterministic polynomial time (P) and polynomial space (PSPACE) is one of the foundational open problems in computational complexity theory. While proving P = PSPACE remains elusive and is widely believed to be false, the characterizations of PSPACE have yielded profound insights into modern computer science, specifically cryptography and zero-knowledge proofs. This paper surveys the landscape of PSPACE, examines the three fundamental barriers preventing resolution, and presents original systems-level experiments in C and Python that make the space-time tradeoff at the heart of the problem tangible and measurable.
Pascal Berrang, Mirco Giacobbe, Jacob Swales, Xiao Yang
We introduce a technology to formally verify that a software system satisfies a temporal specification of functional correctness, without revealing the system itself. Our method combines a deductive approach to model checking to obtain a formal certificate of correctness for the system, with zero-knowledge proofs to convince an external verifier that the system -- kept secret -- complies with its specification of correctness -- made public. We consider proof certificates represented as ranking functions, and introduce both an explicit-state and a symbolic scheme for model checking in zero knowledge. Our explicit-state scheme assumes systems represented as transition graphs. We use polynomial commitments to convince the verifier that the public proof certificates correspond to the secret transition relation. Our symbolic scheme assumes systems specified as linear guarded commands and uses piecewise-linear ranking functions. We apply Farkas' lemma to obtain a witness for the validity of the ranking function with public and secret components, and employ sigma protocols for matrix multiplication and range proofs to convince the verifier of the witness's existence. We built a prototype to demonstrate the practical efficacy of our two schemes on linear temporal logic verification examples. Our technology enables formal verification in domains where both the safety and the confidentiality of the system under analysis are critical.
Miguel Isabel, Enric RodrÃguez-Carbonell, Clara RodrÃguez-Núñez, Albert Rubio
Zero-knowledge proofs (ZKPs) are an emerging technology that has become the solution to efficiently provide security and privacy along with the transparency requirement of blockchains. ZKPs are usually expressed by means of arithmetic circuits and, more generally, systems of polynomial equations in a large prime field (commonly ranging from 64-bit to 256-bit values). An increasing interest to apply formal verification techniques to ensure soundness and completeness properties of ZKP protocols has shown the need of developing powerful SMT solvers able to handle such constraint systems. In this paper we consider the problem of deciding the satisfiability of existentially quantified first-order formulas defined over polynomial equations on a prime field. We present a new DPLL($T$)-based approach in which the theory solver orchestrates several modules with different trade-offs between completeness and efficiency. We have implemented the proposed techniques in a prototype that already shows better results than existing state-of-the-art tools on both benchmarks from the domain of ZKP compiler correctness and new benchmarks coming from the verification of arithmetic circuits for ZKPs. \keywords{SMT \and Finite field \and Polynomials \and Zero-Knowledge Proofs.
This paper present a complete and irreducible formal specification for the SIS-10 safety kernel. The system satisfies totality, invariance, bounded causality, schedulability, feasibility, verifiability, machine-learning safety, compositional closure, and full observability. No additional axioms are required: the specification is dimensionally complete and closed under refinement. The tool is Apache Kafka. Kafka provides an ordered, durable, replayable event log with partitioned total order, replicated storage, and deterministic offsets. We show that Kafka's log semantics satisfy the requirements for totality, observability, compositionality, verifiability, and bounded causality. The resulting system is a closed and provably safe dynamical system. Keywords: safety kernel, formal methods, SIS-10, IEC 61508, Apache Kafka, event sourcing, compositional verification, zero-knowledge proofs, dynamical systems, functional safety.
We introduce a formal semantic Bell inequality for multi-agent validation systems and show that the MetaBell operator Ψ, deployed in the PoISV consensus protocol, functions as a rigorous Bell witness for genuine independent understanding. We derive Ψ ≈ 1 − |S̃|/(2√2), connecting Ψ to the Tsirelson bound and replacing the ad-hoc threshold with a data-driven calibrated threshold Ψ*. We further define a Bell-augmented SPVU goal state, an Immutable Incident Log satisfying EU AI Act Art. 12/17/19, a zero-knowledge proof of MetaBell compliance via Nexus zkVM, a Svetlichny-type k≥3 group extension, and the Semantic Bell Test Corpus (SBTC) for empirical validation. DOI: 10.5281/zenodo.19656679
WebAssembly linear memory is an untyped byte array shared across module boundaries. When independently compiled modules — potentially from different source languages — read and write the same memory regions, no existing type system covers the cross-module interface. We present typed-wasm, a type system that applies a 12-level progressive type safety framework, originally developed for database query languages, to Wasm linear memory. The system treats contiguous memory segments as typed region schemas and load/store operations as typed projections verified against those schemas at compile time. We formalise the system in Idris 2 using Quantitative Type Theory (QTT), providing proofs of bounds safety, aliasing freedom, effect purity, lifetime validity, linearity, cost boundedness, and epistemic freshness — all erased before code generation, yielding zero runtime overhead. Our principal contribution is multi-module schema agreement: a static verification that independently compiled Wasm modules agree on the layout, types, alignment, and invariants of shared memory regions — a property that no source-level type system, and no existing Wasm proposal, can express. We further extend the framework with two novel levels: tropical cost-tracking (Level 11), which proves that memory access patterns have bounded cost via a min-plus semiring, and epistemic safety (Level 12), which prevents modules from acting on stale knowledge of shared state.
The order-statistic gaps that underlie PPP-residualized functional identity measurement are exactly invariant to log-softmax transformation, exactly equivariant under positive scaling (including temperature), and exactly invariant to any position-independent constant shift applied to the logit vector. These are not empirical approximations — they are mathematical identities that hold for any logit vector over any vocabulary size. The result has been formally verified in Coq (GapInvariance.v: 5 theorems, 2 axioms, 0 Admitted). It retroactively strengthens the empirical API-wall finding reported in earlier work: the order-statistic gap geometry measured through API logprobs does not merely "survive" the log-softmax transformation — it is mathematically immune to it. Any deviation attributable to the API boundary must come from truncation, quantization, or coverage limitations, not from the probability-domain transformation itself. Why this matters. Earlier work showed empirically that PPP-based measurements remained stable when models were accessed through APIs that expose log-probabilities instead of raw logits. This note upgrades that result from empirical robustness to mathematical invariance. It removes the probability-domain transformation itself from the list of plausible failure modes. If an API-based PPP measurement deviates from a weights-based measurement, the cause must lie in truncation, quantization, coverage limitations, or the model — not in log-softmax. The API wall is narrower than previously understood, and the space of plausible objections to API-domain model identity measurement has shrunk by one major category. Supplementary Material. This note is accompanied by GapInvariance.v, a Coq proof file that formally verifies the five gap-invariance theorems described in §2: constant-shift invariance, positive-scale equivariance, affine scaling, log-softmax invariance, and general position-independent shift invariance. The file proves 5 theorems from 2 named axioms (OS1 and OS2), with no unresolved obligations (Admitted), and compiles cleanly under the Rocq Prover 9.1.1 (the current release of the Coq proof assistant, compiled with OCaml 5.4.0). It is available for download as a supplementary file attached to this record. The Neural Network Identity Series — Mathematical foundations, empirical validation, and governance frameworks for verifying which model is running Newest addition: Technical Note: The Disappearing Window — AI Logprob Access Withdrawal and the Structural Verifiability of Frontier Model Contracts (DOI: 10.5281/zenodo.20362098) Paper 1: The δ-Gene: Inference-Time Physical Unclonable Functions from Architecture-Invariant Output Geometry (DOI: 10.5281/zenodo.18704275) Paper 2: Template-Based Endpoint Verification via Logprob Order-Statistic Geometry (DOI: 10.5281/zenodo.18776711) Paper 3: The Geometry of Model Theft: Distillation Forensics, Adversarial Erasure, and the Illusion of Spoofing (DOI: 10.5281/zenodo.18818608) Paper 4: Provenance Generalization and Verification Scaling for Neural Network Forensics (DOI: 10.5281/zenodo.18872071) Paper 5: Beneath the Character: The Structural Identity of Neural Networks — Mathematical Evidence for a Non-Narrative Layer of AI Identity (DOI: 10.5281/zenodo.18907292) Paper 6: Which Model Is Running?: Structural Identity as a Prerequisite for Trustworthy Zero-Knowledge Machine Learning (DOI: 10.5281/zenodo.19008116) Paper 7: The Deformation Laws of Neural Identity (DOI: 10.5281/zenodo.19055966) Paper 8: What Counts as Proof? — Admissible Evidence for Neural Network Identity Claims (DOI: 10.5281/zenodo.19058540) Paper 9: Composable Model Identity — Formal Hardening of Structural Attestations in the Enterprise Identity Stack (DOI: 10.5281/zenodo.19099911) Paper 10:Where Identity Comes From: Path Sensitivity and Endpoint Underdetermination in Neural Network Training (DOI: 10.5281/zenodo.19118807) Paper 11: Post-Hoc Disclosure Is Not Runtime Proof: Model Identity at Frontier Scale (DOI: 10.5281/zenodo.19216634) Paper 12: Family-Dependent Response to Reasoning Distillation Across Structural and Functional Identity Layers (DOI: 10.5281/zenodo.19298857) Paper 13: Safety-Alignment Removal as a Model-Identity Failure — Structural Evidence from Published Weight-Level Mutation Checkpoints (DOI: 10.5281/zenodo.19383019) Technical Note: Agent Identity Is Not Model Identity (DOI: 10.5281/zenodo.19240883) Technical Note: Gap Invariance: Why PPP Measurements Are Domain-Independent by Construction (DOI: 10.5281/zenodo.19275524) Technical Note: Measured Model Substitution Under Valid Agent Credentials (DOI: 10.5281/zenodo.19342848) Technical Note: Artifact Identity Is Not Runtime Identity — Trustfall Lite and the Boundary of File-Level Model Verification (DOI: 10.5281/zenodo.20019127) Formal Verification Stack for Neural Network Structural Identity (IT-PUF Coq Proofs) (DOI: 10.5281/zenodo.18930621) Copyright (c) 2026 Anthony Ray Coslett / Fall Risk AI, LLC. All Rights Reserved. Confidential and Proprietary. Patent Pending (Applications 63/982,893, 63/990,487, 63/996,680, 64/003,244).
LICITRA Technical Report Series, Report No. LICITRA-TR-2026-01, Version 0.2. This report documents LICITRA-MMR, an open-source ledger primitive that combines a Merkle Mountain Range (MMR) data structure with per-organization epoch anchoring, a versioned canonical JSON specification, and an atomic two-phase commit pipeline for cryptographic audit integrity in agentic AI systems. At a block size of 1,000 events, LICITRA-MMR produces inclusion proofs requiring 14 SHA-256 operations and verifies a full epoch chain of 1,000 epochs in under 1 ms. The system is a single-operator forensic integrity primitive providing no Byzantine fault tolerance, no distributed consensus, and no confidentiality guarantees. Part of the LICITRA Technical Report Series. Companion report: LICITRA-TR-2026-02 (LICITRA-SENTRY, DOI: 10.5281/zenodo.18843784).
Rong Fu, Jia Yee Tan, Ziyu Kong, Shuning Zhang · 8 authors
Zero-knowledge circuits enable privacy-preserving and scalable systems but are difficult to implement correctly due to the tight coupling between witness computation and circuit constraints. We present zkCraft, a practical framework that combines deterministic, R1CS-aware localization with proof-bearing search to detect semantic inconsistencies. zkCraft encodes candidate constraint edits into a single Row-Vortex polynomial and replaces repeated solver queries with a Violation IOP that certifies the existence of edits together with a succinct proof. Deterministic LLM-driven mutation templates bias exploration toward edge cases while preserving auditable algebraic verification. Evaluation on real Circom code shows that proof-bearing localization detects diverse under- and over-constrained faults with low false positives and reduces costly solver interaction. Our approach bridges formal verification and automated debugging, offering a scalable path for robust ZK circuit development.
Open access
2 source records
Physical Unclonable Functions (PUFs) and Hardware Security
Zero-Knowledge (ZK) proof systems are cryptographic protocols that can (with overwhelming probability) demonstrate that the pair $(X, W)$ is in a relation $R$ without revealing information about the private input $W$. This membership checking is captured by a complex arithmetic circuit: a set of polynomial equations over a finite field. ZK programming languages, like Noir, have been proposed to simplify the description of these circuits. A developer can write a Noir program using traditional high-level constructs that can be compiled into a lower-level ACIR (Abstract Circuit Intermediate Representation), which is essentially a high-level description of an arithmetic circuit. In this paper, we formalise some of the ACIR language using SMT-LIB and its extended theory of finite fields. We use this formalisation to create an open-source formal verifier for the Noir language using the SMT solver cvc5. Our verifier can be used to check whether Noir programs behave appropriately. For instance, it can be used to check whether a Noir program has been properly constrained, that is, the finite-field polynomial equations generated truly capture the intended relation. We evaluate our verifier over 4 distinct sets of Noir programs, demonstrating its practical applicability and identifying a hard-to-check constraint type that charts an improvement path for our verification framework.