# Formal verification

Formal verification is the discipline of mathematically proving that hardware or software systems satisfy precisely stated specifications.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Formally Verified Semidefinite Programming

DevFeed: [Formally Verified Semidefinite Programming](<https://devfeed.tech/articles/formally-verified-semidefinite-programming-145773.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25174>)

Author: Perry Hart

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [software](<https://devfeed.tech/tags/software.md>), [verification](<https://devfeed.tech/tags/verification.md>), [verus](<https://devfeed.tech/tags/verus.md>)

### AI overview

The paper presents a first-order semidefinite programming solver implemented in Rust and formally verified in Verus. The authors wrote the solver by hand, then directed Claude to generate its verification. They describe the solver's algorithm, Rust implementation, and pragmatic approach to proving it correct. The excerpt gives no further details about the algorithm or the scope of the proofs.

### Source excerpt

arXiv:2611.25174v1 Announce Type: new Abstract: We present a formally verified Rust implementation of a first-order semidefinite programming solver, a nontrivial piece of numerical software. We wrote the solver by hand and then directed Claude to generate the entire verification in Verus, an automated theorem prover for Rust programs. We discuss the algorithm underlying the solver, its implementation in Rust, and our pragmatic approach to proving it correct in Verus.

## Structure-Behavior Coalescence: A Definition of Systems

DevFeed: [Structure-Behavior Coalescence: A Definition of Systems](<https://devfeed.tech/articles/structure-behavior-coalescence-a-definition-of-systems-142131.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23254>)

Author: William S. Chao

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [systems](<https://devfeed.tech/topics/systems.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Specifications](<https://devfeed.tech/topics/specifications.md>)

Tags: [behavior](<https://devfeed.tech/tags/behavior.md>), [coherence](<https://devfeed.tech/tags/coherence.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [definition](<https://devfeed.tech/tags/definition.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [formal](<https://devfeed.tech/tags/formal.md>), [framework](<https://devfeed.tech/tags/framework.md>), [identity](<https://devfeed.tech/tags/identity.md>), [interaction](<https://devfeed.tech/tags/interaction.md>), [intermediate](<https://devfeed.tech/tags/intermediate.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [provides](<https://devfeed.tech/tags/provides.md>), [rules](<https://devfeed.tech/tags/rules.md>), [sbc](<https://devfeed.tech/tags/sbc.md>), [structure](<https://devfeed.tech/tags/structure.md>), [system](<https://devfeed.tech/tags/system.md>), [systems](<https://devfeed.tech/tags/systems.md>), [systems-engineering](<https://devfeed.tech/tags/systems-engineering.md>), [terminal](<https://devfeed.tech/tags/terminal.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Structure-Behavior Coalescence (SBC) defines a system as an integrated entity in which structure and behavior are joined through interaction. It proposes well-formedness constraints to preserve their coherence, with representations for terminal, paused, and intermediate states and rules for sequential, parallel, and alternative behaviors. The abstract presents SBC as a formal basis for consistent system modeling, verification, and analysis; it does not provide details of those methods.

### Source excerpt

arXiv:2611.23254v1 Announce Type: new Abstract: For more than seventy years, systems engineering has developed extensive models and frameworks, yet the fundamental question of what constitutes a system remains insufficiently formalized. Existing approaches often treat structure and behavior as separate aspects, leaving their unity, system identity, and consistency conditions insufficiently defined. This paper introduces Structure-Behavior Coalescence (SBC) as a formal framework that defines a system as an integrated entity in which structure and behavior are coalesced through interaction. SBC provides a formal modeling approach with well-formedness constraints for maintaining structural-behavioral coherence, including representations for terminal, paused, and intermediate states and rules for sequential, parallel, and alternative behaviors. The framework provides a formal perspective on the question, "What is a system?", and establishes a foundation for consistent system modeling, verification, and analysis.

## FormalFixer: Intent-Aligned Automated Hardware Repair via Joint Refinement of Specifications, Assertions, and RTL Implementations

DevFeed: [FormalFixer: Intent-Aligned Automated Hardware Repair via Joint Refinement of Specifications, Assertions, and RTL Implementations](<https://devfeed.tech/articles/formalfixer-intent-aligned-automated-hardware-repair-via-joint-refinement-of-specifications-assertions-and-rtl-implementations-142744.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24037>)

Author: Changyuan Yu, Hongce Zhang

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Verilog](<https://devfeed.tech/topics/verilog.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [align](<https://devfeed.tech/tags/align.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [also](<https://devfeed.tech/tags/also.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [assertions](<https://devfeed.tech/tags/assertions.md>), [automated](<https://devfeed.tech/tags/automated.md>), [based](<https://devfeed.tech/tags/based.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [change](<https://devfeed.tech/tags/change.md>), [compromise](<https://devfeed.tech/tags/compromise.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [defect](<https://devfeed.tech/tags/defect.md>), [designs](<https://devfeed.tech/tags/designs.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [repair](<https://devfeed.tech/tags/repair.md>), [rtl](<https://devfeed.tech/tags/rtl.md>), [specifications](<https://devfeed.tech/tags/specifications.md>)

### AI overview

FormalFixer treats a failed formal property verification (FPV) assertion as a possible mismatch among specification intent, verification intent, and RTL behavior--not necessarily an RTL defect. For Verilog designs with assertions, it keeps the original specification as authoritative and appends confidence-filtered refinements to clarify implicit constraints. It then uses intent mismatch and verifier-generated counterexample cone graphs to guide iterative RTL patching, explicitly checking correspondence among the specification, assertions, and RTL. The excerpt reports results supporting intent alignment for FPV-based repair, but provides no quantitative results or workflow details.

### Source excerpt

arXiv:2611.24037v1 Announce Type: cross Abstract: Functional errors in hardware designs can compromise correctness and security, and must be fixed before tape-out. Formal property verification (FPV) provides strong guarantees by proving or refuting assertions, but a failed assertion is not always evidence of an RTL defect: the failure may also come from a buggy assertion or from a specification that is semantically correct but too ambiguous or incomplete for direct formalization. This creates a practical repair problem that existing RTL-centric methods do not directly address: the repair loop must align specification intent, verification intent, and RTL behavior before deciding which artifact to change. \textsc{FormalFixer} addresses this problem with a multi-stage, intent-aligned repair workflow for Verilog designs with assertions. It preserves the original specification as authoritative ground truth and appends confidence-filtered refinements to clarify implicit constraints. \textsc{FormalFixer} uses both intent mismatch and verifier-generated counterexample cone graphs to guide iterative RTL patching. This workflow explicitly checks specification--assertion--RTL correspondence. Results support intent alignment for FPV-based hardware repair.

## Isabelle Pool Server: a pooled verification service for prover training and multi-agent proving

DevFeed: [Isabelle Pool Server: a pooled verification service for prover training and multi-agent proving](<https://devfeed.tech/articles/isabelle-pool-server-a-pooled-verification-service-for-prover-training-and-multi-agent-proving-142832.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24788>)

Author: Xuanwei Ren, Wenda Li

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Isabelle/HOL proof assistant](<https://devfeed.tech/topics/isabelle-hol-proof-assistant.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>)

Tags: [admission](<https://devfeed.tech/tags/admission.md>), [api](<https://devfeed.tech/tags/api.md>), [block](<https://devfeed.tech/tags/block.md>), [budget](<https://devfeed.tech/tags/budget.md>), [build](<https://devfeed.tech/tags/build.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [container](<https://devfeed.tech/tags/container.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [headless](<https://devfeed.tech/tags/headless.md>), [http](<https://devfeed.tech/tags/http.md>), [interface](<https://devfeed.tech/tags/interface.md>), [isabelle](<https://devfeed.tech/tags/isabelle.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-servers](<https://devfeed.tech/tags/mcp-servers.md>), [memory-pressure](<https://devfeed.tech/tags/memory-pressure.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [python](<https://devfeed.tech/tags/python.md>), [server](<https://devfeed.tech/tags/server.md>), [service](<https://devfeed.tech/tags/service.md>), [training](<https://devfeed.tech/tags/training.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Isabelle Pool Server (IPS) serves warm, headless Isabelle sessions through an HTTP API, with session leasing and reclamation, memory-aware admission control, and per-call time limits. Its interface supports single-step execution, block-level checking, whole-theory builds, and checkpoints for branching and backtracking; a fresh build is the final arbiter. It is available as a container through a Python client, two MCP servers, or raw HTTP. In the reported measurements, IPS matched PIDE MCP at one worker and outperformed it at eight (at an October 2026 commit); with sessions running, it handled 32 concurrent workers on one host at 24 times the single-worker rate. Under memory pressure, it rejects new sessions to preserve existing ones.

### Source excerpt

arXiv:2611.24788v1 Announce Type: cross Abstract: Isabelle Pool Server (IPS), a verification service with a pool of warm headless Isabelle sessions behind an HTTP API, with session leasing and reclamation, memory-aware admission control, and a time budget on every call. Its verification interface spans single-step execution, block-level proof checking and whole-theory builds, with checkpoints for cheap branching and backtracking, and a build from scratch as the final arbiter. The service runs as a single container with monitoring and is accessible via a Python client, two MCP servers and a raw HTTP API. In our measurements IPS is level with PIDE MCP, a PIDE frontend for agents, at one worker and ahead of it at eight, at its commit of October 2026 (the tool is now PIDE AI). Once its sessions are up it scales to 32 concurrent workers on one host at 24 times the single-worker rate, and under memory pressure it refuses new sessions rather than losing existing ones. IPS is free software and publicly available at https://github.com/Deep-LCF/Isabelle-Pool-Server

## Worth Reading: LLM-Based Program Verification

DevFeed: [Worth Reading: LLM-Based Program Verification](<https://devfeed.tech/articles/worth-reading-llm-based-program-verification-142343.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2026/11/worth-reading-llm-program-verification/>)

Published: 2026-11-18T10:55:00Z

Content type: opinion

Language: en

Sources: [ipSpace](<https://devfeed.tech/sources/ipspace-net-blog-2.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [article](<https://devfeed.tech/tags/article.md>), [exploits](<https://devfeed.tech/tags/exploits.md>), [formal](<https://devfeed.tech/tags/formal.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [program](<https://devfeed.tech/tags/program.md>), [reading](<https://devfeed.tech/tags/reading.md>), [verification](<https://devfeed.tech/tags/verification.md>), [worth-reading](<https://devfeed.tech/tags/worth-reading.md>)

### AI overview

The excerpt points to a researcher's article on using LLMs to verify program correctness, noting that the approach works. It cautions that similar verification tools existed before and were more optimized, likening LLM use for solvable tasks to running Unix through layers of emulation. The source offers no technical details or tool comparisons.

### Source excerpt

I'm busy finalizing the 26.11 netlab release and don't have the time or willpower for full-blown blog posts at the moment, so you'll get more pointers than anything else. I stumbled upon an interesting What's going on with program verification? article, in which a researcher working on formal program verification (which is what we'll badly need in the era of AI generating exploits at scale) describes the efforts to verify correctness with LLMs. Read more ...

## TLAPS-Bench: Formally Proving Correctness Of Real-World System Specifications With TLA+ Proof System

DevFeed: [TLAPS-Bench: Formally Proving Correctness Of Real-World System Specifications With TLA+ Proof System](<https://devfeed.tech/articles/tlaps-bench-formally-proving-correctness-of-real-world-system-specifications-with-tla-proof-system-141207.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/11/tlaps-bench-formally-proving.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-11-18T06:19:39Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Isabelle/HOL proof assistant](<https://devfeed.tech/topics/isabelle-hol-proof-assistant.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [bench](<https://devfeed.tech/tags/bench.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [harness](<https://devfeed.tech/tags/harness.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [targets](<https://devfeed.tech/tags/targets.md>), [tla-plus](<https://devfeed.tech/tags/tla-plus.md>)

### AI overview

TLAPS-Bench tests whether agents can prove system-wide safety, liveness, and refinement properties in TLA+ without supplied proof scaffolds. Its 265 targets across 95 specifications include a 70-target hard active set; on that set, the best reported model proved 31 targets (44.3%) at pass@3. Tilapia runs agents in isolated containers with TLAPS, TLC, and Apalache, and uses model checking to falsify candidate invariants before proof attempts. Apalache checks bounded transitions symbolically but requires types; when it cannot type a spec, TLC can test inductiveness by enumerating candidate states, which may become expensive. The benchmark also exposed specification, model, and configuration defects, illustrating that proof attempts and model checking can reveal different issues. Results remain limited: no model proved the Wildfire refinement, and many failures involved missing invariants or proof obligations too large for solvers. Accepted proofs can also be lengthy and difficult for engineers to review.

### Source excerpt

TLA+ specification language has long been associated exclusively with TLC model checker in most people's minds. Model checking with TLC finds bugs fast, but it only covers the configuration you give it, and is cheap only for small configurations (3 nodes, value ranges "1..4", etc.). There is also the TLA+ Proof System, TLAPS, which checks a deductive proof, instead of enumerating states like model checking. After you write the proof in TLA+ as a hierarchy of numbered steps, TLAPS turns each step into proof obligations and hands them to backend provers. Being a prover, TLAPS can cover all configurations at once, but it requires a lot of expertise and effort. I had always stayed away from TLAPS, because I hadn't felt I am up to the challenge. You have to figure out the inductive invariant (see below), show every action preserves it, and divide the argument into obligations small enough for Z3, Isabelle, or LS4 to check. So in practice what ends up happening is that almost everyone model checks and almost nobody proves. Well, like with most things in our industry, this changed drastically in the last year. Earlier this summer, my mind was blown when I saw Claude doing TLAPS proofs! Holy molly, I didn't have this on my bingo card for this year! I knew it would be smart to invest more on this, and it turns out Tianyin Xu, Qian Cheng, and Markus Kuppe were already working on it, and they had a paper in the works. I joined the team late, and I am not sure if I was able to contribute significantly. It was great to collaborate and associate with such a qualified team nevertheless. The paper is now on arXiv, and the code is on GitHub. The paper asks how much of the proof burden the agents can carry today, and introduces a benchmark and a harness to investigate this. TLAPS-Bench is a benchmark of 265 proof targets from 95 TLA+ specs of real systems and protocols. Tilapia is the harness that runs agents on those targets, and it provides the proof checker, the model checkers, th

## RyBench: Runtime Verification Benchmarking Framework over Publish/Subscribe Networks

DevFeed: [RyBench: Runtime Verification Benchmarking Framework over Publish/Subscribe Networks](<https://devfeed.tech/articles/rybench-runtime-verification-benchmarking-framework-over-publish-subscribe-networks-139604.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22401>)

Author: Mehmet Hilmi D\\"undar (Bo\\u{g}azi\\c{c}i University), Do\\u{g}an Ulus (Bo\\u{g}azi\\c{c}i University)

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Phoronix Test Suite](<https://devfeed.tech/topics/phoronix-test-suite.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [also](<https://devfeed.tech/tags/also.md>), [application](<https://devfeed.tech/tags/application.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-systems](<https://devfeed.tech/tags/autonomous-systems.md>), [based](<https://devfeed.tech/tags/based.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [channel](<https://devfeed.tech/tags/channel.md>), [components](<https://devfeed.tech/tags/components.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data](<https://devfeed.tech/tags/data.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [efficiently](<https://devfeed.tech/tags/efficiently.md>), [framework](<https://devfeed.tech/tags/framework.md>), [networks](<https://devfeed.tech/tags/networks.md>), [over](<https://devfeed.tech/tags/over.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

RyBench provides a common way to benchmark runtime verification tools over publish/subscribe networks by publishing synthetic events in place of a monitored system. It separates event generation, serialization, and transport, allowing different strategies, formats, and transport layers to be combined. The paper evaluates throughput across configurations using Open Simulation Interface (OSI) schemas and Timescales properties, and demonstrates an end-to-end workflow with Reelay and an integration with MonPoly. The supplied abstract identifies throughput and verdict latency as practical concerns but gives no comparative latency results.

### Source excerpt

arXiv:2611.22401v1 Announce Type: cross Abstract: Autonomous systems built as distributed, node-based systems communicate via publish/subscribe middleware. Runtime Verification (RV) tools are used to monitor those systems against formal specifications, receiving monitored events through the pub/sub channel. An RV tool's practical value depends on its monitoring throughput capacity and verdict latency, besides its correctness, so a systematic benchmarking setup is needed to evaluate how efficiently these tools run. This paper presents RyBench, a pub/sub-based benchmarking framework that acts as a synthetic event publisher in place of a monitored system, providing a common benchmarking setup. RyBench separates benchmark generation, serialization, and transport into distinct components, enabling the combination of different event-generation strategies, data formats, and transport layers. We also evaluate the framework's throughput capacity across these configurations using Open Simulation Interface (OSI) schemas and Timescales properties, and illustrate the end-to-end benchmarking flow through an application to Reelay and an integration with MonPoly.

## Formal Analysis of a Fault-Tolerant Extension of the ROSACE Flight Controller

DevFeed: [Formal Analysis of a Fault-Tolerant Extension of the ROSACE Flight Controller](<https://devfeed.tech/articles/formal-analysis-of-a-fault-tolerant-extension-of-the-rosace-flight-controller-139603.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22394>)

Author: Marco Bozzano (Fondazione Bruno Kessler), Alessandro Cimatti (Fondazione Bruno Kessler), Moussa Fall (Fondazione Bruno Kessler, University of Trento), Stefano Tonetta (Fondazione Bruno Kessler)

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Model driven development](<https://devfeed.tech/topics/model-driven-development.md>), [reliability-engineering](<https://devfeed.tech/topics/reliability-engineering.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [analyze](<https://devfeed.tech/tags/analyze.md>), [approach](<https://devfeed.tech/tags/approach.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [based](<https://devfeed.tech/tags/based.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [builds](<https://devfeed.tech/tags/builds.md>), [cases](<https://devfeed.tech/tags/cases.md>), [component](<https://devfeed.tech/tags/component.md>), [control](<https://devfeed.tech/tags/control.md>), [controller](<https://devfeed.tech/tags/controller.md>), [controllers](<https://devfeed.tech/tags/controllers.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-sc](<https://devfeed.tech/tags/cs-sc.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [design](<https://devfeed.tech/tags/design.md>), [extension](<https://devfeed.tech/tags/extension.md>), [flight](<https://devfeed.tech/tags/flight.md>), [formal](<https://devfeed.tech/tags/formal.md>)

### AI overview

The study extends the ROSACE flight-control benchmark with an FDIR component based on Triple Modular Redundancy to address faults such as sensor noise and sensor failures. Using COMPASTA, a model-based design tool built on ESA's TASTE, the authors model and inject faults, then use a simulation-based workflow to generate and run tests according to user-defined coverage. They construct formal models with faults and FDIR and analyze effects on system properties by coupling those models with the Simulink models used in simulation.

### Source excerpt

arXiv:2611.22394v1 Announce Type: new Abstract: Autonomous avionics controllers must satisfy stringent real-time functional and performance require- ments even in the presence of run-time faults. In this paper, we analyze ROSACE, an open-source control engineering benchmark for flight control systems, focusing on its run-time resilience against faults such as sensor noise and sensor failures. We extend the benchmark with an FDIR (Fault Detection, Identification and Recovery) component based on Triple Modular Redundancy. Our approach builds upon COMPASTA, a tool for Model-Based Design developed on top of the TASTE tool by ESA. COMPASTA enables the modeling and injection of faults into a system's design. Moreover, it implements a simulation-based verification and validation workflow, automating the generation and execution of a set of test cases, based on a user-defined notion of coverage. Using COMPASTA, we construct a set of formal models, with faults and with FDIR, and we formally analyze their impact on the system properties. The analysis is based on the coupling of the formal models with the Simulink models used for the simulations.

## BernBRS: Certified Backward Reachability for Deep Bernstein Neural Networks

DevFeed: [BernBRS: Certified Backward Reachability for Deep Bernstein Neural Networks](<https://devfeed.tech/articles/bernbrs-certified-backward-reachability-for-deep-bernstein-neural-networks-141731.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22083>)

Author: Ibrahim Albool, Yasser Shoukry

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Deep learning](<https://devfeed.tech/topics/deep-learning.md>), [Deep neural networks](<https://devfeed.tech/topics/deep-neural-networks.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>)

Tags: [activation-functions](<https://devfeed.tech/tags/activation-functions.md>), [approximation](<https://devfeed.tech/tags/approximation.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [neural-networks](<https://devfeed.tech/tags/neural-networks.md>), [reachability-analysis](<https://devfeed.tech/tags/reachability-analysis.md>), [safety](<https://devfeed.tech/tags/safety.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

BernBRS computes certified inner and outer approximations of the backward reachable set for DeepBern-Nets, which use Bernstein polynomial activations. It refines an input-space cover by analyzing activation patterns and splitting where an exact decomposition of the relaxation gap predicts the greatest error reduction, rather than relying on a single convex bound. The abstract reports scalability to complex architectures and evaluates the method on a linearized closed-loop Half-Cheetah controller and a distilled Bernstein student of a Transformer block; it also empirically examines how these model-level guarantees relate to the original Half-Cheetah and TinyBERT classifier. The supplied evidence does not give quantitative results.

### Source excerpt

arXiv:2611.22083v1 Announce Type: new Abstract: Ensuring the safety of complex neural network systems requires mathematically rigorous verification. While backward reachability analysis is a critical tool for identifying safe initial states, computing tight, formal bounds remains notoriously difficult to scale. Recent advancements have demonstrated that DeepBern-Nets neural networks utilizing Bernstein polynomial activation functions possess advantageous mathematical properties that enable exceptionally fast and tight forward reachability analysis. Building upon this efficiency, this paper introduces BernBRS, a highly accurate and scalable framework for the backward reachability analysis of DeepBern-Nets. BernBRS simultaneously computes certified inner and outer approximations of the Backward Reachable Set (BRS). Rather than relying on single convex bounding, our method intelligently refines a cover of the input space by analyzing activation patterns, splitting the input domain precisely where an exact decomposition of the relaxation gap predicts the most significant reduction in error. This targeted refinement enables high levels of scalability to highly complex and massive architectures that remain intractable for existing certified methods. We demonstrate the efficacy of our framework on high-dimensional models, including a linearized closed-loop approximation of the Half-Cheetah controller and a distilled Bernstein student of a Transformer block and we empirically study how these model-level guarantees relate to the original Half-Cheetah and TinyBERT classifier, respectively.

## BehaVerify: A Formal Verification Tool for Behavior Trees

DevFeed: [BehaVerify: A Formal Verification Tool for Behavior Trees](<https://devfeed.tech/articles/behaverify-a-formal-verification-tool-for-behavior-trees-139605.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22403>)

Author: Serena S. Serbinowska (Vanderbilt University), Ben Wooding (Vanderbilt University), Diego Manzanas Lopez (Vanderbilt University), Luke Nam (Vanderbilt University), Anne M. Tumlin (Vanderbilt Universit

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Jule](<https://devfeed.tech/topics/jule.md>), [Isaac Sim](<https://devfeed.tech/topics/isaac-sim.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [behaviors](<https://devfeed.tech/tags/behaviors.md>), [bt](<https://devfeed.tech/tags/bt.md>), [critical](<https://devfeed.tech/tags/critical.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-ro](<https://devfeed.tech/tags/cs-ro.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [domain-specific-language](<https://devfeed.tech/tags/domain-specific-language.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [formal](<https://devfeed.tech/tags/formal.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [linear](<https://devfeed.tech/tags/linear.md>), [logic](<https://devfeed.tech/tags/logic.md>), [monitors](<https://devfeed.tech/tags/monitors.md>), [tool](<https://devfeed.tech/tags/tool.md>), [trees](<https://devfeed.tech/tags/trees.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

BehaVerify provides a DSL for modeling behavior trees and Neuro-Symbolic behavior trees, with Linear Temporal Logic and Computation Tree Logic specifications. It checks whether specifications hold by encoding the trees into nuXmv using a method called fastforwarding. The toolbox can also generate Python and Haskell implementations; its Python support integrates with PyTrees and ROS and has been deployed on autonomous robotic systems, including for runtime monitor verification. The manuscript focuses on the toolbox's use, features, and implementation. The supplied text does not give benchmark results or detail the verification limits.

### Source excerpt

arXiv:2611.22403v1 Announce Type: new Abstract: This paper presents BehaVerify, a verification toolbox for behavior trees (BTs) and Neuro-Symbolic BTs. BTs are a graphical language for planning and sequencing behaviors - similar to extended state machines - and are increasingly used in safety-critical domains. BehaVerify enables users to specify a BT using a Domain Specific Language (DSL) with formal syntax and semantics. This language further includes Linear Temporal Logic and Computation Tree Logic specifications. BehaVerify uses an efficient encoding into nuXmv, called fastforwarding, to quickly verify if a specification holds over the BT. Additionally, BehaVerify can generate implementations of the BT in Python and Haskell. Through Python, BehaVerify has been integrated with PyTrees and Robot Operating System (ROS) and has been deployed to several autonomous robotic systems, including for verifying runtime monitors. While prior works have developed the underlying theory, this manuscript focuses on the toolbox usage, functionality and implementation. BehaVerify is open source: https://github.com/verivital/behaverify

## FCP: Formal Context Protocol for Verifying LLM-Generated Artifacts

DevFeed: [FCP: Formal Context Protocol for Verifying LLM-Generated Artifacts](<https://devfeed.tech/articles/fcp-formal-context-protocol-for-verifying-llm-generated-artifacts-139894.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21679>)

Author: Shashank

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [adapters](<https://devfeed.tech/tags/adapters.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [all](<https://devfeed.tech/tags/all.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [assertions](<https://devfeed.tech/tags/assertions.md>), [code](<https://devfeed.tech/tags/code.md>), [concrete](<https://devfeed.tech/tags/concrete.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [decision](<https://devfeed.tech/tags/decision.md>), [designs](<https://devfeed.tech/tags/designs.md>), [engines](<https://devfeed.tech/tags/engines.md>), [formal](<https://devfeed.tech/tags/formal.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [language](<https://devfeed.tech/tags/language.md>), [language-model](<https://devfeed.tech/tags/language-model.md>), [llm](<https://devfeed.tech/tags/llm.md>), [protocol](<https://devfeed.tech/tags/protocol.md>)

### AI overview

FCP checks AI-generated artifacts against the request rather than relying on tests written by the same model. It separates conformance--whether an artifact satisfies a formalized requirement, checked by model checkers or SMT solvers--from fidelity: whether that formalization captures the prose, which cannot be decided mechanically but can be challenged with a concrete counterexample. The protocol turns eight ways proofs can falsely certify requirements into mechanical checks and surfaces unresolved interpretation questions for the request's author. Its adapters apply the same engines to hardware, text, agents, and code. In the reported evaluations, AI-written assertions certified 23% of violated requirements across four hardware designs, while FCP certified none. On ten code tasks, three models' code passed its own tests yet violated the request each time; trusting those tests certified all 33 violations, while FCP certified three.

### Source excerpt

arXiv:2611.21679v1 Announce Type: cross Abstract: When a language model writes both an artifact and the tests meant to check it, a passing test is weak evidence: one misreading of the request yields a faulty artifact and a check that accepts it. We present the Formal Context Protocol (FCP), which checks AI-generated artifacts against the request itself. FCP separates conformance (does the artifact satisfy a formal reading of a requirement?), which model checkers and SMT solvers decide, from fidelity (does the reading mean what the prose means?), which has no decision procedure but is refutable by a concrete witness. Eight ways a proof can falsely certify a requirement each become a mechanical check that returns a witness, and what no machine can settle becomes concrete questions for the request's author. Adapters place hardware, text, agents and code on the same engines. On four hardware designs, trusting AI-written assertions certified 23% of violated requirements, and FCP certified none. On ten code tasks, code from three language models passed its own tests and violated the request every time. Trusting the tests certified all 33 violations, and FCP certified three. Agreement among models, readings or tests did not imply correctness.

## Formal Verification of the Signal Protocol Using AI

DevFeed: [Formal Verification of the Signal Protocol Using AI](<https://devfeed.tech/articles/formal-verification-of-the-signal-protocol-using-ai-137765.md>)

Original publisher: [Read original article](<https://www.schneier.com/blog/archives/2026/11/formal-verification-of-the-signal-protocol-using-ai.html>)

Author: Bruce Schneier

Published: 2026-11-17T12:05:43Z

Content type: article

Language: en

Sources: [Schneier on Security](<https://devfeed.tech/sources/schneier-on-security.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Lean](<https://devfeed.tech/topics/lean.md>)

Tags: [academic-papers](<https://devfeed.tech/tags/academic-papers.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-framework](<https://devfeed.tech/tags/ai-framework.md>), [alphaproof-code](<https://devfeed.tech/tags/alphaproof-code.md>), [code](<https://devfeed.tech/tags/code.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [security-analysis](<https://devfeed.tech/tags/security-analysis.md>), [signal](<https://devfeed.tech/tags/signal.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>)

### AI overview

Google DeepMind researchers used AlphaProof Code to formally verify selected security guarantees of the Signal Protocol in a four-week proof of concept. Models helped translate security goals into mathematical specifications, which human experts reviewed; Gemini Carbon agents then generated more than six million lines of Lean proof code and flagged about one percent for closer human review, while Lean checked the rest. The analysis found no new vulnerabilities in the portions examined. Applied to older Signal versions with known, fixed vulnerabilities, the system identified them and showed those versions could not be formally verified. The researchers are releasing their specification and proof to support further verification work. The excerpt describes a limited analysis, not verification of the entire protocol.

### Source excerpt

This seems like a good thing: Google Deepmind researchers used agentic AI to mathematically prove, or "formally verify," a number of the Signal protocol's key cryptographic guaranteesa landmark development for the widely used cryptography and AI itself. Conducted as a sort of proof-of-concept project in just four weeks, the work is significant in two ways. It serves as further independent validation of the cryptography that protects massive quantities of the world's communications on platforms like the Signal app, Google Messages, and WhatsApp. And it demonstrates Google DeepMind's formal verification capabilities using a new AI framework called AlphaProof Code...

## Turing Agent: Agentic Formal Verification for Mathematical Research

DevFeed: [Turing Agent: Agentic Formal Verification for Mathematical Research](<https://devfeed.tech/articles/turing-agent-agentic-formal-verification-for-mathematical-research-137678.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21299>)

Author: Yang Chen, Qianyi Wang, Ronghui Yang, Zhanhao Li, Yu Cong, Chen Zhang, Hangfan Zhang, Shao Zhang, Shuai Li, Toru Takisaka, Chao Xu, Yi Zhou, Zhihao Tang, Xiao Wang, Bo Zhang, Shuyue Hu

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-harness](<https://devfeed.tech/tags/agent-harness.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [deepseek](<https://devfeed.tech/tags/deepseek.md>), [deepseek-v4](<https://devfeed.tech/tags/deepseek-v4.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [glm-5-3](<https://devfeed.tech/tags/glm-5-3.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [llms](<https://devfeed.tech/tags/llms.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [openai](<https://devfeed.tech/tags/openai.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [research](<https://devfeed.tech/tags/research.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Turing Agent coordinates theorem and proof formalization agents to produce machine-verified research mathematics. Its architecture uses structured proof decomposition, parallel verification, accumulated proof experience, and selective semantic review. In theoretical computer science evaluations, it reports 57-62% faithful formalization success on Formal TCS Bench and 83% overall pass@1 on a TCS-focused RLMEval subset, using GLM-5.3 and DeepSeek-V4-Pro; the abstract compares it with direct generation and general-purpose harnesses such as Codex CLI and Claude Code. Built on DeepSeek, it also reports verifying three previously unresolved TCS tasks from an October 2026 OpenAI collection; one required about 100 formally verified auxiliary claims. The authors say the process can reveal simpler proofs and unnecessary dependencies. These are abstract-reported results, with evaluation focused on TCS.

### Source excerpt

arXiv:2611.21299v1 Announce Type: new Abstract: Large language models (LLMs) are rapidly advancing mathematical discovery, moving beyond benchmark-level problem solving to tackle frontier research problems. This progress is ushering mathematics into an era of proof abundance, raising a fundamental challenge: how can we ensure the correctness of the ever-growing volume of AI-generated proofs and transform them into trustworthy, machine-verified mathematical knowledge? We introduce Turing Agent, an agent harness designed to orchestrate end-to-end formal verification of research-level mathematics. Its wo-scale architecture integrates theorem formalization and proof formalization agents, empowered by structured proof decomposition, parallel verification, accumulated proof experience, and selective semantic review. Leveraging our collaborations with theoretical computer science (TCS) researchers, we focus our evaluation on TCS, a particularly demanding domain characterized by intricate quantification, complex dependencies, and stringent semantic requirements. Against direct generation and general-purpose coding harnesses, including Codex CLI and Claude Code, Turing Agent achieves approximately 57-62% faithful formalization success on Formal TCS Bench and 83% overall pass@1 on a TCS-focused subset of RLMEval, using GLM-5.3 and DeepSeek-V4-Pro. Notably, Turing Agent, built on DeepSeek, successfully completes the formal verification of three previously unresolved TCS tasks from OpenAI's October 2026 collection. One particularly challenging TCS problem required about a hundred formally verified auxiliary claims. Moreover, by actively exploring and refining the formalization process, Turing Agent can uncover simpler alternative proofs, expose unnecessary dependencies in original proofs, and generate reusable mathematical knowledge as a byproduct of verification.

## VeruSAGE-Bench: A Benchmark Suite for Rust System Verification

DevFeed: [VeruSAGE-Bench: A Benchmark Suite for Rust System Verification](<https://devfeed.tech/articles/verusage-bench-a-benchmark-suite-for-rust-system-verification-137918.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2512.18436>)

Author: Chenyuan Yang, Natalie Neamtu, Chris Hawblitzel, Jacob R. Lorch, Shan Lu

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-fl](<https://devfeed.tech/tags/cs-fl.md>), [cs-os](<https://devfeed.tech/tags/cs-os.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [gpt-5](<https://devfeed.tech/tags/gpt-5.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [operating-systems](<https://devfeed.tech/tags/operating-systems.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [qwen3-5](<https://devfeed.tech/tags/qwen3-5.md>), [rust](<https://devfeed.tech/tags/rust.md>), [storage-systems](<https://devfeed.tech/tags/storage-systems.md>), [systems](<https://devfeed.tech/tags/systems.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [verification](<https://devfeed.tech/tags/verification.md>), [verus](<https://devfeed.tech/tags/verus.md>)

### AI overview

VeruSAGE-Bench tests system-level Rust verification with 849 proof tasks drawn from eight open-source systems verified in Verus, including operating systems, storage systems, and memory allocators. Its tasks average over 20 times the formal specification length of prior benchmarks and require a broader range of verification techniques. Across six evaluated LLMs, success rates and costs vary substantially by model and agent setup. The hardest tasks can take over an hour; reported averages are 15.3 minutes and USD 13.65 per task. In the harder version without human-written helper lemmas, the best model proves 41% of tasks from the hardest project, at USD 96 per task.

### Source excerpt

arXiv:2512.18436v3 Announce Type: replace-cross Abstract: Large language models (LLMs) have shown impressive capability to understand and develop code. However, their capability to rigorously reason about and formally prove the correctness of software systems remains in question. Current benchmarks for formal proof generation focus on isolated tasks, typically algorithmic-style problems utilizing basic data structures. We curate a new benchmark suite for system-level proof generation, VeruSAGE-Bench, which consists of 849 proof tasks extracted from eight open-source Verus-verified Rust systems, covering operating systems, storage systems, memory allocators, and more. These tasks are much more complicated than those in previous benchmarks, containing on average more than 20x the formal specification (in Lines of Code) and requiring a much broader array of verification techniques. We evaluate six LLMs on VeruSAGE-Bench (o4-mini, GPT-5, Sonnet 4, Sonnet 4.5, Opus 4.5, Qwen3.5), and demonstrate that different models and agentic setups lead to vastly different success rates and costs. We also show that the best models possess impressive capability in writing correctness proofs and hence should inspire new ways of developing trustworthy software. Meanwhile, some difficult tasks in VeruSAGE-Bench stress even the best model, forcing long reasoning time (over an hour on the hardest tasks, 15.3 min per task on average), high token cost (USD 13.65 per task on average), and proof failures, which we hope will guide future improvements in models and agents. This is particularly true for a harder no-lemma version of VeruSAGE-Bench, where the helper lemmas written by human experts are removed: there, the best model proves only 41% of the tasks from the hardest project, at USD 96 per task.

## Mind the Gap: Cross-RFC Formal Analysis Exposes DNSSEC's Hidden Vulnerabilities

DevFeed: [Mind the Gap: Cross-RFC Formal Analysis Exposes DNSSEC's Hidden Vulnerabilities](<https://devfeed.tech/articles/mind-the-gap-cross-rfc-formal-analysis-exposes-dnssec-s-hidden-vulnerabilities-137010.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2512.11431>)

Author: Qifan Zhang, Zilin Shen, Imtiaz Karim, Elisa Bertino, Daiping Liu, Zhou Li

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [DNSSEC](<https://devfeed.tech/topics/dnssec.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>)

Tags: [attack](<https://devfeed.tech/tags/attack.md>), [availability](<https://devfeed.tech/tags/availability.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-fl](<https://devfeed.tech/tags/cs-fl.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [dnssec](<https://devfeed.tech/tags/dnssec.md>), [formal](<https://devfeed.tech/tags/formal.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [interaction](<https://devfeed.tech/tags/interaction.md>), [resolvers](<https://devfeed.tech/tags/resolvers.md>), [rfc](<https://devfeed.tech/tags/rfc.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

The paper's cross-RFC formal models find that selected DNSSEC authentication properties hold under modeled assumptions, but wildcard expansion has an interaction flaw that breaks integrity. In Cross-Zone Wildcard Cache Poisoning, a malicious zone operator can exploit that gap to place forged records for some out-of-zone domains in resolver caches; clients may receive attacker-chosen positive answers marked DNSSEC-authentic with the AD bit set. All four tested major resolvers using the affected caching optimization accepted the malformed material, though impact depends on each resolver's synthesis path. All four vendors have released fixes. The study also reports two modeled availability flaws, three known attack classes, tests six resolvers, scans resolver and TLD deployment prerequisites, and proposes updates to four RFCs.

### Source excerpt

arXiv:2512.11431v2 Announce Type: replace-cross Abstract: This paper presents a cross-RFC formal analysis of selected DNSSEC mechanisms using SAPIC+ models of cryptographic operations and stateful caching. We analyze properties concerning data origin authenticity, integrity, chain of trust, and authenticated denial of existence within these models. Our analysis shows that core authentication properties hold under the modeled assumptions, while wildcard expansion, the mechanism that bridges positive and negative authentication, exhibits a cross-RFC interaction vulnerability that defeats DNSSEC's integrity guarantee. Specifically, we discover Cross-Zone Wildcard Cache Poisoning: a new attack in which a malicious zone operator exploits a gap in the DNSSEC specifications to poison resolver caches with forged records for some domains outside its authority, served to clients as DNSSEC-authentic. The tested versions of all four major resolvers implementing the affected caching optimization accept the malformed wildcard material. The resulting impact depends on the resolver's synthesis path. All four vendors have publicly released fixes. The distinctive integrity failure is a synthesized, attacker-chosen positive answer with the Authenticated Data (AD) bit set: prior attacks instead exhausted availability, downgraded to AD=0, or skipped validation. Our models also identify two cross-RFC availability flaws and rediscover three known attack classes. We test six resolvers and measure deployment prerequisites through focused resolver and TLD scans. We propose updates to four RFCs.

## SART: Sign-Absolute Reformulation Theory for Binary Variable Reduction in Neural Network Verification

DevFeed: [SART: Sign-Absolute Reformulation Theory for Binary Variable Reduction in Neural Network Verification](<https://devfeed.tech/articles/sart-sign-absolute-reformulation-theory-for-binary-variable-reduction-in-neural-network-verification-137322.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18657>)

Author: Jin Xu, Miaomiao Zhang, Bowen Du

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-ne](<https://devfeed.tech/tags/cs-ne.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [fewer](<https://devfeed.tech/tags/fewer.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [global](<https://devfeed.tech/tags/global.md>), [intermediate](<https://devfeed.tech/tags/intermediate.md>), [layer](<https://devfeed.tech/tags/layer.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [optimum](<https://devfeed.tech/tags/optimum.md>), [reduction](<https://devfeed.tech/tags/reduction.md>), [relu](<https://devfeed.tech/tags/relu.md>), [symmetry](<https://devfeed.tech/tags/symmetry.md>)

### AI overview

SART reduces the binary-variable burden in complete neural-network verification by allowing unstable ReLU neurons to require, on average, fewer than one binary variable. The abstract states that, assuming P ≠ NP, final-layer variables can be compressed by 50%, while intermediate-layer variables cannot be further reduced in a single-layer analysis. LayerABS addresses this limit by treating intermediate layers as temporary final layers and propagating tighter bounds, which the authors say reduces the network-wide search space and variable counts. The abstract also reports that numerical symmetry between positive and negative unstable-neuron weight signs yields the theoretical optimum worst-case complexity. SART is presented as a general-purpose encoding independent of the verification algorithm.

### Source excerpt

arXiv:2611.18657v1 Announce Type: cross Abstract: Complete formal verification of neural networks is crucial for their deployment in safety-critical domains. A key bottleneck stems from encoding complexity: traditional methods assign one binary variable per unstable ReLU neuron. We propose the Sign-Absolute Reformulation Theory (SART), which fundamentally breaks the conventional one-to-one mapping between unstable neurons and binary variables by establishing formal reducibility criteria. This allows for finer-grained modeling, where each unstable neuron corresponds on average to fewer than one binary variable, thereby reducing verification complexity at its source. Based on SART, we derive a theoretical lower bound on the number of binary variables required for complete verification and, under the assumption that $P \neq NP$, prove that variables in the final layer can be compressed by 50\%, while the number of variables in intermediate layers cannot be further reduced. To overcome the apparent ``last-layer-only'' limitation, we recast verification as a sequential process and, crucially, show that the gain lifts to the entire network: LayerABS, a SART-based progressive tightening verifier, iteratively treats intermediate layers as temporary final layers and propagates tight bounds that shrink the global search space and binary-variable counts. Furthermore, we reveal a structural law influencing verification complexity: when the signs of weights of unstable neurons satisfy numerical symmetry, with positive and negative weights equal or differing by at most one, the worst-case verification complexity achieves the theoretical optimum, offering theoretical guidance for the design of verification-friendly architectures. As a general-purpose underlying encoding, the value of SART is independent of specific algorithms.

## Formal Modeling in Software Engineering with LLMs: A Systematic Literature Review

DevFeed: [Formal Modeling in Software Engineering with LLMs: A Systematic Literature Review](<https://devfeed.tech/articles/formal-modeling-in-software-engineering-with-llms-a-systematic-literature-review-137963.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18577>)

Author: Alexandra Newcomb, Omar Ochoa

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [artifacts](<https://devfeed.tech/tags/artifacts.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [formal](<https://devfeed.tech/tags/formal.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [generation](<https://devfeed.tech/tags/generation.md>), [human-in-the-loop](<https://devfeed.tech/tags/human-in-the-loop.md>), [intermediate-representations](<https://devfeed.tech/tags/intermediate-representations.md>), [literature](<https://devfeed.tech/tags/literature.md>), [llms](<https://devfeed.tech/tags/llms.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [review](<https://devfeed.tech/tags/review.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

A systematic review of 34 peer-reviewed studies published from 2022 through April 2026 finds that LLMs can generate and repair formal models syntactically, but often struggle to ensure semantic correctness. Reported approaches commonly use counterexample-guided repair loops, intermediate representations, and human validation. The review identifies work on formal model generation, downstream verification, iterative pipelines, and semi-formal UML and SysML artifacts; it finds research specifically on automating model checking remains limited. The review searched four digital libraries, screening an initial 1,193 articles.

### Source excerpt

arXiv:2611.18577v1 Announce Type: new Abstract: Formal verification provides strong correctness guarantees for software systems but remains hindered by the substantial expertise and manual effort required to construct and maintain formal models. The recent rise of Large Language Models (LLMs) has prompted growing interest in whether their natural language understanding and generation capabilities can be leveraged to automate labor-intensive modeling activities. This paper presents a Systematic Literature Review (SLR) examining how LLMs have been applied to automate model checking and the generation of formal and semi-formal models within software engineering. The review follows established SLR methodologies and a PICOC-driven search strategy across four major digital libraries. From an initial search of 1,193 articles, 34 peer-reviewed conference, journal, and workshop articles published between 2022 and April 2026 were selected and analyzed using a structured data extraction form. The review identifies six recurring trends in the literature, including the automated generation of formal models for model checking, LLM-assisted downstream formal verification, iterative and repair-based generation pipelines, and the generation of semi-formal UML and SysML artifacts whose underlying techniques are transferable to formal modeling contexts. Across these trends, LLMs are generally found to perform well on syntactic generation and repair tasks but struggle with semantic correctness, motivating widespread use of counterexample-guided repair loops, intermediate representations, and human-in-the-loop validation. Notably, this review finds that the use of LLMs specifically to automate model checking remains a largely unexplored area, with comparatively little research published on this narrower task.

## AuXSpec: Learning to Autoformalize Program Specifications via Executable Postconditions

DevFeed: [AuXSpec: Learning to Autoformalize Program Specifications via Executable Postconditions](<https://devfeed.tech/articles/auxspec-learning-to-autoformalize-program-specifications-via-executable-postconditions-138016.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21421>)

Author: Haocheng Wang, Weixuan Yuan, Florian H\\"ubler, Yinya Huang, Zhijiang Guo, Sorrachai Yingchareonthawornchai, Rasmus Kyng

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Reinforcement learning](<https://devfeed.tech/topics/reinforcement-learning.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Lean](<https://devfeed.tech/topics/lean.md>)

Tags: [autoformalization](<https://devfeed.tech/tags/autoformalization.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [execution](<https://devfeed.tech/tags/execution.md>), [lean](<https://devfeed.tech/tags/lean.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [training](<https://devfeed.tech/tags/training.md>)

### AI overview

AuXSpec makes reinforcement-learning feedback for Lean specification generation more scalable by pairing declarative postconditions with executable counterparts. The executable form is obtained through type class resolution when possible; otherwise, it is defined separately with an equivalence proof. Test-case agreement then serves as the reward, avoiding the need to obtain feedback through explicit proofs for each generated specification. Training on synthesized LeetCode problems and Codeforces expert-iteration samples raised Qwen3.5-9B and Qwen3.8-27B pass@4 on AuXSpec-Test to 82.7% and 84.3%, respectively. On Verina with original prompts, both reached 90.5% pass@4; the abstract also reports stronger pass@1 results than VeriSpecGen-30B-A3B. The authors release trained model weights and problem data, including a 300-problem expert-reviewed benchmark with correctness proofs.

### Source excerpt

arXiv:2611.21421v1 Announce Type: new Abstract: Formal specifications define intended program behavior and underpin verification, but writing them in theorem provers such as Lean is slow and expertise-intensive, making specification a major bottleneck to scaling formally correct code. Autoformalization from natural-language problems is promising, yet training specification models requires scalable feedback on whether generated specifications capture intended behavior. Prior approaches obtain this feedback through explicit proofs or separately implemented code with formal correspondence proofs, both expensive. We introduce AuXSpec, a Lean framework that pairs declarative postconditions with executable counterparts, obtained through type class resolution when possible and otherwise defined separately with an equivalence proof. Test cases can then evaluate declarative specifications by execution, letting us use agreement as a reinforcement-learning reward. Using AuXSpec, we synthesize 3,037 LeetCode problems and expand training to 19.5K samples through expert iteration on Codeforces. Experiments show that training Qwen3.5-9B and Qwen3.8-27B with the execution-based reward improves SpecGen pass@4 on AuXSpec-Test 0.7% $\to$ 82.7% and 14.3% $\to$ 84.3%, and the 27B model outperforms all frontier models. On the out-of-domain Verina benchmark with its original prompts, both models improve 7.0% $\to$ 90.5% and 21.9% $\to$ 90.5% and surpass VeriSpecGen-30B-A3B, the prior state of the art among open-source specification models, on pass@1 (theirs 47.6% vs. ours 73.7% and 84.5%) and pass@4 (theirs 63.9% at pass@10 vs. ours 90.5%). We release the weights of the trained 9B and 27B models and the 3,037 problems with test cases, including the 300-problem AuXSpec-Test benchmark with expert review and correctness proofs for future evaluation. Models and data: https://huggingface.co/collections/eth-algopt/auxspec. Website: https://auxspec.org

## Active Learning of Temporal Specifications through Distinguishing Queries

DevFeed: [Active Learning of Temporal Specifications through Distinguishing Queries](<https://devfeed.tech/articles/active-learning-of-temporal-specifications-through-distinguishing-queries-135132.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17866>)

Author: Rajarshi Roy, Xiaowei Huang

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [concept-learning](<https://devfeed.tech/topics/concept-learning.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [after](<https://devfeed.tech/tags/after.md>), [all](<https://devfeed.tech/tags/all.md>), [approach](<https://devfeed.tech/tags/approach.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [behaviour](<https://devfeed.tech/tags/behaviour.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [but](<https://devfeed.tech/tags/but.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [capture](<https://devfeed.tech/tags/capture.md>), [classes](<https://devfeed.tech/tags/classes.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [enumeration](<https://devfeed.tech/tags/enumeration.md>), [environments](<https://devfeed.tech/tags/environments.md>), [learning](<https://devfeed.tech/tags/learning.md>), [queries](<https://devfeed.tech/tags/queries.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [temporal](<https://devfeed.tech/tags/temporal.md>)

### AI overview

The framework learns finite-trace LTL specifications through labeled traces and natural-language hints, without requiring teachers to answer equivalence queries or construct counterexamples. It keeps an enumerated version space of candidate formulas, generates traces to distinguish them, and uses hints to rank candidates or narrow the search. The authors prove consistency with observed examples, bounded-class identification with a query bound, and a PAC guarantee. In simulated experiments on 36 targets, comparing all rivals identified every target with fewer than seven queries beyond an initial ten traces on average. Correct hints reduced queries by up to 16% and generated candidates by 20%; ranking hints preserved identification even when incorrect. The enumeration-based approach was faster than prior SAT-based learners at every tested target size.

### Source excerpt

arXiv:2611.17866v1 Announce Type: cross Abstract: Temporal specifications are essential for verification and monitoring, yet writing formulas that capture the intended behaviour is difficult. Active learning derives such specifications through interaction between a learner and a teacher, but remains underexplored for temporal logics. Existing approaches require the teacher to answer equivalence queries and to construct counterexamples, and they often rely on SAT-based learning procedures that restart the search after each new example. We present an active-learning framework for LTLf in which the teacher only labels traces and answers natural-language questions about the intended behaviour. The learner maintains an enumerated version space of candidate formulas, generates traces that distinguish candidates, and uses the teacher's hints to rank candidates or to restrict the search. We prove consistency with the observed examples, identification within bounded hypothesis classes with a bound on the number of queries, and a PAC guarantee for the final hypothesis. In experiments with a simulated teacher on 36 targets, including targets in four standard environments, the learner identifies every target when it compares all rivals, with fewer than seven queries beyond an initial sample of ten traces on average. Correct hints reduce the number of queries by up to 16% and the number of generated candidates by a fifth, and hints used for ranking never prevent identification, even when incorrect. Our enumeration-based version space is faster than the SAT-based approach of previous learners at every target size.

## Fit-LRP: Fitting Linear Relaxations to Polytopes for Neural Network Verification over Non-Convex Regions

DevFeed: [Fit-LRP: Fitting Linear Relaxations to Polytopes for Neural Network Verification over Non-Convex Regions](<https://devfeed.tech/articles/fit-lrp-fitting-linear-relaxations-to-polytopes-for-neural-network-verification-over-non-convex-regions-132186.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.16003>)

Author: Brian Yarbrough, Jesse Wayment, Jingbo Wang, Philip E. Par\\'{e}, Shreyas Sundaram

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [alpha](<https://devfeed.tech/tags/alpha.md>), [beta](<https://devfeed.tech/tags/beta.md>), [certificates](<https://devfeed.tech/tags/certificates.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [cyber-physical-systems](<https://devfeed.tech/tags/cyber-physical-systems.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [framework](<https://devfeed.tech/tags/framework.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [linear](<https://devfeed.tech/tags/linear.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [neural](<https://devfeed.tech/tags/neural.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [optimizing](<https://devfeed.tech/tags/optimizing.md>), [partitioning](<https://devfeed.tech/tags/partitioning.md>), [pruning](<https://devfeed.tech/tags/pruning.md>), [region](<https://devfeed.tech/tags/region.md>), [regions](<https://devfeed.tech/tags/regions.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [unions](<https://devfeed.tech/tags/unions.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Fit-LRP improves neural network verification over oblique and non-convex polyhedral regions by optimizing affine bounds over exact constraints, represented as unions of polytopes, through small low-dimensional linear programs. It enhances the final optimization step in LiRPA and α,β-CROWN branch-and-bound, avoiding box-induced over-approximations that can drive excessive splitting and impede termination. On ARCH-COMP and neural Lyapunov benchmarks, it reportedly reduced branching on the hardest region by 47x and worst-case verification time by 15x; with region-wise partitioning, it verified 6.1x faster on a single CPU than α,β-CROWN on a GPU.

### Source excerpt

arXiv:2611.16003v1 Announce Type: cross Abstract: State-of-the-art neural network verifiers evaluate linear relaxations over axis-aligned bounding boxes. However, verification domains in cyber-physical systems are rarely boxes. Reachability specifications, obstacle-avoidance constraints, and neural Lyapunov certificates typically yield oblique or non-convex polyhedral regions, over which box-based bounds become extremely loose. This paper proposes Fit-LRP (Fitting Linear Relaxations to Polytopes), a framework the implements exact optimization of affine bounds over non-convex domains (represented by unions of polytopes) by solving a sequence of small, low-dimensional linear programs. Our approach seamlessly enhances the final optimization step of LiRPA and $\alpha,\! \beta$-CROWN branch-and-bound (BaB) algorithms. In BaB verification, approximating oblique constraints with axis-aligned splits causes severe combinatorial blowup and risks non-termination. By optimizing the final affine bound of a nonlinear function over the exact polyhedral state-space constraints our method eliminates box-induced over-approximations, enabling earlier search-tree pruning. On ARCH-COMP and neural Lyapunov benchmarks, Fit-LRP reduces branching on the hardest region by $47\times$, cuts worst-case verification time by $15\times$, and with region-wise partitioning, verifies on a single CPU $6.1\times$ faster than $\alpha,\! \beta$-CROWN on a GPU.

## Theorem-Proving Agent over Abstract Syntax Tree

DevFeed: [Theorem-Proving Agent over Abstract Syntax Tree](<https://devfeed.tech/articles/theorem-proving-agent-over-abstract-syntax-tree-131673.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2607.16372>)

Author: Qiyuan Xu, Joshua Ong Jun Leang, Renxi Wang, Wenda Li, Haonan Li, Luke Ong, Conrad Watt

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Isabelle/HOL proof assistant](<https://devfeed.tech/topics/isabelle-hol-proof-assistant.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Concrete syntax tree](<https://devfeed.tech/topics/cst.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [ast](<https://devfeed.tech/tags/ast.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [faster](<https://devfeed.tech/tags/faster.md>), [fewer](<https://devfeed.tech/tags/fewer.md>), [isabelle](<https://devfeed.tech/tags/isabelle.md>), [json](<https://devfeed.tech/tags/json.md>), [llm](<https://devfeed.tech/tags/llm.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [syntax](<https://devfeed.tech/tags/syntax.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Agent over AST (AoA) represents Minilang proofs as JSON abstract syntax trees and edits a unified proof tree in which each operation carries its subgoal state. This avoids emitting concrete source text and separately locating proof states by line number, which the abstract identifies as a source of repeated work and cost. Against Amazon's Isabelle Agent on the benchmarks' common success sets, AoA reportedly used 2.9-6.9x fewer tokens and 3.9-8.9x fewer tool calls, finished 1.4-2.0x faster, and reduced API cost 2.3-4.7x under normalized input-cache accounting. The abstract also reports substantially more solved problems on the harder verification benchmark; it does not provide the counts here.

### Source excerpt

arXiv:2607.16372v2 Announce Type: replace Abstract: Interactive theorem proving (ITP) underpins program verification and formalized mathematics, but its manual effort limits scalability. LLM-based proof agents promise to ease this effort, but their heavy token consumption and API cost remain a major obstacle. We trace this cost to a shared root: current agents operate on serialized concrete syntax, emitting proofs as source text and recovering proof states through separate, line-number-based queries, so every edit shifts later lines and forces repeated relocation of errors and states. This same dependence on concrete syntax also blocks adoption of Minilang, a recent proof language that reaches SOTA on LLM-based proving but is too new for LLMs' training corpora. We address both problems by lifting the agent off source text and onto the abstract syntax tree (AST): the model supplies proofs as JSON representations of Minilang's AST -- native to tool-calling LLMs -- and drives the prover through a tree-edit model that fuses proof operations and states into one proof tree, so each operation carries its own subgoal's state, readable directly off the tree. We realize this design in \emph{Agent over AST} (AoA). Against Amazon's Isabelle Agent on miniF2F and NTP4VC-Pearl common success sets, AoA cuts API cost by 2.3--4.7x (normalized input-cache accounting), uses 2.9--6.9x fewer tokens and 3.9--8.9x fewer tool calls, and finishes 1.4--2.0x faster -- while also solving far more problems on the harder verification benchmark.

## Pre-QED: Environment Specifications for Agentic Verification

DevFeed: [Pre-QED: Environment Specifications for Agentic Verification](<https://devfeed.tech/articles/pre-qed-environment-specifications-for-agentic-verification-131709.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.15207>)

Author: Tristan Lim, Haoxin Tu, Mehtab Zafar, Zhengxiong Luo, Abhik Roychoudhury

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-workflow](<https://devfeed.tech/tags/agentic-workflow.md>), [api](<https://devfeed.tech/tags/api.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [environment](<https://devfeed.tech/tags/environment.md>), [formal](<https://devfeed.tech/tags/formal.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [functionality](<https://devfeed.tech/tags/functionality.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [harness](<https://devfeed.tech/tags/harness.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [library](<https://devfeed.tech/tags/library.md>), [linear](<https://devfeed.tech/tags/linear.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [orders](<https://devfeed.tech/tags/orders.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The paper argues that agentic verification is limited by what can be proved: existing approaches that prove a fuzz harness never crashes cover one API-call sequence in one context, not the library's full range of use. It proposes executable "verification harnesses" that model all legal API usages, aiming to make proofs apply to every well-behaved client. An agentic workflow extracts usage contracts from code and documentation, then uses Linear-time Temporal Logic to rule out illegal call orders. The authors identify challenges in proving these harnesses and release them as open-source challenges; routine library verification with broad client coverage is presented as a vision.

### Source excerpt

arXiv:2611.15207v1 Announce Type: new Abstract: LLM agents are making formal verification practical at scale. Recently, many attempts have raised this as an enticing possibility. However, formal verification at scale is only meaningful if deep formal specifications capturing functionality are available for checking. Unfortunately, recent works seek to bypass this issue by using shallow specifications devised for purposes other than verification. OSS-Verify from Anthropic and Theorem, for example, reuses the fuzz harnesses of open-source libraries as specifications and has an agent prove that each harness never crashes. However, a fuzz harness follows a single sequence of API calls under a single calling context, so the resulting proof covers one usage scenario rather than the library. We argue that the bottleneck of agentic verification has shifted from how to prove to what to prove. Before zooming into verification at scale, we need deep environment specifications to prove, which is why we call our effort Pre-QED. We propose verification harnesses, executable harnesses that model all legal usages of an API, so that a proof about the harness is a proof about every well-behaved client. To construct them, we use an agentic workflow that extracts the API's usage contract from code / documentation, and uses Linear-time Temporal Logic (LTL) to rule out illegal call orders. We identify the challenges in proving verification harnesses and release our harnesses open-source as challenges for the community. The overarching vision is that verifying an open-source library should become as routine as fuzzing it, with a guarantee that covers every well-behaved client rather than a single scenario like a fuzzing harness.

## LLM-Assisted Verification in Dafny

DevFeed: [LLM-Assisted Verification in Dafny](<https://devfeed.tech/articles/llm-assisted-verification-in-dafny-131738.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.16886>)

Author: Wieger Wesselink, Kees Huizing, Huub van de Wetering

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [human review](<https://devfeed.tech/topics/human-review.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [claude-opus-5](<https://devfeed.tech/tags/claude-opus-5.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [graph-theory](<https://devfeed.tech/tags/graph-theory.md>), [human-oversight](<https://devfeed.tech/tags/human-oversight.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-assisted](<https://devfeed.tech/tags/llm-assisted.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The paper presents a ten-step workflow for using LLMs with Dafny to build machine-checked verifications of scientific algorithms. It combines algorithm formalization, contract and invariant development, proof construction, solver-feedback diagnosis, bottleneck profiling, and resource-driven optimization, with automated testing and verification feedback and human oversight of correctness-critical decisions. The authors report applying Claude Opus 5 and Opus 5.5 to 37 algorithms in graph theory and labelled transition systems, including the Hopcroft-Tarjan triconnectivity test. Many verifications took hours to a few days of interactive development. The authors suggest this approach shifts human effort toward supervision, specification review, and strategic guidance; the excerpt does not provide comparative results or detail the ten steps individually.

### Source excerpt

arXiv:2611.16886v1 Announce Type: cross Abstract: Formal verification of complex algorithms requires expertise in program specification, invariant construction, mathematical proof, and the management of automated theorem provers. Although large language models (LLMs) can generate program code and proof fragments, reliably developing complete machine-checked verifications remains challenging: it requires an iterative process of constructing and validating specifications and invariants, building proofs, diagnosing solver failures, and optimizing verification performance. This paper presents a systematic ten-step workflow for LLM-assisted verification of scientific algorithms using the Dafny verification system. The workflow integrates algorithm formalization, contract development, empirical invariant validation, proof construction, bottleneck profiling, and resource-driven proof optimization. We applied the workflow using Antrhopic's Claude Opus 5 and Opus 5.5 models, combining LLM-driven development with automated testing and verification feedback, while retaining human oversight for correctness-critical decisions and strategic interventions. We evaluate the approach on 37 complex algorithms from graph theory and labelled transition systems. Notably, we verified the Hopfcroft-Tarjan triconnectivity test, demonstrating that even highly challenging algorithmic verification tasks can be carried out through a structured LLM-assisted workflow. Many of our machine-checked verifications were obtained within hours to a few days of interactive development. Our results suggest that LLM-assisted workflows can shift the role of the human verifier from detailed proof construction toward supervision, specification review, and strategic guidance.

## Semantic diffing of formal policies with anti-unification

DevFeed: [Semantic diffing of formal policies with anti-unification](<https://devfeed.tech/articles/semantic-diffing-of-formal-policies-with-anti-unification-129760.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/machine-learning/semantic-diffing-of-formal-policies-with-anti-unification/>)

Author: Ferhat Erata

Published: 2026-11-11T23:33:03Z

Content type: article

Language: en

Sources: [Artificial Intelligence](<https://devfeed.tech/sources/artificial-intelligence.md>)

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>)

Tags: [advanced-300](<https://devfeed.tech/tags/advanced-300.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [autoformalization](<https://devfeed.tech/tags/autoformalization.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [engine](<https://devfeed.tech/tags/engine.md>), [formal](<https://devfeed.tech/tags/formal.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [policies](<https://devfeed.tech/tags/policies.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [thought-leadership](<https://devfeed.tech/tags/thought-leadership.md>)

### AI overview

The engine uses anti-unification over an e-graph to show shared policy structure once and localize disagreements in `Variants` nodes. Declared algebraic laws absorb changes such as reordered or duplicated conjuncts; explicit rewrites encode domain facts. In the policy example, these remove three presentational differences and a known Region expansion, leaving two behavior-changing disagreements: a confidential-data clause weakened from `And` to `Or`, and a strict `<` versus inclusive `≤` size threshold. The tool identifies alternatives but does not decide which matches the requirement; validation, replay, solver checks, or human review may resolve them. It diffs encoded terms rather than importing native policies, and it does not evaluate Dogwood policies. Search can be exact or use an anytime Monte Carlo budget; results depend on the current graph and declared equalities, and incomplete rules or search may leave equivalent expressions unmatched. The article also describes candidate clustering, regression checks, and CI size budgets.

### Source excerpt

A textual diff of two formal policies flags every cosmetic change and hides the one that alters behavior. This post shows how to compute a symbolic, deterministic semantic diff with an open-source anti-unification engine, so reviewers see only the genuine disagreements between two candidate authorization policies.

[Next page](<https://devfeed.tech/topics/formal-verification.md?cursor=WyIyMDI2LTExLTExVDIzOjMzOjAzKzAwOjAwIiwgIjZjNjVjZGU0LWRkNDQtNGE1ZS05YmQwLWIxMThkYmIwZmQ5NiJd>)