# Lean

Lean is an open-source programming language and proof assistant for formally verified code.

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.

## Tether: Verified Stateful Policy Engine for System-Level Monitoring of Agents

DevFeed: [Tether: Verified Stateful Policy Engine for System-Level Monitoring of Agents](<https://devfeed.tech/articles/tether-verified-stateful-policy-engine-for-system-level-monitoring-of-agents-145548.md>)

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

Author: Meghana Aparna Sistla, Alaia Solko-Breslin, Somesh Jha, Aditya Kanade, Krishnamurthy Dj Dvijotham

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

Content type: article

Language: en

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

Topics: [policy-as-code](<https://devfeed.tech/topics/policy-as-code.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [rule-engine](<https://devfeed.tech/topics/rule-engine.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>)

Tags: [access-control](<https://devfeed.tech/tags/access-control.md>), [adversarial](<https://devfeed.tech/tags/adversarial.md>), [agents](<https://devfeed.tech/tags/agents.md>), [autonomous-ai-agents](<https://devfeed.tech/tags/autonomous-ai-agents.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [coding-agent-benchmarks](<https://devfeed.tech/tags/coding-agent-benchmarks.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [defense](<https://devfeed.tech/tags/defense.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [effects](<https://devfeed.tech/tags/effects.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [ephemeral](<https://devfeed.tech/tags/ephemeral.md>), [execution](<https://devfeed.tech/tags/execution.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [policy](<https://devfeed.tech/tags/policy.md>), [policy-engine](<https://devfeed.tech/tags/policy-engine.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [system](<https://devfeed.tech/tags/system.md>)

### AI overview

Tether checks agents' proposed actions by running each in an ephemeral isolated sandbox, inferring semantics from observed system calls, and enforcing stateful policies before allowing the action to proceed. Its policies are written in an embedded Lean 4 DSL for information flow, access control, and network security; formal verification can check global invariants such as blocking network access after a sensitive file is read. The abstract contrasts this with LLM monitors, which lack provable safety guarantees, and stateless enforcement, which can miss multi-step flows and side effects such as network calls inside scripts. On coding-agent benchmarks, one policy shared across tasks reportedly blocked 100% of in-scope attacks with a benign false-positive rate below 5%.

### Source excerpt

arXiv:2611.25599v1 Announce Type: cross Abstract: Autonomous AI agents are increasingly deployed for long-running tasks that execute arbitrary shell commands or programs. However, these actions can result in unauthorized network requests or persistent, malicious changes to the user's file system, processes, or privileges. Existing defense mechanisms rely on either LLM-based monitors, which lack provable safety guarantees, or stateless policy enforcement layers, which miss multi-step data flows and execution side-effects unmodeled by the policy language (e.g., network calls initiated inside a Python script). We introduce Tether, a framework for runtime enforcement of stateful security policies over the observed side-effects of an agent's actions. Tether executes each proposed action in an ephemeral, isolated sandbox, inferring abstract action semantics from observed system calls. Tether then enforces stateful policies over these inferred semantics, permitting actions to proceed only if they comply with the policy. Policies and action semantics are defined in an embedded DSL in Lean 4 capable of expressing diverse constraints, including information flow control (IFC), access control, and network security policies. Because actions can propagate labels from sources to destinations, a single rule can enforce fine-grained IFC policies across multi-step execution flows of arbitrary length. Expressing policies in Lean enables formal verification that they satisfy global security invariants (e.g., preventing network access after reading a sensitive file). We evaluate Tether on realistic coding-agent benchmarks across both benign and adversarial trajectories. With a single policy shared across all tasks, Tether blocks 100% of in-scope attacks while maintaining a benign false-positive rate under 5%.

## Triosecuris: Formally Verified Protection Against Speculative Control-Flow Hijacking

DevFeed: [Triosecuris: Formally Verified Protection Against Speculative Control-Flow Hijacking](<https://devfeed.tech/articles/triosecuris-formally-verified-protection-against-speculative-control-flow-hijacking-145995.md>)

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

Author: Jonathan Baumann, Yonghyun Kim, Yan Farba, Catalin Hritcu, Julay Leatherman-Brooks

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

Content type: article

Language: en

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

Topics: [Protection](<https://devfeed.tech/topics/protection.md>), [side channel](<https://devfeed.tech/topics/side-channel.md>), [Lean](<https://devfeed.tech/topics/lean.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [can](<https://devfeed.tech/tags/can.md>), [combines](<https://devfeed.tech/tags/combines.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [control](<https://devfeed.tech/tags/control.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [defense](<https://devfeed.tech/tags/defense.md>), [flag](<https://devfeed.tech/tags/flag.md>), [flow](<https://devfeed.tech/tags/flow.md>), [hardening](<https://devfeed.tech/tags/hardening.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [hijacking](<https://devfeed.tech/tags/hijacking.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [leaks](<https://devfeed.tech/tags/leaks.md>), [load](<https://devfeed.tech/tags/load.md>), [machine](<https://devfeed.tech/tags/machine.md>), [more](<https://devfeed.tech/tags/more.md>), [protection](<https://devfeed.tech/tags/protection.md>)

### AI overview

Triosecuris combines CET-style hardware-assisted control-flow integrity with compiler-inserted speculative load hardening to defend against Spectre BTB, RSB, and PHT. Its key mechanism uses CET-style protection to detect BTB misspeculation on indirect calls and RSB misspeculation on returns, then sets the SLH misspeculation flag. The authors formalize the transformation in Rocq and report a machine-checked proof of relative security: a transformed program running with speculation leaks no more than its source program does without speculation. They state that this guarantee applies to arbitrary programs, including those outside the cryptographic constant-time programming discipline.

### Source excerpt

arXiv:2601.22978v4 Announce Type: replace Abstract: This paper introduces Triosecuris, a formally verified defense against Spectre BTB, RSB, and PHT that combines CET-style hardware-assisted control-flow integrity with compiler-inserted speculative load hardening (SLH). Triosecuris is based on the novel observation that in the presence of CET-style protection, we can precisely detect BTB misspeculation for indirect calls and RSB misspeculation for returns and set the SLH misspeculation flag. We formalize Triosecuris as a transformation in Rocq and provide a machine-checked proof that it achieves relative security: any transformed program running with speculation leaks no more than what the source program leaks without speculation. This strong security guarantee applies to arbitrary programs, even those not following the cryptographic constant-time programming discipline.

## From Sorry to QED: Refining LLM Math Proofs via Angelic Execution

DevFeed: [From Sorry to QED: Refining LLM Math Proofs via Angelic Execution](<https://devfeed.tech/articles/from-sorry-to-qed-refining-llm-math-proofs-via-angelic-execution-139964.md>)

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

Author: Yanju Chen, Hanzhi Liu, Ruizhe Qian, Jiaming Shan, Xu Yang, Yufei Ding, Osbert Bastani, Yu Feng

Published: 2026-11-18T05: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>), [Lean](<https://devfeed.tech/topics/lean.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [algebra](<https://devfeed.tech/tags/algebra.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [data-flow](<https://devfeed.tech/tags/data-flow.md>), [execution](<https://devfeed.tech/tags/execution.md>), [framework](<https://devfeed.tech/tags/framework.md>), [graph](<https://devfeed.tech/tags/graph.md>), [interaction](<https://devfeed.tech/tags/interaction.md>), [llm](<https://devfeed.tech/tags/llm.md>), [math](<https://devfeed.tech/tags/math.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [symbolic-reasoning](<https://devfeed.tech/tags/symbolic-reasoning.md>)

### AI overview

MathEye turns imperfect LLM-generated Lean proofs into verified proofs by preserving the proof structure while replacing failing fragments with placeholders. It uses a proof dependence graph and MaxSAT optimization to identify a minimal-cost set of essential obligations, presents those in ordinary mathematical language for a mathematician to resolve, then reconstructs the proof automatically. On 30 benchmarks in analysis and algebra, the paper reports solving 93.3% of problems while reducing required user interactions by 55%.

### Source excerpt

arXiv:2611.22103v1 Announce Type: new Abstract: Large language models (LLMs) can now generate Lean proof scripts that capture the high-level structure of many mathematical arguments. However, these scripts frequently fail on complex theorems: a single missing side condition or misapplied lemma can cause the prover to abort early and discard an otherwise viable proof outline. This paper presents MathEye, a framework that converts imperfect LLM-generated proof scripts into fully verified Lean proofs by combining symbolic reasoning with minimal human interaction. At the core of MathEye is angelic proof checking, an optimistic execution model that replaces failing proof fragments with placeholders while preserving the overall structure of the argument. This optimistic check produces an angelic proof that isolates the exact proof obligations that the LLM fails to discharge. Because these unresolved obligations are often logically interdependent, asking a mathematician to address every placeholder directly is inefficient. To minimize human effort, MathEye performs residual analysis over a proof dependence graph that captures symbol-level data flow in the angelic proof. By formulating obligation selection as a MaxSAT optimization problem, MathEye selects a minimal-cost set of essential obligations whose resolution suffices to complete the entire proof. MathEye presents these essential obligations to the mathematician in ordinary mathematical language and uses the mathematician's answers to automatically reconstruct the complete Lean proof. Experiments on 30 real-world benchmarks across analysis and algebra show that MathEye solves 93.3% of the problems while reducing the number of required user interactions by 55%.

## A Temporal Algebraic Framework for Data Stream Evaluation Under Delayed Labels and Distribution Shifts

DevFeed: [A Temporal Algebraic Framework for Data Stream Evaluation Under Delayed Labels and Distribution Shifts](<https://devfeed.tech/articles/a-temporal-algebraic-framework-for-data-stream-evaluation-under-delayed-labels-and-distribution-shifts-139926.md>)

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

Author: Ronaldo C. Prati, Elaine Ribeiro de Faria

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

Content type: article

Language: en

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

Topics: [stream-processing](<https://devfeed.tech/topics/stream-processing.md>), [streaming data analytics](<https://devfeed.tech/topics/streaming-data-analytics.md>), [Lean](<https://devfeed.tech/topics/lean.md>)

Tags: [computer-science](<https://devfeed.tech/tags/computer-science.md>), [concept-drift](<https://devfeed.tech/tags/concept-drift.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [lean-4](<https://devfeed.tech/tags/lean-4.md>), [mask](<https://devfeed.tech/tags/mask.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [memory](<https://devfeed.tech/tags/memory.md>), [model](<https://devfeed.tech/tags/model.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [package](<https://devfeed.tech/tags/package.md>), [precision](<https://devfeed.tech/tags/precision.md>), [recall](<https://devfeed.tech/tags/recall.md>), [sliding-window](<https://devfeed.tech/tags/sliding-window.md>), [specificity](<https://devfeed.tech/tags/specificity.md>), [stream](<https://devfeed.tech/tags/stream.md>), [synthetic](<https://devfeed.tech/tags/synthetic.md>), [temporal](<https://devfeed.tech/tags/temporal.md>)

### AI overview

The framework extends confusion-matrix-based micro and macro evaluation to data streams using exponentially faded or sliding-window counts, with O(m²) updates per step. It handles delayed or selectively observed labels by temporarily counting instances through calibrated class probabilities; interim bias depends on calibration error, and classes without verified instances receive no value under audited conventions. To distinguish prevalence shifts from concept drift, it monitors recall and specificity and uses a first-order Jacobian decomposition to attribute metric changes. On synthetic streams and four real datasets, a detector using these prior-free coordinates and per-class memory produced no excess false alarms under label shift, unlike the Jacobian alarm and error-rate detectors. Delayed-label correction recovered recall in some real settings but only partially corrected precision, specificity, and F1. The abstract reports 25 statements checked in Lean 4 and code in the aggmetrics package.

### Source excerpt

arXiv:2611.21914v1 Announce Type: cross Abstract: In data streams, labels often arrive late or only for some instances, class prevalence drifts, and rare classes vanish from short windows. Standard evaluation then confuses a degraded decision boundary with a change in prevalence, and is biased when labels are delayed or selected by the model. We extend an algebraic framework that obtains pooled (micro) and per-class (macro) measures from one confusion matrix to streams, weighting the counts in time by exponential fading or a sliding window; the update costs O(m^2) per step, whatever the stream length, and each pooled measure stays a weighted combination of the per-class ones. Delayed and selective feedback enter as an observation mask: until its label arrives, an instance is counted with the model's calibrated class probabilities, and the bias of this interim estimate is driven by their calibration error. Audited conventions report no value for a class without verified instances. We separate prior shift from concept drift by monitoring prior-free coordinates (recall and specificity) and attribute a change in a measure to the two sources with a first-order Jacobian decomposition. On synthetic streams and four real datasets, a detector on these coordinates with a memory per class raises no excess false alarms under label shift, unlike the Jacobian alarm and error-rate detectors. The correction for delayed labels recovers recall in some real settings and is only partial for precision, specificity and F1. Twenty-five statements are checked in Lean 4, and the code is in the aggmetrics package.

## Formal Verification of the Signal Protocol Using AI

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

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

Author: Bruce Schneier

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

Content type: article

Language: en

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

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

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

### AI overview

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

### Source excerpt

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

## Type-Confusion Security

DevFeed: [Type-Confusion Security](<https://devfeed.tech/articles/type-confusion-security-139297.md>)

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

Author: Silei Ren, Hanxi Chen, Suraaj Kanniwadi, Andrew C. Myers

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

Content type: article

Language: en

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

Topics: [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [attack](<https://devfeed.tech/tags/attack.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [lean](<https://devfeed.tech/tags/lean.md>), [model-context-protocol](<https://devfeed.tech/tags/model-context-protocol.md>), [security](<https://devfeed.tech/tags/security.md>), [type](<https://devfeed.tech/tags/type.md>), [type-system](<https://devfeed.tech/tags/type-system.md>)

### AI overview

The paper defines type-confusion security as ensuring that attackers who ignore a type system gain no more power than attackers who obey it. It treats attacks such as confused deputies, reentrancy, and control-flow hijacking as instances of type confusion. In an information-flow-typed core calculus, the authors formalize the property as a real-ideal emulation and prove that runtime checks preserve the security guarantees of the type system even against ill-typed attackers. They mechanize the proof in Lean.

### Source excerpt

arXiv:2611.20298v1 Announce Type: cross Abstract: Type systems are a lightweight way to obtain formal assurance that code upholds security properties. However, decentralized systems, such as smart contracts and Model Context Protocol ecosystems, have limited ability to constrain the behavior of untrusted code. In such systems, attackers may attempt to confuse trusted code by supplying values that do not behave according to their advertised types, an attack that we call type confusion. Well-known attacks such as confused deputy attacks, reentrancy attacks, and control-flow hijacking can be understood as instances of type confusion. We define type confusion security as the property that unrestricted attackers who need not follow the type system have no more power than limited attackers who fully obey it. We formally define type confusion security as a real--ideal emulation, and in the context of an information-flow-typed core calculus that statically enforces security against well-typed attackers, prove that its run-time checks also enforce security against ill-typed attackers. In this system, programmers can write code while reasoning about security only against well-typed attackers; the security guarantees enforced by the type system still hold. We mechanize a proof of type confusion security in Lean.

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

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

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

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

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

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

Content type: article

Language: en

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

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

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

### AI overview

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

### Source excerpt

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

## ProofLoom: Proof-Obligation-Driven Theory Construction for Autoformalizing Research-Level Stochastic Optimization

DevFeed: [ProofLoom: Proof-Obligation-Driven Theory Construction for Autoformalizing Research-Level Stochastic Optimization](<https://devfeed.tech/articles/proofloom-proof-obligation-driven-theory-construction-for-autoformalizing-research-level-stochastic-optimization-137287.md>)

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

Author: Feiming Wang, Daibo Li, Kun Yuan

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

Content type: article

Language: en

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

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Operations research and optimization](<https://devfeed.tech/topics/operations-research-and-optimization.md>)

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [lean](<https://devfeed.tech/tags/lean.md>), [llm](<https://devfeed.tech/tags/llm.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [theory](<https://devfeed.tech/tags/theory.md>)

### AI overview

ProofLoom builds Lean models and supporting theory for stochastic optimization by using open proof obligations to guide definitions, interfaces, lemmas, and proof plans. Signature contracts track evidence and obligations when models change; an independent Judge rejects unsupported assumptions or weakened conclusions, while Planner expands source arguments and Audit checks whether formal proofs follow them. Its SOptLib stores verified results and construction records for reuse in later tasks. Across 15 tasks, mean human ratings were 6.3/7 and 6.4/7, versus 4.9/7 and 5.0/7 for the strongest of six baselines. Across 33 developments it produced 490,693 lines of algorithm-local Lean code without `sorry`; across 22 developments, checked formalizations exposed 28 source issues, including incorrect formulas, proof gaps, and analysis mismatches.

### Source excerpt

arXiv:2609.34960v2 Announce Type: replace Abstract: Formalizing research-level stochastic optimization in Lean requires both an algorithm model and domain theory connecting foundational libraries to convergence proofs. Revising a model to restore provability can change the mathematical claim. We introduce ProofLoom, a fully automated LLM-agent system for Proof-Obligation-Driven Theory Construction. Given a published algorithm, target theorem, and source proof, ProofLoom autonomously constructs the Lean model and supporting theory. Open proof obligations drive the development of definitions, interfaces, lemmas, and proof plans. Signature contracts record evidence and obligations for model revisions; an independent Judge rejects unsupported assumptions and weakened conclusions. Planner expands the published argument into intermediate claims, and Audit checks whether the Lean proof follows it. Across tasks, SOptLib accumulates verified mathematics and construction experience: reusable results are extracted, generalized, and verified, while modeling decisions and failed proof routes are recorded. Later tasks retrieve these results and records and contribute new developments, forming a cycle of construction, accumulation, and reuse. On fifteen textbook and research-paper tasks, ProofLoom obtains mean human ratings of 6.3/7 and 6.4/7, compared with 4.9/7 and 5.0/7 for the strongest of six baselines. Across 33 developments, it produces 490,693 lines of algorithm-local Lean code with no sorry. The formalizations also expose 28 incorrect formulas, proof gaps, and algorithm-analysis mismatches in published sources across 22 developments, each with checked evidence.

## From Pen-and-Paper to Machine-Checked Proofs: Lean for System Identification

DevFeed: [From Pen-and-Paper to Machine-Checked Proofs: Lean for System Identification](<https://devfeed.tech/articles/from-pen-and-paper-to-machine-checked-proofs-lean-for-system-identification-135176.md>)

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

Author: Manas Mejari, Dario Piga, Marco Forgione

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

Content type: article

Language: en

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

Topics: [Lean](<https://devfeed.tech/topics/lean.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [filter](<https://devfeed.tech/tags/filter.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [inference](<https://devfeed.tech/tags/inference.md>), [invariance](<https://devfeed.tech/tags/invariance.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [lean](<https://devfeed.tech/tags/lean.md>), [lean-4](<https://devfeed.tech/tags/lean-4.md>), [mathematical-proofs](<https://devfeed.tech/tags/mathematical-proofs.md>), [noise](<https://devfeed.tech/tags/noise.md>), [paper](<https://devfeed.tech/tags/paper.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

Lean 4 checks each inference in a formalized proof through a small trusted kernel, offering a way to scrutinize long chains of mathematical arguments. This introduction for system identification and control readers demonstrates how to read Lean proofs with examples on identifiability and set invariance, then formalizes Ljung's 1999 lemma on noise-filter inversion in prediction-error identification. The formalization exposes a qualification: the lemma's claim holds almost surely, not for every realization as its wording may suggest; the paper illustrates this with a counterexample. It also discusses guidelines and prospects for using Lean in system identification research.

### Source excerpt

arXiv:2611.18220v1 Announce Type: cross Abstract: Mathematical proofs in scientific papers are often long and intricate, relying on chains of references to earlier results. This makes it difficult for readers and reviewers to verify each and every step. Interactive theorem proving offers a complement: the theorem and its proof are written as code, and every inference is checked by a small, trusted piece of software called the kernel. This paper serves as an introduction to the Lean 4 proof assistant for a system identification and control audience, assuming no prior exposure to formal methods. We first show how a Lean proof is read using two elementary examples: the first on identifiability, the second on set invariance. We then illustrate how Lean can be used to analyse results from the literature, taking as example a classic lemma on the inversion of the noise filter in prediction-error identification (Ljung, 1999, Lemma 3.1). Since in Lean every step must be justified, the formalization brings to light a subtle point: the original claim of that lemma holds almost surely, although not for every realisation, as its statement may suggest. A simple counterexample makes this concrete. Finally, the paper discusses guidelines and perspectives on the use of Lean in system identification research.

## Proof automation in a language

DevFeed: [Proof automation in a language](<https://devfeed.tech/articles/proof-automation-in-a-language-135925.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2026/11/15/proofauto2.html>)

Author: Adam Langley

Published: 2026-11-15T00:00:00Z

Content type: article

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [design](<https://devfeed.tech/tags/design.md>), [functional](<https://devfeed.tech/tags/functional.md>), [language](<https://devfeed.tech/tags/language.md>), [local](<https://devfeed.tech/tags/local.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [python](<https://devfeed.tech/tags/python.md>), [quality](<https://devfeed.tech/tags/quality.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [software](<https://devfeed.tech/tags/software.md>), [tradeoffs](<https://devfeed.tech/tags/tradeoffs.md>)

### AI overview

The experimental language combines mutable value semantics, contracts, refinement types, and literate programming to make code easier to reason about and verify with proof automation. Its restricted references are intended to reduce aliasing complexity and enable translation to Lean without separation logic; contracts specify behavior such as strict DER tag parsing, so readers can rely on a function's guarantees without inspecting its body. Arithmetic overflow, casts, indices, invariants, postconditions, and termination generate verification conditions. Z3 and cvc5 propose results, but Lean checks proofs; an LLM can write manual Lean proofs when automation times out. The tradeoff is substantial compute: the DER example produces 149 conditions, checks run at roughly 10 lines per second, and rechecking medium programs can take hours. The compiler front end and LLVM translation remain trusted parts of the system.

### Source excerpt

As I wrote previously, we have proof automation now. Given that fact, I think a very timely question is: how can we use it to improve software quality? The same machines that can write these proofs can also write large amounts of code. So an adjacent question is: how can we use them to improve software understandability? It would be a mistake to start off afresh on those problems because there have been a lot of ideas in programming language design over the decades. The viability of ideas shifts as the underlying cost structures change, so things that didn't take off at the time might suddenly make a lot more sense. Still, language design involves a lot of tradeoffs, and features sometimes interact in surprising ways, so a lot of the work involves mixing some interesting-seeming ingredients together, baking, and asking "what is this? Is this a cake?". So I wanted to give a taste of some of the ingredients that I'm thinking about at the moment, and of the result. Ingredients Mutable Value Semantics Value semantics roughly says that you can't observe mutations to one variable through a different name. Value semantics are great for reasoning locally about code as, without them, you're constantly unsure what non-local effects might be happening. When you work in a language, you instinctively know when it's using value semantics and when it's using reference semantics. Take Python: x = [1] y = x y[0] = 2 print(x) You likely know that that prints [2]. (Although if you write the same program in C++ with std::vector it prints [1]! There's no cross-language norm for this.) Over the span of four lines of code, this is irrelevant. But as the scope of the sharing increases, so does the mental complexity. If you want to be able to jump into a bit of code and understand what it's doing, knowing that there is no such aliasing is a huge boon. Functional programming resolves this by eliminating mutation: if there's no mutation then you certainly can't observe mutations via a differe

## Typed Knowledge over Constructive Institutions: A Proof-Relevant Type Theory for Verified Science

DevFeed: [Typed Knowledge over Constructive Institutions: A Proof-Relevant Type Theory for Verified Science](<https://devfeed.tech/articles/typed-knowledge-over-constructive-institutions-a-proof-relevant-type-theory-for-verified-science-132096.md>)

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

Author: Hans-Martin Will

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

Content type: article

Language: en

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

Topics: [Math and Logic](<https://devfeed.tech/topics/math-and-logic.md>), [база знаний](<https://devfeed.tech/topics/tag-c51cc4bf76e5.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Coq](<https://devfeed.tech/topics/coq.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [axiom](<https://devfeed.tech/tags/axiom.md>), [build](<https://devfeed.tech/tags/build.md>), [class](<https://devfeed.tech/tags/class.md>), [compare](<https://devfeed.tech/tags/compare.md>), [complete](<https://devfeed.tech/tags/complete.md>), [compute](<https://devfeed.tech/tags/compute.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [conversion](<https://devfeed.tech/tags/conversion.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [derivations](<https://devfeed.tech/tags/derivations.md>), [equality](<https://devfeed.tech/tags/equality.md>), [institutions](<https://devfeed.tech/tags/institutions.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [over](<https://devfeed.tech/tags/over.md>), [science](<https://devfeed.tech/tags/science.md>), [theory](<https://devfeed.tech/tags/theory.md>), [type](<https://devfeed.tech/tags/type.md>), [type-theory](<https://devfeed.tech/tags/type-theory.md>)

### AI overview

Eigenius is presented as a verified scientific knowledge substrate that preserves which derivation supports a claim, enabling comparison of independent proofs and counterfactual retractions when an assay, reagent, or model is invalidated. Its dependent kernel makes proof irrelevance a witnessed propositional axiom rather than definitional equality, and combines universe cumulativity, function subtyping, and ontology inclusions in a coercion-free typing judgment. The framework also gives external verifiers explicit axiom policies, tracks justification provenance, and uses Cooper's Type Theory with Records to type open-world knowledge graphs. The authors report a consistency proof in Grothendieck universes and a Lean 4 mechanization with zero sorry axioms.

### Source excerpt

arXiv:2611.15108v1 Announce Type: cross Abstract: Mathematical proof assistants such as Coq, Agda, and Lean 4 build proof irrelevance into definitional conversion ($p \equiv q$ for $p, q : P$ with $P : Prop$), erasing which derivation established a theorem. While natural for mathematics over fixed axioms, judgmental proof irrelevance is incompatible with verified scientific stores, which must inspect and compare independent derivations of the same claim to assess consilience and compute counterfactual retractions when an assay, reagent, or model is invalidated. Moreover, combining definitional proof irrelevance with subsingleton elimination breaks strong normalization and renders algorithmic conversion non-transitive. We present the type-theoretic and institutional foundations of Eigenius, a verified knowledge substrate for science. First, we formulate a dependent kernel with cumulative universes ($Prop, Set, Type_k$), impredicative $Prop$, inductive families with index-forced subsingleton elimination, and intensional identity types, where definitional equality $\equiv$ is untyped joinability under an orthogonal CRS and proof irrelevance is a witnessed propositional axiom ($irrel : \Pi P{:}Prop.\,\Pi p,q{:}P.\,Id\,P\,p\,q$). Second, we unify universe cumulativity, codomain-covariant $\Pi$-subtyping, and ontology class inclusions in a coercion-free subsumption judgment whose bidirectional fragments ($\mathcal{K}_0, \mathcal{K}_1$) satisfy subject reduction and are sound and complete for declarative typing. Third, we organize external verifiers into a three-level institutional hierarchy with explicit axiom policies (Adopt, Discharge, Relativize), internalize a justification logic with Why-provenance semiring support $supp(j,P)$, and embed Cooper's Type Theory with Records (TTR) to type open-world knowledge graphs. Finally, we prove consistency in Grothendieck universes and mechanize the metatheory in Lean 4 with zero sorry axioms.

## Formal Conjectures: An Open and Evolving Benchmark for Verified Discovery in Mathematics

DevFeed: [Formal Conjectures: An Open and Evolving Benchmark for Verified Discovery in Mathematics](<https://devfeed.tech/articles/formal-conjectures-an-open-and-evolving-benchmark-for-verified-discovery-in-mathematics-131914.md>)

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

Author: Moritz Firsching, Paul Lezeau, Salvatore Mercuri, Mikl\\'os Z. Horv\\'ath, Ya\\"el Dillies, Calle S\\"onne, Eric Wieser, Fred Zhang, Thomas Hubert, Blaise Ag\\"uera y Arcas, Pushmeet Kohli

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

Content type: article

Language: en

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

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

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [automated-reasoning](<https://devfeed.tech/tags/automated-reasoning.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [formal](<https://devfeed.tech/tags/formal.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>)

### AI overview

Formal Conjectures is an evolving Lean 4 benchmark of 7,559 mathematical statements drawn from active research: 1,642 open conjectures for proof discovery, 2,923 solved problems for auto-formalization, and 2,994 supporting statements. Its repository connects mathematicians who formalize and clarify problems with people and AI systems attempting to solve them. The authors describe a collaborative process for checking formalizations, with AI-generated proofs and disproofs used to audit and improve fidelity. The benchmark has supported resolutions of open conjectures and formal confirmation of newly announced results. It also provides standardized evaluation and baseline results on frozen subsets to track research-level automated reasoning.

### Source excerpt

arXiv:2605.13171v2 Announce Type: replace Abstract: As automated reasoning systems advance rapidly, there is a growing need for research-level formal mathematical problems to accurately evaluate their capabilities. To address this, we present Formal Conjectures (https://github.com/google-deepmind/formal-conjectures), an evolving benchmark of currently 7559 mathematical problem statements formalized in Lean 4. Sourced from areas of active mathematical research, the dataset features 1642 open research conjectures without known solutions for mathematical proof discovery, 2923 solved problems for proof auto-formalization, and 2994 supporting statements. Notably, the repository provides a structured interface connecting mathematicians who formalize and clarify problems with the AI systems and humans attempting to solve them. Demonstrating its immediate utility, the benchmark has already been leveraged for new mathematical discoveries, including the resolution of open research conjectures, and for the formal confirmation of major newly announced results. We describe our approach to ensuring the correctness of these formalizations in a collaborative open-source project where contributions stem from an active community. In this framework, AI-generated proofs and disproofs serve as a valuable auditing mechanism to iteratively improve the fidelity of the benchmark. Finally, we provide a standardized evaluation setup and report baseline results on frozen evaluation subsets, demonstrating a climbable signal that measures the current frontier of automated reasoning on research-level mathematics.

## LEAP: Supercharging LLMs for Formal Mathematics with Agentic Frameworks

DevFeed: [LEAP: Supercharging LLMs for Formal Mathematics with Agentic Frameworks](<https://devfeed.tech/articles/leap-supercharging-llms-for-formal-mathematics-with-agentic-frameworks-131926.md>)

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

Author: Po-Nien Kung, Linfeng Song, Dawsen Hwang, Jinsung Yoon, Chun-Liang Li, Simone Severini, Mirek Ol\\v{s}\\'ak, Edward Lockhart, Quoc V Le, Burak Gokturk, Thang Luong, Tomas Pfister, Nanyun Peng

Published: 2026-11-13T05: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>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [graph theory](<https://devfeed.tech/topics/graph-theory.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [all](<https://devfeed.tech/tags/all.md>), [art](<https://devfeed.tech/tags/art.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [automated](<https://devfeed.tech/tags/automated.md>), [bench](<https://devfeed.tech/tags/bench.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [blueprints](<https://devfeed.tech/tags/blueprints.md>), [bridges](<https://devfeed.tech/tags/bridges.md>), [but](<https://devfeed.tech/tags/but.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [formal](<https://devfeed.tech/tags/formal.md>), [frameworks](<https://devfeed.tech/tags/frameworks.md>), [llms](<https://devfeed.tech/tags/llms.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

LEAP uses general-purpose foundation models to produce mechanically verifiable Lean proofs by breaking complex problems into smaller units, connecting formal proof construction with informal blueprints, and iteratively checking work with the Lean compiler. The abstract reports that it solves all 12 problems from the 2025 Putnam Competition and raises models' one-shot solve rate on the new Lean-IMO-Bench from below 10% to 70%, compared with a reported 48% for a specialized IMO system. It also reports a verified proof for a key subproblem in Knuth's Hamiltonian decomposition of even-order Cayley graphs.

### Source excerpt

arXiv:2606.03303v3 Announce Type: replace Abstract: Large Language Models (LLMs) exhibit strong informal mathematical reasoning but struggle to generate mechanically verifiable proofs in formal languages like Lean. We present LEAP, an agentic framework that enables general-purpose foundation models to achieve state-of-the-art performance on automated formal theorem proving. LEAP leverages foundation model capabilities, such as informal reasoning, instruction following, and iterative self-refinement. By decomposing complex problems into smaller units, the system bridges formal proof construction with informal blueprints through continuous interaction with the Lean compiler. To provide a rigorous evaluation beyond increasingly saturated benchmarks, we introduce Lean-IMO-Bench, a benchmark of IMO-style problems formalized in Lean, with short statements yet highly non-routine and multi-step proofs across a wide range of difficulty levels. Empirically, on the latest 2025 Putnam Competition, an annual mathematics competition for undergraduate students in North America, LEAP solves all 12 problems, matching recent breakthroughs by frontier formal mathematical models. On Lean-IMO-Bench, LEAP boosts the one-shot formal solve rate of general-purpose LLMs from below 10% to 70%, notably surpassing the 48% benchmark set by a specialized, gold-medal-caliber IMO system. Furthermore, we demonstrate LEAP's research-level utility by autonomously formalizing complex proofs for open combinatorial challenges, including a verified proof for a key subproblem in Knuth's Hamiltonian decomposition of even-order Cayley graphs.

## AutoAssumption: Searching over Assumptions Discovers ML-Systems Algorithms

DevFeed: [AutoAssumption: Searching over Assumptions Discovers ML-Systems Algorithms](<https://devfeed.tech/articles/autoassumption-searching-over-assumptions-discovers-ml-systems-algorithms-132056.md>)

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

Author: Igor Sadalski, Minghao Guo, Benjamin Jones, Wojciech Matusik

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: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [AI Models](<https://devfeed.tech/topics/ai-models.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [lean](<https://devfeed.tech/tags/lean.md>), [llama](<https://devfeed.tech/tags/llama.md>), [llm](<https://devfeed.tech/tags/llm.md>), [ml](<https://devfeed.tech/tags/ml.md>), [searching](<https://devfeed.tech/tags/searching.md>), [speculative-decoding](<https://devfeed.tech/tags/speculative-decoding.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

AutoAssumption searches for ML-systems algorithms by relaxing explicit assumptions in proof-based representations. It formalizes 89 algorithms across KV-cache eviction, weight pruning, and speculative decoding as proof graphs checked in Lean; the harness relaxes one assumption in a published method, re-derives and re-proves the algorithm, then generates code. In the reported KV-cache eviction and weight-pruning evaluations, it improved on every published algorithm tested: its eviction method had the highest RULER-4K score among those methods, and its pruning method the lowest perplexity among 13 methods on four LLaMA models. At equal budget, AutoAssumption scored within one point of OpenEvolve and had lower standard deviation across repeats. The abstract proposes formalizing more fields and combining them through shared assumptions.

### Source excerpt

arXiv:2611.14844v1 Announce Type: new Abstract: Many advances in ML systems came from breaking an assumption that earlier methods took for granted: speculative decoding dropped the assumption that a model needs one forward pass per token. Yet algorithms rarely state their assumptions, so experts and discovery harnesses search over programs, where one edit changes several design choices and gains are difficult to attribute. Searching over the assumptions themselves remains largely unexplored. Writing algorithms as proofs makes their assumptions explicit and turns algorithm design into a search over a small, structured space that an LLM can explore and a proof checker can audit. We formalize 89 algorithms from KV-cache eviction, weight pruning and speculative decoding as proof graphs with explicit assumptions, checked in Lean. Our harness, AutoAssumption, relaxes one assumption of a published method, re-derives and re-proves it, and generates its code. In KV-cache eviction and weight pruning, this search improved on every published algorithm we ran and produced state-of-the-art algorithms. The eviction algorithm has the highest RULER-4K score of the published methods we ran, and the pruning algorithm the lowest perplexity of thirteen on four LLaMA models. At equal budget, the harness scores within a point of OpenEvolve, an open-source implementation of AlphaEvolve, with a lower standard deviation across repeats. Future work will formalize more fields and combine them through the principal assumptions they share.

## A coordination framework for formal proof development with Kiro

DevFeed: [A coordination framework for formal proof development with Kiro](<https://devfeed.tech/articles/a-coordination-framework-for-formal-proof-development-with-kiro-131108.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/devops/a-coordination-framework-for-formal-proof-development-with-kiro/>)

Author: Haoyu Li

Published: 2026-11-12T18:31:29Z

Content type: article

Language: en

Sources: [AWS DevOps & Developer Productivity Blog](<https://devfeed.tech/sources/aws-devops-developer-productivity-blog.md>)

Topics: [Kiro](<https://devfeed.tech/topics/kiro.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [agent to agent communication](<https://devfeed.tech/topics/agent-to-agent-communication.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [codex](<https://devfeed.tech/topics/codex.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [formal](<https://devfeed.tech/tags/formal.md>), [foundational-100](<https://devfeed.tech/tags/foundational-100.md>), [framework](<https://devfeed.tech/tags/framework.md>), [harness](<https://devfeed.tech/tags/harness.md>), [imo](<https://devfeed.tech/tags/imo.md>), [kiro](<https://devfeed.tech/tags/kiro.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [maestro](<https://devfeed.tech/tags/maestro.md>), [thought-leadership](<https://devfeed.tech/tags/thought-leadership.md>)

### AI overview

MAESTRO, a prover harness in Kiro CLI, coordinates formal proof work through a shared evolving proof plan. Specialized agents tackle independent obligations and report checked lemmas, counterexamples, and partial results; a persistent coordinator uses that feedback to revise the proof structure, split difficult goals, and preserve useful work while retracting flawed lemmas and dependent steps. On the reported benchmarks, Kiro CLI with GPT and Claude models solved more hard problems than Codex and Claude Code with corresponding models. For six IMO 2026 problems, Kiro CLI completed all proofs in 1 hour 46 minutes; the text reports longer totals for Humanfia, Pramaana, and AxiomProver. Examples describe the coordinator correcting a faulty decomposition in a Quillen-Suslin proof and finding a direct construction for a matrix theorem that handles repeated singular values, unlike the paper's perturbation approach. These are reported results and examples; the text does not provide enough benchmark detail here to assess methodology or generalize beyond the tested settings.

### Source excerpt

MAESTRO is a prover harness in Kiro CLI that gives large language models a coordination framework for exploring, decomposing, and making structured progress on difficult proofs. It solves more hard theorems than Codex and Claude Code, including all six 2026 IMO problems in 1 hour 46 minutes.

## Compile-Gated Lean Proof Refactoring with Enterprise Agent Practices: A Model per Step under a US\\$3 Cap, Followed by Programmatic Rewrite Rules

DevFeed: [Compile-Gated Lean Proof Refactoring with Enterprise Agent Practices: A Model per Step under a US\\$3 Cap, Followed by Programmatic Rewrite Rules](<https://devfeed.tech/articles/compile-gated-lean-proof-refactoring-with-enterprise-agent-practices-a-model-per-step-under-a-us-3-cap-followed-by-programmatic-rewrite-rules-128235.md>)

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

Author: Bobber Cheng

Published: 2026-11-11T05: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: [Lean](<https://devfeed.tech/topics/lean.md>), [qualitygates](<https://devfeed.tech/topics/qualitygates.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [agent observability](<https://devfeed.tech/topics/agent-observability.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [model](<https://devfeed.tech/tags/model.md>), [practices](<https://devfeed.tech/tags/practices.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [rules](<https://devfeed.tech/tags/rules.md>)

### AI overview

The closed-track Lean proof refactoring entry scored 86.31 across 60 problems, ranking 8th at the deadline, for $166.33 total under a $3-per-problem cap; its mean cost was $2.772 per problem. The team selected models by measured cost effectiveness across nine models: GPT-6.1 Sol for early sessions and style rewrites, GPT-6.1 Terra for later sessions and the tail, and Gemini 4 Argon for review and repair. It converted lessons from development runs into compiler-checked rewrite rules, reporting +0.93 points from rules fixed before release and in-sample gains of +0.26 and +0.30 from later passes. Calls were recorded and reviewed before changes; all nine board scores were within -0.063 to +0.015 points of the team's meter predictions. The abstract says the full bill and spread across three runs are reported, but does not provide those run details.

### Source excerpt

arXiv:2611.13011v1 Announce Type: cross Abstract: Our closed-track entry (Arena username Vexorium-Agent) scored 86.31 points on the final board (L = 77.07, H = 81.86, Z = 100) over the 60 final problems, against 33.33 for the reference proofs, 8th at the deadline (top: 92.57), for US\$166.33 at list prices with every call counted (per problem: mean US\$2.772, at most US\$2.874; US\$3 cap). Three practices carry the entry. First, each paid stage runs the model that measured best per dollar for it among the 9 we tested in our own harness: GPT-6.1 Sol the early sessions, GPT-6.1 Terra the later ones and the tail at 70% of Sol's cost per turn, and Gemini 4 Argon the review and repair; Sol also runs the style rewrite. Second, what our development and research runs learned ships as compiler-checked programmatic rewrite rules rather than prompt text (+0.93 points from rules fixed before the release; +0.26 and +0.30, in sample, from passes built or switched on after the release). Third, every call is recorded and reviewed before each change (all 9 board scores came within -0.063 to +0.015 points of our meter's prediction). The harness, gate and many of these rules also serve our open-track entry. We report the full bill and the spread of three runs.

## Monads in Lean

DevFeed: [Monads in Lean](<https://devfeed.tech/articles/monads-in-lean-129771.md>)

Original publisher: [Read original article](<https://eli.thegreenplace.net/2026/monads-in-lean/>)

Author: Eli Bendersky

Published: 2026-11-11T03:25:00Z

Content type: article

Language: en

Sources: [Eli Bendersky](<https://devfeed.tech/sources/eli-bendersky.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [IO](<https://devfeed.tech/topics/io.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [OCaml](<https://devfeed.tech/topics/ocaml.md>)

Tags: [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [lean](<https://devfeed.tech/tags/lean.md>), [lean-4](<https://devfeed.tech/tags/lean-4.md>), [misc](<https://devfeed.tech/tags/misc.md>)

### AI overview

The post builds up Lean 4 monads through a sequence of expression evaluators. It starts with `Option` for propagating division-by-zero failure, then replaces nested matching with `bind` (`>>=`) and `do` notation. A generic evaluator works with either `Option` or `Except`. Further examples combine failure with logging in `LoggedOption`, carry variable assignments through a stateful evaluator, and use `OptionT IO` to combine failure with printing. The post explains `bind` as sequencing computations while encapsulating effects, and describes the left identity, right identity, and associativity laws; Lean's `LawfulMonad` class requires proofs of those laws, while `Monad` alone does not.

### Source excerpt

This post demonstrates how to use monads in the Lean programming language (Lean 4, to be specific). If you're not familiar with Lean, this part of the language is very similar to other functional programming languages, like Haskell or OCaml. Motivating example - evaluating expressions Suppose we want to write a ...

## Formalizing CPython

DevFeed: [Formalizing CPython](<https://devfeed.tech/articles/formalizing-cpython-127353.md>)

Original publisher: [Read original article](<https://blog.adafruit.com/2026/11/10/formalizing-cpython/>)

Author: Anne Barela

Published: 2026-11-10T20:13:02Z

Content type: news

Language: en

Sources: [Adafruit Industries](<https://devfeed.tech/sources/adafruit-industries-makers-hackers-artists-designers-and-engineers.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [bug-reports](<https://devfeed.tech/tags/bug-reports.md>), [c](<https://devfeed.tech/tags/c.md>), [cpython](<https://devfeed.tech/tags/cpython.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [functions](<https://devfeed.tech/tags/functions.md>), [interpreter](<https://devfeed.tech/tags/interpreter.md>), [lean](<https://devfeed.tech/tags/lean.md>), [memory](<https://devfeed.tech/tags/memory.md>), [programming](<https://devfeed.tech/tags/programming.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [python](<https://devfeed.tech/tags/python.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

AI agents have translated CPython internals into Lean, preserving C behavior such as integer wrapping. The project reports 613,318 lines across 1,539 files and 18,898 theorems and lemmas; 4,071 of 26,004 functions identified for checking are complete (about 15.7%). Each function is copied, tested against real Python, proved, then reviewed. Review asks whether a broken implementation could still pass the proof, after early agents produced correct but empty proofs for functions that always crash. Running proved statements against real Python also caught claims that were valid in Lean but inaccurate about Python. The project reports 418 bug reports against Python 3.15.2, each with a reproducing script; about 55 can crash the interpreter or corrupt memory through ordinary Python code.

### Source excerpt

A project posted at broyojo.com used AI agents to rewrite CPython's internals in Lean, a language where a computer can check mathematical proofs. The Lean copies follow the C source line by line, including how the C code's numbers wrap around when they get too big. So far that's 613,318 lines of Lean across 1,539 [...]

## Introducing AlphaProof Code: a breakthrough in verifying complex software at depth

DevFeed: [Introducing AlphaProof Code: a breakthrough in verifying complex software at depth](<https://devfeed.tech/articles/introducing-alphaproof-code-a-breakthrough-in-verifying-complex-software-at-depth-128945.md>)

Original publisher: [Read original article](<https://deepmind.google/blog/introducing-alphaproof-code/>)

Author: Pushmeet Kohli; Swarat Chaudhuri

Published: 2026-11-10T12:02:28Z

Content type: release

Language: en

Sources: [Google DeepMind News](<https://devfeed.tech/sources/google-deepmind-news.md>)

Topics: [Formal methods](<https://devfeed.tech/topics/formal-methods.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [after](<https://devfeed.tech/tags/after.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [apps](<https://devfeed.tech/tags/apps.md>), [automatically](<https://devfeed.tech/tags/automatically.md>), [banking](<https://devfeed.tech/tags/banking.md>), [breakthrough](<https://devfeed.tech/tags/breakthrough.md>), [bridging](<https://devfeed.tech/tags/bridging.md>), [code](<https://devfeed.tech/tags/code.md>), [complex](<https://devfeed.tech/tags/complex.md>), [core](<https://devfeed.tech/tags/core.md>), [lean](<https://devfeed.tech/tags/lean.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [research](<https://devfeed.tech/tags/research.md>), [signal](<https://devfeed.tech/tags/signal.md>), [software](<https://devfeed.tech/tags/software.md>), [verify](<https://devfeed.tech/tags/verify.md>)

### AI overview

Google DeepMind reports that AlphaProof Code formally verified key security properties of Signal's compiled cryptographic code, connecting protocol-level goals to the implementation running on devices. Human experts and a mix of models translated the goals into mathematical specifications, which experts reviewed; Gemini Carbon agents then generated Lean proofs, and agents audited them, flagging about one percent of the codebase for further human review. Lean machine-checked the proofs. The work took four weeks, and in tests with two previously fixed bugs reintroduced into an isolated code version, the system proved the buggy versions insecure. The account describes verification of specified key properties, not a guarantee that all possible flaws are absent.

### Source excerpt

AlphaProof Code agents wrote three million lines of proofs in Lean to verify Signal's core encryption.

## Extending DBLog-Based Incremental Snapshots to Handle Orphan Rows in CDC Pipelines

DevFeed: [Extending DBLog-Based Incremental Snapshots to Handle Orphan Rows in CDC Pipelines](<https://devfeed.tech/articles/extending-dblog-based-incremental-snapshots-to-handle-orphan-rows-in-cdc-pipelines-125666.md>)

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

Author: Andreas Andreakis

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

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Data pipelines](<https://devfeed.tech/topics/data-pipelines.md>), [Debezium Connector](<https://devfeed.tech/topics/debezium-connector.md>), [Lean](<https://devfeed.tech/topics/lean.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [after](<https://devfeed.tech/tags/after.md>), [also](<https://devfeed.tech/tags/also.md>), [applications](<https://devfeed.tech/tags/applications.md>), [apply](<https://devfeed.tech/tags/apply.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [bootstrap](<https://devfeed.tech/tags/bootstrap.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [capture](<https://devfeed.tech/tags/capture.md>), [cdc](<https://devfeed.tech/tags/cdc.md>), [change](<https://devfeed.tech/tags/change.md>), [change-data-capture](<https://devfeed.tech/tags/change-data-capture.md>), [changes](<https://devfeed.tech/tags/changes.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [handle](<https://devfeed.tech/tags/handle.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>)

### AI overview

The extension lets DBLog-based CDC snapshots repair orphan rows in an existing sink. During chunk reads, the connector can emit delete events for keys absent from the source range; alternatively, an external drift process can submit suspected orphans for the connector to check and delete only when confirmed absent. The system supports integrated cleanup on full or periodic chunk passes, externally requested repairs, or a combination of both, which the authors recommend. The abstract says the extension is formally verified for safety and convergence in Isabelle/HOL and Lean 4.

### Source excerpt

arXiv:2611.10810v1 Announce Type: new Abstract: Applications use heterogeneous datastores where a source feeds sinks such as search indexes or data warehouses via change data capture (CDC). As transaction logs have limited retention, CDC alone cannot bootstrap sinks, and traditional approaches either stall source writes or hold back log events. DBLog-based incremental snapshots, adopted by Debezium and Flink CDC, read tables in chunks interleaved with the log without blocking writes or long log stalls and resume where they stopped. After the initial bootstrap, a sink can drift when losing change events or receiving unintended writes. Even a repeated bootstrap can leave orphan rows that exist in the sink and not at the source. A common remedy is to populate a new empty sink, but repairing an existing sink avoids parallel pipelines, a switch and serving traffic from a drifted sink until the new sink is ready. In DBLog's original design, each chunk only emits the latest state of the rows the table still contains, so it does not handle orphan rows. We extend DBLog to delete them using what a chunk read already knows, namely the keys that the range select did not return, emitting a new kind of event that sinks apply as deletes. We also add a repair request that an external process calls with orphan candidates, which the connector checks with its own read, emitting these events for keys confirmed absent. This enables three modes. In the fully integrated mode, every chunk pass removes the orphans it finds during full or periodic repairs. In the second mode, an external drift process hands suspected orphans to the connector. The third mode combines both and is what we recommend. Together, they turn DBLog into a complete data synchronization engine whether a sink catches up on live changes or missing rows, holds wrong column values, or contains orphan rows. Their safety and convergence are formally verified in Isabelle/HOL and Lean 4.

## Statopia: A Prover--Library Ecosystem for Automated Formalization and Proof Discovery in Statistics

DevFeed: [Statopia: A Prover--Library Ecosystem for Automated Formalization and Proof Discovery in Statistics](<https://devfeed.tech/articles/statopia-a-prover-library-ecosystem-for-automated-formalization-and-proof-discovery-in-statistics-126072.md>)

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

Author: Ziyuan Chen, Tong Gan, Wei Zhang, Ruofei Fang, Boyue Tang, Zhenhua Lin, Fang Yao

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

Content type: article

Language: en

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

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Statistics](<https://devfeed.tech/topics/statistics.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [application](<https://devfeed.tech/tags/application.md>), [automated](<https://devfeed.tech/tags/automated.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [composition](<https://devfeed.tech/tags/composition.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [independent](<https://devfeed.tech/tags/independent.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [lean](<https://devfeed.tech/tags/lean.md>), [lean-4](<https://devfeed.tech/tags/lean-4.md>), [library](<https://devfeed.tech/tags/library.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [planning](<https://devfeed.tech/tags/planning.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>), [review](<https://devfeed.tech/tags/review.md>), [stat-co](<https://devfeed.tech/tags/stat-co.md>), [statistics](<https://devfeed.tech/tags/statistics.md>)

### AI overview

Statopia pairs an independent Lean 4 prover for statistics and machine learning with Statlib, a library organized for agent retrieval and theorem composition. The prover can check existing arguments or discover a machine-checked proof from a statement alone; a natural-language proof may guide the search but is not required. Its workflow combines source preparation, statement review, library-supported planning, and proof construction. Dynamic dependency graphs and task groups support parallel, resumable work. Verified results and prover feedback inform reviewed Statlib updates. A cross-platform app supports uploading source files and running tasks locally or in the cloud.

### Source excerpt

arXiv:2611.11110v1 Announce Type: cross Abstract: Theoretical results in statistics and machine learning rest on long, technically delicate proofs, and fluent arguments generated by large language models are not necessarily correct. Automated formalization makes such arguments mechanically checkable, and automated proving goes further by discovering machine-checked proofs for statements whose proofs are incomplete or missing altogether. Both require reconstructing assumptions from source materials, accessing specialized mathematical infrastructure and managing long proof developments. We present Statopia, an ecosystem that jointly develops Statopia Prover, an independent agent specialized for formalizing and proving results in statistics and machine learning, and Statlib, a Lean~4 library built with the prover and organized for automated use. The prover controls its own execution without relying on external coding agents. It is built for formal proof discovery and checking existing proofs. A natural-language proof, when available, guides its search but is not required: from a statement alone, the prover develops the argument itself and constructs a Lean proof. Its workflow integrates source preparation, statement review, library supported planning and proof construction. Dynamic proof dependency graphs and task groups support parallel, resumable proof development. Statlib's shared definitions and theorem interfaces are organized for retrieval and composition by agents, and its coverage of statistics keeps expanding. Verified results and usage feedback from the prover inform reviewed library updates, so that proof development drives this expansion. A cross-platform application provides an interactive workspace for uploading source files and running tasks locally or in the cloud.

[Next page](<https://devfeed.tech/topics/lean.md?cursor=WyIyMDI2LTExLTEwVDA1OjAwOjAwKzAwOjAwIiwgImI3ODUxMzc3LTE3M2MtNDVlMS1iMjc2LTFiNTBlZDRlNGQ1NSJd>)