# Automated reasoning

Automated reasoning is the use of computing systems and algorithms to mechanize logical deduction and prove theorems, with applications including formal verification of software and hardware.

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

## Anthropic Mathematician Claims to Prove Riemann Hypothesis

DevFeed: [Anthropic Mathematician Claims to Prove Riemann Hypothesis](<https://devfeed.tech/articles/anthropic-mathematician-claims-to-prove-riemann-hypothesis-147077.md>)

Original publisher: [Read original article](<https://science.slashdot.org/story/26/11/21/028221/anthropic-mathematician-claims-to-prove-riemann-hypothesis>)

Author: BeauHD

Published: 2026-11-21T07:00:00Z

Content type: news

Language: en

Sources: [Slashdot](<https://devfeed.tech/sources/slashdot.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-model](<https://devfeed.tech/tags/ai-model.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [claude](<https://devfeed.tech/tags/claude.md>), [lean](<https://devfeed.tech/tags/lean.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [riemann-hypothesis](<https://devfeed.tech/tags/riemann-hypothesis.md>), [riemann-hypothesis-proof](<https://devfeed.tech/tags/riemann-hypothesis-proof.md>)

### AI overview

Anthropic mathematician Levent Alpoge says he used Claude to produce a Lean-coded proof of the Riemann Hypothesis. The excerpt describes independent mathematicians as highly confident after checking the code, while noting that final review must confirm the formalization matches the original hypothesis and has no verification loopholes. If confirmed, mathematicians quoted expect the proof to connect branches of mathematics and open new directions in number theory; the excerpt says it would have no immediate practical applications. A separate proposed proof by Alessandro Masullo, drafted without AI months earlier, is about 940 pages and needs significant revision, with reported omissions and apparent errors.

### Source excerpt

Slashdot has been covering the Riemann Hypothesis for years. 2000: Prove The Riemann Hypothesis And Make.Money.Fast 2002: More on Riemann Hypothesis 2008: Claimed Proof of Riemann Hypothesis 2008: Prominent Mathematicians Rebuke Recent Riemann Hypothesis Proof Add a new headline to the list... 2026: Using AI, mathematician claims to have solved one of math's great mysteries joshuark shares a report from Scientific American: Levent Alpoge, a mathematician at Anthropic, has claimed to have solved the Riemann Hypothesis with the help of Anthropic's AI model Claude, but the proof is not yet independently verified and remains under scrutiny. [An AI-generated solution of the 167-year-old problem, long considered far out of reach to human mathematicians, would cap off the technology's year-long conquest of math in spectacular fashion.] The Riemann hypothesis was first proposed in 1859 by the mathematician Bernhard Riemann. It claims that the locations of the prime numbers along the number line, which appear random at first blush, are actually determined by an intricate, meaningful order. [...] Alpoge posted his Claude proof coded in the programming language Lean, which verifies the mathematical correctness of each argument. Issues can arise in Lean, but it shouldn't take long for experts to verify whether the hypothesis is properly coded, and if the proof is correct. If that happens, it will cap off a year in which AI's mathematical capabilities ascended from unreliable college student to a superhuman force, leaving no part of the discipline undisrupted. [...] Alpoge's statement is elegiac -- recognizing the sense of grief many mathematicians are feeling -- but also optimistic. "It is natural to feel that this is an end, in my case a loss of a principal guiding light," he wrote, "but what I saw during the course of progress so amazed me that I believe it is one dawn across science of something far greater." [...] The Riemann result, if correct, will echo far beyond mathema

## Anthropic Mathematician Claims Proof of the Riemann Hypothesis, Submits Lean Formalization Built with Claude

DevFeed: [Anthropic Mathematician Claims Proof of the Riemann Hypothesis, Submits Lean Formalization Built with Claude](<https://devfeed.tech/articles/anthropic-mathematician-claims-proof-of-the-riemann-hypothesis-submits-lean-formalization-built-with-claude-147009.md>)

Original publisher: [Read original article](<https://joho-todai.com/en/anthropic-mathematician-riemann-hypothesis-claude-lean/>)

Author: Toru Misaki

Published: 2026-11-21T00:00:24Z

Content type: news

Language: en

Sources: [Joho no Todai](<https://devfeed.tech/sources/joho-no-todai.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [anthropic](<https://devfeed.tech/topics/anthropic.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-fable](<https://devfeed.tech/tags/claude-fable.md>), [claude-fable-5](<https://devfeed.tech/tags/claude-fable-5.md>), [clay-mathematics-institute](<https://devfeed.tech/tags/clay-mathematics-institute.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [deepmind](<https://devfeed.tech/tags/deepmind.md>), [generalized-riemann-hypothesis](<https://devfeed.tech/tags/generalized-riemann-hypothesis.md>), [lean](<https://devfeed.tech/tags/lean.md>), [lean-proof-assistant](<https://devfeed.tech/tags/lean-proof-assistant.md>), [levent-alpoge](<https://devfeed.tech/tags/levent-alpoge.md>), [mit](<https://devfeed.tech/tags/mit.md>), [riemann-hypothesis](<https://devfeed.tech/tags/riemann-hypothesis.md>)

### AI overview

Anthropic mathematician Levent Alpoge says he and Claude developed a proof of the Riemann hypothesis and the Generalized Riemann Hypothesis, then formalized it in Lean 4 as a 14-part archive. MIT mathematician Andrew Sutherland independently compiled the formalization successfully, which checks the encoded logical steps; the excerpt notes that this does not settle whether the problem was encoded correctly. Alpoge says the argument is extraordinarily long and difficult to read, and that substantial work remains to understand its details and produce a conventional paper. The claim has drawn strong reactions from mathematicians, but the supplied text presents it as a claimed proof still requiring scrutiny, not as a settled result.

### Source excerpt

Anthropic mathematician Levent Alpoge claims to have proved the 167-year-old Riemann hypothesis through collaboration with Claude. He published a formalization in the Lean proof assistant, and an MIT mathematician independently compiled it successfully.

## Verifiable Logic in Medical LLMs: A Critical Review of Agentic Clinical Reasoning Optimization and Neuro-Symbolic Grounding

DevFeed: [Verifiable Logic in Medical LLMs: A Critical Review of Agentic Clinical Reasoning Optimization and Neuro-Symbolic Grounding](<https://devfeed.tech/articles/verifiable-logic-in-medical-llms-a-critical-review-of-agentic-clinical-reasoning-optimization-and-neuro-symbolic-grounding-145116.md>)

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

Author: Youssef ElNahas, Adel Ammar, Soumaya Chaffar, Wadii Boulila

Published: 2026-11-20T05: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: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-safety](<https://devfeed.tech/tags/ai-safety.md>), [also](<https://devfeed.tech/tags/also.md>), [amplify](<https://devfeed.tech/tags/amplify.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [audit](<https://devfeed.tech/tags/audit.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [critical](<https://devfeed.tech/tags/critical.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-cy](<https://devfeed.tech/tags/cs-cy.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [grounding](<https://devfeed.tech/tags/grounding.md>), [llms](<https://devfeed.tech/tags/llms.md>), [logic](<https://devfeed.tech/tags/logic.md>), [medical](<https://devfeed.tech/tags/medical.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [review](<https://devfeed.tech/tags/review.md>)

### AI overview

Clinical LLMs can produce correct answers through invalid reasoning that final-answer benchmarks miss, while multi-agent and tool-augmented systems may propagate early errors. This review examines hallucination, agentic error cascades, process reward models that supervise reasoning step by step, and neuro-symbolic grounding using logic engines, ontology reasoners, and knowledge graphs to constrain neural outputs. Symbolic veto layers provide guarantees only within their encoded knowledge; reported safety gains come from individual studies, mostly simulated or small-sample, and are not directly comparable with neural baselines. Process reward models are limited by their training data. The authors propose matching agentic failure modes to symbolic interventions and recommend auditing reasoning trajectories alongside benchmark accuracy in clinical AI certification.

### Source excerpt

arXiv:2611.25898v1 Announce Type: cross Abstract: Clinical large language models are usually judged by whether the final answer is right. Yet a model can reach a fluent, plausible output through invalid reasoning that static benchmarks do not detect, and confident hallucination, causally invalid inference, and spurious demographic shortcuts can pass conventional evaluation. This critical review covers four paradigms in turn: how clinical hallucination arises and why static metrics miss it; the agentic hallucination cascade, in which multi-agent and tool-augmented systems propagate and amplify early reasoning errors; process reward modeling as step-level supervision; and neuro-symbolic grounding, in which formal logic engines, ontology reasoners, and knowledge graphs place verifiable constraints on neural output. Within their encoded domains, systems with symbolic veto layers offer guarantees that hold relative to their encoded knowledge, and they report large gains on the safety measures they use. These results come from single studies, mostly in simulated or small-sample settings, and are not directly comparable with neural baselines. Process reward models remain bounded by the statistics of their training data. We propose a conceptual framework that maps each agentic failure mode to a symbolic intervention point, and we argue that clinical AI safety depends substantially on system architecture. Because current regulation emphasizes performance and does not require verification of reasoning steps, we argue that responsible certification should also audit reasoning trajectories alongside accuracy on static benchmarks.

## 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.

## Clause-Factored Bilateral State Grounding and Scoped Passivity for Counterfactual Open-World Deductive Reasoning

DevFeed: [Clause-Factored Bilateral State Grounding and Scoped Passivity for Counterfactual Open-World Deductive Reasoning](<https://devfeed.tech/articles/clause-factored-bilateral-state-grounding-and-scoped-passivity-for-counterfactual-open-world-deductive-reasoning-144943.md>)

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

Author: Zeyu Jia, Bo Yao, Zihao Yang

Published: 2026-11-20T05: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: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>)

Tags: [3](<https://devfeed.tech/tags/3.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [annotations](<https://devfeed.tech/tags/annotations.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autoregressive](<https://devfeed.tech/tags/autoregressive.md>), [batch](<https://devfeed.tech/tags/batch.md>), [chain-of-thought](<https://devfeed.tech/tags/chain-of-thought.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [domain](<https://devfeed.tech/tags/domain.md>), [domains](<https://devfeed.tech/tags/domains.md>), [edge](<https://devfeed.tech/tags/edge.md>), [edits](<https://devfeed.tech/tags/edits.md>), [f](<https://devfeed.tech/tags/f.md>), [flan](<https://devfeed.tech/tags/flan.md>), [grounding](<https://devfeed.tech/tags/grounding.md>), [open](<https://devfeed.tech/tags/open.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [state](<https://devfeed.tech/tags/state.md>), [world](<https://devfeed.tech/tags/world.md>)

### AI overview

TE-BPHD separates open-world deduction into a clause-factored grounder and a deliberation operator, trained from three-way query labels without parsers or proof-depth annotations. On 17,036 ProofWriter queries, it achieves 79.17% depth-5 counterfactual consistency, 23.83-38.67 percentage points above the listed T5 baselines, and 94.95% OOD accuracy across six domains. On a paired 120-query slice, its 93.61% accuracy exceeds 3-shot Qwen3-1.7B's 79.17% under a 2,048-token cap, with reported batch-16 NVIDIA L4 latency of 9.44 versus 14,878.4 ms/query. The abstract attributes improved counterfactual consistency to symmetric single-rule passivity preventing positive two-cycle modes. Grounded Product-T-Norm LTN also has cycle-safe OOD transfer without linear solves; multi-fact ParaRules results remain weak zero-shot and improve with five-slot joint grounding.

### Source excerpt

arXiv:2609.37351v3 Announce Type: replace Abstract: Open-World Assumption (OWA) deduction requires distinguishing provable facts (True), refutations (False), and unprovable statements (Unknown) across counterfactual edits and unseen domains. Sequence and latent-recurrent transformers rely on distributional shortcuts, whereas chain-of-thought language models incur high autoregressive latency. We decompose OWA deduction into a clause-factored bilateral grounder ($F$) and a deductive deliberation operator ($B$), forming $B \circ F$ in Typed Edge-Factorized Bilateral Port-Hamiltonian Deliberation (TE-BPHD). Trained solely on three-way query labels without parsers or proof-depth annotations, TE-BPHD (37.85M parameters) maps clauses into a 1,440-dimensional Belnap space and propagates support through passivity-balanced implicit Port-Hamiltonian rule diodes. Across 17,036 locked ProofWriter test queries, TE-BPHD reaches 79.17 +/- 5.48% depth-5 counterfactual consistency (+23.83 to +38.67 percentage points over Seq2Seq T5, Flan-T5, and Recurrent-Depth T5) and 94.95 +/- 1.23% out-of-distribution (OOD) accuracy across 5,270 six-domain queries (92.54 +/- 3.38% macro-mean). On a paired 120-query OOD slice, TE-BPHD attains 93.61 +/- 4.59% versus 79.17% for 3-shot Qwen3-1.7B under a 2,048-token reasoning cap (+14.44 percentage points) at 9.44 versus 14,878.4 ms/query batch-16 NVIDIA L4 throughput. Operator interventions show that symmetric single-rule passivity prevents positive two-cycle modes seen in Gain-Matched Unilateral Horn (+50.00 percentage points counterfactual consistency), whereas unit-interval Grounded Product-T-Norm Logic Tensor Networks (LTN) achieve cycle-safe OOD transfer (94.50 +/- 0.87%) without linear solves, and multi-fact ParaRules prose exposes an upstream grounding trade-off (1.33 +/- 1.76% zero-shot vs. 34.11 +/- 5.01% with five-slot optimal-transport joint grounding).

## DARSY: A Tool for Data-Driven Abstraction and Policy Synthesis for Stochastic Systems with Unknown Dynamics

DevFeed: [DARSY: A Tool for Data-Driven Abstraction and Policy Synthesis for Stochastic Systems with Unknown Dynamics](<https://devfeed.tech/articles/darsy-a-tool-for-data-driven-abstraction-and-policy-synthesis-for-stochastic-systems-with-unknown-dynamics-145562.md>)

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

Author: Thom Badings, Ibon Gracia, Mahdi Nazeri, Morteza Lahijanian, Alessandro Abate

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

Content type: article

Language: en

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

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [abstractions](<https://devfeed.tech/tags/abstractions.md>), [automated](<https://devfeed.tech/tags/automated.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [data-driven](<https://devfeed.tech/tags/data-driven.md>), [decision](<https://devfeed.tech/tags/decision.md>), [distributions](<https://devfeed.tech/tags/distributions.md>), [dynamic-programming](<https://devfeed.tech/tags/dynamic-programming.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [markov](<https://devfeed.tech/tags/markov.md>), [noise](<https://devfeed.tech/tags/noise.md>), [policy](<https://devfeed.tech/tags/policy.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>), [systems](<https://devfeed.tech/tags/systems.md>), [tool](<https://devfeed.tech/tags/tool.md>)

### AI overview

DARSY is a Python tool for verifying and synthesizing policies for discrete-time stochastic systems whose dynamics and noise distributions are unknown. It needs a system simulator and a Lipschitz bound on the dynamics. From sampled transitions, it builds a finite interval Markov decision process (IMDP), estimating probability intervals with statistical techniques and Lipschitz reasoning; robust dynamic programming then produces a policy and a lower bound on specification satisfaction probability at a user-chosen confidence. It supports Lipschitz-continuous dynamics and syntactically co-safe LTL specifications, including reach-avoid and finite-horizon safety. Its two-layer IMDP (2IMDP) also bounds transitions to aggregated state blocks; the abstract claims this reduces abstraction error and tightens satisfaction guarantees compared with standard IMDPs.

### Source excerpt

arXiv:2611.25654v1 Announce Type: cross Abstract: This paper presents DARSY: a software tool for abstraction-based verification and policy synthesis in discrete-time stochastic control systems with unknown dynamics and noise distributions. DARSY requires only a simulator of the system and a Lipschitz bound on its dynamics, and needs no knowledge of dynamics or noise distributions. The tool is fully automated and constructs a finite interval Markov decision process (IMDP) abstraction from sampled transitions, whose probability intervals are obtained via statistical techniques and Lipschitz reasoning. Robust dynamic programming on this IMDP then yields a policy together with a lower bound on the probability that the unknown system satisfies a desired specification. This lower bound holds with a user-specified confidence; that is, it is probably approximately correct (PAC). The tool is implemented in Python and supports general Lipschitz-continuous system dynamics and specifications expressed in syntactically co-safe LTL (scLTL), which includes reach-avoid and finite-horizon safety specifications as special cases. Beyond standard IMDPs, DARSY implements a two-layer IMDP (2IMDP) abstraction that also bounds the probability of transitioning to aggregated state blocks, yielding smaller abstraction errors than IMDP abstractions and, as a result, tighter satisfaction guarantees. We demonstrate DARSY's broad applicability across a variety of benchmarks and specifications.

## Rational Ensemble Logic for Cohort Discovery with Real-World Electrophysiology Data

DevFeed: [Rational Ensemble Logic for Cohort Discovery with Real-World Electrophysiology Data](<https://devfeed.tech/articles/rational-ensemble-logic-for-cohort-discovery-with-real-world-electrophysiology-data-142694.md>)

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

Author: Guo-Qiang Zhang, Xubing Hao, Yan Huang, Xiaojin Li, Licong Cui

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

Content type: article

Language: en

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

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [annotation](<https://devfeed.tech/tags/annotation.md>), [biomedical](<https://devfeed.tech/tags/biomedical.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [closure](<https://devfeed.tech/tags/closure.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [data](<https://devfeed.tech/tags/data.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [formal](<https://devfeed.tech/tags/formal.md>), [independent](<https://devfeed.tech/tags/independent.md>), [logic](<https://devfeed.tech/tags/logic.md>), [modal](<https://devfeed.tech/tags/modal.md>), [model](<https://devfeed.tech/tags/model.md>), [operations](<https://devfeed.tech/tags/operations.md>), [operators](<https://devfeed.tech/tags/operators.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [prototype](<https://devfeed.tech/tags/prototype.md>), [semantic](<https://devfeed.tech/tags/semantic.md>)

### AI overview

Rational Ensemble Logic (QEL) specifies temporal phenotypes in real-world electrophysiology data with semantics independent of implementation software. It combines three parameterized operators over rational time with Boolean connectives and first-order quantification; its Labeled Interval Ensemble semantics models annotated records as finite interval ensembles. The authors give endpoint-array model-checking algorithms, prove semantic correctness of interval operations, derive finite rational evidence sets by quantifier elimination, and establish polynomial data complexity for fixed formulas. A prototype matched assigned outcomes for base and strict post-ictal generalized EEG suppression queries on 54 manually constructed records. In a separate feasibility experiment, it found 37 qualifying patients and 45 annotation patterns among 1,976 patients in 16 seconds. The released prototype uses endpoint candidates and numerical tolerances.

### Source excerpt

arXiv:2611.23708v1 Announce Type: cross Abstract: Biomedical knowledge representation should make the passage from observations to conclusions transparent, rigorous, understandable, explainable, and reproducible (TRUER). We introduce Rational Ensemble Logic (QEL) for specifying temporal phenotypes in real-world electrophysiology data (RWED), with a meaning independent of the implementation software. QEL combines three parameterized modal operators (exact displacement, bounded existence, and bounded universality) over rational time with Boolean connectives and first-order quantification. Its Labeled Interval Ensemble (LINE) semantics represents annotated records as finite interval ensembles. We relate the operators to morphological operations and develop endpoint-array algorithms and finite rational evidence sets for model checking. We prove closure and semantic correctness of the interval operations, obtain finite evidence sets by quantifier elimination, and establish polynomial data complexity for fixed formulas. On 54 manually constructed records, a prototype agreed with the assigned outcomes for base and strict post-ictal generalized EEG suppression (PGES) queries. A separate feasibility experiment over 1,976 patients identified 37 qualifying patients and 45 annotation patterns in 16 seconds. The released prototype uses endpoint candidates and numerical tolerances. QEL supports the TRUER principle through explicit phenotype definitions, precise semantics, and provably correct evaluation procedures, with rational witnesses for existential queries. These provide a logical foundation for formal specification and correctness of algorithms that are independent of specific clinical interpretation, data annotation quality, and software implementation.

## MicroAssert: Microarchitecture-Aware Structured Assertion Generation for CPU Verification

DevFeed: [MicroAssert: Microarchitecture-Aware Structured Assertion Generation for CPU Verification](<https://devfeed.tech/articles/microassert-microarchitecture-aware-structured-assertion-generation-for-cpu-verification-142219.md>)

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

Author: Hongqin Lyu, Yonghao Wang, Zhiteng Chao, Wenxing Li, Tiancheng Wang, Evangeline F. Y. Young, Huawei Li

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

Content type: article

Language: en

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

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [assertions](<https://devfeed.tech/tags/assertions.md>), [automatic](<https://devfeed.tech/tags/automatic.md>), [behaviors](<https://devfeed.tech/tags/behaviors.md>), [branch](<https://devfeed.tech/tags/branch.md>), [capture](<https://devfeed.tech/tags/capture.md>), [complete](<https://devfeed.tech/tags/complete.md>), [completeness](<https://devfeed.tech/tags/completeness.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [core](<https://devfeed.tech/tags/core.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpus](<https://devfeed.tech/tags/cpus.md>), [cross](<https://devfeed.tech/tags/cross.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [detection](<https://devfeed.tech/tags/detection.md>), [generation](<https://devfeed.tech/tags/generation.md>), [microarchitecture](<https://devfeed.tech/tags/microarchitecture.md>), [structured](<https://devfeed.tech/tags/structured.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

MicroAssert identifies functional regions directly from RTL, then generates local and composite CPU assertions using structured contracts and deterministic verification primitives. Coverage-guided feedback progressively expands proof-relevant RTL coverage. Across five open-source RISC-V CPUs, it achieved 100% syntax correctness and complete branch, statement, and toggle coverage, with a 74.82% average proven rate and 90.96% Proof Core coverage. Mutation testing found an average error detection rate of 28.73%, reported as 1.99-3.51 times higher than three existing assertion-generation approaches.

### Source excerpt

arXiv:2611.24872v1 Announce Type: cross Abstract: Automatic assertion generation reduces manual verification effort, yet existing approaches struggle to capture microarchitectural behaviors and cross-region interactions in CPUs. We present MicroAssert, a microarchitecture-aware framework that identifies functional regions directly from RTL and generates local and composite assertions through structured contracts and deterministic verification primitives. Coverage-guided feedback further improves verification completeness by progressively expanding proof-relevant RTL coverage. Evaluated on five open-source RISC-V CPUs against three existing assertion generation approaches, MicroAssert achieves 100% syntax correctness and complete branch, statement, and toggle coverage, with an average proven rate of 74.82% and Proof Core coverage of 90.96%. Mutation testing further demonstrates its advantage, achieving an average error detection rate of 28.73%, 1.99 to 3.51 times higher than existing methods. These results demonstrate the effectiveness of microarchitecture-aware assertion generation.

## 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

## RustMC: Automated Verification of Real-World Concurrent Rust

DevFeed: [RustMC: Automated Verification of Real-World Concurrent Rust](<https://devfeed.tech/articles/rustmc-automated-verification-of-real-world-concurrent-rust-141437.md>)

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

Author: Oliver Pearce, Julien Lange, Dan O'Keeffe

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

Content type: article

Language: en

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

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

Tags: [atomic](<https://devfeed.tech/tags/atomic.md>), [automated](<https://devfeed.tech/tags/automated.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [c-c-plus-plus](<https://devfeed.tech/tags/c-c-plus-plus.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-bugs](<https://devfeed.tech/tags/concurrency-bugs.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [ffi](<https://devfeed.tech/tags/ffi.md>), [loom](<https://devfeed.tech/tags/loom.md>), [model](<https://devfeed.tech/tags/model.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [rust](<https://devfeed.tech/tags/rust.md>), [stateless](<https://devfeed.tech/tags/stateless.md>), [unmodified](<https://devfeed.tech/tags/unmodified.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

RustMC is a stateless model checker designed to verify unmodified concurrent Rust programs. It builds on GenMC's LLVM IR framework, which also lets it cover foreign-function dependencies written in C or C++. The paper identifies Rust-specific implementation challenges: intercepting threading operations, promoting memory intrinsics, and handling uninitialised accesses. Case studies adapted from real-world programs report concurrency bugs in unsafe Rust, FFI calls, and atomic operations. The evaluation uses the Loom model checker test suite and production-level Rust concurrent data structures; the supplied abstract does not report detailed results.

### Source excerpt

arXiv:2502.06293v2 Announce Type: replace-cross Abstract: RustMC is a stateless model checker that targets push-button verification of unmodified concurrent Rust programs. As both Rust and C/C++ compile to LLVM IR, RustMC builds on GenMC which provides a verification framework for LLVM IR. This allows verification of Rust code and any foreign function dependencies. In this tool paper we present key implementation challenges, use-cases, and an empirical evaluation of RustMC. The challenges include intercepting threading operations, promoting memory intrinsics, and handling uninitialised accesses, all stemming from Rust's unique compilation strategy. Case studies adapted from real-world programs show RustMC finds concurrency bugs in unsafe Rust code, FFI calls to C/C++, and atomic operations. We evaluate our tool's functionality on the Loom model checker test suite and a set of production-level Rust concurrent data structures.

## 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.

## FinVerify: A Verification Framework for Financial Agents

DevFeed: [FinVerify: A Verification Framework for Financial Agents](<https://devfeed.tech/articles/finverify-a-verification-framework-for-financial-agents-137571.md>)

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

Author: Mao Guan, Qian Chen, Ge Meng, Xiao-Yang Liu

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

Content type: article

Language: en

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

Topics: [Finance](<https://devfeed.tech/topics/finance.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [agent-reliability](<https://devfeed.tech/tags/agent-reliability.md>), [agents](<https://devfeed.tech/tags/agents.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [financial](<https://devfeed.tech/tags/financial.md>), [framework](<https://devfeed.tech/tags/framework.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

FinVerify checks financial agents' numerical claims against evidence to catch errors that can persist even when calculations run correctly, including period mismatches, unsupported sources, incompatible units, and incorrect definitions. An LLM structures claims and evidence; deterministic validators check financial requirements, and Z3 tests consistency with grounded inputs when authoritative formulas are available. The system accepts claims only when applicable checks pass, rejects proven violations, and abstains when evidence is insufficient. Across five fixed-candidate benchmarks, accepted-claim precision rose from 56.4% for an LLM judge to 76.7% at 81.2% coverage on Agent Finance Reasoning; it reached 99.8% on XBRLFiling and 87.9% on FinanceBench-67, versus 69.7% for the judge. Gains were smaller on FinQA and TAT-QA, where authoritative evidence was limited. The results also expose trade-offs among correctness, false rejection, and abstention.

### Source excerpt

arXiv:2611.20423v1 Announce Type: new Abstract: Financial agents produce numerical claims that can be wrong even when their calculations execute correctly, due to mismatched reporting periods, unsupported sources, incompatible units, or incorrect financial definitions. We introduce FinVerify, an evidence-grounded framework for verifying financial agents' numerical claims. Based on an analysis of 190 incorrect trajectories from the Agent Finance Reasoning dataset, we define five error categories--temporal integrity, source fidelity, comparability, accounting integrity, and financial-model fidelity--and operationalize them as verification protocols. An LLM structures claims and supporting evidence, while deterministic validators check financial requirements; when authoritative formulas are available, Z3 checks consistency with grounded inputs. FinVerify accepts only if all applicable checks pass, rejects proven violations, and abstains when evidence is insufficient. We evaluate the framework against a Direct baseline and an LLM judge across five fixed-candidate benchmarks. On Agent Finance Reasoning, accepted-claim precision increases from 56.4% for the LLM judge to 76.7% at 81.2% coverage. On XBRLFiling, FinVerify achieves 99.8% accepted-claim precision and 97.0% decision accuracy; on FinanceBench-67, it reaches 87.9% accepted-claim precision versus 69.7% for the judge. Improvements are smaller on FinQA and TAT-QA, where authoritative evidence is limited. These results suggest that explicit, evidence-backed verification can improve financial-agent reliability while exposing trade-offs between correctness, false rejection, and abstention.

## 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.

## Small Harnesses, Default Checks, Limited Coverage: Bounded Model Checking in Practice

DevFeed: [Small Harnesses, Default Checks, Limited Coverage: Bounded Model Checking in Practice](<https://devfeed.tech/articles/small-harnesses-default-checks-limited-coverage-bounded-model-checking-in-practice-137986.md>)

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

Author: Kevin Kolyakov, Ricardo Calvo, James C. Davis, Paschal C. Amusuo

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

Content type: article

Language: en

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

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [ai](<https://devfeed.tech/tags/ai.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [automated](<https://devfeed.tech/tags/automated.md>), [automation](<https://devfeed.tech/tags/automation.md>), [bmc](<https://devfeed.tech/tags/bmc.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [c](<https://devfeed.tech/tags/c.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [environment](<https://devfeed.tech/tags/environment.md>), [errors](<https://devfeed.tech/tags/errors.md>), [execution](<https://devfeed.tech/tags/execution.md>), [function](<https://devfeed.tech/tags/function.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [model](<https://devfeed.tech/tags/model.md>), [small](<https://devfeed.tech/tags/small.md>)

### AI overview

An empirical study of bounded model checking in open-source C and Rust projects using CBMC and Kani finds diverse verification goals and generally small harnesses, alongside property-specification errors and frequent reliance on execution bounds and environment models. Most artifacts finish quickly and achieve high coverage within their stated scope, but repository-level coverage falls as project size grows. The findings motivate better property validation, harness generation, and ways to broaden verification.

### Source excerpt

arXiv:2611.19267v1 Announce Type: new Abstract: The growing use of AI to generate software and verification artifacts has increased the need for automated systems that provide reliable software assurance. Bounded model checking (BMC) offers a practical foundation for such systems by automatically checking correctness and security properties directly on software. However, effective verification requires choices about properties, input assumptions, function models, and execution bounds that influence the guarantees obtained. Little systematic evidence exists on how practitioners make these choices, limiting the empirical foundation for developing automated verification systems. We present an empirical study of BMC practices in open-source C and Rust projects using CBMC and Kani. Through LLM-assisted open coding, static analysis, and artifact execution, we characterize verification properties, artifact complexity, and verification outcomes. Our findings reveal diverse verification objectives and generally small harnesses, but also property-specification errors and extensive use of execution bounds and environment models. Most artifacts complete verification quickly and achieve high coverage within their scope, while repository-level coverage decreases with project size. Our findings and annotated dataset provide empirical baselines for verification automation and motivate improved techniques for property validation, harness generation, and scaling verification breadth.

## 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.

## Flex: A Foundational Proof-Producing Horn Solver

DevFeed: [Flex: A Foundational Proof-Producing Horn Solver](<https://devfeed.tech/articles/flex-a-foundational-proof-producing-horn-solver-137928.md>)

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

Author: Jam Kabeer Ali Khan, Petros Markopoulos, Niki Vazou, Nico Lehmann, Ranjit Jhala

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

Content type: article

Language: en

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

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Computing](<https://devfeed.tech/topics/computing.md>), [Computer science](<https://devfeed.tech/topics/computer-science.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [faster](<https://devfeed.tech/tags/faster.md>), [flex](<https://devfeed.tech/tags/flex.md>), [hash](<https://devfeed.tech/tags/hash.md>), [invariants](<https://devfeed.tech/tags/invariants.md>), [lean](<https://devfeed.tech/tags/lean.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [ring](<https://devfeed.tech/tags/ring.md>), [rust](<https://devfeed.tech/tags/rust.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>), [trusted-computing](<https://devfeed.tech/tags/trusted-computing.md>), [typechecker](<https://devfeed.tech/tags/typechecker.md>)

### AI overview

Flex is a Lean metaprogram that synthesizes predicates for constrained Horn clauses (CHCs) and produces kernel-checked proofs. Its Zap tactic handles acyclic Horn variables by synthesizing strongest predicates and constructing elimination proofs without proof search. Fix uses predicate abstraction over templates built from Lean terms to infer inductive invariants for cyclic variables. A certifying pipeline uses external SMT solvers such as Spacer and Eldarica while keeping them outside the trusted computing base. The authors report verification of sorting algorithms, hash tables, Tock OS ring buffers, and Rust standard-library challenges. In their evaluation, Zap constructs elimination proofs 28.2x faster than grind and 44.6x faster than aesop, and Zap with Fix automatically proves 98.0% of the refinement-typechecker CHCs.

### Source excerpt

arXiv:2607.12226v2 Announce Type: replace-cross Abstract: Constrained Horn Clauses (CHCs) are a versatile intermediate representation for program verification, but leading CHC solvers rely on SMT-based reasoning over supported background theories. Specifications involving user-defined recursive functions or bespoke operators can require additional semantic encodings and reasoning beyond these theories. We observe that CHCs are existentially quantified propositions in a foundational logic, and so can be proved within an interactive theorem prover, where specifications can use native definitions, and users can complete proofs when automation stalls. However, in a foundational setting, every Horn variable solution must be justified by a kernel-checked proof. We present Flex, a proof-producing CHC solver implemented as a Lean metaprogram, that combines predicate synthesis with proof construction. Flex comprises a suite of tactics: Zap, which synthesizes strongest predicates for acyclic Horn variables and exploits their structure to construct elimination proofs without any proof search; Fix, which uses predicate abstraction over templates built from arbitrary Lean terms, discovered by scraping the CHCs and associated definitions, to infer inductive invariants for cyclic Horn variables; and a certifying pipeline that keeps external SMT-based solvers like Spacer and Eldarica outside the trusted computing base. We use Flex to verify the functional correctness of sorting algorithms, hash tables, ring buffers from the Tock OS kernel, and Rust std library challenges. We show that Zap constructs elimination proofs 28.2x and 44.6x faster than grind and aesop, respectively. With Zap and Fix, Flex automatically proves 98.0% of the refinement-typechecker CHCs in our evaluation.

## 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.

## Guiding AI Agents to Generate Conjectures by Encoding How Theorems Build on One Another

DevFeed: [Guiding AI Agents to Generate Conjectures by Encoding How Theorems Build on One Another](<https://devfeed.tech/articles/guiding-ai-agents-to-generate-conjectures-by-encoding-how-theorems-build-on-one-another-137393.md>)

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

Author: Hita Kambhamettu, Daniel Krashen, Lyle Ungar

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

Content type: article

Language: en

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

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [generate](<https://devfeed.tech/tags/generate.md>), [graph](<https://devfeed.tech/tags/graph.md>), [research](<https://devfeed.tech/tags/research.md>), [search](<https://devfeed.tech/tags/search.md>)

### AI overview

The method guides LLM agents to generate mathematical conjectures by building a Theorem Evolution Graph (TEG), which records how theorems modify earlier results, strengthen conclusions, or extend their scope. Agents find relevant theorems by tracing citations backward and forward from a seed paper, then compare them to encode those relationships. In the reported evaluation, LLM judges and an expert mathematician preferred TEG-generated conjectures over an unconstrained baseline; judges favored the TEG outputs for significance, ambition, and insight, while favoring baseline outputs for plausibility. Ablations suggest the graph's construction and use helped even when the available papers were fixed.

### Source excerpt

arXiv:2611.19108v1 Announce Type: new Abstract: Recently, LLMs have been making headlines, and headway, in mathematical research. Much of this work focuses on proving existing open conjectures. Deciding what to prove is harder and less studied, because of the lack of a clear criterion for what makes a conjecture worth pursuing. We present a method for conjecture generation that builds on the observation that mathematical theorems build on one another: new theorems can modify the setting or hypotheses of earlier theorems, strengthen their conclusions, or extend their scope. We encode these relationships in a new kind of graph, the Theorem Evolution Graph (TEG), which we instantiate as an online search method for LLM agents. An agent builds a TEG in two steps: (1) identifying relevant theorems from papers found by following citations backward and forward from a seed paper; and (2) comparing those theorems to record how one builds on another. LLM judges and an expert mathematician preferred TEG-generated conjectures over those from an unconstrained baseline. LLM judges favored TEG conjectures for significance, ambition, and insight, and favored baseline conjectures for plausibility. Ablations suggest a benefit from constructing and using a TEG even when the available papers are fixed.

## Agent-Guided Process Verification for Mathematical Self-Correction

DevFeed: [Agent-Guided Process Verification for Mathematical Self-Correction](<https://devfeed.tech/articles/agent-guided-process-verification-for-mathematical-self-correction-137401.md>)

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

Author: Rui Zou, Mengqi Wei, Xin Zhao, Ji-Rong Wen

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

Content type: article

Language: en

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

Topics: [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [completeness](<https://devfeed.tech/tags/completeness.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [diagnosis](<https://devfeed.tech/tags/diagnosis.md>), [error](<https://devfeed.tech/tags/error.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [mathematical-reasoning](<https://devfeed.tech/tags/mathematical-reasoning.md>), [repair](<https://devfeed.tech/tags/repair.md>), [sequence](<https://devfeed.tech/tags/sequence.md>), [solution](<https://devfeed.tech/tags/solution.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Agent-Guided Process Verification (AGPV) checks a mathematical solution by breaking it into ordered key claims, verifying each with a shared toolbox, and stopping at the first detected error. A summarization agent turns the failure evidence into a diagnosis for a correction agent to re-derive the remaining solution; later verification adapts to the revision and also checks completeness. The authors prove correctness and completeness if the claims cover the solution, local verification is reliable, and every claim passes. Across five challenging datasets and four DeepSeek, Qwen, and GPT models, AGPV reports 63.8% average accuracy, 13.5 percentage points above the strongest evaluated representative baseline, and higher repair coverage than programmatic-verification baselines.

### Source excerpt

arXiv:2611.19122v1 Announce Type: new Abstract: Large language models have made substantial progress in mathematical reasoning, yet in complex multi-step reasoning, an error at any step may propagate along an incorrect path, and the resulting solution may omit necessary branches. Existing natural-language reflection methods often struggle to locate critical errors precisely, while outcome verification typically checks only whether the available candidate answers satisfy the problem conditions and can therefore overlook necessary branches. To address these limitations, we propose Agent-Guided Process Verification (AGPV) for mathematical self-correction. AGPV decomposes the current solution into an ordered sequence of key claims, verifies them individually while invoking a shared mathematical toolbox when needed, and stops upon detecting the first error. A summarization agent converts the failure evidence into a diagnosis that guides a correction agent to re-derive the subsequent solution from that point; AGPV then adapts the next verification iteration to the revised solution. AGPV also verifies solution completeness. We further prove that AGPV guarantees solution correctness and completeness when key claims provide sufficient coverage and local verification is reliable, provided that all key claims pass verification. The implementation compresses long working contexts and reuses successful tool results within each problem. We evaluate AGPV on five challenging mathematical reasoning datasets with four models from DeepSeek, Qwen, and GPT. AGPV achieves an average accuracy of 63.8%, outperforming the strongest among the representative baselines evaluated (50.3%) by 13.5 percentage points, with higher repair coverage than the programmatic-verification baselines.

## Hybrid Mechanical and Agentic Specification Inference

DevFeed: [Hybrid Mechanical and Agentic Specification Inference](<https://devfeed.tech/articles/hybrid-mechanical-and-agentic-specification-inference-134981.md>)

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

Author: Wolfgang Grieskamp, Teng Zhang, Vineeth Kashyap

Published: 2026-11-16T05: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: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [smart contract](<https://devfeed.tech/topics/smart-contract.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [inference](<https://devfeed.tech/tags/inference.md>), [specification](<https://devfeed.tech/tags/specification.md>)

### AI overview

The paper combines LLM-driven specification inference with weakest-precondition (WP) analysis in the Move Prover, a verifier for the Move smart contract language. The agent derives specifications from code and uses a tool that calls the prover to infer and verify contracts, including mechanical contracts needed to prove higher-level properties. In an evaluation of 26 targets--24 drawn from Aptos framework functions without specifications--the agent completed over 90% of runs with or without WP, using Sol 5.6 and Terra 5.6. Adding WP reduced cost by 11-21% overall and 40-64% on targets without loops. The evidence describes this evaluation, not broader performance across languages or programs.

### Source excerpt

arXiv:2605.10005v3 Announce Type: replace-cross Abstract: Adoption of formal verification has long been hindered by the cost of manual specification. To prove high-level properties, one must also write contracts for supporting functions, many of which are mechanical and low-level. Specification inference automatically derives such contracts from the program. We present a hybrid of mechanical and agentic inference for Move, a smart contract language, integrated into its verifier, the Move Prover. A large language model (LLM) agent drives inference and verification through a tool that calls the Move Prover and derives specifications from code by weakest-precondition (WP) analysis. We evaluate our approach on 26 targets, 24 of them extracted from public Move functions of the Aptos framework that have no specifications, under a frontier model and a mid-tier model of the same family (Sol 5.6 and Terra 5.6). With and without WP, the agent completes over 90% of its runs, so agentic inference is effective on its own. Adding WP lowers its cost by 11-21% overall and by 40-64% on targets without loops.

## Advancing science & engineering with Antigravity's /teamwork

DevFeed: [Advancing science & engineering with Antigravity's /teamwork](<https://devfeed.tech/articles/advancing-science-engineering-with-antigravity-s-teamwork-134088.md>)

Original publisher: [Read original article](<https://research.google/blog/advancing-science-engineering-with-antigravitys-teamwork-feature/>)

Published: 2026-11-13T20:47:18Z

Content type: news

Language: en

Sources: [The latest research from Google](<https://devfeed.tech/sources/the-latest-research-from-google.md>)

Topics: [google-antigravity](<https://devfeed.tech/topics/google-antigravity.md>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Electrical engineering and computer science (EECS)](<https://devfeed.tech/topics/electrical-engineering-and-computer-science-eecs.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [antigravity](<https://devfeed.tech/tags/antigravity.md>), [education-innovation](<https://devfeed.tech/tags/education-innovation.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [general-science](<https://devfeed.tech/tags/general-science.md>), [machine-intelligence](<https://devfeed.tech/tags/machine-intelligence.md>), [natural-language-processing](<https://devfeed.tech/tags/natural-language-processing.md>), [science](<https://devfeed.tech/tags/science.md>), [teamwork](<https://devfeed.tech/tags/teamwork.md>)

### AI overview

Antigravity's /teamwork pairs specialized agents with independent checks to tackle research and engineering tasks over long horizons. Researchers set the questions and constraints; agents explore candidates, while tools such as Lean 4, test suites, simulators, and hardware counters verify results. The system limits context loss by giving agents task-specific files and tools and handing work to fresh agents for review. Reported applications include machine-checked proofs, molecular structure identification, kernel optimization, and large code rewrites. For example, a 30-agent chemistry workflow reached 95% top-1 accuracy on benchmark molecules; a Rust rewrite of libgav1 achieved bit-exact parity and, after profiling-led optimization, ran 20-30% faster than the original on x86_64 and ARM. Gemini 4 with /teamwork and /boost is available in Antigravity, Deep Review is also offered there, and the article says additional formal-proof workflows are forthcoming.

### Source excerpt

Education Innovation

## Batch, Pack, and Prove: More Efficient Verifiable Computation for CKKS

DevFeed: [Batch, Pack, and Prove: More Efficient Verifiable Computation for CKKS](<https://devfeed.tech/articles/batch-pack-and-prove-more-efficient-verifiable-computation-for-ckks-133335.md>)

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

Author: Ignacio Cascudo, Anamaria Costache, Daniele Cozzo, Dario Fiore, Antonio Guimar\\~aes, Eduardo Soria-Vazquez

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

Content type: article

Language: en

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

Topics: [homomorphic encryption](<https://devfeed.tech/topics/homomorphic-encryption.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [FHE](<https://devfeed.tech/topics/fhe.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [arguments](<https://devfeed.tech/tags/arguments.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [batch](<https://devfeed.tech/tags/batch.md>), [circuits](<https://devfeed.tech/tags/circuits.md>), [ckks](<https://devfeed.tech/tags/ckks.md>), [crypto](<https://devfeed.tech/tags/crypto.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [design](<https://devfeed.tech/tags/design.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [efficiently](<https://devfeed.tech/tags/efficiently.md>), [encrypted](<https://devfeed.tech/tags/encrypted.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [novel](<https://devfeed.tech/tags/novel.md>), [orders](<https://devfeed.tech/tags/orders.md>), [packing](<https://devfeed.tech/tags/packing.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [proofs](<https://devfeed.tech/tags/proofs.md>)

### AI overview

The paper targets scalability bottlenecks in verifiable computation for CKKS: large polynomial commitment proofs, an O(N) range-proof overhead, and no explicit sublinear verification method. It combines more efficient CKKS arithmetization with BatchFold, a polynomial commitment for R_q supporting batched evaluations and shorter proofs; packing, which avoids commitments to massive polynomials and removes the stated range-proof overhead; and SparsePack, for proving evaluations of sparse, circuit-dependent polynomials. On a generic neural network architecture, the authors report proofs several orders of magnitude smaller and faster than prior approaches. The supplied text gives no benchmark figures or further evaluation details.

### Source excerpt

arXiv:2611.16922v1 Announce Type: new Abstract: An important challenge in homomorphic encryption (HE) is ensuring the integrity of the encrypted computations. Although verifiable computation can address this in theory, making it practical is far from trivial. [Cascudo et al. CRYPTO 2025] recently proposed a solution to this problem for the CKKS scheme. In particular, they propose new succinct arguments that efficiently prove arithmetic circuits and range checks over the ring $R_q = \mathbb{Z}_q[Y]/(Y^N+1)$, and combine them to prove computations on CKKS ciphertexts. Despite the important progress, their work faces scalability challenges: the size of the polynomial commitment proofs, a large $O(N)$ overhead in range proofs, and the lack of an explicit method for efficient -- sublinear in circuit size -- verification. In this paper we present new techniques that remove all these bottlenecks. First, we provide a more efficient arithmetization of CKKS computations. Second, we introduce BatchFold, a new polynomial commitment for $R_q$ that supports batched evaluations and achieves shorter proofs. Third, we design packing, a novel algebraic technique that eliminates the need to commit to massive polynomials and removes the $O(N)$ overhead in range proofs. Finally, we introduce SparsePack, an efficient protocol for proving the evaluations of sparse, circuit-dependent polynomials, leveraging both packing and batched evaluations. We evaluate the efficiency of our solution on a generic neural network architecture, achieving proofs several orders of magnitude smaller and faster than prior approaches.

## 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.

## Solving Witness Triangle Puzzles Faster with an Automatically Learned Predicate

DevFeed: [Solving Witness Triangle Puzzles Faster with an Automatically Learned Predicate](<https://devfeed.tech/articles/solving-witness-triangle-puzzles-faster-with-an-automatically-learned-predicate-131835.md>)

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

Author: Justin Stevens, Vadim Bulitko, David Thue

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

Content type: article

Language: en

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

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [learning](<https://devfeed.tech/tags/learning.md>), [neural](<https://devfeed.tech/tags/neural.md>), [neural-networks](<https://devfeed.tech/tags/neural-networks.md>), [nodes](<https://devfeed.tech/tags/nodes.md>), [predicate](<https://devfeed.tech/tags/predicate.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [pruning](<https://devfeed.tech/tags/pruning.md>), [puzzles](<https://devfeed.tech/tags/puzzles.md>), [search](<https://devfeed.tech/tags/search.md>), [solution](<https://devfeed.tech/tags/solution.md>), [solve](<https://devfeed.tech/tags/solve.md>), [time](<https://devfeed.tech/tags/time.md>), [times](<https://devfeed.tech/tags/times.md>), [using](<https://devfeed.tech/tags/using.md>)

### AI overview

The paper accelerates search for The Witness triangle puzzles by automatically learning a human-explainable predicate that predicts whether a partial path can be completed. A proved property lets the solver use the predicate to prune successor states while preserving search completeness; the authors report about a sixfold speedup. Under fixed time budgets, the approach solves more and larger puzzles than a baseline with a hand-coded predicate, and empirically outperforms weighted A* and Levin tree search with neural networks in time and nodes expanded.

### Source excerpt

arXiv:2308.02666v2 Announce Type: replace Abstract: The Witness is a game with combinatorial puzzles that are challenging for both human players and AI solvers. Search-based AI solvers can require large amounts of time to solve such puzzles. We accelerate search by automatically learning a predicate that predicts whether a partial path to a Witness puzzle is completable to a solution path. We demonstrate that our learned predicate is human-explainable, which makes it amenable to proofs, and we prove a key property that allows us to use it for pruning successor states in search. Doing so accelerates search by about six times while maintaining search completeness. Conversely, given a fixed time budget per puzzle, our predicate-accelerated search can solve more puzzles of larger sizes than a baseline search using a hand-coded predicate. Finally, we empirically demonstrate how accelerating search using an automatically learned predicate can outperform two competitors, weighted A* and Levin tree search with neural networks, in terms of time and number of nodes expanded.

[Next page](<https://devfeed.tech/topics/automated-reasoning.md?cursor=WyIyMDI2LTExLTEzVDA1OjAwOjAwKzAwOjAwIiwgIjlkMjZlMWE4LTEwNGMtNDA5Yy05ZTExLTg2Mjg2M2Y5NzkzZSJd>)