The paper presents a design-time verification framework for truly fearless concurrent and distributed systems. It describes a compiler that tracks wait‑for edges, preserves proofs while lowering code directly to native CPU, GPU, NPU, and FPGA targets, and uses a Program Semantic Graph to maintain the values and relationships that justify boundary contracts. Four verification tiers—structural inference, local arithmetic checks, reusable domain lemmas, and probabilistic relational proofs—enable comprehensive verification without developer annotations, supporting distributed proofs with Iris, Actris, and Aneris.
arXiv:2608. 13522v1 Announce Type: cross Abstract: AI agents are increasingly used for programming, but do not provide any guarantee on the correctness of generated code.
arXiv:2608. 09277v1 Announce Type: new Abstract: Verified code generation asks a large language model (LLM) to generate both an executable program and a machine-checkable proof that the program meets a formal specification, promising software that is correct by construction.
AI agents are increasingly used for programming, but do not provide any guarantee on the correctness of generated code. Verified code generation, in which an agent produces both an implementation and a machine-checked proof of its specification, offers a stronger path toward trustworthy AI-generated software.
arXiv:2607. 06341v1 Announce Type: cross Abstract: Formal verification offers the strongest guarantee of software correctness, but it does not scale: the proofs demanded by interactive theorem provers such as Coq require enormous expert effort.
arXiv:2606. 00220v1 Announce Type: cross Abstract: Formal methods provide rigorous accounts of program behavior, but practical software engineering often works through executable libraries, tests, and incremental design.
arXiv:2607. 14137v2 Announce Type: cross Abstract: To answer a question about a program, move the program to where the question is decidable.
Whiel is a Lean‑certified neurosymbolic platform for reasoning about imperative relational programs. It encodes containment and equivalence for Datalog, its negated extensions, and core graph query fragments, and can represent optimized evaluation algorithms and first‑order specifications of integrity constraints, schema mappings, and views. The system uses Hoare‑style reasoning with prophecy variables and leveled invariants, and supports neurosymbolic discovery of loop invariants verified by the Vampire theorem prover, with counterexamples fed back into the pipeline and solutions translated into Lean proof certificates.
The paper introduces Rewindable Interactive Proofs (RIPs), a new model for scalable oversight where a weak verifier can rewind a powerful AI prover to an earlier state during interaction. RIPs enable verification of oracle‑aided computations that are robust to small changes in oracle answers, achieving near‑linear verifier time without relying on cryptography. The authors provide a construction, implement it on MNIST, and demonstrate that RIPs can outperform existing proof systems in practice.
arXiv:2607. 17780v1 Announce Type: cross Abstract: ETAS is a programming language for agent systems that treats model-backed agents, tool calls, prompts, typed memory, human approvals, policies, and execution traces as semantic program elements rather than library conventions.
Programmers write formal specifications, and LLMs implement them, proving that each implementation matches its spec. Taken to its extreme, this makes specification languages the new programming langua...
arXiv:2608. 03609v1 Announce Type: new Abstract: Agentic systems driven by large language models (LLMs) are increasingly deployed in real-world workflows where they act on persistent operational data.
The paper introduces Rewindable Interactive Proofs (RIPs), a new model for scalable oversight where a weak verifier can rewind a powerful AI prover to an earlier state during interaction. RIPs enable efficient verification of computations whose outputs are robust to small changes in oracle answers, achieving near-linear verifier time without relying on cryptography. The authors implement the protocol, demonstrate a preliminary MNIST experiment, and show that an RIP can outperform a state‑of‑the‑art deployed proof system.